In some cases Socket isn't half-close when .end() is called.

[didkovsky]

Version

v19.2.0

Platform

OSX 12.15.1

Subsystem

No response

What steps will reproduce the bug?

I found few cases when a Socket from node/net isn't closes when it should. Examples:

TCP issue

If a listener .on('data') on a server socket not defined, the 'end' signal from the clients side will be ignored.

Server source

const { createServer } = require('net')

createServer(socket => {

  socket.on('error', console.log)
  
  // Not emitted
  socket.on('end', () => console.log('end.'))
  socket.on('close', () => console.log('close.'))

  /**
   * If listener .on('data') not defined,
   * socket will ignore 'end' signal from client
   */
  // socket.on('data', () => {})

  setTimeout(() => {
    // Missing end
    // socket.end()
  }, 2000)

  setInterval(() => {
    socket.write('Data.')
  }, 500)
})
.listen(444)

Client source

const { Socket } = require('net')

const socket = new Socket()
socket.on('error', console.log)

// Not emitted, if .on('data') not attached on the server side
socket.on('end', () => console.log('End.'))

// Data will come while server sends it
socket.on('data', data => console.log(data.toString('utf8')))

socket.connect({
  host: 'localhost',
  port: 444
}, () => {
  socket.write('Hello!')
 // Will be ignored
  socket.end()
})

HTTP issue 1

This issue is a consequence of the TCP issue above. If we have not listener .on('data') on a req object, the 'end' signal from the clients side will be ignored.

Server source

const { createServer } = require('http')

createServer((req, res) => {
  console.log('Request.')
  req.on('error', console.log)
  req.on('end', () => console.log('End.'))

  /**
   * If listener .on('data') not defined,
   * req will ignore 'end' signal from client
   */
  // req.on('data', () => {})

  const dataInt = setInterval(() => {
    res.write('Data.')
  }, 1000)

  setTimeout(() => { 
    // clearInterval(dataInt)
    // res.end('Ok.')
  }, 10000)
})
.listen(333)

Client source

const { request } = require('http')

const options = {
  host: 'localhost',
  port: 333,
  method: 'POST',
  path: '/'
}

const req = request(options, response => {
  response.on('error', console.log)

  // Data will come while server sends it.
  response.on('data', data => console.log(data.toString('utf8')))
  // Not emitted, if .on('data') not attached on the server side
  response.on('end', () => console.log('End.'))
})

req.on('error', console.log)
req.write('Hello!')

// Will be ignored
req.end()

HTTP issue 2

Server cannot close connection through res.end().

Server source

const { createServer } = require('http')

const server = createServer((req, res) => {
  console.log('Request.')
  req.on('error', console.log)

  // Not emitted
  req.on('end', () => console.log('End.'))
  req.on('close', () => console.log('Close.'))

  req.on('data', data => {
    console.log(data.toString('utf8'))
    res.write('Ok.')

    /**
     * Will be ignored,
     * data will come while client sends it.
     */
    res.end()

    // Will close a socket.
    // res.socket.end()
    // or
    // res.destroy()
  })
})

/**
 * Also, a socket will not release.
 */
server.maxConnections = 1
server.listen(333)

Clien source

const { request } = require('http')

const options = {
  host: 'localhost',
  port: 333,
  method: 'POST',
  path: '/'
}

const req = request(options, response => {
  response.on('error', console.log)
  response.on('data', data => console.log(data.toString('utf8')))

  // Not emitted
  response.on('end', () => console.log('End.'))
})

req.on('error', console.log)

setInterval(() => {
  req.write('Hello.')
}, 1000)

// Missing end
// req.end()

Repo with examples: https://github.com/didkovsky/onend

How often does it reproduce? Is there a required condition?

Always

What is the expected behavior?

If I call socket.end() I expect to get 'end' event. And stop receiving data on .on('data') listener.

What do you see instead?

If we have not .on('data') listener, socket ignore 'end' signal.

Additional information

No response

[bnoordhuis]

What you're describing is the expected behavior, there's no bug. I think you may be confusing socket.end() with socket.destroy()?

From the documentation on socket.end():

Half-closes the socket. i.e., it sends a FIN packet. It is possible the server will still send some data.

[didkovsky]

I understand what you saying about. But.

1. Behaviour is different regarding a 'data' event listener. If we have it - we have one behaviour, if we don't - we have another.
2. I know, after .end() a socket is half-closed, and it's still writable, but I expect, that It will not receive the data (in my listener) after I called .end() (look at HTTP issue 2). Btw in this example, if we call res.socket.end() - it closes connection, but res.end() - does not. You right, we can .destroy() a socket by timeout, or if the data too big, but how many libraries have the same implementation?
3. We also have events on socket: 'end' and 'close'. And if .end() is called, we should get at least 'end' event, but it isn't emitted in cases above.

[didkovsky]

On my opinion, problem can be, if socket has no 'data' listener, it ignores all packets including FIN packet. Try https://github.com/didkovsky/onend/tree/main/tcp example, with the commented string socket.on('data', () => {}) in server.js, then try it with uncommented.

[lpinca]

If a listener .on('data') on a server socket not defined, the 'end' signal from the clients side will be ignored.

This is expected. The 'end' event is not emitted until all data is read. This is valid for all streams. The socket is not closed until all data is read.

[didkovsky]

But why it's emitted if the "data" listener is attached? If we have .on('data') listener, and we got the 'end' signal, socket will be closed.

[mscdex]

Streams start out in paused mode. Attaching a 'data' event handler puts it into flowing mode. Alternatively you can do stream.resume() if you want to simply discard the contents.

[didkovsky]

This is a good point. Thank you. If we call socket.resume() on the server side, socket will be closed by end signal from the clients side.
But if we check socket.isPaused() before we resumed it, or attached the data listener, it returns false. And this is incorrect.

const { createServer } = require('net')

createServer(socket => {
  // Returns false
  console.log(socket.isPaused())
}).listen(444)

Also, this is not an answer why we do not receiving the end signal from the clients side.

From nodejs doc:
https://nodejs.org/dist/latest-v19.x/docs/api/net.html#event-end

Emitted when the other end of the socket signals the end of transmission, thus ending the readable side of the socket.

Also from doc:

By default (allowHalfOpen is false) the socket will send an end of transmission packet back and destroy its file descriptor once it has written out its pending write queue.

If we check console.log(socket.allowHalfOpen) it's really false. So, if the client sends end signal, the server should close the socket regarding to this doc. But, this is not happens.

[bnoordhuis]

I've converted this to a discussion because there are no bugs here, just misunderstandings.

But if we check socket.isPaused() before we resumed it, or attached the data listener, it returns false. And this is incorrect.

isPaused() is only relevant when the stream is in flowing mode. Its documentation mentions that.

If we check console.log(socket.allowHalfOpen) it's really false. So, if the client sends end signal, the server should close the socket regarding to this doc.

I think you're assuming the client always sends a FIN TCP packet but that doesn't have to be the case.