Globsyn

STUDENT REFERENCE

UNIX Basics

globsyn technologies XI - 11 & 12, Block - EP, Sector - V, Salt Lake Electronics Complex,

Calcutta - 700091, India

Globsyn

All rights reserved. No part of this book shall be reproduced, stored in a retrieval system, or transmitted by any means, electronic, mechanical, photocopying, recording, or otherwise, without written permission from the publisher. No patent liability is assumed with respect to the use of the information contained herein.

SR/UNIX/401/0204/SC/1.1

Globsyn

UNIX

UNIX

SR/UNIX/401/0204/SC/1.1 1

Module Objectives

Introduction to UNIX -----------------------------------------------------------------------------------------2 History of UNIX ------------------------------------------------------------------------------ 3 UNIX – a Multi-User Operating System ----------------------------------------------------- 3

Unix Shell ---------------------------------------------------------------------------------------------------------5 Unix Architecture ----------------------------------------------------------------------------- 6 Types of Shell --------------------------------------------------------------------------------- 7 Shell Commands ------------------------------------------------------------------------------ 7 Filter -----------------------------------------------------------------------------------------41

Introduction to vi Editor ----------------------------------------------------------------------------------- 63 Introduction ----------------------------------------------------------------------------------64 Before You Begin----------------------------------------------------------------------------64 Starting the vi Editor-------------------------------------------------------------------------65 Getting Out of vi -----------------------------------------------------------------------------65 The Two Modes of vi ------------------------------------------------------------------------66 Some Simple vi Commands -----------------------------------------------------------------66 Text Buffers in vi ----------------------------------------------------------------------------67 Cutting and Yanking-------------------------------------------------------------------------67 Pasting ---------------------------------------------------------------------------------------68 Settings for vi --------------------------------------------------------------------------------68 Abbreviations and Mapping Keys to Other Keys --------------------------------------------69 The EXINIT Environment Variable and the .exrc file---------------------------------------70 Recovering Your Work When Something Goes Wrong with Your Terminal---------------70 Warning About Using vi on the Workstations-----------------------------------------------71

Shell Programming ------------------------------------------------------------------------------------------ 72 Introduction to shell programming ----------------------------------------------------------73 Variables -------------------------------------------------------------------------------------74 Accept and Display User Input --------------------------------------------------------------77 Environment Variables ----------------------------------------------------------------------80 Positional Parameters ------------------------------------------------------------------------84 Command substitution -----------------------------------------------------------------------85 Conditional statement – the if construct -----------------------------------------------------87 Conditional statement – the case construct --------------------------------------------------95 Iteration – the while statement ---------------------------------------------------------------98 Iteration – the until statement -------------------------------------------------------------- 101 Iteration – the for statement---------------------------------------------------------------- 101 Controlling loops – break and continue ---------------------------------------------------- 103

Introduction to EXCEED ---------------------------------------------------------------------------------108 About Exceed ------------------------------------------------------------------------------ 109 X Window Systems and Exceed ----------------------------------------------------------- 109 Exceed Applications ----------------------------------------------------------------------- 109 Connecting to Hosts ----------------------------------------------------------------------- 110

UNIX

SR/UNIX/401/0204/SC/1.1 2

Introduction to UNIX

At the end of this chapter, you will be able to:

Appreciate History of UNIX

Appreciate UNIX as Multi-user Operating System

UNIX

SR/UNIX/401/0204/SC/1.1 3

History of UNIX

Unix history goes back to 1969 and the famous "little-used PDP-7 in a corner" on which Ken Thompson, Dennis Ritchie (the R in K&R) and others started work on what was to become Unix. The name "Unix" was intended as a pun on Multics (and was written "Unics" at first -- UNiplexed Information and Computing System). For the first 10 years, Unix development was essentially confined to Bell Labs. These initial versions were labeled "Version n" or "Nth Edition" (of the manuals), and were for DEC's PDP-11 (16 bits) and later VAXen (32 bits). Some significant versions include: V1 (1971): 1st Unix version, in assembler on a PDP-11/20. Included file system, fork(), roff, ed. Was used as a text-processing tool for preparation of patents. Pipe() appeared first in V2! V4 (1973): Rewritten in C, which is probably the most significant event in this OS's history: it means Unix can be ported to a new hardware in months, and changes are easy. The C language was originally designed for the Unix operating system, and hence there is a strong synergy between C and Unix. V6 (1975): First version of Unix widely available outside Bell Labs (esp. in universities). This was also the start of Unix diversity and popularity. 1.xBSD (PDP-11) was derived from this version. J. Lions published "A commentary on the Unix Operating System" based on V6. V7 (1979): For many, this is the "last true Unix", an "improvement over all preceding and following Unices" [Bourne]. It included full K&R C, uucp, Bourne shell. V7 was ported to the VAX as 32V. The V7 kernel was a mere 40 Kbytes!

UNIX – a Multi-User Operating System A multi-user operating system consists of one single computer, and several terminals are attached to it. The users of the different terminals can access the operating system and the resources through the network. The terminals can be of two types: Ø Dumb: The terminal having its own VDU, Keyboard and Mouse but does not

have a CPU of its own. The processing is done only at the machine where the operating system is loaded.

UNIX

SR/UNIX/401/0204/SC/1.1 4

Ø Smart: The smart terminals are having their own CPU’s and can work independently. This can also connect to another operating system or access other resources.

UNIX is known as portable true 16-bit multi-user operating system. It supports multiple users to be logged on concurrently, thus leading to multi-tasking and time-sharing operating system. Multi-Programming The concept of executing more than one program simultaneously by different users is known as multi-programming. Time–Sharing The concept of multi-programming is implemented through time sharing and multi-tasking. As the only CPU is taking care of the different programs for execution there, the entire time of the CPU is to be distributed amongst the different programs waiting for the execution. Here every program is assigned a specific period of CPU time, after that it is passed to another process waiting in the queue. Multi-Tasking A program is broken into different tasks and each task is treated as separate activity. So, when a program is waiting for the completion of one task, the CPU, rather than wasting time, starts the execution of another task. It is also the responsibility of the process management system to allocate the CPU time to all the processes in execution (a single login may have more than one process). UNIX maintains its own security mechanism for restricting the file tampering.

Differentiate between Dumb and Smart terminal?

UNIX

SR/UNIX/401/0204/SC/1.1 5

Unix Shell

At the end of this chapter you will be able to:

Appreciate UNIX Architecture

Know Types of Shell

Learn Shell Commands

Appreciate Filters

UNIX

SR/UNIX/401/0204/SC/1.1 6

Unix Architecture

Unix is known to be layered operating system. It mainly consists of three components. They are:

Ø Kernel: It is the heart of the Unix OS. It is the innermost layer of the operating

system that provides a uniform interface to the hardware. When the machine starts, the Boot Loader passes the control to kernel. It is responsible for managing the peripherals such as VDU, mouse, keyboard etc. It also deals with memory management and process management. The kernel does not deal directly with the user; instead it creates a new startup, interactive process for the user–shell.

Ø Shell: As user can’t interact directly with the hardware, shell acts as an interface between the end-user and the kernel. It is another utility program and is created automatically by the OS the moment user logs on. This shell is known as login shell. The shell is acting as a command interpreter between the end-user and the kernel. The shell is responsible for background processing, I/O redirection, pipes and filtering, variable and programming language constructs.

Application programs : These are the special programs created by the user for performing specific tasks. These utilities are provided with the operating system software and are also available from the software vendors. They are generally developed in C language or using the shell programming.

What is the function of kernel?

Kernel

Shell

End-User

Hardware

Commands

UNIX

SR/UNIX/401/0204/SC/1.1 7

Types of Shell

The instructions given by the user are submitted to the OS kernel via its shell in a format that the kernel can understand. Similarly the result returned by the kernel is interpreted in a user-friendly way by the shell. Any error messages displayed on the screen are also the task of the shell. Apart from this, a shell may house several utilities, compilers, facilities for programming constructs etc. Unix supports many shells, as follows: Ø sh: This is the UNIX Bourne Shell, developed at AT&T and is named after the

person who has developed it, Stephen R. Bourne.

Ø c shell: This is another shell developed at the University of California, which supports some syntaxes resembling with ‘C’ language.

Ø korn shell: This is Korn Shell, developed after the name of the developer David Korn, which comprises of the best features of C Shell and Bourne Shell.

Ø Others include:

• tcsh: An enhanced version of the C shell. • ash: A shell suitable when memory runs low on the machine. • zsh: A Bourne compatible shell.

Shell Commands

The efficiency of a Shell lies in its power to do processing and command interpretation, which are the most important functions of a shell. UNIX variants, which were originally built with the idea of supporting technical people, had a lot of features provided by their shells. These shells supported various types of commands, utilities and powerful programming constructs, which had the ability to create programs as good as those written in a language. UNIX shell commands can be broadly divided into three categories: Ø System: These commands give information about the environment, where the user is

working. Examples of such commands are who, date, clear, banner, passwd, etc. Ø File & Directory: To manipulate the files and directories we need some commands

like: pwd, ls, mkdir, cd, rmdir, mv, cp, rm, cmp, comm., chown, chgrp, chmod, head, tail etc.

Ø Communication: This is an important aspect in multi-user systems. There are

commands like write, mail etc.

UNIX

SR/UNIX/401/0204/SC/1.1 8

The date Command

System commands give information about the environment in which the user is working. Some of the system commands are as follows: Lets start with the date command, which is supposed to display the current date and time

$ date The output is as follows:

To customize the output, the date command can be used with arguments. To provide argument with the date command, -u option is used. The syntax for issuing the date command along with an argument is as follows:

date –u +format Some of the frequently used date format commands are given below: Ø To display the full weekday name, the %A option is used.

$date –u +%A Ø To display the full month name, the %B option is used.

$date –u +%B

UNIX

SR/UNIX/401/0204/SC/1.1 9

Ø To display the date in MM/DD/YY format, the %D option is used.

$date –u +%D Ø To display current time in hh:mm:ss (24 hour clock) format, the %T option is used.

$date –u +%T The collective information of all the field descriptors that can be used with the date command are given in the table below: Field descriptors Description %a Abbreviated weekday name. %A Full weekday name. %b Abbreviated month name. %B Full month name. %c Current date and time. %d Day of the month, 01 to 31. %D Date as MM/DD/YY. %H Hour, 00 to 23. %I Hour 01 to 12.

UNIX

SR/UNIX/401/0204/SC/1.1 10

%j Day of the year, 001 to 366. %M Minute, 00 to 59. %S Second, 00 to 61. %T Time as hh:mm:ss (24 hour clock). %u Weekday as decimal number, Monday represented as 1. %U Week number of the year, Sunday as the first day of the week. %V Week number of the year, Monday as the first day of the week,

ranging from 01 to 53 %w Day of the week, Sunday represented as 0. The date command can also be used along with its options without the use of –u. in this case, the field descriptors (%a, %b etc.) must be specified within quotes.

$date +”%A, %B %d” The output of the above command is given below:

View the manual pages of UNIX commands Sometimes, for a beginner, it is required to get information about a particular UNIX command like the different options of a command. UNIX provides the man command through which a user can get help on a particular command. The man command should be followed by the command name on which the user desires the help. The man command displays the manual pages of the desired command.

$ man date The above command displays the manual page of the date command. A part of the output is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 11

Login and Logout

The most important feature of any multi user system is its security feature. UNIX authenticates by the login prompt. Login screen is prompted every time the user wants to start a new session in UNIX. The screen asks for a valid name & password and if correct it gives the “$” prompt to an ordinary user or a “#” prompt to the administrator (root user). To terminate a session, logout from the shell by typing ‘exit’ or Ctrl + d.

uname : KNOW YOUR MACHINE’S NAME

By default, the uname utility will write the operating system name to standard output. When options are specified, symbols representing one or more system characteristics will be written to the standard output. The format and contents of the symbols are implementation-dependent If your machines is connected to a network, then it must have a name. If your network is connected to the Internet, then the name is required to frame your machine’s domain name. The uname command with –n option tells you the machine name in your network : $ uname –n Kaushik

UNIX

SR/UNIX/401/0204/SC/1.1 12

Many unix networking utilities use the machine’s name as an argument. In order to copy files from some machine, one has to know that machine’s name. uname with –r option shows OS’s version number. For example : $ uname –r 3.2 which expands to UNIX system V Release 3.2. the other options are : -a Behave as though all of the options -mnrsv were specified. -m Write the name of the hardware type on which the system is running to standard output. -n Write the name of this node within an implementation-dependent communications network. -r Write the current release level of the operating system implementation. -s Write the name of the implementation of the operating system. -v Write the current version level of this release of the operating system implementation.

UNIX

SR/UNIX/401/0204/SC/1.1 13

Displaying calendar

In UNIX it is possible to display the calendar of any year or month from 1 AD upto 9999 AD. The following command need to be typed from the ‘$’ prompt $ cal

The cal command can also be used to display the calendar of a particular month and year. $ cal 5 1975 where 5 is the month and 1975 is the year. The output of the following command is given in the next page.

UNIX

SR/UNIX/401/0204/SC/1.1 14

The cal command without any argument displays the calendar of the current month along with its previous and next month. The cal command with a year displays all the 12 months of that year e.g. cal 1975. cal command with the month number and the year number will display the calendar of that specific month of that year.

Online calculator

UNIX provides the user with its on-line calculator. The user needs to type at the ‘$’ prompt is: $ bc After issuing this command UNIX will wait for some input. User will enter some mathematical expressions and the moment the return key is pressed, the calculated value will be displayed on the screen.

To come out of the calculator, type quit and then press <Enter> or press <ctrl+d>. The $ prompt will be displayed.

The calculator can be used to calculate the square root of a particular number. The sqrt(number) function is used to achieve the purpose.

Current directory of the User

When users logs into the UNIX system, for the sake of security a user is directly taken to a particular directory. In this directory he has the permission to create files and directories. This directory is called that user’s home directory. Suppose, five users are working in the UNIX environment. Therefore, for each user directories like user1, user2, user3 and so on is generally created under /usr directory. So, when user2 logs into the system, UNIX will directly enter into /usr/user2 as his home directory, which means

UNIX

SR/UNIX/401/0204/SC/1.1 15

/usr/user2 is the default working directory for user2. This is a security measure adopted by UNIX so that users are forced to work in their respective home directories. This situation is not possible with Novell Netware. To display the directory where the user is currently working, the pwd command is used. $ pwd It will display the current working directory of the user along with the full path.

List of logged-in users To know the people working currently in the UNIX, the command to be used is:

$ who The above command will give three-column output

The first column shows the user name, the second column (pts/0, pts/1) shows the device names of their respective terminals (this name can be different for different UNIX variant like LINUX), the third column shows the date and time of logging in. The frequently used options used with who command are: Ø who –H displays the same output as above but with column headings.

UNIX

SR/UNIX/401/0204/SC/1.1 16

$who -H

Ø who am i command displays the status of the user who has invoked the command.

$ who am i

List of Processes

To see the processes currently running for a particular user, the command to be used is:

$ps

The frequently used options with the ps command are: Ø $ps –A will display all the processes running in the system

Ø $ps –u username will display the processes initiated by a particular user

The nohup command: Usually when a process is running and the user logs out of the system, the process gets terminated forcefully. If it is desired that the process will run though user has logged out, the nohup command is used.

$nohup vat file|wc -c

UNIX

SR/UNIX/401/0204/SC/1.1 17

Walking through Directories Lets consider a situation, where an Inventory Control System, a Pay Roll System, an Invoicing System needs to be stored in the same server. If there is any problem in any system, will it be possible to find out the desired file? If all files are in such condition, then it will be very difficult for maintenance. Directories are created to group a particular set of files. Directories are logical grouping of files for easier accessibility. It can be compared with different shelves in a library containing books of different subjects. For example, the physics books are kept in one shelf whereas all the chemistry books are kept in another shelf. In the same way, for storing files in computer, we group them on the basis of similarities depending upon some kind of parameters like purpose, the date of creation of a file. Let us look into a directory structure diagrammatically: Once we have learnt the directory structure, let us try to implement them using UNIX commands. One of the basic needs of any user for working with UNIX is to switch between the directories. Suppose a user (user1) has logged on to the system and issues the following command and presses <Enter> $ pwd /home/user1 which shows, his home directory is /home/user1 Now if he executes $ cd /home/user2

Science

Physics Chemistry Biology

UNIX

SR/UNIX/401/0204/SC/1.1 18

This indicates, he has now changed his current directory to /home/user2, which can be visualized by $ pwd /home/user2 To change from the current directory to the parent directory, the command is: $ cd .. $ pwd /home To go to the root directory, the command is: $ cd / $ pwd /

The parent directory is the directory, from which the current directory has been born. In the directory structure, parent directory is higher in order.

Creating Directories

To create a directory or a subdirectory in UNIX, the mkdir command is used. A directory can be created from the home directory or any other subdirectory under the home directory. The command that needs to be issued from the $ prompt is as follows:

$mkdir temp A directory named temp will be created. This is called relative path reference. The complete path can also be specified with the mkdir command.

$mkdir /home/user1/temp

This is called absolute path reference.

Absolute Path Reference is the reference of a path in relation with root.. Relative path Reference is the reference from the current directory.

UNIX

SR/UNIX/401/0204/SC/1.1 19

Moreover, multiple directories can be created using a single mkdir command. The directory names that need to be created must be separated by a space.

$mkdir temp1 temp2 temp3 With the above command, three directories called temp1, temp2 and temp3 will be created under the current directory.

mkdir –m option is used to set the mode (read, write, execute) for the directory to be created. The modes will be discussed later in the chmod command.

Removing Directories A directory or a subdirectory can be removed with the help of rmdir command.

$rmdir temp

Like mkdir, the full path can also be specified while removing a directory.

$rmdir /usr/user1/temp But a directory can be removed if and only if the following two conditions are satisfied:

The Directory must be empty. The directory cannot be the current directory or any directory, higher in the hierarchy.

A directory can be removed forcefully even though if it is not empty. Suppose, a subdirectory called temp2 exists under a directory called temp1. In this case temp1 can be removed forcefully though it contains a subdirectory. The following command helps to achieve the purpose.

$rm –r temp1

The directory temp1 along with all its subdirectories and files will be removed.

The rm –r <directory_name> needs to be used cautiously as it forcefully removes a directory along with all the subdirectories.

UNIX

SR/UNIX/401/0204/SC/1.1 20

Displaying contents of a Directory To display the contents of a directory, the ls command is used.

$ls The above command will display the long listing of files and subdirectories under the current directory. The ls command followed by the directory name displays the list of subdirectories and files under the specified directory. The ls command is used in the following way: The ls command can also be used with the directory name along with the full path.

$ls /home/user1 The output of the above command is given below: Some of switches that are frequently used with ls command are given below: Ø ls –l : This option provides a more detailed description of the files and subdirectories

of the current directory.

$ls -l The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 21

1---------2-----3-----------4------------5-------------6--------------7

The column description of the output is given below: Column Number Description 1 Denotes file type, ordinary (-), directory (d), special files (b, c or p)

and the permissions for different users of the system. 2 Number of links, minimum of 2 for a directory to depict connection

with its parent. 3 User name. 4 Group name, where user belongs. 5 Size of the file in bytes 6 Date and time of creation or modification. 7 Name of the file or directory Ø ls –t : This option displays the long listing of files and directories in a sorted manner.

Sorting is done on the time of creation or modification. The latest modified file is displayed first.

$ls –l -t

The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 22

Ø ls –a: This option displays all the files along with the hidden files. At this stage lets

consider hidden file as some files, which needs to be kept away from the users. In UNIX, the hidden file names start with a period (.).

$ls -a

The output of the above command is given below: Ø ls –x : This option sorts the files alphabetically and prints the output row wise.

$ls -x The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 23

Ø ls –F : This option helps to distinguish between files and directories. In the output, the

directories are suffixed by a slash (/) symbol.

$ls –F

Copy Ø To create duplication, we use the cp command.

Ø A file may need to be copied from one directory to another directory cp command

serves that purpose also.

The usage of cp command is given below:

cp <Source_filename> <Destination_filename>

The above usage will copy a file within the same directory but with a different name.

UNIX

SR/UNIX/401/0204/SC/1.1 24

cp <Source_filename> <Destination>

The above usage will copy a file from source directory to a different directory. The name of the copied file will be same. Suppose, a file called file1 is present under a directory called temp1. To copy this file from temp1 to another directory called temp2 (both temp1 and temp2 directories are present under /usr/user1 and it is also the current working directory), the following command needs to be issued from the $ prompt:

$cp temp1/file1 temp2 The file will be copied with the same name. The detailed output is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 25

The above command can also be specified using absolute path reference. The usage is given below:

$cp /home/user1/temp1/file1 /usr/user1/temp2 Now, if we want to copy the file called file1 with a different name to the temp2 directory, then the following command needs to be issued:

$cp /home/user1/temp1/file1 /usr/user1/temp2/copiedfile So file1 under temp1 directory will be copied to temp2 directory with the name copiedfile.

If a file has to be copied from a different directory to the current directory, then a “.” must be specified in place of <Destination>, because . indicates the current directory

Some of the frequently used switches of cp command are given below: Ø cp –i: This option asks the user for confirmation before copying a file, which is

already existing in the destination directory. It will copy the file only when the user provides affirmation. If –i is not used, it will directly overwrite the existing file without prompting the user for confirmation.

$cp –i temp1/file1 temp2

The output of the above command is given below:

The cp command without any option does not ask for any confirmation, before overwriting. So, be careful!, even some files may be lost.

UNIX

SR/UNIX/401/0204/SC/1.1 26

Ø cp –r : This option copies the whole file hierarchy. Suppose two directories called dir1 and dir2 are created. Beneath dir1 one subdirectory called dir3 is created and within dir3 one file called file1 is created. The skeleton of the said directory structure is given below:

Now, issue the following command from the $ prompt remaining in the home directory (/usr/user1) only:

$cp –r dir1 dir2 After copying, the above directory structure will look like the picture given below. The copied directories and files are represented by dotted lines.

/usr/user1

dir1 dir2

dir3

file1

UNIX

SR/UNIX/401/0204/SC/1.1 27

The sample output is given below:

/usr/user1

dir1 dir2

dir3

file1

dir1

dir3

file1

UNIX

SR/UNIX/401/0204/SC/1.1 28

Moving and Renaming a file To move a file around the UNIX file system, the mv command is used. The difference between mv command and the cp command is that after moving using mv command, the file will not be present in the source directory. The usage of the mv command while moving a file from directory to another is given below:

mv <Source> <Destination> The above command will move the file from the source directory to the destination directory.

$mv demo1/file demo2 A file can be moved from one directory to another directory keeping the same name or providing a different name. The command given below moves a file with a different name.

$mv demo3/file demo4/file1 The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 29

If the target file already exists while moving a file, then the user will be prompted for a confirmation. If the confirmation reply is ‘y’ then the existing file will be overridden other wise no action will take place. The mv –f option overrides the existing file without asking for any permission.

Multiple files can be moved with a single mv command. Use the following:

$mv file1 file2 demo4 where file1 and file2 will be moved to the directory demo4.

The same mv command can be used to rename a particular file within the same directory only. The usage of mv command to rename a file is given below:

mv <Old_filename> <New_filename> The above command will change the old file name to a new file name.

$mv demo4/file1 demo4/file2 The output of the above command is given below:

Removing a file

To delete an existing file, the rm command is used. The command given below deletes a file from the specified directory. The directory name need not be specified for the current directory.

$rm demo4/file2

UNIX

SR/UNIX/401/0204/SC/1.1 30

The single rm command can be used to delete multiple files.

$rm demo3/file1 demo3/file2

To remove a file in an interactive mode i.e, the user will be prompted for the confirmation, the rm –i command is used. The command given below deletes a file in an interactive mode.

$rm –i demo3/file1 The output of the above command is given below: The rm command when used with –r option deletes all the files in a particular directory. It deletes the directory also. It is a recursive delete.

$rm –r test

UNIX

SR/UNIX/401/0204/SC/1.1 31

The output of the above command is given below:

Comparison of two files The cmp command is used to compare content of two files. This command compares two files and returns the byte position and the line number at which the first difference has occurred. Suppose two files called file1 and file2 has been created. The contents of two files are given below: file1: This is A. file2: Thes is B. Now issue the following command from the command prompt:

$cmp file1 file2 The output of the above command is given below:

Comparison of two sorted files To compare the contents of two sorted files line by line, the comm command is used. This command selects or rejects lines common to both the files. Suppose two files called file1 and file2 is created. The content of these two files are given below: file1 file2

UNIX

SR/UNIX/401/0204/SC/1.1 32

My File My File The first one. The second one. Now, issue the following command from the command prompt:

$comm file1 file2 The above command produces a three-line output. The first column displays the line unique to the first file (file1). The second column displays the line unique to the second file (file2). The third column displays the line common to both the files. The output of the above command is given below: With the comm command, the flags 1,2 or 3 can be used to customize the output. The detail is given in the table below:

Command Description comm –1 file1 file2 Prints lines of file2 only.

comm –2 file1 file2 Prints lines of file1 only. comm –3 file1 file2 Prints unique lines of file1 and file2. comm –12 file1 file2 Prints only the common lines of file1 and

file2. comm –13 file1 file2 Prints the unique line of file2 only. comm –23 file1 file2 Prints the unique line of file1 only. comm –123 file1 file2 No display. The comm command displays the position and line where the first difference has occurred between the content of two files whereas the cmp command displays the common and unique lines of two files.

UNIX

SR/UNIX/401/0204/SC/1.1 33

Display specific lines of a file UNIX provides two useful commands to view portions of a file - head and tail. The head is used to display from the beginning of a file, while tail is used to display lines from the end. Two switches can be used with head and tail: -n: To display the number of lines -c: To display the number of characters The usage is as follows:

$ head –n5 file1 -> displays the first 5 lines of file file1 $ head –c10 file1 -> displays the first 10 characters of file file1

The usage of tail is similar to the head:

$ tail –n5 file1 -> displays the last 5 lines of the file file1 $ tail –c10 file1 -> displays the last 10 characters of the file file1

If head and tail is used without –n or –c, it will display the whole content of the specified file.

Permissions

Whenever a file or a directory is created in UNIX, these have some permission set to it. These permissions are known as File Access Permissions (FAP). The chmod command of UNIX is used to change the protection or permission bits of a file. Only the administrator or the owner of the file can set the permissions on a file. The usage of chmod command is given below:

chmod <type of user+permission> filename The above command requires the knowledge of two things, namely to whom the permission will be given and what are those permissions. The types of users in UNIX are: Ø Owner: The user who has created a file. It is symbolized as u.

UNIX

SR/UNIX/401/0204/SC/1.1 34

Ø Group: Users are put inside groups, who have similar requirements. It helps for easier system administration. It is symbolized as g.

Ø Others : They are users, in the systems, which are not a part of the same group as the

owner of a file. It is symbolized as o. Ø Administrator: It is the supreme owner of the whole system, and hence everything is

in its control. So an administrator is a class by himself and need not bother about any permission.

In UNIX, each and every file has three types of permissions. They are: Ø Read : Represented as r. Ø Write : Represented as w. Ø Execute : Represented as x. Now, let us recall the ls –l command to know user permissions on a particular file. In the above figure, it can be seen that the owners of the files has read and write permission whereas the group and other users has only read permission. To change permissions, the following two methods can be used: Ø Text Method To grant the execute permission to the owner, the command is:

$ chmod u+x shell

UNIX

SR/UNIX/401/0204/SC/1.1 35

Similarly, to revoke read permission from others, the command is:

$ chmod o–r shell Ø Octal Number Method Though we can grant or revoke permissions by combining owner, group and others using the Text Method but it still becomes cumbersome at times. So a simpler technique was devised using the octal number system, where the permissions have the following values: Ø Read = 4 Ø Write = 2 Ø Execute = 1 These values have been calculated taking 2n, where n is the position starting from 0. So collectively for owner, group and others if all permissions are granted then the command will be as following:

$ chmod 777 file1

UNIX

SR/UNIX/401/0204/SC/1.1 36

Thus this is a faster method of changing permissions. A very interesting result is obtained if the owner issues the following command:

$ chmod 000 file1 Thus by revoking all permissions from himself, he has to turn to the administrator for help. Windows NT users will recall that this is the case of giving No access to Everyone and then Taking Ownership.

Changing ownership After changing permissions for your files it is time to be benevolent to others by giving them ownership of your files and even changing group ownership. Only the current owner of the file has the authority to issue the following commands, and of course the administrator. Suppose, there are five users in a particular company and each user is creating their own files. At the end of the day, the administrator of the system wants to takes the ownership of the files so that the next day those will not be able to modify those files. To change ownership, use the following:

$ chown <new_owner> <file> when a particular user needs to be transferred to another group, the chgrp command is used. To change the group, use the following:

$ chgrp <new_group> <file>

Search a file

Sometimes it becomes essential to locate the existence of a particular file. The find command helps to perform the task.

$ find <path> -name “<filename>” –print

path : is the location to search

Once changed, the previous owner of the group has no further authority.

UNIX

SR/UNIX/401/0204/SC/1.1 37

-name : is a switch, which takes the name to search -print : is a switch, which prints the result on the VDU The find command can also be used with another very useful switches, which helps to locate a directory (d) and ordinary (f) file.

$ find <path> -type d –print displays all directories in the path specified. $ find <path> -type f –print displays all ordinary files in the path specified. $ find <path> -name “<filename>” –print displays the file Some of the useful switches used with find command are given below: Ø find –atime n : This option will return a value of true if the file specified has been

read n days ago.

$find . –name “try1” –atime 1 -print Ø find –ctime n : This option will return a value of true if the file specified has been

created or modified n days ago.

$find . –name “try1” –ctime 1 -print

UNIX

SR/UNIX/401/0204/SC/1.1 38

The difference between find and ls command is that ls displays the content of a specified directory whereas find searches in the specified directory as well as in all the sub-directories also. The find command also varies from grep as grep searches a particular pattern within a string.

Wildcards While issuing commands, a common phenomenon is to issue the same command for similar types of file names. For e.g. all data files with a .dat extension should be backed up, so to issue the same command for fifty files, it is time saving and more efficient to do this with a single command. This can be achieved by implementing wildcards. Just as the name suggests wildcards represent a sequence of characters. UNIX supports 3 types of wildcards: ? Represents a single character * Represents multiple characters [] Represents any one character from the list given in the parenthesis Ø $ ls a[bcd] will list files or directories in the current location having names ab or ac or

ad. Ø $ ls a* will list files or directories in the current location having names starting with a

and followed by any one character.

Communication commands UNIX provides some commands to the users to communicate with each other. Some of the communication commands supported by UNIX are as follows: Ø wall The wall command is the short form of Write for All. The administrator of the system to make universal announcements like at the time of system shutdown so that the users can save their files on the disk, uses this command. The wall command is located in the /etc directory and must be invoked as: # /etc/wall <Enter> message <Enter> ctrl+d<Enter>

UNIX

SR/UNIX/401/0204/SC/1.1 39

All the users who are the logged in the system will get the message flashed on their terminals along with a beep sound.

Only the super users can issue the wall command.

The sample output of wall command is given in the next page.

Notice the # prompt in the above diagram which is used for the broadcast. Ø write In UNIX, two users can communicate between themselves provided both the users are logged in. The write command connects one terminal to another terminal and facilitates the user to pass on messages back and forth. At one time, communication can be possible between two users only. But before starting the communication, the write permission has to be set for both the terminals by typing the following command:

$mesg y Now the user is ready to start communication. Issue the following command:

$ write <user_name> message

If the communication needs to be stopped, then mesg should be set to n. Moreover, if multiple users has logged in with the same user name, then the user who has logged in first can only communicate otherwise the terminal name (like tty01, tty02) needs to be specified.

UNIX

SR/UNIX/401/0204/SC/1.1 40

Ø talk It is a visual communication program, which copies lines from one terminal to another. A diagrammatic representation is shown in the next page: The process is initiated by user1 and then user2 has to respond by replying when the communication process is established. Let us see the display of the above process on the screen.

USER1 USER2

1

2

$ talk user2

$talk user1

USER1 USER2

UNIX

SR/UNIX/401/0204/SC/1.1 41

Some useful key combinations while talking are: Ctrl + l : Reprints screen Ctrl + h : Erase Ctrl + w : Erase a character Ctrl + c : Exit

Filter

A filter is defined as a special program, which takes input from standard input device and sends output to standard output device. The input can also be taken from a file and similarly the output can be redirected to another file. UNIX treats all devices as files and the shell provides three data streams (a stream is a collection of characters): Ø 0 – Standard Input stream (the keyboard) or stdin Ø 1 – Standard Output stream (the screen) or stdout Ø 2 – Standard Error stream (the screen) or stderr Now if we wish to take inputs or send outputs to and from other sources the respective data streams must be redirected. Thus we also have the following redirection symbols: Ø < - Input Redirection Ø > - Output Redirection Ø | - Pipe Redirection, which can represent both input as well as output redirections. A few examples of filters used in UNIX are cat, wc, sort, more, grep, cut, etc.

Filter cat The command used to concatenate files is cat. So by just issuing the command:

$ cat expects input from the keyboard (the standard input) and sends output to VDU (the standard output). As soon as the user presses <Enter>, the contents of the buffer are flushed out and the values are displayed on the console. This process will continue until the user chooses <CTRL + d> to terminate it.

UNIX

SR/UNIX/401/0204/SC/1.1 42

The output of the above command is given below:

By default, cat expects input from standard input device, i.e, keyboard and sends output to standard output device i.e, VDU.

Variations of cat Some of the variations of cat command with input and output redirections are given below:

$cat file1 The above command accepts input from a file called file1 and redirects the output to the standard output device (VDU). This implies that the cat command is accepting the input from a file and sends the output to the standard output file. The above command can also be written in the following way using the input redirection symbol:

$cat<file1 The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 43

Using the above logic, we may take input from the stdin, and redirect the content to a file, i.e. we shall create our own file using the following syntax:

$ cat >file1 It will take input from the keyboard till <Ctrl + d>. The only drawback of creating a file using the above way is that the file cannot be modified (till any text editor is used) after hitting the <Enter> key. In the above command, if the file called file1 already exists, the existing text will be overwritten. To prevent this, the following command can be issued:

$cat>>file The command above will append the new text to the existing one. The usage of stderr is given below:

$cat hello 2>err $cat err

In the above command the file hello does not exist. The error message is redirected to a file called err instead of sending it to the standard output device.

The command [cat file1>file2] is similar to [cp file1 file2]

Lets take another example

$ cat fl1 > fl2 2> err If the file fl1 exists, readable and the read permission is granted then the output will be stored in fl2, other wise the system defined error message will be stored in the file err. This is to be noticed that in either case nothing will be displayed

UNIX

SR/UNIX/401/0204/SC/1.1 44

Filter wc UNIX provides a filter to keep track of the number of lines, characters and words of a particular file. The filter that is used to perform the task is wc. The usage of wc filter is given below:

$wc file1 The output is given below: If one likes to view only one value at a time then the following switches may be used:

Switches Description -l Displays number of lines. -w Displays number of words. -c Displays number of characters. Some typical usages of wc is given below: Ø $wc –l file1 The above command will display only the number of lines in file1. The output is given below:

Lines

Words

Characters

UNIX

SR/UNIX/401/0204/SC/1.1 45

Ø $ls | wc -l The above command will give a total count of files and directories in the current directory. The ls command redirects the output to wc filter instead of sending it to the standard output device. The output of the above command is given below:

See the use of Pipe (|)

Ø $wc<file1>count The above command facilitates wc to accept input from the file called file1 and then redirects the output to another file called count, instead of sending the output to standard output device. Now, display the content of count using the cat command. The output is given below:

Filter more Sometimes when the output of a particular command is not accommodated within one full screen, the first part of the display scrolls up. To have one page display at a time, there is a useful filter called more.

UNIX

SR/UNIX/401/0204/SC/1.1 46

The usage of more is as follows: $ more file1 The above command will display the contents of the file one screen full at a time. To move to the next line, press the Enter key. Another usage of more is to display the contents of a directory page wise: $ ls | more

The above command can also be used with the pg filter.

$ls –l | pg

more differs from pg in respect that with the help of more, we can navigate back and forward with the help of b and f keys respectively. In case of pg, we can scroll back and forward using the page number.

Arranging output

To arrange data sequentially either in ascending or descending order in order, the sort filter is used. The sort filter reorders lines depending on the ASCII values of the characters. The sorting starts from the first character of each line and proceeds to next character only when the characters in two lines are identical. By default, the lines are sorted in ascending order. The usage of sort command is given below:

$sort The above command will wait for any input from standard input device. After pressing <Ctrl+d>, it will display the output in a sorted manner in the standard output device.

Press <ctrl+d>

UNIX

SR/UNIX/401/0204/SC/1.1 47

$sort file1 The output of the above command is given below: By default, the sort command starts sorting from the first field (field number starts from 0). The field can be explicitly specified from where the sorting should start using +fieldnumber switch where fieldnumber denotes the value added to the default start field. The command sort takes space as default delimiter. The example given below starts sorting from the second field.

$sort +1 file1 The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 48

Now, to sort the file only depending on the second field, the following command is used:

$sort +1 –2 file1 In the above command, -2 is restricting the sort for the second field only. Some of the frequently used switches with sort are given below: Ø sort –r: By default, sort arranges the output in ascending order. To arrange the output

in descending order, sort –r option is used.

$sort –r file1

UNIX

SR/UNIX/401/0204/SC/1.1 49

Ø sort –t : If a file contains fields having delimiter other than a space, sort –t can be used to specify that delimiter.

$sort –t’|’ file1

The fields in file1 are separated by a pipe (|). In the above command, this delimiter has been specified using sort –t. Ø sort –o : As sort is a filter, sorted output can be redirected to a file using > operator or

–o option. The usage of sort –o is given below:

sort –o <sortedfile> <originalfile> Now, issue the following command from $ prompt:

$sort –o sortfile file1 The output of the above command is given below:

Ø sort –n: In UNIX, sorting can be done on numeric fields also. The command below

will perform the task.

$sort +1n file1

UNIX

SR/UNIX/401/0204/SC/1.1 50

sort can be used with –n and –r simultaneously to arrange the output in reverse order based on the numeric field.

$sort file1 +1nr Moreover, sort can be used with uniq command to eliminate the redundant lines from a file.

$sort file1|uniq

UNIX

SR/UNIX/401/0204/SC/1.1 51

Filter tee As already discussed, with the help of pipes, the output of one command is sent as input of another command and the ultimate output is achieved. But let us take an example where we want to display the number of users that are currently working in the system and at the same time we want to store the output of who command into a file. In order to get that, UNIX provides the tee filter. The tee command enables the output of a command to be redirected to a file and at the same time passes it to the input of a pipe.

$who | tee file3 | wc -l The output of the above command is given below:

tee –a is used to append the output to a file.

Filter grep

UNIX provides a filter called grep that searches for string. The grep stands for Globally Search for Regular Expressions and Print out. The type of search expressions that grep filter can handle is enormous and if used with a combination with sort, the result can be obtained efficiently. The usage of grep is given below:

$ grep <search_expression> <file> The following example searches a specified expression in a particular file and will display the lines containing the expression:

$grep Hello file1 The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 52

If more than one word needs to be specified as a grep pattern, the pattern must be enclosed within quotes.

Some of the search expressions are given below:

CHARACTER MEANING EXAMPLE EX. DESCRIPTION [ ] Matches any one of a set

of characters grep “lab[abc]” Means “laba” or “labb”

or “labc” [ ] with hyphen Matches any one in the

range grep “lab[a-c]” Means “laba” or “labb”

or “labc” ^ Pattern following it must

occur at the beginning of a line

grep “^lab” The word “lab” must occur at the beginning of a line

[^ ] Must not contain any character(s) specified within [ ]

grep “lab[^a-c] Any other pattern but “laba” or “labb” or “labc”.

$ Pattern preceding it must occur at the end of each line

grep “lab$” The word “lab” must occur at the end of the line

.(dot) Matches a single character grep “lab.” The pattern is “lab” followed by any character.

\ Ignores any special meaning of the character following it.

grep “lab\[abc\]” Means literally “lab[abc]” as the pattern

Some frequently used switches with grep command are given in the table below:

Option Description -n Prints each line with the matching pattern along with the line number.

UNIX

SR/UNIX/401/0204/SC/1.1 53

-c Prints the total count of the lines matching the pattern. -v Prints all those lines that do not match the pattern. -i Ignores cases while searching for a pattern.

Some typical usages of grep filter are given below: Ø $ls –l | grep –v “^-“ The above command will display all the directory and special files under the current directory. Ø $grep –v “^$” file1 > newfile The above command will delete all the blank lines from a file called file1 and the final output will be redirected to a file called newfile. The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 54

Ø $grep –v “^ *$” file > newfile

Sometimes a line that looks blank is not really blank. It can contain some spaces. The command given above deletes all those blank lines that contain spaces. Ø $grep –n Hello file1 The command given above will display the lines containing the word hello with the line numbers. The output is given in the next page: Ø $grep –c Hello file1 The command given above will display the count of lines containing the text Hello in the file called file1. Ø $grep –i hello file1 The above command will display the lines containing the text hello irrespective of the case specified during the search.

UNIX

SR/UNIX/401/0204/SC/1.1 55

Filter tr The tr filter of UNIX has multiple roles. It can be used for the following two purposes: Ø Case conversion The command given below will wait for any input from stdin and then it will convert all the upper case characters to lower case.

$tr “[A-Z]” “[a-z]” The output of the above command is given below:

$tr he HE The above command will wait for input from stdin and then it will convert all h and e to H and E. The output of the above command is given below: Ø Squeeze characters The tr command can also be used to convert multiple occurrences of column separator to single. The –s switch with tr filter helps to achieve the purpose. The command given below squeezes multiple occurrences of space in the output of who command to single space.

UNIX

SR/UNIX/401/0204/SC/1.1 56

$who | tr –s “ ” The output of the above command is given below:

$ls | tr –s “ “

The parameter used with -s, must be the same as that of the column separator of the source data

The cut filter

When it is required to display only a part of the columns from the output of certain commands like ls –l, who, or specified columns of a data file, the filter cut comes in handy. The frequently used switches with cut filter are given in the table below:

Switch Description -f Field or column number that is to be cut -d Cut upto the column delimiter (must be uniform throughout all the

columns). The default delimeter of cut filter is tab. -c The position of the character to be cut Some typical usages of cut filter are given below:

UNIX

SR/UNIX/401/0204/SC/1.1 57

Ø $cat file | cut –c1 The above command will redirect the content of the file called file1 to cut filter. The cut filter will extract the first character of each line and will display it. The output of the above command is given in the next page. Ø $cat file1 | cut –c 1,2 The above command will extract first and second character of each line from file1 and will display it. The output of the above command is given below: Ø $cat file1 | cut –c1-5 The above command will extract all the characters lying between first and fifth position of each line of the file called file1and will display it.

UNIX

SR/UNIX/401/0204/SC/1.1 58

Ø $cat file1 | cut –c3- The above command will extract the character from third position of each line till the end of the line. Ø $cat file1 | tr –s “ “ | cut –d “ “ -f1,2 The above command will redirect the content of file1 to tr filter. The tr filter will squeeze the multiple occurrences of spaces between the fields into single space. Ultimately the cut filter will take the column delimiter as space (mentioned as –d “ “) and will extract the first and the second field.

UNIX

SR/UNIX/401/0204/SC/1.1 59

The /etc/hosts file

You start with the most fundamental file that you need for communicating with other computers on your network — the hosts file. When you access another host by name on the Internet or any intranet/internet, your computer needs to know the remote host's IP address. You can get remote host addresses from DNS (Domain Name System) or from your computer's hosts file. This file lists the names and addresses of other hosts known by your computer. When you need to know about thousands of hosts on the Internet, maintaining the hosts file is really too cumbersome a mechanism. Imagine having to spend all that time updating it as computers come and go or relocate on the Internet! In that case, you need DNS to locate remote hosts. IP address are used by many TCP/IP utilities like ftp, telnet. For example : ftp 194.9.200.77 or telnet 194.9.200.77 but it’s impractical to remember machines by their IP addresses, while network understands only the numbers and not the names. On smaller networks, the name-address mappings are placed in the file /etc/hosts on each and every host of the network. This database allows the applications to look up a name and find out its corresponding IP address. A look at a sample file reveals its flexile structure : 127.0.0.1 localhost # the loopback address Kaushik Suvendu Suvro For each machine in the network, this table contains a line mapping the IP address to its respective host name. It contains at least 2 fields for each line, one for each type of the address.

UNIX

SR/UNIX/401/0204/SC/1.1 60

Typical Examples Using Filters Ø Count the number of users currently logged in as user1.

$who | grep ‘user1’ | wc -l The output of the above command is given below: Ø Find the largest file in the current directory

$ls –l | tr –s “ “ | cut –d” “ –f5,9 | sort –nr | head –n1 The output of the above command is given below:

Current Users

Logged in as user1

Count

Squeeze Cut (Field No. 5 and 9)

Numeric sort (desc)

Head

UNIX

SR/UNIX/401/0204/SC/1.1 61

Ø The example given below will display the name and the designation of an employee who is not a clerk and earns the minimum salary. For this purpose, let us first see the content of the file file1:

Now, issue the following command from the $ prompt:

$grep –iv clerk file1 | sort +2n | cut –d” “ –f1-2 | head -1 Ø Display the line number 2 and 3 of a particular file

$cat file1 | tail –5 | head -2 The above command will first extract the last five lines of the file and then it will display the first two lines from that. The output is given below:

Ignore the case and line matching the pattern

Numeric Sort (asc order)

Cut (Field No. 1 and 2)

UNIX

SR/UNIX/401/0204/SC/1.1 62

UNIX

SR/UNIX/401/0204/SC/1.1 63

Introduction to vi Editor

At the end of the chapter, you will be able to:

Know the vi Editor and how it works

Know different modes of vi

Understand the process of cutting and yanking

Know the vi level settings in .exrc

Set the vi environments

UNIX

SR/UNIX/401/0204/SC/1.1 64

Introduction

The vi editor is a screen-based editor used by many Unix users. The vi editor has powerful features to aid programmers, but many beginning users avoid using vi because the different features overwhelm them. This book help beginners get accustomed to using the vi editor, but also contains sections relevant to regular users of vi as well. Examples are provided, and the best way to learn is to try these examples, and think of your own examples as well... There's no better way than to experience things yourself.

Before You Begin The vi editor uses the full screen, so it needs to know what kind of terminal you have. The prompt looks like this: TERM = (vt100) If you know your terminal is a vt100 (or an emulator that can do vt100), just hit return for the terminal type when you log in. If you have an hp terminal, type "hp" for the terminal type and hit return. If you make an error when you log in and type the wrong terminal type, don't panic and log out. You can type the following commands to fix the settings: First, tell your shell what type of terminal you have. (If you're not sure what your shell is, type this command to see what shell you have: echo $SHELL.) For the examples given, the terminal type is "vt100". Substitute it with whatever terminal type you have. For C shell (/bin/csh), the command is this: set term=vt100 For Bourne Shell (/bin/sh) or Korn Shell (/bin/ksh), the commands are the following: export TERM TERM=vt100 Next, reset your terminal with this command: tset Now that the terminal type is (hopefully) correctly set, you are ready to get started with vi.

UNIX

SR/UNIX/401/0204/SC/1.1 65

Starting the vi Editor

The vi editor lets a user create new files or edit existing files. The command to start the vi editor is vi, followed by the filename. For example, to edit a file called temporary, you would type vi temporary and then return. You can start vi without a filename, but when you want to save your work, you will have to tell vi which filename to save it into later. When you start vi for the first time, you will see a screen filled with tildes (A tilde looks like this: ~) on the left side of the screen. Any blank lines beyond the end of the file are shown this way. At the bottom of your screen, the filename should be shown, if you specified an existing file, and the size of the file will be shown as well, like this: "filename" 21 lines, 385 characters If the file you specified does not exist, then it will tell you that it is a new file, like this: "newfile" [New file] If you started vi without a filename, the bottom line of the screen will just be blank when vi starts. If the screen does not show you these expected results, your terminal type may be set wrong. Just type :q and return to get out of vi, and fix your terminal type. If you don't know how, ask a lab monitor.

Getting Out of vi

Now that you know how to get into vi, it would be a good idea to know how to get out of it. The vi editor has two modes and in order to get out of vi, you have to be in command mode. Hit the key labeled "Escape" or "Esc" . If you were already in the command mode when you hit "Escape", don't worry. It might beep, but you will still be in the command mode. The command to quit out of vi is :q. Once in command mode, type colon, and 'q', followed by return. If your file has been modified in any way, the editor will warn you of this, and not let you quit. To ignore this message, the command to quit out of vi without saving is :q!. This lets you exit vi without saving any of the changes. Of course, normally in an editor, you would want to save the changes you have made. The command to save the contents of the editor is :w. You can combine the above command with the quit command, or :wq. You can specify a different file name to save to by specifying the name after the :w. For example, if you wanted to save the file you were working as another filename called filename2, you would type: w filename2 and return. Another way to save your changes and exit out of vi is the ZZ command. When in command mode, type zz and it will do the equivalent of :wq. If any changes were made to the file, it will be saved. This is the easiest way to leave the editor, with only two keystrokes.

UNIX

SR/UNIX/401/0204/SC/1.1 66

The Two Modes of vi

The first thing most users learn about the vi editor is that it has two modes: command and insert. The command mode allows the entry of commands to manipulate text. These commands are usually one or two characters long, and can be entered with few keystrokes. The insert mode puts anything typed on the keyboard into the current file. vi starts out in command mode. There are several commands that put the vi editor into insert mode. The most commonly used commands to get into insert mode are a and i. These two commands are described below. Once you are in insert mode, you get out of it by hitting the escape key. If your terminal does not have an escape key, ^[ should work (control-[). You can hit escape two times in a row and vi would definitely be in command mode. Hitting escape while you are already in command mode doesn't take the editor out of command mode. It may beep to tell you that you are already in that mode. How to Type Commands in Command Mode

The command mode commands are normally in this format: (Optional arguments are given in the brackets)

[count] command [where] Most commands are one character long, including those which use control characters. The commands described in this section are those which are used most commonly the vi editor. The count is entered as a number beginning with any character from 1 to 9. For example, the x command deletes a character under the cursor. If you type 23x while in command mode, it will delete 23 characters. Some commands use an optional where parameter, where you can specify how many lines or how much of the document the command affects, the where parameter can also be any command that moves the cursor.

Some Simple vi Commands

Here is a simple set of commands to get a beginning vi user started. There are many other convenient commands, which will be discussed in later sections. a enter insert mode, the characters typed in will be inserted after the current cursor position. If you specify a count, all the text that had been inserted will be repeated that many times. h move the cursor to the left one character position.

UNIX

SR/UNIX/401/0204/SC/1.1 67

i enter insert mode, the characters typed in will be inserted before the current cursor position. If you specify a count, all the text that had been inserted will be repeated that many times. j move the cursor down one line. k move the cursor up one line. l move the cursor to the right one character position. r replace one character under the cursor. Specify count to replace a number of characters u undo the last change to the file. Typing u again will re-do the change. x delete character under the cursor. Count specifies how many characters to delete. The characters will be deleted after the cursor.

Text Buffers in vi

The vi editor has 36 buffers for storing pieces of text, and also a general purpose buffer. Any time a block of text is deleted or yanked from the file, it gets placed into the general purpose buffer. Most users of vi rarely use the other buffers, and can get along without the other buffers. The block of text is also stored in another buffer as well, if it is specified. The buffer is specified using the " command. After typing ", a letter or digit specifying the buffer must be entered. For example, the command: "mdd uses the buffer m, and the last two characters stand for delete current line. Similarly, text can be pasted in with the p or P command. "mp pastes the contents of buffer m after the current cursor position. For any of the commands used in the next two sections, these buffers can be specified for temporary storage of words or paragraphs.

Cutting and Yanking

The command commonly used command for cutting is d. This command deletes text from the file. The command is preceded by an optional count and followed by a movement specification. If you double the command by typing dd, it deletes the current line. Here are some combinations of these: d^

UNIX

SR/UNIX/401/0204/SC/1.1 68

deletes from current cursor position to the beginning of the line. d$ deletes from current cursor position to the end of the line. dw deletes from current cursor position to the end of the word. 3dd deletes three lines from current cursor position downwards. There is also the y command which operates similarly to the d command which take text from the file without deleting the text.

Pasting

The commands to paste are p and P. The only differ in the position relative to the cursor where they paste. p pastes the specified or general buffer after the cursor position, while P pastes the specified or general buffer before the cursor position. Specifying count before the paste command pastes text the specified number of times.

Settings for vi

You can customize the way VI behaves upon start up. There are several edit options which are available using the :set command mode) Some of these options have values set with the equals sign '=' in it, while others are either set or not set. (These on or off type of options are called Boolean, and have "no" in front of them to indicate that they are not set.) The options shown here are the options that are set without any customization. Descriptions of some of these are given below, with an abbreviation. For example, the command set autoindent, you can type :set autoindent or :set ai. To unset it, you can type :set noautoindent or :set noai autoindent (ai) This option sets the editor so that lines following an indented line will have the same indentation as the previous line. If you want to back over this indentation, you can type ^D at the very first character position. This ^D works in the insert mode, and not in command mode. Also, the width of the indentations can be set with shiftwidth, explained below. exrc The .exrc file in the current directory is read during startup. This has to be set either in the environment variable EXINIT or in the .exrc file in your home directory. mesg

UNIX

SR/UNIX/401/0204/SC/1.1 69

Turn off messages if this option is unset using :set nomesg, so that nobody can bother you while using the editor. number (nu) Displays lines with line numbers on the left side. shiftwidth (sw) This option takes a value, and determines the width of a software tabstop. (The software tabstop is used for the << and >> commands.) For example, you would set a shift width of 4 with this command: :set sw=4. showmode (smd) This option is used to show the actual mode of the editor that you are in. If you are in insert mode, the bottom line of the screen will say INPUT MODE. warn This option warns you if you have modified the file, but haven't saved it yet. window (wi) This option sets up the number of lines on the window that vi uses. For example, to set the vi editor to use only 12 lines of your screen (because your modem is slow) you would use this: :set wi=12. wrapscan (ws) This option affects the behavior of the word search. If wrapscan is set, if the word is not found at the bottom of the file, it will try to search for it at the beginning. wrapmargin (wm) If this option has a value greater than zero, the editor will automatically "word wrap". That is, if you get to within that many spaces of the left margin, the word will wrap to the next line, without having to type return. For example, to set the wrap margin to two characters, you would type this: :set wm=2.

Abbreviations and Mapping Keys to Other Keys

The abbreviate command in vi lets you set up abbreviations for specific strings. The command looks like this : :ab string thing to substitute for. For example, if you had to type the name, "Humuhumunukunukuapua " but you didn't want to type the whole name, you could use an abbreviation for it. For this example, the command is entered like this: :ab gtl Globsyn Techonoligies Ltd Now, whenever you type gtl as a separate word, vi will type in the entire word(s) specified.

UNIX

SR/UNIX/401/0204/SC/1.1 70

To remove a previously defined abbreviation, the command is unabbreviate. To remove the previous example, the command would be ":una gtl" To get your listing of abbreviations, simply just type :ab without any definitions. Another EX editor command that is useful for customization is the mapping command. There are two kinds of mapping commands. One for command mode, and the other for insert mode. These two commands are :map and :map! respectively. The mapping works similarly to the abbreviation, and you give it a key sequence and give it another key sequence to substitute it with. (The substituted key sequences are usually vi commands.)

The EXINIT Environment Variable and the .exrc file There are two ways to customize the vi editor. If you create a file called .exrc in your home directory, all the commands in there will be read when vi starts up. The other method is to set an environment variable called EXINIT. The options will be set in your shell's setup file. If you use /bin/csh (C-Shell), the command is as follows, and is put in the .cshrc file:

setenv EXINIT '...' If you use /bin/sh or /bin/ksh, the command is as follows, and is put into the .profile file: export EXINIT EXINIT='...' Don't put in ... as the example says. In this space put the commands that you want to set up. For example, if you want to have auto indent, line numbering, and the wrap margin of three characters, then the setenv command (for C shell) looks like this: setenv EXINIT 'set ai nu wm=3' If you want to put more than one command in the setenv EXINIT thing, separate the commands with a vertical bar (|). For example, to map the 'g' command to the 'G' character in command mode, the command is :map g G, and combined with the above command, you get this: setenv EXINIT 'set ai nu wm=3|map g G' If you want to create the file called .exrc, you can put exactly the same things in the file as shown in the quotes after the EXINIT.

Recovering Your Work When Something Goes Wrong with Your Terminal

The vi editor edits a temporary copy of your file, and after the editing is complete, or when you tell it to save, it puts the contents of the temporary copy into the original file. If

UNIX

SR/UNIX/401/0204/SC/1.1 71

something goes wrong while you are editing your file, the vi editor will attempt to save whatever work you had in progress, and store it for later recovery. (Note: If vi dies while you were working on any file, it sends you an email message on how to recover it. The -r option stands for recovery. If you were editing the file vitalinfo, and you accidentally got logged out, then the -r option of the 'vi' editor should help. The command would look somewhat like this: vi -r vitalinfo After using the -r option once, though, you MUST save what you have recovered to the actual file... The -r option only works once per failed vi session.

Warning About Using vi on the Workstations

There are two things to be aware of when using the workstations: Editing the same file many times at once, and changing the size of the screen. Because vi edits a copy of your original file and saves the contents of that copy into the original file, if you are logged on more than once and are editing the same file more than once using vi, if you save on one window and then you save on the other window, the changes made to the file on the first save would be overwritten. Make sure that you only run one copy of vi per file. If you use a terminal program from a workstation, you can change the size of the screen by dragging the sides of the window. If the size is not working properly, the command to type is this: eval `resize ̀ If that doesn't work the command would be this: eval `/usr/bin/X11/resize ̀ If the size is wrong, the editor will not operate correctly. If you have any problems with the screen size, ask the monitors in the computer lab for help setting the sizes correctly.

UNIX

SR/UNIX/401/0204/SC/1.1 72

Shell Programming

At the end of the chapter you will be able to:

Create and Execute a Shell Script

Work with Variables

Accept and Display User Input

Work with Positional Parameters

Write Conditional Statements

Write Iteration Statements

Control loops using break and continue

UNIX

SR/UNIX/401/0204/SC/1.1 73

Introduction to shell programming As we know that a shell in UNIX acts as a command interpreter. Besides command interpretation, shell provides the facility of performing a particular task using a collection of UNIX commands acting as a single unit. Some of these features have already been discussed in the filter session. Now, we will use a collection of such commands in the form of a program or script. Such programs that are built out of the shell commands are known as shell programming. Hence a shell script is a collection of shell commands logically connected together through programming constructs. A shell script, when executed works as a command itself. The shell script also accepts arguments like any other UNIX commands. Let us consider the following set of commands:

$cat file1 $ls –l $rm file1 $ls

The above commands will be executed one after the other but independently. Now, suppose all these set of commands are written in a single file (say shellfile). If you display the content of the file using the cat command, all the above lines will be displayed. Now issue the following command from the $ prompt:

$sh shellfile The above command will execute all the commands written within the file called shellfile. The sh command creates another shell (mainly child shell) and within that shell the commands written within the script gets executed. After execution is over, the child shell is destroyed and the control goes back to the parent shell.

A script file can be executed by merely typing the filename from the $ prompt provided the file has the execute permission. By default, when a file is created, it is created with read and write permission (rw for owner and r for group and others) The chmod command can be used to give execute permission to the file.

Comments and Programming style

UNIX

SR/UNIX/401/0204/SC/1.1 74

It is always a good practice of writing a program in such a way that others while reading the program can understand easily what each step within the program is doing. This can be done with the help of indentation and comments. The comment entry can be made with the help of hash (#) sign. If the sign is provided at the beginning of the line, the shell will ignore that line. If the sign is given in between a line, the shell will ignore remainder of the line.

Variables Unlike other programming languages, variables in shell scripts do not have any associated data types; that is, they are not declared as integers or characters. All variables in UNIX are treated as character strings. However, It is possible to manipulate variables mathematically. Variables in UNIX are of two types: Ø Shell or user-defined variables: These types of variables can be created and then

used by the user. Ø System or environment variables: These types of variables are maintained by the

UNIX system. User can only use them. Shell variable Ø Creating variables In UNIX, variables need not to be explicitly declared. Instead, variables can be created at any point of time within the program, whenever required and simply assigning a value to the variable can be done.

<variablename>=<value>

There should not be any spaces on either side of the assignment operator (=).

The command given below creates a variable called name and assigns the value of Tom to the variable.

$name=’Tom’ or name=Tom If a variable is created in the following way

$name=Tom Cruise

then the variable name will contain a value of Tom only. To store the full value, the command needs to be written in the following way:

UNIX

SR/UNIX/401/0204/SC/1.1 75

$name=”Tom Cruise”

Consider the following variable declaration:

$num=1 In the above declaration a variable called num is created with a value of 1. But the variable num will not be treated as a numeric variable. Instead it contains a character value of 1. However, any mathematical operation is possible on this variable, which will be discussed later in this chapter. Variables can be created either in shell scripts or at the shell prompt. Any variable created within a shell script is lost when the script stops executing. However, a variable created at the prompt will remain until the shell is terminated by logging out of the system. Moreover a variable created in one shell cannot be accessed if the user has switched to any other shell. Ø Accessing the value of variable In UNIX, the value of any variable can be accessed with the help of a $ sign in front of the variable name. Let us consider the following example:

$name=“Tom Cruise” Now, if we want to display the value of the variable on the screen, the following command needs to be issued from the $ prompt:

$echo $name #echo helps to display a message on the screen. Ø Scope of a shell variable In UNIX, a variable can be declared and accessed locally or a variable declared within a particular shell can be accessed throughout all other shells. Let us now discuss the scope of variable in details: Local variable When a variable is referenced, it is known only to the shell that created it. If a new shell is created by typing sh, this new shell is born unaware of the parent shell’s variables. Now the same variable name can be given a different value within the new shell without the parent knowing about it. Such a variable is called local variable. The figure given below explains the above statements:

UNIX

SR/UNIX/401/0204/SC/1.1 76

Global variable A variable declared in a particular shell can be made accessible from any other shell. Thus a local variable can be made global with the help of export command. The usage of the export command is given below:

$export <variablename> The figure given in the next page explains the export command:

name declared in the Parent shell

Creates a new child shell

name not declared in the child shell

Return to the parent shell

name still exists

Creates a new child shell

name not declared in the new child shell

UNIX

SR/UNIX/401/0204/SC/1.1 77

By default, variables are local to a shell. The export command does help to propagate a value to the shells that are higher up in the hierarchy.

Accept and Display User Input Besides assigning a value to a variable at the $ prompt, the shell also allows to enter a value into a variable within the shell script. This is done using read command. The script given below prompts the user to enter a name with the help of echo command. The name entered by the user is stored in a variable with the help of read command. After that the value of the variable is displayed, again with the help of echo command. The name of the file is demo1 within which the script is written.

$vi demo1

echo "Enter a name" read name echo "The name is : $name"

To display the content of a variable, the variable name must be preceded with a $ sign. The output of the above script is given below:

name declared in the Parent shell

name made global so that it can be accessible from different shells

Creates a new child shell

name is accessible from the child shell

UNIX

SR/UNIX/401/0204/SC/1.1 78

The echo command displays the enclosed text on the screen. By default the echo command displays the text and then puts a newline character at the end of the text. The newline character causes the cursor to move to the next line after the text is displayed. Using certain characters in the command can change this default. Some of the variant usages of echo command are given below: Ø The following command will display the text and sound the system bell.

$echo “This is a demo of beep sound \007” Ø The following command will display the text and keeps the cursor at the same line.

$echo “This option keeps the cursor in the same line \n” Ø The command creates a new line, displays the text and keeps the cursor in the same

line.

$echo -n “\n This option creates a new line, keeps the cursor in the same line”

If user is using a bash shell then the command given below will create a new line and keep the cursor in the same line. $echo –e “\n This is a demo of bash shell”

More options of echo:

Options Explanation echo ${x+5} No output because variable x is not declared. echo ${x-5} The output is - 5 still the variable x is not declared and hence does

not contain any value. echo ${x=5} The output is - 5 and the variable x is created and initialized with a

value of 5. echo ${x?”no”} The output is - 5 because the variable is already created. echo ${y?”no”} The output is - y: no because the variable y has not been created.

UNIX

SR/UNIX/401/0204/SC/1.1 79

A sample output is given in the next page:

Perform calculations using expr

UNIX does not support numeric variables. All variables are treated as character strings. Let us have a look at the variable declaration given below:

$ctr=25 With the above command, the variable ctr contain the characters 2 and 5 and not the number 25. However, in order perform efficient shell programming, it is imperative that we should be able to manipulate variables mathematically. In other words, it is important that to simulate numeric variables. This can be possible with the help of expr command. The figure given illustrates the use of expr command:

UNIX

SR/UNIX/401/0204/SC/1.1 80

The code given below sum up two numbers using a shell script. The operators that are frequently used while performing any mathematical operations are:

Operators Function + Addition - Subtraction \* Multiplication (\ is given to ignore the special

meaning of * because * is a wildcard). / Division % Returns remainder

Blank spaces must be given on either side of operators. The grave accent must be used with expr.

Environment Variables

Besides user-defined variables, a shell also has some special variables called environment variables. Some of the environmental variables are given below: Ø The HOME variable Every user in UNIX system has an associated directory called the home directory. Whenever a user logs in, he or she is taken to the corresponding home directory. Assigning a value to the environmental variable HOME specifies the home directory.

UNIX

SR/UNIX/401/0204/SC/1.1 81

$HOME=/usr/user1

The command given below displays the home directory:

$echo $HOME Ø The PATH variable The PATH variable contains a list of all full path-names of directories that are to be searched for an executable program. A colon (:) separates these names. The . denotes the current path. The command given below displays the path:

$echo $PATH The output of the above command is given below: Ø The PS1 variable This variable contains the system prompt, the $ symbol. Setting the value of this variable to the desired prompt can change the system prompt. The command given below changes the system prompt:

$PS1=”Hello Prompt” The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 82

The commands given in the table below displays various usages of PS1 variable:

Command Effect PS1=”\u” Changes the prompt with user name. PS1=”\t” Changes the prompt with current time. PS1=”\d” Changes the prompt with current date. Ø The LOGNAME variable This variable contains the user’s login name or user name. The contents of this variable should not be changed by the user, but should be only displayed.

$echo $LOGNAME The output of the above command is given below: Ø The TERM variable This variable informs the system about the type of the terminal user is working with. Accordingly, the shell sets the environment. Assigning a different value to the TERM variable can change the type of the terminal.

$TERM=vt100 Other environmental variables are MAIL, IFS, SHELL, PS2.

The env command is used to display values of all environment variables.

The .profile file

UNIX

SR/UNIX/401/0204/SC/1.1 83

As soon as the user logs into a UNIX system, the system automatically searches for a file called .profile in the user’s home directory. The .profile file of UNIX is very much similar to autoexec.bat of MS-DOS. This files contains different environment variables initialized to different values. Along with these, it also contains some other commands for initializing the session. Let us see the content of .profile of user1:

$cat .profile

It is advisable that .profile file should not be modified unless absolutely required.

Special characters in UNIX The UNIX operating system provides some characters with special meanings. If these characters are used in a shell script as a part of a variable name, they may lead to behave the program incorrectly.

Character Meaning $ The beginning of a shell variable name | Pipes the standard output to next command # Starts a comment ? Matches one character * Matches one or more characters > Output redirection operator < Input redirection operator

UNIX

SR/UNIX/401/0204/SC/1.1 84

>> Output redirection operator (to append to a file) [a-z] All characters from a to z [a, z] Either ‘a’ or ‘z’

& Executes a process in background.

Positional Parameters Till now, we have seen that scripts either don’t need any input from the user at all or it takes the input from the user every time it is executed. But sometimes it becomes convenient to provide a script all the information at the time of execution only, so that it don’t require any input from the user while running. This type of situation arises when a script is running in the background because it don’t have any scope to interact with the user while it is running as a script running in the background disconnects it from the terminal. It is also useful when one script run another script and passing it information. Let us consider the command given below:

$sh shellfile arg1 arg2 arg3 The above command will execute the file called shellfile passing three arguments. Internally, the special variables $1, $2, $3 get set to arg1, arg2, arg3 respectively. The number of arguments go upto $9.

The character $ is used to represent substitutable parameters. So each and every parameter must be prefixed with a $.

Some of the parameters that are automatically set by the shell are given in the table in the next page:

Parameters Description # Number of parameters passed during execution. ? The status of the last executed command. $ The process ID of the current shell. ! The process ID of the last background command invoked. * Returns the actual parameters passed.

Given below is a typical shell script using positional parameters:

echo "This is a demo on positional parameters" echo "The number of parameters passed are : $#" echo "The actual parameters are : $*

UNIX

SR/UNIX/401/0204/SC/1.1 85

Now, to execute the shell passing arguments, issue the following command:

$sh demo2 “Kaushik” “Saurav” “Soumya” The output of the above shell script after executing is given below:

Command substitution Recall the usage of pipes in joining commands by sending the standard output of one command as standard input for another. Another way of using more than one command in a single command line is through command substitution. Suppose a user wants to display the following message on the screen: The date is (output of the date command) To do so, the user needs to enter the following command:

$echo “The date is `date`” The command date is enclosed in single back quotes (also called grave accent). The shell first replaces the enclosed command of the output, and then executes the entire command. The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 86

Command substitution can also be used to store the output of a command in a variable. The command given below counts the number of files in the current directory whose names end with .cc and the result is store in a variable called ctr.

$ctr=`ls *.cc | wc –l` The output of the above command is given below: The example given below sets the value of the date variable:

$set `date ̀ The set command sets the output of the date command into the positional parameters.

UNIX

SR/UNIX/401/0204/SC/1.1 87

Conditional statement – the if construct Most of the programming languages have some way to decide whether to execute of piece of code or not based on a condition. If the condition is true then the code will get executed and if it is false then the code will not get executed. The reverse can also happen. In UNIX, shell provides the facility of if….then….else construct through the conditional execution can be implemented. The if construct is used in conjunction with test command. The usage of if construct is given below:

if test <condition> then command else command fi

Moreover, multiple conditions can be specified within one if…fi block. This can be done with the help of if…then…elif…then…else statement. The usage is given below:

if test <condition> then command elif <condition> then command else command fi

In the above statements, it the test condition returns an exit status of 0 (the condition is true), the command immediately following the condition will be executed and the control will come out of the if block. Otherwise the next condition in the elif statement will be evaluated. In this way the program execution will proceed. If all the conditions return false, the control of the program will go to the else part and will execute the command specified in the else statement. Moreover, some logical operators can be used along with the if condition. Some of the logical operators supported by UNIX shell are given in the table below:

Operators Function -o or || OR -a or && AND ! NOT

Some typical examples using if construct

UNIX

SR/UNIX/401/0204/SC/1.1 88

Ø The script given below will accept a grade from the user. If the grade entered is a then it will display the message Excellent. If anything entered other then a, it will display Good.

echo "Enter the grade" read grade if test $grade = 'a' then echo "Excellent" else echo "Good" fi

The output of the above code is given below: Ø The code given below will check for multiple conditions using –o (OR) operator. The

test condition will check for the first condition. If the exist status is false, it will check the next condition. If any of the condition returns an exit status of 0, the command immediately following it will be executed.

echo "\nEnter a grade: \c" read grade if test $grade = 'a' -o $grade = 'b' -o $grade = 'c' then echo "\nValid grade" else echo "\nInvalid grade" fi

The output of the script is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 89

The same above program can be written with the help of elif statement. The code is given in the next page:

echo "\nEnter a grade: \c" read grade if test $grade = 'a' then echo "\nValid grade" elif test $grade = 'b' then echo "\nValid grade" elif test $grade = 'c' then echo "\nValid grade" else echo "\nInvalid grade" fi

• String comparisons with test

UNIX

SR/UNIX/401/0204/SC/1.1 90

UNIX provides some switches and operators to compare two or more strings. Some of the string comparison operators are given in the table below:

Options Function -z s1 True if the length of string s1 is zero -n s1 True if the length of string s1 is nonzero s1 = s2 True if strings s1 and s2 are identical s1 != s2 True if the strings s1 and s2 are not identical.

The script given below uses all the string comparison operators to compare two strings:

echo "Enter the first string" read str1 echo "Enter the second string" read str2 if test $str1 = $str2 then echo "Both the strings are equal" fi if test $str1 != $str2 then echo "The strings are not equal" fi if test -z $str1 then echo "Length of str1 is zero" fi if test -n $str2 then echo "Length of str2 is greater than zero" fi

The output of the above script is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 91

• Numeric comparison with test In case of numeric comparison, shell provides some operators to compare between two integer values only, the decimal values are simply truncated. The complete set of numeric comparison operators are given in the table below:

Options Effects n1 –eq n2 True if the integers n1 and n2 are algebraically equal n1 –ne n2 True if n1 and n2 are not equal n1 –gt n2 True if n1 is greater than n2 n1 –ge n2 True if n1 is greater than or equal to n2 n1 –lt n2 True if n1 is less than n2 n1 –le n2 True if n1 is less than or equal to n2

Some typical examples using numeric operators Ø The script given below finds the highest of three numbers entered by the user using

numeric operators:

echo "Enter the first number" read num1 echo "Enter the second number" read num2 echo "Enter the third number" read num3 if test $num1 -gt $num2 -a $num1 -gt $num3 then echo "The highest number is : $num1" elif test $num2 -gt $num1 -a $num2 -gt $num3 then echo "The highest number is : $num2" else echo "The highest number is : $num3" fi

A part of the output is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 92

As discussed earlier, test returns an exit status. If the condition is true, it returns a value of 0 otherwise 1. The values returned by test are assigned to the parameter $?. The following commands given from the $ prompt describes the said fact. Ø The script given below checks two conditions. The first check is for number of

arguments passed from the command line while executing the script. The second check uses the grep filter to search a pattern. For this script, let us first create a file called file1 having the following content:

UNIX

SR/UNIX/401/0204/SC/1.1 93

Now, following is the code:

if test $# -ne 3 then echo "Number of arguments are invalid" exit elif grep "$1" $2 > $3 then echo "Matching pattern found" else echo "Matching pattern not found" fi

In the above code, the elif part checks whether the pattern string which is passed as the first argument ($1), is present in the file which is passed as the second argument ($2). If it finds the pattern, the matching lines are redirected to another file passed as third argument ($3). Ultimately the code displays appropriate messages. The output of the above code is given below:

Instead of using the test keyword, [ and ] can also be used. So, test $num1 –eq $num2 is equivalent to [ $num1 –eq $num2 ]. There should be a space on the inner sides of [ and ]

• File comparison using test test can be used to check the various file attributes like whether the specified file exists or not. It can also check whether the file is an ordinary or directory file. The set of switches used with test for checking various file attributes are given in the table below:

Options Function

UNIX

SR/UNIX/401/0204/SC/1.1 94

-e True if file exists -r True if file exists and is readable -w True if file exists and writeable -x True if file exists and executable -f True if file exists and ordinary file -d True if file exists and directory -s True if file exists and is non empty

The code given below describes the file operators. The script will accept a filename from the command line as an argument and will check the various file attributes.

if test -e $1 then echo "File exists" else echo "File does not exist" fi if test -d $1 then echo "Directory file" else echo "Not a directory file" fi if test -f $1 then echo "Ordinary file" else echo "Not an ordinary file" fi if test -r $1 then echo "File is readable" else echo "File is not readable" fi

Now, after executing the above code by passing a filename (file1 in this case) as parameter, the following output is obtained:

UNIX

SR/UNIX/401/0204/SC/1.1 95

Wildcards cannot be used with test. For example test –w *.cc is an invalid checking.

Conditional statement – the case construct

This construct is used in shell scripts to perform a specific set of instructions depending on the expression and is often used in place of the if construct. This type of construct, matches an expression for more than one alternative and depending on that different desired commands are executed. The general syntax of case construct is given below:

case <expression> in value1) command;; value2) command;; *) command esac

In the above syntax, if case matches value1 with the expression, then it executes the command associated with it. If it does not, it goes down and matches value2 and this way it proceeds. If none of the value matches, it executes the command associated with asterisk (*). Each command is terminated with a pair of semi colon and the entire construct is closed with esac. Some typical examples using case construct Ø The script given below displays a menu and depending on the option selected, it will

execute the respective command.

echo " 1. Listing of directory" echo " 2. Today's date" echo " 3. Currently working directory" echo " 4. Quit from the program" echo -n "Enter your choice : " read choice case $choice in 1) ls -l;; 2) date;; 3) pwd;; 4) exit;; esac

UNIX

SR/UNIX/401/0204/SC/1.1 96

The output of the above script is given below: Ø The script given below can act as a calendar service. In the script, the expression is

fetched by command substitution. The first filed of the date command is the day of the week itself and depending on the day a particular task is performed.

case `date | cut -d" " -f1` in Wed) ls -l;; Thu) man who;; Fri) cal;; esac

Before executing the above code, let us see the current date:

$date Now, execute the above code and it will display the calendar, as the current weekday is Fri.

UNIX

SR/UNIX/401/0204/SC/1.1 97

Ø The script given below handles both the uppercase and lowercase of expression with

the help of |. It has also used the wildcard characters.

echo " y/Y. Listing of directory" echo " n/N. Today's date" echo " YES/yes/Yes/YEs/yES. Currently working directory" echo " NO/No/nO/no. Quit from the program" echo -n "Enter your choice : " read choice case $choice in y|Y) ls -l;; n|N) date;; [yY][eE][sS]) pwd;; [nN][oO]) exit;; esac

The output of the above command is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 98

Iteration – the while statement Like other programming languages, UNIX also provides some looping constructs. The looping constructions help to perform a task repeatedly till the condition is true. The while construct is one of the looping construct in UNIX. The usage of while loop is given below:

while test <condition> do execute commands done

The set of instruction written within the do…done block is executed till the condition specified with the while statement return true exit status. Some typical examples using while loop Ø The script given below accepts a name from user and displays it. This task continues

till the condition specified is other than y.

UNIX

SR/UNIX/401/0204/SC/1.1 99

reply="y" while test $reply = "y" do echo "Enter your name" read name echo "Your name is : $name" echo "Wish to continue (y/n)" read reply done

The output of the above command is given below: Ø The script given below displays all the number between 1 and 10.

ctr=1 while [ $ctr -le 10 ] do echo "$ctr" ctr=`expr $ctr + 1` done

The output of the above code is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 100

With the help of while statement, we can purposely create an infinite loop. The administrators of the system require these types of loops. For example, the administrator of the system wants to see the free disk space after every five minutes or the processes running in the system. This can be done with the statements where the while control commands do not go for any condition checking but only returns a true value. That means, the loop will continue till it is forcefully terminated. The script given below is an example of while true loop. In this script free disk space and processes running in the system will be displayed after every five minutes. The script will run in the background.

while true do df -t ps sleep 300 done

In the above script, df –t will display the free disk space and ps will display the processes running in the system. The sleep command will make the scrip halt for specified number of seconds. Now run the script in the background in the following manner:

$ sh prog13 & The & sign is used to run any program in the background. Now, after every five minutes the screen will fill with df and ps output.

UNIX

SR/UNIX/401/0204/SC/1.1 101

As told, the background process needs to be terminated forcefully. For this purpose, issue the following command from the command prompt:

$kill $! The above command will terminate the last background process.

Iteration – the until statement The until and while statement are complementary to each other. As while continues the loop till the condition returns a true value, until statement runs the loop till the condition is false. The usage of until statement is given below:

until [ condition ] do execute commands done

An example using until statement is given below:

rep=”y” until [ $rep = “y” ] do echo “\nEnter your name :\c” read name echo “\nYour name is $name” echo “\nWish to Continue :\c” read rep

done

Iteration – the for statement Unlike while and until statement, for loop in UNIX do not check for any condition, instead it uses values from a list. The syntax of for loop is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 102

for variable in list do execute commands done

In the above usage of for loop, the loop body is executed, as many times as there are items in the list. A typical example of for loop is given below:

for var in a b c d do echo " The value of var is : $var" done

The output of the above command is given in the next page: The script given below returns the total number of ordinary files in the current directory.

ctr=0 for var in `ls -l` do if test -f $var then ctr=`expr $ctr + 1` fi done echo "The number of ordinary file : $ctr"

UNIX

SR/UNIX/401/0204/SC/1.1 103

The output of the above code is given below:

Controlling loops – break and continue A for, while or until loop can be controlled with a break or continue command. The break command exits the loop completely, transferring control to the command that follows the done statement. The continue command immediately begins the next execution of the loop, transferring control to the done statement, which continues the loop. The usage of break and continue is given below:

while true

do echo “\nEnter your Department :\c” read dept if [ $dept = “mktg” –o $dept = “acct” –o $dept = “fact” –o $dept = “sales” ] then echo “Valid Department” break else echo “\nInvalid Department” continue fi done

UNIX

SR/UNIX/401/0204/SC/1.1 104

Worked out shell scripts

Ø The script given below finds the factorial of a given number accepted from the user.

echo "Enter a number : \c" read num result=1 while test $num -gt 0 do result=`expr $result \* $num` num=`expr $num - 1` done echo "The factorial of the number is : $result"

The output of the above code is given below: Ø The script given below will accept a string from the user and will check whether the

string is a palindrome or not:

read str len=`echo $str | wc -c` len=`expr $len - 1` ctr=1 while test $len -ge 1 do str1=`echo $str | cut -c$len` str2=`echo $str | cut -c$ctr` if test $str1 != $str2 then

UNIX

SR/UNIX/401/0204/SC/1.1 105

echo "Not a Palindrome" exit else len=`expr $len - 1` ctr=`expr $ctr + 1` fi done echo "Palindrome"

The output of the above code is given below: Ø The script given below we will try to simulate the copy (cp) command of UNIX.

Here, the shell would take the file name and directory path as arguments and check the permissions for the file and the directory. Then the shell will copy the content of the first file to the directory. If a filename is passed as the second argument, then the shell will check whether the second file exists, then it would confirm the over-writing of the file. If the second file does not exist, it will simply copy the file. The command prototype should be like the following:

if [ $# -ne 2 ] then echo " Usage... filecopy file1 file2 " exit else if [ ! -e $1 ] then echo " The file $1 does not exist " exit elif [ ! -r $1 ] then

UNIX

SR/UNIX/401/0204/SC/1.1 106

echo " The file $1 does not have a read permission" exit fi if [ -d $2 ] then if [ -w $2 ] then cp $1 $2

echo " The file $1 has been copied to the $2 directory"

else echo " The directory $2 does not have a write permission"

fi else if [ -e $2 ] then

echo " File $2 exists. Do you want to overwrite? [y/n]"

read choice if [ $choice = "y" ] then if [ ! -w $2 ] then

echo " The file $2 does not have a write permission "

else cp $1 $2

echo " The file $2 has been overwritten"

fi else exit fi else cp $1 $2 echo " The file has been copied ... " fi fi fi

Ø The example given below uses the shift operator to calculate the sum of three

numbers passed as arguments.

UNIX

SR/UNIX/401/0204/SC/1.1 107

if test $# -lt 3 then echo "Usage : Shift 3 4 5 6" exit fi j=$# result=0 while test $j -gt 0 do result=`expr $result + $1` shift j=`expr $j - 1` done echo "The result is : $result"

The output is given below:

UNIX

SR/UNIX/401/0204/SC/1.1 108

Introduction to EXCEED

At the end of this chapter, you will be able to:

Use Exceed to connect to server and run X-applications.

UNIX

SR/UNIX/401/0204/SC/1.1 109

About Exceed Exceed lets you access applications on UNIX workstations from existing Windows 2000/XP, Windows NT, and Windows 98/Me-based personal computers. It lets you run and display UNIX, Linux, VMS, or X Windows applications (X clients) and integrates your desktop with X Window Systems, IBM mainframes, and the Internet. Exceed includes innovative features that accelerate performance, simplify system administration, optimize personal computing, and delivers ease of use. Users are shielded from the complexities of network computing by working within the familiar Microsoft Windows environment. Exceed is an integrated part of the Hummingbird Host Access Solutions product family which provide organizations with a comprehensive Host Access and Network Connectivity solution.

By using Exceed to run remote applications on your local PC, you can:

Ø access powerful applications and information running on networked hosts

Ø establish simultaneous connections to different computers running X clients

Ø use an appropriate window manager to preserve your familiarity with the PC or X environment

For system administrators, Exceed provides tools to set up, configure and administer PCs remotely to ensure consistency among systems.

X Window Systems and Exceed

Exceed converts your PC into an Exceed X server. In the X Window environment, the Exceed X server is also referred to as an X window terminal or display server. Without Exceed X server software, X applications are accessible only via X terminals, UNIX, Linux, and VMS workstations. Exceed works with your network transport software (TCP/IP, DECnet, or IPX/SPX) or your modem, to access X Windows applications on host computers running the X Window System. The host can be any operating system that is running the X Window environment.

Exceed Applications

Exceed includes applications that serve distinct functions. Use the Exceed startup applications to connect to a host and display UNIX, Linux, VMS and X applications on your PC. Use the X Client Wizard to guide you through this process, or set up the connection manually.

UNIX

SR/UNIX/401/0204/SC/1.1 110

Throughout this guide, xterm (a UNIX VT100 terminal emulator) is used as a sample X client. It provides a terminal emulation window on the host, and a command line where you can start other X clients. The applications are listed and briefly described below. Exceed Exceed X server is a PC X server that displays graphical UNIX,Linux, and X applications on your PC. Exceed XDMCP Broadcast This shortcut lets you start the Exceed X server in XDMCP broadcast mode. Exceed XDMCP Query This shortcut lets you start the Exceed X server in XDMCP query mode. X Client Wizard This application guides you through the process of creating a connection to a host. Xconfig Xconfig is a utility for configuring a variety of Exceed settings: input, communication, video, protocol, security, window modes, performance, X selection, fonts, troubleshooting, and transport settings. Xsession Xsession lets you start multiple X clients (Xstart files) and Windows programs (Wstart files) simultaneously. Xstart Xstart is an application for automating access to hosts and starting applications. Use Xstart to create Xstart (.xs) startup files and create shortcut icons to your UNIX, Linux and X applications. When you click on these icons, they automatically establish a host connection, log on, and then start an X client, a character-based host application in a terminal emulator window, or run a host-based script.

Connecting to Hosts

You can connect to a host using a wizard or by creating startup files with Xstart or Wstart.

Using the X Client Wizard

X Client Wizard guides you through the steps necessary for connecting to a host application from your PC. To create a connection using the Client Wizard:

Ø In the Exceed folder, double-click X Client Wizard.

Ø In the welcome screen, click Next.

UNIX

SR/UNIX/401/0204/SC/1.1 111

Ø In the host panel, enter the host name or IP address.

Ø In the same panel, select a host type, then click Next.

Ø In the host connection panel, select a method from the drop-down list. Click Next.

Ø In the application panel, select an X application from the drop-down list. After you have selected an application, the dialog box immediately displays the command and default parameters for the application. You can modify the parameters, but not the command. When you are finished entering this information, click Next.

Ø In the Login panel, enter the login information you want to display each time this connection is made. You can leave the Password box blank, but not the User ID box.

Ø In the Login panel, test the connection. To do this, select Display Host Replies and click Run. When you are satisfied with the connection, clear Display Host Replies and click Next.

Ø In the Shortcut panel, you can create a shortcut to the application, and its name and location. To do this, complete the following information:

§ Type the name of the shortcut and select the option immediately below this box.

§ Select a location from the drop-down list (showing program groups on the Windows Start menu) or type a new group name. To create a menu item on the Exceed X Server Tools menu, select the check box immediately below this box. When you are satisfied with this information, click Next.

Ø 10 The system creates the specified connection and the shortcut.