Practical System Programming for Rust Developers: Build fast and secure software for Linux/Unix systems with the help of practical examples

Cover
Copyright
About PACKT
Contributors
Table of Contents
Preface
Section 1: Getting Started with System Programming in Rust
Chapter 1: Tools of the Trade – Rust Toolchains and Project Structures
Technical requirements
Choosing the right Rust configuration for your project
Choosing a Rust release channel
Selecting a Rust project type
Introducing Cargo and project structures
Automating build management with Cargo
Building a basic binary crate
Configuring Cargo
Building a static library crate
Automating dependency management
Specifying the location of a dependency
Using dependent packages in source code
Writing and running automated tests
Writing unit tests in Rust
Writing integration tests in Rust
Controlling test execution
Running tests sequentially or in parallel
Documenting your project
Writing inline documentation comments within crate
Writing documentation in markdown files
Running documentation tests
Summary
Further reading
Chapter 2: A Tour of the Rust Programming Language
Technical requirements
Analyzing the problem domain
Modeling the system behavior
Building the tokenizer
Tokenizer data structure
Tokenizer data processing
Building the parser
Parser data structure
Parser methods
Operator precedence
Building the evaluator
Dealing with errors
Putting it all together
Summary
Chapter 3: Introduction to the Rust Standard Library
Technical requirements
The Rust Standard Library and systems programming
Exploring the Rust Standard Library
Computation-oriented modules
Syscalls-oriented modules
Building a template engine
Template syntax and design
Writing the template engine
Executing the template engine
Summary
Further reading
Chapter 4: Managing Environment, Command Line, and Time
Technical requirements
Project scope and design overview
What will we build?
Technical design
Using the Rust Standard Library
Coding the imagix library
Developing the command-line application and testing
Designing the command-line interface
Coding the command-line binary using structopt
Summary
Section 2: Managing and Controlling System Resources in Rust
Chapter 5: Memory Management in Rust
Technical requirements
The basics of OS memory management
The memory management lifecycle
The process memory layout
Understanding the memory layout of Rust programs
Rust program memory layout
The characteristics of stack, heap, and static memory
The Rust memory management lifecycle
Overview of the Rust memory management lifecycle
Memory allocation
Memory use and manipulation
Memory deallocation
Implementing a dynamic data structure
Changes to the design of the template engine
Coding the dynamic data structure
Summary
Further reading
Chapter 6: Working with Files and Directories in Rust
Technical requirements
Understanding Linux system calls for file operations
Doing file I/O in Rust
Learning directory and path operations
Setting hard links, symbolic links, and performing queries
Writing a shell command in Rust (project)
Code overview
Error handling
Source metric computation
The main() function
Summary
Chapter 7: Implementing Terminal I/O in Rust
Technical requirements
Introducing terminal I/O fundamentals
Characteristics of terminals
The Termion crate
What will we build?
Working with the terminal UI (size, color, styles) and cursors
Writing data structures and the main() function
Initializing the text viewer and getting the terminal size
Displaying a document and styling the terminal color, styles, and cursor position
Exiting the text viewer
Processing keyboard inputs and scrolling
Listening to keystrokes from the user
Positioning the terminal cursor
Enabling scrolling on the terminal
Processing mouse inputs
Summary
Chapter 8: Working with Processes and Signals
Technical requirements
Understanding Linux process concepts and syscalls
How does a program become a process?
Delving into Linux process fundamentals
Spawning processes with Rust
Spawning new child processes
Terminating processes
Checking the status of a child process' execution
Handling I/O and environment variables
Handling the I/O of child processes
Setting the environment for the child process
Handling panic, errors, and signals
Aborting the current process
Signal handling
Writing a shell program in Rust (project)
Summary
Chapter 9: Managing Concurrency
Technical requirements
Reviewing concurrency basics
Concurrency versus parallelism
Concepts of multi-threading
Spawning and configuring threads
Error handling in threads
Message passing between threads
Achieving concurrency with shared state
Defining the program structure
Aggregating source file statistics in shared state
Pausing thread execution with timers
Summary
Section 3: Advanced Topics
Chapter 10: Working with Device I/O
Technical requirements
Understanding device I/O fundamentals in Linux
What are device drivers?
Types of devices
Doing buffered reads and writes
Working with standard input and output
Chaining and iterators over I/O
Handling errors and returning values
Getting details of connected USB devices (project)
Designing the project
Writing data structures and utility functions
Writing the main() function
Summary
Chapter 11: Learning Network Programming
Technical requirements
Reviewing networking basics in Linux
Understanding networking primitives in the Rust standard library
Programming with TCP and UDP in Rust
Writing a UDP server and client
Writing a TCP server and client
Writing a TCP reverse proxy (project)
Writing the origin server – structs and methods
Writing the origin server – the main() function
Writing the reverse proxy server
Summary
Chapter 12: Writing Unsafe Rust and FFI
Technical requirements
Introducing unsafe Rust
How do you distinguish between safe and unsafe Rust code?
Operations in unsafe Rust
Introducing FFIs
Reviewing guidelines for safe FFIs
Calling Rust from C (project)
Understanding the ABI
Summary
Other Books You May Enjoy
Index