In this lab, you will learn the following topics and practice C programming skills.

1. Using ln and identifying links
2. Using lseek() and manipulat file descriptor offsets
3. using fseek() and manipulating FILE * pointer offsets

Run the following command

~aviv/bin/ic221-up

Change into the lab directory

cd ~/ic221/labs/10

All the material you need to complete the lab can be found in the lab directory. All material you will submit, you should place within the lab directory. Throughout this lab, we refer to the lab directory, which you should interpret as the above path.

For this lab, all ubmission should be placed in the following folder:

~/ic221/labs/10/

This directory contains 4 sub-directories; examples, timer, term-status, and mini-sh. In the examples directory you will find any source code in this lab document. All lab work should be done in the remaining directories.

• Only source files found in the folder will be graded.
• Do not change the names of any source files

Finally, in the top level of the lab directory, you will find a README file. You must complete the README file, and include any additional details that might be needed to complete this lab.

You are not required to provide your own Makefiles for this lab.

In the top level of the lab directory, you will find a README file. You must fill out the README file with your name and alpha. Please include a short summary of each of the tasks and any other information you want to provide to the instructor.

You are provided a test script which prints pass/fail information for a set of tests for your programs. Note that passing all the tests does not mean you will receive a perfect score: other tests will be performed on your submission. To run the test script, execute test.sh from the lab directory.

./test.sh

You can comment out individual tests while working on different parts of the lab. Open up the test script and place comments at the bottom where appropriate.

Working versions of all the programs described in this lab document can be found here:

~aviv/lab10-bin/llines
~aviv/lab10-bin/flines

Run these programs as a comparison point.

ln path1 path2

This will create a new file at path2 that is hard linked with the file at path1.

#> touch f
#> ls -l
total 0
-rw-r----- 1 aviv scs 0 Mar 25 08:55 f
#> ln f hl
#> ls -l
total 0
-rw-r----- 2 aviv scs 0 Mar 25 08:55 f
-rw-r----- 2 aviv scs 0 Mar 25 08:55 hl

A symbolic link is created in a similar way, but with ln -s.

#> ln -s f sl
#> ls -l
total 0
-rw-r----- 2 aviv scs 0 Mar 25 08:55 f
-rw-r----- 2 aviv scs 0 Mar 25 08:55 hl
lrwxrwxrwx 1 aviv scs 1 Mar 25 08:55 sl -> f

And we can also mix linking by creating a hard link to a symbolic link, which is the same as duplicating the symbolic link:

#> ln sl g
#> ls -l
total 0
-rw-r----- 2 aviv scs 0 Mar 25 08:55 f
lrwxrwxrwx 2 aviv scs 1 Mar 25 08:55 g -> f
-rw-r----- 2 aviv scs 0 Mar 25 08:55 hl
lrwxrwxrwx 2 aviv scs 1 Mar 25 08:55 sl -> f

Finally, we can analyze all the linking by viewing the i-node information with ls -li

#> ls -il
total 0
33426412 -rw-r----- 2 aviv scs 0 Mar 25 08:55 f
33426413 lrwxrwxrwx 2 aviv scs 1 Mar 25 08:55 g -> f
33426412 -rw-r----- 2 aviv scs 0 Mar 25 08:55 hl
33426413 lrwxrwxrwx 2 aviv scs 1 Mar 25 08:55 sl -> f

Both f and hl have the same i-node (33426412) and g and sl have the same i-node (33426413).

Symbolic links can be relative or absolute. We will use relative links for this lab. Recall that the following does not work:

#> echo "Hello World" > a
#> cat a
Hello World
#> mkdir dir1
#> ln -s a dir1/a
#> ls -l dir1
total 0
lrwxrwxrwx 1 aviv scs 1 Mar 25 09:03 a -> a

The link a -> a refers to itself, not the a in the top level directory. Trying to follow this link results in a loop and an error:

#> cat dir1/a 
cat: dir1/a: Too many levels of symbolic links

Instead, the relative path needs to be established:

#> ln -s ../a dir1/a
#> ls -l dir1
total 0
lrwxrwxrwx 1 aviv scs 4 Mar 25 09:07 a -> ../a

It is conceptually easier to always change into the directory where the link is to be created to make the relatively linking more obvious:

#> cd dir1/
#> ln -s ../a b
#> ls -l
total 0
lrwxrwxrwx 1 aviv scs 4 Mar 25 09:07 a -> ../a
lrwxrwxrwx 1 aviv scs 4 Mar 25 09:12 b -> ../a

Recall that there exists two primary ways for interacting with files in C in unix. The first is the standard low level way of file descriptors. To open a file as a file descriptor we use open() and then to read and write with read() and write(), all of these are system calls. For example:

int main(){
  char hello[] = "Hello World!\n";
  int fd = open("hello.txt", O_CREATE | O_WRONLY, 0644);

  write(fd, hello, strlen(hello));

  close(fd);

}

There also exists a standard library interface for files called file streams which we also use. Here, we open a file with fopen() and we can read and write from it using an assortment of standard library routines, like fprintf() fscanf() fgetc() fputc() and etc. Here is an example:

int main(){
  FILE * stream = fopen("hello.txt", "w");

  fprintf(stream, "Hello World!\n");

  fclose(stream);
}

Depending on the task, you may chose to use file descriptors or file streams, but it is important to understand how to do both. Of course, under the surface somewhere, a file stream must interact with a file descriptor since that is the standard interface for read/writing files on Unix.

For file descriptors the command to adjust an offset is lseek() which has the following function prototype:

off_t lseek(int fd, off_t offset, int whence);

It takes in a file descriptor fd and off_t offset, which is just a long integer, and an integer whence. The best way to think about the process of adjusting the offset is that you are moving the cursor within the file to a new offset as measured by whence, or offset + whence is where the cursor is places. To help with this process, there are three constants you can use for whence:

• SEEK_SET : Offset set to offset bytes, that is, whence refers to the start of the file
• SEEK_CUR : Offset is set based on the current location of offset, that is whence refers to the current location when adjusting the offset.
• SEEK_END : Offset is set based on the size of the file, that is whence refers tot he end of the current file. You can seek beyond the end of a file, but it is not advisable for this lab.

The return value of lseek() is the new offset in the file, or the current location of the read/write cursor. Let's look at some example uses of lseek():

• lseek(fd, 0, SEEK_SET) will reset the offset to the start of the file since SEEK_SET is used for whence with at an additive offset.
• lseek(fd, 10, SEEK_SET) will set the offest 10 bytes into the file.
• lseek(fd, -10, SEEK_CUR) will move the offest 10 bytes towards from the start of the file from the current location
• lseek(fd,0,SEEK_END) will move the offset to the end of the file.
• lseek(fd,0,SEEK_CUR) will not move the offset at all, but will return the current offset.

The standard library mechanism for adjusting the offset is fseek() which has a nearly identical function declaration:

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

The stream is the file stream to adjust the offset, the long is the offset to set based on whence. Again, SEEK_SET, SEEK_CUR, and SEEK_END are constants that can be used for whence. There are two additional useful functions:

long ftell(FILE *stream);

void rewind(FILE *stream);

ftell() returns the current offset in the file, while rewind() will set the offset to the start of the file.