1.

Include Header Files

#include <stdio.h>

#include <stdlib.h>

#include <winsock2.h>

#include <windows.h>

• #include <stdio.h>: Includes standard input/output functions.

• #include <stdlib.h>: Includes standard library functions like exit.

• #include <winsock2.h>: Includes the Winsock library for network programming on

• #include <windows.h>: Includes Windows API functions.

2. Link to Winsock Library

#pragma comment(lib, "ws2_32.lib") // Winsock Library

• This line tells the compiler to link against the ws2_32.lib, which is the library needed for
using Winsock functions.

3. Function Declarations

void handle_client(SOCKET client_socket);

• Declares a function handle_client that takes a SOCKET type parameter, which will be
used to communicate with a connected client.

4. Client Thread Function

DWORD WINAPI ClientThread(LPVOID lpParam) {

SOCKET client_socket = (SOCKET)(intptr_t)lpParam; // Cast the parameter back to SOCKET

handle_client(client_socket);

return 0;

• DWORD WINAPI ClientThread(LPVOID lpParam): This defines a thread function that will
handle client connections.

o Parameters:

▪ LPVOID lpParam: A generic pointer that can hold any type of data. Here,
it is expected to be a SOCKET.
 o The function casts lpParam back to a SOCKET and calls handle_client to process
the client.

o Returns 0 to indicate successful completion.

5. Main Function

int main() {

• The entry point of the program.

6. Winsock Initialization

WSADATA wsa;

• A structure that holds information about the Winsock implementation.

if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {

• Initializes the Winsock DLL.

o MAKEWORD(2, 2): Specifies the version of Winsock to be used (2.2).

o &wsa: A pointer to a WSADATA structure that receives information about the

• If initialization fails, it prints an error and exits.

7. Create a Socket

SOCKET server_socket, client_socket;

• Declares two socket variables: server_socket for listening for incoming connections and
client_socket for communication with a client.

if ((server_socket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {

• Creates a socket:

o AF_INET: Specifies IPv4 protocol.

o 0: The default protocol for TCP.

• Checks if the socket was created successfully.

8. Configure Server Address

struct sockaddr_in server_address, client_address;

• Defines structures for server and client addresses.

server_address.sin_family = AF_INET;

server_address.sin_addr.s_addr = INADDR_ANY;

server_address.sin_port = htons(3001);

• Configures the server address:

o sin_family: Address family (IPv4).

o sin_addr.s_addr: Set to INADDR_ANY to accept connections on any available

o sin_port: Port number (3001), converted to network byte order using htons().

9. Bind the Socket

if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) ==

• Binds the socket to the specified address and port.

o (struct sockaddr *)&server_address: Casts the server address to the correct

o sizeof(server_address): Size of the server address structure.

10. Listen for Incoming Connections

listen(server_socket, 3);
 • Puts the server socket in a listening state, allowing it to accept incoming connections.
The second parameter (3) is the maximum length of the queue of pending connections.

11. Accept Connections in a Loop

while (1) {

client_socket = accept(server_socket, (struct sockaddr *)&client_address,

• Enters an infinite loop to accept incoming client connections.

• accept() blocks until a client connects, returning a new socket (client_socket) for
communication with that client.

12. Create a New Thread for Each Client

hThread = CreateThread(NULL, 0, ClientThread, (LPVOID)(intptr_t)client_socket, 0, NULL);

• Creates a new thread for each client:

o NULL: Default security attributes.

o 0: Default stack size.

o ClientThread: Function to run in the new thread.

o (LPVOID)(intptr_t)client_socket: Casts the client_socket to LPVOID for passing

o 0: Default creation flags.

o NULL: No thread identifier is needed.

• If thread creation fails, it closes the client socket.

CloseHandle(hThread); // Close the thread handle in the parent thread

• Closes the thread handle in the parent (main) thread.

13. Close the Server Socket

closesocket(server_socket);
WSACleanup();

return 0;

• Closes the listening server socket and cleans up Winsock resources.

14. Handle Client Function

void handle_client(SOCKET client_socket) {

• Defines the function to handle communication with a connected client.

int num1, num2, result;

recv(client_socket, (char *)&num1, sizeof(num1), 0);

recv(client_socket, (char *)&num2, sizeof(num2), 0);

• Receives two integers from the client through the client_socket.

result = num1 + num2;

send(client_socket, (char *)&result, sizeof(result), 0);

• Calculates the sum of the two integers and sends the result back to the client.

closesocket(client_socket);

• Closes the client socket after the communication is done.

Summary

This server program uses a multithreaded approach to handle multiple client connections. It
initializes Winsock, creates a listening socket, accepts incoming connections in a loop, and
creates a new thread for each client to handle their requests independently. The
communication is done by sending and receiving integers, specifically summing two integers
sent by the client.