How to Compress Files in Linux Using tar Command

The term daemon comes from a word in ancient Greek mythology that referred to an immaterial being influencing the human world. In computing, especially in UNIX-like operating systems, a daemon is a background process that runs without direct interaction from the user. It doesn’t depend on a terminal or user interface and typically starts with the system boot or under specific conditions. What is a Daemon The main function of a daemon is to provide specific services to other processes or users. For example, a daemon might listen on network ports waiting for connections, monitor system events and respond when certain conditions are met, manage scheduled jobs (like cron), send emails (sendmail), and more. In Windows, the closest equivalent to a daemon is a service. The difference lies mainly in how they're started, registered, managed, and configured within operating systems. However, their purpose is the same: to ensure continuous background operation of certain functions or services. Key Characteristics of a Daemon Runs in the background: Users typically don’t see the daemon’s interface; it doesn’t write to standard output (or redirect it to logs), nor does it request keyboard input. Autonomous: A daemon starts either at system boot when triggered by an init system (like systemd), or manually by a user (via scripts, cron, etc.). Long-lived: Ideally, a daemon runs indefinitely unless a critical error occurs or it receives an explicit stop signal. Isolated: Usually runs under a separate user/group account to minimize privileges, making services more secure and easier to manage. Logging: Instead of using standard input/output, daemons log information to log files or the system logger (journald, syslog, etc.), which is helpful for debugging and diagnostics. Daemons in Linux Historically, nearly all system background tasks in Linux are implemented as daemons. The OS includes dozens of them, each responsible for a specific function. Here are some examples: sshd (Secure Shell Daemon): Listens on port 22 (by default) and allows remote users to connect via encrypted SSH. Without sshd, remote terminal access is almost impossible. cron: A job scheduler daemon. It checks crontab entries and runs scripts or commands on a schedule, such as log cleanup, sending reports, system checks, etc. syslogd / rsyslog / journald: System logging daemons that collect messages from the kernel, utilities, other daemons, and apps, and save them in log files or the journal. NetworkManager or Wicd: Daemons that manage network settings — automating connections to wired/wireless networks, switching, configuring VPNs, and more. These daemons start at system boot and are registered with the system service manager (e.g., systemd). They run until the system is shut down or rebooted. Users interact with them indirectly — through config files, terminal commands (service, systemctl), or network requests (if the daemon provides HTTP/S, SSH, or another network interface). How to Create and Manage Daemons To implement a daemon, follow these steps: Forking the process: The parent process calls fork() and continues running the daemon code in the child process. Detach from controlling terminal (setsid): To avoid user interference (e.g., closing the terminal), the daemon calls setsid() to start a new session and become its leader. Close standard input/output descriptors: Since the daemon shouldn't write to the screen or wait for input, stdin, stdout, and stderr are closed or redirected to log files. Handle signals and logging: To support graceful shutdown or config reloads, the daemon must handle signals (SIGTERM, SIGHUP, etc.). Logging is usually done via syslog or files. Main loop:  After initialization, the daemon enters its main loop: waiting for events, handling them, and repeating until stopped. Let’s see how to create a daemon on Ubuntu 22.04 using a Hostman cloud server 1. Write the Daemon in C Create a file called mydaemon.c and insert the following code: #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <syslog.h> int main() { // Open syslog openlog("mydaemon", LOG_PID, LOG_DAEMON); syslog(LOG_NOTICE, "Daemon started"); // Main infinite loop while (1) { // Your background tasks: monitoring, queue handling, etc. syslog(LOG_NOTICE, "Performing task..."); sleep(60); } // If we ever exit the loop syslog(LOG_NOTICE, "Daemon stopped"); closelog(); return 0; } 2. Compile the Program First, update your packages: sudo apt update && sudo apt upgrade Install the GCC compiler if not already installed: sudo apt install gcc Compile the daemon: gcc mydaemon.c -o mydaemon 3. Move the Executable Move the binary to /usr/local/bin/, a standard location for custom utilities: mv mydaemon /usr/local/bin/mydaemon 4. Create a systemd Service Create a unit file called mydaemon.service: sudo nano /etc/systemd/system/mydaemon.service Insert the following content: [Unit] Description=My Daemon After=network.target [Service] Type=simple ExecStart=/usr/local/bin/mydaemon Restart=on-failure [Install] WantedBy=multi-user.target Explanation of the fields: Description: Description shown in systemctl status. After=network.target: Ensures the daemon starts after the network is up. Type=simple: The daemon doesn’t fork, it runs as a single process. ExecStart: Path to the daemon executable. Restart=on-failure: Restart automatically if the daemon crashes. WantedBy=multi-user.target: Makes the service start in the standard multi-user environment. 5. Start and Monitor the Daemon sudo systemctl daemon-reload # Reload systemd configuration sudo systemctl start mydaemon # Start the daemon sudo systemctl status mydaemon # Check its status If everything works, the status will show active. To view logs: journalctl -u mydaemon.service -e Examples of Daemon Usage Web Servers Their job is to listen on a network port (usually 80 or 443), accept HTTP/HTTPS requests, generate a response (an HTML page, JSON data, etc.), and send the result back to the client. In most cases, a web server starts with the system and continues running until the server is shut down or a stop command is issued (e.g., systemctl stop nginx). Database Daemons MySQL/MariaDB, PostgreSQL, MongoDB — all of these are also daemons. They start with the system and continue running in the background, accepting requests from client applications or web services. These daemons typically log activity, support configuration via files, and are managed using special utilities (or systemd). Job Schedulers (cron, atd) The cron daemon checks the schedule table (crontab) and runs programs at the times or intervals specified by the user. This makes it possible to automate backups, system updates, health checks, and many other routine tasks. atd is a similar daemon but executes tasks only once at a specific time (unlike cron, which runs tasks on a regular schedule). Access and Control Services (sshd, xrdp) sshd (Secure Shell Daemon) provides remote access via the SSH protocol. xrdp enables remote desktop connections using the RDP protocol. It acts as a daemon that listens for network connections on a specified port. Init System Daemons (systemd, init, Upstart) In modern systems, the role of the "main daemon" is fulfilled by systemd (replacing the older SysV init system). systemd is the first process to start after the kernel and is responsible for launching and managing all other services and processes. It starts them in parallel and handles their dependencies. Simply put, systemd is itself a daemon that “orchestrates” all others in the system. Advantages and Disadvantages of Daemons Advantages: Automation: Daemons enable system behavior to be automated — from responding to network requests to scheduling tasks — without user intervention. Isolation: Running under separate user/group accounts and detaching from terminals enhances security by limiting potential damage in case of compromise. Continuous Operation: A daemon can keep servicing requests (like a web server) without interruption even if the user logs out or the console is closed. Manageability: Linux provides system tools (e.g., systemd, init scripts) to centrally manage all daemons: starting, stopping, restarting, and logging. Disadvantages: Debugging Complexity: Since daemons run in the background and don’t output to the console, debugging requires thorough logging and more complex setups (debug flags, tracing, etc.). Security Risks: If a daemon runs with elevated privileges (e.g., as root), any vulnerability can potentially compromise the entire system. It's best to run daemons under limited accounts. Dependency Management: Some daemons may fail if, for example, they need network access before the network is up. Modern init systems solve this, but with classic SysV init scripts, this used to be a common issue. Increased Resource Usage: Any constantly running background process consumes system resources (memory, CPU time). If there are too many daemons, this can impact performance, especially on systems with limited resources. Conclusion Daemons are central to Linux operating systems' architecture, offering vast automation and background services capabilities. They allow administrators to flexibly configure network operations, scheduled tasks, logging, security systems, and many other components. Writing your own daemon requires understanding processes, signals, system calls, and careful attention to logging and security. Modern init systems (especially systemd) have simplified daemon management and service logic, making the creation of custom services more structured and flexible. However, it remains a complex field that demands careful design, debugging, and ongoing maintenance.

A personal DNS server can be useful if your provider doesn't offer this service or if existing solutions don't suit your needs. The easiest way to set one up is via a control panel (cPanel, CloudPanel, HestiaCP, etc), but you can also do it manually using the terminal and the Linux DNS Server BIND 9. Preparing the Server Let's say you've rented a Hostman Linux VPS and want to use your own DNS servers. To do that, you need to meet two conditions: Order another public IP address — DNS setup requires at least two IPs. Open DNS port 53, which is necessary for the nameserver to work. Ubuntu/Debian Update the package list: apt update Allow incoming packets on port 53 UDP in the firewall: iptables -I INPUT -p udp --dport 53 -j ACCEPT Save the firewall rules: iptables-save CentOS Install system updates: yum update Install time synchronization utility: yum install chrony Set your timezone, for example: timedatectl set-timezone Europe/Cyprus Enable and start the time synchronization service: systemctl enable chronyd --now Open port 53: firewall-cmd --permanent --add-port=53/udp Apply the updated firewall rules: firewall-cmd --reload Installing the DNS Server This guide uses BIND 9 to create an IP-based DNS server. Ubuntu/Debian Install required packages: apt-get install bind9 dnsutils Enable autostart: systemctl enable bind9 Start the service: systemctl start bind9 Check if it's running: systemctl status bind9 Look for active status in the output. CentOS Install the DNS utility: yum install bind Enable autostart: systemctl enable named Start the service: systemctl start named Check its status: systemctl status named You should see active in the output. Basic DNS Server Configuration The settings are defined in the configuration file. Ubuntu/Debian Open the config file: vi /etc/bind/named.conf.options In the listen-on block, specify the networks, e.g.: listen-on { 10.10.10.0/24; 10.1.0.0/16; }; To allow the DNS server to listen on all interfaces, either omit this line or use any. In the allow-query line, specify who can make queries: allow-query { any; }; Restart the service for changes to take effect: systemctl restart bind9 CentOS Open the config file: vi /etc/named.conf Find these lines: listen-on port 53 { 127.0.0.1; localhost; 192.172.160.14; }; ... allow-query { any; }; In the listen-on line, after localhost, specify the DNS IP address. This is the IP on which the host will accept queries. Use any to listen on all addresses. In the allow-query line, define query permissions. any allows queries from everyone. You can also restrict it to a specific subnet, e.g., 192.172.160.0/24. Apply the config: systemctl restart named Global Options Besides the basics, you can fine-tune the server using other global parameters: Argument What It Configures directory Working directory (default is /var/named if not specified) forwarders IPs to forward unresolved queries to (e.g., Google's DNS) forwarders { 8.8.8.8; 8.8.4.4; }; forward Options: FIRST or ONLY. FIRST tries forwarders first, then internal. ONLY skips internal search. listen-on Interfaces that BIND listens on (usually port 53 UDP) allow-transfer Hosts allowed for zone transfers allow-query Who is allowed to send DNS queries allow-notify Hosts allowed to receive zone change notifications allow-recursion Hosts that can make recursive queries. Default is unrestricted. Testing To check if the DNS server accepts queries from clients, use the nslookup utility. From another computer: nslookup site-example.com 192.172.160.14 This checks the IP address of site-example.com using DNS server 192.172.160.14. Alternatively, use dig: dig @192.172.160.14 site-example.com It works similarly, just a different syntax. BIND Zones Basic DNS server setup is complete. Now, let’s talk about usage. For that, you configure zones: Primary zone – You create and edit domain records directly on this host. Secondary zone – This host pulls data from a primary DNS server. Stub zone – Stores only NS records used for redirection. Caching-only zone – Doesn’t store records; only caches query results for performance. Zone management is handled in the config file and is a larger topic. Creating your own zone lets you assign friendly names to each host, which is helpful when dealing with many nodes instead of using IPs.

One of the key principles of the UNIX philosophy is that all command-line interface (CLI) commands should accept text as input and produce text as output. Since this concept was applied in the development of UNIX (and later Linux), there are commands to receive text as input, perform an operation on it, and then produce text as output. Commands that read text input, modify it in some way, and then produce text output are sometimes called filters. To use filter commands and work with text streams effectively, we should understand several types of redirection available with most commands: pipelines, standard output redirection, error output redirection, and input redirection. Standard Output When a command executes without errors, the resulting output is called standard output, also known as STDOUT. By default, this output is sent to the terminal where the command is run. We can redirect standard output from the command so it goes to a file instead of the terminal using the greater-than symbol (>) followed by the target file. For example, the command ls ~ lists files in the home directory. To save this list to a text file: ls ~ > /tmp/home.txt The contents of home.txt would then look like this: cat /tmp/home.txt Desktop Documents Downloads Music Pictures Public Templates Videos Using a single > creates a new file or overwrites an existing one. Using two greater-than symbols >> also creates a file if it doesn't exist but appends output to the end if the file already exists. For example, to append the output of the date command: date >> /tmp/home.txt    cat /tmp/home.txt Desktop Documents Downloads Music Pictures Public Templates Videos Sun Mar 30 07:36:02 UTC 2025 Standard Error In Linux, when a command encounters an error, it produces output known as standard error, also called stderr or STDERR. Like standard output, it is usually sent to the same terminal. The file descriptor number for standard error is 2. For example, trying to run: ls /junk Will produce: ls: cannot access /junk: No such file or directory Since this output goes to stderr, using just > won't redirect it: ls /junk > output ls: cannot access /junk: No such file or directory To redirect error messages, use the correct file descriptor: ls /junk 2> /tmp/ls.err Like with standard output, > will create or overwrite the file. To append to the error log instead: ls /junk 2>> /tmp/ls.err Some commands produce both stdout and stderr. For example: find /etc -name passwd /etc/pam.d/passwd /etc/passwd find: '/etc/ssl/private': Permission denied You can redirect these into two separate files: find /etc -name passwd > /tmp/output.txt 2> /tmp/error.txt To verify: cat /tmp/output.txt /etc/pam.d/passwd/etc/passwd cat /tmp/error.txt find: '/etc/ssl/private': Permission denied If you don't want to display or save error messages, redirect them to /dev/null. This file acts like a trash bin where all input disappears. Any output type can be redirected there, most commonly stderr: find /etc -name passw 2> /dev/null /etc/pam.d/passwd /etc/passwd Combining Standard Output and Error To redirect both stdout and stderr into a single file, use either of the following methods: ls > /tmp/ls.all 2>&1 ls &> /tmp/ls.all Both commands create the file /tmp/ls.all containing both standard output and error messages. In the first command, 2>&1 means "send stderr to the same place as stdout." The second uses &> as shorthand for "redirect all output." Standard Input Standard input, also known as stdin or STDIN, typically comes from the keyboard and is entered by the user running the command. While most commands can read input from files, some expect the user to type input manually using the keyboard. One common way to use text files as standard input is by creating script files. Scripts are simple text files that are interpreted by the shell when given the appropriate permissions and start with #!/bin/sh in the first line, which tells the shell to interpret the script as standard input: cat examplescriptfile.sh #!/bin/sh echo HelloWorld When a script file is called in the command line using the ./ syntax, the shell executes all commands in the script file and returns the result to the terminal window or wherever the output is directed: ./examplescriptfile.sh HelloWorld In some cases, it’s useful to redirect standard input so that it comes from a file instead of the keyboard. A good example where input redirection is desirable is the tr command. The tr command translates characters by reading from standard input, converting one set of characters to another, and writing the transformed text to standard output. For example, the following tr command takes input from the user (via keyboard) to convert all lowercase letters to uppercase: tr 'a-z' 'A-Z' hello HELLO The tr command will not stop reading from standard input unless it is terminated. You can do this by pressing Ctrl+D. The tr command does not accept a filename as a command-line argument. To perform translation using a file as input, use input redirection. To do this, enter the command with its parameters and arguments, followed by the less-than symbol < and the file path to be used for input. For example: cat Documents/animals.txt 1 retriever 2 badger 3 bat 4 wolf 5 eagle tr 'a-z' 'A-Z' < Documents/animals.txt 1 RETRIEVER 2 BADGER 3 BAT 4 WOLF 5 EAGLE Command Pipelines Command pipelines are often used to efficiently apply filter commands. In a command pipeline, the output of one command is sent to another command as input. In Linux and most operating systems, the vertical bar | represents a pipeline between two commands. For example, if the output of the history command is very long, you can send it to the less command to display one page at a time: history | less An even better example is taking the output of history and filtering it using the grep command. In the following example, the text output from history is redirected to grep as input. The grep command matches lines containing "ls" and sends the result to standard output: history | grep "ls" 1 ls ~ > /tmp/home.txt 5 ls l> /tmp/ls.txt 6 ls 1> /tmp/ls.txt 7 date 1>> /tmp/ls.txt 8 ls /junk 9 ls /junk > output 10 ls /junk 2> /tmp/ls.err 11 ls /junk 2>> /tmp/ls.err 14 ls > /tmp/ls.all 2>&1 15 ls &> /tmp/ls.all 16 ls /etc/au* >> /tmp/ls.all 2>&1 17 ls /etc/au* &>> /tmp.ls.all 20 history | grep "ls" Command pipelines become especially powerful when combining three or more commands. For example, view the contents of the os.csv file in the Documents directory: cat Documents/os.csv 1970,Unix,Richie 1987,Minix,Tanenbaum 1970,Unix,Thompson 1991,Linux,Torvalds The following command line extracts some fields from os.csv using the cut command, then sorts those lines using sort, and finally removes duplicates using uniq: cut -f1 -d',' Documents/os.csv | sort -n | uniq 1970 1987 1991 The tee Command The tee command splits the output of a command into two streams: one is directed to standard output (displayed in the terminal), and the other is written to a file. The tee command is useful for logging the output of a command or script. For example, to record the execution time of a process, start with the date command and copy the output to a file timer.txt: date | tee timer.txt Tue Apr 2 02:21:24 UTC 2025 The timer.txt file now contains a copy of the date, the same output as shown above: cat timer.txt Tue Apr 2 02:21:24 UTC 2025 To append the time to the end of timer.txt, use the -a option: date | tee -a timer.txt Tue Apr 2 02:28:43 UTC 2025 To run multiple commands as one line, use the semicolon ; as a separator: date | tee timer.txt; sleep 15; date | tee -a timer.txt Tue Apr 2 02:35:47 UTC 2025 Tue Apr 2 02:36:02 UTC 2025 The command above displays and writes the first date output, pauses for 15 seconds, then displays and writes the second date output. The timer.txt file now contains a persistent execution log. The xargs Command Command options and parameters are typically specified directly in the command line as arguments. Alternatively, you can use the Linux xargs command to collect arguments from another input source (such as a file or standard input) and pass them to a command. xargs can be called directly and will accept any input: xargs Hello There To exit xargs, press Ctrl+C. By default, xargs passes input to the echo command if no other command is explicitly given. After pressing Ctrl+D, xargs sends the input to echo: Pressing Ctrl+D after exiting xargs with Ctrl+C will also exit the current shell. To send input to echo without exiting the shell, press Ctrl+D during xargs execution. The Linux xargs command is most useful when used in a pipeline. The following example uses the touch command to create four files. The file names are 1a, 1b, 1c, and 1d, based on the output from the echo command: echo '1a 1b 1c 1d' | xargs touch ls 1a 1c Desktop Downloads Pictures Templates timer.txt 1b 1d Documents Music Public Videos Conclusion We’ve reviewed input/output stream redirection in Linux: standard output redirection, error output redirection, input redirection, and pipelines. Understanding these capabilities makes working with bash scripts easier and helps efficiently administer servers running Linux-based operating systems.