Table of Contents

• 1. Introduction
• 2. Conformance
• 3. Terminology
• 4. Security and privacy considerations
• 5. Navigator Interface
  • 5.1 Attributes
• 6. UDPPermission Interface
  • 6.1 Methods
• 7. TCPPermission Interface
  • 7.1 Methods
• 8. TCPServerPermission Interface
  • 8.1 Methods
• 9. Interface UDPSocket
  • 9.1 Attributes
  • 9.2 Methods
• 10. Interface TCPSocket
  • 10.1 Attributes
  • 10.2 Methods
• 11. Interface TCPServerSocket
  • 11.1 Attributes
  • 11.2 Methods
• 12. Dictionary UDPMessage
  • 12.1 Dictionary UDPMessage Members
• 13. Dictionary UDPOptions
  • 13.1 Dictionary UDPOptions Members
• 14. Dictionary TCPOptions
  • 14.1 Dictionary TCPOptions Members
• 15. Dictionary TCPServerOptions
  • 15.1 Dictionary TCPServerOptions Members
• 16. Dictionary UDPPermissionOptions
  • 16.1 Dictionary UDPPermissionOptions Members
• 17. Dictionary TCPPermissionOptions
  • 17.1 Dictionary TCPPermissionOptions Members
• 18. Dictionary TCPServerPermissionOptions
  • 18.1 Dictionary TCPServerPermissionOptions Members
• 19. Enums
  • 19.1 TCPUDPPermissionState
  • 19.2 SocketReadyState
  • 19.3 TCPKeepAliveOptions
• A. Acknowledgements
• B. References
  • B.1 Normative references

2. Conformance

As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.

The key word MUST is to be interpreted as described in [RFC2119].

This specification defines conformance criteria that apply to a single product: the user agent that implements the interfaces that it contains.

Implementations that use ECMAScript to implement the APIs defined in this specification MUST implement them in a manner consistent with the ECMAScript Bindings defined in the Web IDL specification [WEBIDL], as this specification uses that specification and terminology.

3. Terminology

The term webapp refers to a Web application, i.e. an application implemented using Web technologies, and executing within the context of a Web user agent, e.g. a Web browser or other Web runtime environment.

The Promise interface provides asynchronous access to the result of an operation that is ongoing, has yet to start, or has completed, as defined in [ES6].

4. Security and privacy considerations

This is a security and privacy sensitive API and a webapp must have permission to use the API. The manner in which permission is given or not varies depending on the type of web runtime environment in which this API is implemented and could be based on:

• Consent through user interaction.
• Previously granted or denied permission explicitly for this webapp.
• Explicit trust for the requesting webapp based on the security system of the web runtime this API is implemented in.
• A combination of above.

The UDPPermission, TCPPermission and TCPServerPermission interfaces provides a method hasPermission that retrieves the permission state for the requesting webapp and a method requestPermission that requests permission for the webapp to use the socket interface. If a webapp calls the contructor of a socket interface for which it has not permission to access the user agent MUST immediately throw DOMException "SecurityError".

5. Navigator Interface

partial interface Navigator {
    readonly    attribute UDPPermission       udpPermission;
    readonly    attribute TCPPermission       tcpPermission;
    readonly    attribute TCPServerPermission tcpServerPermission;
};

6. UDPPermission Interface

This interface exposes methods related to the permission to access the UDPSocket interface. Permission could be given based on user consent, based on trust for the webapp, e.g. related to the origin of it and verified through web security mechanisms such as secure transport and signatures, based on previously granted or denied permission explicitly for this webapp or a combination of these mechanisms.

interface UDPPermission {
    Promise<TCPUDPPermissionState> hasPermission (optional UDPPermissionOptions udpPermissionOptions);
    Promise<void>                  requestPermission (optional UDPPermissionOptions udpPermissionOptions);
};

7. TCPPermission Interface

This interface exposes methods related to the permission to access the TCPSocket interface. Permission could be given based on user consent, based on trust for the webapp, e.g. related to the origin of it and verified through web security mechanisms such as secure transport and signatures, based on previously granted or denied permission explicitly for this webapp or a combination of these mechanisms.

interface TCPPermission {
    Promise<TCPUDPPermissionState> hasPermission (optional TCPPermissionOptions tcpPermissionOptions);
    Promise<void>                  requestPermission (optional TCPPermissionOptions tcpPermissionOptions);
};

8. TCPServerPermission Interface

This interface exposes methods related to the permission to access the TCPServerSocket interface. Permission could be given based on user consent, based on trust for the webapp, e.g. related to the origin of it and verified through web security mechanisms such as secure transport and signatures, based on previously granted or denied permission explicitly for this webapp or a combination of these mechanisms.

interface TCPServerPermission {
    Promise<TCPUDPPermissionState> hasPermission (optional TCPServerPermissionOptions tcpServerPermissionOptions);
    Promise<void>                  requestPermission (optional TCPServerPermissionOptions tcpServerPermissionOptions);
};

9. Interface UDPSocket

The UDPSocket interface defines attributes and methods for UDP communication

//
// This example shows a simple implementation of UPnP-SSDP M-SEARCH
// discovery using a multicast UDPSocket
//

var address = '239.255.255.250',
    port = '1900',
    serviceType = 'upnp:rootdevice',
    rn = '\r\n',
    search = '';

//  Request permission to send multicast messages to the address and
//  port reserved for SSDP
navigator.udpPermission.requestPermission({remoteAddress:"239.255.255.250",
                                           remotePort:1900}).then(
  () => {
    // Permission was granted

    //  Create a new UDP client socket
    var mySocket = new UDPSocket();

    // Build an SSDP M-SEARCH multicast message
    search += 'M-SEARCH * HTTP/1.1' + rn;
    search += 'ST: ' + serviceType + rn;
    search += 'MAN: "ssdp:discover"' + rn;
    search += 'HOST: ' + address + ':' + port + rn;
    search += 'MX: 10';


    // Receive and log SSDP M-SEARCH response messages
    function receiveMSearchResponses() {
      mySocket.readable.getReader().read().then(({ value, done }) => {
        if (done) return;

        console.log('Remote address: ' + value.remoteAddress +
                    'Remote port: ' + value.remotePort +
                    'Message: ' + ab2str(value.data));
        // ArrayBuffer to string conversion could also be done by piping
        // through a transform stream. To be updated when the Streams API
        // specification has been stabilized on this point.
      });
    }

    // Join SSDP multicast group
    mySocket.joinMulticast(address);

    // Send SSDP M-SEARCH multicast message
    mySocket.writeable.write(
      {data : str2ab(search),
       remoteAddress : address,
       remotePort : port
      }).then(
        () => {
          // Data sent sucessfully, wait for response
          console.log('M-SEARCH Sent');
          receiveMSearchResponses();
        },
        e => console.error("Sending error: ", e);
    );

    // Log result of UDP socket setup.
    mySocket.opened.then(
      () => {
        console.log("UDP socket created sucessfully");
      },
      e =>console.error("UDP socket setup failed due to error: ", e);
    );

    // Handle UDP socket closed, either as a result of the application
    // calling mySocket.close() or an error causing the socket to be
    // closed.
    mySocket.closed.then(
      () => {
         console.log("Socket has been cleanly closed");
      },
      e => console.error("Socket closed due to error: ", e);
    );

  },
  e => console.error("Sending SSDP multicast messages was denied due
                      to error: ", e);
);

[Constructor (optional UDPOptions options)]
interface UDPSocket {
    readonly    attribute DOMString?       localAddress;
    readonly    attribute unsigned short?  localPort;
    readonly    attribute DOMString?       remoteAddress;
    readonly    attribute unsigned short?  remotePort;
    readonly    attribute boolean          addressReuse;
    readonly    attribute boolean          loopback;
    readonly    attribute SocketReadyState readyState;
    readonly    attribute Promise          opened;
    readonly    attribute Promise          closed;
    readonly    attribute ReadableStream   readable;
    readonly    attribute WriteableStream  writeable;
    Promise close ();
    void    joinMulticast (DOMString multicastGroupAddress);
    void    leaveMulticast (DOMString multicastGroupAddress);
};

When the UDPSocket constructor is invoked, the user agent MUST run the following steps:

1. Create a new UDPSocket object ("mySocket").
2. If the webapp does not have permission to create a UDPSocket object according to the options argument then throw DOMException "SecurityError" and abort the remaining steps.
3. If the options argument's remoteAddress member is present and it is a valid host name or IPv4/6 address then set the mySocket.remoteAddress attribute (default remote address) to the requested address. Else, if the remoteAddress member is present but it is not a valid host name or IPv4/6 address then throw DOMException InvalidAccessError and abort the remaining steps. Otherwise, if the options argument's remoteAddress member is absent then set the mySocket.remoteAddress attribute (default remote address) to null.
4. If the options argument's remotePort member is present and it is a valid port number then set the mySocket.remotePort attribute (default remote port) to the requested port. Else, if the remotePort member is present but it is not a valid port number then throw DOMException InvalidAccessError and abort the remaining steps. Otherwise, if the options argument's remotePort member is absent then set the mySocket.remotePort attribute (default port number) to null.
5. If the options argument's localAddress member is present and the options argument's remoteAddress member is present, execute the following step:
   • If the options argument's localAddress member is a valid IPv4/6 address for a local interface that can be used to connect to the selected remoteAddress (according to the routing table) bind the socket to this local IPv4/6 address and set the mySocket.localAddress attribute to this addres. Else, if the localAddress member is present but it is not a valid local IPv4/6 address for a local interface that can be used to connect to the selected remoteAddress, throw DOMException InvalidAccessError and abort the remaining steps.
   Else, if the options argument's localAddress member is present and the options argument's remoteAddress member is absent, execute the following step:
   • If the options argument's localAddress member is a valid IPv4/6 address for a local interface on the device bind the socket to this local IPv4/6 address and set the mySocket.localAddress attribute to this addres. Else, if the localAddress member is present but it is not a valid local IPv4/6 address for a local interface on the device, throw DOMException InvalidAccessError and abort the remaining steps. Note that binding the UDPSocket to a certain local interface means that the socket can only be used to send UDP datagrams to peers reachable through this local interface.
   Else, if the options argument's localAddress member is absent, and the options argument's remoteAddress member is present, execute the following steps:
   1. Use the routing table to determine the local interface(s) that can be used to send datagrams to the selected remoteAddress. If no local interface can be used to send datagrams to the selected remoteAddress, throw DOMException InvalidAccessError and abort the remaining steps.
   2. If the routing table states that more than one local interface can be used to send datagrams to the selected remoteAddress bind the socket to the IPv4/6 address of the "default" local interface to use for the selected remoteAddress. The selection of a "default" local interface is out of scope for this specification.
   3. Set the mySocket.localAddress attribute to the local address that the socket is bound to.
   Else, i.e. the options argument's localAddress member is absent, and the options argument's remoteAddress member is absent, execute the following step:
   • Set the mySocket.localAddress attribute to null.
6. If the options argument's localPort member is absent then bind the socket to an ephemeral local port decided by the system and set the mySocket.localPort attribute to null. Otherwise, bind the socket to the requested local port and set the mySocket.localPort attribute to the local port that the socket is bound to.
7. Set the mySocket.addressReuse attribute to the value of the options argument's addressReuse member if it is present or to true if the options argument's addressReuse member is not present.
8. If the options argument's loopback member is present then set the mySocket.loopback attribute to the value of this field. Else set this attribute to false.
9. Set the mySocket.readyState attribute to "opening".
10. Create a new promise, "openedPromise", and store it so it can later be returned by the opened property.
11. Create a new promise, "closedPromise", and store it so it can later be returned by the closed property and the close method.
12. Let the mySocket.readable attribute be a new ReadableStream object, [STREAMS]. The user agent MUST implement the adaptation layer to [STREAMS] for this new ReadableStream object through implementation of a number of functions that are given as input arguments to the constructor and called by the [STREAMS] implementation. The semantics for these functions are described below:
    • The constructor's start() function is called immediately by the [STREAMS] implementation. The start() function MUST run the following steps:
      1. Setup the UDP socket to the bound local and remote address/port pairs in the background (without blocking scripts) and return openedPromise.
      2. When the UDP socket has been successfully setup the following steps MUST run:
         1. Change the mySocket.readyState attribute's value to "open".
         2. Resolve openedPromise with undefined.
      The following internal methods of the ReadableStream are arguments of the constructor's start() function and MUST be called by the start() function implementation according to the following steps:
      • The enqueue() argument of start() is a function that pushes received data into the internal buffer.
        When a new UDP datagram has been received the following steps MUST run:
        1. Create a new instance of UDPMessage.
        2. Set the UDPMessage object's data member to a new read-only ArrayBuffer object whose contents are the received UDP datagram [TYPED-ARRAYS].
        3. Set the remoteAddress member of the UDPMessage object to the source address of the received UDP datagram.
        4. Set the remotePort member of the UDPMessage object to the source port of the received UDP datagram.
        5. Call enqueue() to push the UDPMessage object into the internal [STREAMS] receive buffer. Note that enqueue() returns false if the high watermark of the buffer is reached. However, as there is no flow control mechanism in UDP the flow of datagrams can't be stopped. The enqueue() return value should therefore be ignored. This means that datagrams will be lost if the internal receive buffer has been filled to it's memory limit but this is the nature of an unreliable protocol as UDP.
      • The error() argument of start() is a function that handles readable stream errors and closes the readble stream.
        Upon detection that the attempt to setup a new UDP socket (mySocket.readyState is "opening") has failed, e.g. because the local address/port pair is already in use and mySocket.addressReuse is false, the following steps MUST run:
        1. Call error() with DOMException "NetworkError".
        2. Reject openedPromise with DOMException "NetworkError".
        3. Reject closedPromise with DOMException "NetworkError".
        4. Change the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
        Upon detection that there is an error with the established UDP socket (mySocket.readyState is "open"), e.g. network connection is lost, the following steps MUST run:
        1. Call error() with DOMException "NetworkError".
        2. Reject closedPromise with DOMException "NetworkError".
        3. Change the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
        When a new UDP datagram has been received and upon detction that it is not possible to convert the received UDP data to ArrayBuffer, [TYPED-ARRAYS], the following steps MUST run:
        1. Call error() with TypeError.
        2. Reject closedPromise with TypeError.
        3. Change the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
    • The constructor's pull() function MUST be omitted as there is no flow control mechanism in UDP and the flow of datagrams cannot be stopped and started again.
    • The constructor's cancel() function input argument is called by the [STREAMS] implementation when the ReadbleStream should be canceled. For UDP this means that the UDP socket should be closed for reading and writing. The cancel() function MUST run the following steps:
      1. If mySocket.readyState is "closed" then do nothing and abort the remaning steps.
      2. If mySocket.readyState is "opening" then fail the UDP socket setup process, reject openedPromise with DOMException AbortError and set the mySocket.readyState attribute to "closed".
      3. If mySocket.readyState is "open" the the following steps MUST run:
         1. Call mySocket.writeable.close() to assure that any buffered send data is sent.
         2. Set the mySocket.readyState attribute's value to "closed".
         3. Resolve closedPromise with undefined and release any underlying resources associated with this socket.
      Issue 1

      If the constructor's strategy argument is omitted the default backpressure behavior of readable streams applies. Currently this means that the ReadableStream object begins applying backpressure after 1 chunk has been enqueued to the internal ReadableStream object's input buffer. To be further investigated which readable stream strategy that should be applied to UDP.

13. Let the mySocket.writeable attribute be a new WritableStream object, [STREAMS]. The user agent MUST implement the adaptation layer to [STREAMS] for this new WritableStream object through implementation of a number of functions that are given as input arguments to the constructor and called by the [STREAMS] implementation. The semantics for these functions are described below:
    • The constructor's start() function MUST run the following steps:
      1. Create a new promise, "writableStartPromise".
      2. If the attempt to create a new UDP socket (see the description of the semantics for the mySocket.readable attribute constructor's start() function ) succeded resolve writableStartPromise with undefined, else reject writableStartPromise with DOMException "NetworkError".
    • The constructor's write(chunk) function is called by the [STREAMS] implementation to write UDP data. The write() function MUST run the following steps:
      1. Create a new promise, "writePromise"
      2. Convert the chunk argument to a UDPMessage object (per [WEBIDL] dictionary conversion).
      3. If no default remote address was specified in the UDPSocket's constructor options argument's remoteAddress member and the UDPMessage object's remoteAddress member is not present or null then throw DOMException InvalidAccessError and abort these steps.
      4. If no default remote port was specified in the UDPSocket's constructor options argument's remotePort member and the UDPMessage object's remotePort member is not present or null then throw DOMException InvalidAccessError and abort these steps.
      5. If the UDPMesssage object's remoteAddress and/or remotePort member(s) are present but the webapp does not have permission to send UDP packets to this address and port then throw DOMException SecurityError and abort these steps.
      6. Send UDP data with data passed in the data member of the UDPMessage object. The destination address is the address defined by the UDPMesssage object's remoteAddress member if present, else the destination address is defined by the UDPSocket's constructor options argument's remoteAddress member. The destination port is the port defined by the UDPMesssage object's remotePort member if present, else the destination port is defined by the UDPSocket's constructor options argument's remotePort member.
      7. If sending succeed resolve writePromise with undefined, else reject writePromise with DOMException "NetworkError".
    • The constructor's close() and abort() functions MUST be omitted as it is not possible to just close the writable side of a UDP socket.
      Issue 2

      If the constructor's strategy argument is omitted the Default strategy for Writable Streams applies. Currently this means that the WriteableStream object goes to "waiting" state after 1 chunk has been written to the internal WriteableStream object's output buffer. This means that the webapp should use .ready to be notified of when the state changes to "writable", i.e. the queued chunk has been written to the remote peer and more data chunks could be written. To be further investigated which WritableStreamStrategy that should be applied to UDP.

14. Return the newly created UDPSocket object ("mySocket") to the webapp.

The close method when invoked MUST run the following steps:

1. Call mysocket.readable.cancel(reason). (Reason codes TBD.)
2. Return closedPromise.

10. Interface TCPSocket

The TCPSocket interface defines attributes and methods for TCP communication

//
// This example shows a simple TCP echo client.
// The client will send "Hello World" to the server on port 6789 and log
// what has been received from the server.
//

//  Request permission to connect to server at address 127.0.0.1 on port
//  6789

navigator.tcpPermission.requestPermission({remoteAddress:"127.0.0.1", remotePort:6789}).then(
  () => {
    // Permission was granted
    // Create a new TCP client socket and connect to remote host
    var mySocket = new TCPSocket("127.0.0.1", 6789);

    // Send data to server
    mySocket.writeable.write("Hello World").then(
        () => {

            // Data sent sucessfully, wait for response
            console.log("Data has been sent to server");
            mySocket.readable.getReader().read().then(
                ({ value, done }) => {
                    if (!done) {
                        // Response received, log it:
                        console.log("Data received from server:" + value);
                    }

                    // Close the TCP connection
                    mySocket.close();
                }
            );
        },
        e => console.error("Sending error: ", e);
    );

    // Signal that we won't be writing any more and can close the write half of the connection.
    mySocket.halfClose();

    // Log result of TCP connection attempt.
    mySocket.opened.then(
      () => {
        console.log("TCP connection established sucessfully");
      },
      e =>console.error("TCP connection setup failed due to error: ", e);
    );

    // Handle TCP connection closed, either as a result of the webapp
    // calling mySocket.close() or the other side closed the TCP
    // connection or an error causing the TCP connection to be closed.
    mySocket.closed.then(
      () => {
         console.log("TCP socket has been cleanly closed");
      },
      e => console.error("TCP socket closed due to error: ", e);
    );
  },
  e => console.error("Connection to 127.0.0.1 on port 6789 was denied
                     due to error: ", e);
);

[Constructor (DOMString remoteAddress, unsigned short remotePort,
                 optional TCPOptions options)]
interface TCPSocket {
    readonly    attribute DOMString        remoteAddress;
    readonly    attribute unsigned short   remotePort;
    readonly    attribute DOMString        localAddress;
    readonly    attribute unsigned short   localPort;
    readonly    attribute boolean          addressReuse;
    readonly    attribute boolean          noDelay;
    readonly    attribute SocketReadyState readyState;
    readonly    attribute Promise          opened;
    readonly    attribute Promise          closed;
    readonly    attribute ReadableStream   readable;
    readonly    attribute WriteableStream  writeable;
    Promise close ();
    void    halfClose ();
};

When the TCPSocket constructor is invoked, the user agent MUST run the following steps:

1. Create a new TCPSocket object ("mySocket").
2. If the webapp does not have permission to create a TCPSocket object that connects to the remoteAddress/remotePort as stated by the input arguments, then throw DOMException "SecurityError" and abort the remaining steps.
3. If the remoteAddress argument is not a valid host name or IPv4/6 address and/or the remotePort argument is not a valid port number then throw DOMException "InvalidAccessError" and abort the remaining steps, else set the mySocket.remoteAddress and mySocket.remotePort attributes to the requested values.
4. If the options argument's localAddress member is present and it is a valid IPv4/6 address for a local interface that can be used to connect to the selected remoteAddress (according to the routing table) bind the socket to this local IPv4/6 address and set the mySocket.localAddress attribute to this addres. Else, if the localAddress member is present but it is not a valid local IPv4/6 address for a local interface that can be used to connect to the selected remoteAddress then throw DOMException "InvalidAccessError" and abort the remaining steps.
   Otherwise, if the options argument's localAddress member is absent, execute the following steps:
   1. Use the routing table to determine the local interface(s) that can be used to connect to the selected remoteAddress. If no local interface can be used to connect to the selected remoteAddress then throw DOMException "InvalidAccessError" and abort the remaining steps.
   2. If the routing table states that more than one local interface can be used to connect to the selected remoteAddress bind the socket to the IPv4/6 address of the "default" local interface to use for the selected remoteAddress. The selection of a "default" local interface is out of scope for this specification.
   3. Set the mySocket.localAddress attribute to the local address that the socket is bound to.
5. If the options argument's localPort member is absent then bind the socket to an ephemeral local port decided by the system and set the mySocket.localPort attribute to this port. Otherwise, bind the socket to the requested local port and set the mySocket.localPort attribute to the local port that the socket is bound to.
6. Set the mySocket.addressReuse attribute to the value of the options argument's addressReuse member if it is present or to true if the options argument's addressReuse member is not present.
7. Set the mySocket.noDelay attribute to the value of the options argument's noDelay member if it is present or to true if the options argument's noDelay member is not present.
8. Set the mySocket.readyState attribute to "opening".
9. Create a new promise, "openedPromise", and store it so it can later be returned by the opened property.
10. Create a new promise, "closedPromise", and store it so it can later be returned by the closed property and the close method.
11. Let the mySocket.readable attribute be a new ReadableStream object, [STREAMS]. The user agent MUST implement the adaptation layer to [STREAMS] for this new ReadableStream object through implementation of a number of functions that are given as input arguments to the constructor and called by the [STREAMS] implementation. The semantics for these functions are described below:
    • The constructor's start() function is called immediately by the [STREAMS] implementation. The start() function MUST run the following steps:
      1. A TCP connection setup handshake to the requested address and port MUST be performed in the background (without blocking scripts). Return openedPromise.
      2. When the TCP connection has been successfully established the following steps MUST run:
         1. Change the mySocket.readyState attribute's value to "open".
         2. Resolve openedPromise with undefined.
      The following functions are arguments of the constructor's start() function and MUST be called by the start() function implementation according to the following steps:
      • The enqueue() argument of start() is a function that pushes received data into the internal buffer.
        When new TCP data is received the following steps MUST run:
        1. Create a new read-only ArrayBuffer object whose contents are the received TCP data.
        2. Call enqueue() to push the ArrayBuffer into the internal [STREAMS] receive buffer.
        3. If the high watermark of the buffer is reached enqueue() returns false and the TCP flow control MUST be used to stop the data transmission from the remote peer.
      • The close() argument of start() is a function that closes the readable stream.
        Upon detection that the TCP connection has been closed cleanly (initiated either by the server, or by the client webapp calling close()) through a successful TCP connection closing handshake the following steps MUST run:
        1. Call close().
        2. Set the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
        3. Resolve closedPromise with undefined.
      • The error() argument of start() is a function that handles readable stream errors and closes the readble stream.
        Upon detection that the attempt to create a new TCP socket and establish a new TCP connection (mySocket.readyState is "opening") has failed the following steps MUST run:
        1. Call error() with DOMException "NetworkError".
        2. Reject openedPromise with DOMException "NetworkError".
        3. Reject closedPromise with DOMException "NetworkError".
        4. Change the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
        Upon detection that the established TCP connection (mySocket.readyState is "open") has been lost the following steps MUST run:
        1. Call error() with DOMException "NetworkError".
        2. Reject closedPromise with DOMException "NetworkError".
        3. Change the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
        Upon detection that the TCP connection closing handshake failed (mySocket.readyState is "closing") has failed the following steps MUST run:
        1. Call error() with DOMException "NetworkError".
        2. Reject closedPromise with DOMException "NetworkError".
        3. Change the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
        When new TCP data has been received and upon detction that it is not possible to convert the received data to ArrayBuffer, [TYPED-ARRAYS], the following steps MUST run:
        1. Call error() with TypeError.
        2. Reject closedPromise with TypeError.
        3. Change the mySocket.readyState attribute's value to "closed" and release any underlying resources associated with this socket.
    • The constructor's pull() function is called by the [STREAMS] implementation if the internal buffer has been emptied, but the stream's consumer still wants more data. The pull() function MUST run the following steps:
      1. The function MUST resume receiving TCP data through the TCP flow control mechanism.
    • The constructor's cancel() function input argument is called by the [STREAMS] implementation when the ReadbleStream should be canceled. For TCP this means that the TCP connection should be terminated. The cancel() function MUST run the following steps:
      1. If mySocket.readyState is "closing" or "closed" then do nothing and abort the remaning steps.
      2. If mySocket.readyState is "opening" then fail the connection attempt, reject openedPromise and closedPromise with DOMException AbortError and set the mySocket.readyState attribute to "closing".
      3. If mySocket.readyState is "open" then the following steps MUST run:
         1. Call mySocket.writeable.close() to assure that any buffered send data is sent before closing the socket.
         2. Set the mySocket.readyState attribute's value to "closing".
         3. Initiate TCP closing handshake.
      Issue 3

      If the constructor's strategy argument is omitted the default backpressure behavior of readable streams applies. Currently this means that the ReadableStream object begins applying backpressure after 1 chunk has been enqueued to the internal ReadableStream object's input buffer. To be further investigated which readable stream strategy that should be applied to TCP.

12. Let the mySocket.writeable attribute be a new WritableStream object, [STREAMS]. The user agent MUST implement the adaptation layer to [STREAMS] for this new WritableStream object through implementation of a number of functions that are given as input arguments to the constructor and called by the [STREAMS] implementation. The semantics for these functions are described below:
    • The constructor's start() function MUST run the following steps:
      1. Create a new promise, "writableStartPromise".
      2. If the attempt to create a new TCP socket and establish a new TCP connection (see the description of the semantics for the mySocket.readable attribute constructor's start() function ) succeded resolve writableStartPromise with undefined, else reject writableStartPromise with DOMException "NetworkError".
    • The constructor's write(chunk) function is called by the [STREAMS] implementation to write data to the remote peer on the TCP connection. The write() function MUST run the following steps:
      1. Create a new promise, "writePromise"
      2. Send TCP data with data passed in the chunk parameter to the address and port of the recipient as stated by the TCPSocket object constructor's remoteAddress and remotePort fields. The data in the chunk parameter can be of any type.
      3. If sending succeed resolve writePromise with undefined, else reject writePromise with DOMException "NetworkError".
    • The constructor's close() function is called by the [STREAMS] implementation to close the writable side of the connection, that is a TCP "half close" is performed. The close() function MUST run the following steps:
      1. If mySocket.readyState is "closing" or "closed" then do nothing.
      2. If mySocket.readyState is "opening" then complete the connection attempt. If succesful send FIN and set the mySocket.readyState attribute to "halfclosed".
      3. If mySocket.readyState is "open" then send FIN and set the mySocket.readyState attribute to "halfclosed".
      Note that the Streams implementation will call close() after all queued-up writes successfully completed.
    • The constructor's abort() function is called by the [STREAMS] implementation to abort the writable side of the connection. This function MUST run the same steps as close() but note that the Streams implementation will throw away any pending queued up chunks.
      Issue 4

      If the constructor's strategy argument is omitted the Default strategy for Writable Streams applies. Currently this means that the WriteableStream object goes to "waiting" state after 1 chunk has been written to the internal WriteableStream object's output buffer. This means that the webapp should use .ready to be notified of when the state changes to "writable", i.e. the queued chunk has been written to the remote peer and more data chunks could be written. To be further investigated which WritableStreamStrategy that should be applied to TCP.

13. Return the newly created TCPSocket object ("mySocket") to the webapp.

The close() method when invoked MUST run the following steps:

1. Call mysocket.readable.cancel(reason). (Reason codes TBD.)
2. Return closedPromise.

The halfClose() method when invoked MUST run the following steps:

1. Call mysocket.writeable.close().

11. Interface TCPServerSocket

The TCPServerSocket interface supports TCP server sockets that listens to connection attempts from TCP clients

//
// This example shows a simple TCP echo server.
// The server will listen on port 6789 and respond back with whatever
// has been sent to the server.
//

 //  Request permission to listen on port 6789
 navigator.tcpServerPermission.requestPermission({"localPort":6789}).then(
   () => {
     // Permission was granted

     //  Create a new server socket that listens on port 6789
     var myServerSocket = new TCPServerSocket({"localPort": 6789});

     // Listen for connection attempts from TCP clients.
     listenForConnections();
     function listenForConnections() {
       myServerSocket.listen().then(
           connectedSocket => {
           // A connection has been accepted

             console.log ("Connection accepted from address: " +
                           connectedSocket.remoteAddress + " port: " +
                           connectedSocket.remotePort);

             var reader = connectedSocket.readable.getReader();

             // Wait for data
             waitForData();
             function waitForData () {
               reader.read().then(
                 ({ value, done }) => {
                   if (done) return;

                   // Data in buffer, read it
                   console.log("Received: " + value);

                   // Send data back
                   connected.writeable.write(value).then(
                     () => console.log("Sending data succeeded"),
                     e => console.error("Failed to send: ", e);
                   });
                   // Continue to wait for data
                   waitForData ();
                 }
               );

             }

             // Continue to listen for new connections
             listenForConnections();
       },
           e => {
             console.error("A client connection attempt failed: ", e);

             // Continue to listen for new connections
             listenForConnections();
           }

       );
     }

     // Log result of TCP server socket creation attempt.
     myServerSocket.opened.then(
       () => {
         console.log("TCP server socket created sucessfully");
       },
       e =>console.error("TCP server socket creation failed due to error: ", e);
     );

     // Handle TCP server closed, either as a result of the webapp
     // calling myServerSocket.close() or due to an error.
     myServerSocket.closed.then(
       () => {
          console.log("TCP server socket has been cleanly closed");
       },
       e => console.error("TCP server socket closed due to error: ", e);
     );

   },
   e => console.error("TCP Server Socket on local port 6789 was denied
                      due to error: ", e);
 );

[Constructor (optional TCPServerOptions options)]
interface TCPServerSocket {
    readonly    attribute DOMString        localAddress;
    readonly    attribute unsigned short   localPort;
    readonly    attribute boolean          addressReuse;
    readonly    attribute SocketReadyState readyState;
    readonly    attribute Promise          opened;
    readonly    attribute Promise          closed;
    Promise listen ();
    Promise close ();
};

When the TCPServerSocket constructor is invoked, the user agent MUST run the following steps:

1. Create a new TCPServerSocket object ("myServerSocket").
2. If the webapp does not have permission to create a TCPServerSocket object according to the options argument then throw DOMException "SecurityError" and abort the remaining steps.
3. If the options argument's localAddress member is absent the server will accept connections directed to any IPv4 address and the localAddress attribute is set to null. Otherwise, if the requested local address is a valid IPv4/6 address for a local interface on the device bind the server socket to this local IPv4/6 address and set the localAddress attribute to this address. Else, if the localAddress member is present but it is not a valid local IPv4/6 address for a local interface on the device, throw DOMException InvalidAccessError and abort the remaining steps.
4. If the options argument's localPort member is absent then bind the socket to an ephemeral local port decided by the system and set the localPort attribute to null. Otherwise, bind the socket to the requested local port and set the localPort attribute to the local port that the socket is bound to.
5. Set the addressReuse attribute to the value of the options argument's addressReuse member if it is present or to true if the options argument's addressReuse member is not present.
6. Set the myServerSocket.readyState attribute to "opening".
7. Create a new promise, "openedPromise", and store it so it can later be returned by the opened property.
8. Create a new promise, "closedPromise", and store it so it can later be returned by the closed property and the close method.
9. Return the newly created TCPServerSocket object to the webapp.

The close method when invoked MUST run the following steps:

1. If a TCP connection setup is in progress the connection setup is finalized according to the descriptions below.
2. Stop listening to further connection attempts from clients.
3. Set the myServerSocket.readyState attribute to "closed".
4. Resolve closedPromise with undefined.

The listen method when invoked MUST run the following steps:

1. If myServerSocket.readyState attribute is"closed" then throw DOMException "InvalidStateError" and abort the remaining steps.
2. Create a new promise, "connectionPromise".
3. Start listening for connections on the specified local port and address. Return connectionPromise.

When a new TCP server socket has successfully been created the user agent MUST run the following steps:

1. Change the myServerSocket.readyState attribute's value to "open".
2. Resolve openedPromise with undefined.

When the attempt to create a new TCP server socket (myServerSocket.readyState is "opening") has failed the user agent MUST run the following steps:

1. Change the myServerSocket.readyState attribute's value to "closed".
2. Reject openedPromise with DOMException "NetworkError".
3. Reject closedPromise with DOMException "NetworkError".

When there is an error on an established TCP server socket (myServerSocket.readyState is "open"), e.g. loss of network contact, the user agent MUST run the following steps:

1. Change the myServerSocket.readyState attribute's value to "closed".
2. Reject closedPromise with DOMException "NetworkError".

Upon a new successful connection to the TCP server socket the user agent MUST run the following steps:

1. Let socket be a new instance of TCPSocket.
2. Set the remoteAddress attribute of socket to the IPv4/6 address of the peer.
3. Set the remotePort attribute of socket to the source port of the of the peer.
4. Set the localAddress attribute of socket to the used local IPv4/6 address.
5. Set the localPort attribute of socket to the used local source port.
6. Set the readyState attribute of socket to "open".
7. Set the bufferedAmount attribute of socket to 0.
8. Resolve connectionPromise with socket as argument.

Upon a new connection attempt to the TCP server socket that can not be served, e.g. due to max number of open connections, the user agent MUST run the following steps:

1. Reject connectionPromise with DOMException "NetworkError".

12. Dictionary UDPMessage

The UDPMessage dictionary represents UDP data including address and port of the remote peer. The field data is mandatory but remoteAddress and remotePort are optional.

dictionary UDPMessage {
             ArrayBuffer    data;
             DOMString      remoteAddress;
             unsigned short remotePort;
};

13. Dictionary UDPOptions

States the options for the UDPSocket. An instance of this dictionary can optionally be used in the constructor of the UDPSocket object, where all fields are optional.

dictionary UDPOptions {
             DOMString      localAddress;
             unsigned short localPort;
             DOMString      remoteAddress;
             unsigned short remotePort;
             boolean        addressReuse;
             boolean        loopback;
};

14. Dictionary TCPOptions

States the options for the TCPSocket. An instance of this dictionary can optionally be used in the constructor of the TCPSocket object, where all fields are optional.

dictionary TCPOptions {
             DOMString           localAddress;
             unsigned short      localPort;
             boolean             addressReuse;
             boolean             noDelay;
             boolean             useSecureTransport;
             TCPKeepAliveOptions tcpKeepAliveOptions;
             unsigned long       tcpKeepAliveSparseIntvl;
};

15. Dictionary TCPServerOptions

States the options for the TCPServerSocket. An instance of this dictionary can optionally be used in the constructor of the TCPServerSocket object, where all fields are optional.

dictionary TCPServerOptions {
             DOMString      localAddress;
             unsigned short localPort;
             boolean        addressReuse;
             boolean        useSecureTransport;
};

16. Dictionary UDPPermissionOptions

States the options for the webapp to get status of permission for creating a UDPSocket object or to request permission to create a UDPSocket object. An instance of this dictionary can optionally be used as argument to the UDPPermission hasPermission and requestPermission methods. All fields are optional.

dictionary UDPPermissionOptions {
             DOMString      localAddress;
             unsigned short localPort;
             DOMString      remoteAddress;
             unsigned short remotePort;
};

17. Dictionary TCPPermissionOptions

States the options for the webapp to get status of permission for creating a TCPSocket object or to request permission to create a TCPSocket object. An instance of this dictionary can optionally be used as argument to the TCPPermission hasPermission and requestPermission methods. All fields are optional.

dictionary TCPPermissionOptions {
             DOMString      remoteAddress;
             unsigned short remotePort;
};

18. Dictionary TCPServerPermissionOptions

States the options for the webapp to get status of permission for creating a TCPServerSocket object or to request permission to create a TCPServerSocket object. An instance of this dictionary can optionally be used as argument to the TCPServerPermission hasPermission and requestPermission methods. All fields are optional.

dictionary TCPServerPermissionOptions {
             DOMString      localAddress;
             unsigned short localPort;
};

19. Enums

enum TCPUDPPermissionState {
    "granted",
    "denied",
    "prompt"
};

enum SocketReadyState {
    "opening",
    "open",
    "closing",
    "closed",
    "halfclosed"
};

enum TCPKeepAliveOptions {
    "off",
    "frequent-then-sparse",
    "sparse"
};