Creating a TCP server is a great way to dive into socket programming and understand how servers handle client connections. In this project, I built a basic TCP server in C, organized the code into multiple files, and used CMake as the build system. Here’s a walkthrough of the setup, structure, and key functions of the server.
<a href="https://github.com/dexter-xD/tcp_server_c.git" target="_blank" rel="noopener nofollow">Check out the GitHub repo</a>
<h4>Project Overview</h4>
The server is designed to:
<ol>
<li>Initialize a TCP socket on port 8080.</li>
<li>Bind to the port and start listening for client connections.</li>
<li>Accept client connections and print received data to the console.</li>
</ol>
This is a fundamental example, but it’s a useful building block for larger networking applications.
<h4>Project Structure</h4>
The code is modular, which keeps it organized and easy to maintain. Here’s the directory structure:
<pre><code>project/
├── CMakeLists.txt # Build configuration file
├── include/
│ ├── server.h # Header file for main server functions
│ └── socket_utils.h # Header for socket utility functions
├── src/
│ ├── server.c # Main server code
│ └── socket_utils.c # Socket utilities (initialize, bind, read)
└── README.md # Project documentation
</code></pre>
<h4>Key Components</h4>
<ol>
<li><code>server.c</code>: Contains the main server logic. It uses utility functions for setting up and handling the server.</li>
<li><code>socket_utils.c</code>: Provides helper functions like <code>initialize_server()</code> for setting up the server socket and <code>read_client_data()</code> to handle incoming messages.</li>
<li><code>CMakeLists.txt</code>: Configures CMake to compile the project, ensuring that all files are correctly linked and organized.</li>
</ol>
<h4>Core Functions</h4>
The two key functions here are:
<ul>
<li><code>initialize_server(struct sockaddr_in* address)</code>: Initializes and binds the server socket to port 8080.</li>
<li><code>read_client_data(int socket, char* buffer)</code>: Reads and displays data from a connected client in a loop.</li>
</ul>
<h4>Building and Running the Server</h4>
To build the server, simply clone the repository, navigate to the <code>build</code> directory, and run:
<pre><code class="language-bash">cmake ..
make
</code></pre>
Run the server with:
<pre><code class="language-bash">./bin/server
</code></pre>
The server will begin listening on port 8080 and will print any data received from clients. This modular setup makes it easy to expand by adding more features, such as handling multiple clients or adding error handling.
<h4>Why Use CMake and a Modular Structure?</h4>
Using CMake streamlines the build process, particularly for larger projects. By breaking down the code into modules, each component can be easily modified or extended without affecting the entire codebase. This setup is ideal for anyone looking to build scalable C applications.
<hr>
This project provides a strong foundation for socket programming in C. With this modular setup, you can dive deeper into network programming by adding features like concurrency, advanced error handling, and more sophisticated client-server interactions.

This is the place to discuss everything about C/C++ and Assembly —from basic programming concepts to advanced topics like memory management, concurrency, and performance optimization. Share knowledge, ask questions, and collaborate with developers.

C/C++ Community

Building a simple TCP server in C helps to understand socket programming and server-client connections. This project initializes a TCP socket on port 8080, binds and listens for client connections, and prints received data. The project uses a modular structure with CMake as the build system, including organized files for server logic and socket utilities. The setup allows easy extension and modification of components for scalable network applications.

Building a Simple TCP Server in C

Where do learn these stuffs from?
It would be nice if you share