Scribd
Upload
3 views

Unit 2 LP Dup and Dup2 Systemcalls

The dup() system call in Linux creates a copy of a file descriptor using the lowest-numbered unused descriptor, allowing both descriptors to refer to the same open file description. The dup2() system call is similar but allows the user to specify the new descriptor number, closing it if it was previously open. Both system calls enable interchangeable use of file descriptors for file operations, as illustrated in provided C code examples.

Uploaded by

lakshmiprasannagouda02
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
3 views

Unit 2 LP Dup and Dup2 Systemcalls

The dup() system call in Linux creates a copy of a file descriptor using the lowest-numbered unused descriptor, allowing both descriptors to refer to the same open file description. The dup2() system call is similar but allows the user to specify the new descriptor number, closing it if it was previously open. Both system calls enable interchangeable use of file descriptors for file operations, as illustrated in provided C code examples.

Uploaded by

lakshmiprasannagouda02
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

dup() and dup2() Linux system call

The dup() system call creates a copy of a file descriptor.


Take a step-up from those "Hello World" programs. Learn to implement data structures like
Heap, Stacks, Linked List and many more! Check out our Data Structures in C course to
start learning today.
 It uses the lowest-numbered unused descriptor for the new descriptor.
 If the copy is successfully created, then the original and copy file descriptors may be
used interchangeably.
 They both refer to the same open file description and thus share file offset and file
status flags.
Syntax:
int dup(int oldfd);
oldfd: old file descriptor whose copy is to be created.
// CPP program to illustrate dup()
#include<stdio.h>
#include <unistd.h>
#include <fcntl.h>

int main()
{
// open() returns a file descriptor file_desc to a
// the file "dup.txt" here"

int file_desc = open("dup.txt", O_WRONLY | O_APPEND);

if(file_desc < 0)
printf("Error opening the file\n");

// dup() will create the copy of file_desc as the copy_desc


// then both can be used interchangeably.

int copy_desc = dup(file_desc);

// write() will write the given string into the file


// referred by the file descriptors

write(copy_desc,"This will be output to the file named


dup.txt\n", 46);

write(file_desc,"This will also be output to the file named


dup.txt\n", 51);

return 0;
}
Explanation: The open() returns a file descriptor file_desc to the file named “dup.txt”.
file_desc can be used to do some file operation with file “dup.txt”. After using the dup()
system call, a copy of file_desc is created copy_desc. This copy can also be used to do
some file operation with the same file “dup.txt”. After two write operations one with
file_desc and another with copy_desc, same file is edited i.e. “dup.txt”.
Before running the code, Let The file “dup.txt” before the write operation be as shown
below:
After running the C program shown above, the file “dup.txt” is as shown below:

dup2()
The dup2() system call is similar to dup() but the basic difference between them is that
instead of using the lowest-numbered unused file descriptor, it uses the descriptor number
specified by the user.
Syntax:
int dup2(int oldfd, int newfd);

oldfd: old file descriptor


newfd new file descriptor which is used by dup2() to create a copy.

Important points:
 Include the header file unistd.h for using dup() and dup2() system call.
 If the descriptor newfd was previously open, it is silently closed before being reused.
 If oldfd is not a valid file descriptor, then the call fails, and newfd is not closed.
 If oldfd is a valid file descriptor, and newfd has the same value as oldfd, then dup2()
does
nothing, and returns newfd.

A tricky use of dup2() system call: As in dup2(), in place of newfd any file descriptor can be
put. Below is a C implementation in which the file descriptor of Standard output (stdout) is
used. This will lead all the printf() statements to be written in the file referred by the old
file descriptor.
// CPP program to illustrate dup2()
#include<stdlib.h>
#include<unistd.h>
#include<stdio.h>
#include<fcntl.h>

int main()
{
int file_desc = open("tricky.txt",O_WRONLY | O_APPEND);

// here the newfd is the file descriptor of stdout (i.e. 1)


dup2(file_desc, 1) ;

// All the printf statements will be written in the file


// "tricky.txt"
printf("I will be printed in the file tricky.txt\n");

return 0;
}
This can be seen in the figure shown below:
Let The file “tricky.txt” before the dup2() operation be as shown below:
After running the C program shown above, the file “tricky.txt” is as shown below:

You might also like