1.1   Syllabus

• gcc, make, vi
• File I/O
• Process management
• Pipes
• Signals
• Sockets

2.1   Getting help

• An online reference for the C language:

  http://en.cppreference.com/w/c
• The manual pages, both from the terminal and online:

  http://linux.die.net/man/
• The GNU C library manual:

  https://www.gnu.org/software/libc/manual/html_node/index.html
• A quick tutorial on the C language:

  http://www.tutorialspoint.com/cprogramming/c_quick_guide.htm

2.2   System calls

• Specific procedure, as processor needs to switch to supervisor mode
• The standard C library provides C-wrappers
• Documented in section 2; see also section 3 and section 7
• 380 system calls for Linux 3.2.0, see syscalls(2)

2.3   Error handling

• System calls almost always return -1 (or NULL) when an error occurs

• C library makes available an explanation through variable

  extern int errno;
  

  defined in <errno.h>, see errno(3)

2.4   First example

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <err.h>

int main(int argc, char *argv[])
{
   fprintf(stderr, "EACCES: %s\n", strerror(EACCES));
   errno = ENOENT;
   warn ("%s: The error ENOENT", argv[0]);
   exit(0);
}

• Use exit(3) or simply return from the main function to terminate the program. The return code of the program is the value passed to exit or returned from main.

2.5   Compiling with gcc

Assume you have a small project consisting on two C files, main.c, containing the main() function of the program, and aux.c, containing auxiliary code.

Compiling and linking with one command:

gcc aux.c main.c -o myprog

Compiling into object code + linking:

gcc aux.c        # outputs aux.o
gcc main.c       # outputs main.o
gcc aux.o main.o -o myprog

The advantage of the second method is that it requires compiling only the files that were modified since last compilation (+ linking)

Here are some frequent options:

-g
-Wall
-Wextra
-O1, -O2, -O3
-lm
-lMY_LIB
-I INCLUDE_DIR
-D MACRO=VALUE

2.6   Using make

• The tool make computes which parts of a program need to be recompiled and calls the compiler accordingly

• Information about the source code is in the file Makefile (or makefile)

• Target-oriented rules of the form:

  target : prerequisite1 prerequisite2
  <TAB> shell commands using the prerequisites and generating the target
  <TAB> more shell commands
  

• Observe that the commands need to be prefixed with a tab (!)

• The target of the first rule in the Makefile becomes the default target

First example of a Makefile:

myprog: main.c aux.c
    gcc -Wall -Wextra -g aux.c main.c -o myprog

A more advanced version:

myprog: main.o aux.o
    gcc main.o aux.o -o myprog

main.o: main.c
    gcc -Wall -Wextra -g -c main.c

aux.o: aux.c
    gcc -Wall -Wextra -g -c aux.c

Now the same but using pattern rules and automatic variables:

myprog: main.o aux.o
    gcc $^ -o $@

%.o: %.c
    gcc -Wall -Wextra -g -c $^ -o $@

In fact, make already knows the pattern rule above, not only for C but also for many other languages! Such built-in rules (which you can display running make -p) are parametrized with variables. An even shorter version of our Makefile would be:

CC=gcc
CFLAGS=-Wall -Wextra -g

myprog: main.o aux.o
    gcc $^ -o $@

Some frequently used options of make are

-n
-j N
-p

8.1   Exercise, the command tcpcat

The goal of this exercise is writing a simplified version of the netcat(1) command. The output should be called tcpcat, and it will be able to both open TCP connexions as a client and act as a TCP server, with the following syntax and functionality:

• $ tcpcat HOST PORT

  where HOST is either an IP address or an URL, and PORT is a port number.

  This command will open a connection to the port PORT of the host HOST. It will send anything written to its standard input and write on standard output anything received from the connection.

• $ tcpcat -l PORT

  where PORT is a port number.

  This command will open a listening TCP socket accepting incoming connections from any network card. It will accept one client, will send to it anything read from its standard input, and will write to the standard output anything received from the connection.

Note: you do not have the right to use threads to implement this program, use either poll(2) or select(2).