Method Close

cmd/run/socket/socket.go:708–792

()

}

func (s *Socket) Close() syscall.Errno {
	if !s.FD.ClosingIncRef() {
		return unix.EBADF
	}
	defer s.FD.DecRef()

	s.FD.Lock()
	if err := unix.Close(s.FD.FD()); err != nil {
		var errno syscall.Errno
		if !errors.As(err, &errno) {
			panic(fmt.Errorf("cannot interpret close(2) error as errno: %w", err))
		}
		return errno
	}

	if last := s.Inode.remove(s); !last {
		return 0
	}

	var errs []error
	var prev *ImmutableState
	for {
		prev = s.Inode.state.Load()
		if prev.state == StateClosed {
			panic(fmt.Errorf("final socket close for inode %d: inode state is already closed", s.Inode.Number))
		}

		next := &ImmutableState{state: StateClosed}
		if s.Inode.state.CompareAndSwap(prev, next) {
			break
		}
	}

	switch prev.state {
	case StatePassive:
		if prev.passive.bind != nil && prev.passive.bind.ClosingIncRef() {
			defer prev.passive.bind.DecRef()
			prev.passive.bind.Lock()
			if err := unix.Close(prev.passive.bind.FD()); err != nil {
				errs = append(errs, fmt.Errorf("close temp bind socket: %w", err))
			}
		}

	case StateConnected:
		if prev.connected.proxy.skipCloseTCP.CompareAndSwap(false, true) {
			// We can't close the two underlying TCP connections yet because the
			// proxy might still have some unflushed bytes in a buffer somewhere. The
			// connections will be closed when the (*proxy).start() goroutine ends.
			// See the equivalent CAS in proxy.go for the process.Close() and
			// external.Close() calls.
		} else {
			if err := prev.connected.proxy.process.Close(); err != nil && !errors.Is(err, net.ErrClosed) {
				errs = append(errs, fmt.Errorf("close process conn: %w", err))
			}
			if err := prev.connected.proxy.external.Close(); err != nil && !errors.Is(err, net.ErrClosed) {
				errs = append(errs, fmt.Errorf("close external conn: %w", err))
			}
		}