BASH

BASH

Michael Musick

CSC 415: Programming Languages

1

BASH

The History of bash

Origins

The origins of bash, also known as the Bourne Again shell, which was named in

tribute to Steve Bourne's shell, is a pretty basic and linear story. Brian Fox, the man who

wrote the first versions of bash, officially released bash on January 10, 1988. He

continued to improve the shell until 1993. That was when Chet Ramey took over, he

started working with Brian Fox back in 1989. In 1995 Chet started to work on release

2.0 which was released in December 1996, to this day Chet Ramey still works on and

maintains bash and is up to release 4.3.This language was created for use in the GNU

project, the purpose of this project was to create a UNIX-compatible operating system

that would replace all commercial UNIX utilities with freely distributable ones. Thanks to

this work with the GNU project, all versions of bash from 0.99 to the most recent

releases have been available to the public free of cost. (Newham 26)

Current Events

Recently a bug has been found within the bash shell, this bug has said to be just

as bad if not worse than the Heartbleed bug. This bug has been aptly named the

Shellshock bug. The versions stated to be affected are all versions up to 4.3, this is

roughly 25 years worth of bash versions. What the bug actually does is pretty

dangerous, according to an article written by Troy Hunt this bug "allows remote

attackers to execute arbitrary code" and he later refers to this attack as a "code injection

attack". What he is saying is that an attacker can execute a shell command of their

2

BASH

choosing on any vulnerable machine. The ramifications of a bug like this are nearly

limitless and the damage that can be done depends on what the attacker would want to

do. Luckily there has been a patch to fix this glaring bug almost immediately upon its

discovery. (Hunt)

Names, Bindings, and Scopes

When talking about bash and how it works its best to talk about its variables first,

since that is one of the more peculiar traits of most interpreted languages. Much like

with Java script when declaring a variable the naming method is very relaxed. All you

need to do is something along the lines of this when declaring a variable.

COLOR="black"

NUMBER="9"

Now, if you want to see what is stored inside the variables a user can use the $ to get

the content of the variable, for example.

echo "This is a string: $COLOR"

echo "And this is a number: $NUMBER"

This all seems to be very basic stuff but it shows how very basic the syntax of bash can

be, even Java script indicates the end of a line with a semi-colon, bash has a different

use for semi-colons. There will be more on that later, getting back to variables in bash,

take note at how the variable was declared, this is a naming procedure that is required.

Putting a space between the variable name and its value results in an error. Looking

3

BASH

back at the examples used to show how variables are declared, all upper case letters

were used, and this is not required but are usually capitalized by default. Variables in

Bash are case sensitive but using all upper case letters when naming variables does

improve the readability of the language. Reserved variables in bash is very interesting,

there are two different types of reserved variables, there are Bourne shell variables and

then Bash reserved variables. The difference is Bourne shell variables are reserved for

most shells and treated the same with each shell whereas Bash reserved variables are

only used by Bash and in other shells are not treated as reserved variables. A couple of

reserved Bourne shell variables are variables such as HOME which shows the current

user's home directory, CDPATH which is used as a search path for the cd built-in

command. As for Bash reserved variables the list is much larger, a couple of variables

out of this large list BASH_VERSION which gives the current version number of the

current instance of bash, EUID gives the current numeric ID of the current user, these

are just a few examples of the basic Bash and Bourne shell reserved variables. Scoping

with Bash is very simple if a variable is just declared it is treated as a global variable

regardless of where this variable is declared. It is possible to easily change this simply

by adding local to the declaration, for example "var=23" would be treated at a global

variable by default but by changing that to "local var=23" will change its declaration to a

local variable. Even though variables default to global it is possible to declare a variable

as global just by adding global to the declaration of the variable much like what was

done with the examples for local variables. This is important to remember because in

Bash before a function is called all variables declared within the function are invisible

4

BASH

outside the body of the function, not just the ones that were declared as local. This

feature of scoping with Bash makes for a very flexible language.

Data Types

When it comes to data types in Bash there are only 4 data types: strings,

integers, constants, and arrays. With this being the case all variables in Bash are

treated as strings until the script determines what the data type actually is. This is a

common feature in most interpreted languages. There is a feature in Bash that will be

covered that can assign a data type of a variable before the execution of the script, this

is called the declare feature. This declare feature is a very large portion of data types in

Bash. As previously mentioned there are only four data types in this language, but the

declare feature gives a user many more options for what they want to do with their

variables. To use the declare feature it is similar to the previously mentioned method for

declaring local and global variables. The following example is how to declare a variable

as an integer: “declare –i num1=12” This will declare this variable as an integer, this is

not a practice that is commonly used since it can limit what a programmer could do with

Bash a great deal. Strings are ironically the most common form of data type in Bash, it

is this way simply because all variables that have not been declared otherwise through

the use of the declare feature are treated as strings until the interpreter determines what

that variable needs to be, this is an easy job given that the only other options are array,

constant or an integer. There are multiple ways to declare an array in Bash, what is to

follow are a few examples of how to manipulate arrays. The first is simply declaring

arrays and assigning values to the arrays.

5

BASH

Unix[0]=’Ubuntu’

Unix[1]=’Debian’

The other way to create an array in Bash is to initialize an array during declaration, the

following is an example of that.

Declare –a example=(value1 value2 value3 value4)

An important thing to remember with this feature if there is white space in the elements

of the array it needs to be enclosed with quotes like this.

Declare –a example=(‘value one’ ‘value two’ ‘value three’ ‘value4’)

Even the values that don’t have any white space need quotes in this type of declaration.

The syntax to print the elements of an array is as follows: echo ${example[@]} and this

will print all of the elements of an array. If the user wishes to see a certain element with

in an array just replace the @ with the numeric value remembering that the array index

with Bash starts at 0. The parameter use to see the length of a Bash array is $

{#example[@]}. These are just a small sample of a few ways to manipulate arrays in

Bash, there are obvious commands for deleting arrays, there is a very simple way to

concatenate two arrays into a single array, the way to do that is as follows

Unixexample=(“${Unix[@]}” “${example[@}”) and the new array would be called

Unixexample and would contain the elements of both arrays starting with whichever

array was first entered into the command, in this case the first elements would be from

the Unix array. When it comes down to data types arrays are the most complex aspect

of this part of the language. As for multi-dimensional arrays, this is currently not

6

BASH

supported by Bash, even though there have been claims that it is possible to simulate a

multi-dimensional array in Bash, the feature is not officially supported yet. Declaring a

constant is much more simple in Bash, all a user has to do is use the declare feature,

the following is an example of how to use the feature to create a constant data type in

Bash.

Declare –r example=”sample”

This uses the declare feature to create the variable example with the string value of

sample and is set to a read only variable that can’t be modified by the Bash script or any

of the functions within the script. The only data types not mentioned yet are the most

basic types, integers and strings. Integers can be declared simply by doing one of the

two following examples.

Example1=19

Declare –i example2=23

One is simply declaring a numeric value to the variable named example1 the other

example uses the declare feature, both are viable options even though the first example

is the more frequently used method. Strings are the easiest data type to manage in

Bash since all variables are initially treated as strings. Regardless the following is an

example of declaring a string in Bash.

SAMPLESTRING=”this is a string”

There is no command in the declare feature to set the variable data type to a string

since the default data type for all variables in Bash is that of a string.

7

BASH

Expressions and Assignment Statements

Operator precedence in Bash is a very basic almost left to right set up and easy

to remember even for someone who may have only complete a basic algebra class.

The easiest way to remember operator precedence for Bash is that it starts with

multiply, divide, add, and subtract, then compound logical operators such as the && (the

and operator), || (the or operator), -a (the declare operator to make a variable an array),

and –o (another option for the or operator) have low precedence and the order of

evaluation is usually left-to-right. The list below is the order of precedence for operators

in Bash from highest to lowest.

1. Var++ var are the post increment and decrement operators

2. ++var –var are the pre increment and decrement operators

3. ! ~ the negation operators (inverts the sense of the following operator)

4. ** the exponentiation operator, raises a number to a power of n

5. * / % the multiplication division and modulo operators

6. + - the addition and subtraction operators

7. <<>> left, right shift

8. –z –n unary comparison if a string is or is-not null

9. –e –f –t –x etc. unary comparison for file tests

10.< -lt > -bt <= -le >= -ge compound comparison for strings and integers

11.–nt –ot –ef compound comparison for file tests

12.== -eq != -ne equality and inequality test operators for strings and integers

13.& (AND) bitwise

14.^ (XOR) exclusive OR, bitwise

8

BASH

15. | (OR) bitwise

16. ?: trinary operator (condition?result-if-ture:result-if-false)

17.= assignment (not to be confused with equality test)

18.*= /= %= += -= <<= >>= &= combination assignments (times-equal etc.)

19. , comma (links a sequence of operations)

(Cooper) Following this list along with the previous mentioned guidelines for operator

precedence in Bash it should be fairly easy to fully understand. Most of the operator

functions explain themselves but the more confusing ones such as the –lt –ge and other

compound comparison operators are just abbreviations of greater than or less than or

greater than or equal to and so on. File test operators are a bit stranger and are used

when checking to see if a file has certain properties, to simplify what they do it runs a

check with these operators and returns a true value for the operator. When testing for

multiple features the file test operator is declared as such –xzvf, this will then test each

of those but the whole thing is treated as a single operator. Commands like –x check if

the file has execute permission –f checks to see if the file is a regular file and not a

directory or device file. (Cooper) There are two features that are common place features

in less archaic languages that have yet to be implemented in Bash. Those features are

operator overloading and type conversions. These are both useful features in more up

to date languages but are features that have yet to be implemented in Bash. It is easy to

understand why type conversion has not been implemented yet in Bash since there is

such a limited number of data types there is no need for such a feature to be placed in

the language. Taking a look back at the operator precedence it is easy to see that

assignment statements function much like they do in just about any other language,

9

BASH

they have unary assignments such as post increment and pre increment assignments

also known as unary assignment operators as well as compound assignments such as

+= -= and *= assignments that make basic arithmetic functions simple. As for mixed-

mode assignments that is not something that is not needed and therefore not

implemented in Bash, given the limited data types available in the Bash language mixed

mode assignment is not currently something in high demand for Bash users.

Statement Level Control Structures

It was stated previously that the semicolons that are strangely absent from this

language so far would come into play. This is where they finally get some attention, the

best place to start is with the basics, if else statements. The structure of if else

statements are somewhat different for Bash users. Starting off with an example and

then explaining its structure is best.

if[ $1 -eq2 ]; then

    return1

elif[ $(($1%2)) -eq0 ]; then

    return0

else

    for(( d=3; d*d <= $1; d+=2 )); do

        if[ $(($1%$d)) -eq0 ]; then

            return0

        fi

    done

10

BASH

    return1

fi

The example here is part of a script that helps to determine if a chosen number is prime

or not. This is where semicolons come into use with Bash, the semicolon indicates the

end of the initial condition for the statement, which is located within the brackets. The

elif is Bash’s version of else if, which again requires brackets for the condition and then

a semicolon to end the conditional part of the statement. The fi found at the end of the if

then statement is used to end the if statements. This control structure also contains

another popular type of control structure, for loops. Like most other languages a for loop

starts off with the obvious for statement, then with in the parenthesis is the condition for

the loop, which is almost always limited to some sort of increment or decrement, and

then what is unique to Bash, there is a semicolon used to end the declaration of the

loop, and another feature unique to Bash is the do command, which basically states

what will be done with in the for loop. To indicate the end of the for loop the keyword

done is used to exit the loop. The next control structure to talk about is the while loop,

the following example will show the syntax for a while loop in Bash.

COUNTER=0

while [ $COUNTER -lt 10 ]; do

echo The counter is $COUNTER

let COUNTER=COUNTER+1

done

11

BASH

Like the if statements in Bash the while loop uses the brackets for its condition to test

against the semicolon ends the condition portion and like the for loop it has the do

command to tell the loop what to do and the done statement to exit the loop once the

condition has been met. The next control structure that can be used in bash is called the

case statement the following example that will be used to show the syntax of the case

statement has been pulled from tldp.org in their beginners guide for Bash.

case $space in

[1-6]*)

Message="All is quiet."

;;

[7-8]*)

Message="Start thinking about cleaning out some stuff. There's a partition that is

$space % full."

;;

9[1-8])

Message="Better hurry with that new disk... One partition is $space % full."

;;

99)

Message="I'm drowning here! There's a partition at $space %!"

;;

*)

Message="I seem to be running with a nonexistent amount of disk space..."

;;

12

BASH

Esac

There is much more than just this found on their example but a lot of it is not relevant to

the syntax of the case statement. Case statements are similar to if statements but are

able to be a bit more specific in their structure, this specific snippet is checking disk

usage and offering a warning message dependent on how much space is left. It is easy

to see that the syntax for case statements in Bash is very strange, but those semicolons

still play an important role the dual semicolons terminate each clause for the case

statements there is the case to initialize the case statement and much like with the if

statements the syntax to end the case statement is just case spelled backwards. The

final control structure covered in bash is the select construct. The syntax for a select

statement is as follows.

Select WORD [in LIST]; do RESPECTIVE-COMMANDS; done

The main use of the select construct is for making lists for a user to select from. While it

sounds pretty simple the user selects a word, or option from a list, once that selection is

made, the respective commands are executed and the list either repeats or the select

construct terminates depending on what the respective commands are. Control

structures like these really help expand the versatility of Bash which given its limited

capabilities is something that this language needs a great deal of.

Subprograms

Subprograms are a very simple concept in Bash. Subprograms are basically

functions that are created within a bash script and run their own parameters whenever

they are called. Subprograms are essential for larger programs. The following is a short

sample of a hello world program using subprograms.

13

BASH

#!/bin/bash

function quit {

exit

}

function e {

echo $1

}

e Hello

e World

quit

(Garrels) This script creates a function quit and a function e, it then hits the main portion

of the program which then calls the function e and passes the string “Hello” into $1 and

the string “World” into $1 the second time it is called. This prints Hello World onto the

screen then the quit function is called that exits the program. This is a very basic

example of how subprograms are used. Subprograms are used in the practice of

recursion which is required for larger and more complex programs and scripts. The

previous code sample also demonstrates how variables are passed between

subprograms in Bash as well. It may sound like a complex concept but it is as easy as

naming the variables and values to be passed into the subprogram.

Other Issues of Bash

One of the major issues with Bash is that it shows its age in comparison to

other languages. There is no support for abstract data types, encapsulation constructs

or concurrency. Given that Bash is completely run in the command prompt there is no

14

BASH

support for object oriented programming, exception or event handling. The archaic

structure of the language means that it is lacking in a lot of modern features that most

users take for granted. Putting the archaic structure of Bash aside there are not many

other issues that need to be address with the language.

Evaluation

The readability and writability of Bash go hand in hand with the syntax of the

language. The readability is not as bad as it may seem but given the strange structure

of the language it can be difficult to properly read through and understand a Bash script

the first time through can be difficult, the same goes with writability in this case, the

language has some very strange rules for how it is structured compared to most

programming languages. Once a user gets used to reading Bash scripts it slowly gets

easier but that is a small comfort given how difficult it is to get started on. When it

comes down to the reliability of the Bash language, putting shell shock aside the

language has not had many major issues in the past 25 years. The code executes

efficiently and is effective at doing what it is needed for. When it comes to the cost of

Bash all of the software is free to use thanks to the GNU project, which only leaves the

cost for training people to use the language meaning that the cost of using Bash is

extremely affordable.

15

BASH

BibliographyBezroukov, N. (2014, February 19). Softpanorama. Retrieved from Bash Control Structures:

http://www.softpanorama.org/Scripting/Shellorama/control_structures.shtml

Cooper, M. (2014, March 10). Advanced Bash-Scripting Guide. Retrieved from The Linux Documentation Project: http://www.tldp.org/LDP/abs/html/index.html

Garrels, M. (2008, December 27). Bash Guide for Beginners. Retrieved from The Linux Documentation Program: http://www.tldp.org/LDP/Bash-Beginners-Guide/html/index.html

Hunt, T. (2014, September 25). Troyhunt.com. Retrieved from Everything you need to know about the Shellshock Bash bug: http://www.troyhunt.com/2014/09/everything-you-need-to-know-about.html

Mikkey, M. G. (2014, July 27). The Linux Documentation Project. Retrieved from BASH Programming - Introduction HOW-TO: http://tldp.org/HOWTO/Bash-Prog-Intro-HOWTO.html#toc8

Newham, C. (2009). Learning the bash Shell, 3rd Edition. O'Reilly Media.

Ramey, C. (2014, September 24). BASH. Retrieved from The GNU Bourne Again Shell: http://tiswww.case.edu/php/chet/bash/bashtop.html

16