week5 - web viewas unix is a multiuser operating system which involves many users can work...

Unix Internals Lab

UNIX INTERNAL LAB PROGRAMS (JNTU SYLLABUS) - VOLUME 1

Week 1

a) To write a program to display environment variables.b) To write a program implement different types of functions of exec family

Week 2

a) To write a program to implement creation of stream

b) To write a program to read and write a stream in a file. c) To write a program to implement to position a stream.Week 3a) To write a program to implement adding, modifying & deleting a record in a fileb) To write a program to find the status of a file.

Week 4 Write a Program that takes certain file names along the command line arguments and remove if there exists any duplicates

Week5 To Write a Program to find whether the file is having read, write, execute permissions and also check whether a given name is file or directory

Week 6

To create chain of processes

Week 7

Write a program to

(a) Create semaphores b)Set values to semaphores

c)Get values from semaphores d)Remove semaphores

Department of CSE,MITS,Madanapalle

Unix Internals Lab

Week 8

To write a program implement message queue

Week 9

Write a program to

(a) Create shared memory

(b) Write to shared memory

(c) Read from shared memory

Week 10

Write a program which takes a source file name and directory name as command line argument and print a message ‘YES’, if the file is found in the given directory


Unix Internals Lab

Week 1 a)

AIM: To write a program to display environment variables.DESCRIPTION:

As UNIX is a multiuser operating system which involves many users can work simultaneously on a server and server maintains all the details of each user known as “User Environment”.

The environment variables give several properties of user. Some of them are:HOSTNAMEIt gives the name the host computer i.e., user computer name.SHELL It gives the location of the shell in server.SSH_CLIENTIt gives the IP address and port number with which the user(client) was connected.HIST_SIZE It gives the size of the user history which had been maintained.USER It gives the user name.MAIL It gives the mailing information of the user.PATHIt gives the absolute path of the user working directory(from root).PWD It gives the path of user’s present working directory.LOGNAME It gives the login name of the user with which the user had logined.OLDPWD It gives the directory within which the present working directory of the user presents.

SOURCE CODE://This program is to display environment variables#include<stdio.h>void main(argc,argv,envp)int argc;char *argv[];char *envp[];{

int i;for(i=0;envp[i]!=(char*)0;i++)printf("\n%s",envp[i]);

}


Unix Internals Lab

INPUT/OUTPUT:HOSTNAME=linuxsr.mits.comSELINUX_ROLE_REQUESTED=TERM=xtermSHELL=/bin/bashHISTSIZE=1000SSH_CLIENT=172.16.2.18 1291 22SELINUX_USE_CURRENT_RANGE=QTDIR=/usr/lib/qt-3.3OLDPWD=/home/11695A0510QTINC=/usr/lib/qt-3.3/includeSSH_TTY=/dev/pts/111USER=11695A0510LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=01;05;37;41:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lz=01;31:*.xz=01;31:*.bz2=01;31:*.tbz=01;31:*.tbz2=01;31:*.bz=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.axv=01;35:*.anx=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=01;36:*.au=01;36:*.flac=01;36:*.mid=01;36:*.midi=01;36:*.mka=01;36:*.mp3=01;36:*.mpc=01;36:*.ogg=01;36:*.ra=01;36:*.wav=01;36:*.axa=01;36:*.oga=01;36:*.spx=01;36:*.xspf=01;36:MAIL=/var/spool/mail/11695A0510PATH=/usr/lib/qt-3.3/bin:/usr/lib/ccache:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/home/11695A0510/binPWD=/home/11695A0510/UnixLabLANG=en_US.UTF-8KDE_IS_PRELINKED=1KDEDIRS=/usrSELINUX_LEVEL_REQUESTED=SSH_ASKPASS=/usr/libexec/openssh/gnome-ssh-askpass


Unix Internals Lab

HISTCONTROL=ignoredupsSHLVL=1HOME=/home/11695A0510LOGNAME=11695A0510QTLIB=/usr/lib/qt-3.3/libCVS_RSH=sshSSH_CONNECTION=172.16.2.18 1291 172.16.0.251 22LESSOPEN=|/usr/bin/lesspipe.sh %sG_BROKEN_FILENAMES=1

Week 1 b):


Unix Internals Lab

AIM: To write a program implement different types of functions of exec family.

DESCRIPTION:

The’exec’ family of functions, for executing a file as a process image. You can use these functions to make a child process execute a new program after it has been forked. They are declared in the header file’unistd.h’.

execl(): int execl (const char *FILENAME, const char *ARG0, ...)This is similar to’execv', but the ARGV strings are specified individually instead of as an

array. A null pointer must be passed as the last such argument.

execv(): int execv (const char *FILENAME, char *const ARGV[])The’execv’ function executes the file named by FILENAME as a new process image.

The ARGV argument is an array of null-terminated strings that is used to provide a value for the ’argv’ argument to the’main’ function of the program to be executed. The last element of this array must be a null pointer.

execle(): int execle (const char *FILENAME, const char *ARG0, char *const ENV[], ...) This is similar to ‘execl’, but permits you to specify the environment for the new

program explicitly. The environment argument is passed following the null pointer that marks the last ARGV argument, and should be an array of strings in the same format as for the ’environ’ variable.

execlp(): int execlp (const char *FILENAME, const char *ARG0, ...) This function is like ’execl’, except that it performs the same file name searching as the ’execvp’ function.

execve ():int execve (const char *FILENAME, char *const ARGV[], char *const ENV[]) This is similar to ’execv’, but permits you to specify the environment for the new

program explicitly as the ENV argument. This should be an array of strings in the same format as for the ’environ’ variable;

execvp():int execvp (const char *FILENAME, char *const ARGV[]) The ’execvp’ function is similar to ’execv’, except that it searches the directories listed

in the ’PATH’ environment variable (*note Standard Environment::) to find the full file name of a file from FILENAME if FILENAME does not contain a slash. This function is useful for executing system utility programs, because it looks for them in the places that the user has chosen. Shells use it to run the commands that user’s type.

SOURCE CODE:


Unix Internals Lab

//This program is to implement different types of functions of exec family.#include<unistd.h>main(){ int r; char *cmd[]={"ls","-l",(char *)0}; char *env[]={"Home=/user/home","logname=home",(char*)0}; char *argv[]={"/bin/ls/","-r","-t","-l",(char *)0}; execl("/bin/ls","-r","-t","-l",(char*)0); execv("/bin/ls",argv); execle("/bin/ls/","ls","-l",(char*)0); r=execlp("ls","ls","-l",(char*)0); r=execve("/bin/ls",cmd,env); r=execvp("ls",cmd);}INPUT/OUTPUT:total 52-rwxrwxr-x. 1 11695A0510 11695A0510 5410 Jan 29 15:45 a.out-rw-rw-r--. 1 11695A0510 11695A0510 938 Jan 29 15:07 msgque.c-rw-rw-r--. 1 11695A0510 11695A0510 180 Jan 8 15:56 fileoperations.dat-rw-rw-r--. 1 11695A0510 11695A0510 396 Jan 8 15:54 fileoperations-rw-rw-r--. 1 11695A0510 11695A0510 1837 Jan 8 15:53 fileoperations.c-rw-rw-r--. 1 11695A0510 11695A0510 0 Jan 8 15:51 new.txt-rw-rw-r--. 1 11695A0510 11695A0510 0 Jan 8 15:50 unix.txt-rw-rw-r--. 1 11695A0510 11695A0510 311 Jan 8 15:46 filestatus.c-rw-rw-r--. 1 11695A0510 11695A0510 591 Jan 1 16:01 readWriteStream.c-rw-rw-r--. 1 11695A0510 11695A0510 358 Jan 1 15:57 positionStream.c-rw-rw-r--. 1 11695A0510 11695A0510 340 Jan 1 14:35 createStream.c-rw-rw-r--. 1 11695A0510 11695A0510 380 Dec 18 15:59 execFamily.c-rw-rw-r--. 1 11695A0510 11695A0510 136 Dec 18 14:58 Welcome.c-rw-rw-r--. 1 11695A0510 11695A0510 143 Dec 18 14:53 dispEnv.c

Week 2 a)


Unix Internals Lab

AIM: To write a program to implement creation of stream

DESCRIPTION:The ’open’ and ’creat’ functions are declared in the header file ’fcntl.h’.

creat(): int creat (const char *FILENAME, mode_t MODE)This function is obsolete, the call creat (FILENAME, MODE) is equivalent to open

(FILENAME, O_WRONLY | O_CREAT | O_TRUNC, MODE). If on a 32 bit machine the sources are translated with ’_FILE_OFFSET_BITS == 64’ the function ’creat’ returns a file descriptor opened in the large file mode which enables the file handling functions to use files up to 2^63 in size and offset from -2^63 to 2^63. This happens transparently for the user since all of the low-level files handling functions are equally replaced.

open(): int open (const char *FILENAME, int FLAGS[, mode_t MODE])The ’open’ function creates and returns a new file descriptor for the file named by

FILENAME. Initially, the file position indicator for the file is at the beginning of the file. The argument MODE is used only when a file is created, but it doesn't hurt to supply the argument in any case. The normal return value from ’open' is a non-negative integer file descriptor. In the case of an error, a value of -1 is returned instead. File access modes used for open() are as follows: O_RDONLY Open for reading only.O_RDWROpen for reading and writing.O_WRONLY Open for writing only.

SOURCE CODE:

#include<stdio.h>#include<fcntl.h>#include<stdlib.h>void main(){ int fd;//fd gives file descriptor fd=creat("unix.txt",0666); if(fd==-1) printf("\nFile cannot be created"); else printf("\nFile is created"); fd=open("unix.txt", O_RDONLY); if(fd==-1) printf("\nFile cannot be opened");


Unix Internals Lab

else printf("\nFile is opened\n");}INPUT/OUTPUT:File is createdFile is openedWeek 2 b)AIM: To write a program to read and write a stream in a file.DESCRIPTION:

The ’open’ and ’creat’ functions are declared in the header file ’fcntl.h’.

Open():int open (const char *FILENAME, int FLAGS[, mode_t MODE])The ’open’ function creates and returns a new file descriptor for the file named by

FILENAME. Initially, the file position indicator for the file is at the beginning of the file. The argument MODE is used only when a file is created, but it doesn't hurt to supply the argument in any case. The normal return value from ’open' is a non-negative integer file descriptor. In the case of an error, a value of -1 is returned instead. File access modes used for open() are as follows: O_RDONLY Open for reading only.O_RDWROpen for reading and writing.O_WRONLY Open for writing only.creat(): int creat (const char *FILENAME, mode_t MODE)

This function is obsolete, the call creat (FILENAME, MODE) is equivalent to open (FILENAME, O_WRONLY | O_CREAT | O_TRUNC, MODE). If on a 32 bit machine the sources are translated with ’_FILE_OFFSET_BITS == 64’ the function ’creat’ returns a file descriptor opened in the large file mode which enables the file handling functions to use files up to 2^63 in size and offset from -2^63 to 2^63. This happens transparently for the user since all of the lowlevel files handling functions are equally replaced.

The functions for performing primitive input and Input/Output operations on file descriptors: ’read', ’write', and ’lseek'. These functions are declared in the header file ’unistd.h'.read():

data type: ssize_t This data type is used to represent the sizes of blocks that can be read or written in a single operation. It is similar to ’size_t’, but must be a signed type.

ssize_t read (int FILEDES, void *BUFFER, size_t SIZE) The ’read’ function reads up to SIZE bytes from the file with descriptor FILEDES, storing the results in the BUFFER. (This is not necessarily a character string, and no terminating null character is added.).The return value is the number of bytes actually read. This might be less than SIZE; A value of zero indicates end-of-file (except if the value of the SIZE argument is also zero). If ’read’ returns at least one character, there is no way you can tell whether end-of-file was reached. But if you did reach the end, the next read will return zero.write():


Unix Internals Lab

ssize_t write (int FILEDES, const void *BUFFER, size_t SIZE) The ‘write’ function writes up to SIZE bytes from BUFFER to the file with descriptor

FILEDES. The data in BUFFER is not necessarily a character string and a null character is Input/Output like any other character. The return value is the number of bytes actually written. This may be SIZE, but can always be smaller. Your program should always call ’write’ in a loop, iterating until all the data is written. In the case of an error, ’write’ returns -1.

SOURCE CODE:

#include<stdio.h>#include<fcntl.h>#include<stdlib.h>void main(){ int fd1,fd2,size; fd1=open("createStream.c",O_RDONLY); if(fd1==-1) printf("\nFile createStream.c is not opened"); else printf("\nFile createStream.c is opened"); fd2=creat("new.txt",0666); if(fd2==-1) printf("\nFile new.txt is not created\n"); else { printf("\nFile new.txt is created\n"); exit(0); } size=sizeof(buffer); while((n=read(fd1,buffer,size))>=0) { write(fd2,buffer,n); printf("\nWritten %d",n); }}INPUT/OUTPUT:File createStream.c is openedFile new.txt is created


Unix Internals Lab

Week 2 c)AIM: To write a program to implement to position a stream.

DESCRIPTION:

Open(): int open (const char *FILENAME, int FLAGS[, mode_t MODE])The ’open’ function creates and returns a new file descriptor for the file named by

FILENAME. Initially, the file position indicator for the file is at the beginning of the file. The argument MODE is used only when a file is created, but it doesn't hurt to supply the argument in any case. The normal return value from ’open' is a non-negative integer file descriptor. In the case of an error, a value of -1 is returned instead. File access modes used for open() are as follows: O_RDONLY Open for reading only.O_RDWROpen for reading and writing.O_WRONLY Open for writing only.

read(): ssize_t read (int FILEDES, void *BUFFER, size_t SIZE)

The ’read’ function reads up to SIZE bytes from the file with descriptor FILEDES, storing the results in the BUFFER. (This is not necessarily a character string, and no terminating null character is added.).The return value is the number of bytes actually read. This might be less than SIZE; a value of zero indicates end-of-file (except if the value of the SIZE argument is also zero). If ’read’ returns at least one character, there is no way you can tell whether end-of-file was reached. But if you did reach the end, the next read will return zero.lseek():

’lseek’ specifies the position in the file for the next ’read’ or ’write’ operation.off_t lseek (int FILEDES, off_t OFFSET, int WHENCE)

The ’lseek’ function is used to change the file position of the file with descriptor FILEDES. The WHENCE argument specifies how the OFFSET should be interpreted.

SOURCE CODE://This program is to implement to position a stream#include<stdio.h>#include<fcntl.h>void main(){


Unix Internals Lab

int fd,var,count=0; char c; fd=open("createStream.c",O_RDONLY); if(fd==-1) printf("\nFile createStream.c is not opened"); else printf("\nFile createStream.c is opened"); while((var=read(fd,&c,1))>0&&(count<4)) { printf("\n%c ",c); var=lseek(fd,0L,1); printf("var=%d\n",var); count++; }}

INPUT/OUTPUT:File createStream.c is opened# var=1i var=2n var=3c var=4Week 3 a)AIM: To write a program to implement adding, modifying & deleting a record in a file.

Description:

fopen:

fopen - open a stream

#include <stdio.h>

FILE *fopen(const char *filename, const char *mode);

The fopen() function opens the file whose pathname is the string pointed to by filename, and associates a stream with it.

The argument mode points to a string beginning with one of the following sequences:


Unix Internals Lab

r or rbOpen file for reading.

w or wbTruncate to zero length or create file for writing.

a or abAppend; open or create file for writing at end-of-file.

r+ or rb+ or r+bOpen file for update (reading and writing).

w+ or wb+ or w+bTruncate to zero length or create file for update.

a+ or ab+ or a+bAppend; open or create file for update, writing at end-of-file.

fseek(), rewind()

Position the file pointer in anticipition of the next read or write.

Prototypes:#include <stdio.h>

int fseek(FILE *stream, long offset, int whence);void rewind(FILE *stream);

When doing reads and writes to a file, the OS keeps track of where you are in the file using a counter generically known as the file pointer. You can reposition the file pointer to a different point in the file using the fseek() call. Think of it as a way to randomly access you file.

The first argument is the file in question, obviously. offset argument is the position that you want to seek to, and whence is what that offset is relative to.

Of course, you probably like to think of the offset as being from the beginning of the file. I mean, "Seek to position 3490, that should be 3490 bytes from the beginning of the file." Well, it can be, but it doesn't have to be. Imagine the power you're wielding here. Try to command your enthusiasm.

You can set the value of whence to one of three things:

SEEK_SET

offset is relative to the beginning of the file. This is probably what you had in mind anyway, and is the most commonly used value for whence.

SEEK_CUR


Unix Internals Lab

offset is relative to the current file pointer position. So, in effect, you can say, "Move to my current position plus 30 bytes," or, "move to my current position minus 20 bytes."

SEEK_END

offset is relative to the end of the file. Just like SEEK_SET except from the other end of the file. Be sure to use negative values for offset if you want to back up from the end of the file, instead of going past the end into oblivion.

Speaking of seeking off the end of the file, can you do it? Sure thing. In fact, you can seek way off the end and then write a character; the file will be expanded to a size big enough to hold a bunch of zeros way out to that character.

Now that the complicated function is out of the way, what's this rewind() that I briefly mentioned? It repositions the file pointer at the beginning of the file:

fseek(fp, 0, SEEK_SET); // same as rewind()rewind(fp); // same as fseek(fp, 0, SEEK_SET)

Return Value

For fseek(), on success zero is returned; -1 is returned on failure.

The call to rewind() never fails.

Examplefseek(fp, 100, SEEK_SET); // seek to the 100th byte of the filefseek(fp, -30, SEEK_CUR); // seek backward 30 bytes from the current posfseek(fp, -10, SEEK_END); // seek to the 10th byte before the end of file

fseek(fp, 0, SEEK_SET); // seek to the beginning of the filerewind(fp); // seek to the beginning of the file

fwrite:size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );Write block of data to stream

Writes an array of count elements, each one with a size of size bytes, from the block of memory pointed by ptr to the current position in the stream.

The postion indicator of the stream is advanced by the total number of bytes written.


Unix Internals Lab

The total amount of bytes written is (size*count).

Parameters:Ptr :Pointer to the array of elements to be written, converted to a const void*.

Size : Size in bytes of each element to be written.size_t is an unsigned integral type.

Count: Number of elements, each one with a size of size bytes.size_t is an unsigned integral type.

Stream:Pointer to a FILE object that specifies an Input/Output stream.

Return ValueThe total number of elements successfully written is returned.If this number differs from the count parameter, a writing error prevented the function from completing. In this case, the error indicator (ferror) will be set for the stream.If either size or count is zero, the function returns zero and the error indicator remains unchanged.size_t is an unsigned integral type.

Fread:

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );Read block of data from stream

Reads an array of count elements, each one with a size of size bytes, from the stream and stores them in the block of memory specified by ptr.

The position indicator of the stream is advanced by the total amount of bytes read.

The total amount of bytes read if successful is (size*count).

Parameters:ptr


http://www.cplusplus.com/size_t

http://www.cplusplus.com/ferror

http://www.cplusplus.com/FILE



Unix Internals Lab

Pointer to a block of memory with a size of at least (size*count) bytes, converted to a void*.

size

Size, in bytes, of each element to be read.size_t is an unsigned integral type.

count

Number of elements, each one with a size of size bytes.size_t is an unsigned integral type.

stream

Pointer to a FILE object that specifies an input stream.

Return Value:The total number of elements successfully read is returned.If this number differs from the count parameter, either a reading error occurred or the end-of-file was reached while reading. In both cases, the proper indicator is set, which can be checked with ferror and feof, respectively.If either size or count is zero, the function returns zero and both the stream state and the content pointed by ptr remain unchanged.size_t is an unsigned integral type.

SOURCE CODE://This program is to perform adding, modifying & deleting a record in a file#include<stdio.h>#include<stdlib.h>#include<fcntl.h>struct employee{ char name[30]; int age;}emp;void main(){ char ch,c,sn[30],filename[30]; FILE *ft,*fp; printf("Enter the file to be opened:"); scanf("%s",&filename);



http://www.cplusplus.com/feof

http://www.cplusplus.com/ferror

http://www.cplusplus.com/FILE



Unix Internals Lab

fp=fopen(filename,"rb+"); if(fp==NULL) fp=fopen(filename,"wb+"); while(1){ printf("\n1.Add\n2.List\n3.Modify\n4.Delete\n5.Exit\n"); printf("Enter your choice:"); ch=getchar(); switch(ch){ case’1': fseek(fp,0,SEEK_END); c='y'; while(c=='y'){ printf("\nEnter the name and age:"); scanf("%s%d",&emp.name,&emp.age); fwrite(&emp,sizeof(emp),1,fp); c=getchar(); } break; case’2': rewind(fp); printf("\nThe list is:"); while((fread(&emp,sizeof(emp),1,fp))==1) printf("\n%s%d",emp.name,emp.age); break; case’3': c='y'; while(c=='y') { printf("Enter name to be modified:"); scanf("%s",&sn); rewind(fp); while((fread(&emp,sizeof(emp),1,fp))==1) if(strcmp(emp.name,sn)==0){ printf("Enter the name and age:"); scanf("%s%d",&emp.name,&emp.age); fseek(fp,sizeof(emp),SEEK_CUR); fwrite(&emp,sizeof(emp),1,fp); }


Unix Internals Lab

c=getchar(); } break; case’4': c='y'; while(c=='y'){ printf("\nEnter name to be deleted:"); scanf("%s",&sn); ft=fopen("temp.dat","wb+"); rewind(fp); while(fread(&emp,sizeof(emp),1,fp)==1) if(strcmp(emp.name,sn)!=0) fwrite(&emp,sizeof(emp),1,ft); fclose(fp); fclose(ft); remove(filename); rename("temp.dat",filename); fp=fopen(filename,"rb+"); c=getchar(); } break; case’5': fclose(fp); exit(0); default: printf("Enter the valid number!"); } } getch();}INPUT/OUTPUT:1.Add2.List3.Modify4.Delete5.ExitEnter your choice:1


Unix Internals Lab

Enter the name and age:chiru 581.Add2.List3.Modify4.Delete5.ExitEnter your choice:1Enter the name and age:balu 491.Add2.List3.Modify4.Delete5.ExitEnter your choice:1Enter the name and age:sky 271.Add2.List3.Modify4.Delete5.ExitEnter your choice:2The list is:Chiru 58Balu 49Sky 271.Add2.List3.Modify4.Delete5.ExitEnter your choice:3Enter name to be modified:chiruEnter the name and age:ramcharan 281.Add2.List3.Modify4.Delete5.Exit


Unix Internals Lab

Enter your choice:4Enter name to be deleted:sky11.Add2.List3.Modify4.Delete5.ExitEnter your choice:2The list is:Chiru 58Balu 491.Add2.List3.Modify4.Delete5.ExitEnter your choice:5Week 3 b)AIM: To write a program to find the status of a file.

SOURCE CODE://This program is tofind the status of a file#include<stdio.h>#include<fcntl.h>#include<stdlib.h>#include<sys/types.h>#include<sys/stat.h>void main(){ int fd; struct stat s; fd=open("new.txt",O_RDONLY); if(stat("new.txt",&s)==-1) printf("Error!"); printf("File Status:%o",s.st_mode); close(fd);}

INPUT/OUTPUT:


Unix Internals Lab

File Status: 100664

Week 4:AIM: Write a Program that takes certain file names along the command line arguments and remove if there exists any duplicatesDESCRIPTION:

Files can be deleted from the file system by using the unlink() function. The unlink() function takes the file name to be removed as an argument removes the file from the file system. The unlink() function is defined in unistd.h header file.

int unlink(const char *pathname);

unlink() deletes a name from the file system. If that name was the last link to a file and no processes have the file open the file is deleted and the space it was using is made available for reuse.

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

SOURCE CODE:#include <stdio.h>#include <unistd.h>#include <sys/stat.h>int main(int argc, char *argv[]){ struct stat s; int i;


Unix Internals Lab

if(argc<2){ printf("Arguments missing!"); return 1; } for(i=1;i<argc;i++){ if(stat(argv[i],&s)==0){ if(unlink(argv[i])==0) printf("\nFile \"%s\" found and deleted.",argv[i]); else printf("\nFile \"%s\" canot be deleted.",argv[i]); } else printf("\nNo duplicates exist for file \"%s\".",argv[i]); } return 0;}

Input/Output:

[usr@linuxsr labcode]$ ./week4.out sample.c

File "sample.c" found and deleted.Week5Aim: To Write a Program to find whether the file is having read, write, execute permissions and also check whether a given name is file or directoryDescriptionNAME: access - check user's permissions for a file

#include <unistd.h>int access(const char *pathname, int mode);

access checks whether the process would be allowed to read, write or test for existence of the file (or other file system object) whose name is pathname. If pathname is a symbolic link permissions of the file referred to by this symbolic link are tested. mode is a mask consisting of one or more of R_OK, W_OK, X_OK and F_OK.

R_OK, W_OK and X_OK request checking whether the file exists and has read, write and execute permissions, respectively. F_OK just requests checking for the existence of the file.

RETURN VALUE


Unix Internals Lab

On success (all requested permissions granted), zero is returned. On error (at least one bit in mode asked for a permission that is denied, or some other error occurred), -1 is returned, and errno is set appropriately.

NAME: stat, fstat, lstat - get file status

#include <sys/types.h> #include <sys/stat.h> #include <unistd.h> int stat(const char *file_name, struct stat *buf); int fstat(int filedes, struct stat *buf); int lstat(const char *file_name, struct stat *buf);

These functions return information about the specified file. You do not need any access rights to the file to get this information but you need search rights to all directories named in the path leading to the file.

stat stats the file pointed to by file_name and fills in buf.

lstat is identical to stat, except in the case of a symbolic link, where the link itself is stat-ed, not the file that it refers to.

fstat is identical to stat, only the open file pointed to by filedes (as returned by open(2)) is stat-ed in place of file_name. They all return a stat structure, which contains the following fields:

struct stat { dev_t st_dev; /* device */ ino_t st_ino; /* inode */ mode_t st_mode; /* protection */ nlink_t st_nlink; /* number of hard links */ uid_t st_uid; /* user ID of owner */ gid_t st_gid; /* group ID of owner */ dev_t st_rdev; /* device type (if inode device) */ off_t st_size; /* total size, in bytes */ blksize_t st_blksize; /* blocksize for filesystem I/O */ blkcnt_t st_blocks; /* number of blocks allocated */ time_t st_atime; /* time of last access */ time_t st_mtime; /* time of last modification */ time_t st_ctime; /* time of last change */};


Unix Internals Lab

The value st_size gives the size of the file (if it is a regular file or a symlink) in bytes. The size of a symlink is the length of the pathname it contains, without trailing NUL.

The following POSIX macros are defined to check the file type: S_ISREG(m)is it a regular file? S_ISDIR(m)directory? S_ISCHR(m)character device? S_ISBLK(m)block device? S_ISFIFO(m)fifo? S_ISLNK(m)symbolic link? (Not in POSIX.1-1996.) S_ISSOCK(m)socket? (Not in POSIX.1-1996.)

Source Code:

#include<stdio.h>#include<stdlib.h>#include<sys/types.h>#include<sys/stat.h>#include<unistd.h>#include<dirent.h>int main(int argc,char *argv[]){ int count; struct stat statbuf; if(argc<2) { printf("\n need some more arguments"); exit(1); } for(count=1;count<argc;count++){ if(access(argv[count],F_OK)==-1) { printf("\n %s this file or directory not found in pwd\n",argv[count]); continue; } stat(argv[count],&statbuf); if(S_ISDIR(statbuf.st_ino)) printf("\n %s is a directory and its permissions are \n",argv[count]);else printf("|n %s is a file and its permissions are \n ",argv[count]);


Unix Internals Lab

if(access(argv[count],R_OK)==0) printf("read permission \n");if(access(argv[count],W_OK)==0) printf("write permission \n");if(access(argv[count],X_OK)==0) printf("execute permission \n");}exit(0);}

INPUT/OUTPUT:

[sudhakar.n@linuxsr ~]$ vi week5_file.c[sudhakar.n@linuxsr ~]$ cc week5_file.c[sudhakar.n@linuxsr ~]$ ./a.out test unix

test is a directory and its permissions areread permissionwrite permissionexecute permission

unix is a directory and its permissions areread permissionwrite permissionexecute permission

[sudhakar.n@linuxsr ~]$ ./a.out test unix sdkf

test is a directory and its permissions areread permissionwrite permissionexecute permission

unix is a directory and its permissions areread permissionwrite permission


Unix Internals Lab

execute permission sdkf this file or directory not found in pwd

Week 6

Aim: To create chain of processes

Description:

fork() System call:

System call fork() is used to create processes. It takes no arguments and returns a process ID. The purpose of fork() is to create a new process, which becomes the child process of the caller. After a new child process is created, both processes will execute the next instruction following the fork() system call. Therefore, we have to distinguish the parent from the child. This can be done by testing the returned value of fork():

If fork() returns a negative value, the creation of a child process was unsuccessful. fork() returns a zero to the newly created child process. 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. Moreover, a process can use function getpid() to retrieve the process ID assigned to this process.

Therefore, after the system call to fork(), a simple test can tell which process is the child. Please note that Unix will make an exact copy of the parent's address space and give it to the child. Therefore, the parent and child processes have separate address spaces.

getppid and getppid System Calls:

#include <sys/types.h>


Unix Internals Lab

#include <unistd.h>

pid_t getpid(void)

pid_t getppid(void)

Getpid() returns the process ID of the calling process. The ID is guar- anteed to be unique and is useful for constructing temporary file names. Getppid() returns the process ID of the parent of the calling process.

The getpid() and getppid() functions are always successful, and no return value is reserved to indicate an error.

Source code:

#include<fcntl.h>

#include<stdio.h>

int main()

{

if(fork()==0) {

printf("%d \t %d\n",getpid(),getppid());

if(fork()==0)

{

printf("%d \t %d\n",getpid(),getppid());

if(fork()==0)

printf("%d \t %d\t hello \n",getpid(),getppid());

}

}

return 0;


Unix Internals Lab

}

Input/Output:

[sudhakar.n@linuxsr ~]$ vi week6process.c

[sudhakar.n@linuxsr ~]$ cc week6process.c

[sudhakar.n@linuxsr ~]$ ./a.out

13924 13923

13925 13924

13926 13925 he

Week-7

Aim: Write a program to

(a) Create semaphores

(b) Set values to semaphores

(c) Get values from semaphores

(d) Remove semaphores

Description:

A semaphore in UNIX is a variable that acts as a counter. A semaphore is used to control access to a resource when two or more processes try to access it at the same time. The value of the semaphore is initialized by the first process when the resource is in access by it. When the second process tries to access the resource it checks the value of the semaphore and if it finds the value as initialized it does not access the resource. After the first process is completed it reinitializes the semaphore value and now the second process uses it.

UNIX provides a set of functions for performing operations on semaphores. These functions are defined in sys/sem.h header file.

int semctl(int semid, int semnum, int cmd, ...);


Unix Internals Lab

The function semctl performs the control operation specified by cmd on the semaphore set identified by semid, or on the semnum-th semaphore of that set. (Semaphores are numbered starting at 0.)

int semget(key_t key, int nsems, int semflg);

The semget system call returns the semaphore set identifier associated with the argument key. A new set of nsems semaphores is created if key has the value IPC_PRIVATE or if no existing semaphore set is associated with key and IPC_CREAT is specified in semflg. If semflg specifies both IPC_CREAT and IPC_EXCL and a semaphore set already exists for key, then semget() fails with errno set to EEXIST.

int semop(int semid, struct sembuf *sops, unsigned nsops);

semop performs operations on selected semaphores in the set indicated by semid. Each of the nsops elements in the array pointed to by sops specifies an operation to be performed on a single semaphore.

Source Code:

#include<stdio.h>

#include<unistd.h>

#include<string.h>

#include<stdlib.h>

#include<sys/types.h>

#include<sys/sem.h>

#include<sys/ipc.h>

#define SEMKEY 75

int semid;

unsigned int count;

struct sembuf psembuf,vsembuf;


Unix Internals Lab

main(argc,argv)

int argc;

char *argv[];

{

int i,first,second;

short initarray[2],outarray[2];

extern cleanup();

if(argc==1)

{

for(i=0;i<20;i++)

signal(i,cleanup);

semid=semget(SEMKEY,2,0777|IPC_CREAT);

initarray[0]=initarray[1]=1;

semctl(semid,2,SETALL,initarray);

semctl(semid,2,GETALL,outarray);

printf("Sem init vals %d %d \n",outarray[0],outarray[1]);

pause();

}

else if(argv[1][0]=='a')

{

first=0;

second=1;

}


Unix Internals Lab

else

{

first=1;

second=0;

}

semid=semget(SEMKEY,2,0777);

psembuf.sem_op=-1;

psembuf.sem_flg=SEM_UNDO;

vsembuf.sem_op=1;

vsembuf.sem_flg=SEM_UNDO;

for(count=0; ;count++)

{

psembuf.sem_num=first;

semop(semid,&psembuf,1);

psembuf.sem_num=second;

semop(semid,&psembuf,1);

printf("Proc %d count %d \n",getpid(),count);

vsembuf.sem_num=second;

semop(semid,&vsembuf,1);

vsembuf.sem_num=first;

semop(semid,&vsembuf,1);

if(count>1)

break;


Unix Internals Lab

}

}

cleanup()

{

semctl(semid,2,IPC_RMID,0);

exit(0);

}

INPUT/OUTPUT::

[09BF1A0551@localhost ~]$ ./a.out a

Proc 18161 count 0

Proc 18161 count 1

Proc 18161 count 2

Proc 18247 count 2

Week 8

AIM::To write a program implement message queue

Description:Two (or more) processes can exchange information via access to a common system message queue. Before a process can send or receive a message, the queue must be initialized (through the msgget) Operations to send and receive messages are performed by the msgsnd() and msgrcv() functions, respectively.

msgget():The msgget() function returns the message queue identifier associated with key.#include <sys/msg.h>int msgget(key_t key, int msgflg)If successful, msgget() returns a message queue identifier. On failure, msgget() returns a value of -1 and sets errno to indicate the error


Unix Internals Lab

msgctl():This function performs the control operation specified by cmd on the message queue with identifier msqid.

#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>

int msgctl(int msqid, int cmd, struct msqid_ds *buf); On success, the return value will be 0, otherwise -1 with errno indicating the error.

msgget() & msgrcv()#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>

int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg); ssize_t msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz, long msgtyp, int msgflg);

On a failure both functions return -1 with errno indicating the error, otherwise msgsnd returns 0 and msgrvc returns the number of bytes actually copied into the mtext array. To send or receive a message, the calling process allocates a structure of the following general form: struct msgbuf { long mtype; /* message type, must be > 0 */

char mtext[1]; /* message data */ }; Source Code:

#include<stdio.h>#include<time.h>#include<string.h>#include<sys/ipc.h>#include<sys/msg.h>#include<sys/wait.h>#include<sys/errno.h>extern int err;#define mp 0600#define ml 128int msgqid,rc,done;struct msg_buf{ long int mtype; char mtext[ml];


Unix Internals Lab

}msg;int main(int argc,char **argv){ int msgqid=msgget(IPC_PRIVATE,mp|IPC_CREAT); if(msgqid<0) { printf("Error"); return; } printf("mq %d created\n",msgqid); printf("\nTrying to send message"); msg.mtype=1; sprintf(msg.mtext,"%s","Welcome"); rc=msgsnd(msgqid,&msg,sizeof(msg.mtext),0); if(rc<0) { printf("Error"); return 1; } rc=msgrcv(msgqid,&msg,sizeof(msg.mtext),1,0); if(rc<0) { printf("Error"); return 1; } printf("\nRecieved msg:%s\n",msg.mtext); rc=msgctl(msgqid,IPC_RMID,NULL); if(rc<0) { printf("Error"); return 1; } printf("\nmsgqid %d is removed \n",msgqid); return 0;}

INPUT/OUTPUT:::[09BF1A0551@localhost ~]$ gcc msgque.c[09BF1A0551@localhost ~]$ ./a.outmq 786434 createdTrying to send messageRecieved msg:a.textmsg....msgqid 786434 is removed


Unix Internals Lab

Week 9

Aim: Write a program to

(d) Create shared memory

(e) Write to shared memory

(f) Read from shared memory

Description:

There are various ways for inter-process communication. Shared memory is the fastest and most flexible of the techniques. In this technique, information is shared by reading and writing from a common segment of memory.

A shared memory segment is described by a control structure with a unique ID that points to an area of physical memory. The identifier of the segment is called the shmid. The structure


Unix Internals Lab

definition for the shared memory segment control structures and prototypes are found in sys/shm.h header file.

shmget() is used to obtain access to a shared memory segment.

int shmget(key_t key, size_t size, int shmflg);

The key argument is an access value associated with the semaphore ID. The size argument is the size in bytes of the requested shared memory. The shmflg argument specifies the initial access permissions and creation control flags.

When the call succeeds, it returns the shared memory segment ID.

shmctl() is used to alter the permissions and other characteristics of a shared memory segment. It is prototyped as follows:

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

The cmd argument is one of following control commands:

SHM_LOCK -- Lock the specified shared memory segment in memory.

SHM_UNLOCK -- Unlock the shared memory segment.

IPC_STAT -- Return the status information contained in the control structure and place it in the buffer pointed to by buf.

IPC_SET -- Set the effective user and group identification and access permissions.

IPC_RMID -- Remove the shared memory segment.

shmat() and shmdt() are used to attach and detach shared memory segments.

void *shmat(int shmid, const void *shmaddr, int shmflg);

int shmdt(const void *shmaddr);

shmat() returns a pointer, shmaddr, to the head of the shared segment associated with a valid shmid. shmdt() detaches the shared memory segment located at the address indicated by shmaddr.

Source Code:


Unix Internals Lab

#include<stdio.h>

#include<sys/ipc.h>

#include<sys/shm.h>

#include<sys/types.h>

#include<string.h>

#include<stdlib.h>

#include<unistd.h>

#include<fcntl.h>

#define segsize 100

int main(int argc,char *argv[])

{

int shmid,cntr;

key_t key;

char *segptr;

char buff[]="hello world";

key=ftok(".",'s');

if(shmid=shmget(key,segsize,IPC_CREAT|IPC_EXCL|0666)==-1)

{

if((shmid=shmget(key,segsize,0))==-1)

{

printf("\nError");

exit(1);

}

}

else


Unix Internals Lab

{

printf("\nCreating a new shmid\n");

printf("\nshmid %d",shmid);

}

system("ipcs -m");

if((segptr=shmat(shmid,0,0))==(char *)-1)

{

printf("\nError");

exit(1);

}

printf("\nwriting data to shm....\n");

strcpy(segptr,buff);

printf("\nDone\n");

printf("\nReading data from shm....\n");

printf("\nDATA %s \n",segptr);

printf("\nDone\n");

printf("\nRemaining shmseg....\n");

if(shmctl(shmid,IPC_RMID,0)==-1)

printf("\nCant remove shmreg.....\n");

else

printf("\nRemoved successfully");

}


Unix Internals Lab

INPUT/OUTPUT::

[09BF1A0551@localhost ~]$ gcc sharedmemory.c

[09BF1A0551@localhost ~]$ ./a.out

------ Shared Memory Segments --------

key shmid owner perms bytes nattch status

0x7300019d 1048578 09BF1A0554666 100 0

0x53000135 327683 09BF1A0540666 100 0

0xbfbea638 393221 09BF1A0538666 100 0

0xbff39188 425990 09BF1A0538666 100 0

0xffffffff 458759 09BF1A0551666 100 0

0x00619ff4 491528 09BF1A0538666 100 0

0x5300013d 524297 09BF1A0541666 100 0

0x7300018d 1081354 09BF1A0551666 100 0

writing data to shm....

Done

Reading data from shm....

DATA hello world

Done

Remaining shmseg....

Removed successfully


Unix Internals Lab

Week 10

Aim: Write a program which takes a source file name and directory name as command line argument and print a message ‘YES’, if the file is found in the given directory

Description:

The existence of a file can be determined using the access() function with the F_OK mode. If the file exists, the function returns 0 else, it returns 1.

The full pathname of the file should be provided as an argument for the access() function.

access() checks whether the calling process can access the file pathname. The mode specifies the accessibility check(s) to be performed. The mode may be

F_OK – tests for the existence of the file.


Unix Internals Lab

Source code:

#include<stdio.h>#include<unistd.h>#include<string.h>main(int argc, char *argv[]){ char *filename, *path; if(argc<2){ printf("Arguments missing!\n"); printf("Usage: FILE DIRECTORY"); return 1; } filename=argv[1]; path=argv[2]; if(path[strlen(path)-1]!='/') path=strcat(path,"/"); filename=strcat(path,filename); printf("Filename: %s",filename); if(access(filename,F_OK)==0) printf("\nYES"); else printf("\nNO"); return 0;}

Input/Output:

[usr@linuxsr labcode]$ ./week10.out week1a.c /home/usr/labcodeFilename: /home/usr/labcode/week1a.cFile present.

[usr@linuxsr labcode]$ ./week10.out ser.c /home/usr/labcodeFilename: /home/usr/labcode/ser.cFile not present!


Unix Internals Lab

TEXT BOOKS:

1. The Design of the Unix Operating System, Maurice J. Bach, Prentice Hall of India, 1991.

REFERENCES:

1. William Stallings, Operating Systems: Internals and Design Principles, Fifth Edition, Prentice Hall, 2005.

2. Understanding the LINUX Kernel, Daniel P. Bovet and Marco cesati, O’REILLY Publications, 2005

Web Sites:

1. www.ugu.com


Unix Internals Lab

2. http://www.wikipedia.com

3. www.unix.org


http://www.unix.org/

http://www.wikipedia.com/

week5 - web viewas unix is a multiuser operating system which involves many users can work...

Documents