Linux System Programming Techniques

By : Jack-Benny Persson

5 (1)

Buy this Book

Linux System Programming Techniques

5 (1)

By: Jack-Benny Persson

Buy this Book

Overview of this book

Linux is the world's most popular open source operating system (OS). Linux System Programming Techniques will enable you to extend the Linux OS with your own system programs and communicate with other programs on the system. The book begins by exploring the Linux filesystem, its basic commands, built-in manual pages, the GNU compiler collection (GCC), and Linux system calls. You'll then discover how to handle errors in your programs and will learn to catch errors and print relevant information about them. The book takes you through multiple recipes on how to read and write files on the system, using both streams and file descriptors. As you advance, you'll delve into forking, creating zombie processes, and daemons, along with recipes on how to handle daemons using systemd. After this, you'll find out how to create shared libraries and start exploring different types of interprocess communication (IPC). In the later chapters, recipes on how to write programs using POSIX threads and how to debug your programs using the GNU debugger (GDB) and Valgrind will also be covered. By the end of this Linux book, you will be able to develop your own system programs for Linux, including daemons, tools, clients, and filters.

Preface

Who this book is for

What this book covers

To get the most out of this book

Code in Action

Download the color images

Conventions used

Sections

Get in touch

Reviews

Chapter 1: Getting the Necessary Tools and Writing Our First Linux Programs

Technical requirements

Installing GCC and GNU Make

Installing GDB and Valgrind

Writing a simple C program for Linux

Writing a program that parses command-line options

Looking up information in the built-in manual page

Searching the manual for information

Free Chapter

Chapter 2: Making Your Programs Easy to Script

Technical requirements

Return values and how to read them

Exiting a program with a relevant return value

Redirecting stdin, stdout, and stderr

Connecting programs using pipes

Writing to stdout and stderr

Reading from stdin

Writing a pipe-friendly program

Redirecting the result to a file

Reading environment variables

Chapter 3: Diving Deep into C in Linux

Technical requirements

Linking against libraries using GCC

Changing C standards

Using system calls – and when not to use them

Getting information about Linux- and Unix-specific header files

Defining feature test macros

Looking at the four stages of compilation

Compiling with Make

Writing a generic Makefile with GCC options

Writing a simple Makefile

Writing a more advanced Makefile

Chapter 4: Handling Errors in Your Programs

Technical requirements

Why error handling is important in system programming

Handling some common errors

Error handling and errno

Handling more errno macros

Using errno with strerror()

Using errno with perror()

Returning an error value

Chapter 5: Working with File I/O and Filesystem Operations

Technical requirements

Reading inode information and learning the filesystem

Creating soft links and hard links

Creating files and updating the timestamp

Deleting files

Getting access rights and ownership

Setting access rights and ownership

Writing to files with file descriptors

Reading from files with file descriptors

Writing to files with streams

Reading from files with streams

Reading and writing binary data with streams

Moving around inside a file with lseek()

Moving around inside a file with fseek()

Chapter 6: Spawning Processes and Using Job Control

Technical requirements

Exploring how processes are created

Using job control in Bash

Controlling and terminating processes using signals

Replacing the program in a process with execl()

Forking a process

Executing a new program in a forked process

Starting a new process with system()

Creating a zombie process

Learning about what orphans are

Creating a daemon

Implementing a signal handler

Chapter 7: Using systemd to Handle Your Daemons

Technical requirements

Getting to know systemd

Writing a unit file for a daemon

Enabling and disabling a service – and starting and stopping it

Creating a more modern daemon for systemd

Making the new daemon a systemd service

Reading the journal

Chapter 8: Creating Shared Libraries

Technical requirements

The what and why of libraries

Creating a static library

Using a static library

Creating a dynamic library

Installing the dynamic library on the system

Using the dynamic library in a program

Compiling a statically linked program

Chapter 9: Terminal I/O and Changing Terminal Behavior

Technical requirements

Viewing terminal information

Changing terminal settings with stty

Investigating TTYs and PTYs and writing to them

Checking if it's a TTY

Creating a PTY

Disabling echo for password prompts

Reading the terminal size

Chapter 10: Using Different Kinds of IPC

Technical requirements

Using signals for IPC – building a client for the daemon

Communicating with a pipe

FIFO – using it in the shell

FIFO – building the sender

FIFO – building the receiver

Message queues – creating the sender

Message queues – creating the receiver

Communicating between child and parent with shared memory

Using shared memory between unrelated processes

Unix socket – creating the server

Unix socket – creating the client

Chapter 11: Using Threads in Your Programs

Technical requirements

Writing your first threaded program

Reading return values from threads

Causing a race condition

Avoiding race conditions with mutexes

Making the mutex program more efficient

Using condition variables

Chapter 12: Debugging Your Programs

Technical requirements

Starting GDB

Stepping inside a function with GDB

Investigating memory with GDB

Modifying variables during runtime

Using GDB on a program that forks

Debugging programs with multiple threads

Finding a simple memory leak with Valgrind

Finding buffer overflows with Valgrind

Why subscribe?

Other Books You May Enjoy

Packt is searching for authors like you

Leave a review - let other readers know what you think

Customer Reviews

5 (1)

5 star

100%

4 star

3 star

2 star

1 star

Deleting files

In this recipe, we learn how to delete files using a system call and where the name—unlink()—comes from. This recipe will enhance your understanding of links and close the circle. This will improve your overall knowledge of Linux and its filesystem. Knowing how to delete files using the system call will enable you to remove files directly from within your programs.

Here we will write our own version of rm, which we will call remove. After this recipe, we know how to create and delete files and how to make links. These are some of the most common filesystem operations.

Getting ready

In this recipe, we will use the my-stat-v1 program, which we wrote in the Reading inode information and learning the filesystem recipe. We will also continue experimenting on the filenames we created in the previous recipes, my-file, another-name, and third-name. Except for that, you'll need what's listed under Technical requirements for this chapter, that...

Linux System Programming Techniques

By : Jack-Benny Persson

Linux System Programming Techniques

By: Jack-Benny Persson

Overview of this book

Related Content you might be interested in

Current Title:

Linux System Programming Techniques

C++ System Programming Cookbook

Extreme C

Hands-On System Programming with Linux

Deleting files

Getting ready