Linux Command Line and Shell Scripting Bible

RICHARD BLUM has over three decades of experience working as a system and network administrator. He is the author of several Linux books and is an accomplished online Linux instructor. CHRISTINE BRESNAHAN is an Adjunct Professor at Ivy Tech Community College where she teaches Linux certification and Python classes. She is the author of several Linux books, including the CompTIA Linux+ Study Guide, Fourth Edition.

Acknowledgments xi

Part I: The Linux Command Line 1

Chapter 1: Starting with Linux Shells 3

Investigating Linux 3

Looking into the Linux kernel 4

System memory management 5

Software program management 6

Hardware management 8

Filesystem management 8

The GNU utilities 9

The core GNU utilities 10

The shell 10

The Linux desktop environment 11

The X Window software 12

The KDE Plasma desktop 12

The GNOME desktop 13

Other desktops 15

Examining Linux Distributions 17

Core Linux distributions 18

Specialized Linux distributions 19

Summary 20

Chapter 2: Getting to the Shell 21

Reaching the Command Line 21

Console terminals 22

Graphical terminals 22

Accessing CLI via a Linux Console Terminal 23

Accessing CLI via Graphical Terminal Emulation 26

Using the GNOME Terminal Emulator 27

Accessing GNOME Terminal 27

The menu bar 32

Using the Konsole Terminal Emulator 36

Accessing Konsole 36

The menu bar 38

Using the xterm Terminal Emulator 42

Accessing xterm 43

Command-line parameters 44

Summary 45

Chapter 3: Basic Bash Shell Commands 47

Starting the Shell 47

Using the Shell Prompt 48

Interacting with the Bash Manual 49

Navigating the Filesystem 53

Looking at the Linux filesystem 53

Traversing directories 57

Using absolute directory references 57

Using relative directory references 59

Listing Files and Directories 60

Displaying a basic listing 61

Displaying a long listing 63

Filtering listing output 64

Handling Files 66

Creating files 66

Copying files 66

Using command-line completion 69

Linking files 69

Renaming files 71

Deleting files 73

Managing Directories 74

Creating directories 74

Deleting directories 75

Viewing File Contents 77

Viewing the file type 77

Viewing the whole file 78

Using the cat command 78

Using the more command 78

Using the less command 80

Viewing parts of a file 80

Using the tail command 80

Using the head command 82

Summary 82

Chapter 4: More Bash Shell Commands 85

Monitoring Programs 85

Peeking at the processes 85

Unix-style parameters 86

BSD-style parameters 89

The GNU long parameters 91

Real-time process monitoring 93

Stopping processes 95

The kill command 95

The pkill command 96

Monitoring Disk Space 96

Mounting media 97

The mount command 97

The umount command 99

Using the df command 100

Using the du command 101

Working with Data Files 102

Sorting data 102

Searching for data 106

Compressing data 108

Archiving data 109

Summary 111

Chapter 5: Understanding the Shell 113

Investigating Shell Types 113

Exploring Parent and Child Shell Relationships 117

Looking at process lists 121

Creatively using subshells 123

Investigating background mode 123

Putting process lists into the background 125

Looking at co-processing 126

Understanding External and Built-In Commands 127

Looking at external commands 128

Looking at built-in commands 129

Using the history command 130

Using command aliases 134

Summary 135

Chapter 6: Using Linux Environment Variables 137

Exploring Environment Variables 137

Looking at global environment variables 138

Looking at local environment variables 140

Setting User-Defined Variables 141

Setting local user-defined variables 141

Setting global environment variables 142

Removing Environment Variables 144

Uncovering Default Shell Environment Variables 145

Setting the PATH Environment Variable 150

Locating System Environment Variables 152

Understanding the login shell process 152

Viewing the /etc/profi le file 152

Viewing the $HOME startup files 156

Understanding the interactive shell process 157

Understanding the noninteractive shell process 158

Making environment variables persistent 159

Learning about Variable Arrays 159

Summary 161

Chapter 7: Understanding Linux File Permissions 163

Exploring Linux Security 163

The /etc/passwd file 164

The /etc/shadow file 165

Adding a new user 166

Removing a user 169

Modifying a user 169

usermod 170

passwd and chpasswd 170

chsh, chfn, and chage 171

Using Linux Groups 173

The /etc/group file 173

Creating new groups 174

Modifying groups 175

Decoding File Permissions 176

Using file permission symbols 176

Default file permissions 178

Changing Security Settings 179

Changing permissions 180

Changing ownership 181

Sharing Files 182

Access Control Lists 184

Summary 186

Chapter 8: Managing Filesystems 189

Exploring Linux Filesystems 189

Exploring the Linux filesystem evolution 190

Looking at the ext filesystem 190

Looking at the ext2 filesystem 190

Digging into journaling filesystems 191

Looking at the ext3 filesystem 191

Looking at the ext4 filesystem 191

Looking at the JFS filesystem 192

Looking at ReiserFS 192

Looking at XFS 192

Understanding the volume-managing filesystems 192

Looking at the ZFS filesystem 193

Looking at the Btrfs filesystem 193

Looking at the Stratis filesystem 193

Working with Filesystems 194

Creating partitions 194

Looking at the fdisk utility 194

Working with gdisk 197

The GNU parted command 198

Creating a filesystem 199

Checking and repairing a filesystem 201

Managing Logical Volumes 202

Exploring LVM layout 203

Physical volume 203

Volume group 203

Logical volume 203

Understanding the LVM in Linux 203

Create the PVs 204

Create a VG 204

Create an LV 205

Using the Linux LVM 206

Format and mount an LV 206

Growing or shrinking your VGs and LVs 206

Summary 207

Chapter 9: Installing Software 209

Exploring Package Management 209

Inspecting the Debian-Based Systems 210

Managing packages with apt 211

Installing software packages with apt 213

Upgrading software with apt 215

Uninstalling software with apt 216

The apt repositories 218

The Red Hat–Based Systems 220

Listing installed packages 220

Installing software with dnf 221

Upgrading software with dnf 223

Uninstalling software with dnf 223

Dealing with broken dependencies 223

RPM repositories 224

Managing Software Using Containers 225

Using snap containers 225

Using flatpak containers 227

Installing from Source Code 229

Summary 232

Chapter 10: Working with Editors 235

Visiting the vim Editor 235

Checking your vim package 236

Exploring vim basics 237

Editing data 240

Copying and pasting 240

Searching and substituting 241

Navigating the nano Editor 242

Exploring the Emacs Editor 244

Checking your Emacs package 245

Using Emacs on the console 246

Exploring the basics of Emacs 247

Editing data 248

Copying and pasting 249

Searching and replacing 249

Using buffers in Emacs 250

Using windows in console mode Emacs 251

Using Emacs in a GUI 252

Exploring the KDE Family of Editors 253

Looking at the KWrite editor 253

Looking at the Kate editor 259

Exploring the GNOME Editor 263

Starting gedit 264

Understanding basic gedit features 265

Managing plugins 268

Summary 271

Part II: Shell Scripting Basics 273

Chapter 11: Basic Script Building 275

Using Multiple Commands 275

Creating a Script File 276

Displaying Messages 278

Using Variables 279

Environment variables 280

User variables 281

Command substitution 283

Redirecting Input and Output 284

Output redirection 285

Input redirection 285

Employing Pipes 287

Performing Math 289

The expr command 290

Using brackets 292

A floating-point solution 293

The basics of bc 293

Using bc in scripts 295

Exiting the Script 297

Checking the exit status 297

The exit command 298

Working through a Practical Example 300

Summary 301

Chapter 12: Using Structured Commands 303

Working with the if-then Statement 303

Exploring the if-then-else Statement 306

Nesting ifs 307

Trying the test Command 311

Using numeric comparisons 313

Using string comparisons 314

Looking at string equality 315

Looking at string order 316

Looking at string size 318

Using file comparisons 320

Checking directories 320

Checking whether an object exists 321

Checking for a file 322

Checking for read access 324

Checking for empty files 325

Checking whether you can write to a file 326

Checking whether you can run a file 327

Checking ownership 328

Checking default group membership 329

Checking file date 330

Considering Compound Testing 331

Working with Advanced if-then Features 332

Using single parentheses 332

Using double parentheses 333

Using double brackets 335

Considering the case Command 335

Working through a Practical Example 337

Summary 343

Chapter 13: More Structured Commands 345

Looking at the for Command 345

Reading values in a list 346

Reading complex values in a list 347

Reading a list from a variable 349

Reading values from a command 350

Changing the field separator 351

Reading a directory using wildcards 352

Trying the C-Style for Command 354

The C language for command 355

Using multiple variables 356

Exploring the while Command 357

Basic while format 357

Using multiple test commands 358

Using the until Command 359

Nesting Loops 361

Looping on File Data 364

Controlling the Loop 365

The break command 365

Breaking out of a single loop 365

Breaking out of an inner loop 366

Breaking out of an outer loop 367

The continue command 368

Processing the Output of a Loop 371

Working through a Few Practical Examples 372

Finding executable files 373

Creating multiple user accounts 374

Summary 375

Chapter 14: Handling User Input 377

Passing Parameters 377

Reading parameters 377

Reading the script name 380

Testing parameters 381

Using Special Parameter Variables 382

Counting parameters 382

Grabbing all the data 384

Being Shifty 386

Working with Options 388

Finding your options 388

Processing simple options 388

Separating options from parameters 389

Processing options with values 391

Using the getopt command 392

Looking at the command format 392

Using getopt in your scripts 393

Advancing to getopts 395

Standardizing Options 398

Getting User Input 399

Reading basics 399

Timing Out 401

Reading with no display 402

Reading from a file 403

Working through a Practical Example 404

Summary 408

Chapter 15: Presenting Data 411

Understanding Input and Output 411

Standard file descriptors 412

STDIN 412

STDOUT 413

STDERR 414

Redirecting errors 414

Redirecting errors only 414

Redirecting errors and data 415

Redirecting Output in Scripts 416

Temporary redirections 416

Permanent redirections 417

Redirecting Input in Scripts 418

Creating Your Own Redirection 419

Creating output file descriptors 419

Redirecting file descriptors 420

Creating input file descriptors 421

Creating a read/write file descriptor 422

Closing file descriptors 423

Listing Open File Descriptors 424

Suppressing Command Output 426

Using Temporary Files 427

Creating a local temporary file 427

Creating a temporary file in /tmp 428

Creating a temporary directory 429

Logging Messages 430

Working through a Practical Example 431

Summary 433

Chapter 16: Script Control 435

Handling Signals 435

Signaling the Bash shell 435

Generating signals 436

Interrupting a process 436

Pausing a process 437

Trapping signals 438

Trapping a script exit 440

Modifying or removing a trap 441

Running Scripts in Background Mode 443

Running in the background 443

Running multiple background jobs 445

Running Scripts without a Hang-up 447

Controlling the Job 448

Viewing jobs 448

Restarting stopped jobs 450

Being Nice 451

Using the nice command 452

Using the renice command 453

Running like Clockwork 454

Scheduling a job using the at command 454

Understanding the at command format 454

Retrieving job output 455

Listing pending jobs 457

Removing jobs 457

Scheduling regular scripts 458

Looking at the cron table 458

Building the cron table 459

Viewing cron directories 460

Looking at the anacron program 460

Starting scripts with a new shell 462

Working through a Practical Example 463

Summary 469

Part III: Advanced Shell Scripting 471

Chapter 17: Creating Functions 473

Exploring Basic Script Functions 473

Creating a function 474

Using functions 474

Returning a Value from a Function 477

The default exit status 477

Using the return command 478

Using function output 479

Using Variables in Functions 480

Passing parameters to a function 480

Handling variables in a function 482

Global variables 483

Local variables 484

Investigating Array Variables and Functions 485

Passing arrays to functions 485

Returning arrays from functions 487

Considering Function Recursion 488

Creating a Library 489

Using Functions on the Command Line 491

Creating functions on the command line 491

Defining functions in the bashrc file 492

Directly defining functions 492

Sourcing function files 493

Working Through a Practical Example 494

Downloading and installing 494

Building the library 495

The shtool library functions 496

Using the library 497

Summary 497

Chapter 18: Writing Scripts for Graphical Desktops 499

Creating Text Menus 499

Create the menu layout 499

Create the menu functions 501

Add the menu logic 502

Putting it all together 502

Using the select command 504

Doing Windows 505

The dialog package 506

The msgbox widget 507

The yesno widget 508

The inputbox widget 508

The textbox widget 510

The menu widget 511

The fselect widget 512

The dialog options 513

Using the dialog command in a script 515

Getting Graphic 516

The KDE environment 517

kdialog widgets 517

Using kdialog 519

The GNOME environment 521

zenity Widgets 521

Using zenity in scripts 523

Working Through a Practical Example 525

Summary 529

Chapter 19: Introducing sed and gawk 531

Manipulating Text 531

Getting to know the sed editor 532

Defining an editor command in the command line 533

Using multiple editor commands in the command line 534

Reading editor commands from a file 534

Getting to know the gawk program 535

Visiting the gawk command format 536

Reading the program script from the command line 536

Using data field variables 537

Using multiple commands in the program script 538

Reading the program from a file 539

Running scripts before processing data 539

Running scripts after processing data 540

Looking at the sed Editor Basic Commands 542

Introducing more substitution options 542

Substituting flags 542

Replacing characters 543

Using addresses 544

Addressing the numeric line 544

Using text pattern filters 545

Grouping commands 546

Deleting lines 547

Inserting and appending text 549

Changing lines 551

Transforming characters 552

Printing revisited 553

Printing lines 554

Printing line numbers 555

Listing lines 555

Using files with sed 556

Writing to a file 556

Reading data from a file 557

Working Through a Practical Example 559

Summary 564

Chapter 20: Regular Expressions 565

Exploring Regular Expressions 565

A definition 565

Types of regular expressions 567

Defining BRE Patterns 567

Plain text 567

Special characters 569

Anchor characters 570

Starting at the beginning 570

Looking for the ending 571

Combining anchors 572

The dot character 572

Character classes 573

Negating character classes 575

Using ranges 576

Special character classes 577

The asterisk 578

Trying Out Extended Regular Expressions 579

The question mark 579

The plus sign 580

Using braces 581

The pipe symbol 582

Grouping expressions 583

Working Through Some Practical Examples 584

Counting directory files 584

Validating a phone number 585

Parsing an email address 587

Summary 589

Chapter 21: Advanced sed 591

Looking at Multiline Commands 591

Navigating the next command 592

Using the single-line next command 592

Combining lines of text 593

Navigating the multiline delete command 595

Navigating the multiline print command 596

Holding Space 598

Negating a Command 599

Changing the Flow 602

Branching 603

Testing 605

Replacing via a Pattern 606

Using the ampersand 606

Replacing individual words 607

Placing sed Commands in Scripts 608

Using wrappers 608

Redirecting sed output 609

Creating sed Utilities 610

Spacing with double lines 610

Spacing files that may have blanks 611

Numbering lines in a file 612

Printing last lines 613

Deleting lines 614

Deleting consecutive blank lines 615

Deleting leading blank lines 616

Deleting trailing blank lines 616

Removing HTML tags 617

Working Through a Practical Example 619

Summary 624

Chapter 22: Advanced gawk k 627

Using Variables 627

Built-in variables 628

The field and record separator variables 628

Data variables 631

User-defined variables 634

Assigning variables in scripts 634

Assigning variables on the command line 635

Working with Arrays 636

Defining array variables 636

Iterating through array variables 637

Deleting array variables 638

Considering Patterns 638

Regular expressions 639

The matching operator 639

Mathematical expressions 640

Structured Commands 641

The if statement 641

The while statement 643

The do-while statement 644

The for statement 645

Printing with Formats 645

Using Built-in Functions 648

Mathematical functions 649

String functions 650

Time functions 652

Trying Out User-Defined Functions 653

Defining a function 653

Using your functions 654

Creating a function library 654

Working Through a Practical Example 655

Summary 657

Chapter 23: Working with Alternative Shells 659

Considering the Dash Shell 659

Looking at the Dash Shell Features 661

The Dash command-line parameters 661

The Dash environment variables 662

Default environment variables 662

Positional parameters 663

User-defined environment variables 663

The Dash built-in commands 664

Scripting in Dash 665

Creating Dash scripts 665

Things that won’t work 665

Using arithmetic 666

The test command 666

The function command 667

Exploring the zsh Shell 668

Viewing Parts of the zsh shell 668

Shell options 669

Built-in commands 670

Core built-in commands 670

Add-in modules 673

Viewing, adding, and removing modules 673

Scripting with zsh 674

Mathematical operations 674

Performing calculations 674

Mathematical functions 675

Structured commands 676

Functions 677

Working Through a Practical Example 677

Summary 678

Part IV: Creating and Managing Practical Scripts 679

Chapter 24: Writing Simple Script Utilities 681

Performing Backups 681

Backing up files daily 682

Obtaining the required functions 682

Creating a daily archive location 685

Creating a daily backup script 686

Running the daily archive script 688

Creating an hourly archive script 689

Running the hourly archive script 692

Managing Account Deletion 693

Obtaining the required functions 693

Getting the correct account name 693

Creating a function to get the correct account name 695

Verifying the entered account name 696

Determining whether the account exists 698

Removing any account processes 699

Finding account files 702

Removing the account 702

Creating the script 703

Running the script 708

Monitoring Your System 710

Obtaining the default shell audit functions 710

Obtaining the permission audit functions 714

Creating the script 716

Running the script 719

Summary 721

Chapter 25: Getting Organized 723

Understanding Version Control 723

Working directory 724

Staging area 725

Looking at the local repository 725

Exploring a remote repository 726

Branching 726

Cloning 726

Using Git for VCS 727

Setting Up Your Git Environment 727

Committing with Git 732

Summary 739

Appendix A: Quick Guide to Bash Commands 741

Appendix B: Quick Guide to sed and gawk 755

Index 767