/**

 * ddos/server.c

 * Copyright (C) 2008 Markus Broeker

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <netdb.h>

#include <signal.h>

int set_proc_limit (int);

int server_write (int client_socket, char *s)

{

    return write (client_socket, s, strlen (s));

}

int server_init (char *port)

{

    int server_socket, status;

    struct addrinfo hints;

    struct addrinfo *result, *rp;

    int yes = 1, no = 0;

    memset (&hints, 0, sizeof (hints));

    hints.ai_family = AF_UNSPEC;

    hints.ai_socktype = SOCK_STREAM;

    hints.ai_flags = AI_PASSIVE;

    if (getaddrinfo (NULL, "4000", &hints, &result) < 0) {

        perror ("GETADDRINFO");

        return -1;

    }

    server_socket = -1;

    for (rp = result; rp != NULL; rp = rp->ai_next) {

        if ((server_socket = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol)) < 0) {

            perror ("SOCKET");

            continue;

        }

        // enable rebinding of the socket

        if (setsockopt (server_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof (int)) == -1) {

            perror ("setsockopt");

            return -1;

        }

        // disable IPV6ONLY, eg enable an hybrid socket

        if (rp->ai_family == AF_INET6)

        if ((bind (server_socket, rp->ai_addr, rp->ai_addrlen)) == -1) {

            perror ("BIND");

            close (server_socket);

            server_socket = -1;

        } else {

        }

    }

    status = listen (server_socket, 10);

    if (status != 0) {

        perror ("LISTEN");

        return -1;

    }

    if (result != NULL)

        freeaddrinfo (result);

    return server_socket;

}

int main (int argc, char **argv)

{

    int server_socket;

    int client_socket;

    char message[MAXLEN + 1];

    int len;

    pid_t pid;

    pid_t parent_pid;

        return EXIT_FAILURE;

    int links = 0;

    parent_pid = getpid ();

    /*

     * Child quits immediately, father mustn't wait

     */

    signal (SIGCHLD, SIG_IGN);

    if (set_proc_limit (200) != 0) {

        printf ("Cannot limit the process limit\n");

        return EXIT_FAILURE;

    }

    for (;;) {

        client_socket = accept (server_socket, NULL, NULL);

        printf ("PARENT PID = %d\n", parent_pid);

        pid = fork ();

        switch (pid) {

        case 0:                /* Child */

            close (server_socket);

            if ((len = read (client_socket, message, MAXLEN)) == -1)

                break;

            message[len] = '\0';

            len = server_write (client_socket, "Please wait...\r\n");

            sleep (10);

            printf ("DELETING LINK [%04d] %04d\n", getpid (), links--);

            shutdown (client_socket, SHUT_RDWR);

            close (client_socket);

            return 1;

        case -1:

            perror ("Fork Error");

            close (client_socket);

            /*

             * server is still alive and will continue when resources are available

             */

            break;

        default:               /* PID > 0 */

            close (client_socket);

            printf ("Starting LINK [%04d] %04d\n", pid, links++);

        }

    }

    return close (server_socket);

}