Files and Directories

File types
stat functions for file information
File permissions
suid and sgid
Sticky bit
Hard link and soft link
Directory operations
Device special files
File system

File Types

Regular file
Directory file
Character special file (unbuffered I/O
access)
Block special file (buffered I/O)
Named Pipe (a type of IPC) - FIFO
Socket (a network form of IPC)
Symbolic Link (a file that just points to
another file)

stat, fstat and lstat

int stat(const char *path, struct stat *buf);
int fstat(int filedes, struct stat *buf);
int lstat(const char *path, struct stat *buf);
All three return 0 on success or -1 on failure
All three set buf to point to a structure of information
stat get info about the file
fstat gets info about an already open file
lstat same as stat but if given a symbolic link will get
info about the link instead of what the link points to

stat structure

Definition on page
88

st_mode
st_ino
st_dev
st_rdev
st_nlink
st_uid
st_gid

st_size
st_blocks
st_blksize
st_atime
st_mtime
st_ctime

Determining the type of a

file

Set of macros defined in <sys/stat.h> can be

used.
They all accept the st_mode field of the stat
struct as their only parameter
S_ISREG(mode_t mode)
S_ISDIR(mode_t mode)
S_ISCHR(mode_t mode)
S_ISBLK(mode_t mode)
S_ISFIFO(mode_t mode)
S_ISLNK(mode_t mode)
S_ISSOCK(mode_t mode)

Set-User-ID & Set-Group-ID

Every process has 6 or more IDs

Real user ID
Real group ID
Effective user ID
Effective group ID
Supplementary group IDs
Saved set-user-ID
Saved set-group-ID

Set-User-ID & Set-Group-ID

Normally, effective IDs are the same as

real user IDs
Sometimes, we need to run a process
with the permissions of the user or
group that owns the file (ex: passwd)
Two bits in the files mode word
(st_mode) allow this.

set-user-ID bit
set-group-ID bit

Set-User-ID & Set-Group-ID

When creating a file with the creat

function, the new files UID is the
effective UID of the process, and
the new files GID is the effective
GID of the process

Checking set-user-ID and

set-group-ID bits
Can use S_ISUID and S_ISGID
masks
Ex:
if(S_ISUID & st_mode)
if(S_ISGID & st_mode)

Setting SUID and GUID

SUID has a value of 4
GUID has a value of 2
chmod 4755 afile -rwsr-xr-x
chmod 2755 afile -rwxr-sr-x
chmod 6755 afile -rwsr-sr-x

File access permissions

Read section 4.5 on page 92. Note

the different permissions required
for operations on regular files
versus directories

access function
Tests to see if the real user ID and real
group ID allow access to a file
Useful if a program that may be running as
another user (ex root) wants to be sure
that the person that started the program
has permissions to access some file
int access(const char *pathname, int mode);
Returns 0 if ok, -1 otherwise

access function (cont)

In this context, mode is not the

same as in previous functions.
Here, mode is the bitwise OR of
several constants

R_OK
W_OK
X_OK
F_OK

- test for read permission

- test for write permission
- test for execute permission
- test for file existence

umask function
mode_t umask(mode_t mask);
Sets the file mode creation mask
file mode creation mask is used to
specify the default permissions of newly
created files
Since we are dealing with a mask it is the
complement of what we want. So we set
the bits corresponding to the permissions
we dont want.

umask function

When using open or creat, any bits

in mode that are also set in the file
creation mask are turned of.
All the UNIX shells also define a shell
command called umask that displays
the default umask set at login. Each
process can change its own mask
without interfering with each other

File Size

st_size member of stat structure holds

the size of a file
Only meaningful for regular files,
directories and symbolic links

Regular file number of bytes in the file

Directories multiple of a number (more on
this later)
Symbolic Links number of chars in
filename

Sticky Bit

Historically

Used to tell the system to keep a copy

of the text portion of a program in
the swap space even after the
program exits. (text = instructions,
not data)
Swap file is contiguous faster start
on next execution.

Sticky Bit

Currently

Used on directories, indicates that in order to

rename or delete a file in that directory a user
must both have write permissions to the
directory and one of the following must be true

User owns the file

User owns the directory
User is the superuser

To set the sticky bit

chmod +t mydir

chmod and fchmod

Allows us to change the existing

permissions for a file

int chmod(const char *path, mode_t mode);

int fchmod(int fildes, mode_t mode);

Returns 0 on success or -1 on failure

mode is bitwise OR of constants shown
on page 99 fig 4.11
Effective UID of process must be the
same as the UID of the file or the process
must have superuser permissions

link, unlink, remove and

rename

link
int link(const char *oldpath, const char *newpath);

Creates a new hard link within the file

system
oldpath is the file to be linked. Newpath
must already exist except for the last
portion which will be created
If all of newpath already exists, an error will
be returned
Returns 0 if ok, -1 otherwise

link, unlink, remove and

rename

unlink
int unlink(const char *pathname);

Removes directory entry indicated by

pathname
Decrements the link count of the file

Must have write and execute on

containing directory
Only when link count reaches 0 and no
process has the file open will it be deleted

link, unlink, remove and

rename

remove
int remove(const char *pathname);

Calls unlink for files and rmdir for

directories

rename
int rename(const char *oldpath, const char *newpath);

Equivelant to mv shell command

Symbolic Links

Indirect pointer to a file or

directory

Created to get around limitations of

hard links

Hard links must live in the same file

system that the think it links to is in
Only superuser can hard link to a
directory

symlink and readlink

symlink

int symlink(const char *oldpath, const char *newpath);

Creates the symbolic link file newpath that

contains the text contained in oldpath
oldpath and newpath may be on different
file systems

readlink

ssize_t readlink(const char *path, char *buf, size_t bufsiz);

open function follows symbolic links.

readlink operates on the link file itself
String from file placed in buf, with number of
bytes in bufsiz. String is not null terminated

File Times

3 times are kept for any file

Last access time

Last modified time
Last status change time

These are stored in the following fields

of the stat struct

st_atime
st_mtime
st_ctime

utime
int utime(const char *filename, const struct utimbuf *buf);
struct utimbuf {
time_t actime;
time_t modtime;
}

actime and modtime are calendar times

marking seconds since Epoch
buf may be NULL, in which case the time is
updated to current system time
Unless using NULL for buf, just having write
permissions is not enough. Effective user ID
must equal owner ID or process must have
superuser privileges

Directory Operations

mkdir and rmdir

int mkdir(const char *pathname, mode_t mode);
int rmdir(const char *pathname);

Create and remove the specified directory

For mkdir, the mode parameter is the same
as those used for open. However, recall that
interactions with the umask may occur!
When creating directories, remember that we
usually want execute permissions so that the
files within the directory can be listed

Reading Directories
DIR *opendir(const char *name);
struct dirent *readdir(DIR *dir);
void rewinddir(DIR *dir);
int closedir(DIR *dir);
off_t telldir(DIR *dir);
void seekdir(DIR *dir, off_t offset);
struct dirent {
ino_t d_ino;
char d_name[NAME_MAX + 1];
}

chdir fchdir and getcwd

int chdir(const char *path);
int fchdir(int fd);
Change the current working directory
of the process
long getcwd(char *buf, unsigned long
size);
Get the current working directory of
the process

Device Special Files

Many devices are represented as

files within /dev directory
Each device has major number and
minor number for the Kernel to
identify it

Major number usually specifies the

driver to use for the device
Minor number may be the specific sub
device or options for that device

Device Special Files

ls lL on a device file will show major

and minor numbers instead of size of
file
st_dev and st_rdev

st_dev for every file is the device number

under the filesystem containing that
filename and its associated i-node
st_rdev (only for character and block
special files) contains actual device
number

Device Special Files

Obtaining the major and minor

numbers

Use the major and minor macros

major(st_dev)
minor(st_dev)

For block and character special

devices use st_rdev instead to obtain
real device number