MSDN Community

Welcome to the Winsock Basics C++ Samples section of the MSDN Community. This page provides a curated collection of code examples designed to help you understand and implement fundamental networking operations using the Windows Sockets API (Winsock) in C++.

Winsock is a Microsoft Windows API implementation of the Berkeley sockets API, used for network programming on Windows platforms. These samples cover essential concepts such as socket creation, binding, listening, connecting, sending, and receiving data.

Featured Samples:

• Basic TCP Server

  Demonstrates how to create a simple TCP server that listens for incoming connections, accepts them, and echoes back any data received.

  View Sample →

• Basic TCP Client

  Illustrates how to create a TCP client that connects to a server, sends a message, and receives a response.

  View Sample →

• Basic UDP Echo Server

  Shows how to set up a UDP server that receives datagrams and sends them back to the sender.

  View Sample →

• Basic UDP Echo Client

  Provides a UDP client example for sending datagrams to an echo server and receiving the echoed data.

  View Sample →

• Address Resolution (gethostbyname)

  Explains how to resolve hostnames to IP addresses using Winsock functions.

  View Sample →

Basic TCP Server

This sample provides a straightforward implementation of a TCP server. It handles multiple client connections sequentially.

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

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

int main() {
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return 1;
    }

    SOCKET ListenSocket = INVALID_SOCKET;
    SOCKET ClientSocket = INVALID_SOCKET;
    struct sockaddr_in ServerAddr, ClientAddr;
    int ClientAddrSize = sizeof(ClientAddr);
    char buffer[512];
    int bytesReceived;

    // Create socket
    ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (ListenSocket == INVALID_SOCKET) {
        std::cerr << "Error creating socket: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    // Bind socket
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_addr.s_addr = INADDR_ANY; // Listen on any interface
    ServerAddr.sin_port = htons(8080);      // Port to listen on

    if (bind(ListenSocket, (struct sockaddr*)&ServerAddr, sizeof(ServerAddr)) == SOCKET_ERROR) {
        std::cerr << "Bind failed with error: " << WSAGetLastError() << std::endl;
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    // Listen for connections
    if (listen(ListenSocket, SOMAXCONN) == SOCKET_ERROR) {
        std::cerr << "Listen failed with error: " << WSAGetLastError() << std::endl;
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Server listening on port 8080..." << std::endl;

    // Accept a client socket
    ClientSocket = accept(ListenSocket, (struct sockaddr*)&ClientAddr, &ClientAddrSize);
    if (ClientSocket == INVALID_SOCKET) {
        std::cerr << "Accept failed: " << WSAGetLastError() << std::endl;
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Client connected!" << std::endl;

    // Receive and echo data
    do {
        bytesReceived = recv(ClientSocket, buffer, sizeof(buffer) - 1, 0);
        if (bytesReceived > 0) {
            buffer[bytesReceived] = '\0'; // Null-terminate the received data
            std::cout << "Received: " << buffer << std::endl;
            send(ClientSocket, buffer, bytesReceived, 0); // Echo back
        } else if (bytesReceived == 0) {
            std::cout << "Client disconnected." << std::endl;
        } else {
            std::cerr << "Recv failed: " << WSAGetLastError() << std::endl;
        }
    } while (bytesReceived > 0);

    // Cleanup
    closesocket(ClientSocket);
    closesocket(ListenSocket);
    WSACleanup();

    return 0;
}

Basic TCP Client

This client sample connects to a specified server, sends a message, and waits for a response.

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

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

int main() {
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return 1;
    }

    SOCKET ConnectSocket = INVALID_SOCKET;
    struct sockaddr_in ServerAddr;
    const char* serverIp = "127.0.0.1"; // Replace with server IP
    int serverPort = 8080;

    // Create socket
    ConnectSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (ConnectSocket == INVALID_SOCKET) {
        std::cerr << "Error creating socket: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    // Setup server address
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(serverPort);
    inet_pton(AF_INET, serverIp, &ServerAddr.sin_addr); // Convert IP string to binary form

    // Connect to server
    if (connect(ConnectSocket, (struct sockaddr*)&ServerAddr, sizeof(ServerAddr)) == SOCKET_ERROR) {
        std::cerr << "Connect failed: " << WSAGetLastError() << std::endl;
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Connected to server " << serverIp << ":" << serverPort << std::endl;

    // Send data
    std::string message = "Hello from Winsock client!";
    int sendResult = send(ConnectSocket, message.c_str(), (int)message.length(), 0);
    if (sendResult == SOCKET_ERROR) {
        std::cerr << "Send failed: " << WSAGetLastError() << std::endl;
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
    }
    std::cout << "Sent: " << message << std::endl;

    // Receive data
    char buffer[512];
    int bytesReceived = recv(ConnectSocket, buffer, sizeof(buffer) - 1, 0);
    if (bytesReceived > 0) {
        buffer[bytesReceived] = '\0';
        std::cout << "Received: " << buffer << std::endl;
    } else if (bytesReceived == 0) {
        std::cout << "Connection closed by server." << std::endl;
    } else {
        std::cerr << "Recv failed: " << WSAGetLastError() << std::endl;
    }

    // Cleanup
    closesocket(ConnectSocket);
    WSACleanup();

    return 0;
}

Basic UDP Echo Server

A simple UDP server that listens for datagrams and sends them back.

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

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

int main() {
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return 1;
    }

    SOCKET ServerSocket = INVALID_SOCKET;
    struct sockaddr_in ServerAddr, ClientAddr;
    int ClientAddrSize = sizeof(ClientAddr);
    char buffer[512];
    int bytesReceived;

    // Create socket
    ServerSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (ServerSocket == INVALID_SOCKET) {
        std::cerr << "Error creating socket: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    // Bind socket
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_addr.s_addr = INADDR_ANY;
    ServerAddr.sin_port = htons(8080);

    if (bind(ServerSocket, (struct sockaddr*)&ServerAddr, sizeof(ServerAddr)) == SOCKET_ERROR) {
        std::cerr << "Bind failed with error: " << WSAGetLastError() << std::endl;
        closesocket(ServerSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "UDP Echo Server listening on port 8080..." << std::endl;

    // Receive and echo data
    while (true) {
        bytesReceived = recvfrom(ServerSocket, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&ClientAddr, &ClientAddrSize);
        if (bytesReceived == SOCKET_ERROR) {
            std::cerr << "Recvfrom failed: " << WSAGetLastError() << std::endl;
            continue;
        }

        buffer[bytesReceived] = '\0';
        std::cout << "Received from " << inet_ntoa(ClientAddr.sin_addr) << ":" << ntohs(ClientAddr.sin_port) << ": " << buffer << std::endl;

        // Echo back
        sendto(ServerSocket, buffer, bytesReceived, 0, (struct sockaddr*)&ClientAddr, ClientAddrSize);
    }

    // Cleanup
    closesocket(ServerSocket);
    WSACleanup();

    return 0;
}

Basic UDP Echo Client

A UDP client that sends data to an echo server and displays the response.

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

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

int main() {
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return 1;
    }

    SOCKET ClientSocket = INVALID_SOCKET;
    struct sockaddr_in ServerAddr;
    const char* serverIp = "127.0.0.1"; // Replace with server IP
    int serverPort = 8080;

    // Create socket
    ClientSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (ClientSocket == INVALID_SOCKET) {
        std::cerr << "Error creating socket: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    // Setup server address
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(serverPort);
    inet_pton(AF_INET, serverIp, &ServerAddr.sin_addr);

    // Send data
    std::string message = "Ping from UDP client!";
    int sendResult = sendto(ClientSocket, message.c_str(), (int)message.length(), 0, (struct sockaddr*)&ServerAddr, sizeof(ServerAddr));
    if (sendResult == SOCKET_ERROR) {
        std::cerr << "Sendto failed: " << WSAGetLastError() << std::endl;
        closesocket(ClientSocket);
        WSACleanup();
        return 1;
    }
    std::cout << "Sent: " << message << " to " << serverIp << ":" << serverPort << std::endl;

    // Receive data
    char buffer[512];
    int ClientAddrSize = sizeof(ServerAddr); // Reuse ServerAddr for client info
    int bytesReceived = recvfrom(ClientSocket, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&ServerAddr, &ClientAddrSize);
    if (bytesReceived > 0) {
        buffer[bytesReceived] = '\0';
        std::cout << "Received: " << buffer << std::endl;
    } else {
        std::cerr << "Recvfrom failed: " << WSAGetLastError() << std::endl;
    }

    // Cleanup
    closesocket(ClientSocket);
    WSACleanup();

    return 0;
}

Address Resolution (gethostbyname)

This sample demonstrates how to resolve a hostname into an IP address.

#include <winsock2.h>
#include <ws2tcpip.h>
#include <iostream>
#include <string>
#include <iomanip> // For std::setw, std::setfill

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

int main() {
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return 1;
    }

    const char* hostname = "www.example.com";
    struct hostent* remoteHost;

    std::cout << "Resolving hostname: " << hostname << std::endl;

    remoteHost = gethostbyname(hostname);

    if (remoteHost == NULL) {
        std::cerr << "gethostbyname failed with error: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    std::cout << "Official name: " << remoteHost->h_name << std::endl;

    // Print IP addresses
    std::cout << "IP Addresses:" << std::endl;
    for (int i = 0; remoteHost->h_addr_list[i] != 0; ++i) {
        struct in_addr address;
        memcpy(&address, remoteHost->h_addr_list[i], sizeof(struct in_addr));
        std::cout << "  " << inet_ntoa(address) << std::endl;
    }

    // Print aliases
    std::cout << "Aliases:" << std::endl;
    for (int i = 0; remoteHost->h_aliases[i] != NULL; ++i) {
        std::cout << "  " << remoteHost->h_aliases[i] << std::endl;
    }

    WSACleanup();
    return 0;
}