TCP client-server programming in C is a critical skill for systems developers, backend engineers, and anyone dealing with low-level networking. It’s the foundation of everything from chat servers and IoT systems to custom network daemons.
This guide will take you from basic theory to a multithreaded TCP server, explaining every step in between.
What is TCP Client-Server Programming?
In TCP client-server architecture, one program (server) waits for connections, and others (clients) initiate communication.
- TCP ensures reliable, ordered delivery of data.
- Server runs continuously, listens on a port.
- Client connects to the server, sends and receives data.
This is connection-oriented programming—both sides perform a “handshake” to establish a session.
Understanding TCP/IP and Sockets
Before writing code, let’s understand what happens under the hood.
| Layer | Protocol | Purpose |
| Application | HTTP, FTP, Custom | You write this! |
| Transport | TCP | Reliable byte stream |
| Network | IP | Routing and addressing |
| Link | Ethernet, Wi-Fi | Hardware transmission |
Sockets are programming abstractions to communicate between these layers.
In C, we use system calls like:
- socket(): create a socket
- bind(): assign IP/port
- listen(): wait for connections
- accept(): accept a connection
- connect(): client connects to server
- send()/recv() or read()/write(): data exchange
ALSO READ:
Socket API in C (Cheat Sheet)
| Function | Role |
| socket() | Create socket |
| bind() | Bind socket to IP/port |
| listen() | Listen for incoming connections |
| accept() | Accept a new client |
| connect() | Initiate a connection |
| send()/recv() | Send/receive data |
| close() | Close socket |
All of them return -1 on failure and set errno.
Simple TCP Server Code
// tcp_server.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 9090
#define BUFFER_SIZE 1024
int main() {
int server_fd, new_socket;
struct sockaddr_in address;
char buffer[BUFFER_SIZE] = {0};
int opt = 1;
socklen_t addrlen = sizeof(address);
// 1. Create socket
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}
// 2. Set socket options (optional but recommended)
setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
// 3. Bind
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
bind(server_fd, (struct sockaddr *)&address, sizeof(address));
// 4. Listen
listen(server_fd, 5);
printf("Server is listening on port %d...\n", PORT);
// 5. Accept
new_socket = accept(server_fd, (struct sockaddr *)&address, &addrlen);
read(new_socket, buffer, BUFFER_SIZE);
printf("Client says: %s\n", buffer);
// 6. Reply
send(new_socket, "Welcome to the server!", 23, 0);
// 7. Close
close(new_socket);
close(server_fd);
return 0;
}
Simple TCP Client Code
// tcp_client.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 9090
int main() {
int sock;
struct sockaddr_in serv_addr;
char buffer[1024] = {0};
char *msg = "Hello, Server!";
sock = socket(AF_INET, SOCK_STREAM, 0);
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
send(sock, msg, strlen(msg), 0);
read(sock, buffer, 1024);
printf("Server reply: %s\n", buffer);
close(sock);
return 0;
}
How to Compile and Run
gcc tcp_server.c -o server
gcc tcp_client.c -o client
Open two terminals and run the following commands:
- Run the server: ./server
- Run the client: ./client
Handling Multiple Clients with Threads
Let’s make it a true server that can handle many clients simultaneously using POSIX threads.
// multi_server.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <arpa/inet.h>
#define PORT 9090
void* handle_client(void* socket_desc) {
int sock = *(int*)socket_desc;
char buffer[1024];
read(sock, buffer, 1024);
printf("Client: %s\n", buffer);
send(sock, "Response from threaded server", 30, 0);
close(sock);
free(socket_desc);
return NULL;
}
int main() {
int server_fd, new_socket;
struct sockaddr_in address;
socklen_t addrlen = sizeof(address);
server_fd = socket(AF_INET, SOCK_STREAM, 0);
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
bind(server_fd, (struct sockaddr*)&address, sizeof(address));
listen(server_fd, 10);
printf("Threaded server listening on port %d...\n", PORT);
while (1) {
new_socket = accept(server_fd, (struct sockaddr*)&address, &addrlen);
int *new_sock = malloc(sizeof(int));
*new_sock = new_socket;
pthread_t thread_id;
pthread_create(&thread_id, NULL, handle_client, (void*)new_sock);
pthread_detach(thread_id); // auto-free thread
}
close(server_fd);
return 0;
}
Best Practices & Error Handling
- Always check return values of socket functions.
- Use perror() or strerror(errno) for diagnostics.
- Use setsockopt() to avoid “address already in use” errors.
- Gracefully close sockets using shutdown() + close().
Real-World Applications
| Use Case | How |
| Chat apps | Socket server with message loop |
| IoT gateway | Clients are sensors reporting data |
| Multiplayer games | Game loop over TCP |
| Remote shells | Use bidirectional send/recv |
| File transfer tools | Read and write byte streams |
Conclusion
You’ve just completed the ultimate guide to TCP client-server programming in C. From theory to a real-world multithreaded server, you’ve seen how TCP sockets are used to build reliable communication systems.
Now It’s Your Turn:
- Modify the client to send user input
- Make the server broadcast to all connected clients
- Add logging, message timestamps, and authentication
