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