Bash Cookbook=Ron Brash; Note=Erxin.txt

Bash cookbook=Ron Brash; Note=Erxin

# Preface
- handle variable assignment 

```
#!/bin/bash

PI=3.14
VAR_A=10
VAR_B=$VAR_A
VAR_C=${VAR_B}

echo "Let's print 3 variables:"
echo $VAR_A
echo $VAR_B
echo $VAR_C

echo "We know this will break:"
echo "0. The value of PI is $PIabc"     # since PIabc is not declared, it will be empty string

echo "And these will work:"
echo "1. The value of PI is $PI"
echo "2. The value of PI is ${PI}"
echo "3. The value of PI is" $PI

echo "And we can make a new string"
STR_A="Bob"
STR_B="Jane"
echo "${STR_A} + ${STR_B} equals Bob + Jane"
STR_C=${STR_A}" + "${STR_B}
echo "${STR_C} is the same as Bob + Jane too!"
echo "${STR_C} + ${PI}"
```

- global context and environment variables 

```
$ env
XDG_VTNR=7
XDG_SESSION_ID=c2
CLUTTER_IM_MODULE=xim
XDG_GREETER_DATA_DIR=/var/lib/lightdm-data/rbrash
SESSION=ubuntu
SHELL=/bin/bash
TERM=xterm-256color
XDG_MENU_PREFIX=gnome-
VTE_VERSION=4205
QT_LINUX_ACCESSIBILITY_ALWAYS_ON=1
WINDOWID=81788934
UPSTART_SESSION=unix:abstract=/com/ubuntu/upstart-session/1000/1598
GNOME_KEYRING_CONTROL=
GTK_MODULES=gail:atk-bridge:unity-gtk-module
USER=rbrash
....
```

- reserved keywords programming/scripting languages.

if, elif, else, fi
while, do, for, done, continue, break
case, select, time
function
&, |, >, <, !, =
#, $, (, ), ;, {, }, [, ], \

\ is very special because it is an escape character. Escape characters are used to escape or stop the interpreter

- conditional logic using if, else, and elseif 

```
#!/bin/bash
AGE=40
if [ ${AGE} -lt 18 ]  then
    echo "You must be 18 or older to see this movie"
elif [ "${MY_NAME}" != ${NAME_1}" && "${MY_NAME}" != ${NAME_2}" then 
    echo ...
else
    echo "You may see the movie!"
    exit 1
fi
```

operators:

-gt (greater than >)
-ge (greater or equal to >=)
-lt (less than <)
-le (less than or equal to <=)
-eq (equal to)
-nq (not equal to)

operators: &&, ||, ==, and != 

&& (means and)
|| (means or)
== (is equal to)
!= (not equal to)
-n (is not null or is not set)
-z (is null and zero length)

- case statement 

```
case $THING_I_AM_TO_EVALUATE in
  1) # Condition to evaluate is number 1 (could be "a" for a string too!)
    echo "THING_I_AM_TO_EVALUATE equals 1"
    ;; # Notice that this is used to close this evaluation
  *) # * Signified the catchall (when THING_I_AM_TO_EVALUATE does not equal values in the switch)
    echo "FALLTHOUGH or default condition"
esac # Close case statement


VAR=10 # Edit to 1 or 2 and re-run, after running the script as is.
case $VAR in
  1)
    echo "1"
    ;;
  2)
    echo "2"
    ;;
  *)
    echo "What is this var?"
    exit 1
esac
```

- loop 

```
#!/bin/bash

FILES=( "file1" "file2" "file3" )
for ELEMENT in ${FILES[@]}
do
        echo "${ELEMENT}"
done

echo "Echo\'d all the files" 


#!/bin/bash
CTR=1
while [ ${CTR} -lt 9 ]
do
    echo "CTR var: ${CTR}"
    ((CTR++)) # Increment the CTR variable by 1
done
echo "Finished"


#!/bin/bash
CTR=1
until [ ${CTR} -gt 9 ]
do
    echo "CTR var: ${CTR}"
    ((CTR++)) # Increment the CTR variable by 1
done
echo "Finished"
```

- function and parameters 

```
#!/bin/bash
function my_function() {
    local PARAM_1="$1"
    local PARAM_2="$2"
    local PARAM_3="$3"
    echo "${PARAM_1} ${PARAM_2} ${PARAM_3}"
}
my_function "a" "b" "c"
```

Parameters are referred to systematically like this: $1 for parameter 1, $2 for parameter 2, $3 for parameter 3, and so on
The local keyword refers to the fact that variables declared with this keyword remain accessible only within this function
We can call functions merely by name and use parameters simply by adding them, as in the preceding example

- return code 

```
$ ls ~/this.file.no.exist
ls: cannot access '/home/rbrash/this.file.no.exist': No such file or directory
$ echo $?
```

- linking commands and pipe and input/output 

``
iwconfig command:

$ iwconfig
wlp3s0 IEEE 802.11abgn ESSID:"127.0.0.1-2.4ghz" 
          Mode:Managed Frequency:2.412 GHz Access Point: 18:D6:C7:FA:26:B1 
          Bit Rate=144.4 Mb/s Tx-Power=22 dBm 
          
wireless interface information:

$ iw dev                # This will give list of wireless interfaces
$ iw dev wlp3s0 link    # This will give detailed information about particular wireless interface


```

three commands to get information from one place to another:

stdin (standard in)
stdout (standard out)
stderr (standard error)

```
$ ls /filethatdoesntexist.txt 2> err.txt
$ ls ~/ > stdout.txt
$ ls ~/ > everything.txt 2>&1 # Gets stderr and stdout
$ ls ~/ >> everything.txt 2>&1 # Gets stderr and stdout
$ cat err.txt
```

f >, 2>, and 2>&1. With the arrows we can redirect the output to any file or even to other programs!

- redirection and pipe bonzanza 

Neato.txt will contain the same information as the console
ls -la ~/fakefile.txt ~/ 2>&1 | tee neato.txt

- passing your program flags 

code leverages a piece of functionality called getopts. Getopts allows us to grab the program parameter flags for use within our program. 

```
#!/bin/bash

HELP_STR="usage: $0 [-h] [-f] [-l] [--firstname[=]<value>] [--lastname[=]<value] [--help]"

# Notice hidden variables and other built-in Bash functionality
optspec=":flh-:"
while getopts "$optspec" optchar; do
    case "${optchar}" in
        -)
            case "${OPTARG}" in
                firstname)
                    val="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    FIRSTNAME="${val}"
                    ;;
                lastname)
                    val="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                        LASTNAME="${val}"
                    ;;
                help)
                    val="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                    ;;
                *)
                    if [ "$OPTERR" = 1 ] && [ "${optspec:0:1}" != ":" ]; then
                        echo "Found an unknown option --${OPTARG}" >&2
                    fi
                    ;;
            esac;;
        f)
                val="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                FIRSTNAME="${val}"
                ;;
        l)
                val="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
                LASTNAME="${val}"
                ;;
        h)
            echo "${HELP_STR}" >&2
            exit 2
            ;;
        *)
            if [ "$OPTERR" != 1 ] || [ "${optspec:0:1}" = ":" ]; then
                echo "Error parsing short flag: '-${OPTARG}'" >&2
                exit 1
            fi

            ;;
    esac
done

# Do we have even one argument?
if [ -z "$1" ]; then
  echo "${HELP_STR}" >&2
  exit 2
fi

# Sanity check for both Firstname and Lastname
if [ -z "${FIRSTNAME}" ] || [ -z "${LASTNAME}" ]; then
  echo "Both firstname and lastname are required!"
  exit 3
fi

echo "Welcome ${FIRSTNAME} ${LASTNAME}!"

exit 0
```

- get help with man command 



# Acting like a typewriter 
- logic to modify strings such as the following:

Removing trailing characters
Replacing sections of words (substrings)
Searching for strings in files
Finding files
Testing file types (directory, file, empty, and so on)
Performing small calculations
Limiting the scope of searches or data (filtering)
Modifying the contents of variables (strings inside of string variables)

- ASCII or UTF. ASCII is a commonly used format in the *NIX world on the console. There is also the UTF encoding scheme, which is an improvement upon ASCII

- core commands such as grep, ls, mkdir, touch, traceroute, strings, wget, xargs, and find.

```
#!/bin/bash

# Let's find all the files with the string "Packt"
DIRECTORY="www.packtpub.com/"
SEARCH_TERM="Packt"

# Can we use grep?
grep "${SEARCH_TERM}" ~/* > result1.txt 2&> /dev/null

# Recursive check
grep -r "${SEARCH_TERM}" "${DIRECTORY}" > result2.txt

# What if we want to check for multiple terms?
grep -r -e "${SEARCH_TERM}" -e "Publishing" "${DIRECTORY}" > result3.txt

# What about find?
find "${DIRECTORY}" -type f -print | xargs grep "${SEARCH_TERM}" > result4.txt

# What about find and looking for the string inside of a specific type of content?
find "${DIRECTORY}" -type f -name "*.xml" ! -name "*.css" -print | xargs grep "${SEARCH_TERM}" > result5.txt

# Can this also be achieved with wildcards and subshell?
grep "${SEARCH_TERM}" $(ls -R "${DIRECTORY}"*.{html,txt}) > result6.txt
RES=$?

if [ ${RES} -eq 0 ]; then
  echo "We found results!"
else
  echo "It broke - it shouldn't happen (Packt is everywhere)!"
fi

# Or for bonus points - a personal favorite
history | grep "ls" # This is really handy to find commands you ran yesterday!


# grep can be used with multiple user-supplied arguments:

$ grep -e "Packt" -e "Publishing" -r ~/www.packtpub.com/
```

$ xargs --help
Usage: xargs [OPTION]... COMMAND [INITIAL-ARGS]...
Run COMMAND with arguments INITIAL-ARGS and more arguments read from input.

$ find --help
Usage: /usr/bin/find [-H] [-L] [-P] [-Olevel] [-D debugopts] [path...] [expression]

Default path is the current directory; default expression is -print.
Expression may consist of: operators, options, tests, and actions.

- whildcards and regexes our searches. In short:

A wildcard can be: *, {*.ooh,*.ahh}, /home/*/path/*.txt, [0-10], [!a], ?, [a,p] m
A regex can be: $, ^, *, [], [!], | (be careful to escape this)

enhance grep (or another command), we could use any of the following:

[:alpha:]: Alphabetic (case-insensitive) 
[:lower:]: Lowercase printable characters
[:upper:]: Uppercase printable characters
[:digit:]: Numbers in decimal 0 to 9
[:alnum:]: Alphanumeric (all digits and alphabetic characters)
[:space:]: White space meaning spaces, tabs, and newlines
[:graph:]: Printable characters excluding spaces
[:print:]: Printable characters including spaces
[:punct:]: Punctuation (for example, a period)
[:cntrl:]: Control characters (non-printable characters like when a signal is generated when you use Ctrl + C)
[:xdigit:]: Hexadecimal characters


```
#!/bin/bash
STR1='123 is a number, ABC is alphabetic & aBC123 is alphanumeric.'

echo "-------------------------------------------------"
# Want to find all of the files beginning with an uppercase character and end with .pdf?
ls * | grep [[:upper:]]*.pdf

echo "-------------------------------------------------"
# Just all of the directories in your current directory?
ls -l [[:upper:]]*

echo "-------------------------------------------------"
# How about all of the files we created with an expansion using the { } brackets?
ls [:lower:].test .

echo "-------------------------------------------------"
# Files with a specific extension OR two?
echo ${STR1} > test.txt
ls *.{test,txt} 

echo "-------------------------------------------------"
# How about looking for specific punctuation and output on the same line
echo "${STR1}" | grep -o [[:punct:]] | xargs echo

echo "-------------------------------------------------"
# How about using groups and single character wildcards (only 5 results)
ls | grep -E "([[:upper:]])([[:digit:]])?.test?" | tail -n 5
```

tr --help
Usage: tr [OPTION]... SET1 [SET2]
Translate, squeeze, and/or delete characters from standard input,
writing to standard output.

- math and calculations in script 

$ echo $((1*5))


$ sudo apt-get install -y bc tar

install GCC, which is short for the GNU Compiler Collection. This sounds terribly complex and we assure you that we did all the hard work:

$ sudo apt-get install -y gcc

use gcc and -lm (this refers to libmath) as follows:

$ gcc -Wall -02 -o mhelper main.c -lmath

- Striping/altering/sorting/deleting/searching strings with bash only 

```
# ${VARIABLE:startingPosition:optionalLength}
echo ${VARIABLE:3:4}
```

${var}  use value of var; braces are optional if var is separated from the following text 
${var:-value}, use var if set otherwise use value 
${var:=value}, use var if set otherwise use value and assigne value to var 
${var:?value}, use var if set otherwise print value and exit 
${var:+value}, use value if var is set otherwise using nothing 
${#var}, use the length of var 
#{#*}, ${#@} use the number of positional parameters 
${var#pattern} use value of var after removing text matching pattern 
${var##pattern}, same as #pattern but remove the longest matching piece
#{var%pattern}, use value of var after removing text matching pattern from the right, remove the shortest matching piece 
${var%%pattern}, same as %pattern, but remove the longest matching piece 
${var^pattern}, convert the case of var to uppercase 
${var^^pattern}, same as ^pattern but apply the match to every letter in the string 
${var, pattern}, same as ^pattern, but convert matching characters to lowercase 
${var,, pattern}, but apply the match to every lettern in string 
${var@a}, use the flag values representing var's attributes var may be an array subscripted with @ or * 
${var@A}, a string in the orm of a command or assignement statement that if evaluated recreates var and its attributes 
${var@E}, the value of var wth $'...' escape sequences evaluated 
${var@P}, the value of var wth prompt string escape sequences 
${var@Q}, the value of var quoted in a way that allows entering the values as input 
${!prefix*}, list of variables whose names begin with prefix 
${!prefix@}

${var:pos}, starting at position pos(0-based) in variable var 
${var:pos:len}, extract len characters, or extract rest of string if no len pos 
${var/pat/repl}, use value of var, with first match of pat replaced with repl 
${var/pat}, use value of var, with first match of pat deleted 
${var//pat/repl}, use value of var, with every match of pat replaced with repl 
${var/#pat/repl}, use value o fvar, with match of pat replaced with repl, match must occur at the beginning 
${var/%pat/repl}, use valeu of var with match of pat replaced with repl, match must be occur at the end 
${!var}, use value f var as name of variable whose value should be used (indirect reference)

$#, number of command-line arguments 
$-, options currently ineffect 
$?, exit value of last executed command 
$$, process number of the shell 
$!, process number of last background command 
$0, first word the command name. this will have the full pathname if the command was found via PATH search 
$n, individual arguments on the command line 
$*, $@, all arguments on the command line, $1, $2, ...
"$*", all arguments on the command line as one string 
"$@", all arguments on the command line with individual quoted ("$1" "$2")

    + bash automatically set the following addtional variables 
$_, temporary variable initialiated to the pathname of the script or program being executed, later stores the last argument of the previous command, also stores the name of the matching mail file 

- environment variables 
BASH    the full path name used to inovke this instance of bash 
BASHOPTS    a read-only colon-separated list of shell options that are curretly enabled 
BASHPID     the process id of the current bash process. in some cases this can differ from $$ 
BASH_AIASES, associative array variable, each element holds an alias defined with the alias command 
BASH_ARGC, array variable, each element holds the number of arguments for the corresponding function or dot-script invocation. set only in extended debug mode, with shopt -s extdebug 

BASH_ARGV, an array variable similar to BASH_ARGC, each element is noe of te arguments passed to a function or dot-script 
BASH_CMDS,  associative array variable, command in the internal hash table maintained by the hash command 
BASH_COMMAND    the command currently executing or about to be executed 
BASH_EXECUTION_STRING,  the string argument passed tothe -c option 
BASH_LINENO,        array varialbe, corresponding to BASH_SOURCE and FUNCNAME
BASH_REMATCH, array variable assigned by the =~ operator of the [[]] construct the index zero is the text that matched the entire pattern 
BASH_SOURCE, array varialbe containing source filenames 
BASH_SUBSHELL
BASH_VERSINFO[0-5]
BASH_VERSION 
COMP_CWORD, for programmable completion, index into COMP_WORDS 
COMP_KEY, for programmable completion, the key or final key in a sequence 
COMP_...

COPROC, array holds the file descriptor used for communicating with an unnamed coprocess 
DIRSTACK, array variable, containg the contents of the directory stack as displayed by dirs 
EUID, read-only variable with the numeric effective UID 
FUNCNAME, array variable, containg function names 
FUNCNEST, a value greater than zero defined the maximum function call nesting level 
GROUPS, array variable containing the list of numeric group ids 
HISTCMD, the history number of the current command 
HOSTNAME, the name of the current host 
HOSTTYPE, a strig that describes the host system 
LINENO, current line number within the script for function 
MACHTYPE, a string that describes the host system in the GNU cpu-compay-system format 
MAPFILE, default array for the mapfile and readarray commands 

OLDPWD, previous working dir 
OPTARG, value of argument to last option processed by getopts 
OPTIND, numerical index of OPTARG 
OSTYPE
PIPESTATUS, array variable, containing the exit status of the commands in the most recent foreground 
PPID, process nubmer of this shell's parent 
PWD, current working directory 
RANDOM[=n], generate a new random number with each reference;start with integer n
READLINE_LINE, for use with bind -x, the contents of the editing buffer are available in this variable 
READLINE_POINT, for use with bind -x the index in $READLINE_LINE of the insert point 
REPLY   default reply used by select and read 
SECONDS[=n], number of seconds since the shell was started 
SHELLOPTS, a read-only colon-seperated list of shell  options 
SHLVL, incremented by one every time a new bash 

- using sed and awk to remove/replace substrings 

awk 'BEGIN { FS=","; OFS="," } {$5="";gsub(",+",",",$0)}1' OFS=, ${EM_CSV}
sed -i 's/Bob/Robert/' ${EM_CSV}
sed -i 's/^/#/' ${EM_CSV} # In place, instead of on the data in the array

```
Usage: sed [OPTION]... {script-only-if-no-other-script} [input-file]...

  -n, --quiet, --silent
                 suppress automatic printing of pattern space
      --debug
                 annotate program execution
  -e script, --expression=script
                 add the script to the commands to be executed
  -f script-file, --file=script-file
                 add the contents of script-file to the commands to be executed
  --follow-symlinks
                 follow symlinks when processing in place
  -i[SUFFIX], --in-place[=SUFFIX]
                 edit files in place (makes backup if SUFFIX supplied)
  -b, --binary
                 open files in binary mode (CR+LFs are not processed specially)
  -l N, --line-length=N
                 specify the desired line-wrap length for the `l' command
  --posix
                 disable all GNU extensions.
  -E, -r, --regexp-extended
                 use extended regular expressions in the script
                 (for portability use POSIX -E).
  -s, --separate
                 consider files as separate rather than as a single,
                 continuous long stream.
      --sandbox
                 operate in sandbox mode (disable e/r/w commands).
  -u, --unbuffered
                 load minimal amounts of data from the input files and flush
                 the output buffers more often
  -z, --null-data
                 separate lines by NUL characters
      --help     display this help and exit
      --version  output version information and exit

If no -e, --expression, -f, or --file option is given, then the first
non-option argument is taken as the sed script to interpret.  All
remaining arguments are names of input files; if no input files are
specified, then the standard input is read.

GNU sed home page: <https://www.gnu.org/software/sed/>.
General help using GNU software: <https://www.gnu.org/gethelp/>.
E-mail bug reports to: <bug-sed@gnu.org>.
```

sed  's/.$//', and then pipe the output to convert everything to uppercase using sed -e 's/.*/\U&/'.

```
Usage: awk [POSIX or GNU style options] -f progfile [--] file ...
Usage: awk [POSIX or GNU style options] [--] 'program' file ...
POSIX options:          GNU long options: (standard)
        -f progfile             --file=progfile
        -F fs                   --field-separator=fs
        -v var=val              --assign=var=val
Short options:          GNU long options: (extensions)
        -b                      --characters-as-bytes
        -c                      --traditional
        -C                      --copyright
        -d[file]                --dump-variables[=file]
        -D[file]                --debug[=file]
        -e 'program-text'       --source='program-text'
        -E file                 --exec=file
        -g                      --gen-pot
        -h                      --help
        -i includefile          --include=includefile
        -I                      --trace
        -l library              --load=library
        -L[fatal|invalid|no-ext]        --lint[=fatal|invalid|no-ext]
        -M                      --bignum
        -N                      --use-lc-numeric
        -n                      --non-decimal-data
        -o[file]                --pretty-print[=file]
        -O                      --optimize
        -p[file]                --profile[=file]
        -P                      --posix
        -r                      --re-interval
        -s                      --no-optimize
        -S                      --sandbox
        -t                      --lint-old
        -V                      --version

To report bugs, see node `Bugs' in `gawk.info'
which is section `Reporting Problems and Bugs' in the
printed version.  This same information may be found at
https://www.gnu.org/software/gawk/manual/html_node/Bugs.html.
PLEASE do NOT try to report bugs by posting in comp.lang.awk,
or by using a web forum such as Stack Overflow.

gawk is a pattern scanning and processing language.
By default it reads standard input and writes standard output.

Examples:
        awk '{ sum += $1 }; END { print sum }' file
        awk -F: '{ print $1 }' /etc/passwd
```

- Echo is far more "straightforward", printf can provide the same and more functionality using C style parameters.

```
DECIMAL=10.0
FLOAT=3.333333
FLOAT2=6.6666 # On purpose two missing values

printf "%s %.2f\n\n" "This is two decimal places: " ${DECIMAL}

printf "shall we align: \n\n %.3f %-.6f\n" ${FLOAT} ${FLOAT2}
```

- local will display the current system local language 

$ sudo apt-get install -y gettext

xgettext to generate the appropriate strings. We will not use the results, but this is how you can generate a minimalist

>xgettext --help
Usage: xgettext [OPTION] [INPUTFILE]...

Extract translatable strings from given input files.

Mandatory arguments to long options are mandatory for short options too.
Similarly for optional arguments.

- word count 

$ wc -c <<< "1234567890"

Using other programs like sort and uniq (or a combination of the two), we can also sort the contents of a file and reduce duplicates

The cut command is a useful command for trimming strings, which may be delimited or merely using hard-coded values such as remove X

$ wc -c testdata/duplicates.txt | cut -d ' ' -f1

- using file attributes with conditional logic 

-e: The file exists
-f: This is a regular file and not a directory or device file
-s: The file is not empty or zero in size
-d: This is a directory
-r: This has read permissions
-w: This has write permissions
-x:This has execute permissions
-O: This is the owner of the file the current user
-G: This executes the user if they have the same group as yours
f1 (- nt, -ot, -ef) f2: Refers to if f1 is newer than f2, older than f2, or are hard-linked to the same file

```
function file_attributes() {

  if [ ! -s $1 ]; then
    echo "\"$1\" is empty" 
  else 
    FSIZE=$(stat --printf="%s" $1 2> /dev/null)
    RES=$?
    if [ $RES -eq 1 ]; then
      return
    else
      echo "\"$1\" file size is: ${FSIZE}\""
    fi
  fi
  
  if [ ! -O $1 ]; then
    echo -e "${USER} is not the owner of \"$1\"\n"
  fi
  if [ ! -G $1 ]; then
    echo -e "${USER} is not among the owning group(s) for \"$1\"\n"
  fi
  
  permissions $1 "file"
  
}
```

- reading delimited data and altered output format 

```
# Enter content
echo ${ELM} | \
sed '{:q;N;s/\n/\\n/g;t q}'| \
awk \
'{ print "awk \x27 BEGIN{FS=\"'${DELIMITER}'\"}{print "$0"}\x27 '${INPUT_FILE}'"}' | \
 sh >> ${OUTPUT_FILE}
```

- viewing files from various angles 

Head: Can be used to output the beginning lines of a file
Tail: Can be used to output the end or tail of a file (continuously as well)
More: A tool used as a pager to view large files page by page/line by line
Less: Is the same as more, but it has more features, including backwards scrolling

$ tail -F /var/log/kern.log

locate (also a sibling of the updatedb command): Used to find files more efficiently using an index of files
find: Used to find files with specific attributes, extensions, and even names within a specific directory

find command are as follows:

-type: This is used to specify the type of file, which can be either file or directory
-delete: This is used to delete files, but may not be present, which means that exec will be required
-name: This is used to specify searching by name functionality
-exec: This is used to specify what else to do upon match
-{a,c,m}time: This is used to search for things such as time of access, creation, and modification
-d, -depth: This is used to specify the depth searching may delve recursively into
-maxdepth: This is used to specify the maximum depth per recursion
-mindepth: This is used to specify the minimum depth when recursively searching
-L, -H, -P: In order, -L follow symbolic links, -H does not follow symbolic links except in specific cases, and -P never follows symbolic links
-print, -print0: These commands are used to print the name of the current file on a standard output
!, -not: This is used to specify logical operations such as match everything, but not on this criteria
-i: This is used to specify user interaction on a match such as -iname test

- create a diff of two files 

Diffs in a unified format typically look like this:

$ sudo apt-get install patch diff
$ diff -urN fileA.txt fileB.txt 

apply patch 
$ patch --verbose --dry-run /etc/updatedb.conf < 001-myfirst-patch-for-updatedb.patch 

- creating symbolic links and using them effectively 

- tools such as SHA512sum and MD5sum to generate a unique hash

file-splitter.sh 
```
#!/bin/bash
FNAME=""
LEN=10
TYPE="line" 
OPT_ERROR=0
set -f

function determine_type_of_file() {
  local FILE="$1"
  file -b "${FILE}" | grep "ASCII text" > /dev/null
  RES=$?
  if [ $RES -eq 0 ]; then
    echo "ASCII file - continuing"
    
  else
    echo "Not an ASCII file, perhaps it is Binary?"
  fi 
}
```

- generating dataset and random files of various size 

dd if="inputFile" of="outputFile" bs=1M count=10. From this command, we can see:

if=: Stands for input file
of=: Stands for output file
bs=: Stands for block size
count=: Stands for numbers of blocks to be copied

- using the hexdump command. The hexdump command created a simplified "dump" of all of the bytes inside of the garbage0.bin




# Make a script behave like daemon 
- Keeping programs/scripts running after logoff

- Running a program continuously (forever) using looping constructs or recursion

```
recursive_read_input.sh script:
#!/bin/bash

function recursive_func() {

    echo -n "Press anything to continue loop "
    read input
    recursive_func
}

recursive_func
exit 0


#!/bin/bash
for (( ; ; ))
do
   echo "Shall run for ever"
   sleep 1
done
exit 0


#!/bin/bash
EXIT_PLEASE=0
while : # Notice no conditions?
do
   echo "Pres CTRL+C to stop..."
   sleep 1
   if [ $EXIT_PLEASE != 0 ]; then
      break 
    fi 
done
exit 0
```

- Invoking commands when they require permissions

Sudo doesn't activate a root shell or allow you access to other user accounts, which is unlike the su command.

```
# Cmnd alias specification

Cmnd_Alias READ_CMDS = /sbin/halt, /sbin/shutdown

# User privilege specification
root ALL=(ALL:ALL) ALL

bob ALL=(ALL:ALL) NOPASSWD: READ_CMDS

# Members of the admin group may gain root privileges
%admin ALL=(ALL) ALL

# Allow members of group sudo to execute any command
%sudo ALL=(ALL:ALL) ALL

# See sudoers(5) for more information on "#include" directives:

#includedir /etc/sudoers.d
```

- Sanitizing user input and for repeatable results
- Making a simple multi-level user menu using select
- Generating and trapping signals for cleanup

SIGHUP (1), SIGINT (2), SIGKILL(9), SIGTERM(15), SIGSTOP(17,18,23), SIGSEGV(12), and SIGUSR1(10)/SIGUSR2(12). 

kill command can be used easily as follows:

$ kill -s SIGUSR1 <processID>
$ kill -9 <processID>
$ kill -9 `pidof myprogram.sh`

$$: Which returns the PID of the current script
$?: Which returns the PID of the last job that was sent to the background
$@ :Which returns the array of input variables (for example, $!, $2)

a script itself. Using trap, kill, and signals, we can set timers or alarms (ALRM) to perform clean exits from runaway functions

- network interfaces (NICs) on their computer.
```
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=16.04
DISTRIB_CODENAME=xenial
DISTRIB_DESCRIPTION="Ubuntu 16.04.4 LTS"
NAME="Ubuntu"
VERSION="16.04.4 LTS (Xenial Xerus)"
ID=ubuntu
ID_LIKE=Debian
PRETTY_NAME="Ubuntu 16.04.4 LTS"
VERSION_ID="16.04"
HOME_URL="http://www.ubuntu.com/"
SUPPORT_URL="http://help.ubuntu.com/"
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"
VERSION_CODENAME=xenial
UBUNTU_CODENAME=xenial
```

- gathering network information 

```
if ping -q -c 1 -W 1 8.8.8.8 >/dev/null; then
  echo "IPv4 is up"
else
  echo "IPv4 is down"
fi

if ping -q -c 1 -W 1 google.com >/dev/null
then
  echo "The network is up"
else
  echo "The network is down"
fi

case "$(curl -s --max-time 2 -I http://google.com | sed 's/^[^ ]*  *\([0-9]\).*/\1/; 1q')" in
  [23]) echo "HTTP connectivity is up";;
  5) echo "The web proxy won't let us through";;
  *) echo "The network is down or very slow";;
esac
```

- Compressing tools 

bzip2, bzip2 is used to compress the files and folder at the same time.
zip, zip compress the files individually and then collects them in a single file.
TAR, file is a collection of different files and directories, which combines them into one file

compress and run the following command:
$ bzip2 filename

compressed individually:
$ zip -r file_name.zip files_dir

two archiving modes:
```
-x: extract an archive
-c: create an archive
-f: FILE name of the archive—you must specify this unless using tape drive for archive
-v: Be verbose, list all files being archived/extracted
-z: Create/extract archive with gzip/gunzip
-j: Create/extract archive with bzip2/bunzip2
-J: Create/extract archive with XZ
```

create a TAR file, use the following command:

$ tar -cvf filename.tar directory/file
$ cat /etc/logrotate.conf

- adding configuration to /etc/logrotate.d 

configuration to /etc/logrotate.d/, first open up a new file there:

$ sudo nano /etc/logrotate.d/example-app

run the following command:

$ sudo logrotate /etc/logrotate.conf --debug

create database 
$  sqlite3 testdb

ssh-keygen command is used to create a SSH key. Run the command as follows:
$ ssh-keygen

- shell script to run daily, place it in the cron.daily folder

cron folders:
/etc/cron.hourly
/etc/cron.daily
/etc/cron.weekly
/etc/cron.monthly

add the following line in your script:
 * * * * * /etc/name_of_cron_folder/script.sh
 
 You can list the existing jobs by running the following command:
$ crontab -l

Run the following command:
$ crontab -e

- The dd command is mainly used for converting and copying files

- mount command. To mount a file system onto the file system tree, use the mount command. This command will instruct the kernel to mount the file system found on a particular device

$ mount -t ext4 /directorytobemounted /directoryinwhichitismounted -o ro,noexec

- The scp command is used to securely transfer files between two hosts

$ scp from_host_name:filename /local_directory_name

w3m is a text-based web browser. Using w3m, we can browse web pages through our terminal window.

ELinks is also a text-based web browser. 

$ w3m google.com

- a packet sniffer tool called tcpdump. This tool is used to filter or capture TCP/IP packets that are transferred or received over a network

- used the file command to get the information about the binary.

$ file binary_name

- string command will return the string within that binary file.

$ strings binary_name

- od command, you will get the hexdump of the file.

$ od -tx1 binary_name

- list those symbols by running the nm command.

$ nm binary_name

- ldd command, you can check which shared library your binary is linked with.

$ ldd binary_name

- using openssl to encrypt files 

$ echo "Welcome to Bash Cookbook" | openssl enc -base64

$ echo " V2VsY29tZSB0byBCYXNoIENvb2tib29rCg==" | openssl enc -base64 -d

encryt file 
$ openssl enc -aes-256-cbc -in /etc/services -out enc_services.dat

decrypt file 
$ openssl enc -aes-256-cbc -d -in enc_services.dat > services.txt




# Writing bash to win and profit 
- The HTTP GET method is used to request a data from a specified resource.

$ curl -H "Content-Type:application/json" -H "Accept:application/json" -X GET http://host/resource/name

$ curl -H "Content-Type:application/xml" -H "Accept:application/xml" -X GET http://host/resource/name

- POST: The HTTP POST method is used to send the data to server.

$ curl --data "name1=value1&name2=value2" http://host/resource/name

$ curl -T "{File,names,separated,by,comma}" http://host/resource/name

- get links
 
$ wget -q -r -l5 -x 5  https://imdb.com
$ cd ..
$ grep -r -Po -h '(?<=href=")[^"]*' data/ > links.csv

- play all the .mp3 files:
$ play *mp3

- DMZ using iptables. Create a dmz_iptables.sh script and write the following code in it:

- evtest Linux tool. This tool is used to monitor the input device events.

display the information on the input device. It will display all the events supported by the device. 

- TLP is a command-line tool; it is used for power management and will optimize the battery life.

```
get the operation mode:

$ sudo tlp start
To get the system information as well as TLP status, run the following command:

$ sudo tlp-stat -s
To view TLP configuration, run this command:

$ sudo tlp-stat -c
To get all the power configurations, run the given command:

$ sudo tlp-stat
To get the battery information, use this command:

$ sudo tlp-stat -b
To get the fan speed and temperature of the system, run the next command:

$ sudo tlp-stat -t

-b: Battery
-t: Temperature
-p: Processor data
-c: Configuration
-s: System information
```
- color codes for the tput command are as follows:

Code

Color   

0  Black

1  Red

2  Green

3  Yellow

4  Blue

5  Magenta

6  Cyan

7  White

- two tty sessions as:

Terminal A = /dev/pts/4
Terminal B = /dev/pts/7

- Zenity is used to add a graphical interface to shell scripts using a single command.

# the special -- 
the argument behind it will be treat as pass to bash itself and assigned $@