Winsock Connecting a Socket - Windows API Reference

Connecting a Socket

This section covers the process of establishing a connection to a remote host using Winsock. This is a fundamental step in building client-server applications where clients initiate communication with servers.

The `connect` Function

The primary function used to establish a connection is connect. This function attempts to establish a connection to a specified destination address and port on a remote host.

Syntax


int connect(
  SOCKET                s,
  const struct sockaddr *name,
  int                   namelen
);

Parameters

s: A descriptor identifying an unconnected socket.
name: A pointer to a sockaddr structure that specifies the destination address and port to which this socket should be connected. For IPv4, this will typically be a sockaddr_in structure.
namelen: The length, in bytes, of the structure pointed to by the name parameter.

Return Value

If the connection is successful, connect returns zero. Otherwise, it returns SOCKET_ERROR, and a specific error code can be retrieved by calling WSAGetLastError.

Remarks

The behavior of connect depends on the socket's operating mode:

Blocking Mode: In blocking mode, connect is a synchronous operation. The function call will not return until the connection is established or fails. If the connection is successful, it returns 0. If it fails, it returns SOCKET_ERROR, and WSAGetLastError can be used to determine the specific error. Common errors include WSAECONNREFUSED (connection refused) and WSAETIMEDOUT (connection timed out).
Non-blocking Mode: In non-blocking mode, connect is an asynchronous operation. The function call returns immediately. If the connection is established immediately, it returns 0. If the connection is still in progress, it returns SOCKET_ERROR with WSAGetLastError returning WSAEINPROGRESS. The application must then use functions like select or WSAEventSelect to determine when the connection attempt has completed (either successfully or with an error). When the connection is ready, the socket will be marked as writable.

Important Considerations for Non-blocking Sockets:

When using connect on a non-blocking socket, it's crucial to handle the WSAEINPROGRESS return value. You should then monitor the socket for writability using mechanisms like select. A successful connection will result in the socket becoming writable, while a failed connection will cause select to indicate an error on the socket.

Example (Conceptual)

The following C++ snippet illustrates a basic connection attempt. Note that error handling and non-blocking mode logic would be more extensive in a real-world application.


#include <winsock2.h>
#include <ws2tcpip.h>

#pragma comment(lib, "Ws2_32.lib")

// ... (Winsock initialization omitted for brevity)

SOCKET clientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (clientSocket == INVALID_SOCKET) {
    // Handle socket creation error
    return;
}

sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(8080); // Example port
InetPton(AF_INET, L"192.168.1.100", &serverAddr.sin_addr.s_addr); // Example IP address

int result = connect(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

if (result == SOCKET_ERROR) {
    int errorCode = WSAGetLastError();
    if (errorCode == WSAEINPROGRESS) {
        // Connection is in progress (for non-blocking socket)
        // Need to wait for completion using select or WSAEventSelect
        OutputDebugString(L"Connection in progress...\n");
    } else {
        // Handle connection failure
        wprintf(L"connect failed with error: %d\n", errorCode);
        closesocket(clientSocket);
        // ... (Winsock cleanup omitted)
        return;
    }
} else {
    // Connection successful immediately
    OutputDebugString(L"Connection successful!\n");
}

// If connection was in progress, you would now wait for it to complete
// and then check WSAGetLastError() again after the select/WSAEventSelect
// indicates the socket is ready.

// ... (Send/Receive operations would follow)

// closesocket(clientSocket);
// ... (Winsock cleanup)