MSDN - Windows API (Win32)

Developer Documentation and Tutorials

Networking Tutorials

This section provides comprehensive tutorials for developing network-aware applications using the Windows API (Win32). Master the fundamentals and advanced techniques of network programming on Windows.

Getting Started with WinSock

Learn the basics of the Windows Sockets API (WinSock), the standard interface for network programming on Windows. This tutorial covers essential concepts like socket creation, binding, listening, and connecting.

Building TCP/IP Applications

Dive deeper into developing reliable, connection-oriented applications using TCP/IP. Explore data transmission, error handling, and stream-based communication.

Working with UDP

Understand connectionless datagram communication with UDP. This section covers sending and receiving datagrams, broadcasting, and scenarios where UDP is the preferred protocol.

Advanced Networking Concepts

Explore more complex networking topics, including non-blocking sockets, asynchronous I/O, multithreading for network applications, and network protocols.

1. Introduction to WinSock

The Windows Sockets API (WinSock) is a set of programming interfaces that allows applications to communicate over a network. It's based on the Berkeley Sockets API and provides a standardized way to interact with network protocols like TCP/IP.

2. Creating and Closing Sockets

A socket is an endpoint for communication. You create a socket using the socket() function. The parameters specify the address family (e.g., AF_INET for IPv4), socket type (e.g., SOCK_STREAM for TCP, SOCK_DGRAM for UDP), and protocol.


#include <winsock2.h>

// ...

SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock == INVALID_SOCKET) {
    // Handle error
    WSAGetLastError();
}

// To close a socket
closesocket(sock);

3. Understanding Address Structures (SOCKADDR_IN)

Network addresses are represented by structures. For IPv4, SOCKADDR_IN is used, containing the address family, port number, and IP address.


#include <winsock2.h>
#include <ws2ipdef.h> // For INADDR_ANY

SOCKADDR_IN serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(8080); // Port number (e.g., 8080)
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); // Listen on any interface

htons() and htonl() are used for byte order conversion (host to network short/long).

4. Binding and Listening for Connections

For a server, you need to bind a socket to a local address and port, then listen for incoming connections.


// Assume 'sock' is a created socket and 'serverAddr' is configured
if (bind(sock, (SOCKADDR*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
    // Handle error
}

if (listen(sock, SOMAXCONN) == SOCKET_ERROR) {
    // Handle error
}

5. Accepting Client Connections

Once a server is listening, it can accept incoming client connections using the accept() function. This creates a new socket for communication with the specific client.


SOCKADDR_IN clientAddr;
int clientAddrSize = sizeof(clientAddr);
SOCKET clientSock = accept(sock, (SOCKADDR*)&clientAddr, &clientAddrSize);
if (clientSock == INVALID_SOCKET) {
    // Handle error
}
// Use clientSock to communicate with the client

6. Connecting to a Server

A client application connects to a server using the connect() function, providing the server's address and port.


// Assume 'clientSock' is a created socket
SOCKADDR_IN serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(8080);
// Convert IP string to network address (e.g., "192.168.1.100")
InetPton(AF_INET, _T("192.168.1.100"), &serverAddr.sin_addr);

if (connect(clientSock, (SOCKADDR*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
    // Handle error
}

Building a Simple TCP Server

Combine the concepts above to create a basic TCP server that accepts connections and echoes received data back to the client.

Building a Simple TCP Client

Develop a client application that connects to a TCP server, sends data, and receives responses.

Sending and Receiving Data with TCP

Use send() and recv() (or sendto() and recvfrom() for UDP) to transfer data over the network.


char buffer[1024];
int bytesSent = send(clientSock, "Hello, server!", 14, 0);
int bytesReceived = recv(clientSock, buffer, sizeof(buffer) - 1, 0);
if (bytesReceived > 0) {
    buffer[bytesReceived] = '\0'; // Null-terminate the received data
    // Process buffer
} else if (bytesReceived == 0) {
    // Connection closed by peer
} else {
    // Handle error
}

TCP Error Handling and Robustness

Implement error checking for all WinSock calls and handle network disruptions gracefully.

UDP Fundamentals

UDP is a connectionless protocol. It's faster but less reliable than TCP. Data is sent in packets (datagrams).

Sending UDP Datagrams

Use sendto() to send UDP datagrams to a specific destination address.

Receiving UDP Datagrams

Use recvfrom() to receive UDP datagrams, which also returns the sender's address.

Using UDP Broadcast

Send UDP packets to all hosts on a network segment.

Non-Blocking Sockets

Configure sockets to operate in non-blocking mode, allowing your application to perform other tasks while waiting for network operations to complete.

Asynchronous I/O with I/O Completion Ports (IOCP)

Leverage IOCP for high-performance asynchronous I/O, essential for scalable server applications.

Multithreaded Network Servers

Design network servers that use multiple threads to handle client connections concurrently, improving responsiveness.

Understanding Common Network Protocols

Gain insights into HTTP, FTP, DNS, and other protocols commonly used over TCP/IP.

Introduction to IPv6 Support in WinSock

Learn how to adapt your applications for IPv6, the next generation of Internet Protocol.