Licão 02 shell basics bash intro

Lesson 2
• Shell Basics
• Bash shell Introduction
• Bash commands
• Booting process and run levels
• role of shells in the Linux environment
• Shells and Shell environment (/etc/shells)
• Command substitution = Shell variables intro
• Shell Command Line Syntax
• Why Use Shell scripts ?
• Shell Script consists of
• Looking at a Shell Script
• executing scripts and shebang

Shell Basics
• SHELL hierarchy, types, Login shell

Shell
• Acts as an interface between the user and the kernel.
• Is the command interpreter of UNIX.
• Provides powerful programming capabilities.
• System administration.
• Text processing.
• File management.
• UNIX Utilities and Applications.
• User can customize his/her own shell.
• Users can use different shells on the same machine.

Shell
To use the shell you simply type commands.
A command is a computer program, which is built to perform a specific
task.
Examples of commands include: ls clear cal date
• If your Linux system is booted into a text mode
you can start using the shell as soon as you log in.
• If you started in a graphical mode (GUI) Gnome desktop or Kde desktop
you can open a shell by going to : Applications >> Accessories >> Terminal.
Using Linux Terminal
Alternatively, you can switch to a virtual console by pressing Ctrl-Alt-F1
and logging in with your usernameand password.
To switch back to graphical mode, simply press Alt-F7.

Online shells
• Linux zoo : linuxzoo.net
• There is 15 min shell : http://simpleshell.com
• Short time shell : http://cb.vu/
• Side by side shell & executed outputs :
http://www.compileonline.com/execute_bash_online.php
• Cloud Shells:
– Amazon EC2
– Ibm cloud instance

Shell Features
• Filename completion
• Command-line history.
• Multiple job control.
• Redirection (program to file).
• Pipes (program to program).
• Storage variables.
Some of the common features that most all shells have to offer:

Bash is the shell, or command language interpreter, for the Linux operating system.
The name is an acronym for the Bourne-Again SHell, a pun on Stephen Bourne, the author of the
direct ancestor of the current Unix shell sh, which appeared in the Seventh Edition Bell Labs Research
version of Unix Bash Reference Manual.
• Developed by GNU project.
• The default Linux shell.
• Backward-compatible with the original sh UNIX shell.
• Bash is compatible with sh. Incorporates features from Korn shell, ksh and C shell csh.
• Bash is the default shell for Linux.
runs on every version of Unix and other op. systems such as ms-dos, os/2, Windows.
Quoting from the official Bash home page:
Bash is the shell, or command language interpreter, that will appear in the GNU operating system. It is intended to conform to the
IEEE POSIX P1003.2/ISO 9945.2 Shell and Tools standard. It offers functional improvements over sh for both programming and
interactive use. In addition, most sh scripts can be run by Bash without modification.
bash shell introduction

The Bash syntax is an improved version of the Bourne shell syntax.
In most cases Bourne shell scripts can be executed by Bash without any problems.
• Command line editing.
• Command line completion.
• Unlimited size command history.
• Prompt control.
• Indexed arrays of unlimited size (Arrays).
• Integer arithmetic in any base from two to sixty-four.
• Bash startup files - You can run bash as an interactive login shell, or interactive non-login shell.
• Bash conditional expressions: Used in composing various expressions for test builtin or [[ or [ cmds.
• The Directory Stack - History of visited directories.
• The Restricted Shell: A more controlled mode of shell execution.
• Bash POSIX Mode: Making Bash behave more closely to what the POSIX standard specifies.
bash shell improvements

Bash v4.0 Features
Usual run time environment: POSIX
• Command and file name completion - Bash can automatically fill in partially typed
commands or arguments to the commands
• Arithmetic support:
‒ Integer arithmetic supported.
‒ Floating point arithmetic is not supported.
‒ Exponential notation is limited via printf buildin.
‒ Date and time arithmetic is not supported.
• Hash table: Bash uses a hash table to remember the full pathnames of executable files.
• Pattern Matching and regular expressions are supported.
• Globbing - For example, you can use *.conf to match all those conf files in /etc directory.
• Directory stack is supported via pushd and popd builtins.
• Command history and History completion fully supported by Bash.
• Custom command prompt - Allows you to change the default prompt.

Bash Shell Commands
The bash shell comes with two types of commands:
• Internal commands
(builtins) - part of the shell itself, i.e. built into the shell.
• External commands
separate binaries stored in /sbin, /usr/sbin, /usr/bin, /bin, or /usr/local/bin directories.
The bash shell understands the following types of commands:
• Aliases such as ll
• Keywords such as if
• Functions (user defined functions such as genpasswd)
• Built in such as pwd
• Files such as /bin/date
The type command can be used to find out a command type.

Bash Shell Commands
type command
can be used to find out if a command is built in or an external binary file.
Find out if ls is built in or an external command
[root@localhost ~]# type –a ls
ls is /bin/ls
Find out if history is built in or an external command
[root@localhost ~]# type –a history
history is a shell build in
Some commands are supplied as both internal and external commands. Ex:
[root@localhost ~]# type -a true
[root@localhost ~]# type -a echo
echo is a shell built in
echo is /bin/echo

List of command bash keywords and built in commands
• JOB_SPEC &
• (( expression ))
• . filename
• [[:]]
• [ arg... ]
• expression
• alias
• bg
• bind
• builtin
• caller
• case
• command
• compgen
• complete
• continue
• declare
• dirs
• disown
• echo
• enable
• eval
• exec
• exit
• export
• false
• fc
• fg
• for
• getopts
• hash
• help
• history
• if
• jobs
• kill
• let
• local
• logout
• popd
• printf
• pushd
• pwd
• read
• readonly
• return
• select
• set
• shift
• shopt
• source
• suspend
• test
• time
• times
• trap
• true
• type
• typeset
• ulimit
• umask
• unalias
• unset
• until
• variables
• while

Booting Process
• Hardware configuration check.
• The operating system file /vmunix ( the UNIX kernel) gets loaded.
• The kernel brings up the swapper and the init program.
• Jobs of init are:
– Takes the system into the multi-user mode.
– Checks the integrity of the file systems.
– Mounts the file systems
– The login process gets executed.
– After successful login, the shell appears.

Run Levels
• UNIX system has several modes of operation called system
states ( or run levels). These are:
0 : shutdown state
1 : administrative state
s or S : single user state
2 : multi-user state
6 : stop and reboot state
• These states are passed to the init program, which operates the
system in the appropriate state.

role of shells in the Linux environment
Login
User can login locally into the console when in runlevel # 3 or graphically when in runlevel # 5
(depending on distribution). In both cases you need to provide username and password.
Bash uses the following initialization and start-up files:
1. /etc/profile - The system wide initialization file, executed for login shells.
2. /etc/bash.bashrc - The system wide per-interactive-shell startup file.
This is a non-standard file which may not exist on your distribution.
Even if it exists, it will not be sourced unless it is done explicitly in another start-up file.
3. /etc/bash.logout - The system wide login shell cleanup file, executed when a login shell exits.
4. $HOME/.bash_profile - The personal initialization file, executed for login shells.
5. $HOME/.bashrc - The individual per-interactive-shell startup file.
6. $HOME/.bash_logout - The individual login shell cleanup file, executed when login shell exits.
7. $HOME/.inputrc - Individual readline initialization file.

role of shells in the Linux environment
Bash Startup Scripts
Script of commands executed at login to set up environment. Ex: setup JAVA_HOME path.
Login Shell
Login shells are first shell started when you log in to the system. Login shells set environment which
is exported to non-login shells. Login shell calls the following when a user logs in:
– /etc/profile runs first when a user logs in runlevel # 3.
– /etc/profile.d
– $HOME/.bash profile, $HOME/.bash_login, and $HOME/.profile, runs second when a user
logs in in that order.
$HOME/.bash_profile calls $HOME/.bashrc, which calls /etc/bashrc (/etc/bash.bashrc).
Non-Login Shell
When an interactive shell that is not a login shell is started, bash reads and executes commands
from /etc/bash.bashrc or /etc/bashrc and $HOME/.bashrc, if these files exist.
First, it calls $HOME/.bashrc. This calls /etc/bash.bashrc, which calls /etc/profile.d.
Bash Logout Scripts
When a login shell exits, bash reads and executes cmds from file $HOME/.bash_logout, if it exists.

Other standard shells
In Linux, a lot of work is done using a command line shell.
Linux comes preinstalled with Bash. Many other shells are available under
Linux:
• tcsh - An enhanced version of csh, the C shell.
• ksh - The real, AT&T version of the Korn shell.
• csh - Shell with C-like syntax, standard login shell on BSD systems.
• zsh - A powerful interactive shell.
• scsh- An open-source Unix shell embedded within Scheme programming language.
Find out available binary packages shell list
To find list available shell packages in Red Hat EnterpLinux / CentOS Linux / Fedora Linux, enter:
yum search shell
To find list of available shell packages under Debian Linux / Ubuntu Linux, enter:
apt-cache search shell

shells
The shell allows users to enter commands and then interprets these commands
into instructions for Linux operating system.
Linux allows to use a number of different shells; default shell installed with Linux is
bash shell.
default shell is specified in /etc/passwd file and can be changed there on a per user basis.
To change to a different shell, you simply type the full path along with the
command name of the new shell. Ex. /bin/sh
To return to the default login shell, type exit or press CTRL-D.
The default login shell is contained in the environment variable SHELL.
Each shell has corresponding resource configuration file - rc file, located in /etc directory
It contains global settings for the shell. For the bash shell the file is /etc/bashrc.
Related information to environment goes to /etc/profile
To know which default shell is currently configured, type: echo $SHELL

shells
The available shells and paths are listed in /etc/shells
Shell Explanation
/bin/bash Bourne-Again Shell that is compatible with the sh shell, which includes features of both the Korn
and C shells. This may be a link to the /bin/bash2 file on some distributions.
/bin/sh The Bourne Shell. On many systems this file is linked to /bin/bash.
/bin/ash A System V version of the sh shell.
/bin/bsh This file is linked to /bin/ash.
/bin/bash2 Bourne-Again Shell version 2.
/bin/csh The Berkeley UNIX C shell.
/bin/tcsh An enhanced version of the Berkeley UNIX C shell.
chsh command is used to change the default shell for the user
Options Alternate Function
-s --shells Specifies the default login shell for this user.
-l --list Lists the shells specified in the /etc/shells file.
-u --help Displays the options for the chsh command.
-v --version Displays version information for the shell.

Pathnames of valid login shells
/etc/shells is a text file which contains the full pathnames of valid login shells.
File is consulted by chsh and available to be queried by other programs such as ftp servers.
cat /etc/shells
which command
You can also use the which command to display the full path of (shell) commands:
which bash
However, which cannot tell you exactly what the shell will execute in all cases as it is an external
command.
For more accurate information, use type command as follows:
type -p commandName
type -p bash
type -p date
type -p gcc
type –p echo

shells
Editing shell commands with the Readline Library:
Key Combination Function
Ctrl-b Move back one character.
Ctrl-f Move forward one character.
Del Delete the character to the left of the cursor.
Ctrl-d Delete the character underneath the cursor.
Ctrl-a Move to the start of the line.
Ctrl-e Move to the end of the line.
Esc-f Move forward a word.
Esc-b Move backward a word.
Ctrl-l Clear the screen, reprinting the current line at the top.
Ctrl-k Kill (delete) the text from the current cursor position to the end of the line.
Esc-d Kill from the cursor to the end of the current word, or if between words, to the end of the next word.
Esc-Del Kill from the cursor the start of the previous word, or if between words, to the start of the previous word.
Ctrl-w Kill from the cursor to the previous white space.
This differs from Esc-Del because the boundaries separating words differ.
• Editor can be configured globally using /etc/inputrc file for global changes.
• To make changes for specific user edit .inputrc file located in user’s home directory.
This file can be used to change key mappings for Readline Library editor, and map keys to commonly used commands.
•To view keyboard bindings type the command: bind -v

Shell Command Line Syntax
<command> [options] [arguments]
• Everything is separated with white space
• Options are just a special interpretation of arguments, generally identified with a
prefixed hyphen
• POSIX options (long options) use double hyphen prefix
often spell out option with a word rather than just a letter ( --verbose instead of -v )
- Arguments are separated with whitespace
- sometimes whitespace needs to be part of the argument itself (ex: spaces in filenames)
 command filename with spaces
Without any guidance, the shell will interpret this input as a command with various arguments.
Quoting is the easiest way to guide the shell in this matter.
There are two forms...

Shell Command Quoting
Single quotes: command ‘filename with spaces’
- Quotes let shell know where an argument starts and stops (quotes not included);
- It doesn’t bother with what’s between markers - its interpreted strictly as data;
this line would be interpreted as a command with one argument: filename with spaces
Double quotes: command “filename with spaces” - equals single syntax, but interpret differently:
- Quotes let the shell know where an argument starts and stops,
- but data between is loosely examined for metacharacters.
this line would also be interpreted as a command with one argument: filename with spaces
Metacharacter any character that has more than one meaning or interpretation.
Ex: single and double quotes.
- In normal context, they denote endpoints for arguments, not actual quote characters;
- But if you need a quote in your argument value (ex: filename smith’s) use the
backslash: escape metacharacter command (ex: filename smith’s)
tells shell to interpret character following backslash as normal character, not a metacharacter
This allows you to use metacharacters as regular characters

Command substitution = Shell variables intro
Command substitution $(...) and `...`
Some commands say interesting things to include as parameters on other commands.
command substitution operators allows to include output of a command in another command.
foo:~ $ whoami
Gerald
foo:~ $ grep gerald /etc/passwd
gerald:x:500:500:G Smith:/home/gerald:/bin/bash
It's much easier like using substitution:
foo:~ $ grep `whoami` /etc/passwd
gerald:x:500:500: G Smith:/home/gerald:/bin/bash
foo:~ $ grep $( whoami ) /etc/passwd
gerald:x:500:500: G Smith:/home/gerald:/bin/bash
# echo `pwd`

Why Use Shell scripts ?
• Batch processing of commands
• Repetitive tasks
• You can use shell scripts to automate administrative tasks.
• Encapsulate complex configuration details.
• Get at the full power of the operating system.
• The ability to combine commands allows you to create new
commands Adding value to your operating system.

Why Use Shell scripts ?
Shell scripting involves placing series of shell commands in a file for
later re-use.
• Simple shell scripts run command after command, as if user typed
them in at cmdline
• Complex shell scripts make decisions about what commands need to
be run, and might repeat certain sequences to accomplish some task
Scripts start executing at top and stop when there are no more
commands to execute or when exit is called.

Practical examples where shell scripting actively used
• Monitoring your Linux system.
• Data backup and creating snapshots.
• Dumping Oracle or MySQL database for backup.
• Creating email based alert system.
• Find out what processes are eating up your system resources.
• Find out available and free memory.
• Find out all logged in users and what they are doing.
• Find out if all necessary network services are running or not. For example if web server failed
then send an alert to system administrator via a pager or an email.
• Find out all failed login attempt, if login attempt are continue repeatedly from same network IP
automatically block all those IPs accessing your network/service via firewall.
• User administration as per your own security policies.
• Find out information about local or remote servers.
• Configure server such as BIND (DNS server) to add zone entries.
• Shell scripting is fun. It is useful to create nice (perhaps ugly) things in shell scripting. Here are a
few examples of scripts I use everyday:
• Find out today's weather
• Find out what that site is running
• Download RSS feeds and display them as you login or in your email.
• Find out the name of the MP3 file you are listening to.
• Monitor your domain expiry date every day.

Shell Script consists of:
• Shell keywords
if..else, do..while.
• Shell commands
pwd, test, echo, continue, type.
• Linux binary commands
w, who, free etc..
• Text processing utilities
grep, awk, cut.
• Functions
add frequent actions together via functions.
Ex: File /etc/init.d/functions contains functions to be used by most or all
system shell scripts in the /etc/init.d directory.
• Control flow statments
such as if..then..else or shell loops to perform repeated actions.

Programming or Scripting ?
• Difference between programming and scripting languages:
– Programming languages are generally a lot more powerful and a lot faster than
scripting languages.
Programming languages generally start from source code and are compiled into an
executable. This executable is not easily ported into different operating systems.
– A scripting language also starts from source code, but is not compiled into an
executable.
Rather, an interpreter reads the instructions in the source file and executes each
instruction.
Interpreted programs are generally slower than compiled programs.
The main advantage is that you can easily port the source file to any operating system.
bash is a scripting language. Other examples of scripting languages are Perl, Lisp, and Tcl.

Fast script exemple
• There are two major text editors in Linux:
– vi, emacs (or xemacs).
So fire up a text editor; for example:
$ vi &
and type the following inside it:
#!/bin/bash
echo “Hello World”
The first line tells Linux to use the bash interpreter to run this script.
We call it hello.sh. Then, make the script executable:
$ chmod 700 hello.sh
$ ./hello.sh
Hello World

Looking at a Shell Script
[root@localhost ~]# bash myscript
Hello, what is your name?
Linus
Hello Linus, it’s nice to meet you!
The current time is: Sun Nov 29 09:39:33 CST 2009
[root@localhost ~]#
echo “Hello, what is your name?”
read NAME
echo “Hello $NAME, it’s nice to meet you!”
echo -n “The current time is: “
date
• Using the echo command, the script asks a question.
• The read cmd accepts input from user and stores it in environment variable NAME
• Script finishes up with more echo statements, greeting user and announcing today’s date
If we put the example in file called myscript, we can execute script as:
bash myscript
bash will open myscript and execute each line as if user had typed it in manually.

Shell Script as interpreter
In previous example, there’s five commands in a regular file and fed the
filename to bash on command line, which in turn executed the commands.
Running in this way, bash operated as an interpreter.
Reading each line of file, bash would interpret words and perform actions.
There are many interpreted languages available for scripting including all
shells:
python, ruby, perl, etc.

executing scripts
To run a script, feed the file to the appropriate interpreter:
bash mybashscript
perl myperlscript
This works, but sometimes it’s more user-friendly to allow the script to be
run directly, removing the need for an external call to the interpreter:
./mybashscript
myperlscript
To remove need for external call to interpreter use the shebang in the script
To remove need for external call to interpreter use the shebang ( #! ) in the
script
Also known as a hash bang, pound bang or hashpling.

shebang
• When the kernel is asked to execute a file, it must either be machine code, or a file
that starts with the shebang sequence.
• If first two characters of file are a hash mark and an exclamation mark, the rest of
the line is expected to be an absolute pathname for an interpreter, which will
then be invoked to “run” the file as a script.
#!/bin/bash
echo “Hello, what is your name?”
read NAME
echo “Hello $NAME, it’s nice to meet you!”
echo -n “The current time is: “
date
add an appropriate shebang to the example:
Then add execute permissions and the script can be run directly:
[root@localhost ~]# chmod 755 myscript
[root@localhost ~]# ./myscript
Hello, what is your name?
Linus
Hello Linus, it’s nice to meet you!
The current time is: Sun Nov 29 09:39:33 CST 2009
[root@localhost ~]#

Challenges questions
• Write a command names, which can display the files to the terminal.
• Write a command to list details of all files ending in '.perl' in reverse time order.
• Write a command to list your running programs.
• Write a command to list files waiting to be printed.
• Write a command to delete 3 files called file1.txt, file2.txt, and data1.txt.
• Write a command to creates a new sub-directory called 'foo' in /tmp.
• Write a command to delete the directory called 'foo'.
• Write a command to read all ls command options.

Challenges answers
Write a command names, which can display the files to the terminal.
[root@localhost ~]# ls
Write a command to list details of all files ending in '.perl' in reverse time order.
[root@localhost ~]# ls -r *.perl
Write a command to list your running programs.
[root@localhost ~]# ps
[root@localhost ~]# top
[root@localhost ~]# top –u username
Write a command to list files waiting to be printed.
[root@localhost ~]# lpq
Write a command to delete 3 files called file1.txt, file2.txt, and data1.txt.
[root@localhost ~]# rm file1.txt file2.txt data1.txt
[root@localhost ~]# rm file{1,2}.txt data1.txt

Challenges answers
Write a command to creates a new sub-directory called 'foo' in /tmp..
[root@localhost ~]# mkdir /tmp/foo
Write a command to delete the directory called 'foo'.
[root@localhost ~]# rmdir foo
Write a command to read all ls command options.
[root@localhost ~]# man ls

Licão 02 shell basics bash intro

More Related Content

What's hot

Similar to Licão 02 shell basics bash intro

More from Acácio Oliveira

Recently uploaded

Licão 02 shell basics bash intro