Read Contents of File From File Descriptor C

Important Terminology

What is the File Descriptor?
File descriptor is integer that uniquely identifies an open file of the process.

File Descriptor table: File descriptor table is the collection of integer array indices that are file descriptors in which elements are pointers to file table entries. One unique file descriptors table is provided in operating system for each process.

File Table Entry: File table entries is a construction In-retention surrogate for an open up file, which is created when procedure request to opens file and these entries maintains file position.

Standard File Descriptors: When any process starts, and so that procedure file descriptors table'south fd(file descriptor) 0, i, 2 open up automatically, (Past default) each of these three fd references file tabular array entry for a file named /dev/tty

/dev/tty: In-memory surrogate for the terminal
Terminal: Combination keyboard/video screen

Read from stdin => read from fd 0 : Whenever we write any graphic symbol from keyboard, it read from stdin through fd 0 and save to file named /dev/tty.
Write to stdout => write to fd 1 : Whenever we come across whatsoever output to the video screen, it'south from the file named /dev/tty and written to stdout in screen through fd 1.
Write to stderr => write to fd ii : Nosotros see any mistake to the video screen, it is likewise from that file write to stderr in screen through fd 2.

I/O System calls

Basically there are total 5 types of I/O organization calls:

1. Create: Used to Create a new empty file.

          Syntax in C language:                    int create(char *filename, mode_t style)

Parameter:

• filename : name of the file which you want to create
• fashion : indicates permissions of new file.

Returns:

• render first unused file descriptor (mostly 3 when first create employ in procedure considering 0, 1, 2 fd are reserved)
• return -1 when mistake

How it work in OS

• Create new empty file on disk
• Create file table entry
• Set first unused file descriptor to point to file table entry
• Return file descriptor used, -1 upon failure

two. open up: Used to Open the file for reading, writing or both.

          Syntax in C language                    #include<sys/types.h> #include<sys/stat.h> #include <fcntl.h>   int open up (const char* Path, int flags [, int fashion ]);        

Parameters

• Path: path to file which you desire to use
  • use absolute path begin with "/", when you are non work in same directory of file.
  • Use relative path which is only file name with extension, when you lot are work in same directory of file.
• flags : How you lot like to use
  • O_RDONLY: read merely, O_WRONLY: write only, O_RDWR: read and write, O_CREAT: create file if it doesn't be, O_EXCL: foreclose cosmos if it already exists

How it works in Os

• Find the existing file on disk
• Create file table entry
• Set up first unused file descriptor to point to file table entry
• Render file descriptor used, -ane upon failure

C

#include<stdio.h>

#include<fcntl.h>

#include<errno.h>

extern int errno ;

int main()

{

int fd = open( "foo.txt" , O_RDONLY | O_CREAT);

printf ( "fd = %d/northward" , fd);

if (fd ==-i)

{

printf ( "Error Number % d\northward" , errno );

perror ( "Plan" );

}

return 0;

}

Output:

fd = 3

three. shut: Tells the operating organization yous are washed with a file descriptor and Close the file which pointed by fd.

          Syntax in C linguistic communication          #include <fcntl.h> int close(int fd);        

Parameter:

• fd :file descriptor

Render:

• 0 on success.
• -1 on mistake.

How it works in the Os

• Destroy file table entry referenced by element fd of file descriptor table
  – As long as no other process is pointing to it!
• Set element fd of file descriptor table to NULL

C

#include<stdio.h>

#include <fcntl.h>

int main()

{

int fd1 = open up( "foo.txt" , O_RDONLY);

if (fd1 < 0)

{

perror ( "c1" );

exit (ane);

}

printf ( "opened the fd = % d\n" , fd1);

if (close(fd1) < 0)

{

perror ( "c1" );

exit (1);

}

printf ( "closed the fd.\northward" );

}

Output:

opened the fd = 3 closed the fd.

C

#include<stdio.h>

#include<fcntl.h>

int main()

{

int fd1 = open( "foo.txt" , O_RDONLY, 0);

close(fd1);

int fd2 = open( "baz.txt" , O_RDONLY, 0);

printf ( "fd2 = % d\due north" , fd2);

exit (0);

}

Output:

fd2 = 3

Here, In this lawmaking first open() returns 3 considering when principal process created, then fd 0, 1, 2 are already taken by stdin, stdout and stderr. Then first unused file descriptor is 3 in file descriptor table. After that in shut() system telephone call is free it this 3 file descriptor and and so after prepare three file descriptor as nil. So when we called 2d open(), then first unused fd is besides three. So, output of this plan is 3.

iv. read: From the file indicated past the file descriptor fd, the read() office reads cnt bytes of input into the memory area indicated by buf. A successful read() updates the access time for the file.

          Syntax in C language                    size_t read (int fd, void* buf, size_t cnt);        

Parameters:

• fd: file descriptor
• buf: buffer to read data from
• cnt: length of buffer

Returns: How many bytes were actually read

• return Number of bytes read on success
• return 0 on reaching end of file
• render -ane on error
• return -one on signal interrupt

Important points

• buf needs to point to a valid memory location with length not smaller than the specified size because of overflow.
• fd should be a valid file descriptor returned from open() to perform read operation because if fd is Zip then read should generate error.
• cnt is the requested number of bytes read, while the return value is the bodily number of bytes read. As well, some times read system call should read less bytes than cnt.

C

#include<stdio.h>

#include <fcntl.h>

int main()

{

int fd, sz;

char *c = ( char *) calloc (100, sizeof ( char ));

fd = open up( "foo.txt" , O_RDONLY);

if (fd < 0) { perror ( "r1" ); exit (one); }

sz = read(fd, c, 10);

printf ( "called read(% d, c, 10). returned that"

" %d bytes were read.\n" , fd, sz);

c[sz] = '\0' ;

printf ( "Those bytes are as follows: % s\n" , c);

}

Output:

called read(iii, c, x).  returned that 10 bytes  were read. Those bytes are as follows: 0 0 0 foo.

Suppose that foobar.txt consists of the 6 ASCII characters "foobar". Then what is the output of the following program?

C

#include<stdio.h>

#include<unistd.h>

#include<fcntl.h>

#include<stdlib.h>

int chief()

{

char c;

int fd1 = open( "sample.txt" , O_RDONLY, 0);

int fd2 = open up( "sample.txt" , O_RDONLY, 0);

read(fd1, &c, 1);

read(fd2, &c, 1);

printf ( "c = %c\n" , c);

exit (0);

}

Output:

c = f

The descriptors fd1 and fd2 each have their own open file table entry, so each descriptor has its own file position for foobar.txt . Thus, the read from fd2 reads the first byte of foobar.txt , and the output is c = f, non c = o.

v. write: Writes cnt bytes from buf to the file or socket associated with fd. cnt should not be greater than INT_MAX (defined in the limits.h header file). If cnt is zero, write() but returns 0 without attempting any other action.

#include <fcntl.h> size_t write (int fd, void* buf, size_t cnt);        

Parameters:

• fd: file descriptor
• buf: buffer to write information to
• cnt: length of buffer

Returns: How many bytes were actually written

• return Number of bytes written on success
• return 0 on reaching end of file
• return -1 on error
• return -ane on betoken interrupt

Important points

• The file needs to exist opened for write operations
• buf needs to be at least every bit long as specified by cnt considering if buf size less than the cnt and then buf will atomic number 82 to the overflow condition.
• cnt is the requested number of bytes to write, while the render value is the bodily number of bytes written. This happens when fd have a less number of bytes to write than cnt.
• If write() is interrupted by a point, the effect is one of the following:
  -If write() has non written any data yet, it returns -1 and sets errno to EINTR.
  -If write() has successfully written some data, it returns the number of bytes it wrote earlier information technology was interrupted.

C

#include<stdio.h>

#include <fcntl.h>

master()

{

int sz;

int fd = open( "foo.txt" , O_WRONLY | O_CREAT | O_TRUNC, 0644);

if (fd < 0)

{

perror ( "r1" );

exit (1);

}

sz = write(fd, "hello geeks\due north" , strlen ( "how-do-you-do geeks\north" ));

printf ( "called write(% d, \"hello geeks\\n\", %d)."

" Information technology returned %d\northward" , fd, strlen ( "how-do-you-do geeks\n" ), sz);

close(fd);

}

Output:

called write(3, "hello geeks\north", 12).  it returned 11

Here, when y'all see in the file foo.txt later on running the code, you lot become a "how-do-you-do geeks". If foo.txt file already have some content in it and so write system call overwrite the content and all previous content are deleted and only "hello geeks" content will accept in the file.

Print "hello world" from the program without use any printf or cout function.

C

#include<stdio.h>

#include<string.h>

#include<unistd.h>

#include<fcntl.h>

int primary ( void )

{

int fd[2];

char buf1[12] = "how-do-you-do world" ;

char buf2[12];

fd[0] = open up( "foobar.txt" , O_RDWR);

fd[1] = open( "foobar.txt" , O_RDWR);

write(fd[0], buf1, strlen (buf1));

write(1, buf2, read(fd[1], buf2, 12));

shut(fd[0]);

shut(fd[one]);

return 0;

}

Output:

hullo world

In this lawmaking, buf1 array's string "hullo world" is commencement write in to stdin fd[0] then later on that this string write into stdin to buf2 array. Afterwards that write into buf2 array to the stdout and print output " hello earth ".
This article is contributed by Kadam Patel. If you like GeeksforGeeks and would like to contribute, you lot can as well write an commodity using write.geeksforgeeks.org or postal service your article to review-team@geeksforgeeks.org. See your commodity appearing on the GeeksforGeeks main folio and assistance other Geeks.
Delight write comments if you observe anything wrong, or yous want to share more than information near the topic discussed higher up.

laymancompall.blogspot.com

Source: https://www.geeksforgeeks.org/input-output-system-calls-c-create-open-close-read-write/

Share this post