LINUX PROGRAMMING FINAL NOTES UNIT 1ST
THESE NOTES ARE AS PER SYLLABUS & WILL HELP YOU TO ACHIEVE SUCCESS IN FINAL EXAM OF MCA 5TH SEMESTER.
LETS START: UNIT 1ST

Linux – The Operating System: Linux is one of popular version of UNIX operating System. It is open source as its source code is freely available. It is free to use. Linux was designed considering UNIX compatibility. It's functionality list is quite similar to that of UNIX. Linux is a free distributed implementation of a Unix-like Kernel Developed by Linus Torvalds at the University of Helsinki with the help of programmers across the Internet.
Linux history: *

Linux features:
Following are some of the important features of Linux Operating System. * Portable - Portability means softwares can works on different types of hardwares in same way.Linux kernel and application programs supports their installation on any kind of hardware platform. * Open Source - Linux source code is freely available and it is community based development project. Multiple teams works in collaboration to enhance the capability of Linux operating system and it is continuously evolving. * Multi-User - Linux is a multiuser system means multiple users can access system resources like memory/ ram/ application programs at same time. * Multiprogramming - Linux is a multiprogramming system means multiple applications can run at same time. * Hierarchical File System - Linux provides a standard file structure in which system 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 programs etc. * Security - Linux provides user security using authentication features like password protection/ controlled access to specific files/ encryption of data.

Linux distributions: 1. .Ubuntu, a popular desktop and server distribution derived from Debian, maintained by Canonical Ltd..
2.Kubuntu, the KDE version of Ubuntu.
3.Linux Mint, a distribution based on and compatible with Ubuntu.
4.Xubuntu, is the Xfceversion of the popular desktop distroUbuntu.
Commonly used by Linux users that wish to have the function of a bigger distrosuch as Ubuntu or openSusewith the speed of a smaller distro. 5.Fedora,a community distribution sponsored by Red Hat
6.CentOS, a distribution derived from the same sources used by Red Hat, maintained by a dedicated volunteer community of developers.
7.Mandriva, a Red Hat derivative popular in France and Brazil, today maintained by the French company of the same name.
8.PCLinuxOS, a derivative of Mandriva, grew from a group of packages into a community-spawned desktop distribution.
Linux’s relationship to Unix:
What is the difference between Linux and UNIX operating systems?
UNIX is copyrighted name only big companies are allowed to use the UNIX copyright and name, so IBM AIX and Sun Solaris and HP-UX all are UNIX operating systems. The Open Group holds the UNIX trademark in trust for the industry, and manages the UNIX trademark licensing program.
Most UNIX systems are commercial in nature.
Linux is a UNIX Clone:
But if you consider Portable Operating System Interface (POSIX) standards then Linux can be considered as UNIX. To quote from Official Linux kernel README file:
Linux is a Unix clone written from scratch by Linus Torvalds with assistance from a loosely-knit team of hackers across the Net. It aims towards POSIX compliance.
However, "Open Group" do not approve of the construction "Unix-like", and consider it misuse of their UNIX trademark. Linux is just a kernel. All Linux distributions includes GUI system + GNU utilities (such as cp, mv, ls,date, bash etc) + installation & management tools + GNU c/c++ Compilers + Editors (vi) + and various applications (such as Open Office, Firefox). However, most UNIX operating systems are considered as a complete operating system as everything come from a single source or vendor.
As I said earlier Linux is just a kernel and Linux distribution makes it complete usable operating systems by adding various applications. Most UNIX operating systems comes with A-Z programs such as editor, compilers etc. For example HP-UX or Solaris comes with A-Z programs.
Overview of Linux architecture:

Linux System Architecture is consists of following layers * Hardware layer - Hardware consists of all peripheral devices (RAM/ HDD/ CPU etc). * Kernel - Core component of Operating System, interacts directly with hardware, provides low level services to upper layer components. - Kernel is the core part of Linux. It is responsible for all major activities of this operating system. It is consists of various modules and it interacts directly with the underlying hardware. Kernel provides the required abstraction to hide low level hardware details to system or application programs * Shell - An interface to kernel, hiding complexity of kernel's functions from users. Takes commands from user and executes kernel's functions. * Utilities - Utility programs giving user most of the functionalities of an operating systems

Installation: Installation is a practicle work please do it yourself.
Start up scripts:
System Lifecycle: Ups & Downs: * Booting * Kernel Initialization * init: Process Number One * Shutdown * Advanced Boot Concepts * Power Management start_kernel Power on Power off Boot
Kernel
Init
OS
Init
RUN!
Shut down init shutdown LILO sleep? (hlt)

The following are the 6 high level stages of a typical Linux boot process.

* MBR: MBR stands for Master Boot Record. * It is located in the 1st sector of the bootable disk. Typically /dev/hda, or /dev/sda * MBR is less than 512 bytes in size. This has three components 1) primary boot loader info in 1st 446 bytes 2) partition table info in next 64 bytes 3) mbr validation check in last 2 bytes. * It contains information about GRUB (or LILO in old systems).
So, in simple terms MBR loads and executes the GRUB boot loader
GRUB: Grand Unified Bootloader: * GRUB is an operating system independent boot loader * A multiboot software packet from GNU * Flexible command line interface * File system access * Support multiple executable format * Support diskless system
Download OS from network
LILO: LInux Loader: * Not depend on a specific file system * Can boot from harddisk and floppy * Up to 16 different images * Must change LILO when kernel image file or config file is changed

* Kernel Initializtion: Linux Kernel is is itself a program, and the first bootstraping task is to get this program into memory so that it is executed. * The kernel is the central part in most computer operating systems because of its task, which is the management of the system's resources and the communication between hardware and software components * Kernel is always store on memory until computer is turn off * Kernel image is not an executable kernel, but a compress kernel image * zImage size less than 512 KB * bzImage size greater than 512 KB

Init process: * The first thing the kernel does is to execute init program * Init is the root/parent of all processes executing on Linux * The first processes that init starts is a script /etc/rc.d/rc.sysinit * Based on the appropriate run-level, scripts are executed to start various processes to run the system and make it functional Runlevel * A runlevel is a software configuration of the system which allows only a selected group of processes to exist * The processes spawned by init for each of these runlevels are defined in the /etc/inittab file * Init can be in one of eight runlevels: 0-6

To Summarize: Boot sequence: * Load hardware information from BIOS * Read MBR’s Kernel Loader (master boot record) * For Linux, goto boot (kernel with /boot/vmlinuz-xxxx * For DOS, goto boot.ini * Load Linux kernel * Execute init program (/sbin/init)to get run-level details (contains in /etc/inittab) * There are 6 levels * init execute /etc/rc.d/rc.sysinit * Start kernel external model (/etc/modules.conf) * init execute run-level’s scripts files * init execute /etc/rc.d/rc.local files； * execute /bin/login program； * After successful login, shell take over the machine Linux Security: * Administering Passwords: Attacks from your own system users.
Precautions to secure Linux System: * Learn how to implement safety measures & take a proactive approach. * Know how to fix the system and clean-up after a suspected break-in. * Be able to prevent any future security breaches.
Keeping Users in Check: Creating and keeping the passwords up to date. * Aging Measures After a certain period of time, users need to issue the system a new password. * Encrypt Password Files Using gpasman program
Securing Shell with ssh:
An encrypted connection from one machine to another that prevents a mediocre cracker from gaining too much information from the connection. * The ssh utility runs as a background daemon and should be started upon bootup. * The daemon files are located in /usr/local/ sbin

The Ext2 and Ext3 File systems:
The ext2 or second extended filesystem is a file system for the Linux kernel.
 It was initially designed by Rémy Cardas a replacement for the extended file system (ext).
 Theext3 or third extended file system is a journaled file system that is commonly used by the Linux kernel.
 It is the default file system for many popular Linux distributions.
 Stephen Tweedie first revealed that he was working on extending ext2 in Journaling the Linux .
The space in ext2 is split up into blocks. These blocks are grouped into block groups, analogous to cylinder groups in the Unix File System. There are typically thousands of blocks on a large file system. Data for any given file is typically contained within a single block group where possible. This is done to minimize the number of disk seeks when reading large amounts of contiguous data.
Each block group contains a copy of the superblock and block group descriptor table, and all block groups contain a block bitmap, an inode bitmap, an inode table and finally the actual data blocks. Thesuperblock contains important information that is crucial to the booting of the operating system. Thus backup copies are made in multiple block groups in the file system. However, typically only the first copy of it, which is found at the first block of the file system, is used in the booting.

Ext3 Filesystem: Ext3, or third extended file system, is a journaled file system that is commonly used by the Linux kernel. • It is the default file system for many popular Linux distributions, including Debian. • Its main advantage over ext2 is journaling, which improves reliability and eliminates the need to check the file system after an unclean shutdown. –A log of file system actions is maintained –In case a crash occurs, the actions recorded in a journal file are replayed to restore the system to a stable state –Avoids lengthy file system checks Journal (lowest risk) Both metadata and file contents are written to the Journal before being committed to the main file system. Because the journal is relatively continuous on disk, this can improve performance, if the journal has enough space. In other cases, performance gets worse, because the data must be written twice— once to the journal, and once to the main part of the filesystem. Linux file System:

* / * This is referred to as the root directory. It's the baseline for the directory structure, which is important when navigating from one directory tree to another. *
This is a virtual directory where your devices are 'stored.' Devfs allows Linux to list devices (hard drives, input devices, modems, sound cards, etc.) as 'files.'

/etc/

This is where you'll find all your global settings. Daemons such as ssh, telnet, and smtp/pop3 mail servers find their configuration files here. Also in /etc/ is the system's password file, group lists, user skeletons, and cron jobs.

/home/

This is the default directory where non-root users' homes are created. When you add a user, the default home directory is created as /home/username. You can change this default in the proper file in /etc/.

/lib/

This is where shared libraries (perl, python, C, etc.) are stored. Also in /lib/ are your kernel modules.

/mnt/

This is the default location for mounting cdroms, floppy disk drives, USB memory sticks, etc. You can mount anything anywhere, but by default there is a /mnt/floppy (if you have a floppy drive) and /mnt/cdrom.

/proc/

This virtual folder contains information about your system. You can view processor statistics/specifications, PCI bus information, ISA bus information, and pretty much anything else you want to know about the hardware on your system.

/root/

This is the default home directory for the user root.

/sbin/

This is where system programs are installed. These include fdisk, tools to make partitions, certain network tools, and other things that normal users shouldn't have a need for.

/tmp/

This is the default location to place files for temporary use. When you install a program, it uses /tmp/ to put files during installation that won't be needed once the program is installed.

/usr/

This contains various programs, non-daemon program settings and program resources.

/var/

This is where your log files, system mail messages and database of installed programs are stored. File Permission: ls -l file mode (permissions): Quoting from the unix ls command man page -the file mode printed under the -l option consists of the entry type and the permissions. The entry type character describes the type of file, as follows: -Regular file. • b Block special file. • c Character special file. • d Directory l Symbolic link. • p FIFO. • s Socket. • w Whiteout. Files are owned by both a user and a group and other • Each file has 3 sets of permissions –Permissions for the user who owns it (user permissions) –Permissions for the group that owns it (group permissions) –Permissions for everyone else (‘other’ or ‘world’ permissions) • There are 3 types of permissions –Read--controls ability to read a file –Write--controls ability to write or change a file –Executable--controls whether or not a file can be executed as a program Symbolic Codes: Examples chmod u+x filename • chmod u+x, g+w filename • chmod ug+x filename • chmod a-w filename • chmod u=rw filename • Chmod 777 a.c • Chmod 700 a.c • Chmod 421 a.c User Management: The command can be used in order to –Create a new user –Set the default set of attributes for new user –Get the default set of attributes for new user –While adding a user, the values in • /etc/login.defs • Default settings made by useradd itself are used for deciding attributes of a new user –New values provided on command line override the Defaults Add a user: Options: • -dhome directory • -sstarting program (shell) • -ppassword • -g(primary group assigned to the users) • -G(Other groups the user belongs to) • -m(Create the user's home directory Modify a user: usermod -Modifying existing user options: • -dhome directory • -sstarting program (shell) • -ppassword • -g(primary group assigned to the users) • -G(Other groups the user belongs to) : Delete a user: Options: • -r(remove home directory) Example: To remove the user 'roger' and his home directory userdel -r roger Add a user through GUI: Use user drakecommand in run.

UNIT 2ND
Resource Management in Linux: file and directory management;
-------------------------------------------------
Linux Directory Hierarchy:
-------------------------------------------------
The Linux operating system, like all versions of UNIX, uses an hierarchical file system, in which files and directories are arranged logically in an inverted tree structure. The root directory generally contains the following sub-directories, although some may be specific only to the University of Calgary's IT Linux system
-------------------------------------------------

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

-------------------------------------------------
Linux Directory and File Naming Conventions
Linux adheres to the following rules for file and directory names: * A file or directory name can have from 1 to 256 characters in length. * Linux is case sensitive -- uppercase characters are different from lowercase characters. * File or directory names can include letters, numbers, and the following special characters: period ( . ), underscore ( _ ), and dash ( - ). * The special characters comma ( , ), quotes ( ' , " , or ` ), slash ( / ), backslash ( \ ) and space can be used in file or directory names, but are highly advised against. * The directory you are working in at any given point is called your current or working directory. To print the name of your working directory, try the following on your Linux prompt: * type: pwd
You should see something similar to: /lu101/username * When you first log in, your working directory is your home directory, and usually takes a form similar to the above example, where username is your IT username. The text displayed by the pwd command is the pathname of your working directory, and in this example specifies a directory named username, contained in the directory /lu101, which itself is in the root directory. This pathname, beginning from the root directory ( / ), is an absolute pathname. A relative pathname is specified relative to some other directory in the file system, depending on the characters at the beginning of the supplied pathname:

-------------------------------------------------
Working with Linux Directories: change to a different working directory, type: cd directory_name where directory_name is the pathname of the directory you want to switch to. The syntax of directory_name can take several forms. Examine the following examples to see how to change directories: cd /lu101/username | Absolute pathname. In this example specifying the sub-directory username in thelu101 directory from the root ( / ) | Cd | Return to the home directory (/lu101/username in this example) | cd text | Relative pathname specifying the subdirectory text (/lu101/username/text) | cd .. | The home directory (/lu101/username) | cd ../.. | The root directory (/) | cd ~/text | Absolute pathname specifying the subdirectory text in the home directory (/lu101/username/text) |

To create a new directory, type: mkdir directory_name where directory_name is the absolute or relative pathname of the new directory. You must have write permission on the first directory. If you do not have the required permission, you will get the following error message: mkdir: The file access permissions do not allow the specified action.
The new directory will be created, giving you read, write, and execute permission, and no permissions for anyone else. Refer to Controlling Linux File and Directory Access for a detailed discussion of Linux file and directory permissions.
To move a directory to a new location in the directory hierarchy, type: mv directory_name new_location where directory_name andnew_location can be either absolute or relative pathnames. You must have write and execute permission for new_location and the directory containing directory_name.

To delete a directory, type: rmdir directory_name where directory_name must be an empty directory. If you try to delete a directory that contains files or other directories, you will get the following error message: rmdir: Directory directory_name is not empty.
-------------------------------------------------

-------------------------------------------------
Managing Linux Files:
-------------------------------------------------

Directories are not very useful without files to put in them. To list the names of the files and sub-directories in a directory, type ls . The contents of your working directory will be listed in several columns, like this: file.txt | file01.txt | file50.txt | untitled.txt | file01.data | file02.txt | text | |

To list all the files and directories, type ls -a . . | .bash_profile | file01.txt | text | .. | file.txt | file02.txt | untitled.txt | .bash_history | file01.data | text50.txt | |
This listing includes files and directories whose names begin with a period ( . ). Files and directories which start with a period usually contain information relating to the functioning of Linux itself, rather than your work, and can often be ignored.

You can also display text files within Linux. Here are four commands, each processing the output in a different way: * To display the file contents on your screen, with no page breaks or scrolling control, type cat filename * To display the file on your screen, with page breaks, but no scrolling control, type pr filename * To display the file on your screen, one screenful at a time, type more filename * To display the file on your screen, one screenful at a time but with scrolling control, type less filename

more can also be used to display the text from the other commands one screenful at a time. To display the file on your screen, with page breaks and scrolling control, type: pr filename | more . This sends the output of the pr command to the more command, which displays it one screen at a time.

To move a file to another directory or to a file with a different name (renaming a file), use the mv command: mv old_file new_file . For example, to rename the file chapter_1.txt to introduction.txt, type: mv chapter_1.txt introduction.txt . To move the file abstract.ps from your working directory to the subdirectory named thesis, type: mv abstract.ps thesis/abstract.ps . Since the same filename is used for the new file, you can shorten the command to: mv abstract.ps thesis/ .
The mv command deletes the original file, so if you want to make a copy of a file, use the cp (for copy) command. The copy of the file must have a different name or be in a different directoy. For example, to copy the file named motd from its system location to a file namedmessage.txt in your working directory, type: cp /usr/local/motd/motd message.txt.
-------------------------------------------------

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

system calls for files:
The functions which change the execution mode of the program from user mode to kernel mode are known as system calls. These calls are required in case some services are required by the program from kernel. For example, if we want to change the date and time of the system or if we want to create a network socket then these services can only be provided by kernel and hence these cases require system calls.
For example, socket() is a system call.
Interaction between components:

System calls acts as entry point to OS kernel:
There are certain tasks that can only be done if a process is running in kernel mode. Examples of these tasks can be interacting with hardware etc. So if a process wants to do such kind of task then it would require itself to be running in kernel mode which is made possible by system calls. • There are library functions that do not make any system call. For example, the string manipulation functions like strlen() etc fall under this category. • Also, there are library functions that further make system calls, for example the fopen() function which a standard library function but internally uses the open() sytemcall.
Process:
• A running instance of a program is called a process.
• Each process in a Linux system is identified by its unique process ID,sometimes referred to as pid.
• Process IDs are 16-bit numbers that are assigned sequentially by Linux as new processes are created.
• Every process also has a parent process (except the special init process).
• The parent process ID, or ppid, is simply the process ID of the process’s parent.
• When referring to process IDs in a C or C++ program, always use the pid_t typedef, which is defined in <sys/types.h>.
Printing the Process ID:
#include <stdio.h>
#include <unistd.h> int main ()
{
printf(“The process ID is %d\n”, (int) getpid()); printf(“The parent process ID is %d\n”, (int) getppid()); return 0; }
Fork() system call: >The system call fork() is used to create new processes. >It does not take any arguments and returns a process ID. >The purpose of fork() is to create a new process, which becomes the child process of the caller (which is called the parent). >After a new child process is created, both processes will execute the next instruction following the fork() system call. We can distinguish the parent from the child by testing the returned value of fork() >Therefore, the parent and child processes will have separate address spaces. Both processes start their execution right after the system call fork(). * If fork() returns a negative value, the creation of a child process was unsuccessful. * A call to fork() returns a zero to the newly created child process and the same call to fork() returns a positive value (the process ID of the child process) to the parent. * The returned process ID is of type pid_t defined in sys/types.h. Normally, the process ID is an integer. * 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 request from a client. When the request arrives, The parent calls fork and lets the child handle the request. The parent goes back for the next service request to arrive. * When a process wants to execute a different program. This is common for shells. In this case,child does an exec right after the fork * Some OS combine the operations into a single opertaion called a spawn. * Unix separates the two
Using the exec Family:
The exec functions replace the program running in a process with another program. When a program calls an exec function, that process immediately ceases executing that program and begins executing a new program from the beginning, assuming that the exec call doesn’t encounter an error. exec will replace the contents of the currently running process with the information from a program binary.
Signals:
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.
• Each signal type is specified by its signal number, but in programs, you usually refer to a signal by its name.
• In Linux, these are defined in /usr/include/bits/signum.h. (You shouldn’t include this header file directly in your programs; instead, use <signal.h>.)
• A process may also send a signal to another process. One common use of thismechanism is to end another process by sending it a SIGTERMor SIGKILLsignal.
IPC:
Interprocess communication (IPC) is the transfer of data among processes. For example,
A Web browser may request a Web page from a Web server, which then sends HTML data. This transfer of data usually uses sockets in a telephone-like connection.
In another example, you may want to print the filenames in a directory using a command such as ls | lpr.
Types of Interprocess Communication:
1,Shared memor ypermits processes to communicate by simply reading and writing to a specified memory location.
2. Mapped memory is similar to shared memory, except that it is associated with a file in the filesystem.
3. Pipes permit sequential communication from one process to a related process.
4. FIFO sare similar to pipes, except that unrelated processes can communicate because the pipe is given a name in the filesystem.
5. Sockets support communication between unrelated processes even on different computers.
Explanation:
Signals
Signals are one of the oldest inter-process communication methods used by Unix TM systems. They are used to signal asynchronous events to one or more processes. A signal could be generated by a keyboard interrupt or an error condition such as the process attempting to access a non-existent location in its virtual memory. Signals are also used by the shells to signal job control commands to their child processes.
There are a set of defined signals that the kernel can generate or that can be generated by other processes in the system, provided that they have the correct privileges. You can list a system's set of signals using the killcommand (kill -l)
Pipes
A pipe is a communication device that permits unidirectional communication.
• Data written to the “write end” of the pipe is read back from the “read end.”
• Pipes are serial 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. #include <unistd.h> int pipe(int filedes[2]);

The common Linux shells all allow redirection. For example $ ls | pr | lpr pipes the output from the ls command listing the directory's files into the standard input of the pr command which paginates them. Finally the standard output from the pr command is piped into the standard input of the lprcommand which prints the results on the default printer. Pipes then are unidirectional byte streams which connect the standard output from one process into the standard input of another process. Neither process is aware of this redirection and behaves just as it would normally. It is the shell which sets up these temporary pipes between the processes.
Named pipe (FIFO): For communication between related or unrelated processes on a system.

A first-in, first-out (FIFO) file is a pipe that has a name in the filesystem. Any process can open or close the FIFO; the processes on either end of the pipe need not be related to each other. FIFOs are also called named pipes. You can make a FIFO using the mkfifocommand. Specify the path to the FIFO on the command line. For example, create a FIFO in /tmp/fifo by invoking this:
% mkfifo /tmp/fifo
% ls -l /tmp/fifo prw-rw-rw-1 samuel users 0 Jan 16 14:04 /tmp/fifo
System V IPC Mechanisms
Linux supports three types of interprocess communication mechanisms that first appeared in Unix TM System V (1983). These are message queues, semaphores and shared memory. These System V IPC mechanisms all share common authentication methods. Processes may access these resources only by passing a unique reference identifier to the kernel via system calls. Access to these System V IPC objects is checked using access permissions, much like accesses to files are checked. The access rights to the System V IPC object is set by the creator of the object via system calls. The object's reference identifier is used by each mechanism as an index into a table of resources. It is not a straight forward index but requires some manipulation to generate the index.
All Linux data structures representing System V IPC objects in the system include an ipc_perm

Message Queues
Message queues allow one or more processes to write messages, which will be read by one or more reading processes. Linux maintains a list of message queues, the msgque vector; each element of which points to amsqid_ds data structure that fully describes the message queue. When message queues are created a new msqid_ds data structure is allocated from system memory and inserted into the vector.
Semaphores
In its simplest form a semaphore is a location in memory whose value can be tested and set by more than one process. The test and set operation is, so far as each process is concerned, uninterruptible or atomic; once started nothing can stop it. The result of the test and set operation is the addition of the current value of the semaphore and the set value, which can be positive or negative. Depending on the result of the test and set operation one process may have to sleep until the semphore's value is changed by another process. Semaphores can be used to implement critical regions, areas of critical code that only one process at a time should be executing.
Shared Memory
Shared memory allows one or more processes to communicate via memory that appears in all of their virtual address spaces. The pages of the virtual memory is referenced by page table entries in each of the sharing processes' page tables. It does not have to be at the same address in all of the processes' virtual memory. As with all System V IPC objects, access to shared memory areas is controlled via keys and access rights checking. Once the memory is being shared, there are no checks on how the processes are using it. They must rely on other mechanisms, for example System V semaphores, to synchronize access to the memory.

system calls for processes: fork() function call returned different values for each process. For the parent, fork() returned the PID of the child; for the child, fork() returned 0. If the fork() fails, then -1 is returned in the parent process (the only one running since the fork failed)
2) exec family replace currently executing code with called code Note that when we run the execdemo example, we do not see the line “Did it work?”. This is because the execvp() function call replaced the code being executed in the current process with the program “ls –l”. Once the program “ls –l” is done, our program is done, because that is the code it is now executing. You can think of the process as a container that is running some code (any code). When we call an exec() function, we replace the existing code with new code of our choice.
3) wait() – parent process suspends, waiting for child process to finish In addition to waiting for the child to finish, the wait() function returns information about the child process. The return value for wait() is the child’s PID. The single parameter passed back is the address of an int (32 bits), portions of which provide the exit()/return() value of the child process, whether or not it dumped core, and the signal ID if a signal was used to terminate the child process. system() – pause calling program until called program complete
Memory Management:
Memory management is the heart of operating systems; it is crucial for both programming and system administration. In the next few posts I’ll cover memory with an eye towards practical aspects, but without shying away from internals. While the concepts are generic, examples are mostly from Linux and Windows on 32-bit x86. This first post describes how programs are laid out in memory. Each process in a multi-tasking OS runs in its own memory sandbox. This sandbox is the virtual address space, which in 32-bit mode is always a 4GB block of memory addresses.

UNIT 3RD
Shell Programming: * Shell is a user level program .It is an command language interpreter that executes commands read from the standard input device (keyboard) or from a file. * It is not part of system kernel, but uses the system kernel to execute programs, create files etc. * In MS-DOS, Shell name is COMMAND.COM which is also used for same purpose, but it's not as powerful as Linux Shells are! Common Shells:

BASH SHELL * Bash is the shell, or command language interpreter, for the GNU operating system. The name is an acronym for the `Bourne-Again SHell', a pun on Stephen Bourne, the author of the direct ancestor of the current Unix shell /bin/sh, which appeared in the Seventh Edition Bell Labs Research version of Unix. * Bash is largely compatible with sh and incorporates useful features from the Korn shell ksh and the C shell csh. It is intended to be a conformant implementation of the IEEE POSIX Shell and Tools specification (IEEE Working Group 1003.2). It offers functional improvements over sh for both interactive and programming use.

Shell: Responsibilities: * Command Interpretation * Providing a scripting language * A process that provides runtime environment. Control the environment provided by the shell Set via any of the following activities * During the time when boot sequence is executing * After user logs in through login scripts * As a result of scripts executed after login * Interactively by user Also known as Environment / System variables Each shell variable is used for a specific purpose A shell variable is typically entered in uppercase To get its value, you precede the shell variable name with a $, as in $PATH The set command shows the complete list Examples of shell variables: * PWD – the most recent working directory set with the cd command * OLDPWD – the previous working directory set with the cd command * BASH – the full path of the bash shell * RANDOM – generates a random number between 0 and 32,767 * HOSTNAME – the current hostname of a Linux system * IFS – Internal Field Separator, which is used as a separator between shell words * PATH – contains the list of directories used to search for commands when executing them * HOME – each user’s home directory, typically /home/username, where username is a user’s login name Shell Scripts: Normally shells are interactive i.e. shell accept command from you (via keyboard) and execute them. But if required a set of related commands can be run by storing them to text file and telling the shell to execute this text file. This is known as shell script. Definition: * "Shell Script is series of command written in plain text file. Shell script is just like batch file is MS-DOS but have more power than the MS-DOS batch file." * Shell script can take input from user, file and output them on screen. * Useful to create our own commands. * Multiple commands can be bound by means of control constructs to define a logical flow of control. * Used in order to automate some task of day to day life or carry out System Administration activities. Filters: * One class of programs you can use with pipes is called filters. * Filters take standard input and perform an operation upon it and send the results to standard output. In this way they can be used to process information in powerful ways. Here are some of the common programs that can act as filters

* Where does the name come from? * :g/RE/p * globally regular expression print * How it works? * grep looks inside file(s) and returns any line that contains the string or expression * prints lines matching a pattern to STDOUT grep examples: * grep Pattern * grep Pattern filename * Ex. grep ‘permission’ thisFile * grep pattern file1 file2 * Ex. grep ‘permission’ file1 file2 * file1: * file2: * If grep cannot find a line in any of the specified files that contain the requested pattern, no output is produced. * $? is set to 0 * if grep finds something * $? is set to 1 * if grep finds nothing * $? is set to 2 * if one of the input file cannot be found. * * The general format: * grep [options] PATTERN [FILE…] grep Options: * i: ignore case * grep –i unix filename * -n: list line numbers along with the matching line * [File:]lineNumber:theLine * -v: invert match * grep –v ‘#’ /etc/hosts * Produces a list of all the lines in /etc/hosts that do not contain the # character. * ps –ef | grep tborrelli | grep –v grep sed: string replacement: * Line-oriented tool for pattern matching and replacement (stream editor) * Not really a programming language (cf. awk) * E.g., apply same change to lots of source files * Filter, i.e., does not modify input file * pattern a text add to output * address s /regex/replacement/ * address d delete line * delete lines 1-10: sed -e '1,10d‘ * delete comments: sed -e '/^#/d‘ * print only matching: sed -n -e '/regexp/p * convert Unix to DOS: sed -e 's/$/\r/' myunix.txt > mydos.txt awk: * Special-purpose language for line-oriented pattern processing * pattern {action} * action = * if (conditional) statement else statement * while (conditional) statement * break * continue * variable=expression * print expression-list awk examples: * Add up first column, print sum and average
{s += $1 }
END {print “sum is”, s, “average is”, s/NR} * Print all lines between start/stop words: /start/,/stop/ * Print all lines whose first field differs from previous one: $1 != prev {print; prev = $1}

UNIT 4TH
Networking in LINUX:
What are sockets? * An end-point for a network connection * used for interprocess communication * Server and Client exchange messages over the network through a common Socket API * Language and protocol independent * To the kernel, a socket is an endpoint of communication * To an application, a socket is a file descriptor that lets the application read/write from/to the network * Clients and servers communicate with each by reading from and writing to socket descriptors. • Remember: All Unix I/O devices, including networks, are modeled as files socket() FUNCTION: int socket(int family,int type,int proto); * Family is * AF_INET (for IPv4) * AF_INET6 (for IPv6) * PF_INET (for TCP/IP) * Type specifies the type of service * SOCK_STREAM (for TCP) * SOCK_DGRAM (for UDP) * Protocol specifies the specific protocol * usually 0, which means the default * The socket() system call returns a socket descriptor (small integer) or -1 on error * socket() allocates resources needed for a communication endpoint - but it does not deal with endpoint addressing

Two types of sockets:

Client Server Connection using Socket:

System calls for establishing a connection:
Elementary TCP Sockets: bind(): * The bind() system call is used to assign an address to an existing socket * bind() returns 0 if successful or -1 on error * sockfd is socket descriptor from socket() * myaddr is a pointer to address struct with port number and IP address addrlen is length of structure listen(): int listen(int sockfd, int backlog); * listen() accepts a connection request * sockfd is socket descriptor from socket() * backlog is maximum number of incomplete connections accept() int accept(int sockfd,struct sockaddr cliaddr,socklen_t *addrlen); * Accepts a connection on a socket * sockfd is socket descriptor from socket() * cliaddr and addrlen return protocol address from client connect() int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen); * Used to connect to a server * sockfd is socket descriptor from socket() * servaddr is a pointer to a structure with port number and IP address * addrlen is length of structure * returns socket descriptor if ok, -1 on error close() int close(int sockfd); * Close socket for use

TCP Client server Example
Socket programming with TCP :