14. ASSIGNMENT TOPICS WITH...

14. ASSIGNMENT TOPICS WITH MATERIALS UNIT-I

1. LINUX UTILITIES

The following commands we use in linux are: Ls: Displays list files in current directory

Eg: ls al Chmod: Change the file access permissions to give read/write/execute permissions

to a file or files Eg: chmod +x myscript.sh Cat: Shows the contents of a file

Eg: cat hello.txt Chown: Change the file owner / group owner.

Eg: chown bahmni:bahmni -R /var/www/ Grep: Finds matching data in text inputs using regular expressions.

Eg: cat hello.txt | grep "bahmni" Pwd: Shows the current directory path (pwd = present working directory).

Cd-Change into the specified directory.

Eg: cd /home Tail: Display the last few contents of a text file. Useful for seeing log files.

Eg: tail -f /var/log/openmrs/openmrs.log Cp: Copies a file from one location to another.

Eg: cp abc.txt /home Mv : Moves a file to another location. Also used for renaming a file.

Eg: mb abc1.txt abc2.txt Rm:Delete a file or a directory

Eg: rm /tmp/hello

Mkdir: Create a new directory. Eg: mkdir music

Disk commands:

Df: Print disk space usage (short for 'disk free') Du: Print disk usage report for current directory. Tar: For creating or extracting tar files

-xvf <filename.tar> extract tar file -cvf <filename.tar> compress files and folders -tvf archive.tar List all files in archive.tar verbosely. Kill: Terminate a process / Raise a Signal.

Eg: kill -9 <pid>.

2. SED

sed is a stream editor. A stream editor is used to perform basic text transformations on an input stream (a file or input from a pipeline). While in some ways similar to an editor which permits scripted edits (such as ed), sed works by making only one pass over the input(which particularly distinguishes it from other types of editors.

Normally sed is invoked like this: sed SCRIPT INPUTFILE... For example, to replace all occurrenc sed 's/hello/world/' input.txt > output.txt

If you do not specify INPUTFILE, or if INPUTFILE is -, sed filters the contents of the standard input. The following commands are equivalent:

sed 's/hello/world/' input.txt > output.txt sed 's/hello/world/' < input.txt > output.txt cat input.txt | sed 's/hello/world/' - > output.txt

sed writes output to standard output. Use -i to edit files in-place instead of printing to standard output. See also the W and s///w commands for writing output to other files. The following command modifies file.txt and does not produce any output:

sed -i 's/hello/world/' file.txt

By default sed prints all processed input (except input that has been modified/deleted by commands such as d). Use -n to suppress output, and the p command to print specific lines. The following command prints only line 45 of the input file:

sed -n '45p' file.txt

sed treats multiple input files as one long stream. The following example prints the first line of the first file (one.txt) and the last line of the last file (three.txt). Use -s to reverse this behavior.

sed -n '1p ; $p' one.txt two.txt three.txt

Without -e or -f options, sed uses the first non-option parameter as the script, and the following non-option parameters as input files. If -e or -f options are used to specify a script, all non-option parameters are taken as input files. Options -e and -f can be combined, and can appear multiple times (in which case the final effective script will be concatenation of all the individual scripts).

The following examples are equivalent:

sed 's/hello/world/' input.txt > output.txt sed -e 's/hello/world/' input.txt > output.txt sed --expression='s/hello/world/' input.txt > output.txt echo 's/hello/world/' > myscript.sed sed -f myscript.sed input.txt > output.txt sed --file=myscript.sed input.txt > output.txt

3. AWK

Awk is a scripting language used for manipulating data and generating reports.The awk command programming language requires no compiling, and allows the user to use variables, numeric functions, string functions, and logical operators. Awk is a utility that enables a programmer to write tiny but effective programs in the form of statements that define text patterns that are to be searched for in each line of a document and the action that is to be taken when a match is found within a line. Awk is mostly used for pattern scanning and processing. It searches one or more files to see if they contain lines that matches with the specified patterns and then performs the associated actions.

Awk is abbreviated from the names of the developers Aho, Weinberger, and Kernighan.

What can we do with awk ?

1. AWK Operations:

(a) Scans a file line by line (b) Splits each input line into fields (c) Compares input line/fields to pattern (d) Performs action(s) on matched lines

2. Useful For:

(a) Transform data files (b) Produce formatted reports

3. Programming Constructs:

(a) Format output lines (b) Arithmetic and string operations (c) Conditionals and loops

Syntax:

awk options 'selection _criteria {action }' input-file > output-file

Options:

-f program-file : Reads the AWK program source from the file program-file, instead of from the first command line argument. -F fs : Use fs for the input field separator

Sample Commands

Example: Consider the following text file as the input file for all cases below.

$cat > employee.txt ajay manager account 45000 sunil clerk account 25000 varun manager sales 50000 amit manager account 47000 tarun peon sales 15000 deepak clerk sales 23000 sunil peon sales 13000

satvik director purchase 80000

1. Default behavior of Awk :By default Awk prints every line of data from the specified file.

$ awk '{print}' employee.txt

Output:

ajay manager account 45000 sunil clerk account 25000 varun manager sales 50000 amit manager account 47000 tarun peon sales 15000 deepak clerk sales 23000 sunil peon sales 13000 satvik director purchase 80000

In the above example, no pattern is given. So the actions are applicable to all the lines. Action print without any argument prints the whole line by default, so it prints all the lines of the file without failure.

2. Print the lines which matches with the given pattern.

$ awk '/manager/ {print}' employee.txt

Output:

ajay manager account 45000 varun manager sales 50000 amit manager account 47000

In the above example, the awk command prints all the line which matches with the

3. Spliting a Line Into Fields :For each record i.e line, the awk command splits the record delimited by whitespace character by default and stores it in the $n variables. If the line has 4 words, it will be stored in $1, $2, $3 and $4 respectively. Also, $0 represents the whole line.

$ awk '{print $1,$4}' employee.txt

Output:

ajay 45000 sunil 25000 varun 50000 amit 47000 tarun 15000 deepak 23000 sunil 13000 satvik 80000

In the above example, $1 and $4 represents Name and Salary fields respectively.

Built In Variables In Awk

-in variables include the field variables $1, $2, $3, and so on ($0 is the entire line) that break a line of text into individual words or pieces called fields.

NR: NR command keeps a current count of the number of input records. Remember that records are usually lines. Awk command performs the pattern/action statements once for each record in a file.

NF: NF command keeps a count of the number of fields within the current input record.

FS: FS command contains the field separator character which is used to divide fields on the input line. The defabe reassigned to another character (typically in BEGIN) to change the field separator.

RS: RS command stores the current record separator character. Since, by default, an input line is the input record, the default record separator character is a newline.

OFS: OFS command stores the output field separator, which separates the fields when Awk prints them. The default is a blank space. Whenever print has several parameters separated with commas, it will print the value of OFS in between each parameter.

ORS: ORS command stores the output record separator, which separates the output lines when Awk prints them. The default is a newline character. Print automatically outputs the contents of ORS at the end of whatever it is given to print

4. SHELL RESPONSIBILITIES

The shell provides you with an interface to the UNIX system. It gathers input from you and executes programs based on that input. When a program finishes executing, it displays that program's output.

A shell is an environment in which we can run our commands, programs, and shell scripts. There are different flavors of shells, just as there are different flavors of operating systems. Each flavor of shell has its own set of recognized commands and functions.

Shell Prompt:

The prompt, $, which is called command prompt, is issued by the shell. While the prompt is displayed, you can type a command.

The shell reads your input after you press Enter. It determines the command you want executed by looking at the first word of your input. A word is an unbroken set of characters. Spaces and tabs separate words.

Following is a simple example of date command which displays current date and time:

$date ThuJun 25 08:30:19 MST 2009

You can customize your command prompt using environment variable PS1 explained in Environment tutorial.

Shell Types:

In UNIX there are two major types of shells:

1. The Bourne shell. If you are using a Bourne-type shell, the default prompt is the $ character. 2. The C shell. If you are using a C-type shell, the default prompt is the % character.

There are again various subcategories for Bourne Shell which are listed as follows:

Bourne shell ( sh) Korn shell ( ksh) Bourne Again shell ( bash) POSIX shell ( sh)

The different C-type shells follow:

C shell ( csh) TENEX/TOPS C shell ( tcsh)

The original UNIX shell was written in the mid-1970s by Stephen R. Bourne while he was at AT&T Bell Labs in New Jersey.

The Bourne shell was the first shell to appear on UNIX systems, thus it is referred to as "the shell".

The Bourne shell is usually installed as /bin/sh on most versions of UNIX. For this reason, it is the shell of choice for writing scripts to use on several different versions of UNIX.

5). SHELL SCRIPTING

Shell Scripts:

The basic concept of a shell script is a list of commands, which are listed in the order of execution. A good shell script will have comments, preceded by a pound sign, #, describing the steps.

There are conditional tests, such as value A is greater than value B, loops allowing us to go through massive amounts of data, files to read and store data, and variables to read and store data, and the script may include functions.

Shell scripts and functions are both interpreted. This means they are not compiled.

We are going to write a many scripts in the next several tutorials. This would be a simple text file in which we would put our all the commands and several other required constructs that tell the shell environment what to do and when to do it.

Example Script:

Assume we create a test.sh script. Note all the scripts would have .sh extension. Before you add anything else to your script, you need to alert the system that a shell script is being started. This is done using the shebang construct. For example:

#!/bin/sh

This tells the system that the commands that follow are to be executed by the Bourne shell. It's called a shebang because the # symbol is called a hash, and the !symbol is called a bang.

To create a script containing these commands, you put the shebang line first and then add the commands:

#!/bin/bash pwd ls

Shell Comments:

You can put your comments in your script as follows:

#!/bin/bash # Author : Zara Ali # Copyright (c) Tutorialspoint.com # Script follows here: pwd ls

Now you save the above content and make this script executable as follows:

$chmod +x test.sh

Now you have your shell script ready to be executed as follows:

$./test.sh

This would produce following result:

/home/amrood index.htm unix-basic_utilities.htm unix-directories.htm test.sh unix-communication.htm unix-environment.htm

Note: To execute your any program available in current directory you would execute using ./program_name

6. Extended Shell Scripts:

Shell scripts have several required constructs that tell the shell environment what to do and when to do it. Of course, most scripts are more complex than above one.

The shell is, after all, a real programming language, complete with variables, control structures, and so forth. No matter how complicated a script gets, however, it is still just a list of commands executed sequentially.

Following script use the read command which takes the input from the keyboard and assigns it as the value of the variable PERSON and finally prints it on STDOUT.

#!/bin/sh # Author : Zara Ali

# Copyright (c) Tutorialspoint.com # Script follows here: echo"What is your name?" read PERSON echo"Hello, $PERSON"

Here is sample run of the script:

$./test.sh Whatis your name? ZaraAli Hello,ZaraAli

UNIT-II

1. FILE AND ITS TYPES

A file system is a logical collection of files on a partition or disk. A partition is a container for information and can span an entire hard drive if desired. Your hard drive can have various partitions which usually contain only one file system, such as one file system housing the /file system or another containing the /home file system. One file system per partition allows for the logical maintenance and management of differing file systems. Everything in Unix is considered to be a file, including physical devices such as DVD-ROMs, USB devices, and floppy drives. Directory Structure Unix uses a hierarchical file system structure, much like an upside-down tree, with root (/) at the base of the file system and all other directories spreading from there. A Unix filesystem is a collection of files and directories that has the following propert It has a root directory (/) that contains other files and directories. Each file or directory is uniquely identified by its name, the directory in which it resides, and a unique identifier, typically called an inode. By convention, the root directory has an inode number of 2 and the lost+found directory has an inode number of 3. Inode numbers 0 and 1 are not used. File inode numbers can be seen by specifying the -i option to ls command. It is self-contained. There are no dependencies between one filesystem and another. The directories have specific purposes and generally hold the same types of information for

S.No. Directory & Description /

This is the root directory which should contain only the directories needed at the top level of the file structure /bin This is where the executable files are located. These files are available to all users /dev These are device drivers /etc Supervisor directory commands, configuration files, disk configuration files, valid user lists, groups, ethernet, hosts, where to send critical messages /lib Contains shared library files and sometimes other kernel-related files /boot Contains files for booting the system /home Contains the home directory for users and other accounts /mnt Used to mount other temporary file systems, such as cdrom and floppy for the CD-ROM drive and floppy diskette drive, respectively /proc Contains all processes marked as a file by process number or other information that is dynamic to the system /tmp Holds temporary files used between system boots /usr Used for miscellaneous purposes, and can be used by many users. Includes administrative commands, shared files, library files, and others /var Typically contains variable-length files such as log and print files and any other type of file that may contain a variable amount of data /sbin Contains binary (executable) files, usually for system administration. For example, fdisk and ifconfig utlities /kernel Contains kernel files

2. KERNEL SUPPORT FOR FILES:

UNIX supports the sharing of open files between different processes. Kernel has three data structures are used and the relationship among them determines the effect one process has on another with regard to file sharing.

1. Every process has an entry in the process table. Within each process table entry is a table of open file descriptors, which is taken as a vector, with one entry per descriptor. Associated with each file descriptor are a. The file descriptor flags. b. A pointer to a file table entry. 2. The kernel maintains a file table for all open files. Each file table entry contains a. The file status flags for the file(read, write, append, sync, nonblocking, etc.), b. The current file offset, c. A pointer to the v-node table entry for the file. 3. Each open file (or device) has a v-node structure. The v-node contains information about the type of file and pointers to functions that operate on the file. For most files the v- node also contains the i-node for the file. This information is read from disk when the file is opened, so that all the pertinent information about the file is readily available. The arrangement of these three tables for a single process that has two different files open one file is open on standard input (file descriptor 0) and the other is open standard output (file descriptor 1). Here, the first process has the file open descriptor 3 and the second process has file open Descriptor. 4. Each process that opens the file gets its own file table entry, but only a single v- node table entry. One reason each process gets its own file table entry is so that each process has its own current offset for the file. HEADER FILES: #include<fcntl.h> #include<types.h> DATA STRUCTURES: mode_t: struct_t: off_t:

Open: This system call is used to open the file Read: This system call used to read the content which is written in the file. Write: This is used to write the content in the file. Iseek:This system call is used to reposition read/write file offset. Close:This system call is used to close a file descriptor. Stat,fstat:This system call is used to get file status Chmod:This system call is used to change permissions of a file Chown: The chown command stands for "change owner" and is used to change the owner of a file. Link: This system call is used to creates a hard link from an existing directory entry to a new directory entry.

3. DIRECTORIES:

A directory is a file the solo job of which is to store the file names and the related information. All the files, whether ordinary, special, or directory, are contained in directories.

linux uses a hierarchical structure for organizing files and directories. This structure is often referred to as a directory tree. The tree has a single root node, the slash character (/), and all other directories are contained below it.

/cd :$cd ~username /pwd: $pwd /user0/home/amrood /ls: $ls /usr/local X11 bin gimp jikes sbin ace doc include lib share atalk etc info man ami /mkdir: $mkdir dirname /cd: $cd dirname $cd /usr/local/bin /mv: $mv olddir newdir

4. KERNEL SUPPORT FOR DIRECTORIES.

Creating Directories: We will now understand how to create directories. Directories are created by the following

$mkdir dirname Here, directory is the absolute or relative pathname of the directory you want to create. For

$mkdir mydir Creates the directory mydir $mkdir /tmp/test-dir This command creates the directory test-dir in the /tmpdirectory. The mkdir command produces no output if it successfully creates the requested directory. If you give more than one directory on the command line, mkdircreates each of the

$mkdir docs pub Creates the directories docs and pub under the current directory.

Creating Parent Directories We will now understand how to create parent directories. Sometimes when you want to create a directory, its parent directory or directories might not exist. In this case, $mkdir /tmp/amrood/test mkdir: Failed to make directory "/tmp/amrood/test"; No such file or directory In such cases, you can specify the -p option to the mkdircommand. It creates all the

$mkdir -p /tmp/amrood/test The above command creates all the required parent directories. Removing Directories Directories can be deleted using the rmdir $rmdir dirname Note file or sub-directory inside this directory. You can re $rmdir dirname1 dirname2 dirname3 The above command removes the directories dirname1, dirname2, and dirname3, if they are empty. The rmdircommand produces no output if it is successful. Changing Directories You can use the cd command to do more than just change to a home directory. You can use it to change to any directory by specifying a valid absolute or relative path. The syntax is as

$cd dirname Here, dirname is the name of the directory that you want to change to. For example, the

$cd /usr/local/bin Changes to the directory /usr/local/bin. From this directory, you can cd to the directory /usr/home/amrood $cd ../../home/amrood Renaming Directories The mv (move) command can also be used to rename a directory. The syntax is as follows

$mv olddir newdir You can rename a directory mydir to yourdir $mv mydir yourdir The directories . (dot) and .. (dot dot)

The filename . (dot) represents the current working directory; and the filename .. (dot dot) represents the directory one level above the current working directory, often referred to as the parent directory. If we enter the command to show a listing of the current working directories/files and use the -a option to list all the files and the -l option to provide the long listing, we will receive the following result. $ls -la drwxrwxr-x 4 teacher class 2048 Jul 16 17.56 . drwxr-xr-x 60 root 1536 Jul 13 14:18 .. ---------- 1 teacher class 4210 May 1 08:27 .profile -rwxr-xr-x 1 teacher class 1948 May 12 13:42 memo

5. FILE PERMISSIONS.

Linux permissions dictate 3 things you may do with a file, read, write and execute. They are referred to in Linux by a single letter each.

r read - you may view the contents of the file. w write - you may change the contents of the file. x execute - you may execute or run the file if it is a program or script.

Every file in Unix has the following

Owner permissions of the file can perform on the file.

Group permissions is a member of the group that a file belongs to, can perform on the file.

Other (world) permissions other users can perform on the file.

File Access Modes The permissions of a file are the first line of defense in the security of a Unix system. The basic building blocks of Unix permissions are the read, write, and execute permissions,

Read Grants the capability to read, i.e., view the contents of the file.

Write Grants the capability to modify, or remove the content of the file.

Execute User with execute permissions can run a file as a program.

Directory Access Modes Directory access modes are listed and organized in the same manner as any other file.

Read Access to a directory means that the user can read the contents. The user can look at the filenames inside the directory.

Write Access means that the user can add or delete files from the directory.

Execute Executing a directory doesn't really make sense, so think of this as a traverse permission.

A user must have execute access to the bin directory in order to execute the ls or the cd command.

Changing Permissions To change the file or the directory permissions, you use the chmod (change mode) command. There are two ways to use chmod the symbolic mode and the absolute mode.

Using chmod in Symbolic Mode The easiest way for a beginner to modify file or directory permissions is to use the symbolic mode. With symbolic permissions you can add, delete, or specify the permission set you want by using the operators in the following table.

S.No. Chmod operator & Description

1 +Adds the designated permission(s) to a file or directory.

2 - Removes the designated permission(s) from a file or directory.

3 = Sets the designated permission(s).

chown chown command stands for "change owner" and is used to change the owner of a file.

chgrp chgrp command stands for "change group" and is used to change the group of a file.

SUID and SGID File Permission Additional permissions are given to programs via a mechanism known as the Set User ID (SUID) and Set Group ID (SGID) bits.

When you execute a program that has the SUID bit enabled, you inherit the permissions of that program's owner. Programs that do not have the SUID bit set are run with the permissions of the user who started the program.

This is the case with SGID as well. Normally, programs execute with your group permissions, but instead your group will be changed just for this program to the group owner of the program.

UNIT-III

1. Process and Kernel support for process:

The UNIX process table may be thought of as a data structure describing all of the processes that are currently loaded.

Viewing Processes

We can see what processes are running by using the ps command. Here is some sample

output:

The PID column gives the PIDs, the TTY column shows which terminal started the process, the STAT column shows the current status, TIME gives the CPU time used so far and the COMMAND column shows the command used to start the process. Let's take a closer look at some of these:

The initial login was performed on virtual console number one (v01). The shell is running bash. Its status is s, which means sleeping. This is because it's waiting for the X Windows sytem to finish.

X Windows was started by the command startx. It won't finish until we exit from X. It too is sleeping.

The fvwm is a window manager for X, allowing other programs to be started and windows to be arranged on the screen.

This process represents a window in the X Windows system. The shell, bash, is running in the new window. The window is running on a new pseudo terminal (/dev/ptyp0) abbreviated

pp0.

This is the EMACS editor session started from the shell mentioned above. It uses the pseudo terminal.

This is a clock program started by the window manager. It's in the middle of a one-minute wait between updates of the clock hands.

Process environment

Let's look at some other processes running on this Linux system. The output has been abbreviated for clarity:

Here we can see one very important process indeed:

In general, each process is started by another, known as its parent process. A process so started is known as a child process.

When UNIX starts, it runs a single program, the prime ancestror and process number one:

init.

One such example is the login procedure init starts the getty program once for each terminal that we can use to long in.

These are shown in the ps output like this:

When interacting with user server through a shell session, there are many pieces of information that user shell compiles to determine its behavior and access to resources. Some of these settings are contained within configuration settings and others are determined by user input.

One way that the shell keeps track of all of these settings and details is through an area it maintains called the environment. The environment is an area that the shell builds every time that it starts a session that contains variables that define system properties. In this guide, we will discuss how to interact with the environment and read or set environmental and shell variables interactively and through configuration files. We will be using an Ubuntu 12.04 VPS as an example, but these details should be relevant on any Linux system.

Every time a shell session spawns, a process takes place to gather and compile information that should be available to the shell process and its child processes. It obtains the data for these settings from a variety of different files and settings on the system.

Kernel support for process:

Basically the environment provides a medium through which the shell process can get or set settings and, in turn, pass these on to its child processes. The kernel runs the show, i.e. it manages all the operations in a Unix flavored environment.

The kernel architecture must support the primary Unix requirements. These requirements fall in two categories namely, functions for process management and functions for file management (files include device files). Process management entails allocation of resources

including CPU, memory, and offers services that processes may need. The file management in itself involves handling all the files required by processes, communication with device

drives and regulating transmission of data to and from peripherals. The kernel operation gives the user processes a feel of synchronous operation, hiding all underlying asynchronism in peripheral and hardware operations (like the time slicing by clock). In summary, we can say that the kernel handles the following operations :

1. It is responsible for scheduling running of user and other processes.

2. It is responsible for allocating memory.

3. It is responsible for managing the swapping between memory and disk.

4. It is responsible for moving data to and from the peripherals.

5. It receives service requests from the processes and honors them.

2. Zombie Process: its

process descriptor stays in memory (the process descriptor only takes a tiny amount of

notified that its child process has died with the SIGCHLD signal. The parent process is then supposed to execute the other information. This allows the parent process to get information from the dead process. After wait() is called, the zombie process is completely removed from memory. When a child exits, the parent process will receive a SIGCHLD signal to indicate that one of its children has finished executing; the parent process will typically call the wait() status, and will cause the child to be reaped, or removed from the process table.

3. Orphan Process

An orphan process is a computer process whose parent process has finished or terminated, though it remains running itself.

In a Unix-like operating system any orphaned process will be immediately adopted by the special init system process. This operation is called re-parenting and occurs automatically. Even though technically the process has the init process as its parent, it is still called an orphan process since the process that originally created it no longer exists.

A process can be orphaned unintentionally, such as when the parent process terminates or crashes. The process group mechanism in most Unix-like operation systems can be used to help protect against accidetry to terminate all the child processes with the SIGHUP process signal, rather than letting them continue to run as orphans.

4. Signals:

Signals are software interrupts sent to a program to indicate that an important event has occurred. The events can vary from user requests to illegal memory access errors. Some signals, such as the interrupt signal, indicate that a user has asked the program to do something that is not in the usual flow of control SIGHUP: Hang up detected on controlling terminal or death of controlling process SIGINT: Issued if the user sends an interrupt signal (Ctrl + C) SIGQUIT: Issued if the user sends a quit signal (Ctrl + D) SIGFPE: Issued if an illegal mathematical operation is attempted SIGKILL: If a process gets this signal it must quit immediately and will not perform any clean-up operations SIGALRM: Alarm clock signal (used for timers)

Terminate the process.

Ignore the signal.

Dump core. This creates a file called core containing the memory image of the process when it received the signal.

Stop the process.

Continue a stopped process.

5. alarm(), kill(), raise(), pause(), abort(), sleep() system calls:

Alarm():

The alarm function allows us to get a timer that will expire at a specified time in the future.

signal, its default action is to terminate the process. #include<unistd.h> unsigned int alarm(unsigned int seconds); Returns: 0 or number of seconds until previously set alarm. The seconds value is the number of clock seconds in the future when the signal

should be generated. There is only one of the alarm clocks per process. If, when we call alarm, there is a

previously registered alarm clock for the process that has not yet expired, the number of seconds left for that alarm clock to return as the value of this function. That previously registered alarm clock is replaced by the new value. If there is a previously registered alarm clock for the process that has not yet

seconds left for that previous alarm clock is still returned as the value of the function. Although the default action for SIGALRM is terminating the process, most processes use an alarm clock catch this signal.

Kill( ) and raise( ):

The kill function sends a signal to a process or a group of processes. The raise function allows a process to send a signal to itself.

#include<sys/types.h>

#include<signal.h>

int kill(pid_t pid, int signo); int raise(int signo);

Both return: 0 if OK, -1 on error

There are four different conditions for the pid argument to kill: pid > 0 The signal is sent to the process whose process ID is pid.

pid = 0 The signal is sent to all processes whose process group ID equals the process

group ID of the sender and for which the sender has permission to send thesignal.

pid<0 The signal is sent to all processes whose process group ID equals the absolute value

of pid and for which the sender has permission to send the signal.

pid = -1 unspecified.

Pause( ): The pause function suspends the calling process until a signal is caught.

#include<unistd.h> int pause(void); Returns: -1 with errno set to EINTR The only time pause returns is if a signal handler is executed and that handler returns. In that case, pause returns -1 with errno set to EINTR.

Abort( ):

abort function causes abnormal program termination.

#include<stdlib.h> void abort(void);

This function never returns. This function sends the SIGABRT signal to the process. A process should not ignore

this signal. abort overrides the blocking or ignoring of the signal by the process.

sleep ():

#include<unistd.h>

unsigned int sleep(unsigned int seconds);

Returns: 0 or number of unslept seconds.

This function causes the calling process to be suspended until either:

The amount of clock that is specified by seconds has elapsed or A signal is caught by the process and the signal handler returns.

In case 1 the return value is 0 when sleep returns early, because of some signal being caught

case 2, the return value is the number of unslept seconds.

Sleep can be implemented with an alarm function. If alarm is used however, there can be

interaction between the two functions.

UNIT-IV

1. Inter-process Communication

Interprocess Communication-

Interprocess communication (IPC) includes thread synchorization and data exchange between threads beyond the process boundaries. If threads belong to the same process, they execute in the same address space, i.e. they can access global (static) data or heap directly, without the help of the operating system. However, if threads belong to different processes, they cannot access each others address spaces without the help of the operating system.

There are two fundamentally different approaches in IPC:

processes are residing on the samecomputer processes are residing on differentcomputers

The first case is easier to implement because processes can share memory either in the user space or in the system space. This is equally true for uniprocessors and multiprocessors. In the second case the computers do not share physical memory, they are connected via I/O device(for example serial communication or Ethernet). Therefore the processes residing in different computers can not use memory as a means for communication.

IPC between processes on a Single System

Most of this chapter is focused on IPC on a single computer system, including four general approaches:

Sharedmemory Messages Pipes Sockets

The synchronization objects considered in the previous chapter normally work across the process boundaries (on a single computer system). There is one addition necessary however: the synchronization objects must be named. The handles are generally private to the process, while the object names, like file names, are global and known to all processes. h = init_CS("xxx"); h = init_semaphore(20,"xxx"); h = init_event("xxx");

h = init_condition("xxx"); h = init_message_buffer(100,"xxx"); IPC between processes on different systems

IPC between processes on different systems

IPC is Inter Process Communication, more of a technique to share data across different processes withinone machine, in such a way that data passing binds the coupling of different processes.

The first,isusing memory mapping techniques, where a memory map is created, andothers open the memory map forreading/writing...

The second is, using sockets, to communicate with one another...this has a high overhead,as each process would have to open up the socket, communicate across...althougheffective

The third, is to use a pipe or a named pipe, a very goodexample

2. PIPES

A pipe is a serial communication device (i.e., the data is read in the order in which it was written),which allows a unidirectional communication. The data written to end is read back from the other end. The pipe is mainly used to communicate between two threads in a single process or between parent and child process. Pipes can only connect the related process. In shell, the symbol can be used to create pipe. In pipes the capacity of data is limited. (i.e.) If the writing process is faster than the reading process which consumes the data, the pipe cannot store the data. In this situation the writer process will block until more capacity becomes available. Also if the reading process tries to read data when there is no data to read, it will be blocked until the data becomes available. By this, pipes automatically synchronize the twoprocess.

Creatingpipes:

The pipe() function provides a means of passing data between two programs and also allows to read and write the data. #include<unistd.h> int pipe(int file_descriptor[2]); pipe()function is passed with an array of file descriptors. It will fill the array with new file

descriptors and returns zero. On error, returns -1 and sets the errno to indicate the reason of failure. The file descriptors are connected in a way that is data written to file_ descriptor[1] can be read back from the file_descriptor[0]. (Note: As this uses file descriptors and not the file streams, we must use read and write system calls to access the data.) Pipes are originally used in UNIX and are made even more powerful in Windows 95/NT/2000. Pipes are implemented in file system. Pipes are basically files with only two file offsets: one for reading another for writing. Writing to a pipe and reading from a pipe is strictly in FIFO manner. (Therefore pipes are also called FIFOs). For efficiency, pipes are in-core files, i.e. they reside in memory instead on disk, as any other global data structure. Therefore pipes must be restricted in size, i.e. number of pipe blocks must be limited. (In UNIX the limitation is that pipes use only direct blocks.)Since the pipes have a limited size and the FIFO access discipline, the reading and writing processes are synchronized in a similar manner as in case of message buffers. The access functions for pipes are the same as for files: WriteFile() and ReadFile().

3. FIFO

Similar to pipes, but allows for communication between unrelated processes. This is done by naming the communication channel and making it permanent. Like pipe, FIFO is the unidirectional data stream. FIFO creation:

int mkfifo ( const char *pathname, mode_t mode ); - makesa FIFO special file with namepathname. (mode specifies the FIFO's permissions, as common in UNIX-like file systems). - A FIFO special file is similar to a pipe, except that it is createdin a different way. Instead of being an anonymous communications channel, a FIFO special file is entered into the file system by calling mkfifo() Once a FIFO special file has been created, any process can open it for reading or writing, in the same

way as an ordinary file. A First-in, first-out(FIFO) file is a pipe that has a name in the filesystem. It is also called as named pipes.

Creation of FIFO: We can create a FIFO from the command line and within a program. To create from command line we can use either mknod or mkfifo commands.

$ mknod filename p $ mkfifo filename (Note: The mknod command is available only n older versions, you can make use of mkfifo in new versions.) To create FIFO within the program we can use two system calls. They are,

#include<sys/types.h> #include<sys/stat.h> int mkfifo(const char *filename,mode_t mode); int mknod(const char *filename, mode_t mode|S_IFIFO,(dev_t) 0); If we want to use the mknod function we have to use ORing process of fileaccess mode with S_IFIFO and the dev_t value of 0.Instead of using this we can use the simple mkfifo function.

Accessing FIFO: Let us first discuss how to access FIFO in command line using file commmands. The useful feature of named pipes is, as they appear in the file system, we can use them in commands. We can read from the FIFO(empty) $ cat< /tmp/my_fifo Now, let us write to the FIFO. $ echo "Simple!!!"> /tmp/my_fifo (Note: These two commands should be executed in different terminals because first command will be waiting for some data to appear in the FIFO.)

4. Message Queues

A message queue is a linked list of messages stored within the kernel and identified by a message queue identifier. A new queue is created or an existing queue opened by msgget(). New messages are added to the end of a queue by msgsnd(). Every message has a positive long integer type field, a non-negative length, and the actual data bytes (corresponding to the length), all of which are specified to msgsnd() when the message is added to a queue. Messages are fetched from a queue by msgrcv()first-in, first-out order. Instead, we can fetch messages based on their type field. All processes can exchange information through access to a common system message queue. The sending process places a message (via some (OS) message-passing module) onto a queue which can be read by another process. Each message is given an identification or type so that processes can select the appropriate message. Process must share a common key in order to gain access to the queue in the first place.

System calls used for message queues:

ftok(): is use to generate a unique key.

msgget(): either returns the message queue identifier for a newly created message

queue or returns the identifiers for a queue which exists with the same key value.

msgsnd(): Data is placed on to a message queue by calling msgsnd().

msgrcv(): messages are retrieved from a queue.

msgctl(): It performs various operations on a queue. Generally it is use to

destroy message queue.

5. Semaphores

Semaphores are not used to exchange a large amount of data. Semaphores are used synchronization among processes. Other synchronization mechanisms include record locking and mutexes. Why necessary? Examples include: shared washroom, common rail segment, and common bank account. Further comments: 1) The semaphore is stored in the kernel: Allows atomic operations on the semaphore. Processes are prevented from indirectly modifying the value.

2) A process acquires the semaphore if it has a value of zero. The value of the semaphore is then incremented to a process releases the semaphore, the value of the semaphore is decremented. 3) If the semaphore has non-zero value when a process tries to acquire it, that process blocks. 4) In comments 2 and 3, the semaphore acts as a customer counter. In most cases, it is a resource counter. 5) the semaphore is available. This is better (more efficient) than busy waiting such as TEST&SET. 6) The kernel maintains information on each semaphore internally, using a data structure struct semis_ds that keeps track of permission, number of semaphores, etc. 7) Apparently, a semaphore in Unix is not a single binary value, but a set of nonnegative integer values 8) There are 3 (logical) types of semaphores: Binary semaphore have a value of 0 or 1. Similar to a mutex lock. 0 means locked; 1 means unlocked.

Counting semaphore has a value 0. Used for counting resources, like the producer-

consumer example. Note that value =0 is similar to a lock (resource not available).

Set of counting semaphores one or more semaphores, each of which is a counting semaphore.

9) There are 2 basic operations performed with semaphores: Wait waits until the semaphore is > 0, then decrements it.

Post increments the semaphore, which wakes waiting processes.

UNIT-V

1. Shared Memory

Using a pipe or a message queue requires multiple exchanges of data through the kernel. Shared memory can be used to bypass the kernel for faster processing.

The kernel maintains information about each shared memory segment, including permission, size, access time, etc in struct shmid_ds .struct shmid_ds looks like struct semid_ds or as struct msqid_ds .

A share memory segment is created using: int shmget(key_t key, int size, int shmflag); size --- size of the shared memory segment in bytes. shmflag --- same as for msgget() and

--- shmid, the shared memory identifier, -1 on error.

Attach to the shared memory segment using: char *shmat(int shmid, char *shmaddr, int shmflag) shmid --- return value of shmget, that is, the id of the created shared memory.shmaddr--- 0: let the kernel select the address. shmflag--- SHM_RDONLY for read_only access. returns the starting address of the shared memory, and thus we can read/write on the shared memory after getting its starting address.

Detach the shared memory segment using: char *shmdt(char *shmaddr) shmaddr --- the return value of shmat(), that is, the starting address of the shared memory. returns 1 on failure. To remove a shared memory segment: Int shmctl(int shmid, int cmd, shmid_ds *buf); cmd--- IPC_RMID to delete, e.g., shmctl(shmid, IPC_RMID,

2. Socket

Sockets allow communication between two different processes on the same or different machines. To be more precise, it's a way to talk to other computers using standard Unix file descriptors. In Unix, every I/O action is done by writing or reading a file descriptor. A file descriptor is just an integer associated with an open file and it can be a network connection, a text file, a terminal, or something else.

To a programmer, a socket looks and behaves much like a low-level file descriptor. This is because commands such as read() and write() work with sockets in the same way they do with files and pipes.

Sockets were first introduced in 2.1BSD and subsequently refined into their current form with 4.2BSD. The sockets feature is now available with most current UNIX system releases.

Where is Socket Used?

A Unix Socket is used in a client-server application framework. A server is a process that performs some functions on request from a client. Most of the application-level protocols like FTP, SMTP, and POP3 make use of sockets to establish connection between client and server and then for exchanging data.

Socket Types

There are four types of sockets available to the users. The first two are most commonly used and the last two are rarely used.

Processes are presumed to communicate only between sockets of the same type but there is no restriction that prevents communication between sockets of different types.

Stream Sockets through the stream socC". These sockets use TCP (Transmission Control Protocol) for data transmission. If delivery is impossible, the sender receives an error indicator. Data records do not have any boundaries.

Datagram Sockets

you build a packet with the destination information and send it out. They use UDP (User Datagram Protocol).

3. Socket in client/server model

Most of the Net Applications use the Client-Server architecture, which refers to two processes or two applications that communicate with each other to exchange some information. One of the two processes acts as a client process, and another process acts as a server.

Client Process

This is the process, which typically makes a request for information. After getting the response, this process may terminate or may do some other processing.

Example, Internet Browser works as a client application, which sends a request to the Web Server to get one HTML webpage.

Server Process

This is the process which takes a request from the clients. After getting a request from the client, this process will perform the required processing, gather the requested information, and send it to the requestor client. Once done, it becomes ready to serve another client. Server processes are always alert and ready to serve incoming requests.

Example or requests from Internet Browsers and as soon as it gets any request from a browser, it picks up a requested HTML page and sends it back to that Browser.

Note that the client needs to know the address of the server, but the server does not need to know the address or even the existence of the client prior to the connection being established. Once a connection is established, both sides can send and receive information.

2-tier and 3-tier architectures

There are two types of client-

2-tier architecture type of architecture may have some security holes and performance problems. Internet Explorer and Web Server work on two-tier architecture. Here security problems are resolved using Secure Socket Layer (SSL).

3-tier architectures

all the security checks and load balancing in case of heavy load. A middleware takes all requests from the client and after performing the required authentication, it passes that request to the server. Then the server does the required processing and sends the response back to the middleware and finally the middleware passes this response back to the client. If you want to implement a 3-tier architecture, then you can keep any middleware like Web Logic or WebSphere software in between your Web Server and Web Browser.

Types of Server

T

Iterative Server client and after completing the first request, it takes request from another client. Meanwhile, another client keeps waiting.

Concurrent Servers many requests at a time because one process may take longer and another client cannot wait for so long. The simplest way to write a concurrent server under Unix is to fork a child process to handle each client separately.

How to Make Client

The system calls for establishing a connection are somewhat different for the client and the server, but both involve the basic construct of a socket. Both the processes establish their own sockets.

Create a socket with the socket() system call.

Connect the socket to the address of the server using the connect() system call.

Send and receive data. There are a number of ways to do this, but the simplest way is to use the read() and write() system calls.

How to make a Server

Create a socket with the socket() system call.

Bind the socket to an address using the bind() system call. For a server socket on the Internet, an address consists of a port number on the host machine.

Listen for connections with the listen() system call.

Accept a connection with the accept() system call. This call typically blocks the connection until a client connects with the server.

Send and receive data using the read() and write()system calls.

Client and Server Interaction

Following is the diagram showing the complete Client and Server interaction.

4. Socket Addresses

sockaddr

The first structure is sockaddr

struct sockaddr {

unsignedshort sa_family;

char sa_data[14];

};

This is a generic socket address structure, which will be passed in most of the socket

Attribute Values Description

sa_family

AF_INET

AF_UNIX

AF_NS

AF_IMPLINK

It represents an address family. In most of the Internet-based applications, we use AF_INET.

sa_data Protocol-specific Address

The content of the 14 bytes of protocol specific address are interpreted according to the type of address. For the Internet family, we will use port number IP address, which is represented by sockaddr_in structure defined below.

sockaddr in

struct sockaddr_in {

shortint sin_family;

unsignedshortint sin_port;

struct in_addr sin_addr;

unsignedchar sin_zero[8];

};


sa_family

AF_INET

AF_UNIX

AF_NS

AF_IMPLINK

It represents an address family. In most of the Internet-based applications, we use AF_INET.

sin_port Service Port A 16-bit port number in Network Byte Order.

sin_addr IP Address A 32-bit IP address in Network Byte Order.

sin_zero Not Used You just set this value to NULL as this is not being used.

in addr

This structure is used only in the above structure as a structure field and holds 32 bit netid/hostid.

struct in_addr {

unsignedlong s_addr;

};

Attribute

Values

Description

s_addr service port

A 32-bit IP address in Network Byte Order.

hostent

This structure is used to keep information related to host.

struct hostent {

char*h_name;

char**h_aliases;

int h_addrtype;

int h_length;

char**h_addr_list

#define h_addr h_addr_list[0]

};


h_name ti.com etc.

It is the official name of the host. For example, tutorialspoint.com, google.com, etc.

h_aliases TI It holds a list of host name aliases.

h_addrtype AF_INET It contains the address family and in case of Internet based application, it will always be AF_INET.

h_length 4 It holds the length of the IP address, which is 4 for Internet Address.

h_addr_list in_addr For Internet addresses, the array of pointers h_addr_list[0], h_addr_list[1], and so on, are points to structure in_addr.

NOTE h_addr is defined as h_addr_list[0] to keep backward compatibility.

5.Socket APIs

This list is a summary of functions or methods provided by the Berkeley sockets API library:

socket() creates a new socket of a certain socket type, identified by an integer number, and allocates system resources to it.

bind() is typically used on the server side, and associates a socket with a socket address structure, i.e. a specified local port number and IP address.

listen() is used on the server side, and causes a bound TCP socket to enter listening state.

connect() is used on the client side, and assigns a free local port number to a socket. In case of a TCP socket, it causes an attempt to establish a new TCP connection.

accept() is used on the server side. It accepts a received incoming attempt to create a new TCP connection from the remote client, and creates a new socket associated with the socket address pair of this connection.

send() and recv(), or write() and read(), or sendto() and recvfrom(), are used for sending and receiving data to/from a remote socket.

close() causes the system to release resources allocated to a socket. In case of TCP, the connection is terminated.

gethostbyname() and gethostbyaddr() are used to resolve host names and addresses. IPv4 only.

select() is used to suspend, waiting for one or more of a provided list of sockets to be ready to read, ready to write, or that have errors.

poll() is used to check on the state of a socket in a set of sockets. The set can be tested to see if any socket can be written to, read from or if an error occurred.

getsockopt() is used to retrieve the current value of a particular socket option for the specified socket.

setsockopt() is used to set a particular socket option for the specified socket.

16. Unit Wise Question Bank

UNIT-I

Two Mark Question with Answer:

1) What is Linux?

Linux is an operating system based on UNIX, and was first introduced by Linus Torvalds. It is

based on the Linux Kernel, and can run on different hardware platforms manufactured by Intel,

MIPS, HP, IBM, SPARC and Motorola. Another popular element in Linux is its mascot, a penguin

figure named Tux.

2) What is the difference between UNIX and LINUX?

Unix originally began as a propriety operating system from Bell Laboratories, which later on

spawned into different commercial versions. On the other hand, Linux is free, open source and

intended as a non-propriety operating system for the masses.

3) Write a short notes on BASH?

BASH is short for Bourne Again SHell. It was written by Steve Bourne as a replacement to the

original Bourne Shell (represented by /bin/sh). It combines all the features from the original

version of Bourne Shell, plus additional functions to make it easier and more convenient to use. It

has since been adapted as the default shell for most systems running Linux.

4) What is Linux Kernel?

The Linux Kernel is a low-level systems software whose main role is to manage hardware

resources for the user. It is also used to provide an interface for user-level interaction.

5 ) What are the basic components of Linux?

The operating system, Linux has all of these components: kernel, shells and GUIs, system utilities,

and application program. What makes Linux advantageous over other operating system is that

every aspect comes with additional features and all codes for these are ownloadable for free.

Three Mark Question with Answer:

1) How do you change permissions under Linux?

Assuming you are the system administrator or the owner of a file or directory, you can grant

permission using the chmod command. Use + symbol to add permission or symbol to deny

permission, along with any of the following letters: u (user), g (group), o (others), a (all), r (read),

w (write) and x (execute).

For example the command chmod go+rw FILE1.TXT grants read and write access to the file

FILE1.TXT, which is assigned to groups and others.

2) What is the pwd command?

command, and is used to display the current location in the directory tree.

3) What are the kinds of permissions under Linux?

There are 3 kinds of permissions under Linux:

Read: users may read the files or list the directory

Write: users may write to the file of new files to the directory

Execute: users may run the file or lookup a specific file within a directory

4)What are environmental variables?

Linux programs. Another common term for environmental variables is global shell variables.

5) What is redirection?

Redirection is the process of directing data from one output to another. It can also be used to direct

an output as an input to another process.

Five Mark Question with Answer:

1. UNIX/ LINUX operating system and features of UNIX/LINUX.

Linux is a Unix-like computer operating system assembled under he model of free and opensource

software development and distribution. The defining component of Linux is the Linuxkernel, an

operating system kernel first released 5 October 1991 by Linus Torvalds.

Linux was originally developed as a free operating system for Intel x86-based personal

computers. It has since been ported to more computer hardware platforms than any other operating

system. It is a leading operating system on servers and other big iron systems such as mainframe

computers and supercomputers more than 90% of today's 500 fastestsupercomputers run some

variant of Linux, including the 10 fastest. Linux also runs on embedded systems (devices where

the operating system is typically built into the firmware and highly tailored to the system) such as

mobile phones, tablet computers, network routers, televisions and video gameconsoles; the

Android system in wide use on mobile devices is built on the Linuxkernel.

Basic Features

Following are some of the important features of Linux Operating System.

Portable -

way. A Linux kernel and application program supports their installation on anykind of

hardwareplatform.

Open Source - Linux source code is freely available and it is community based

Linux operating system and it is continuouslyevolving.

Multi-User - Linux is a multiuser system means multiple users can accesssystem resources

like memory/ ram/ application programs at sametime.

Multiprogramming Linux is a multiprogramming system means multipleapplications

can run at sametime.

Hierarchical File System - Linux provides a standard file structure in whichsystem

files/ user files are arranged.

Shell - Linux provides a special interpreter program which can be used to execute

commands of the operating system. It can be used to do various types of operations,call

application programsetc.

Security - Linux provides user security using authentication features like password

protection/ controlled access to specific files/ encryption ofdata.

Linux Advantages:

1. Low cost: spend time and money to obtain licenses since Linux and

much of its software come with the GNU General Public License. User can start to work

immediately without worrying that user software may stop working anytime because the

free trial version expires. Additionally, there are large repositories from which user can

freely download high quality software for almost any task user can thinkof.

2. Stability:

down over time due to memory leaks. Continuous up- times of

hundreds of days (up to a year or more) are notuncommon.

3. Performance: Linux provides persistent high performance on workstations andon

networks. It can handle unusually large numbers of users simultaneously, and can make old

computers sufficiently responsive to be usefulagain.

4. Network friendliness: Linux was developed by a group of programmers over theInternet

and has therefore strong support for network functionality; client and server systems can be

easily set up on any computer running Linux. It can perform tasks such as network backups

faster and more reliably than alternativesystems.

5. Flexibility: Linux can be used for high performance server applications, desktop

applications, and embedded systems. User can save disk space by only installing the

components needed for a particular use. User can restrict the use of specific computers by

installing for example only selected office applications instead of the wholesuite.

6. Compatibility: It runs all common Unix software packages and can process all common

file formats.

7. Choice: The large number of Linux distributions gives user a choice. Each distribution is

developed and supported by a different organization. User can pick the one user like

best;the core functionalities are the same; most software runs on most distributions.

8. Fast and easy installation: Most Linux distributions come with user-friendly installation

and setup programs. Popular Linux distributions come with tools that make installation of

additional software very user friendly aswell.

9. Full use of hard disk: Linux continues work well even when the hard disk is almost full.

10. Multitasking: Linux is designed to do many things at the same time; e.g., a largeprinting

w down user otherwork.

11. Security:

access permission systems prevent access by unwanted visitors or viruses. Linux users

haveto option to select and safely download software, free of charge, from online

repositories containing thousands of high quality packages. No purchase transactions

requiring credit card numbers or other sensitive personal information arenecessary.

12. Open Source: If user develop software that requires knowledge or modification of the

are Open Source aswell.

--------------------------------------------------------------------------------------------------------------

2. Disk Utilities with example

du takes a single argument, specifying a pathname for du to work; if it is not specified, the current

directory is used. The SUS mandates for du the following options:

-a, display an entry for each file (and not directory) contained in the current directory

-H, calculate disk usage for link references specified on the command line

-k, show sizes as multiples of 1024 bytes, not 512-byte

-L, calculate disk usage for link references anywhere

-s, report only the sum of the usage in the current directory, not for each file

-x, only traverse files and directories on the device on which the pathname argument is specified.

Other UNIX and Unix-like operating systems may add extra options. For example, BSD and GNU

du specify a -h option, displaying disk usage in a format easier to read by the user, adding units

with the appropriate SI prefix

$ du -sk *

152304 directoryOne

1856548 directoryTwo

Sum of directories in human-readable format (Byte, Kilobyte, Megabyte, Gigabyte, Terabyte and

Petabyte):

$ du -sh *

149M directoryOne 1.8G directoryTwo

Disk usage of all subdirectories and files including hidden files within the current directory (sorted

by filesize) :

$ du -sk .[!.]* *| sort -n

Disk usage of all subdirectories and files including hidden files within the current directory (sorted

by reverse filesize) :

$ du -sk .[!.]* *| sort nr

The weight of directories:

$ du -d 1 -c -h

df command : Report file system disk space usage

Df command examples - to check free disk space

Type df -h or df -k to list free disk space:

$ df -h OR

$ df k Output:

Filesystem Size Used Avail Use% Mountedon

/dev/sdb1 20G 9.2G 9.6G 49%

/varrun 393M 144k 393M 1%

/var/run varlock 393M 0 393M 0%

/var/lock procbususb 393M 123k 393M 1%

/proc/bus/usbudev 393M 123k 393M 1%

/devdevshm 393M 0 393M 0%

/dev/shmlrm 393M 35M 359M 9%

/lib/modules/ 2.6.20-15-generic/volatile

/dev/sdb5 29G 5.4G 22G 20%/media/docs

/dev/sdb3 30G 5 9 G 23G 21%/media/isomp3s

/dev/sda1 8.5G 4.3G 4.3G 51%/media/xp1

/dev/sda2 12G 6.5G 5.2G 56%/media/xp2

/dev/sdc1 40G 3.1G 35G 9%/media/backup

du command examples:

du shows how much space one ore more files or directories is using.

$ du -sh 103M

-s option summarize the space a directory is using and -h option provides "Human-readable"

output.

-----------------------------------------------------------------------------------------------------------

3. SED and its addresses?

sed instruction format(Sed Addresses):

address determines which lines in the input file are to be processed by thecommand(s)

if no address is specified, then the command is applied to each inputline

addresstypes:

Single-Lineaddress

Set-of-Linesaddress

Rangeaddress

Nested

address Single-LineAddress

Specifies only one line in the inputfile

special: dollar sign ($) denotes last line of inputfile

Examples:

show only line3

sed -n -e '3 p' input-file

show only lastline

sed -n -e '$ p' input-file

substitute e with online10

sed -e '10 s/endif/fi/' input-file

Set-of-Lines Address

use regular expression to matchlines

written between twoslashes

process only lines thatmatch

may match severallines

lines may or may not beconsecutives

Examples:

sed - -file sed -n - -file

Range Address

Defines a set of consecutivelines

Format:

start-addr,end-addr (inclusive)

Examples:

10,50 line-number,line-number 10,

/R.E/ line-number,/RegExp/

/R.E./,10 /RegExp/,line-number

/R.E./,/R.E/ /RegExp/,/RegExp/ Example: RangeAddress

% sed -n - -file

Print lines between BEGIN and END,inclusive

BEGIN

Line 1 of input Line 2 of input Line3 of input END

Line 4 of input

Line 5 of input

Nested Address

Nested address contained within anotheraddress

Example:

print blank lines between line 20 and 30

20,30{

/^$/ p

}

---------------------------------------------------------------------------------------------------------------

4. awk

created by: Aho, Weinberger, andKernighan

scripting language used for manipulating data and generatingreports

awkoperations:

scans a file line byline

splits each input line intofields

compares input line/fields topattern

performs action(s) on matchedlines

Useful for:

transform datafiles

produce formattedreports

Programming constructs:

format outputlines

arithmetic and stringoperations

conditionals and loops

awk Syntax

awk [options] f scriptfilefile(s)

Options:

-F to change input field separator

-f to namescriptfile

awkProgram

consists of patterns &actions:

pattern {action}

if pattern is missing, action is applied to alllines

if action is missing, the matched line isprinted

must have either pattern oraction

Example:

awk '/for/' testfile

prints all lines containing string for intext file.

awk Scripts

awk scripts are divided into three majorparts:

Linux Programming

comment lines start with#

BEGIN:pre-processing

performs processing that must be completed before the file processing starts(i.e., before

awk starts reading records from the inputfile)

useful for initialization tasks such as to initialize variables and to create report

headings

BODY:Processing

contains main processing logic to be applied to inputrecords

like a loop that processes input data one record at atime:

if a file contains 100 records, the body will be executed 100 times, onefor eachrecord

END:post-processing

contains logic to be executed after all input data have beenprocessed

Logic such as printing report grand total should be performed in this part ofthe script.

----------------------------------------------------------------------------------------------------------------

5. Shell and its responsibilities?

The shell has similarities to the DOS command processor Command.com (actually

Dos was design as a poor copy of UNIX shell), it's actually much more powerful,

really a programming language in its own right.

A shell is always available on even the most basic UNIX installation. User has to go

through the shell to get other programs to run. User can write programs using the shell.

Users use the shell to administrate user UNIX system.

For example: ls -al | more

is a short shell program to get a long listing of the present directory and route the

output through the more command.

Linux Programming

Working with BourneShell

The Bourne shell, or sh, was the default Unix shell of Unix Version 7. It

wasdeveloped by Stephen Bourne, of AT&T BellLaboratories.

A Unix shell, also called "the command line", provides the traditional user

interfacefor the Unix operating system and for Unix-like systems. Users direct the

operation of the computer by entering command input as text for a shell toexecute.

There are many different shells in use. Theyare

Bourne shell(sh)

C shell(csh)

Korn shell(ksh) Bourne Again shell(bash)

When we issue a command the shell is the first agency to acquire the information. It

accepts and interprets user requests. The shell examines &rebuilds the commands

&leaves the execution work to kernel. The kernel handles the h/w on behalf ofthese

commands &all processes in thesystem.

The shell is generally sleeping. It wakes up when an input is keyed inat the prompt.

This input is actually input to the program that represents theshell.

Shell responsibilities

1. ProgramExecution

2. Variable and FilenameSubstitution

3. I/ORedirection

4. PipelineHookup

5. EnvironmentControl

6. Interpreted ProgrammingLanguage

1.ProgramExecution:

The shell is responsible for the execution of all programs that user request fromuser

terminal.

Each time user type in a line to the shell, the shell analyzes the line and

thendetermines what todo.

Linux Programming

Thelinethatistypedtotheshell isknownmoreformallyasthecommandline.Theshell scans

this command line and determines the name of the program to be executed and what

arguments to pass to theprogram.

2. Variable and FilenameSubstitution:

Like any other programming language, the shell lets user assign values to variables.

Whenever user specify one of these variables on the command line, preceded by

adollar sign, the shell substitutes the value assigned to the variable atthatpoint.

3. I/ORedirection:

It is the shell's responsibility to take care of input and output redirection on

thecommand line. It scans the command line for the occurrence of the special

redirection characters<,

>, or >>.

4. PipelineHookup:

Just as the shell scans the command line looking for redirection characters, it also

looks for the pipe character |. For each such character that it finds, it connects the

standard output from the command preceding the | to the standard input of the one

following the|. It then initiates execution of bothprograms.

5. EnvironmentControl:

The shell provides certain commands that let user customize user environment. User

environment includes home directory, the characters that the shell displays

topromptuser to type in a command, and a list of the directories to be searched

whenever user request that a program be executed.

6. Interpreted ProgrammingLanguage:

The shell has its own built-in programming language. This language is interpreted,

meaning that the shell analyzes each statement in the language one line at a time

andthen executes it. This differs from programming languages such as C and

FORTRAN, in which the programming statements are typically compiled into a

machine-executable form before they areexecuted.

Linux Programming

Programs developed in interpreted programming languages are typically easier to

debug and modify than compiled ones. However, they usually take much longer to

executethan their compiledequivalents.

-------------------------------------------------------------------------------------------------------

MULTIPLE CHOICE

1. The kernel interacts with the machine

_____________

a. hardware

b. software

c. operating system

d. user

2. The programs access the kernel through a set of

functions called ______

a. shell

b. system call

c. interface

d. command

3. The kernel manages the__________

a. system call

b. command interpreter

c. system memory

d. hardware

4. _________ act as interface between user and

kernel.

a. shell

b. system call

c. system memory

d. hardware

Linux Programming

5. The command which can be connected to

manipulate data in different ways is called as

_______

a. multi tasking

b. pipes

c. internal command

d. filters

6. By default, Linux uses the _________ shell.

a. sh

b. csh

c. ksh

d. bash

7. The system function can be controlled and

automated by using the _______

a. control structures

b. loops and variables

c. unix command

d. shell script

8. The features of the unix are:

a. the file and process

b. multi programming and multi tasking

c. kernel and shell

d. the system calls

9. The shell is represented

by________,_______and______.

a. sh, dsh, bsh.

b. sh, csh, ksh

c. sh, csh, bsh.

d. sh, csh, dsh.

Linux Programming

10. _______ command is used to display and

evaluate shell variables.

a. man

b. echo

c. ls

d. script

1 A 6 D

2 B 7 D

3 C 8 B

4 A 9 B

5 D 10 B

FILL IN THE BLANKS:

Father of UNIX ______.

Unix was written in ____ Language.

_____ is the core of operating system.

UNIX is a _____ system.

Flavors of Linux _________

_____ is a UNIX implementation that is constantly growing with

contributions from the free software foundation.

A command is used with_____ and _______.

_____ command is used to count the total number of lines, words, and

characters contained in a file.

____ tells the user current directory.

Pipes connects the standard ______ of one command to the standard

______ of another.

er

command.

Linux Programming

The shell is a _____ that runs when a user logs in and terminates when

user logs out.

1 Linus Torvalds 7 Options, arguments

2 C 8 WC

3 Kernel 9 pwd

4 Command Based 10 Output, input

5 Red Hat, 11 Command substitution

6 LINUX 12 Process

UNIT II


1) What is grep command?

grep a search command that makes use of pattern-based searching. It makes use of options

and parameters that is specified along the command line and applies this pattern into

searching the required file output.

2) Explain linux file system?

Linux File system Hierarchy Standard (FHS)

File system hierarchy standard describes directory structure and its content in Unix and Unix

like operating system. It explains where files and directories should be located and what it

should contain.

The Root Directory

All the directories in the Linux system comes under the root directory which is represented

by a forward slash (/). Everything in your system can be found under this root directory even

if they are stored in different virtual or physical directories.

Linux Programming

3) What is the advantage of open source?

Open source facilitates you to distribute your software, including source codes freely to

anyone who is interested. So, you can add features and even debug and correct errors of the

source code.

4) write a short notes on Inode?

A structure that is maintained in a separate area of the harddisk.

File attributes are stored in theinode.

Every file is associated with a table called theinode.

The inode is accessed by the inodenumber.

5) List the attributes of inode?

Inode contains the following attributes of file: file type, file permissions , no.of links,UID of

the owner, GID of the group owner, file size date and time of last modification, last access,

change.

Three mark Question with Answer

1)Write about lseek()?

The lseek system call sets the read/write pointer of a file descriptor,

fildes. You use it to set where in the file the next read or write will

occur.

The offset parameter is used to specify the position and the whence

parameter specifies how the offset is used.

Linux Programming

whencecan be one of the following:

2)Write system call dup and dup2.

The dup system calls provide a way of duplicating a file descriptor,

giving two or more, different descriptors that access the same file.

3) List the use of softlink.

Soft link(symbolic links):Refer to a symbolic path indicating the abstract

location of another file.

Used to provide alternative means of referencingfiles.

Users may create links for files using ln command by specifying soption.

4) write short notes on hardlink.

hard links : Refer to the specific location of physical data.

A hard link is a UNIX path name for afile.

Most of the files have only one hard link. However users may create

additional hard linksfor files using lncommand.

Linux Programming

5) List the functions of directory.

The directory functions are declared in a header file, dirent.h. They use a

structure, DIR, as a basis for directory manipulation.

Here are these functions:

Five mark Question with Answer:

1. LINUX File system

Linux file structure files are grouped

according to purpose. Ex: commands, data

files, documentation. Parts of a Unix

directory tree are listed below. All

directories are grouped under the root

entry "/". That part of the directory tree is

left out of the below diagram.

1. / Root

Every single file and directory

starts from the rootdirectory.

Only root user has write privilege

under thisdirectory.

Please note

2. /bin UserBinaries

Contains binaryexecutables.

Linux Programming

Common linux commands user need to use in single-user modes are located under

this directory.

Commands used by all the users of the system are locatedhere.

For example: ps, ls, ping, grep,cp.

3. /sbin SystemBinaries

Just like /bin, /sbin also contain binaryexecutables.

But, the linux commands located under this directory are used typically by system

administrator, for system maintenancepurpose.

For example: iptables, reboot, fdisk, ifconfig,swapon

4. /etc ConfigurationFiles

Contains configuration files required by allprograms.

This also contains startup and shutdown shell scripts used to start/stop individual

programs.

For example: /etc/resolv.conf,/etc/logrotate.conf

5. /dev DeviceFiles

Contains devicefiles.

These include terminal devices, usb, or any device attached to thesystem.

For example: /dev/tty1,/dev/usbmon0

6. /proc ProcessInformation

Contains information about systemprocess.

Thisisapseudofilesystemcontainsinformationaboutrunningprocess.Forexample:

/proc/{pid} directory contains information about the process with that particular pid.

This is a virtual filesystem with text information about system resources. For

example:

/proc/uptime

7. /var VariableFiles

Linux Programming

var stands for variablefiles.

Content of the files that are expected to grow can be found under thisdirectory.

This includes system log files (/var/log); packages and database files (/var/lib);

emails (/var/mail); print queues (/var/spool); lock files (/var/lock); temp files needed

across reboots(/var/tmp);

8. /tmp TemporaryFiles

Directory that contains temporary files created by system andusers.

Files under this directory are deleted when system isrebooted.

9. /usr UserPrograms

Contains binaries, libraries, documentation, and source-code for second

levelprograms.

binaryunder

/bin, look under /usr/bin. For example: at, awk, cc, less, scp

binary under /sbin, look under /usr/sbin. For example: atd, cron, sshd, useradd,userdel

/usr/lib contains libraries for /usr/bin and/usr/sbin

/usr/local contains users programs that user install from source. For example, when

user

install apache from source, it goes under /usr/local/apache2

10. /home HomeDirectories

Home directories for all users to store their personalfiles.

For example: /home/john,/home/nikita

11. /boot Boot LoaderFiles

Contains boot loader relatedfiles.

Kernel initrd, vmlinux, grub files are located under/boot

For example: initrd.img-2.6.32-24-generic,vmlinuz-2.6.32-24-generic

Linux Programming

12. /lib SystemLibraries

Contains library files that supports the binaries located under /bin and/sbin

Library filenames are either ld* orlib*.so.*

For example: ld-2.11.1.so,libncurses.so.5.7

13. /opt Optional add-onApplications

opt stands foroptional.

Contains add-on applications from individualvendors.

add-on applications should be installed under either /opt/ or /opt/sub-directory.

14. /mnt MountDirectory

Temporary mount directory where sysadmins can mountfilesystems.

15. /media Removable MediaDevices

Temporary mount directory for removabledevices.

For examples, /media/cdrom for CD-ROM; /media/floppy for floppy

drives;

/media/cdrecorder for CD writer

16. /srv ServiceData

srv stands forservice.

Contains server specific services relateddata.

For example, /srv/cvs contains CVS relateddata.

---------------------------------------------------------------------------------------------------------------

2. Files attributes and I/O operations.

File attributes

Attribute valuemeaning

Filetype type of thefile

Linux Programming

Accesspermission file access permission for owner, groupandothersHardlinkcount

no.of hard links of afile.

UID file owner userID.

GID the file groupID.

Filesize file size inbytes.

Inode number system inode number of the file.

File system ID file system ID where the file is stored.

I/O operations:

To provide a higher level interface to device and disk files, UNIIX provides a number of

standard libraries.

Low-level File Access

Each running program, called a process, has associated with it a number of file descriptors.

When a program starts, it usually has three of these descriptors already opened. These are:

Linux Programming

The write system call arranges for the first nbytes bytes from buf to be written to the file

associated with the file descriptor fields.

With this knowledge, let's write our first program, simple_write.c:

Here is how to run the program and its output.

$ simple_write Here is some data

$

read

The read system call reads up to nbytes of data from the file associated with the file

descriptor fields and places them in the data area buf.

This program, simple_read.c, copies the first 128 bytes of the standard input to the standard

output.

Linux Programming

If user run the program, user should see:

$ echo hello there | simple_read hello there

$ simple_read < draft1.txt Files

Open: To create a new file descriptor we need to use the open system call.

openestablishes an access path to a file or device.

The name of the file or device to be opened is passed as a parameter, path, and the oflags

parameter is used to specify actions to be taken on opening the file.

The oflags are specified as a bitwise OR of a mandatory file access mode and other optional

Linux Programming

modes. The open call must specify one of the following file access modes:

The call may also include a combination (bitwise OR) of the following optional modes in the

oflags parameter:

Initial Permissions

When we create a file using the O_CREAT flag with open, we must use the three parameter

form. mode, the third parameter, is made form a bitwise OR of the flags defined in the header

file sys/stat.h. These are:

Linux Programming

For example:

Has the effect of creating a file called myfile, with read permission for the owner and

execute permission for others, and only those permissions.

umask

The umask is a system variable that encodes a mask for file permissions to be used when a

file is created.

User can change the variable by executing the umask command to supply a new value.

The value is a three-digit octal value. Each digit is the results of ANDing values from 1, 2,

or 4.

Linux Programming

For example, to block 'group' write and execute, and 'other' write, the umask would be:

Values for each digit are ANDed together; so digit 2 will have 2 &

1, giving 3. The resulting umask is 032.

Close: We use close to terminate the association between a file

descriptor, fildes, and its file.

----------------------------------------------------------------------------------------------------------------

Linux Programming

3. File permissions and links used in file system.

chmod

Command:

chmod command allows user to alter / Change access rights to files and directories.

File Permission is given for users, group and others as,

SYNTAX:

The Syntax is

chmod [options] [MODE] FileName

File Permission

# File Permission

0 None

1 execute only

2 write only

Read Write Execute

User

Group

Others

Permission 000 Symbolic

Linux Programming

3 write and execute

4 read only

5 read and execute

6 read and write

7 set all permissions OPTIONS:

-c Displays names of only those files whose permissions are being changed

-f Suppress most error messages

-R Change files and directories recursively

EXAMPLE:

1. To view user files with what permission they are: ls-alt

This command is used to view user files with what permission they are.

2. To make a file readable and writable by the group andothers. chmod 066file1.txt

3. To allow everyone to read, write, and execute thefile

chmod 777 file1.txt

ln command is used to create link to a file (or) directory. It helps to provide soft link for

desired files. Inode will be different for source and destination.

SYNTAX:

The Syntax is

ln [options] existingfile(or directory)name newfile(or directory)name

-v Output version information and exit.

Linux Programming

OPTIONS:

-f Link files without questioning the user, even if the mode of target forbids

writing. This is the default if the standard input is not a terminal.-n Does not overwrite existing files.

-s Used to create soft links. EXAMPLE:

1. ln -s file1.txtfile2.txt

Creates a symbolic link to 'file1.txt' with the name of 'file2.txt'. Here inode for

'file1.txt' and 'file2.txt' will be different.

2. ln -s abc xyz

Creates a symbolic link to 'abc' with the name of 'xyz'.

-------------------------------------------------------------------------------------------------------------

4.Directory manipulation functions.

The directory functions are declared in a header file, dirent.h. They use a structure, DIR, as

a basis for directory manipulation.

Here are these functions:

opendir

The opendir function opens a directory and establishes a directory stream.

Linux Programming

readdir

The readdir function returns a

pointer to a structure detailing

the next directory entry in the

directory stream dirp.

The dirent structure containing directory entry details included the following entries:

telldir

The telldir function returns a value

that records the current position in a

directory stream.

Linux Programming

seekdir

The seekdir function sets

the directory entry pointer

in the directory stream

given by dirp.

closedir

The closedir function closes a directory

stream and frees up the resources associated

with it.

-------------------------------------------------------------------------------------------------------------

5) Write about File and record locking. File locking is applicable only for regularfiles.

It allows a process to impose a lock on a file so that other processes can not

modifythe file until it is unlocked by theprocess.

Write lock: it prevents other processes from setting any overlapping read / write

lockson the locked region of afile.

Read lock: it prevents other processes from setting any overlapping write locks onthe

locked region of afile.

Write lock is also called a exclusive lock and read lock is also called a sharedlock.

fcntl API can be used to impose read or write locks on either a segment or

anentirefile.

Functionprototype:

#include<fcntl.h>

All file locks set by a process will be unlocked when the processterminates.

Linux Programming

----------------------------------------------------------------------------------------------------------------

Fill in the Blanks

1. A device file is created in UNIX via the ______ command.

2. _____ stores system administrative files and programs.

3. _____ keeps tracks of all all files.

4. Files are identified by _____.

5. System call used for symbolic links _____.

6. The ____ in a file inode record specifies how many file table entries are

pointing to the file inode record.

7. _____ function sets file pointer to beginning of file.

8. A ____ link is a UNIX path name for a file.

9. _____ sets default file creation mask.

10. _____ access mode flag uses opens the file for read and write.

11. The ____ function helps a user to query or set access control flags and

close on exec flag of any file descriptor.

12. _____ is also called a shared lock.

1 Mknod 7 rewinddir

2 /etc 8 hard

3 Inode table 9 umask

4 Path name 10 O_RDWR

5 Symlink 11 fcntl

6 Reference count 12 read

Linux Programming

Multiple Choice

1. The commonly used unix commands are found in______ directories.

a. /etc

b. lib and/usr/lip

c. /bin and/usr/bin

d. /usr/include

2. vi provides the repeat factor by using thefollowing mode commands

a. i/p mode, ex mode

b. ex mode, command mode

c. i/p mode, command mode

d. ex mode

3. What command is used to abort the editingprocess and quit the editing mode without

savingthe buffer

a. :w

b. : x and :wq

c. :q

d. :wq

4. ps options are _______

a. ps e,ps c, ps u

b. ps c, ps e

c. ps f, ps u,ps-a

d. ps f,ps c, ps a

5. Unix provides a _________ command to see howmuch of the disk is being used and

what partof it lies free

a. du

b. df

c. dfspace

d. ulimit

6. du command is used to know_______________

a. know available disk space

Linux Programming

b. disk space used by specified directory

c. disk space used by specified file

d. disk space used by specified files and directories

7. mount o ro mounts a file system in _____ mode

a. remounts in read mode

b. read only

c. remounts in write mode

d. allows binary execution

8. The unix system creates files and directorieswith 666 and 777 as the default

permissions,these default permissions can be changed by________ in the systems

startup scripts.

a. unlink

b. ulimit

c. unmask

d. umask

9. ____________ command restricts on themaximum size of a file that a user is

permitted tocreate

a. unmask

b. umask

c. unlimit

d. ulimit

10. Which command is used to mount file system?

a. mount

b. umount

c. mnt

d. umnt

Linux Programming

1 C 6 D

2 C 7 B

3 C 8 D

4 C 9 D

5 B 10 A

UNIT III


1)Write about fork API .

fork Function

The only way a new process is created by the UNIX kernel is when an existing process calls

the fork function.


#include<unistd.h> pid_t fork(void);

Return: 0 is child, process ID of child in parent, -1 on error.

2) Write the syntax of kill command.

kill COMMAND:

kill command is used to kill the background process.

SYNTAX:

The Syntax iskill [-s] [-l] %pid

3) What is a PATH variable

The PATH variable contains a list of directories (called path prefixes) that are

separated by colors. For example, the name=value environment string

PATH=/bin:/usr/bin:usr/local/bin/:.

Specifies four directories to search, where last one is current working directory.

Linux Programming

4) Write a program using alarm()

5) Write about abort Function



This function never returns.

This function sends the SIGABRT signal to the process. A process should not ignore this

signal. abort overrides the blocking or ignoring of the signal by the process.

Three Mark Question with Answer:

1. What is a process? List its characteristics?

A process is a running program or script and consists of

program/script itself and

necessary to ensure a correct program flow.

Characteristics of a process are (among others)

t process (PPID),

Linux Programming

Normally, when a process has been started from a shell, the shell cannot be used for other

input until the end of the process. But processes and programs can also be run in the

background. To enable this feature, the command line which calls the process/program must

2)Write about fork()

The forkfunction is used to create a process from within a process.

The resultant new process created by fork() is known as child process while the

original process (from which fork() was called) becomes the parent process.

The function fork() is called once (in the parent process) but it returns twice. Once it

returns in the parent process while the second time it returns in the child process.

Syntax: pid_t fork(void);

3)Explain waidpid()?

The function waitpid() that can be used by the parent process to query the change

state of a particular child.

The signature of waitpid() is :

pid_t waitpid(pid_t pid, int *status, int options);

By default, waitpid() waits only for terminated children, but this behavior is

modifiable via the options argument, as described below.

The value of pid can be:

< -1 : Wait for any child process whose process group ID is equal to the absolute

value of pid.

-1 : Wait for any child process.

0 : Wait for any child process whose process group ID is equal to that of the calling

process.

>0 : Wait for the child whose process ID is equal to the value of pid.

Linux Programming

4)Explain exec family?

The exec functions replace the program running in a process with another program.

Functions that contain the letter p in their names (execvp and execlp) accept a

program name and search for a program by that name in the current execution path;

contain the p must be given the full path of the program to be

executed.

Functions that contain the letter v in their names (execv, execvp, and execve) accept

the argument list for the new program as a NULL-terminated array of pointers to

strings.

Functions that contain the letter l (execl, execlp, and execle) accept the argument list

Functions that contain the letter e in their names (execve and execle) accept an

additional argument, an array of environment variables.The argument should be a

NULL-terminated array of pointers to character strings. Each character string should

5)What is a signal?

Signals are mechanisms for communicating with and manipulating processes in

Linux.

A signal is a special message sent to a process. Signals are asynchronous; when a

process receives a signal, it processes the signal immediately, without finishing the

current function or even the current line of code.There are several dozen different

signals, each with a different meaning. Each signal type is specified by its signal

number, but in programs, user usually refer to a signal by its name. In Linux, these are

defined in /usr/include/bits/signum.h.

Linux Programming


1. Process and Kernel support for process.

The UNIX process table may be thought of as a data structure describing all of the processes

that are currently loaded.

Viewing Processes

We can see what processes are running by using the ps command. Here is some sample

output:

The PID column gives the PIDs, the TTY column shows which terminal started the process,

the STAT column shows the current status, TIME gives the CPU time used so far and the

COMMAND column shows the command used to start the process. Let's take a closer look at

some of these:

The initial login was performed on virtual console number one (v01). The shell is running

bash. Its status is s, which means sleeping. This is because it's waiting for the X Windows

sytem to finish.

X Windows was started by the command startx. It won't finish until we exit from X. It too is

sleeping.

The fvwm is a window manager for X, allowing other programs to be started and windows to

be arranged on the screen.

This process represents a window in the X Windows system. The shell, bash, is running in

the new window. The window is running on a new pseudo terminal (/dev/ptyp0) abbreviated

pp0.

This is the EMACS editor session started from the shell mentioned above. It uses the pseudo

terminal.

This is a clock program started by the window manager. It's in the middle of a one-minute

Linux Programming

wait between updates of the clock hands.

Process environment

Let's look at some other processes running on this Linux system. The output has been

abbreviated for clarity:

Here we can see one very important process indeed:

In general, each process is started by another, known as its parent process. A process so

started is known as a child process.

When UNIX starts, it runs a single program, the prime ancestror and process number one:

init.

One such example is the login procedure init starts the getty program once for each terminal

that we can use to long in.

These are shown in the ps output like this:

When interacting with user server through a shell session, there are many pieces of

information that user shell compiles to determine its behavior and access to resources. Some

of these settings are contained within configuration settings and others are determined by user

input.

One way that the shell keeps track of all of these settings and details is through an area it

maintains called the environment. The environment is an area that the shell builds every time

that it starts a session that contains variables that define system properties.

In this guide, we will discuss how to interact with the environment and read or set

environmental and shell variables interactively and through configuration files. We will be

using an Ubuntu 12.04 VPS as an example, but these details should be relevant on any Linux

system.

Every time a shell session spawns, a process takes place to gather and compile information

that should be available to the shell process and its child processes. It obtains the data for

these settings from a variety of different files and settings on the system.

Linux Programming

Kernel support for process

Basically the environment provides a medium through which the shell process can get or set

settings and, in turn, pass these on to its child processes

The kernel runs the show, i.e. it manages all the operations in a Unix flavored environment.

The kernel architecture must support the primary Unix requirements.

These requirements fall in two categories namely, functions for process management and

functions for file management (files include device files). Process management entails

allocation of resources including CPU, memory, and offers services that processes may need.

The file management in itself involves handling all the files required by processes,

communication with device drives and regulating transmission of data to and from

peripherals. The kernel operation gives the user processes a feel of synchronous operation,

hiding all underlying asynchronism in peripheral and hardware operations (like the time

slicing by clock).

In summary, we can say that the kernel handles the following operations :

1. It is responsible for scheduling running of user and otherprocesses.

2. It is responsible for allocating memory.

3. It is responsible for managing the swapping between memory and disk.

4. It is responsible for moving data to and from the peripherals.

5. It receives service requests from the processes and honors them.

----------------------------------------------------------------------------------------------------------------

2. System call interface for process management.

fork Function

The only way a new process is created by the UNIX kernel is when an existing process calls

the fork function.


Linux Programming

#include<unistd.h> pid_t fork(void);

Return: 0 is child, process ID of child in parent, -1 on error

The new process created by fork is called child process. This is called once, but return twice

that is the return value in the child is 0, while the return value in the parent is the process ID

process can have more than one child, so there is no function that allows a process to obtain

the process IDs of its children. The reason fork return 0 to the child is because a process can

have only a single parent, so that child can always call getppid to obtain the process ID of its

parent.

Both the child and parent contain executing with the instruction that follows the call to fork.

heap and stack. This is a copy fo

of memory. Often the parent and child share the text segment, if it is read-only.

There are two users for fork:

1. When a process wants to duplicate itself so that the parent and child can each execute

different sections of code at the same time. This is common for network servers_ the parent

waits for a service requests from a client. When the request arrives, the parent calls fork and

lets the child handle the request. The parent goes back to waiting for the next service request

to arrive.

When a process wants to execute a different program, this is common for shells. In this case

the child does an exec right after it returns from the fork.

vfork Function

The function vfork has the same calling sequence and share return values as fork. But the

semantics of the two functions differ. vfork is intended to create a new process when the

purpose of the new process is to exec a new program. vfork creates the new process, just like

fork, without fully copying the address space of the parent into the child, since the child

the child just calls exec right after the vfork. Instead,

while the child is running, until it calls either exec or exit, the child runs in the address space

of the parent. This optimization provides an efficiency gain on some paged virtual memory

Linux Programming

implementations of UNIX.

Another difference between the two functions is that vfork guarantees that the child runs first,

until the parent resumes.

wait and waitpid Functions

When a process terminates, either normally or abnormally, the parent is notified by the kernel

sending the parent SIGCHLD signal. Since the termination of a child is an asynchronous

event, this signal is the asynchronous notification from the kernel to the parent. The default

action for this signal is to be ignored. A parent may want for one of its children to terminate

A process that calls wait and waitpid can

1. block (if all of its children are still running).

2. return immediately with termination status of a child ( if a child has terminated and is

waiting for its termination status to be fetched) or

3. return immediately with an error (if it down have any child process).

If the process is calling wait because it received SIGCHLD signal, we expect wait to return

immediately. But, if we call it at any random point in time, it can block.


#include<sys/wait.h>

pid_t wait(int *statloc);

pid_t waitpid(pid_t pid, int *statloc, int options); Both return: process ID if OK, o or -1 on

error The difference between these two functions is

1. wait can block the caller until a child process terminates, while waitpid has an option

that prevents it from blocking.

2. waitpid does not wait for the first child to terminate, it has a number of options that

control which process it waits for.

Linux Programming

exit Function

There are three ways for a process to terminate normally, and two forms of abnormal

termination.

1. Normal termination:

a. Executing a return from the main function. This is equivalent to calling exit

b. Calling the exit function

c. Calling the _exit function

2. Abnormal termination

a. Calling abort: It generates the SIGABRT signal

b. When the process receives certain signals. The signal can be generated by the process

it-self.

Regardless of how a process terminates, the same code in the kernel is eventually

executed. This kernel code closes all the open descriptors for the process, releases the

memory.

----------------------------------------------------------------------------------------------------------------

3. What is Signal? List different types of signals?

A signal is an event generated by the UNIX system in response to some condition, upon

receipt of which a process may in turn take some action. Signal names are defined in the

header file signal.h. They all begin with SIG and include:

Additional signals include:

If the shell and terminal driver are configured normally, typing the interrupt character

(Ctrl-C) at the keyboard will result in the SIGINT signal being sent to the foreground

process. This will cause the program to terminate.

----------------------------------------------------------------------------------------------------------------

4. Define reliable signals and unreliable signals? Explain functions kill(), raise()?

Signal Functions

The system calls related to signals are explained in the following sections.

Unreliable signals

The signals could get lost a signal could occur and the process would never know about it.

Linux Programming

Here, the process has little control over a signal, it could catch the signal or ignore it, but

blocking of a signal is not possible.

Reliable signals

Linux supports both POSIX reliable signals (hereinafter "standard signals") and POSIX real-

time signals.

kill and raise Functions

The kill function sends a signal to a process or a group of processes. The raise function

allows a process to send a signal to itself.


#include<signal.h>

int kill(pid_t pid, int signo); int raise(int signo);

Both return: 0 if OK, -1 on error

There are four different conditions for the pid argument to kill: pid > 0 The signal is sent to

the process whose process ID is pid.

pid = 0 The signal is sent to all processes whose process group ID equals the process

group ID of the sender and for which the sender has permission to send thesignal.

pid<0 The signal is sent to all processes whose process group ID equals the absolute value

of pid and for which the sender has permission to send the signal.

pid = -1 unspecified.

----------------------------------------------------------------------------------------------------------------

5. Write short notes on alarm(), pause(), abort(), sleep()?

alarm and pause Functions

The alarm function allows us to get a timer that will expire at a specified time in the future.

signal, its default action is to terminate the process.

#include<unistd.h>

unsigned int alarm(unsigned int seconds);

Linux Programming

Returns: 0 or number of seconds until previously set alarm.

The seconds value is the number of clock seconds in the future when the signal should be

generated. There is only one of the alarm clocks per process. If, when we call alarm, there is a

previously registered alarm clock for the process that has not yet expired, the number of

seconds left for that alarm clock to return as the value of this function. That previously

registered alarm clock is replaced by the new value.

If there is a previously registered alarm clock for the process that has not yet expired and if

that previous alarm clock is still returned as the value of the function.

Although the default action for SIGALRM is terminating the process, most processes use an

alarm clock catch this signal.

The pause function suspends the calling process until a signal is caught.

#include<unistd.h> int pause(void);

Returns: -1 with errno set to EINTR

The only time pause returns is if a signal handler is executed and that handler returns. In that

case, pause returns -1 with errno set to EINTR.

abort Function



This function never returns.

This function sends the SIGABRT signal to the process. A process should not ignore

this signal. abort overrides the blocking or ignoring of the signal by the process.

Linux Programming

sleep Function

#include<unistd.h>

unsigned int sleep(unsigned int seconds);

Returns: 0 or number of unslept seconds.

This function causes the calling process to be suspended until either:

1. The amount of clock that is specified by seconds has elapsed or

2. A signal is caught by the process and the signal handler returns.

In case 1 the return value is 0 when sleep returns early, because of some signal being caught

case 2, the return value is the number of unslept seconds.

Sleep can be implemented with an alarm function. If alarm is used however, there can be

interaction between the two functions.

----------------------------------------------------------------------------------------------------------------

Fill in the blanks

1. A ____ has a Process Table that keeps track of all active process.

2. Process table contains ___, ___, ___ segments.

3. ___ is an integer identification number that is unique per process in an entire

operating system.

4. The _____ system call is used to create a child process.

5. The pipe system creates a communication channel between two _____ process.

6. The important aspect of process control is ______.

7. _____ are triggered by events.

8. SIGTERM used for _____.

9. The sleep function is only one use of ____ API.

10. The primary use of signals is for _____.

1 Kernel 6 Signal handling

2 Text, data, stack 7 Signals

3 PID 8 Process termination

4 Fork 9 Alarm

5 Related 10 Process control

Linux Programming

UNIT-IV

Two mark Question with Answer

1)write semaphore datastructure

2) What are pipes

A pipe is a communication device that permits unidirectional communication. Data

devices; the data is always read from the pipe in the same order it was written. Typically,

a pipe is used to communicate between two threads in a single process or between parent

and child processes.

In a shell, the symbol | creates a pipe.For example, this shell command causes the

shell to produce two child processes, one for ls and one for less:

% ls | less

3) What is IPC?

Interprocess Communication-

Interprocess communication (IPC) includes thread synchorization and data

exchange between threads beyond the process boundaries. If threads belong

to the same process, they execute in the same address space, i.e. they can

access global (static) data or heap directly, without the help of the

operating system. However, if threads belong to different processes, they

cannot access each others address spaces without the help of the operating

Linux Programming

system.

4) Write about mkfifo()

int mkfifo ( const char *pathname, mode_t mode );

-

(mode specifies the FIFO's permissions,

as common in UNIX-like file systems).

-

a different way. Instead of being an anonymous

communications channel, a FIFO special file is

entered into the file system by calling mkfifo()

5) What isMessagequeue?

This is an easy way of passing message between two process. It provides a

way of sending a block of data from one process to another. The main

advantage of using this is, each block of data is considered to have a type, and a

receiving process receives the blocks of data having different type

valuesindependently.

Five mark Question with Answer

1. Explain Inter Process Communication?

Inter-process Communication- -process communication (IPC) is the

Processes communicate with each other and with the kernel to coordinate their

activities. Linux supports a number of Inter-Process Communication (IPC)

mechanisms. Signals and pipes are two of them but Linux also supports the System

V IPC mechanisms named after the Unix release in which they first appeared.

Inter Process Communication (IPC) includes thread synchronization and data

exchange between threads beyond the process boundaries. If threads belong to the

same process, they execute in the same address space, i.e. they can access global

(static) data or heap directly, without the help of the operating system. However, if

Linux Programming

threads belong to different processes, they cannot access each other address spaces

without the help of the operating system.

There are two fundamentally different approaches in IPC:

Processes are residing on the samecomputer

Processes are residing on differentcomputers

The first case is easier to implement because processes can share memory either in

the user space or in the system space. This is equally true for uniprocessors and

multiprocessors.

In the second case the computers do not share physical memory, they are connected

via I/O device (for example serial communication or Ethernet). Therefore the

processes residing in different computers can not use memory as a means for

communication.

IPC between processes on a Single System

Most of this chapter is focused on IPC on a single computer system, including

four general approaches:

Sharedmemory

Messages

Pipes

Sockets

----------------------------------------------------------------------------------------------------------------

2. What are pipes? Explain named and unnamed pipes?

Pipes

Pipes are used to allow one or more processes to have information "flow" between them. The

most common example of this is with the shell.

$ ls | wc -l

Linux Programming

-out from the left side (ls) is connected to the std-in on the right side

(wc -l).As far the each program is concerned, it is reading or writing as it normally does. Both

processes are running concurrently.

There are 2 types of pipes:

unnamed pipes

named pipes

The examples we seen at the shell command line are unnamed. They are created, used and

One end is for reading and one end is for writing. When you are done with a pipe, it is closed

like any other file.

Creating unnamed pipes

#include <unistd.h>

int pipe(int fd[2]);

Returnsfile descriptors in the fd array.

fd[0] is for read

fd[1] write

Returns 0 on successful creation of pipe and -1 otherwise.

Each end of the pipe is closed individually using normal close() system call. Pipes are only

Reading from pipes

When reading from a pipe:

read() will return 0 (end of file) when the write end of the pipe is closed. if write end of the is

still open and there is no data, read() will block until input become available. if a read() tries

to get more data than is currently in pipe, read() will only contain the number of bytes

actually read. Subsequent reads will block until more data are available.

Writing to pipes

When writing to a pipe:

If read end of pipe is closes, a write() will fail and process will be sent SIGPIPE signal.

Default SIGPIPE handler terminates.

Linux Programming

Named pipes

exist as special files

within a file system. (file type p) They exist until they are removed with rm or unlink() They

can be used with unrelated process not just descendants of the pipe creator.

Created with:

mknod utility

mknod() system call

Creating named pipes

From the shell

$ mknod mypipe p

From a C program

mknod ( "mypipe", SIFIFO, 0 );

Either way you create it, this will result in a special file being created on the filesystem.

$ ls -l mypipe

prw-r r-- 1 srs users 0 Nov 6 22:28 mypipe

Once a named pipe is created, processes can open(), read() and write() them just like any

other file. Unless you specify O_NONBLOCK, or O_NDELAY, on the open:

opens for reading will block until a process opens if for writing.

opens for writing will block until a process opens it for reading.

3. Write short notes on semaphore and mutex.

Semaphores

Semaphores are used to protect critical regions of code or data structures. Remember

that each access of a critical piece of data such as a VFS inode describing a directory is

made by kernel code running on behalf of a process. It would be very dangerous to

allow one process to alter a critical data structure that is being used by another process.

One way to achieve this would be to use a buzz lock around the critical piece of data

that is being accessed, but this is a simplistic approach that would degrade system

performance.

Instead Linux uses semaphores to allow just one process at a time to access critical

regions of code and data; all other processes wishing to access this resource will be

made to wait until it becomes free. The waiting processes are suspended, other

processes in the system can continue to run as normal.

Linux Programming

A Linux semaphore data structure contains the following information:

count

This field keeps track of the count of processes wishing to use this resource. A positive

value means that the resource is available. A negative or zero value means that

processes are waiting for it. An initial value of 1, means that one and only one process

at a time can use this resource. When processes want this resource they decrement the

count and when they have finished with this resource they increment the count.

waking

This is the count of processes waiting for this resource which is also the number of

process waiting to be awakened when this resource becomes free.

wait queue

When processes are waiting for this resource they are put onto this wait queue,

Suppose the initial count for a semaphore is 1, the first process to come along will see

that the count is positive and decrement it by 1, making it 0. The process now ``owns''

the critical piece of code or resource that is being protected by the semaphore. When

optimal case is where there are no other processes contending for ownership of the

critical region. Linux has implemented semaphores to work efficiently for this, the

most common case.

Mutexes:

Mutexes are used to prevent data inconsistencies due to race conditions. A race

condition often occurs when two or more threads need to perform operations on the

same memory area, but a result of computations depends on the order in which these

operations are performed. Mutexes are used for serializing shared resources. Anytime a

global resource is accessed by more than one thread the resource should have a Mutex

associated with it. One can apply a mutex to protect a segment of memory ("critical

region") from other threads. Mutexes can be applied only to threads in a single process

and do not work between processes as do semaphores

----------------------------------------------------------------------------------------------------------------

4. Explainmessage queue from System V?

The message queue from System V

A process can invoke msgsnd() to send a message. User needs to pass the IPC

identifier of the receiving message queue, the size of the message and a message structure,

Linux Programming

including the message type and text.

On the other side, a process invokes msgrcv() to receive a message, passing the IPC

identifier of the message queue, where the message should get stored, the size and a

value t. t specifies the message returned from the queue, a positive value means the first

message with its type equal to t is returned, a negative value returns the last message equal

to type t and zero returns the first message of the queue.

Those functions are defined in include/linux/msg.h and implemented in ipc/msg.c

There are limitations upon the size of a message (max), the total number of

messages (mni) and the total size of all messages in the queue (mnb):

$ sysctl kernel.msg{max,mni,mnb}

kernel.msgmax = 8192

kernel.msgmni = 1655

kernel.msgmnb = 16384

.

POSIX Message Queue

The POSIX standard defines a message queue mechanism based on System V IPC's

message queue, extending it by some functionalities:

Simple file-based interface to the application

Support for message priorities

Support for asynchronous notification

Timeouts for blocking operations.

5. List APIs for semaphore?

Semaphores are not used to exchange a large amount of data. Semaphores are used

synchronization among processes. Other synchronization mechanisms include record

locking and mutexes.

1) The semaphore is stored in the kernel: Allows atomic operations on the

semaphore. Processes are prevented from indirectly modifying the value.

2) A process acquires the semaphore if it has a value of zero. The value of the

semaphore is then incremented to 1. When a process releases the semaphore, the

value of the semaphore is decremented.

3) If the semaphore has non-zero value when a process tries to acquire it, that

process blocks.

Linux Programming

4) In point 2 and 3, the semaphore acts as a customer counter. In most cases, it is

a resource counter.

until the semaphore is available. This is better (more efficient) than busy waiting

such as TEST&SET.

6) The kernel maintains information on each semaphore internally, using a data

structure struct semis_ds that keeps track of permission, number of semaphores,

etc.

7) Apparently, a semaphore in Unix is not a single binary value, but a set of

nonnegative integer values

8) There are 3 (logical) types of semaphores:

Binary semaphore have a value of 0 or 1. Similar to a mutex lock. 0 means

locked; 1 means unlocked.

Counting semaphore

producer-consumer example. Note that value =0 is similar to a lock (resource

not available).

Set of counting semaphores one or more semaphores, each of which is a

counting semaphore.

9) There are 2 basic operations performed with semaphores:

Wait waits until the semaphore is > 0, then decrements it.

Post increments the semaphore, which wakes waiting processes.

A semaphore set is created using

int semget(key_t key, int nsems, int semflag);

-- returns int semid; the id of the semaphore set; -1 on error.

nsems # of semaphores, use multiple semaphores for multiple resources.

semflag Same as msgflag, sets permission and creation options.

Linux Programming

The System V IPC semaphore

functions

are semget(), semop() and semc

tl().

semget() - Create a new

semaphore set or access an

existing set with

the semget() system call.

semop() - Perform semaphore operations.

semctl() - Change its ownership or permissions if user are the semaphore creator.

POSIX semaphores are much lighter weight than are System V semaphores. A POSIX

semaphore structure defines a single semaphore, not an array of semaphores. The POSIX

semaphore functions are:

sem_open() - Connects to, and optionally creates, a named semaphore.

sem_init() - Initializes a semaphore structure (internal to the calling program, so not a

named semaphore).

sem_close() - Ends the connection to an open semaphore.

sem_unlink() - Ends the connection to an open semaphore and removes the semaphore

when the last process closes it.

sem_destroy() - Initializes a semaphore structure (internal to the calling program, so not a

named semaphore).

sem_getvalue() - Copies the value of the semaphore into the specified integer

sem_wait(), sem_trywait() - Blocks while the semaphore is held by other processes or

returns an error if the semaphore is held by another process.

sem_post() - Increments the count of the semaphore.

Linux Programming

Multiple Choice:

Fill in the Blanks

1. _____ is a mechanism whereby two or more processes communicate with each

other to perform tasks.

2. BSD UNIX provides ______ for processes running on different machines to

communicate.

3. ______ allows processes on the same machine to exchange formatted data.

4. msgctl used to manipulate the _____ of the message queue.

5. Message API msgctl uses _____ file APIs.

6. The _____ function returns the number of bytes written to the mtext buffer.

7. ____ provides a method to synchronize the execution of multiple processes.

8. A process can also use multiple ______ sets.

9. The semaphore table entry data type is ______.

10. The _____ header defines a data type struct semid_ds.

1 Inter Process Communication 6 msgrcv

2 Socket 7 semaphore

3 Messages 8 Semaphore

4 Control data 9 Struct semid_ds

5 Stat, unlink, chmod, chown 10 Sys/sem.h

Linux Programming

UNIT-V


1)Write about kernel support for Shared memory?

Shared Memory:

Shared memory is a highly efficient way of data sharing between the

running programs. It allows two unrelated processes to access the same

logical memory. It is the fastest form of IPC because all processes share

the same piece of memory. I also avoids copying data unnecessarily.

As kernel does not synchronize the processes, it should be handled by the

user. Semaphore can also be used to synchronize the access to shared

memory.

Usage of shared memory:

To use the shared memory, first of all one process should allocate the

segment, and then each process desiring to access the segment should attach

the segment. After accessing the segment, each process should detach it.

It is also necessary to deallocatethe segment without fail.

Allocating the shared memory causes virtual pages to be created. It is

important to note that allocating the existing segment would not create new

pages, but will return the identifier for the existing pages.

All the shared memory segments are allocated as the integral multiples of

the system's page size, which is the number of bytes in a page of memory.

Unix kernel support for shared memory

There is a shared memory table in the kernel address space that keeps

track of allshared memory regions created in thesystem.

Each entry of the tables store the followingdata:

Linux Programming

1. Name

2. Creator user ID and groupID.

3. Assigned owner user ID and groupID.

4. Read-write access permission of theregion.

5. The time when the last process attached to theregion.

6. The time when the last process detached from theregion.

7. The time when the last process changed control data of theregion.

8. The size, in no. of bytes of theregion.

--------------------------------------------------------------------------------------------------------------

2)Explain APIs for shared memory?

shmget

Open and create a sharedmemory.

Functionprototype:


#include<sys/ipc.h>

#include<sys/shm.h>

int shmget ( key_t key, int size, int flag);

Function returns a positive descriptor if it succeeds or -1 if itfails.

Shmat

Attach a shared memory to a process virtual addressspace.

Functionprototype:


#include<sys/ipc.h>

Linux Programming

#include<sys/shm.h>

void * shmat ( int shmid, void *addr, int flag );

Function returns the mapped virtual address of he shared memory if it

succeeds or -1 ifit fails.

Shmdt

Detach a shared memory from the process virtual addressspace.

Functionprototype:


#include<sys/ipc.h>

#include<sys/shm.h>

int shmdt ( void *addr );

Function returns 0 if it succeeds or -1 if itfails.

Shmctl

Query or change control data of a shared memory or deletethememory.

Functionprototype:


#include<sys/ipc.h>

Linux Programming

#include<sys/shm.h>

int shmctl ( int shmid, int cmd, struct shmid_ds *buf );

Function returns 0 if it succeeds or -1 if itfails.

3)Explain Berkeley Socket?

Sockets allow communication between two different processes on the same or different

machines. To be more precise, it's a way to talk to other computers using standard Unix

file descriptors. In Unix, every I/O action is done by writing or reading a file descriptor. A

file descriptor is just an integer associated with an open file and it can be a network

connection, a text file, a terminal, or something else.

To a programmer, a socket looks and behaves much like a low-level file descriptor. This

is because commands such as read() and write() work with sockets in the same way they

do with files and pipes.

Sockets were first introduced in 2.1BSD and subsequently refined into their current form

with 4.2BSD. The sockets feature is now available with most current UNIX system

releases.

A Unix Socket is used in a client-server application framework. A server is a process that

performs some functions on request from a client. Most of the application-level protocols

like FTP, SMTP, and POP3 make use of sockets to establish connection between client and

server and then for exchanging data.

Processes are presumed to communicate only between sockets of the same type but there

is no restriction that prevents communication between sockets of different types.

Stream Sockets

through the stream socket three items "A, B, C", they will arrive in the same order

transmission. If delivery is impossible, the sender receives an error indicator. Data

records do not have any boundaries.

Datagram Sockets

Linux Programming

They're connectionless because you don't need to have an open connection as in

out. They use UDP (User Datagram Protocol).

--------------------------------------------------------------------------------------------------------------

4)Explain Socket address structure?

sockaddr in

The second structure that helps you to reference to the

struct sockaddr_in {

short int sin_family;

unsigned short int sin_port;

struct in_addr sin_addr;

unsigned char sin_zero[8];

};


sa_family

AF_INET

AF_UNIX

AF_NS

AF_IMPLINK

It represents an address family. In most

of the Internet-based applications, we

use AF_INET.

sin_port Service Port A 16-bit port number in Network Byte

Order.

Linux Programming

sin_addr IP Address A 32-bit IP address in Network Byte

Order.

sin_zero Not Used You just set this value to NULL as this

is not being used.

in addr

This structure is used only in the above structure as a structure field and holds 32 bit

netid/hostid.

struct in_addr {

unsigned long s_addr;

};


s_addr service

port

A 32-bit IP address in Network Byte

Order.

Hostent

This structure is used to keep information related to host.

struct hostent {

char *h_name;

char **h_aliases;

int h_addrtype;

int h_length;

char **h_addr_list

Linux Programming

#define h_addr h_addr_list[0]

};


h_name ti.com

etc.

It is the official name of the host. For example,

tutorialspoint.com, google.com, etc.

h_aliases TI It holds a list of host name aliases.

h_addrtype AF_INET It contains the address family and in case of Internet

based application, it will always be AF_INET.

h_length 4 It holds the length of the IP address, which is 4 for

Internet Address.

h_addr_list in_addr For Internet addresses, the array of pointers

h_addr_list[0], h_addr_list[1], and so on, are points to

structure in_addr.

NOTE

servent

This particular structure is used to keep information related to service and associated

ports.

struct servent {

char *s_name;

char **s_aliases;

Linux Programming

int s_port;

char *s_proto;

};

Here is the description of the member fields


s_name http This is the official name of the service. For

example, SMTP, FTP POP3, etc.

s_aliases ALIAS It holds the list of service aliases. Most of the

time this will be set to NULL.

s_port 80 It will have associated port number. For

example, for HTTP, this will be 80.

s_proto TCP

UDP

It is set to the protocol used. Internet services

are provided using either TCP or UDP.

--------------------------------------------------------------------------------------------------------------

5)List socket system calls?

int socket(int domain, int type, int protocol)

Domain: protocol family

Type: semantics of the communication

Linux Programming

Protocol: specific protocol

Connect to Server:

int connect(int sockfd, struct sockaddr *server_address, socketlen_t addrlen)

-1 if an error occurs

Sending data

-1 on error

Receiving data

o place the data, size of the buffer

-1 on error

Closing the socket

Bind socket to the local address and port

y_addr, socklen_t addrlen)

-1 if an error occurs

Define the number of pending connections

Linux Programming

d acceptable backlog

-1 on error

List is a summary of functions or methods provided by the Berkeley sockets

API library:

socket() creates a new socket of a certain socket type, identified by an

integernumber, and allocates system resources toit.

bind() is typically used on the server side, and associates a socket with

a socketaddress structure, i.e. a specified local port number and IPaddress.

listen() is used on the server side, and causes a bound TCP socket to enter

listeningstate.

connect() is used on the client side, and assigns a free local port

numberto a socket.In case of a TCP socket, it causes an attempt to

establish a new TCPconnection.

accept() is used on the server side. It accepts a received

incoming attempt to create a new TCP connection from the

remote client, and creates a new socket associated with the

socket address pair of thisconnection.

send() and recv(), or write() and read(), or sendto() and

recvfrom(), are used forsending and receiving data to/from a

remotesocket.

close() causes the system to release resources allocated to a

socket. In case of TCP,the connection isterminated.

gethostbyname() and gethostbyaddr() are used to resolve host

names and addresses.IPv4 only.

select() is used to pend, waiting for one or more of a

provided list of sockets to beready to read, ready to write, or

that haveerrors.

poll() is used to check on the state of a socket in a set of

sockets. The set can be testedto see if any socket can be

written to, read from or if an erroroccurred.

getsockopt() is used to retrieve the current value of a

Linux Programming

particular socket option forthe specifiedsocket.

setsockopt() is used to set a particular socket option for the

specifiedsocket.

Fill in the Blanks

1. Shared memory allows multiple processes to map a portion of their _____

addresses to a common memory region.

2. The ______ header defines a struct ipc_perm data type.

3. ______ API used to detach a shared memory from the process virtual address

space.

4. The shmget opens a shared memory whose ______ is specified in key argument.

5. A ______ can be addressed by a host Internet address or a port number.

6. Sockets may be ______ and _______.

7. _______ socket API used to assigns a name to a socket.

8. listen system call specifies the number of pending ______ messages that can be

queued for a ______ socket.

9. The socket function creates a socket of the specified ______, _______ and ______.

10. The connect system call is called in a client process in requesting a connection to a

______ socket.

1 Virtual 6 Connection based,

Connection less

2 Sys/ipc.h 7 Bind

3 Shmdt 8 Client, server

4 Key ID 9 Domain, type, protocol

5 Socket 10 server

Linux Programming

17. BEYOND SYLLABUS TOPICS WITH MATERIAL

Vi Editor

It's usually available on all the flavors of Unix system.

Its implementations are very similar across the board.

It requires very few resources.

It is more user-friendly than other editors such as the ed or the ex.

You can use the vi editor to edit an existing file or to create a new file from scratch. You

can also use this editor to just read a text file.

Starting the vi Editor

S.No. Command & Description

1 vi filename

Creates a new file if it already does not exist, otherwise opens an existing file.

2 vi -R filename

Opens an existing file in the read-only mode.

3 view filename

Opens an existing file in the read-only mode.

Following is an example to create a new file testfile if it already does not exist in the

$vi testfile

Linux Programming

|

~

~

~

~

~

~

~

~

~

~

~

~

"testfile" [New File]

You will notice a tilde (~) on each line following the cursor. A tilde represents an unused

line. If a line does not begin with a tilde and appears to be blank, there is a space, tab,

newline, or some other non-viewable character present.

You now have one open file to start working on. Before proceeding further, let us

understand a few important concepts.

Operation Modes

Command mode

saving the files, executing the commands, moving the cursor, cutting (yanking)

and pasting the lines or words, as well as finding and replacing. In this mode,

whatever you type is interpreted as a command.

Insert mode

typed in this mode is interpreted as input and placed in the file.

vi always starts in the command mode. To enter text, you must be in the insert mode for

which simply type i. To come out of the insert mode, press the Esc key, which will take

you back to the command mode.

Hint

Linux Programming

you to the command mode. You open a file using the vi editor. Start by typing some

characters and then come to the command mode to understand the difference.

Getting Out of vi

The command to quit out of vi is :q. Once in the 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.

The command to save the contents of the editor is :w. You can combine the above

command with the quit command, or use :wq and return.

The easiest way to save your changes and exit vi is with the ZZ command. When you

are in the command mode, type ZZ. The ZZ command works the same way as

the :wq command.

If you want to specify/state any particular name for the file, you can do so by specifying it

after the :w. For example, if you wanted to save the file you were working on as another

filename called filename2, you would type :w filename2 and return.

Moving within a File

To move around within a file without affecting your text, you must be in the command

mode (press Esc twice). The following table lists out a few commands you can use to


1 k

Moves the cursor up one line

2 j

Moves the cursor down one line

3 h

Linux Programming

Moves the cursor to the left one character position

4 l

Moves the cursor to the right one character position

vi is case-sensitive. You need to pay attention to capitalization when using the

commands.

Most commands in vi can be prefaced by the number of times you want the action

to occur. For example, 2j moves the cursor two lines down the cursor location.

There are many other ways to move within a file in vi. Remember that you must be in the

command mode (press Esc twice). The following table lists out a few commands to move

Given below is the list of commands to move around the file.

Control Commands

The following commands can be used with the Control Key to performs functions as

given in the table below

Given below is the list of control commands.

Editing Files

To edit the file, you need to be in the insert mode. There are many ways to enter the insert


1 i

Inserts text before the current cursor location

2 I

Inserts text at the beginning of the current line

Linux Programming

3 a

Inserts text after the current cursor location

4 A

Inserts text at the end of the current line

5 o

Creates a new line for text entry below the cursor location

6 O

Creates a new line for text entry above the cursor location

Deleting Characters

Here is a list of important commands, which can be used to delete characters and lines in


1 x

Deletes the character under the cursor location

2 X

Deletes the character before the cursor location

3 dw

Deletes from the current cursor location to the next word

4 d^

Deletes from the current cursor position to the beginning of the line

Linux Programming

5 d$

Deletes from the current cursor position to the end of the line

6 D

Deletes from the cursor position to the end of the current line

7 dd

Deletes the line the cursor is on

As mentioned above, most commands in vi can be prefaced by the number of times you

want the action to occur. For example, 2x deletes two characters under the cursor location

and 2dd deletes two lines the cursor is on.

It is recommended that the commands are practiced before we proceed further.

Change Commands

You also have the capability to change characters, words, or lines in vi without deleting


1 cc

Removes the contents of the line, leaving you in insert mode.

2 cw

Changes the word the cursor is on from the cursor to the lowercase w end of the word.

3 r

Replaces the character under the cursor. vi returns to the command mode after the

replacement is entered.

4 R

Linux Programming

Overwrites multiple characters beginning with the character currently under the

cursor. You must use Esc to stop the overwriting.

5 s

Replaces the current character with the character you type. Afterward, you are left in

the insert mode.

6 S

Deletes the line the cursor is on and replaces it with the new text. After the new text is

entered, vi remains in the insert mode.

Copy and Paste Commands

You can copy lines or words from one place and then you can paste them at another place


1 yy

Copies the current line.

2 yw

Copies the current word from the character the lowercase w cursor is on, until the end

of the word.

3 p

Puts the copied text after the cursor.

4 P

Linux Programming

Puts the yanked text before the cursor.

Advanced Commands

There are some advanced commands that simplify day-to-day editing and allow for more

Given below is the list advanced commands.

Word and Character Searching

The vi editor has two kinds of searches: string and character. For a string search,

the / and ? commands are used. When you start these commands, the command just typed

will be shown on the last line of the screen, where you type the particular string to look

for.

The / command searches forwards (downwards) in the file.

The ? command searches backwards (upwards) in the file.

The n and N commands repeat the previous search command in the same or the opposite

direction, respectively. Some characters have special meanings. These characters must be

preceded by a backslash (\) to be included as part of the search expression.

S.No. Character &Description

1 ^

Searches at the beginning of the line (Use at the beginning of a search expression).

2 .

Matches a single character.

3 *

Matches zero or more of the previous character.

Linux Programming

4 $

End of the line (Use at the end of the search expression).

5 [

Starts a set of matching or non-matching expressions.

6 <

This is put in an expression escaped with the backslash to find the ending or the

beginning of a word.

7 >

This helps see the '<' character description above.

The character search searches within one line to find a character entered after the

command. The f and F commands search for a character on the current line

only. f searches forwards and F searches backwards and the cursor moves to the position

of the found character.

The t and T commands search for a character on the current line only, but for t, the cursor

moves to the position before the character, and T searches the line backwards to the

position after the character.

Set Commands

You can change the look and feel of your vi screen using the following :setcommands.

Once you are in the command mode, type :set followed by any of the following

commands.


1 :set ic

Ignores the case when searching

Linux Programming

2 :set ai

Sets autoindent

3 :set noai

Unsets autoindent

4 :set nu

Displays lines with line numbers on the left side

5 :set sw

Sets the width of a software tabstop. For example, you would set a shift width of 4

with this command :set sw = 4

6 :set ws

If wrapscan is set, and the word is not found at the bottom of the file, it will try

searching for it at the beginning

7 :set wm

If this option has a value greater than zero, the editor will automatically "word wrap".

For example, to set the wrap margin to two characters, you would type this: :set wm =

2

8 :set ro

Changes file type to "read only"

9 :set term

Prints terminal type

10 :set bf

Linux Programming

Discards control characters from input

Running Commands

The vi has the capability to run commands from within the editor. To run a command, you

only need to go to the command mode and type :! command.

For example, if you want to check whether a file exists before you try to save your file

with that filename, you can type :! ls and you will see the output of lson the screen.

You can press any key (or the command's escape sequence) to return to your vi session.

Replacing Text

The substitution command (:s/) enables you to quickly replace words or groups of words

:s/search/replace/g

The g stands for globally. The result of this command is that all occurrences on the

cursor's line are changed.

Important Points to Note

You must be in command mode to use the commands. (Press Esc twice at any time

to ensure that you are in command mode.)

You must be careful with the commands. These are case-sensitive.

You must be in insert mode to enter text.

Opening multiple files with VI/VIM editor

To open multiple files, command would be same as is for a single file; we just add the file name for second file as well.

$ vi file1 file2 file 3

Now to browse to next file, we can use

$ :n

or we can also use

$ :e filename

Linux Programming

Run external commands inside the editor

We can run external Linux/Unix commands from inside the vi editor, i.e. without exiting the editor. To issue a command from editor, go back to Command Mode if in Insert mode & we

command is,

$ :! command

An example for this would be

$ :! df -H

Searching for a pattern

To search for a word or pattern in the text file, we use following two commands in command mode,

command searches the pattern in forward direction

command searched the pattern in backward direction

Both of these commands are used for same purpose, only difference being the direction they search in. An example would be,

$ :/ search pattern (If at beginning of the file)

$ search pattern (If at the end of the file)

14. ASSIGNMENT TOPICS WITH...

Documents

Transcript of 14. ASSIGNMENT TOPICS WITH...