Voir la source de 20180205:TP:C:TCP:SimpleServer

[[category:EPITA:TP:20172018]]

== Introduction ==

This session is dedicated to simple server. We'll do two basic server: an echo server and a ''bc server''.

In order to test your server, you'll need to use a basic TCP client able to send text like <tt>telnet</tt> or <tt>nc</tt> (netcat). You should prefer <tt>nc</tt> since it doesn't send, by default, the double end-line characters CR/LF (<tt>\n\r</tt>).

=== Submission ===

The folder name for this session is <tt>20180205_tcp_server</tt>, the expected architecture is as follow:

* <tt>20180205_tcp_server</tt>
** <tt>AUTHORS</tt>
** <tt>echo_server</tt>: directory for the first exercise (source and <tt>Makefile</tt>)
** <tt>bc_server</tt>: directory for the second exercise (source and <tt>Makefile</tt>)

As usual, you should submit your work before next monday 2pm.

== Helping Code ==

This section provides some piece of code that can be useful:

* setting signal handler correctly for <tt>SIGINT</tt> (with some tricks to close accepting socket.)
* setting signal handler correctly for <tt>SIGCHLD</tt>
* using <tt>getaddrinfo(3)</tt> in order to set-up server-side socket

=== SIGINT ===

We want to be able to close our server using <tt>SIGINT</tt> (<tt>Ctrl-C</tt> in your terminal.) For that we need to set-up correctly a signal handler that will close the file descriptor of the accepting socket.

The idea is to define a function with a static variable that store the accept socket FD, a function runned with <tt>SIGINT</tt> is received and then calling <tt>sigaction(2)</tt> correctly.

First, the functions:

<source lang="C">
// register an fd or get it
// call with -1 if you just want the fd
int fdaccept_register(int fd) {
  static int fdaccept = -1;
  if (fdaccept == -1 && fd != -1) {
    fdaccept = fd;
  }
  return fdaccept;
}

// signal handler for SIGINT
void sigint_handler(int sig) {
  (void)sig;
  int fd = fdaccept_register(-1);
  if (fd != -1)
    close(fd);
  _exit(0);
}
</source>

Now, in your main, before starting anything, you can add the following code:

<source lang="C">
  struct sigaction sigint;

  // Handle terminaison through Ctrl-C
  memset(&sigint, 0, sizeof (struct sigaction));
  sigint.sa_handler = sigint_handler;
  sigfillset(&sigint.sa_mask);
  sigint.sa_flags = SA_NODEFER;
  if ( sigaction(SIGINT, &sigint, NULL) == -1)
    err(EXIT_FAILURE, "can't change SIGINT behavior");
</source>

=== SIGCHLD ===

<tt>SIGCHLD</tt> is the signal sent when a child process dies. Normally we should handle it and perform a <tt>wait(2)</tt> in order to discard zombie process, but there exists a flag for <tt>sigaction(2)</tt> that indicate that we don't want zombie at all, so we don't need an handler function, just a correct set-up of <tt>sigaction(2)</tt>:

<source lang="C">
  struct sigaction sigchld;

  // Avoid zombies and don't get notify about children
  memset(&sigchld, 0, sizeof (struct sigaction));
  sigchld.sa_handler = SIG_DFL;
  sigemptyset(&sigchld.sa_mask);
  sigchld.sa_flags = SA_NOCLDSTOP | SA_NOCLDWAIT;
  if ( sigaction(SIGCHLD, &sigchld, NULL) == -1 )
    err(EXIT_FAILURE, "can't change SIGCHLD behavior");
</source>

This code should be placed near the code for <tt>SIGINT</tt> in you main.

=== Using <tt>getaddrinfo(3)</tt> for server-side socket ===

Last week we use <tt>getaddrinfo(3)</tt> on client-side, now we'll see that we can also use it on server-side.

The principle is the same, somehow simpler: set some hints (mainly port number or service name) and call the function. Here is a little code sample:

<source lang="C">
  int info_err = 0;
  struct addrinfo hints, *resinfo = NULL;

  // setup hints and get local info
  memset(&hints, 0, sizeof (struct addrinfo));
  hints.ai_family = AF_UNSPEC;                 // IPv4 or IPv6
  hints.ai_socktype = SOCK_STREAM;             // TCP
  hints.ai_protocol = 0;
  hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG; // server mode
  // let's go !
  info_err = getaddrinfo(NULL, portname, &hints, &resinfo);

  // Error management
  if (info_err != 0) {
    errx(EXIT_FAILURE, "Server setup fails on port %s: %s", portname,
	 gai_strerror(info_err));
  }
</source>

Once done, <tt>resinfo</tt> will points to a struct <tt>addrinfo</tt> with everything we need for <tt>socket(2)</tt> and <tt>bind(2)</tt>.

What you'll use:

* <tt>resinfo->ai_family</tt>, <tt>resinfo->ai_socktype</tt> and <tt>resinfo->ai_prototype</tt> for <tt>socket(2)</tt>
* <tt>resinfo->ai_addr</tt> and <tt>resinfo->ai_addrlen</tt> for <tt>bind(2)</tt>

After creating your socket and binding it, you'll to release <tt>resinfo</tt> using <tt>freeaddrinfo(3)</tt>.

== A simple echo server ==

An echo server is a TCP server that sends back what it receive, nothing less, nothing more.

=== Echo function ===

In order to prepare your server (and to avoid long and boring testing) you should write an echo function, which in fact is the same as a cat function: it takes an input FD and an output FD, read on input (until end of the stream) and write received data to the output.

You must be careful on error management:

* check returns of <tt>read(2)</tt> and <tt>write(2)</tt>
* continue reading/writing when error (<tt>errno</tt> value) is <tt>EINTR</tt>, <tt>EAGAIN</tt> or <tt>EWOULDBLOCK</tt>.
* be sure when sending that all data have been sent and restart when needed.

* '''Implement the following function:'''
<source lang="C">
void echo(int fdin, int fdout);
</source>

Since input and output are independent, you can test your code like a cat function, or run it with <tt>STDIN_FILENO</tt> and <tt>STDOUT_FILENO</tt>.

=== Server ===

Now we need to set-up the server. Here is a sketch of the server function:

* define hints and get info (see previous section) using <tt>getaddrinfo(3)</tt>
* create the socket using <tt>socket(2)</tt>
* set the option <tt>SOL_REUSEADDR</tt> using <tt>setsockopt(2)</tt> (see below)
* save the socket FD using our function <tt>fdaccept_register</tt>
* bind the socket to the address information using <tt>bind(2)</tt>
* start listening using <tt>listen(2)</tt>
* now you can enter the accepting loop (see below.)

We want to set the option <tt>SOL_REUSEADDR</tt> in order to minimize port reuse issues. You can do that this way (assuming <tt>fdaccept</tt> is your socket):

<source lang="C">
  int reuse_err;
  int reuse = 1;
  reuse_err = setsockopt(fdaccept, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof (reuse));

  // Error management
  if (reuse_err == -1)
    err(EXIT_FAILURE, "Fail to set socket options");
</source>

All this code should be grouped in a ''server'' function:

<source lang="C">
void server(const char *portname);
</source>

'''Remarque:''' you need to do error management for all system calls and once the socket is created (especially after binding) you need to close it before leaving the program !

For error management, use <tt>err(3)</tt>: it's clean, easy, prints readable error messages depending on <tt>errno</tt>.

==== Accepting loop: one by one ====

Our first attempt for the accepting loop will be a simple one connexion at a time variant. Here is the idea:

* loop forever (<tt>for(;;)</tt>)
** accept incoming connexion using <tt>accept(2)</tt> store FD in <tt>fdcnx</tt>
** call <tt>echo(fdcnx, fdcnx)</tt>
** close <tt>fdcnx</tt>

And don't forget error management.

For <tt>accept(2)</tt> we only need the first parameter (the listening socket), remaining parameters will be <tt>NULL</tt> or <tt>0</tt> (check the type, please.)

This version can already be tested (see below.)

==== Accepting loop: using <tt>fork(2)</tt> ====

This loop is similar to the previous one but:

* once accepting you'll fork
* in the parent process, you'll close the connexion socket and loop (use <tt>continue</tt>)
* in the child process, you'll close the accepting socket, run <tt>echo</tt>, close socket and exit.

=== Program and tests ===

We can now build our program. You need to add the correct includes (read the manual pages) and build a main that perform the following actions

* check if there's an argument, exit with an error message if it's not the case.
* set signal handlers as described in the first section
* run server with the first argument (<tt>argv[1]</tt>)
* leave.

In order to test, you'll need at least 2 terminals, one for launching the server and another one for connexion.

For the server:

<pre>
shell> make echo_server
gcc -fsanitize=address -Wall -Wextra -std=c99 -O0 -g    echo_server.c   -o echo_server
shell> ./echo_server 4242

</pre>

In the other terminal, now you can test:

<pre>
# check if server is listening
shell> netstat --inet -l | grep 4242
tcp        0      0 *:4242                  *:*                     LISTEN
# test it now
shell> nc 127.0.0.1 4242
hello
hello
echo me please !
echo me please !
shell>
</pre>

''In order to leave <tt>nc</tt>, just hit <tt>Ctrl-D</tt>''.

You can leave your server with <tt>Ctrl-C</tt>.

== A bc server ==

<tt>bc(1)</tt> is a shell command providing functionality of a symbolic calculator, try it, it's easy to use.

Our goal, is to write a simple server that accept connexion then redirect <tt>STDIN_FILENO</tt> and <tt>STDOUT_FILENO</tt> to the connexion socket and exec (using <tt>execvp(3)</tt>) the command <tt>bc</tt>.

You just need to take the code of the previous program and replace the echo part with a correct call to <tt>execvp(3)</tt> using redirections (with <tt>dup2(2)</tt>.)

Here is a test session using the 2 terminals:

Server side:
<pre>
shell> make bc_server
gcc -fsanitize=address -Wall -Wextra -std=c99 -O0 -g    bc_server.c   -o bc_server
shell> ./bc_server 4242

</pre>

Client side:
<pre>
shell> nc 127.0.0.1 4242
1 + 1
2
sqrt(1024)
32
27972 / 42
666
quit
</pre>

Since <tt>bc</tt> outputs its error on <tt>STDERR_FILENO</tt> it can be interesting to redirect it also, but that's not mandatory.

You can also replace <tt>bc</tt> with any similar command (it just needs to read on its standard input and write it's result on standard output.)