Lab Objective:: Coastal Institute of Technology and Management

1
LAB OBJECTIVE:
Upon successful completion of this Lab the student will be able to--
1. Demonstrate how to use the following Bourne Shell commands: cat, grep, ls, more, ps,
chmod, finger, ftp, etc.
2. Use the following Bourne Shell constructs: test, if then, if then else, if then elif, for, while,
until, and case.
3. Learn tracing mechanisms (for debugging), user variables, Bourne Shell variables,
read-only variables, positional parameters, reading input to a Bourne Shell script, command
substitution, comments, and exporting variables. In addition, test on numeric values, test on file
type, and test on character strings are covered.
4. Copy, move, and delete files and directories
5. Write moderately complex Shell scripts.
6. Make a Shell script executable.
7. Create a ".profile" script to customize the user environment.
8. Use advanced features of File Transfer Protocol (FTP)
9. Compile source code into object and executable modules.
10. Execute programs written in c under UNIX environment
INTRODUCTION ABOUT LAB:
Coastal Institute of Technology and Management

2
There are 64 systems (HCL) installed in this Lab. Their configurations are
as follows
Processor : Intel Pentium Dual Core CPU E2160 1.80GHz
RAM : 1 GB
Hard Disk : 160 GB
Mouse : Optical Mouse
Network Interface card: Present
Software:
 All
systems are configured in DUAL BOOT mode i.e., Students can boot from Windows
XP or Linux as per their lab requirement.
This is very useful for students because they are familiar with different Operating
Systems so that they can execute their programs in different programming
environments.
 Each student has a separate login for database access
Oracle 9i client version is installed in all systems. On the server, account for each
student has been created.
This is very useful because students can save their work (scenarios’, pl/sql
programs, data related projects, etc) in their own accounts. Each student work is safe
and secure from other students.
 Latest Technologies like DOT NET and J2EE are installed in some systems. Before
submitting their final project, they can start doing mini project from 2nd year onwards.
 MASM ( Macro Assembler ) is installed in all the systems
Students can execute their assembly language programs using MASM. MASM is
very useful students because when they execute their programs they can see
contents of Processor Registers and how each instruction is being executed in the
CPU.
 Rational Rose Software is installed in some systems
Using this software, students can depict UML diagrams of their projects.

3
 Software’s installed: C, C++, JDK1.5, MASM, OFFICE-XP, J2EE and DOT NET,
Rational Rose.
 Systems are provided for students in the 1:1 ratio.
Systems are assigned numbers and same system is allotted for students when they do the lab.
How to Run Shell Scripts:
There are two ways you can execute your shell scripts. Once you have created a script file:
Method 1:
Pass the file as an argument to the shell that you want to interpret your script.
Step 1: create the script using vi, ex or ed
For example, the script file show has the following lines
echo Here is the date and time
date
Step 2: To run the script, pass the filename as an argument to the sh (shell )
$ sh show
Here is the date and time
Sat jun 03 13:40:15 PST 2006
Method 2:
Make your script executable using the chmod command.
When we create a file, by default it is created with read and write permission turned on and
execute permission turned off. A file can be made executable using chmod.
Step 1: create the script using vi, ex or ed
For example, the script file show has the following lines
echo Here is the date and time
date

4
Step 2: Make the file executable
$ chmod u+x script_file
$ chmod u+x show
Step 3: To run the script, just type the filename
$ show
Here is the date and time
Sat jun 03 13:40:15 PST 2006
How to run C programs:
Step 1: Use an editor, such as vi, ex, or ed to write the program. The name of the file containing
the program should end in .c
For example, the file hello.c contains the following lines:
#include<stdio.h>
int main()
{
printf(“ Welcome to CITM “);
return 0;
}
Step 2: Submit the file to CC (the C Compiler) to compile the program
$ cc –c hello.c
If the program is okay, have to create execute file
Step 3: To create execute file,
$ cc –o hello hello.o
Step 3: To run the program, type. /hello
$. /helo
Welcome to CITM
How to run C++ programs:
the program should end in .C
For example, the file hello.C contains the following lines:

5
#include<iostream.h>
int main()
{
cout<<”\n Welcome to CITM”;
return 0;
}
Step 2: Submit the file to CC (the C++ Compiler) to compile the program
$ CC –c hello.C
If the program is okay, have to create execute file
Step 3: To create execute file,
$ CC –o hello hello.o
Step 3: To run the program, type. /hello
$. /helo
Welcome to CITM
How to run java programs:
the class name of a program
For example, the class test contains the following lines:
Public class test

{
Public static void main(string s[])
{
System.out.println(“Welcome to CITM”);
}
Step 2: Submit the file to javac ( the JAVA Compiler )
$ javac test.java
Step 3: To run the program, type java test
$ java test
The vi Editor:

6
To write and edit some programs and scripts, we require editors. UNIX provides vi editor for
BSD system – created by Bill Joy. Bram Moolenaar improved vi editor and called it as vim (vi
improved) on Linux OS.
vi Basics
To add some text to a file, we invoke,
vi <filename>
In all probability, the file doesn’t exist, and vi presents you a full screen with the filename
shown at the bottom with the qualifier. The cursor is positioned at the top and all remaining lines
of the screen show a ~. They are non-existent lines. The last line is reserved for commands that
you can enter to act on text. This line is also used by the system to display messages. This is
the command mode. This is the mode where you can pass commands to act on text, using most
of the keys of the keyboard. This is the default mode of the editor where every key pressed is
interpreted as a command to run on text. You will have to be in this mode to copy and delete
text
For, text editing, vi uses 24 out of 25 lines that are normally available in the terminal. To
enter text, you must switch to the input mode. First press the key i, and you are in this mode
ready to input text. Subsequent key depressions will then show up on the screen as text input.
After text entry is complete, the cursor is positioned on the last character of the last line.
This is known as current line and the character where the cursor is stationed is the current
cursor position. This mode is used to handle files and perform substitution. After the command
is run, you are back to the default command mode. If a word has been misspelled, use ctrl-w to
erase the entire word.
Now press esc key to revert to command mode. Press it again and you will hear a beep.
A beep in vi indicates that a key has been pressed unnecessarily. Actually, the text entered has
not been saved on disk but exists in some temporary storage called a buffer. To save the
entered text, you must switch to the execute mode (the last line mode). Invoke the execute
mode from the command mode by entering a: which shows up in the last line.
The Repeat Factor
vi provides repeat factor in command and input mode commands. Command mode
command k moves the cursor one line up. 10k moves cursor 10 lines up.
To undo whenever you make a mistake, press
Esc u
To clear the screen in command mode, press
ctrl-l
Don’t use (caps lock) - vi commands are case-sensitive
Avoid using the PC navigation keys

7
Input Mode – Entering and Replacing Text
It is possible to display the mode in which is user is in by typing,
:set showmode
Messages like INSERT MODE, REPLACE MODE, CHANGE MODE, etc will appear in the last
line.
Pressing ‘i’ changes the mode from command to input mode. To append text to the right of the
cursor position, we use a, text. I and A behave same as i and a, but at line extremes
I inserts text at the beginning of line. A appends text at end of line. o opens a new line below the
current line
• r<letter> replacing a single character

• s<text/word> replacing text with s
• R<text/word> replacing text with R
• Press esc key to switch to command mode after you have keyed in text
Some of the input mode commands are:
COMMAND FUNCTION
i inserts text
a appends text
I inserts at beginning of line
A appends text at end of line
o opens line below
O opens line above
r replaces a single character
s replaces with a text
S replaces entire line
Saving Text and Quitting – The ex Mode
When you edit a file using vi, the original file is not distributed as such, but only a copy of
it that is placed in a buffer. From time to time, you should save your work by writing the buffer
contents to disk to keep the disk file current. When we talk of saving a file, we actually mean
saving this buffer. You may also need to quit vi after or without saving the buffer. Some of the
save and exit commands of the ex mode is:
Command Action
:W saves file and remains in editing mode

8
:x saves and quits editing mode
:wq saves and quits editing mode
:w <filename> save as
:w! <filename> save as, but overwrites existing file
:q quits editing mode
:q! quits editing mode by rejecting changes made
:sh escapes to UNIX shell
:recover recovers file from a crash
Navigation
A command mode command doesn’t show up on screen but simply performs a function.
To move the cursor in four directions,
k moves cursor up
j moves cursor down
h moves cursor left
l moves cursor right
Word Navigation
Moving by one character is not always enough. You will often need to move faster along a
line. vi understands a word as a navigation unit which can be defined in two ways, depending on
the key pressed. If your cursor is a number of words away from your desired position, you can
use the word-navigation commands to go there directly. There are three basic commands:
b moves back to beginning of word
e moves forward to end of word
w moves forward to beginning word
Example,
5b takes the cursor 5 words back
3w takes the cursor 3 words forward
Moving to Line Extremes
Moving to the beginning or end of a line is a common requirement.

9
To move to the first character of a line 0 or |
30| moves cursor to column 30
$ moves to the end of the current line
The use of these commands along with b, e, and w is allowed
Scrolling
Faster movement can be achieved by scrolling text in the window using the control keys.
The two commands for scrolling a page at a time are
ctrl-f scrolls forward
ctrl-b scrolls backward
10ctrl-f scroll 10 pages and navigate faster
ctrl-d scrolls half page forward
ctrl-u scrolls half page backward
Absolute Movement
The editor displays the total number of lines in the last line
Ctrl-g to know the current line number
40G goes to line number 40
1G goes to line number 1
G goes to end of file
Editing Text
The editing facilitates in vi are very elaborate and invoke the use of operators. They use
operators, such as,
d delete
y yank (copy)
Deleting Text
x deletes a single character
dd delete entire line
yy copy entire line
6dd deletes the current line and five lines below

10
Moving Text
Moving text (p) puts the text at the new location.
p and P place text on right and left only when you delete parts of lines. But the same keys get
associated with “below” and “above” when you delete complete lines
Copying Text
Copying text (y and p) is achieved as,
yy copies current line
10yy copies current line & 9 lines below
Joining Lines
J to join the current line and the line following it
4J joins following 3 lines with current line
Undoing Last Editing Instructions
In command mode, to undo the last change made, we use u
To discard all changes made to the current line, we use U
vim (LINUX) lets you undo and redo multiple editing instructions. u behaves differently
here; repeated use of this key progressively undoes your previous actions. You could even have
the original file in front of you. Further 10u reverses your last 10 editing actions. The function of
U remains the same.
You may overshoot the desired mark when you keep u pressed, in which case use ctrl-r
to redo your undone actions. Further, undoing with 10u can be completely reversed with 10ctrl-r.
The undoing limit is set by the execute mode command: set undolevels=n, where n is set to
1000 by default.
Repeating the Last Command
The. (dot) command is used for repeating the last instruction in both editing and command
mode commands
For example:
2dd deletes 2 lines from current line and to repeat this operation, type. (dot)
Searching for a Pattern
/ search forward
? search backward

11
/printf
The search begins forward to position the cursor on the first instance of the word
?pattern
Searches backward for the most previous instance of the pattern
Repeating the Last Pattern Search
N repeats search in same direction of original search
n doesn’t necessarily repeat a search in the forward direction. The direction depends on
the search command used. If you used? printf to search in the reverse direction in the first
place, then n also follows the same direction. In that case, N will repeat the search in the
forward direction, and not n.
Search and repeat commands
Command Function
/pat searches forward for pattern pat
?pat searches backward for pattern pat
n repeats search in same direction along which previous search was made
N repeats search in direction opposite to that along which previous search was made
Substitution – search and replace
We can perform search and replace in execute mode using: s. Its syntax is,
:address/source_pattern/target_pattern/flags
:1,$s/director/member/g can also use % instead of 1,$
:1,50s/unsigned//g deletes unsigned everywhere in lines 1 to 50
:3,10s/director/member/g substitute lines 3 through 10
:.s/director/member/g only the current line
:$s/director/member/g only the last line
Interactive substitution: sometimes you may like to selectively replace a string. In that case, add
the c parameter as the flag at the end:
:1,$s/director/member/gc
Each line is selected in turn, followed by a sequence of carets in the next line, just below the
pattern that requires substitution. The cursor is positioned at the end of this caret sequence,
waiting for your response.

12
The ex mode is also used for substitution. Both search and replace operations also use
regular expressions for matching multiple patterns.
The features of vi editor that have been highlighted so far are good enough for a
beginner who should not proceed any further before mastering most of them. There are many
more functions that make vi a very powerful editor. Can you copy three words or even the entire
file using simple keystrokes? Can you copy or move multiple sections of text from one file to
another in a single file switch? How do you compile your C and Java programs without leaving
the editor? vi can do all this.
System Calls:
System calls are special set of functions available in several programming languages. They are
used by programs to communicate directly with an operating system. The operating system
communicates back to the user's program through the return value of the function.
Generally, system calls are slower than normal function calls. The reason is because when you
call a system call, control is relinquished to the operating system to perform the system call. In
addition, depending on the nature of the system call, your program may be blocked by the OS
until the system call has finished, thus making the execution time of your program even longer.
One rule of thumb should always be followed when calling a system call: Always check the
return value. The return value is the only method that the operating system has to communicate
information to your program. Thus, you should always check the return value in the event that
the system call failed.
List of C System Calls
close
dup
dup2
festal
lseek
lstat
open
read
stat
write
open (C System Call)

13
open is a system call that is used to open a new file and obtain its file descriptor.
Required Include Files
#include <fcntl.h>
/* Not technically required, but needed on some UNIX distributions */
#include <sys/types.h>
#include <sys/stat.h>
Function Definition
int open(const char *path, int oflags);
int open(const char *path, int oflags, mode_t mode);
Field Description
const
char The relative or absolute path to the file that is to be opened.
*path
A bitwise 'or' separated list of values that determine the method in which the file is to
int oflags be opened (whether it should be read only, read/write, whether it should be cleared
when opened, etc). See a list of legal values for this field at the end.
mode_t A bitwise 'or' separated list of values that determine the permissions of the file if it is
mode created. See a list of legal values at the end.
Returns the file descriptor for the new file. The file descriptor returned is always the
return
smallest integer greater than zero that is still available. If a negative value is returned,
value
then there was an error opening the file.
Example
Example using the open system call:
#include <unistd.h>
#include <fcntl.h>
int main()
size_t filedesc = open("testfile.txt", O_WRONLY | O_APPEND);
if(filedesc < 0)

14
return 1;
if(write(filedesc,"This will be output to testfile.txt\n", 36) != 36)
write(2,"There was an error writing to testfile.txt\n",43);
return 1;
return 0;
Available Values for oflag
Value Meaning
O_RDONLY Open the file so that it is read only.
O_WRONLY Open the file so that it is write only.
O_RDWR Open the file so that it can be read from and written to.
O_APPEND Append new information to the end of the file.
O_TRUNC Initially clear all data from the file.
If the file does not exist, create it. If the O_CREAT option is used, then you must
O_CREAT
include the third parameter.
Combined with the O_CREAT option, it ensures that the caller must create the file.
O_EXCL
If the file already exists, the call will fail.
Available Values for mode
Value Meaning
S_IRUSR Set read rights for the owner to true.
S_IWUSR Set write rights for the owner to true.

15
S_IXUSR Set execution rights for the owner to true.
S_IRGRP Set read rights for the group to true.
S_IWGRP Set write rights for the group to true.
S_IXGRP Set execution rights for the group to true.
S_IROTH Set read rights for other users to true.
S_IWOTH Set write rights for other users to true.
S_IXOTH Set execution rights for other users to true.
close (C System Call)
close is a system call that is used to close an open file descriptor.
#include <unistd.h>
Function Definition
int close(int fieldes);
Field Description
int
The file descriptor to be closed.
fieldes
return Retuns a 0 upon success, and a -1 upon failure. It is important to check the return
value value, because some network errors are not returned until the file is closed.
Example
Example closing an open file descriptor:
#include <stdlib.h>
#include <fcntl.h>
int main()

16
size_t filedesc = open("testfile.txt", O_WRONLY | O_CREAT);
if(filedesc < 0)
return 1;
if(close(filedesc) < 0)
return 1;}return 0;}
read (C System Call)
read is a system call used to read data into a buffer.
#include <unistd.h>
Function Definition
size_t read(int fildes, void *buf, size_t nbytes);
Field Description
The file descriptor of where to write the output. You can either use a file
int fildes descriptor obtained from the open system call, or you can use 0, 1, or 2, to
refer to standard input, standard output, or standard error, respectively.
const
A character array where the read content will be stored.
void *buf
size_t The number of bytes to read before truncating the data. If the data to be read is
nbytes smaller than nbytes, all data is saved in the buffer.
return Returns the number of bytes that were read. If value is negative, then the
value system call returned an error.
Example
#include <unistd.h>
int main()
char data[128];
if(read(0, data, 128) < 0)

17
write(2, "An error occurred in the read.\n", 31);
exit(0);
write (C System Call)
write is a system call that is used to write data out of a buffer.
#include <unistd.h>
Function Definition
size_t write(int fildes, const void *buf, size_t nbytes);
Field Description
The file descriptor of where to write the output. You can either use a file descriptor
int fildes obtained from the open system call, or you can use 0, 1, or 2, to refer to standard
input, standard output, or standard error, respectively.
const
A null terminated character string of the content to write.
void *buf
size_t The number of bytes to write. If smaller than the provided buffer, the output is
nbytes truncated.
return Returns the number of bytes that were written. If value is negative, then the system
value call returned an error.
Example
Example using standard file descriptors:
#include <unistd.h>
int main()
if(write(1,"This will be output to standard out\n", 36) != 36)

18
write(2,"There was an error writing to standard out\n",44);
return 1;
return 0;
Example using a file descriptor:
#include <unistd.h>
#include <fcntl.h>
int main()
size_t filedesc = open("testfile.txt", O_WRONLY | O_APPEND);
if(filedesc < 0)
return 1;
if(write(filedesc,"This will be output to testfile.txt\n", 36) != 36)
write(2,"There was an error writing to testfile.txt\n",43);
return 1;
return 0;
stat (C System Call)
stat is a system call that is used to determine information about a file based on its file path.
#include <unistd.h>

19
Function Definition
int stat(const char *path, struct stat *buf);
Field Description
const char
The file descriptor of the file that is being inquired.
*path
struct stat A structure where data about the file will be stored. A detailed look at all of the fields
*buf in this structure can be found in the struct stat page.
return
Returns a negative value on failure.
value
Example
An example of code that uses the stat() system call is below.
#include <unistd.h>
#include <stdio.h>
int main(int argc, char **argv)
if(argc != 2)
return 1;
struct stat fileStat;
if(stat(argv[1],&fileStat) < 0)
return 1;
printf("Information for %s\n",argv[1]);
printf("---------------------------\n");
printf("File Size: \t\t%d bytes\n",fileStat.st_size);
printf("Number of Links: \t%d\n",fileStat.st_nlink);
printf("File inode: \t\t%d\n",fileStat.st_ino);
printf("File Permissions: \t");

20
printf( (S_ISDIR(fileStat.st_mode)) ? "d" : "-");
printf( (fileStat.st_mode & S_IRUSR) ? "r" : "-");
printf( (fileStat.st_mode & S_IWUSR) ? "w" : "-");
printf( (fileStat.st_mode & S_IXUSR) ? "x" : "-");
printf( (fileStat.st_mode & S_IRGRP) ? "r" : "-");
printf( (fileStat.st_mode & S_IWGRP) ? "w" : "-");
printf( (fileStat.st_mode & S_IXGRP) ? "x" : "-");
printf( (fileStat.st_mode & S_IROTH) ? "r" : "-");
printf( (fileStat.st_mode & S_IWOTH) ? "w" : "-");
printf( (fileStat.st_mode & S_IXOTH) ? "x" : "-");
printf("\n\n");
printf("The file %s a symbolic link\n", (S_ISLNK(fileStat.st_mode)) ? "is" : "is not");
return 0;
The output of this program is shown in the following set of commands:
Information on the current files in the directory:
$ ls -l
total 16
-rwxr-xr-x 1 stargazer stargazer 36 2009-05-06 20:50 testfile.sh
-rwxr-xr-x 1 stargazer stargazer 7780 2009-05-07 12:36 testProgram
-rw-r--r-- 1 stargazer stargazer 1229 2009-05-07 12:04 testProgram.c
Running the program with the file testfile.sh
$ ./testProgram testfile.sh
Information for testfile.sh
---------------------------
File Size: 36 bytes
Number of Links: 1
File inode: 180055

21
File Permissions: -rwxr-xr-x
The file is not a symbolic link
Running the program with the files testProgram.c
$ ./testProgram testProgram.c
Information for testProgram.c
---------------------------
File Size: 1229 bytes
Number of Links: 1
File inode: 295487
File Permissions: -rw-r--r--
Running the program with the directory /home/stargazer
$ ./testProgram /home/stargazer
Information for /home/stargazer
---------------------------
Number of Links: 61
File inode: 32706
File Permissions: drwxr-xr-x
fstat (C System Call)
fstat is a system call that is used to determine information about a file based on its file
descriptor.
#include <unistd.h>
Function Definition
int fstat(int fildes, struct stat *buf);

22
Field Description
int fildes The file descriptor of the file that is being inquired.
struct stat *buf A structure where data about the file will be stored.
return value Returns a negative value on failure.
Example
An example of code that uses the fstat() system call is below.
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
int main(int argc, char **argv)
if(argc != 2)
return 1;
int file=0;
if((file=open(argv[1],O_RDONLY)) < -1)
return 1;
struct stat fileStat;
if(fstat(file,&fileStat) < 0)
return 1;
printf("Information for %s\n",argv[1]);
printf("---------------------------\n");
printf("File Size: \t\t%d bytes\n",fileStat.st_size);
printf("Number of Links: \t%d\n",fileStat.st_nlink);
printf("File inode: \t\t%d\n",fileStat.st_ino);

23
printf("File Permissions: \t");
printf( (S_ISDIR(fileStat.st_mode)) ? "d" : "-");
printf( (fileStat.st_mode & S_IRUSR) ? "r" : "-");
printf( (fileStat.st_mode & S_IWUSR) ? "w" : "-");
printf( (fileStat.st_mode & S_IXUSR) ? "x" : "-");
printf( (fileStat.st_mode & S_IRGRP) ? "r" : "-");
printf( (fileStat.st_mode & S_IWGRP) ? "w" : "-");
printf( (fileStat.st_mode & S_IXGRP) ? "x" : "-");
printf( (fileStat.st_mode & S_IROTH) ? "r" : "-");
printf( (fileStat.st_mode & S_IWOTH) ? "w" : "-");
printf( (fileStat.st_mode & S_IXOTH) ? "x" : "-");
printf("\n\n");
printf("The file %s a symbolic link\n\n", (S_ISLNK(fileStat.st_mode)) ? "is" : "is not");
return 0;
The output of this program is shown in the following set of commands:
Information on the current files in the directory:
$ ls -l
total 16
-rwxr-xr-x 1 stargazer stargazer 36 2009-05-06 20:50 testfile.sh
-rwxr-xr-x 1 stargazer stargazer 7780 2009-05-07 12:36 testProgram
-rw-r--r-- 1 stargazer stargazer 1229 2009-05-07 12:04 testProgram.c
Running the program with the file testfile.sh
$ ./testProgram testfile.sh
Information for testfile.sh
---------------------------
File Size: 36 bytes
Number of Links: 1

24
File inode: 180055
File Permissions: -rwxr-xr-x
Running the program with the files testProgram.c
$ ./testProgram testProgram.c
Information for testProgram.c
---------------------------
Number of Links: 1
File inode: 295487
File Permissions: -rw-r--r--
Running the program with the directory /home/stargazer
$ ./testProgram /home/stargazer
Information for /home/stargazer
---------------------------
Number of Links: 61
File inode: 32706
File Permissions: drwxr-xr-x
lstat (C System Call)
lstat is a system call that is used to determine information about a file based on its filename.
lstat is exactly the same as the stat system call. The only difference between the two is when
the filename refers to a link. When this is the case, lstat returns information about the link itself,
whereas stat returns information about the actual file.
#include <unistd.h>

25
Function Definition
int lstat(const char *path, struct stat *buf);
Field Description
const char The file path of the file that is being inquired. This can be both relative and
*path absolute.
struct stat *buf A structure where data about the file will be stored.
return value Returns a negative value on failure.
Example
The code for using lstat is exactly the same as the code for using stat. As mentioned before, the
only difference between the two functions is when the target is a symbolic link.
lseek (C System Call)
lseek is a system call that is used to change the location of the read/write pointer of a file
descriptor. The location can be set either in absolute or relative terms.
#include <unistd.h>
Function Definition
off_t lseek(int fildes, off_t offset, int whence);
Field Description
int fildes The file descriptor of the pointer that is going to be moved.
off_t
The offset of the pointer (measured in bytes).
offset
int The method in which the offset is to be interpreted (relative, absolute, etc.). Legal
whence values for this variable are provided at the end.
return Returns the offset of the pointer (in bytes) from the beginning of the file. If the return
value value is -1, then there was an error moving the pointer.
Example

26
The following is an example using the lseek system call.
#include <unistd.h>
#include <fcntl.h>
int main()
int file=0;
if((file=open("testfile.txt",O_RDONLY)) < -1)
return 1;
char buffer[19];
if(read(file,buffer,19) != 19) return 1;
printf("%s\n",buffer);
if(lseek(file,10,SEEK_SET) < 0) return 1;
if(read(file,buffer,19) != 19) return 1;
printf("%s\n",buffer); return 0;
The output of the preceding code is:
$ cat testfile.txt
This is a test file that will be used to demonstrate the use of lseek.
$ ./testing
This is a test file
test file that will
Available Values for whence
Value Meaning
SEEK_SET Offset is to be measured in absolute terms.
SEEK_CUR Offset is to be measured relative to the current location of the pointer.
SEEK_END Offset is to be measured relative to the end of the file.

27
dup (C System Call)
dup is a system call similar to dup2 in that it creates an alias for the provided file descriptor. dup
always uses the smallest available file descriptor. Thus, if we called dup first thing in our
program, then you could write to standard output by using file descriptor 3 (dup uses 3 because
0, 1, and 2 are already taken by default). You can determine the value of the new file descriptor
by saving the return value from dup
#include <unistd.h>
Function Definition
int dup(int fildes);
Field Description
int fildes The file descriptor that you are attempting to create an alias for.
dup returns the value of the new file descriptor that it has created (which will always be
return
the smallest available file descriptor). A negative return value means that an error
value
occured.
Example
Using dup(), we can create an alias for standard output, as follows:
#include <unistd.h>
int main()
int outputAlias = dup(1);
if(write(outputAlias, "This will print to the screen.") < 0)
return 1;
return 0;
You can also use dup() to redirect standard output by taking advantage of the fact that it always
uses the smallest available file descriptor:
#include <unistd.h>
int main()
int file = open("MyFile.txt",O_RDWR);

28
if( file < 0) return 1;
/* yes, we are about to close standard output */
close(1);
/* Now we call dup to create a duplicate file descriptor. Because dup always
uses the smallest available file descriptor and we just closed file descriptor
1, the return value on dup will be 1. */
if(dup(file) != 1) return 1;
/* We don't need our original file descriptor, because now the file descriptor 1
points to our file. */
close(file);
/* Now all of standard output has been redirected to our file */
printf("This will be printed to MyFile.txt");
return 0;
dup2 (C System Call) :dup2 is a system call similar to dup in that it duplicates one file
descriptor, making them aliases, and then deleting the old file descriptor. This becomes very
useful when attempting to redirect output, as it automatically takes care of closing the old file
descriptor, performing the redirection in one elegant command. For example, if you wanted to
redirect standard output to a file, then you would simply call dup2, providing the open file
descriptor for the file as the first command and 1 (standard output) as the second command.
#include <unistd.h>
Function Definition
int dup2(int fildes, int fildes2);
Field Description
int fildes The file descriptor that will be changed.
int fildes2 The file descriptor that will be used to make the copy.
dup2 returns the value of the first parameter (fildes) upon success. A negative return
return value
value means that an error occured.
Example

29
Using dup2(), we can redirect standard output to a file, as follows:
#include <iostream>
#include <unistd.h>
#include <fcntl.h>
using namespace std;
int main()
//First, we're going to open a file
int file = open("myfile.txt", O_APPEND | O_WRONLY);
if(file < 0) return 1;
//Now we redirect standard output to the file using dup2
if(dup2(file,1) < 0) return 1;
//Now standard out has been redirected, we can write to
cout << "This will print in myfile.txt" << endl;
return 0; }//end of function main
Why Use Shells? Well, most likely because the are a simple way to string together a bunch of
UNIX commands for execution at any time without the need for prior compilation. Also because
its generally fast to get a script going. Not forgetting the ease with which other scripters can
read the code and understand what is happening. Lastly, they are generally completely portable
across the whole UNIX world, as long as they have been written to a common standard.
The Shell History: The basic shells come in three main language forms. These are (in order of
creation) sh, csh and ksh. Be aware that there are several dialects of these script languages
which tend to make them all slightly platform specific. Where these differences are known to
cause difficulties I have made special notes within the text to highlight this fact. The different
dialects are due, in the main, to the different UNIX flavours in use on some platforms. All script
languages though have at their heart a common core which if used correctly will guarantee
portability.
Bourne Shell:Historically the sh language was the first to be created and goes under the name
of The Bourne Shell. It has a very compact syntax which makes it obtuse for novice users but
very efficient when used by experts. It also contains some powerful constructs built in. On UNIX
systems, most of the scripts used to start and configure the operating system are written in the
Bourne shell. It has been around for so long that is it virtually bug free. I have adopted the
Bourne shell syntax as the defacto standard within this book.
C Shell:Next up was The C Shell (csh), so called because of the similar syntactical structures
to the C language. The UNIX man pages contain almost twice as much information for the C
Shell as the pages for the Bourne shell, leading most users to believe that it is twice as good.

30
This is a shame because there are several compromises within the C Shell which makes using
the language for serious work difficult (check the list of bugs at the end of the man pages!).
True, there are so many functions available within the C Shell that if one should fail another
could be found. The point is do you really want to spend your time finding all the alternative
ways of doing the same thing just to keep yourself out of trouble. The features that guarantee its
continued use in this arena are aliases, and history lists. There are rumors however; that C
Shell is destined to be phased out, with future UNIX releases only supporting sh and ksh.
Differences between csh and sh syntax will be highlighted where appropriate.
Korne Shell:Lastly we come to The Korne Shell (ksh) made famous by IBM's AIX flavour of
UNIX. The Korne shell can be thought of as a superset of the Bourne shell as it contains the
whole of the Bourne shell world within its own syntax rules. The extensions over and above the
Bourne shell exceed even the level of functionality available within the C Shell (but without any
of the compromises!), making it the obvious language of choice for real scripters. However,
because not all platforms are yet supporting the Korne shell it is not fully portable as a scripting
language at the time of writing. This may change however by the time this book is published.
Korne Shell does contain aliases and history lists aplenty but C Shell users are often put off by
its dissimilar syntax. Persevere, it will pay off eventually. Any sh syntax element will work in the
ksh without change
FILTERS USING REGULAR EXPRESSIONS – grep and sed:
We often need to search a file for a pattern, either to see the lines containing (or not
containing) it or to have it replaced with something else. This chapter discusses two important
filters that are specially suited for these tasks – grep and sed. grep takes care of all search
requirements we may have. sed goes further and can even manipulate the individual characters
in a line. In fact sed can de several things, some of then quite well.
grep – searching for a pattern
It scans the file / input for a pattern and displays lines containing the pattern, the line
numbers or filenames where the pattern occurs. It’s a command from a special family in UNIX
for handling search requirements.
grep options pattern filename(s)
grep “sales” emp.lst
will display lines containing sales from the file emp.lst. Patterns with and without quotes is
possible. It’s generally safe to quote the pattern. Quote is mandatory when pattern involves
more than one word. It returns the prompt in case the pattern can’t be located.
grep president emp.lst
When grep is used with multiple filenames, it displays the filenames along with the output.

31
grep “director” emp1.lst emp2.lst
Where it shows filename followed by the contents
grep options
grep is one of the most important UNIX commands, and we must know the options that
POSIX requires grep to support. Linux supports all of these options.
-i ignores case for matching
-v doesn’t display lines matching expression
-n displays line numbers along with lines
-c displays count of number of occurrences
-l displays list of filenames only
-e exp specifies expression with this option
-x matches pattern with entire line
-f file takes pattrens from file, one per line
-E treats pattren as an extended RE
-F matches multiple fixed strings
grep -i ‘agarwal’ emp.lst
grep -v ‘director’ emp.lst > otherlist
wc -l otherlist will display 11 otherlist
grep –n ‘marketing’ emp.lst
grep –c ‘director’ emp.lst
grep –c ‘director’ emp*.lst
will print filenames prefixed to the line count
grep –l ‘manager’ *.lst
will display filenames only
grep –e ‘Agarwal’ –e ‘aggarwal’ –e ‘agrawal’ emp.lst
will print matching multiple patterns
grep –f pattern.lst emp.lst
all the above three patterns are stored in a separate file pattern.lst
Basic Regular Expressions (BRE) – An Introduction

32
It is tedious to specify each pattern separately with the -e option. grep uses an
expression of a different type to match a group of similar patterns. If an expression uses meta
characters, it is termed a regular expression. Some of the characters used by regular
expression are also meaningful to the shell.
BRE character subset
The basic regular expression character subset uses an elaborate meta character set,
overshadowing the shell’s wild-cards, and can perform amazing matches.
* Zero or more occurrences
g* nothing or g, gg, ggg, etc.
. A single character
.* nothing or any number of characters
[pqr] a single character p, q or r
[c1-c2] a single character within the ASCII range represented by c1 and c2
The character class
grep supports basic regular expressions (BRE) by default and extended regular
expressions (ERE) with the –E option. A regular expression allows a group of characters
enclosed within a pair of [ ], in which the match is performed for a single character in the group.
grep “[aA]g[ar][ar]wal” emp.lst
A single pattern has matched two similar strings. The pattern [a-zA-Z0-9] matches a single
alphanumeric character. When we use range, make sure that the character on the left of the
hyphen has a lower ASCII value than the one on the right. Negating a class (^) (caret) can be
used to negate the character class. When the character class begins with this character, all
characters other than the ones grouped in the class are matched.
The *
The asterisk refers to the immediately preceding character. * indicates zero or more
occurrences of the previous character.
g* nothing or g, gg, ggg, etc.
grep “[aA]gg*[ar][ar]wal” emp.lst
Notice that we don’t require to use –e option three times to get the same output!!!!!
The dot
A dot matches a single character. The shell uses ? Character to indicate that.

33
.* signifies any number of characters or none
grep “j.*saxena” emp.lst
Specifying Pattern Locations (^ and $)
Most of the regular expression characters are used for matching patterns, but there are
two that can match a pattern at the beginning or end of a line. Anchoring a pattern is often
necessary when it can occur in more than one place in a line, and we are interested in its
occurance only at a particular location.
^ for matching at the beginning of a line
$ for matching at the end of a line
grep “^2” emp.lst
Selects lines where emp_id starting with 2
grep “7…$” emp.lst
Selects lines where emp_salary ranges between 7000 to 7999
grep “^[^2]” emp.lst
Selects lines where emp_id doesn’t start with 2
When meta characters lose their meaning
It is possible that some of these special characters actually exist as part of the text.
Sometimes, we need to escape these characters. For example, when looking for a pattern g*,
we have to use \
To look for [, we use \[
To look for .*, we use \.\*
Extended Regular Expression (ERE) and grep
If current version of grep doesn’t support ERE, then use egrep but without the –E option.
-E option treats pattern as an ERE.
+ matches one or more occurrences of the previous character
? Matches zero or one occurrence of the previous character
b+ matches b, bb, bbb, etc.
b? matches either a single instance of b or nothing
These characters restrict the scope of match as compared to the *
grep –E “[aA]gg?arwal” emp.lst

34
# ?include +<stdio.h>
The ERE set
ch+ matches one or more occurrences of character ch
ch? Matches zero or one occurrence of character ch
exp1|exp2 matches exp1 or exp2
(x1|x2)x3 matches x1x3 or x2x3
Matching multiple patterns (|, ( and ))
grep –E ‘sengupta|dasgupta’ emp.lst
We can locate both without using –e option twice, or
grep –E ‘(sen|das)gupta’ emp.lst
sed – The Stream Editor
sed is a multipurpose tool which combines the work of several filters. sed uses
instructions to act on text. An instruction combines an address for selecting lines, with an
action to be taken on them.
sed options ‘address action’ file(s)
sed supports only the BRE set. Address specifies either one line number to select a single line
or a set of two lines, to select a group of contiguous lines. action specifies print, insert, delete,
substitute the text.
sed processes several instructions in a sequential manner. Each instruction operates on

the output of the previous instruction. In this context, two options are relevant, and probably they
are the only ones we will use with sed – the –e option that lets us use multiple instructions, and
the –f option to take instructions from a file. Both options are used by grep in identical manner.
Line Addressing
sed ‘3q’ emp.lst
Just similar to head –n 3 emp.lst. Selects first three lines and quits
sed –n ‘1,2p’ emp.lst
p prints selected lines as well as all lines. To suppress this behavior, we use –n whenever we
use p command
sed –n ‘$p’ emp.lst
Selects last line of the file

35
sed –n ‘9,11p’ emp.lst
Selecting lines from anywhere of the file, between lines from 9 to 11
sed –n ‘1,2p
7,9p
$p’ emp.lst
Selecting multiple groups of lines
sed –n ‘3,$!p’ emp.lst
Negating the action, just same as 1,2p
Using Multiple Instructions (-e and –f)
There is adequate scope of using the –e and –f options whenever sed is used with
multiple instructions.
sed –n –e ‘1,2p’ –e ‘7,9p’ –e ‘$p’ emp.lst
Let us consider,
cat instr.fil
1,2p
7,9p
$p
-f option to direct the sed to take its instructions from the file
sed –n –f instr.fil emp.lst
We can combine and use –e and –f options as many times as we want
sed –n –f instr.fil1 –f instr.fil2 emp.lst
sed –n –e ‘/saxena/p’ –f instr.fil1 –f instr.fil2 emp.lst
Context Addressing
We can specify one or more patterns to locate lines
sed –n ‘/director/p’ emp.lst
We can also specify a comma-separated pair of context addresses to select a group of lines.
sed –n ‘/dasgupta/,/saxena/p’ emp.lst
Line and context addresses can also be mixed
sed –n ‘1,/dasgupta/p’ emp.lst

36
Using regular expressions
Context addresses also uses regular expressions.
Sed –n ‘/[aA]gg*[ar][ar]wal/p’ emp.lst
Selects all agarwals.
Sed –n ‘/sa[kx]s*ena/p
/gupta/p’ emp.lst
Selects saxenas and gupta.
We can also use ^ and $, as part of the regular expression syntax.
sed –n ‘/50…..$/p’ emp.lst
Selects all people born in the year 1950.
Writing Selected Lines to a File (w)
We can use w command to write the selected lines to a separate file.
sed –n ‘/director/w dlist’ emp.lst
Saves the lines of directors in dlist file
sed –n ‘/director/w dlist
/manager/w mlist
/executive/w elist’ emp.lst
Splits the file among three files
sed –n ‘1,500w foo1
501,$w foo2’ foo.main
Line addressing also is possible. Saves first 500 lines in foo1 and the rest in foo2
Text Editing
sed supports inserting (i), appending (a), changing (c) and deleting (d) commands for the
text.
$ sed ‘1i\
> #include <stdio.h>\
> #include <unistd.h>
> ’foo.c > $$

37
Will add two include lines in the beginning of foo.c file. Sed identifies the line without the \ as the
last line of input. Redirected to $$ temporary file. This technique has to be followed when using
the a and c commands also. To insert a blank line after each line of the file is printed (double
spacing text), we have,
sed ‘a\
’ emp.lst
Deleting lines (d)
sed ‘/director/d’ emp.lst > olist or
sed –n ‘/director/!p’ emp.lst > olist
Selects all lines except those containing director, and saves them in olist
Note that –n option not to be used with d
Substitution (s)
Substitution is the most important feature of sed, and this is one job that sed does
exceedingly well.
[address]s/expression1/expression2/flags
Just similar to the syntax of substitution in vi editor, we use it in sed also.
sed ‘s/|/:/’ emp.lst | head –n 2
2233:a.k.shukla |gm |sales |12/12/52|6000
9876:jai sharma |director|production|12/03/50|7000
Only the first instance of | in a line has been replaced. We need to use the g (global) flag
to replace all the pipes
sed ‘s/|/:/g’ emp.lst | head –n 2
We can limit the vertical boundaries too by specifying an address (for first three lines only).
sed ‘1,3s/|/:/g’ emp.lst
Replace the word director with member in the first five lines of emp.lst
sed ‘1,5s/director/member/’ emp.lst
sed also uses regular expressions for patterns to be substituted. To replace all occurrence of
agarwal, aggarwal and agrawal with simply Agarwal, we have,
sed ‘s/[Aa]gg*[ar][ar]wal/Agarwal/g’ emp.lst
We can also use ^ and $ with the same meaning. To add 2 prefix to all emp-ids,

38
sed ‘s/^/2/’ emp.lst | head –n 1
22233 | a.k.shukla | gm | sales | 12/12/52 | 6000
To add .00 suffix to all salary,
sed ‘s/$/.00/’ emp.lst | head –n 1
2233 | a.k.shukla | gm | sales | 12/12/52 | 6000.00
Performing multiple substitutions
sed ‘s///g
s///g
s///g’ form.html
An instruction processes the output of the previous instruction, as sed is a stream editor and
works on data stream
sed ‘s///g
s///g’ form.html
When a ‘g’ is used at the end of a substitution instruction, the change is performed globally
along the line. Without it, only the left most occurrence is replaced. When there are a group of
instructions to execute, you should place these instructions in a file instead and use sed with the
–f option.
Compressing multiple spaces
sed ‘s/*|/|/g’ emp.lst | tee empn.lst | head –n 3
2233|a.k.shukla|g.m|sales|12/12/52|6000
9876|jai sharma|director|production|12/03/50|7000
5678|sumit chakrobarty|dgm|mrking|19/04/43|6000
The remembered patterns
Consider the below three lines which does the same job
sed ‘s/director/member/’ emp.lst
sed ‘/director/s//member/’ emp.lst
sed ‘/director/s/director/member/’ emp.lst
The // representing an empty regular expression is interpreted to mean that the search and
substituted patterns are the same
sed ‘s/|//g’ emp.lst removes every | from file
Basic Regular Expressions (BRE) – Revisited

39
Three more additional types of expressions are:
The repeated patterns - &
The interval regular expression (IRE) – { }
The tagged regular expression (TRE) – ( )
The repeated patterns - &
To make the entire source pattern appear at the destination also
sed ‘s/director/executive director/’ emp.lst
sed ‘s/director/executive &/’ emp.lst
sed ‘/director/s//executive &/’ emp.lst
Replaces director with executive director where & is a repeated pattern
The interval RE - { }
sed and grep uses IRE that uses an integer to specify the number of characters preceding a
pattern. The IRE uses an escaped pair of curly braces and takes three forms:
ch\{m\} – the ch can occur m times
ch\{m,n\} – ch can occur between m and n times
ch\{m,\} – ch can occur at least m times
The value of m and n can't exceed 255. Let teledir.txt maintains landline and mobile phone
numbers. To select only mobile numbers, use IRE to indicate that a numerical can occur 10
times.
grep ‘[0-9]\{10\}’ teledir.txt
Line length between 101 and 150
grep ‘^.\{101,150\}$’ foo
Line length at least 101
sed –n ‘/.{101,\}/p’ foo
The Tagged Regular Expression (TRE)
You have to identify the segments of a line that you wish to extract and enclose each segment
with a matched pair of escaped parenthesis. If we need to extract a number, $[0-9]*$. If we
need to extract non alphabetic characters,
$[â-zA-Z]*$
Every grouped pattern automatically acquires the numeric label n, where n signifies the nth
group from the left.

40
sed ‘s/ \ (a-z]*\) *\ ([a-z]*\) / \2, \1/’ teledir.txt
To get surname first followed by a , and then the name and rest of the line. sed does not use
compulsorily a / to delimit patterns for substitution. We can use only any character provided it
doesn’t occur in the entire command line. Choosing a different delimiter has allowed us to get
away without escaping the / which actually occurs in the pattern.
Basic File Attributes:

The UNIX file system allows the user to access other files not belonging to them and without
infringing on security. A file has a number of attributes (properties) that are stored in the inode.
In this chapter, we discuss,
• ls –l to display file attributes (properties)

• Listing of a specific directory
• Ownership and group ownership
• Different file permissions
Listing File Attributes
ls command is used to obtain a list of all filenames in the current directory. The output in
UNIX lingo is often referred to as the listing. Sometimes we combine this option with other
options for displaying other attributes, or ordering the list in a different sequence. ls look up the
file’s inode to fetch its attributes. It lists seven attributes of all files in the current directory and
they are:
• File type and Permissions

• Links
• Ownership
• Group ownership
• File size
• Last Modification date and time
• File name
•
The file type and its permissions are associated with each file. Links indicate the number of
file names maintained by the system. This does not mean that there are so many copies of the
file. File is created by the owner. Every user is attached to a group owner. File size in bytes is
displayed. Last modification time is the next field. If you change only the permissions or
ownership of the file, the modification time remains unchanged. In the last field, it displays the
file name.

41
For example,
$ ls –l
total 72
-rw-r--r-- 1 kumar metal 19514 may 10 13:45 chap01
-rw-r--r-- 1 kumar metal 4174 may 10 15:01 chap02
-rw-rw-rw- 1 kumar metal 84 feb 12 12:30 dept.lst
-rw-r--r-- 1 kumar metal 9156 mar 12 1999 genie.sh
drwxr-xr-x 2 kumar metal 512 may 9 10:31 helpdir
drwxr-xr-x 2 kumar metal 512 may 9 09:57 progs
Listing Directory Attributes
ls -d will not list all subdirectories in the current directory
For example,
ls –ld helpdir progs
drwxr-xr-x 2 kumar metal 512 may 9 10:31 helpdir
drwxr-xr-x 2 kumar metal 512 may 9 09:57 progs
Directories are easily identified in the listing by the first character of the first column,
which here shows a d. The significance of the attributes of a directory differs a good deal from
an ordinary file. To see the attributes of a directory rather than the files contained in it, use ls –ld
with the directory name. Note that simply using ls –d will not list all subdirectories in the current
directory. Strange though it may seem, ls has no option to list only directories.
File Ownership
When you create a file, you become its owner. Every owner is attached to a group
owner. Several users may belong to a single group, but the privileges of the group are set by
the owner of the file and not by the group members. When the system administrator creates a
user account, he has to assign these parameters to the user:
The user-id (UID) – both its name and numeric representation
The group-id (GID) – both its name and numeric representation
File Permissions
UNIX follows a three-tiered file protection system that determines a file’s access rights. It
is displayed in the following format:
Filetype owner (rwx) groupowner (rwx) others (rwx)
For Example:

42
-rwxr-xr-- 1 kumar metal 20500 may 10 19:21 chap02
rwx r-x r--
owner/user group owner others
The first group has all three permissions. The file is readable, writable and executable by
the owner of the file. The second group has a hyphen in the middle slot, which indicates the
absence of write permission by the group owner of the file. The third group has the write and
execute bits absent. This set of permissions is applicable to others.
You can set different permissions for the three categories of users – owner, group and
others. It’s important that you understand them because a little learning here can be a
dangerous thing. Faulty file permission is a sure recipe for disaster
Changing File Permissions
A file or a directory is created with a default set of permissions, which can be determined
by umask. Let us assume that the file permission for the created file is -rw-r--r--. Using chmod
command, we can change the file permissions and allow the owner to execute his file. The
command can be used in two ways:
In a relative manner by specifying the changes to the current permissions
In an absolute manner by specifying the final permissions
Relative Permissions
chmod only changes the permissions specified in the command line and leaves the other
permissions unchanged. Its syntax is:
chmod category operation permission filename(s)
chmod takes an expression as its argument which contains:
user category (user, group, others)
operation to be performed (assign or remove a permission)
type of permission (read, write, execute)
Category operation permission
u - user + assign r - read
g - group - remove w - write
o - others = absolute x - execute
a - all (ugo)
Let us discuss some examples:

43
Initially,
-rw-r--r-- 1 kumar metal 1906 sep 23:38 xstart
chmod u+x xstart
-rwxr--r-- 1 kumar metal 1906 sep 23:38 xstart
The command assigns (+) execute (x) permission to the user (u), other permissions remain
unchanged.
chmod ugo+x xstart or
chmod a+x xstart or
chmod +x xstart
-rwxr-xr-x 1 kumar metal 1906 sep 23:38 xstart
chmod accepts multiple file names in command line
chmod u+x note note1 note3
Let initially,
-rwxr-xr-x 1 kumar metal 1906 sep 23:38 xstart
chmod go-r xstart
Then, it becomes
-rwx--x--x 1 kumar metal 1906 sep 23:38 xstart
Absolute Permissions
Here, we need not to know the current file permissions. We can set all nine permissions
explicitly. A string of three octal digits is used as an expression. The permission can be
represented by one octal digit for each category. For each category, we add octal digits. If we
represent the permissions of each category by one octal digit, this is how the permission can be
represented:
• Read permission – 4 (octal 100)

• Write permission – 2 (octal 010)
• Execute permission – 1 (octal 001)
Octal Permissions Significance
0 --- no permissions
1 --x execute only
2 -w- write only
3 -wx write and execute

44
4 r-- read only
5 r-x read and execute
6 rw- read and write
7 rwx read, write and execute
We have three categories and three permissions for each category, so three octal digits
can describe a file’s permissions completely. The most significant digit represents user and the
least one represents others. chmod can use this three-digit string as the expression.
Using relative permission, we have,
chmod a+rw xstart
Using absolute permission, we have,
chmod 666 xstart
chmod 644 xstart
chmod 761 xstart
will assign all permissions to the owner, read and write permissions for the group and only
execute permission to the others.
777 signify all permissions for all categories, but still we can prevent a file from being
deleted. 000 signifies absence of all permissions for all categories, but still we can delete a file.
It is the directory permissions that determine whether a file can be deleted or not. Only owner
can change the file permissions. User can not change other user’s file’s permissions. But the
system administrator can do anything.
The Security Implications
Let the default permission for the file xstart is
-rw-r--r--
chmod u-rw, go-r xstart or
chmod 000 xstart
----------
This is simply useless but still the user can delete this file
On the other hand,
chmod a+rwx xstart
chmod 777 xstart

45
-rwxrwxrwx
The UNIX system by default, never allows this situation as you can never have a secure
system. Hence, directory permissions also play a very vital role here
We can use chmod Recursively.
chmod -R a+x shell_scripts
This makes all the files and subdirectories found in the shell_scripts directory, executable by all
users. When you know the shell meta characters well, you will appreciate that the * doesn’t
match filenames beginning with a dot. The dot is generally a safer but note that both commands
change the permissions of directories also.
Directory Permissions
It is possible that a file cannot be accessed even though it has read permission, and can
be removed even when it is write protected. The default permissions of a directory are,
rwxr-xr-x (755)
A directory must never be writable by group and others
Example:
mkdir c_progs
ls –ld c_progs
drwxr-xr-x 2 kumar metal 512 may 9 09:57 c_progs
If a directory has write permission for group and others also, be assured that every user
can remove every file in the directory. As a rule, you must not make directories universally
writable unless you have definite reasons to do so.
Changing File Ownership
Usually, on BSD and AT&T systems, there are two commands meant to change the
ownership of a file or directory. Let kumar be the owner and metal be the group owner. If
sharma copies a file of kumar, then sharma will become its owner and he can manipulate the
attributes
chown changing file owner and chgrp changing group owner
On BSD, only system administrator can use chown
On other systems, only the owner can change both
chown
Changing ownership requires superuser permission, so use su command
ls -l note
-rwxr----x 1 kumar metal 347 may 10 20:30 note

46
chown sharma note; ls -l note
-rwxr----x 1 sharma metal 347 may 10 20:30 note
Once ownership of the file has been given away to sharma, the user file permissions that
previously applied to Kumar now apply to sharma. Thus, Kumar can no longer edit note since
there is no write privilege for group and others. He can not get back the ownership either. But he
can copy the file to his own directory, in which case he becomes the owner of the copy.
SOLUTIONS FOR PROGRAMS:
WEEK 1
SESSION 1:
A) Aim: Log into the system

When we return on the system one screen will appear. In this we have to type 192.168.1.61
then we enter into editor. It asks our details such as
Login : citm
password:
Then we get log into the commands.
B) Aim: Use vi editor to create a file called myfile.txt which contains

some text.To create a file in vi editor we must follow the syntax given below
Syntax:-vi file name
Here we have to open a file named as my file text when we open the file by using the
above syntax one window will be opened in that we type text as our wish.
Example: vi myfile.text.
C) Aim: Correct typing errors during creation.
In creating a file through vi editor an error an error will occur we
modify the file by opening the file again. An error will occur when

47
we don’t give space between filename and command name
Example: vi530
Other type of error is when any wrong typing in file.
D) Aim: Save the File.
To save the file created in vi editor we press esc:WQ1.It means
that saves the file and Quits editing mode .then we come out from
the vi editor.
E) Aim: Logout the system.

In our current directory press exit to log out from the commands .In desktop turn of f
computer option will displayed Ok that option and then ok shutdown option then windows
will shutdown and we log out from the system.
SESSION 2:
When we turn on the system one screen will appear. In this we have to type 192.168.1.61
then we enter into editor. It asks
Login : citm
password:
Then we log into the commands.
B) Aim: Open the file created in session -1
In the above session we create a file in vi editor To open the
file created in Session 1 we have to type as follows
Syntax: vi filename
It displays the file as follows
C) Aim: Add Some text:
To add some text to the file which is already created first we have to open that file then
add text.

48
vi filename. Text
D) Aim: Change some text
To change the some text in myfile.text move the cursor where we want to change
the text After that replace the text under cursor with other text first open the file as
follows.
vi myfile.text
E) Aim: Delete some text :
To delete text in my file text we first move the cursor to end of that line and
then press delete then the line is erased to do this first we open the file as
vi myfile.text
F) Aim: Save the changes:
To save the changes made in file myfile.text we press
esc:WQ
It means that saves the file and quits editing mode then we log out from the vi Mode.
G) Aim: Logout of the System:
In our current directory press exit to logout from the commands in desktop turn off
computer option will appear ok that option and then ok shutdown option then windows will
shutdown we logout from the system.

49
WEEK 2

When we turn on the system one screen will appear in this we have to type 192.168.1.61
then we log into the commends it asks
Login : citm530
password:
then we log into the commands.
B) Aim: Use the cat command to create a file containing the following
data .Call it mytable use
tabs to separate the fields.
1425 Ravi 15.65
4320 Ramu 26.27
6830 Sita 36.15
1450 Raju 21.86
Cat command is used to create the files Here file name is mytable
Example: cat>mytable
Type the file as given above
$ cat >mytable
1425 Ravi 15.65
4320 Ramu 26.27
6830 Sita 36.15

50
1450 Raju 21.86
To save the file press Ctrl + D
C) Aim: Use the Cat command to display the file,mytable.
To display the text in my table we use the syntax as follows
Syntax: cat mytable
It display the file as follows
$ cat mytable
1425 Ravi 15.65
4320 Ramu 26.27
6830 Sita 36.15
1450 Raju 21.86
D) Aim: Use the vi command to correct any errors in the file ,mytable
By using vi editor we have to correct errors occurred in creating file .
Open the file in vi editor as
Vi mytable
Use vi command to correct errors
E) Aim: Use the sort command to sort the file mytable according to the first field. Call
the
sorted my table (same name)
short command is used to print the contents of the file in alphabetical order
syntax: sort filename
example: sort mytable.
$ sort -k 1 mytable > sortfile;cp sortfile mytable
cp: overwrite `mytable'? Y
$ cat mytable

51
1425 Ravi 15.65
1450 Raju 21.86
4320 Ramu 26.27
6830 Sita 36.15
F) Aim: print the file mytable
To print the file mytable we use cat command as follows
Syntax: cat filename
Example: cat myfile
$ lp mytable
1425 Ravi 15.65
1450 Raju 21.86
4320 Ramu 26.27
6830 Sita 36.15
G) Aim: use the cut and paste commands to swap fields 2 and 3 of mytable.Call it my
table(same name)
By using cut command we cut fields as well as characters from the file cut
command cuts mentioned characters and it is stored in another file as follows
cut –c characters my table >my
the fields are removed by using the syntax as follows the out put is stored in
table
cut –f fields mytable >table
example: cut –f 1,3 mytable>my
It means it cuts 1,3 fields the middle part is stored in my file
Cut –c 5,9 mytable>table
It means it cuts the characters from 5 to 9 the remaining 1,3 fields are stored
in table .To paste these two files we use paste command
Syntax: paste file1,file2

52
$ cat mytable
1425 Ravi 15.65
4320 Ramu 26.27
6830 Sita 36.15
1450 Raju 21.86
$ cut -f 1 mytable >field1;cut -f 2 mytable >field2;cut -f 3 mytable>field3
$ paste field1 field3 field2 > mytable
$ cat mytable
1425 15.65 Ravi
4320 26.27 Ramu
6830 36.15 Sita
1450 21.86 Raju
H) Aim:Print the new file,mytable
The file swapped this file can be displayed as follows
$ lp mytable
1425 15.65 Ravi
4320 26.27 Ramu
6830 36.15 Sita
1450 21.86 Raju
I) Aim: logout of the system.
In our current directory type exit to log out from the commands in desktop turnoff
computer option will appear ok that option and then ok shutdown option then windows will
shutdown we logout from the system.
Logout
[ctrl-d] or
Exit

53
WEEK 3
1. A) Aim: login to the system
When we turn on the system one screen will appear in this we have to type
192.168.1.61 then we enter into one window it asks
Login : citm
password:
Then we login to the commands
B) Aim: use the appropriate command to determine your login shell
If we want to known in which shell you login shell the syntax is as follows
Syntax: $ echo $SHELL
$ echo $SHELL
/bin/bash
Unix contains a system variable shell that identifiers the path to your login shell
Aim: use the /etc/passwd file to verify the result of step b.
By using cat command we can print who login in to the system
$ cd /
$ ls
bin dev lib media net root srv usr
boot etc home .............. linux tmp
$ cd etc
$ ls

54
a2ps,a2ps.cfg, initlog.conf,......... , passwd, passwd-
................................
$ cat passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
....................................................
...................................................
citm:x:501:501:Citmrushi:/home/citm:/bin/bash
D) Aim: use the who command and redirect the result to a file called myfile1.Use
the more command to see the contents of myfile1.
When we redirect the standard output the command output is copy to a file
rather than displayed on the monitor the redirection operator for output is >
Command >file name
Who>myfile1
The result of who command is stored in myfile1
By using more command we print the myfile1 contents as follows
More myfile1
$ who >myfile1
$ more myfile1
citm tty7 2009-08-23 09:08 (:0)
citm pts/1 2009-08-23 09:09 (:0.0)
.......... ....... .......................................
.......... ....... .......................................
E) Aim: Use the date and who commands in sequence (in one line) such that the output of
date will display on the screen and the output of who will be redirected to a file called
myfile2. use the more command to check the contents of myfile2.
In sequence command sequence of commands can be entered on oneline

55
$ date;who > myfile2
Sat Aug 23 09:38:05 IST 2009
$ more myfile2
citm tty7 2009-08-23 09:08 (:0)
citm pts/1 2009-08-23 09:09 (:0.0)
......... . ..............................................
2. A) Aim: Write a sed command that deletes the first character
in each line in a file.
#Delete the first character in each line in a file.
$ cat mytable
1425 Ravi 15.65
4320 Ramu 26.27
6830 Sita 36.15
1450 Raju 21.86
7820 Anil 23.34
9000 Citm 35.56
$ sed 's/^./ / ' mytable
425 Ravi 15.65
320 Ramu 26.27
830 Sita 36.15
450 Raju 21.86
820 Anil 23.34
000 Citm 35.56
B) Aim: Write a sed command that deletes the character before the
last character in each line in a file.

56
# Delete the last character in each line in a file.
$ sed 's/.$/ /' mytable
1425 Ravi 15.6
4320 Ramu 26.2
6830 Sita 36.1
1450 Raju 21.8
7820 Anil 23.3
9000 Citm 35.5
C) Aim: Write a sed command that swaps the first and second words in a
file.
# Swaps the first and second words in each line in a file.
$ sed ‘s/ $[^ ]*$ *$[^ ]*$/ \2 \1 /g’ mytable
Ravi 1425 15.65
Ramu 4320 26.27
Sita 6830 36.15
Raju 1450 21.86
Anil 7820 23.34
Citm 9000 35.56

57
WEEK 4
Aim: pipe your /etc/passwd file to awk , and print out the home directory of
A)
each user.
First we go to vi editor by using
$ vi home.awk
if(match ($0, /^.*home/) > 0)
split( $0, user)
split(user[1],homedir, ":")
print homedir[1]
To compile the program use
Sh filename.sh
To return the program
awk command :
$ cat /etc/passwd | awk -f home.awk
Administrator
Guest
sys1
IT
IT123
it
IT501

58
IT502
B) Aim: Develop an interactive grep script that asks for a word and a
file name and then tells how many lines contain that word.
First we create a file with filename grep.sh
$ vi grep.sh
echo "Enter the pattern to be searched: "
read pattern
echo "Enter the file to be used: "
read filename
echo "Searching for $pattern from file $filename"
echo "The selected records are: "
grep "$pattern" $filename
echo "The no.of lines contains the word( $pattern ) :"
grep -c "$pattern" $filename
Output :
$ sh grep.sh
Enter the pattern to be searched:
computer
Enter the file to be used:
sales.dat
Searching for computer from file sales.dat
The selected records are:
10 computer 2345
10 computer 7685
The no.of lines contains the words ( computer ) :

59
WEEK 5
A) Aim: write a shell script that takes a command –line argument and
reports on whether it is
directory, a file, or something else.
$ vi filetype.sh
echo "Enter the file name: "
read file
if [ -f $file ]
then
echo $file "---> It is a ORDINARY FILE."
elif [ -d $file ]
then
echo $file "---> It is a DIRCTORY."
else
echo $file "---> It is something else."
fi
outputs:
$ sh filetype.sh
Enter the file name:
sales.dat
sales.dat ---> It is a ORDINARY FILE.
$ sh filetype.sh
Enter the file name:
IT

60
IT---> It is a DIRCTORY.
B) Aim: Write a shell script that accepts one or more file name as
arguments and converts all of them to uppercase, provided they exist in the
current directory.
$vi upper.sh
for file in *
do
if [ -f $file ]
then
echo $file | tr '[a-z]' '[A-Z]'
fi
done
Reading input :
$ ls
afile
afile1.tar
afile.tar
aped.sed
errfile
exch.dat
exsed.sed
f1
for.sh
grep.sh
Output:
$ sh upper.sh

61
AFILE
AFILE.TAR
APED.SED
ERRFILE
EXCH.DAT
EXSED.SED
F1
FOR.SH
GREP.SH
C) Aim: Write a shell script that determines the period for which a
specified user is working On the system.
$vi logtime.sh
echo "Enter the USER NAME : "
read user
last $user
Output :
$ sh logtime.sh
Enter the USER NAME :
IT123
IT123 tty7 :0 Fri Sep 26 13:27 still logged in
IT123 pts/1 :0.0 Thu Sep 25 15:08 - 15:45 (00:37)
IT123 tty7 :0 Thu Sep 25 14:53 - 16:32 (01:39)
IT123 tty7 :0 Thu Sep 25 14:13 - 14:25 (00:11)
IT123 tty7 :0 Tue Sep 23 13:54 - 15:30 (01:36)
IT123 pts/2 :20.0 Mon Sep 22 17:02 - 17:23 (00:21)
WEEK 6

62
A) Aim: write a shell script that accepts a file name starting and ending line
numbers as arguments and displays all the lines between the given line
numbers.
$ vi range.sh
echo " Enter the file name :"
read file
if [ -f $file ]
then
echo "Enter the Starting line number:"
read snum
echo "Enter the Ending line number:"
read enum
if [ $snum -lt $enum ]
then
echo "The selected lines from $snum line to $enum line in $file :"
sed -n ' ' $snum','$enum' 'p' ' $file
else
echo "Enter proper starting & ending line numbers."
fi
else
echo "The file ' $file ' doesn't exists. "
fi
Output:
$sh range.sh
Enter the file name :

63
sales.dat
Enter the Starting line number:
Enter the Ending line number:
The selected lines from 2 line to 4 line in sales.dat :
11 tvsets 8765
10 computer 7685
12 mouse 6785
B) Aim: write a shell script that deletes all lines containing a specified word in
one or more files supplied as arguments to it.
$ vi detline.sh
echo "Enter the word to search for all lines :"
read word
echo "the file name are $* ."
for i in $*
do
echo "The name of the file :" $i
grep -v $word $i
done
Output :
$ sh detline.sh sales.dat sales1.dat sales2.dat
Enter the word to search for all lines :
computer
the file name are sales.dat sales1.dat sales2.dat

64
The name of the file : sales.dat
11 tvsets 8765
12 mouse 6785
13 keyboard 2341
The name of the file : sales1.dat
11 tvsets 8765
12 mouse 6785
13 keyboard 2341
The name of the file : sales2.dat
11 tvsets 8765
12 mouse 6785
13 keyboard 2341
WEEK 7

65
A) Aim: write a shell script that computes the gross salary of a employee according
to the following rules:
i ) If basic salary is <1500 then HRA=10% of the basic and DA=90% of the basic
ii) If the basic salary is>=1500 then HRA=500/- and DA=98% of the basic
The basic salary is entered interactively through the key board.
$ vi gsalary.sh
echo "enter the basic salary:"
read bsal
if [ $bsal -lt 1500 ]
then
gsal=$((bsal+((bsal/100)*10)+(bsal/100)*90))
echo "The gross salary : $gsal"
fi
if [ $bsal -ge 1500 ]
then
gsal=$(((bsal+500)+(bsal/100)*98))
echo "the gross salary : $gsal"
fi
Output :
$ sh gsalary.sh
enter the basic salary:
1200
The gross salary : 2400
$ sh gsalary.sh
enter the basic salary:
2400

66
the gross salary : 5252
B) Aim: Write a shell script that accepts two integers as its arguments
and computers the value of first number raised to the power of the second number.
$ vi pow.sh
echo "Enter the integer value :"
read int1
echo "Enter the power of that integer:"
read int2
pv=$int1
i=1
while [ $i -lt $int2 ]
do
pv=èxpr $pv \* $int1`
i=èxpr $i + 1 `
done
echo "The value of first number to the power of the second number :"
echo "$pv"
output:
$ sh pow.sh
Enter the integer value :
Enter the power of that integer:
The value of first number to the power of the second number : 32
WEEK 8

67
A) Aim: Write an interactive file –handling shell program. Let it offer the user
the choice of copying removing, renaming, or linking files. Once the user has
made a choice, have the same program ask the user for the necessary
information, such as the
file name ,new name and so on.
$ cat 8a.sh
echo "*******MENU*********"
echo "
1. List of files.
2. Copying files.
3. Removing files.
4. Renaming files.
5. Linking files."
Echo "enter your choice "
read ch
case "$ch" in
1 ) echo "The list of file names."
ls –l
2 ) echo "Enter the old filename."
read ofile
echo "Enter the new file name."
read nfile
cp $ofile $nfile && echo "Copied sucessfully." || echo
"Copied is not possible." ;;
3 ) echo "Enter the file name to remove."
read rfile
rm -f $rfile && echo "Successfully removed." ;;

68
4 ) echo "Enter the old file name."
read ofile
echo "Enter the new file name."
read nfile
mv $ofile $nfile && echo "The file $ofile name renamed
to $nfile." || echo "You cann't Rename the file. “;;
5 ) echo "Enter the original filename."
read ofile
echo "Enter the new filename to link a file."
read lfile
ln $ofile $lfile && echo "Creat the linking file
Sccessfully." || echo "You cann't Linking the file.";; * )
echo "Invalid option."
Echo " Enter correct choice."
esac
Output :
$ sh 8a.sh
*******MENU*********
1. List of files.
2. Copying files.
3. Removing files.
4. Renaming files.
5. Linking files.
enter your choice

69
Enter the old filename.
f1
Enter the new file name.
f0
Copied sucessfully.
B) Aim: Write shell script that takes a login name as command-line argument and reports
when that person logs in.
$vi login.sh
echo "Enter the USER NAME : "
read user
last $user
Output :
$ sh logtime.sh
Enter the USER NAME :
IT123
IT123 pts/1 :0.0 Thu Sep 25 15:08 - 15:45 (00:37)
IT123 tty7 :0 Thu Sep 25 14:53 - 16:32 (01:39)
IT123 tty7 :0 Tue Sep 23 13:54 - 15:30 (01:36)
IT123 pts/2 :20.0 Mon Sep 22 17:02 - 17:23 (00:21)
(or)
echo “ The Login repots of the user : $* .”
last $*
output :
$sh login.sh IT123

70
IT123 pts/1 :0.0 Thu Sep 25 15:08 - 15:45 (00:37)
IT123 tty7 :0 Thu Sep 25 14:53 - 16:32 (01:39)
IT123 tty7 :0 Thu Sep 25 14:13 - 14:25 (00:11)
C) Aim: Write a shell script which receives two file names as arguments. It should check
whether the two file contents are same or not. If they are same then second file should
be deleted.
$vi cheek.sh
echo "enter the first file name"
read file1
echo "enter the second file name"
read file2
cmp $file1 $file2 && rm $file2
if [ -e $file1 ]
then
if [ ! –e $file2 ]
then
echo "The two files contents are same."
echo "The second file is deleted successfully."
else
echo "The two files contents are not same."
echo "You cann't remove the file '$file2' ."
fi
else
echo "You should enter the existing file names."
fi

71
Output:
$ sh cheek.sh
enter the first file name
file1.dat
enter the second file name
file3.dat
The two files contents are same.
The second file is deleted successfully.
$ sh 8c.sh
file1.dat
file2.dat
file1.dat file2.dat differ: byte 1, line 1
The two files contents are not same.
You cann't remove the file 'file2.dat' .
$ sh 8c.sh
file5.dat
file3.dat
cmp: file3.dat: No such file or directory
You should enter the existing file names.
WEEK 9
A) Aim: write a shell script that displays a list of all the files in the current directory
to which the use has read ,write and execute permissions.

72
$vi perm.sh
echo "The list of File Names in the curent directory."
echo "Which have Read,Write and Execute permisions. "
for file in *
do
if [ -f $file ]
then
if [ -r $file -a -w $file -a -x $file ]
then
ls -l $file
fi
fi
done
Output :
$chmod 777 file1
$chmod 777 file2
$chmod 777 file3
$chmod 777 file4
$ sh perm.sh
The list of File Names in the curent directory.
Which have Read,Write and Execute permisions.
-rwxrwxr-x 1 citm citm 6722 2009-08-21 10:00 a.out
-rwxrwxrwx 1 citm citm 4 2009-08-18 16:48 file1
-rwxrwxr-x 1 citm citm 4 2009-08-19 14:33 file3

73
B) Aim: Develop an interactive script that ask for a word and a file name and then tells
how many times that word occurred in the file.
$ vi wcount.sh
echo " Enter the word to be searched"
read word
echo "Enter the filename to be used"
read flname
echo "the no. of times the word occured in the file."
grep -c $word $flname
Output:
$ sh wcount.sh
Enter the word to be searched
computers
Enter the filename to be used
sales.dat
the no. of times the word occured in the file.
C) Aim: Write a shell script to perform the following string operations:
I) To extract a sub-string from a given string.

II) To find the length of a given string.
$ vi strlen.sh
echo "To find the length of the given string."
echo "Enter the string."

74
read string
strlen=${#string}
echo "The string length is : $strlen"
Output :
$ sh strlen.sh
To find the length of the given string.
Enter the string.
computer science and engineering.
The string length is : 33
WEEK 10
A) Aim: Write a C program that takes one or more file or directory names

75
as command line input and reports the following information on the file:
I)file type
#include<stdio.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
int main(int argc,char *argv[])
struct stat b;
int i;
for(i=1;i<argc;i++)
if(lstat(argv[i],&b)==-1)
printf("%s",argv[i]);
fflush(stdout);
perror("lstat error");
continue;
else if(S_ISREG(b.st_mode))
printf("regular file\n");
else if(S_ISDIR(b.st_mode))
printf("directory file \n");
else if(S_ISCHR(b.st_mode))
printf("character special file\n");

76
else if(S_ISBLK(b.st_mode))
printf("block special file \n");
else if(S_ISFIFO(b.st_mode))
printf("pipefile \n");
else if(S_ISLNK(b.st_mode))
printf("symbloic link file");
else if(S_ISSOCK(b.st_mode))
printf("socket file \n");
else
printf("unknown file");
OUTPUT :
$./a.out lab1.sh
regular file
B) Aim: Write a C program that takes one or more file or directory names as
command line input and reports the following information on the file:
(i) file type

77
(ii) number of links
(ii) read, write and execute permission
(iv) time of last access
#include<sys/stat.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
struct stat statbuf;
int i;
if(argc<2)
printf("usage:./a.out< filename(s)");
exit(1);
for(i=1;argc!=i;i++)
if(access(argv[i],F_OK)<0)
printf(" \n %s,File/dir not exists",argv[i]);
continue;
else

78
if(lstat(argv[i],&statbuf)<0)
printf("unable to read Status of file :%s",argv[i]);
continue;
printf("No of links :%d \t",statbuf.st_nlink);
return(0);
OUTPUT :
No of links :1
Last access time is 1207834720
Read permissions for the user
Write permissions for the user
Execute permissions for the user
WEEK 11
A) Aim: Write a C program that simulate the following UNIX commands:

79
a) mv
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
if(argc!=3)
printf("usage:a.out <old name> <new name>");
exit(1);
if(access(argv[1],F_OK)<0)
if("File not found");
exit(2);
if(rename(argv[1],argv[2])<0)
printf("Rename Error");
exit(3);
printf("%s renamed as %s",argv[1],argv[2]);
return 0;
OUTPUT :

80
$./a.out lab8c.c lab8b.c
lab8c.c renamed as lab8b.c
B) Aim: Write a C program that simulate the following UNIX commands:
b) cp (use system calls)
#include<stdio.h>
Int main(int argc,char *argv[])
FILE *fp1,*fp2;
int ch;
fp1=fopen(argv[1],”r”);
fp2=fopen(argv[2],”r”);
while((ch=fgtc(fp1))!=-1)
fputc(ch,fp2);
OUT PUT:
Cc filename c
La out ab abc
This is CITM College.
WEEK 12
A) Aim: Write a C program that simulates ls command (use system calls/directory API)

81
#include<stdio.h>
#include<conio.h>
#include<unistd.h>
#include<derent.h>
Int main()
DIR *dirp;
Struct dirent *dp;
Dirp=opendir(“”);
If(dirp==NULL)
Printf(“error”);
else
for(dp=readdir(dirp);dp!=NULL;dp=readdir(dirp))
printf(“%s\n”,dp->d=name);
Output:
cc filename c
la.output
a.out
ramesh
file1
file2

Lab Objective:: Coastal Institute of Technology and Management

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Lab Objective:: Coastal Institute of Technology and Management

Hochgeladen von

Copyright:

Verfügbare Formate

1

5. Write moderately complex Shell scripts.

6. Make a Shell script executable.

7. Create a ".profile" script to customize the user environment.

8. Use advanced features of File Transfer Protocol (FTP)

9. Compile source code into object and executable modules.

10. Execute programs written in c under UNIX environment

INTRODUCTION ABOUT LAB:

Coastal Institute of Technology and Management

Processor : Intel Pentium Dual Core CPU E2160 1.80GHz

Hard Disk : 160 GB

Mouse : Optical Mouse

Network Interface card: Present

 Each student has a separate login for database access

 Rational Rose Software is installed in some systems

Coastal Institute of Technology and Management

How to Run Shell Scripts:

Step 1: create the script using vi, ex or ed

echo Here is the date and time

Here is the date and time

Sat jun 03 13:40:15 PST 2006

Make your script executable using the chmod command.

Step 1: create the script using vi, ex or ed

echo Here is the date and time

Coastal Institute of Technology and Management

Step 2: Make the file executable

$ chmod u+x script_file

$ chmod u+x show

Step 3: To run the script, just type the filename

Here is the date and time

Sat jun 03 13:40:15 PST 2006

How to run C programs:

For example, the file hello.c contains the following lines:

Step 2: Submit the file to CC (the C Compiler) to compile the program

Step 3: To create execute file,

Step 3: To run the program, type. /hello

How to run C++ programs:

For example, the file hello.C contains the following lines:

Coastal Institute of Technology and Management

Step 3: To create execute file,

Step 3: To run the program, type. /hello

How to run java programs:

For example, the class test contains the following lines:

Public class test

Step 2: Submit the file to javac ( the JAVA Compiler )

Step 3: To run the program, type java test

Coastal Institute of Technology and Management

To add some text to a file, we invoke,

The Repeat Factor

To undo whenever you make a mistake, press

To clear the screen in command mode, press

Don’t use (caps lock) - vi commands are case-sensitive

Avoid using the PC navigation keys

Coastal Institute of Technology and Management

Input Mode – Entering and Replacing Text

It is possible to display the mode in which is user is in by typing,

• r<letter> replacing a single character

Some of the input mode commands are:

I inserts at beginning of line

A appends text at end of line

o opens line below

O opens line above