Analysis and Solutions for OSError: [Errno 107] Transport endpoint is not connected in Python Socket Programming

In Python network programming, sockets serve as fundamental components for inter-process communication. However, developers often encounter various connection errors in practice, with OSError: [Errno 107] Transport endpoint is not connected being a typical example. This error usually indicates that the socket connection has been disconnected or is in an invalid state, but the underlying causes are often more complex than they appear.

Error Phenomenon and Preliminary Analysis

When developers attempt to run client and server programs on the same machine, they may encounter the following error sequence: first OSError: [Errno 107] Transport endpoint is not connected, followed by OSError: [Errno 106] Transport endpoint is already connected when trying to reconnect. This contradictory phenomenon indicates issues with connection state management. Semantically, Errno 107 means the transport endpoint is not connected, while Errno 106 means it is already connected. Though seemingly contradictory, they actually reflect confusion in the socket state machine.

Core Issue: Correct Usage of socket.accept()

The key to solving this problem lies in understanding and properly using the socket.accept() method. According to Python official documentation, the socket.accept() method accepts a connection request, but it's crucial to note that its return value is a tuple (conn, address), where conn is a new socket object specifically for data transmission on that connection.

Many developers mistakenly believe they can use the listening socket directly for communication after accept() returns, but they should actually use the returned new socket object conn. The following code example demonstrates the correct approach:

# Server-side code example
import socket

# Create TCP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Bind to local address and port
server_socket.bind(("localhost", 8081))

# Start listening, set maximum pending connections
server_socket.listen(2)

# Accept connection, returns new socket and client address
connection_socket, client_address = server_socket.accept()

# Use new socket to receive data
data = connection_socket.recv(1024).decode("ascii")
print(f"Received data: {data}")

# Close connection socket
connection_socket.close()

# Close server socket
server_socket.close()

In this example, server_socket is only used for listening and accepting connections, while actual communication occurs through connection_socket. This separation ensures clear management of connection states.

Client Implementation and Communication Flow

Client implementation is relatively straightforward but also requires proper management of connection states:

# Client-side code example
import socket

# Create TCP socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Connect to server
client_socket.connect(("localhost", 8081))

# Send data
client_socket.send("Hello Server".encode())

# Can continue sending more data
client_socket.send("Additional data".encode())

# Close socket
client_socket.close()

Error Handling and State Management

To avoid OSError: [Errno 107] and OSError: [Errno 106] errors, developers need to implement comprehensive error handling mechanisms:

import socket
import errno

class SocketManager:
    def __init__(self):
        self.socket = None
        self.connected = False
    
    def connect(self, host, port):
        if self.connected:
            raise OSError(errno.EISCONN, "Transport endpoint is already connected")
        
        try:
            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.socket.connect((host, port))
            self.connected = True
        except socket.error as e:
            if e.errno == errno.ECONNREFUSED:
                print("Connection refused by server")
            elif e.errno == errno.ETIMEDOUT:
                print("Connection timeout")
            else:
                print(f"Connection error: {e}")
            self.connected = False
            raise
    
    def send_data(self, data):
        if not self.connected:
            raise OSError(errno.ENOTCONN, "Transport endpoint is not connected")
        
        try:
            return self.socket.send(data.encode())
        except socket.error as e:
            if e.errno == errno.EPIPE:
                print("Broken pipe - connection lost")
                self.connected = False
            raise
    
    def close(self):
        if self.socket:
            self.socket.close()
            self.connected = False

Practical Considerations in Application Development

In actual development, beyond correctly using the socket.accept() method, developers should also pay attention to the following points:

1. Connection State Tracking: Maintain clear connection state variables to avoid attempting to send data when not connected.

2. Resource Cleanup: Ensure proper closure of sockets and release of system resources when programs end or encounter exceptions.

3. Timeout Settings: Set reasonable timeout values for socket operations to prevent indefinite waiting.

4. Error Recovery: Implement reconnection mechanisms to automatically recover when connections are unexpectedly lost.

By understanding how the socket state machine works and adopting correct programming patterns, developers can avoid most connection-related errors and write stable, reliable network applications.