Daytime Client-Server Program In C: A Simple Guide

Let's dive into creating a daytime client-server program in C. This tutorial will guide you through the process step by step, making it easy to understand even if you're relatively new to network programming. The goal is to build a simple system where a client requests the current date and time from a server, and the server responds with the information. This is a classic example that illustrates basic client-server communication concepts, and it's super useful for understanding how networked applications work. So, grab your favorite text editor, and let's get started!

Understanding the Basics

Before we jump into the code, let's cover some fundamental concepts. The client-server model is the backbone of many networked applications. In this model, a server provides services, and clients request those services. Think of it like a restaurant: the restaurant (server) offers food, and you (the client) order what you want.

Sockets: At the heart of network communication are sockets. A socket is an endpoint for sending or receiving data across a network. In our program, we'll use sockets to establish connections between the client and the server. There are different types of sockets, but we'll focus on TCP (Transmission Control Protocol) sockets, which provide reliable, ordered, and error-checked delivery of data.

TCP/IP: TCP/IP is a suite of protocols that govern how data is transmitted over the internet. TCP ensures reliable communication by establishing a connection, guaranteeing that data packets arrive in the correct order, and re-transmitting lost packets. IP (Internet Protocol) handles the addressing and routing of data packets between different machines.

Ports: A port is a virtual point where network connections start and end. Think of it as a specific door in a building. Each service running on a server typically listens on a specific port. For example, HTTP (web) servers usually listen on port 80, and HTTPS (secure web) servers listen on port 443. For our daytime server, we'll use a port number greater than 1024 (as ports below 1024 are usually reserved for system services).

Server-Side Implementation

Let's start by building the server-side of our daytime program. The server will listen for incoming connections, accept a connection from a client, retrieve the current date and time, and send it back to the client.

Setting up the Server Socket

First, we need to create a socket. This involves specifying the address family (IPv4 or IPv6), the socket type (TCP), and the protocol (usually 0 for the default protocol associated with the socket type).

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 5000 // You can change this to any port > 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);

    // Creating socket file descriptor
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // Binding the socket to the specified address and port
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // Listening for incoming connections
    if (listen(server_fd, 3) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d\n", PORT);

    // Accepting a connection
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept failed");
        exit(EXIT_FAILURE);
    }

    // Rest of the server logic will be added here

    return 0;
}

Handling Client Requests

Once a client connects, the server needs to retrieve the current date and time and send it back. We'll use the time() and ctime() functions for this.

    // Inside the main function, after accepting the connection
    time_t rawtime;
    struct tm *timeinfo;
    char buffer[80];

    time(&rawtime);
    timeinfo = localtime(&rawtime);

    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", timeinfo);
    send(new_socket, buffer, strlen(buffer), 0);
    printf("Sent time: %s\n", buffer);

    close(new_socket);
    close(server_fd);

Complete Server Code

Here’s the complete server code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 5000

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    time_t rawtime;
    struct tm *timeinfo;
    char buffer[80];

    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    if (listen(server_fd, 3) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d\n", PORT);

    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept failed");
        exit(EXIT_FAILURE);
    }

    time(&rawtime);
    timeinfo = localtime(&rawtime);

    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", timeinfo);
    send(new_socket, buffer, strlen(buffer), 0);
    printf("Sent time: %s\n", buffer);

    close(new_socket);
    close(server_fd);

    return 0;
}

Client-Side Implementation

Now, let's create the client-side program. The client will connect to the server, receive the date and time, and display it to the user.

Setting up the Client Socket

Similar to the server, the client needs to create a socket and connect to the server.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 5000

int main() {
    int sock = 0, valread;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // Convert IPv4 and IPv6 addresses from text to binary form
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }

    // Connecting to the server
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nConnection Failed \n");
        return -1;
    }

    // Rest of the client logic will be added here

    return 0;
}

Receiving Data from the Server

After connecting, the client receives the date and time from the server and prints it.

| Read Also : Syracuse Basketball Tickets: Your Guide For Students

    // Inside the main function, after connecting to the server
    valread = read(sock, buffer, 1024);
    printf("Received: %s\n", buffer);

    close(sock);

Complete Client Code

Here’s the complete client code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 5000

int main() {
    int sock = 0, valread;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }

    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nConnection Failed \n");
        return -1;
    }

    valread = read(sock, buffer, 1024);
    printf("Received: %s\n", buffer);

    close(sock);

    return 0;
}

Compiling and Running the Code

To compile the server and client code, you can use a C compiler like GCC. Save the server code in a file named server.c and the client code in a file named client.c.

Compile the server:

gcc server.c -o server

Compile the client:

gcc client.c -o client

Run the server in one terminal:

./server

And run the client in another terminal:

./client

You should see the current date and time printed on the client side, received from the server. Congratulations, you've built a simple daytime client-server program in C! This foundational example can be expanded upon for more complex network applications. Experiment with different data formats, error handling, and more sophisticated client-server interactions to deepen your understanding.

Enhancements and Further Learning

Error Handling

Always include robust error handling in your code. Check the return values of system calls like socket, bind, listen, accept, connect, send, and recv. Use perror to print descriptive error messages. Proper error handling makes your programs more reliable and easier to debug.

Concurrency

The server we created can only handle one client at a time. To handle multiple clients concurrently, you can use techniques like threading or forking. Threading allows you to create multiple threads within the same process, each handling a different client. Forking creates a new process for each client. Both techniques enable the server to handle multiple clients simultaneously.

Data Serialization

For more complex data structures, consider using data serialization techniques like JSON or Protocol Buffers. These techniques allow you to convert complex data structures into a format that can be easily transmitted over the network and then reconstructed on the receiving end.

Security

Security is paramount in network programming. Use encryption techniques like SSL/TLS to protect data transmitted between the client and server. Validate and sanitize all input data to prevent vulnerabilities like injection attacks. Always follow security best practices to ensure the safety of your applications.

Conclusion

Creating a daytime client-server program in C is a fantastic way to understand the fundamentals of network programming. By setting up sockets, handling connections, and exchanging data, you gain practical experience with the client-server model. This simple example serves as a building block for more advanced networked applications. Keep experimenting, keep learning, and you'll be well on your way to mastering network programming. Good luck, and happy coding, guys!