Book123

    Free register and download UseNet downloader, then you can FREE Download from UseNet.

    Download without Limit " EBook Torrents Bash Cookbook " from UseNet for FREE!

*******************************************************************************

Bash Cookbook

*******************************************************************************

-------------------------------------------------------------------------------

General Information

-------------------------------------------------------------------------------

Type.................: Ebook

Part Size............: 3,314,837 bytes

Buy Book at Lowest Price on Amazon

-------------------------------------------------------------------------------

Post Information

-------------------------------------------------------------------------------

Posted by............: ~tqw~

-------------------------------------------------------------------------------

Release Notes

-------------------------------------------------------------------------------

The key to mastering any Unix system, especially Linux and Mac OS X, is a

thorough knowledge of shell scripting. Scripting is a way to harness and

customize the power of any Unix system, and it's an essential skill for any Unix

users, including system administrators and professional OS X developers. But

beneath this simple promise lies a treacherous ocean of variations in Unix

commands and standards.

& 34;bash Cookbook& 34; teaches shell scripting the way Unix masters practice the craft.

It presents a variety of recipes and tricks for all levels of shell programmers

so that anyone can become a proficient user of the most common Unix shell -- the

bash shell -- and cygwin or other popular Unix emulation packages. Packed full

of useful scripts, along with examples that explain how to create better

scripts, this new cookbook gives professionals and power users everything they

need to automate routine tasks and enable them to truly manage their systems --

rather than have their systems manage them.

Bash Cookbook is a great book for anyone who is interested in learning more

about bash and shell scripting. The book starts off with its first chapters

dedicated to beginners and learning what bash is, how the prompt works, and how

exactly shell scripting works. As the book progresses further, the examples and

topics get to an intermediate level, and finally end with an advanced level. The

book is packed with wonderful examples and full explanations of all parts of

bash. I had very little knowledge of bash and any sort of scripting before

reading this book. I started at the beginning even though I knew some of the

topics that were covered, but I still learned things from the tips, which are

scattered throughout the book. This book is a good fit for anyone that has very

little experience. It explains every type of variable, how to make them, their

uses, and shows examples of them in use. It does the same for loops, logic and

arithmetic, and every other topic covered in the book. At the very end of the

book there are nearly one hundred pages of appendixes which are a wonderful

resource full of tables and sample code. I feel very comfortable after reading

this book to do more advanced tasks with bash and shell scripting. I strongly

suggest this book to anyone who is interested in leaping into a UNIX shell for

the first time. The book is very up to date as it was published in May of 2007,

and I plan to use it as a reference for every bash questions I could have.

Chapter 1. Beginning bash

Section 0. Why bash

Section 0. The bash Shell

Section 1.1. Decoding the Prompt

Section 1.2. Showing Where You Are

Section 1.3. Finding and Running Commands

Section 1.4. Getting Information About Files

Section 1.5. Showing All Hidden (dot) Files in the Current Directory

Section 1.6. Using Shell Quoting

Section 1.7. Using or Replacing Built-ins and External Commands

Section 1.8. Determining If You Are Running Interactively

Section 1.9. Setting bash As Your Default Shell

Section 1.10. Getting bash for Linux

Section 1.11. Getting bash for xBSD

Section 1.12. Getting bash for Mac OS X

Section 1.13. Getting bash for Unix

Section 1.14. Getting bash for Windows

Section 1.15. Getting bash Without Getting bash

Section 1.16. Learning More About bash Documentation

Chapter 2. Standard Output

Section 2.1. Writing Output to the Terminal/Window

Section 2.2. Writing Output but Preserving Spacing

Section 2.3. Writing Output with More Formatting Control

Section 2.4. Writing Output Without the Newline

Section 2.5. Saving Output from a Command

Section 2.6. Saving Output to Other Files

Section 2.7. Saving Output from the ls Command

Section 2.8. Sending Both Output and Error Messages to Different Files

Section 2.9. Sending Both Output and Error Messages to the Same File

Section 2.10. Appending Rather Than Clobbering Output

Section 2.11. Using Just the Beginning or End of a File

Section 2.12. Skipping a Header in a File

Section 2.13. Throwing Output Away

Section 2.14. Saving or Grouping Output from Several Commands

Section 2.15. Connecting Two Programs by Using Output As Input

Section 2.16. Saving a Copy of Output Even While Using It As Input

Section 2.17. Connecting Two Programs by Using Output As Arguments

Section 2.18. Using Multiple Redirects on One Line

Section 2.19. Saving Output When Redirect Doesn't Seem to Work

Section 2.20. Swapping STDERR and STDOUT

Section 2.21. Keeping Files Safe from Accidental Overwriting

Section 2.22. Clobbering a File on Purpose

Chapter 3. Standard Input

Section 3.1. Getting Input from a File

Section 3.2. Keeping Your Data with Your Script

Section 3.3. Preventing Weird Behavior in a Here-Document

Section 3.4. Indenting Here-Documents

Section 3.5. Getting User Input

Section 3.6. Getting Yes or No Input

Section 3.7. Selecting from a List of Options

Section 3.8. Prompting for a Password

Chapter 4. Executing Commands

Section 4.1. Running Any Executable

Section 4.2. Telling If a Command Succeeded or Not

Section 4.3. Running Several Commands in Sequence

Section 4.4. Running Several Commands All at Once

Section 4.5. Deciding Whether a Command Succeeds

Section 4.6. Using Fewer if Statements

Section 4.7. Running Long Jobs Unattended

Section 4.8. Displaying Error Messages When Failures Occur

Section 4.9. Running Commands from a Variable

Section 4.10. Running All Scripts in a Directory

Chapter 5. Basic Scripting: Shell Variables

Section 5.1. Documenting Your Script

Section 5.2. Embedding Documentation in Shell Scripts

Section 5.3. Promoting Script Readability

Section 5.4. Separating Variable Names from Surrounding Text

Section 5.5. Exporting Variables

Section 5.6. Seeing All Variable Values

Section 5.7. Using Parameters in a Shell Script

Section 5.8. Looping Over Arguments Passed to a Script

Section 5.9. Handling Parameters with Blanks

Section 5.10. Handling Lists of Parameters with Blanks

Section 5.11. Counting Arguments

Section 5.12. Consuming Arguments

Section 5.13. Getting Default Values

Section 5.14. Setting Default Values

Section 5.15. Using null As a Valid Default Value

Section 5.16. Using More Than Just a Constant String for Default

Section 5.17. Giving an Error Message for Unset Parameters

Section 5.18. Changing Pieces of a String

Section 5.19. Using Array Variables

Chapter 6. Shell Logic and Arithmetic

Section 6.1. Doing Arithmetic in Your Shell Script

Section 6.2. Branching on Conditions

Section 6.3. Testing for File Characteristics

Section 6.4. Testing for More Than One Thing

Section 6.5. Testing for String Characteristics

Section 6.6. Testing for Equal

Section 6.7. Testing with Pattern Matches

Section 6.8. Testing with Regular Expressions

Section 6.9. Changing Behavior with Redirections

Section 6.10. Looping for a While

Section 6.11. Looping with a read

Section 6.12. Looping with a Count

Section 6.13. Looping with Floating-Point Values

Section 6.14. Branching Many Ways

Section 6.15. Parsing Command-Line Arguments

Section 6.16. Creating Simple Menus

Section 6.17. Changing the Prompt on Simple Menus

Section 6.18. Creating a Simple RPN Calculator

Section 6.19. Creating a Command-Line Calculator

Chapter 7. Intermediate Shell Tools I

Section 7.1. Sifting Through Files for a String

Section 7.2. Getting Just the Filename from a Search

Section 7.3. Getting a Simple True/False from a Search

Section 7.4. Searching for Text While Ignoring Case

Section 7.5. Doing a Search in a Pipeline

Section 7.6. Paring Down What the Search Finds

Section 7.7. Searching with More Complex Patterns

Section 7.8. Searching for an SSN

Section 7.9. Grepping Compressed Files

Section 7.10. Keeping Some Output, Discarding the Rest

Section 7.11. Keeping Only a Portion of a Line of Output

Section 7.12. Reversing the Words on Each Line

Section 7.13. Summing a List of Numbers

Section 7.14. Counting String Values

Section 7.15. Showing Data As a Quick and Easy Histogram

Section 7.16. Showing a Paragraph of Text After a Found Phrase

Chapter 8. Intermediate Shell Tools II

Section 8.1. Sorting Your Output

Section 8.2. Sorting Numbers

Section 8.3. Sorting IP Addresses

Section 8.4. Cutting Out Parts of Your Output

Section 8.5. Removing Duplicate Lines

Section 8.6. Compressing Files

Section 8.7. Uncompressing Files

Section 8.8. Checking a tar Archive for Unique Directories

Section 8.9. Translating Characters

Section 8.10. Converting Uppercase to Lowercase

Section 8.11. Converting DOS Files to Linux Format

Section 8.12. Removing Smart Quotes

Section 8.13. Counting Lines, Words, or Characters in a File

Section 8.14. Rewrapping Paragraphs

Section 8.15. Doing More with less

Chapter 9. Finding Files: find, locate, slocate

Section 9.1. Finding All Your MP3 Files

Section 9.2. Handling Filenames Containing Odd Characters

Section 9.3. Speeding Up Operations on Found Files

Section 9.4. Finding Files Across Symbolic Links

Section 9.5. Finding Files Irrespective of Case

Section 9.6. Finding Files by Date

Section 9.7. Finding Files by Type

Section 9.8. Finding Files by Size

Section 9.9. Finding Files by Content

Section 9.10. Finding Existing Files and Content Fast

Section 9.11. Finding a File Using a List of Possible Locations

Chapter 10. Additional Features for Scripting

Section 10.1. & 34;Daemon-izing& 34; Your Script

Section 10.2. Reusing Code with Includes and Sourcing

Section 10.3. Using Configuration Files in a Script

Section 10.4. Defining Functions

Section 10.5. Using Functions: Parameters and Return Values

Section 10.6. Trapping Interrupts

Section 10.7. Redefining Commands with alias

Section 10.8. Avoiding Aliases, Functions

Chapter 11. Working with Dates and Times

Section 11.1. Formatting Dates for Display

Section 11.2. Supplying a Default Date

Section 11.3. Automating Date Ranges

Section 11.4. Converting Dates and Times to Epoch Seconds

Section 11.5. Converting Epoch Seconds to Dates and Times

Section 11.6. Getting Yesterday or Tomorrow with Perl

Section 11.7. Figuring Out Date and Time Arithmetic

Section 11.8. Handling Time Zones, Daylight Saving Time, and Leap Years

Section 11.9. Using date and cron to Run a Script on the Nth Day

Chapter 12. End-User Tasks As Shell Scripts

Section 12.1. Starting Simple by Printing Dashes

Section 12.2. Viewing Photos in an Album

Section 12.3. Loading Your MP3 Player

Section 12.4. Burning a CD

Section 12.5. Comparing Two Documents

Chapter 13. Parsing and Similar Tasks

Section 13.1. Parsing Arguments for Your Shell Script

Section 13.2. Parsing Arguments with Your Own Error Messages

Section 13.3. Parsing Some HTML

Section 13.4. Parsing Output into an Array

Section 13.5. Parsing Output with a Function Call

Section 13.6. Parsing Text with a read Statement

Section 13.7. Parsing with read into an Array

Section 13.8. Getting Your Plurals left

Section 13.9. Taking It One Character at a Time

Section 13.10. Cleaning Up an SVN Source Tree

Section 13.11. Setting Up a Database with MySQL

Section 13.12. Isolating Specific Fields in Data

Section 13.13. Updating Specific Fields in Data Files

Section 13.14. Trimming Whitespace

Section 13.15. Compressing Whitespace

Section 13.16. Processing Fixed-Length Records

Section 13.17. Processing Files with No Line Breaks

Section 13.18. Converting a Data File to CSV

Section 13.19. Parsing a CSV Data File

Chapter 14. Writing Secure Shell Scripts

Section 14.1. Avoiding Common Security Problems

Section 14.2. Avoiding Interpreter Spoofing

Section 14.3. Setting a Secure $PATH

Section 14.4. Clearing All Aliases

Section 14.5. Clearing the Command Hash

Section 14.6. Preventing Core Dumps

Section 14.7. Setting a Secure $IFS

Section 14.8. Setting a Secure umask

Section 14.9. Finding World-Writable Directories in Your $PATH

Section 14.10. Adding the Current Directory to the $PATH

Section 14.11. Using Secure Temporary Files

Section 14.12. Validating Input

Section 14.13. Setting Permissions

Section 14.14. Leaking Passwords into the Process List

Section 14.15. Writing setuid or setgid Scripts

Section 14.16. Restricting Guest Users

Section 14.17. Using chroot Jails

Section 14.18. Running As a Non-root User

Section 14.19. Using sudo More Securely

Section 14.20. Using Passwords in Scripts

Section 14.21. Using SSH Without a Password

Section 14.22. Restricting SSH Commands

Section 14.23. Disconnecting Inactive Sessions

Chapter 15. Advanced Scripting

Section 15.1. Finding bash Portably for !

Section 15.2. Setting a POSIX $PATH

Section 15.3. Developing Portable Shell Scripts

Section 15.4. Testing Scripts in VMware

Section 15.5. Using for Loops Portably

Section 15.6. Using echo Portably

Section 15.7. Splitting Output Only When Necessary

Section 15.8. Viewing Output in Hex

Section 15.9. Using bash Net-Redirection

Section 15.10. Finding My IP Address

Section 15.11. Getting Input from Another Machine

Section 15.12. Redirecting Output for the Life of a Script

Section 15.13. Working Around & 34;argument list too long& 34; Errors

Section 15.14. Logging to syslog from Your Script

Section 15.15. Sending Email from Your Script

Section 15.16. Automating a Process Using Phases

Chapter 16. Configuring and Customizing bash

Section 16.1. bash Startup Options

Section 16.2. Customizing Your Prompt

Section 16.3. Change Your $PATH Permanently

Section 16.4. Change Your $PATH Temporarily

Section 16.5. Setting Your $CDPATH

Section 16.6. Shortening or Changing Command Names

Section 16.7. Adjusting Shell Behavior and Environment

Section 16.8. Adjusting readline Behavior Using .inputrc

Section 16.9. Keeping a Private Stash of Utilities by Adding ~/bin

Section 16.10. Using Secondary Prompts: $PS2, $PS3, $PS4

Section 16.11. Synchronizing Shell History Between Sessions

Section 16.12. Setting Shell History Options

Section 13. Creating a Better cd Command

Section 16.14. Creating and Changing into a New Directory in One Step

Section 16.15. Getting to the Bottom of Things

Section 16.16. Adding New Features to bash Using Loadable Built-ins

Section 16.17. Improving Programmable Completion

Section 16.18. Using Initialization Files Correctly

Section 16.19. Creating Self-Contained, Portable RC Files

Section 16.20. Getting Started with a Custom Configuration

Chapter 17. Housekeeping and Administrative Tasks

Section 17.1. Renaming Many Files

Section 17.2. Using GNU Texinfo and Info on Linux

Section 17.3. Unzipping Many ZIP Files

Section 17.4. Recovering Disconnected Sessions Using screen

Section 17.5. Sharing a Single bash Session

Section 17.6. Logging an Entire Session or Batch Job

Section 17.7. Clearing the Screen When You Log Out

Section 17.8. Capturing File Metadata for Recovery

Section 17.9. Creating an Index of Many Files

Section 17.10. Using diff and patch

Section 17.11. Counting Differences in Files

Section 17.12. Removing or Renaming Files Named with Special Characters

Section 17.13. Prepending Data to a File

Section 17.14. Editing a File in Place

Section 17.15. Using sudo on a Group of Commands

Section 17.16. Finding Lines in One File But Not in the Other

Section 17.17. Keeping the Most Recent N Objects

Section 17.18. Grepping ps Output Without Also Getting the grep Process Itself

Section 17.19. Finding Out Whether a Process Is Running

Section 17.20. Adding a Prefix or Suffix to Output

Section 17.21. Numbering Lines

Section 17.22. Writing Sequences

Section 17.23. Emulating the DOS Pause Command

Section 17.24. Commifying Numbers

Chapter 18. Working Faster by Typing Less

Section 18.1. Moving Quickly Among Arbitrary Directories

Section 18.2. Repeating the Last Command

Section 18.3. Running Almost the Same Command

Section 18.4. Substituting Across Word Boundaries

Section 18.5. Reusing Arguments

Section 18.6. Finishing Names for You

Section 18.7. Playing It Safe

Chapter 19. Tips and Traps: Common Goofs for Novices

Section 19.1. Forgetting to Set Execute Permissions

Section 19.2. Fixing & 34;No such file or directory& 34; Errors

Section 19.3. Forgetting That the Current Directory Is Not in the $PATH

Section 19.4. Naming Your Script Test

Section 19.5. Expecting to Change Exported Variables

Section 19.6. Forgetting Quotes Leads to & 34;command not found& 34; on Assignments

Section 19.7. Forgetting That Pattern Matching Alphabetizes

Section 19.8. Forgetting That Pipelines Make Subshells

Section 19.9. Making Your Terminal Sane Again

Section 19.10. Deleting Files Using an Empty Variable

Section 19.11. Seeing Odd Behavior from printf

Section 19.12. Testing bash Script Syntax

Section 19.13. Debugging Scripts

Section 19.14. Avoiding & 34;command not found& 34; When Using Functions

Section 19.15. Confusing Shell Wildcards and Regular Expressions

Appendix A. Reference Lists

Section A.1. bash Invocation

Section A.2. Prompt String Customizations

Section A.3. ANSI Color Escape Sequences

Section A.4. Built-in Commands and Reserved Words

Section A.5. Built-in Shell Variables

Section A.6. set Options

Section A.7. shopt options

Section A.8. Adjusting Shell Behavior Using set, shopt, and Environment

Variables

Section A.9. Test Operators

Section A.10. I/O Redirection

Section A.11. echo Options and Escape Sequences

Section A.12. printf

Section A.13. Date and Time String Formatting with strftime

Section A.14. Pattern-Matching Characters

Section A.15. extglob Extended Pattern-Matching Operators

Section A.16. tr Escape Sequences

Section A.17. Readline Init File Syntax

Section A.18. emacs Mode Commands

Section A.19. vi Control Mode Commands

Section A.20. Table of ASCII Values

Appendix B. Examples Included with bash

Section B.1. Startup-Files Directory Examples

Appendix C. Command-Line Processing

Section C.1. Command-Line Processing Steps

Appendix D. Revision Control

Section D.1. CVS

Section D.2. Subversion

Section D.3. RCS

Section D.4. Other

Appendix E. Building bash from Source

Section E.1. Obtaining bash

Section E.2. Unpacking the Archive

Section E.3. What's in the Archive

Section E.4. Who Do I Turn To

About the Authors

Colophon

Index

Product Details

* ISBN: 0596526784

* ISBN-13: 9780596526788

* Format: Paperback, 598pp

* Publisher: O'Reilly Media, Incorporated

* Pub. Date: May 2007

-------------------------------------------------------------------------------

Install Notes

-------------------------------------------------------------------------------

Adobe Acrobat Reader

Rating:
2.5 out of 5 by Book123