stdin: Increase input buffer size.

[paraslash.git] / server.c

diff --git a/server.c b/server.c
index 1e4caf08c90d0e04233a987f6e520e19850c20c5..2e5f5f748887f91e257f8065c134d53253f1b7af 100644 (file)
--- a/server.c
+++ b/server.c
@@ -59,7 +59,7 @@
  *     - Ring buffer: \ref ringbuffer.c, \ref ringbuffer.h,
  *     - Hashing: \ref hash.h, \ref sha1.h, \ref sha1.c,
  *     - Crypto: \ref crypt.c.
- *
+ *     - Forward error correction: \ref fec.c
  */
 
 #include <signal.h>
@@ -291,15 +291,32 @@ static void signal_post_select(struct sched *s, struct task *t)
                        if (pid != mmd->afs_pid)
                                continue;
                        PARA_EMERG_LOG("fatal: afs died\n");
-                       goto genocide;
+                       kill(0, SIGTERM);
+                       goto cleanup;
                }
                break;
        /* die on sigint/sigterm. Kill all children too. */
        case SIGINT:
        case SIGTERM:
                PARA_EMERG_LOG("terminating on signal %d\n", st->signum);
-genocide:
                kill(0, SIGTERM);
+               /*
+                * We must wait for afs because afs catches SIGINT/SIGTERM.
+                * Before reacting to the signal, afs might want to use the
+                * shared memory area and the mmd mutex.  If we destroy this
+                * mutex too early and afs tries to lock the shared memory
+                * area, the call to mutex_lock() will fail and terminate the
+                * afs process. This leads to dirty osl tables.
+                *
+                * There's no such problem with the other children of the
+                * server process (the command handlers) as these reset their
+                * SIGINT/SIGTERM handlers to the default action, i.e.  these
+                * processes get killed immediately by the above kill().
+                */
+               PARA_INFO_LOG("waiting for afs (pid %d) to die\n",
+                       (int)mmd->afs_pid);
+               waitpid(mmd->afs_pid, NULL, 0);
+cleanup:
                free(mmd->afd.afhi.chunk_table);
                free(mmd->afd.afhi.info_string);
                close_listed_fds();
@@ -318,25 +335,15 @@ static void init_signal_task(void)
        st->task.post_select = signal_post_select;
        sprintf(st->task.status, "signal task");
 
+       PARA_NOTICE_LOG("setting up signal handling\n");
        st->fd = para_signal_init(); /* always successful */
-
-       PARA_NOTICE_LOG("setting up signal handlers\n");
-       if (para_install_sighandler(SIGINT) < 0)
-               goto err;
-       if (para_install_sighandler(SIGTERM) < 0)
-               goto err;
-       if (para_install_sighandler(SIGHUP) < 0)
-               goto err;
-       if (para_install_sighandler(SIGCHLD) < 0)
-               goto err;
-       if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
-               goto err;
+       para_install_sighandler(SIGINT);
+       para_install_sighandler(SIGTERM);
+       para_install_sighandler(SIGHUP);
+       para_install_sighandler(SIGCHLD);
+       para_sigaction(SIGPIPE, SIG_IGN);
        add_close_on_fork_list(st->fd);
        register_task(&st->task);
-       return;
-err:
-       PARA_EMERG_LOG("could not install signal handlers\n");
-       exit(EXIT_FAILURE);
 }
 
 static void command_pre_select(struct sched *s, struct task *t)
@@ -352,6 +359,8 @@ static void command_post_select(struct sched *s, struct task *t)
        int new_fd, ret, i;
        char *peer_name;
        pid_t child_pid;
+       uint32_t *chunk_table;
+       char *info_string;
 
        if (!FD_ISSET(sct->listen_fd, &s->rfds))
                return;
@@ -364,6 +373,16 @@ static void command_post_select(struct sched *s, struct task *t)
        mmd->num_connects++;
        mmd->active_connections++;
        random();
+       /* The chunk table and the info_string are pointers located in the
+        * mmd struct that point to dynamically allocated memory that must be
+        * freed by the parent and the child. However, as the mmd struct is in
+        * a shared memory area, there's no guarantee that after the fork these
+        * pointers are still valid in child context. As these two pointers are
+        * not used in the child anyway, we save them to local variables and
+        * free the memory via that copy in the child.
+        */
+       info_string = mmd->afd.afhi.info_string;
+       chunk_table = mmd->afd.afhi.chunk_table;
        child_pid = fork();
        if (child_pid < 0) {
                ret = -ERRNO_TO_PARA_ERROR(errno);
@@ -374,6 +393,9 @@ static void command_post_select(struct sched *s, struct task *t)
                /* parent keeps accepting connections */
                return;
        }
+       /* mmd might already have changed at this point */
+       free(info_string);
+       free(chunk_table);
        alarm(ALARM_TIMEOUT);
        close_listed_fds();
        para_signal_shutdown();
@@ -514,19 +536,13 @@ static void server_init(int argc, char **argv)
         * before the child gets a chance to ignore this signal -- only the
         * good die young.
         */
-       if (signal(SIGUSR1, SIG_IGN) == SIG_ERR) {
-               PARA_EMERG_LOG("failed to ignore SIGUSR1\n");
-               exit(EXIT_FAILURE);
-       }
+       para_sigaction(SIGUSR1, SIG_IGN);
        /*
         * We have to install a SIGCHLD handler before the afs process is being
         * forked off. Otherwise, para_server does not notice if afs dies before
         * the SIGCHLD handler has been installed by init_signal_task() below.
         */
-       if (signal(SIGCHLD, tmp_sigchld_handler) == SIG_ERR) {
-               PARA_EMERG_LOG("failed to install temporary SIGCHLD handler\n");
-               exit(EXIT_FAILURE);
-       }
+       para_sigaction(SIGCHLD, tmp_sigchld_handler);
        PARA_NOTICE_LOG("initializing the audio file selector\n");
        afs_socket = init_afs();
        init_signal_task();