CSBS | FCS | UNIT 05: Question Bank

01 How can you use the open() and create() functions to create and open files in Unix
programming? Provide an example of how you can use these functions to open a file
in read-only mode.

Ans:

In Unix programming, a file descriptor is a unique integer that identifies an open file or
input/output (I/O) device. File descriptors are used by the operating system to track
and manipulate open files and I/O devices.
When a program opens a file or device, the operating system assigns a file descriptor
to that file or device and returns the descriptor to the program. The program can then
use this descriptor to perform I/O operations on the file or device. For example, the
read() and write() functions in Unix take a file descriptor as one of their arguments,
which specifies the file or device to read from or write to.
File descriptors are significant in terms of low-level I/O operations because they
provide a standardized way for programs to interact with files and devices. By using
file descriptors, programs can perform I/O operations on any open file or device
without having to know the underlying details of how the file or device is
implemented. This abstraction makes it easier to write portable programs that can run
on different Unix systems and hardware configurations.

02 How can you use the open() and create() functions to create and open files in Unix
programming? Provide an example of how you can use these functions to open a file in
read-only mode.

Ans:
In Unix programming, the open() and creat() functions can be used to create and open files.
The open() function is used to open an existing file or to create a new file if it does not exist. It
takes two arguments: the path of the file to open or create, and a set of flags that control the
behavior of the function, such as whether to open the file in read-only, write-only, or read-
write mode.
The creat() function is a shorthand for creating a new file with write-only access. It takes one
argument, which is the path of the file to create.

#include <fcntl.h>
#include <unistd.h>

int main() {
int fd = open("example.txt", O_RDONLY);
if (fd == -1) {
// error handling code
}

// read from the file using fd

close(fd);

return 0;
 CSBS | FCS | UNIT 05: Question Bank

}
In this example, the open() function is used to open the file "example.txt" in read-only mode.
The O_RDONLY flag specifies that the file should be opened for reading only. If the function
succeeds, it returns a file descriptor (fd) that can be used to read from the file. If the function
fails, it returns -1 and sets the errno variable to indicate the type of error that occurred.

After reading from the file, the close() function is called to release the file descriptor and free
up system resources.

In this example, the open() function is used to open the file "example.txt" in read-only mode.
The O_RDONLY flag specifies that the file should be opened for reading only. If the function
succeeds, it returns a file descriptor (fd) that can be used to read from the file. If the function
fails, it returns -1 and sets the errno variable to indicate the type of error that occurred.
After reading from the file, the close() function is called to release the file descriptor and free
up system resources.

03 What is random access in Unix programming? Explain how you can use the lseek() function
to move the file pointer to a specific position within a file.

Ans:

Random access is a term used in computer science to describe the ability to access data at any
random point in a file or memory without having to go through all the preceding data.
In Unix programming, random access refers to the ability to read or write data at any specific
position within a file. The file pointer is used to keep track of the current position within the
file.
The lseek() function in Unix programming is used to move the file pointer to a specific position
within a file. The function takes three arguments:
off_t lseek(int fd, off_t offset, int whence);

fd: This argument is the file descriptor, which is an integer that represents the file being
accessed.
offset: This argument specifies the position to which the file pointer should be moved. It is an
integer value that can be positive or negative, depending on whether the offset is relative to
the beginning or end of the file.
whence: This argument specifies the reference point for the offset. It can take one of three
values:
SEEK_SET: This value sets the offset relative to the beginning of the file.
SEEK_CUR: This value sets the offset relative to the current position of the file pointer.
SEEK_END: This value sets the offset relative to the end of the file.
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
int fd = open("example.txt", O_RDONLY);
if (fd == -1) {
perror("Error opening file");
return 1;
}
off_t offset = 5;
 CSBS | FCS | UNIT 05: Question Bank

off_t new_offset = lseek(fd, offset, SEEK_SET);

In this example, we first open the file "example.txt" using the open() function and check for
any errors. Then, we use lseek() to move the file pointer to offset 5 from the beginning of the
file. We check for any errors and then use the read() function to read 10 bytes from the file
into a buffer. Finally, we print out the number of bytes read and the contents of the buffer.

04 Discuss the process of listing directories in Unix programming. Explain how you can use the
opendir() and readdir() functions to retrieve information about files and directories within a
specified directory.

Ans:
Listing directories in Unix programming involves retrieving information about files and
directories within a specified directory. This is commonly done using the opendir() and
readdir() functions.
The opendir() function is used to open a directory and returns a pointer to a DIR structure,
which contains information about the directory. The function takes a single argument, which is
the name of the directory to be opened.

DIR *opendir(const char *name);

The readdir() function is used to read the contents of the directory specified by the DIR
structure. The function returns a pointer to a dirent structure, which contains information
about a specific file or directory within the directory. The function takes a single argument,
which is a pointer to the DIR structure.
05 What is the purpose of debugging in Unix programming? Explain how you can use the gdb
utility to debug your C programs.

Ans:
Debugging is an essential process in Unix programming used to identify and fix errors in
software. It is the process of finding and removing bugs or errors from software programs to
ensure that they perform as intended.
In Unix programming, the GNU debugger (gdb) utility is used to debug C programs. gdb is a
command-line tool that provides a wide range of debugging features, including setting
breakpoints, stepping through code, examining variables, and stack traces.
Here's an example of how to use gdb to debug a C program:
 CSBS | FCS | UNIT 05: Question Bank

#include <stdio.h>

int main() {
int i, sum = 0;
for (i = 1; i <= 10; i++) {
sum += i;
}
printf("Sum = %d\n", sum);
return 0;
}
06 What is the Unix system interface? Explain the role of file descriptors in the Unix system.

Ans:
The Unix system interface is the set of functions and system calls provided by the Unix
operating system that programmers can use to interact with the system. It provides a
standardized way for programs to communicate with the operating system and access system
resources, such as files, processes, and network connections.
One important concept in the Unix system interface is file descriptors. A file descriptor is a
unique integer value that identifies an open file within a process. It is used by the operating
system to keep track of open files and to perform I/O operations on them.
When a program opens a file using the open() system call, the operating system returns a file
descriptor that the program can use to access the file. The file descriptor is an integer value
that can be passed to other system calls, such as read(), write(), and close(), to perform I/O
operations on the file.

07 What is a makefile in Unix programming? How can you use the make utility to compile and
link your source code files into an executable program?

Ans:
In Unix programming, a makefile is a text file that contains a set of rules and dependencies for
compiling and linking source code files into an executable program. It is used to automate the
build process and make it easier to manage complex software projects.
A makefile consists of a set of rules that specify the dependencies between source code files,
object files, and the final executable. Each rule defines a target, which is a file that needs to be
built, and a set of prerequisites, which are files that the target depends on.
The make utility is a command-line tool that reads the makefile and determines which files
need to be built based on their dependencies. It then invokes the appropriate compiler and
linker commands to build the target files.

08 What is storage allocator in Unix programming? Explain how you can use the malloc() and
free() functions to dynamically allocate and deallocate memory in your programs.

Ans:
In Unix programming, a storage allocator is a tool that is used to dynamically allocate and
deallocate memory in a program. It is used to manage the memory used by a program,
allowing it to allocate memory as needed during runtime.
The most commonly used storage allocator in Unix programming is the malloc() function,
which is used to allocate memory on the heap. The malloc() function takes a single argument,
which is the number of bytes to allocate, and returns a pointer to the beginning of the
allocated block of memory.
For example, to allocate a block of memory to hold 10 integers, you could use the following
 CSBS | FCS | UNIT 05: Question Bank

code:
cCopy code
int *ptr = (int*) malloc(10 * sizeof(int));
The malloc() function returns a void pointer, so we need to cast it to the appropriate pointer
type (in this case, int*) before we can use it.