WRITING A SERVICE IN C

Introduction to Writing a Service in C

Writing services that run as long-running background processes is a common task for many C/C++ programmers. These types of services, often referred to as daemons or servers, provide crucial functionality like monitoring systems, handling asynchronous I/O, or powering web, database, or other network services. In this article, we will discuss the key concepts and steps for writing a basic service application in C that can run as a daemon process.

Though there are many techniques and ways to approach writing service applications, we will focus on some basic best practices that are common across Unix-like environments like Linux and macOS. Our example service will listen for HTTP requests on port 8080 and simply return a basic “Hello World” response. While simple, it demonstrates the fundamental patterns needed to write services in C.

Daemon Fundamentals

The first thing to understand is what defines a process as a daemon or service. On Unix systems, daemons are background processes that are not associated with any user session or terminal. They typically start at boot and run continuously in the background handling tasks or requests asynchronously.

Some key characteristics of daemon processes include:

They run as non-interactive background processes that are detached from any controlling terminal.

They have no controlling tty or process group associations.

They run with specific user privileges like “daemon” or “ntp.”

They don’t have a command line interface and typically communicate via files, pipes, sockets or other IPC.

They detach themselves from the parent process and run independently.

They have logic to gracefully handle signals and shutdown.

A well-written daemon detaches itself from its parent process and any user session/terminal, has its own lifecycle handling, and communicates asynchronously via standard I/O mechanisms like files or sockets rather than direct user interaction.

Forking and Detaching
The first step is to detach the daemon process from its parent using the fork() system call. This creates a child process while the parent exits immediately. For our service, we want the child process to become a detached daemon process while the parent exists:

c
Copy
pid_t pid;

pid = fork();
if (pid < 0) { exit(EXIT_FAILURE); } // We got a good PID, exit parent if (pid > 0)
exit(EXIT_SUCCESS);

Now the child process needs to detach from the controlling terminal by changing its process group ID and session ID to orphan it from the parent:

c
Copy
// Further prepare the child
setsid();

// Ignore pipe signals
signal(SIGPIPE, SIG_IGN);

This essentially adopts the child process, making it official daemon that is detached and runs independently of any parent process or user session.

Setting File Permissions
Now that the daemon process is detached and independent, we need to change the file access permissions and redirection of standard streams. This helps ensure anything output by the daemon isn’t accessible at the terminal:

c
Copy
// Change the file mode
umask(0);

// Redirect standard streams to /dev/null
freopen(“/dev/null”, “r”, stdin);
freopen(“/dev/null”, “w”, stdout);
freopen(“/dev/null”, “w”, stderr);

By changing the file access mask and redirecting stdio, we prevent any files created or used by the daemon from being world writable and ensure any output is suppressed rather than going to the terminal.

Lifecycle Control with PID Files
For control and monitoring, daemons typically write their process IDs (PIDs) to a file in the filesystem. This allows checking if the service is running and sending it signals like restart from scripts or other utilities.

Our daemon will write its PID to “/var/run/daemon.pid”:

c
Copy
pid_t pid;

// Open pidfile
FILE *fp = fopen(“/var/run/daemon.pid”, “w”);
if (!fp) {
printf(“Unable to open pidfile”);
exit(1);
}

// Write the pid to pidfile
fprintf(fp, “%d”, getpid());
fclose(fp);

Later the PID can be obtained from this file and used to signal the daemon, check if it’s running, and perform cleanup on daemon shutdown.

Starting the Service Logic
Now that the basic daemon setup is complete, we can start the core service logic which for our example will be a simple HTTP server:

c
Copy
int port = 8080;

while(1) {

// Listen for incoming connections
int client = accept(server_fd, NULL, NULL);

if (client < 0) { perror("Accept failed"); continue; } // Handle new client connection handle_request(client); close(client); } Inside handle_request(), we would use functions like read(), write(), send(), recv() to receive and respond to client requests with a simple "Hello World". Handling Shutdown and Signals The last pieces are setting up signal handlers to gracefully shutdown the daemon: c Copy void handle_sigterm(int sig) { printf("Received SIGTERM, shutting down\n");

Now the service can be controlled and monitored using this start/stop script.

Summary
This covers the basic patterns, steps, and practices for writing a daemon or service application in C that can run independently as a long-running background process. Key aspects included detached forking, changing permissions, writing PID files, signal handling, and providing control scripts.

Of course, real-world daemon code involves much more – logging, configuration, multi-threading, access control, and other advanced techniques. But this provides a solid starting point and foundation for anyone looking to create a basic Linux service in C. With some tweaking, these techniques can be applied to build all sorts of system services and daemons.