y_browseremulation.c

Go to the documentation of this file.

/*
 * Ylib Loadrunner function library.
 * Copyright (C) 2012-2014 Floris Kraak <randakar@gmail.com> | <fkraak@ymor.nl>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#ifndef _Y_BROWSER_EMULATION_C_
#define _Y_BROWSER_EMULATION_C_

#include "y_core.c"
#include "y_string.c"


struct y_struct_browser
{
    char* name;
    int chance; 
    void* next; 

    int max_connections_per_host;
    int max_connections;
    char* user_agent_string;
};

typedef struct y_struct_browser y_browser;


#define MAX_BROWSER_LIST_LENGTH 1000

y_browser* y_browser_list_head = NULL;

int y_browser_list_chance_total = 0; 

void y_log_browser(const y_browser* browser)
{
    if(browser == NULL)
    {
        lr_error_message("y_browser_emulation.c: Attempt to log content of NULL browser. Ignoring.");
        return;
    }

    lr_log_message("y_browseremulation.c: browser: %s, chance %d, max_conn_per_host %d, max_conn %d, user agent string: %s",
                   browser->name,
                   browser->chance,
                   browser->max_connections_per_host,
                   browser->max_connections,
                   browser->user_agent_string);
}

void y_save_browser_to_parameters(const y_browser* browser)
{
    if(browser == NULL)
    {
        lr_error_message("y_browser_emulation.c: Attempt to store the content of NULL browser into parameters. Aborting.");
        lr_abort();
        return;
    }

    lr_save_string(browser->name, "browser_name");
    lr_save_int(browser->chance, "browser_chance");
    lr_save_int(browser->max_connections_per_host, "browser_max_connections_per_host");
    lr_save_int(browser->max_connections, "browser_max_connections");
    lr_save_string(browser->user_agent_string, "browser_user_agent_string");
}


int y_setup_browser_emulation_from_parameters(const char* browser_name_param,
                                              const char* browser_chance_param,
                                              const char* browser_max_connections_per_host_param,
                                              const char* browser_max_connections_param,
                                              const char* browser_user_agent_string_param)
{
    int i;
    y_browser* previous_browser = NULL;

    for(i=0; i < MAX_BROWSER_LIST_LENGTH; i++ )
    {
        y_browser* browser;
        char* browser_name = y_get_parameter_with_malloc_or_null(browser_name_param);

        if( browser_name == NULL )
        {
            lr_error_message("Browser name parameter %s does not exist. Aborting browser emulation setup.", browser_name_param);
            return -1;
        }
        if(strcmp(browser_name, "END") == 0)
        {
            free(browser_name);
            lr_log_message("y_browseremulation.c: End of browser list initialisation");
            return 0;
        }

        // Allocate a browser object
        browser = (y_browser*) y_mem_alloc( sizeof browser[0] );
        browser->name = browser_name;
        browser->next = NULL;

        // The next bit is a bit verbose due to all of the checks on missing parameters,
        // but really we're just filling out the remaining fields of the browser struct.
        {
            int error = 0;
            char* browser_chance                   = y_get_parameter_or_null(browser_chance_param);
            char* browser_max_connections_per_host = y_get_parameter_or_null(browser_max_connections_per_host_param);
            char* browser_max_connections          = y_get_parameter_or_null(browser_max_connections_param);

            if( browser_chance == NULL || browser_max_connections_per_host == NULL || browser_max_connections == NULL )
            {
                lr_error_message("Browser parameter missing. Aborting browser emulation setup. chance: %s:%s, max_connections_per_host %s:%s, max_connections %s:%s", 
                                 browser_chance_param, browser_chance,
                                 browser_max_connections_per_host_param, browser_max_connections_per_host,
                                 browser_max_connections_param, browser_max_connections);
                error = 1;
            }
            else if( (browser->user_agent_string = y_get_parameter_with_malloc_or_null(browser_user_agent_string_param)) == NULL )
            {
                lr_error_message("Browser user agent parameter %s does not exist. Aborting browser emulation setup.", browser_user_agent_string_param);
                error = 1;
            }

            if( error )
            {
                free(browser_name);
                free(browser);
                return -1;
            }
            browser->chance                   = atoi(browser_chance);
            browser->max_connections_per_host = atoi(browser_max_connections_per_host);
            browser->max_connections          = atoi(browser_max_connections);
        }

        //lr_log_message("y_browseremulation.c: Adding browser");
        //y_log_browser(browser);

        // Increment the global count of weights.
        y_browser_list_chance_total += browser->chance;
        //lr_log_message("y_browseremulation.c: Adding weight: %d", y_browser_list_chance_total);

        // Add it to the list.
        if( y_browser_list_head == NULL )
        {
            y_browser_list_head = browser;
        }
        else
        {
            previous_browser->next = browser;
        }
        previous_browser = browser; // Replaces the previous tail element with the new one.

        // Get the next value for the new iteration.
        // This parameter should be set to "update each iteration", or this code will play havoc with it ..
        lr_advance_param((char* )browser_name_param);
    }

    if( i == (MAX_BROWSER_LIST_LENGTH) )
    {
        lr_log_message("Too many browsers to fit in browser list struct, max list size = %d", MAX_BROWSER_LIST_LENGTH);
        lr_abort();
        return -1;
    }
    return 0; // No error.
}

int y_setup_browser_emulation()
{
    return y_setup_browser_emulation_from_parameters("browser_name", "browser_chance", "browser_max_connections_per_host", "browser_max_connections", "browser_user_agent_string");
}

int y_setup_browser_emulation_from_file(char* filename)
{
    y_browser* previous_browser = NULL;
    long fp = fopen(filename, "r");
    char line[4096];

    if (fp == NULL)
    {
        lr_error_message("Unable to open file %s", filename);
        lr_abort();
        return -1;
    }
    lr_log_message("Opened file %s", filename);

    // Overflow protection
    line[0] = '\0';
    line[4095] = '\0';

    // Now read the file line by line.
    while(fgets(line, sizeof line, fp))
    {
        char* remove;
        lr_log_message("Read line: %s", line);

        // Remove comments and trailing newlines.
        while( ((remove = strchr(line, '#'))  != NULL) ||
               //((remove = strstr(line, "//")) != NULL) ||
               ((remove = strchr(line, '\r')) != NULL) || 
               ((remove = strchr(line, '\n')) != NULL) )
        {
            remove[0] = '\0';
            //lr_log_message("Stripped line: %s", line);
        }


        { // start namespace for various temporary stack buffers

            char name[4096];
            size_t user_agent_offset;

            y_browser* browser = (y_browser*) y_mem_alloc( sizeof browser[0] );
            int scanresult = sscanf(line, "%4095s   %*f%%   %d  %d  %d  %n",
                name, &browser->chance, &browser->max_connections, &browser->max_connections_per_host, &user_agent_offset);

            // Debug code
//             lr_log_message("Found %d matches", scanresult);
//             switch(scanresult)
//             {
//                 case 5:
//                     lr_log_message("Found at least one too many ..");
//                 case 4:
//                     lr_log_message("user_agent_offset: %d", user_agent_offset); // %n telt niet mee  blijkbaar.
//                     lr_log_message("browser->max_connections_per_host: %d", browser->max_connections_per_host);
//                 case 3:
//                     lr_log_message("browser->max_connections: %d", browser->max_connections);
//                 case 2:
//                     lr_log_message("browser->chance: %d", browser->chance);
//                 case 1:
//                     lr_log_message("name: %s", name);
//             }
            if(scanresult < 4)
            {
                free(browser);
                lr_log_message("Non-matching line.");
                continue;
            }

            // Copy the char* fields into their own allocated memory and store that.
            browser->name = y_strdup(name);
            browser->user_agent_string = y_strdup(line + user_agent_offset);

            // Report the result
            //y_log_browser(browser);

            // Increment the global count of weights.
            y_browser_list_chance_total += browser->chance;
            lr_log_message("y_browseremulation.c: Adding weight: %d", y_browser_list_chance_total);

            // Add it to the list.
            if( y_browser_list_head == NULL )
                y_browser_list_head = browser;
            else
                previous_browser->next = browser;
            previous_browser = browser; // Replaces the previous tail element with the new one.
        } // end namespace
    } // end while loop

    return 0;
}


y_browser* y_choose_browser_from_list(y_browser* browser_list_head, int browser_list_chance_total)
{
    int i, lowerbound, cursor = 0;
    y_browser* browser = NULL;
    long roll;

    if( browser_list_chance_total < 1 )
    {
        lr_error_message("y_browseremulation.c: Browser list not initialised before call to y_choose_browser_from_list(). Cannot choose, ignoring.");
        return NULL;
    }

    // The upper bound of the rand() function is determined by the RAND_MAX constant.
    // RAND_MAX is hardcoded in loadrunner to a value of exactly 32767.
    // In fact, it doesn't even get #defined by loadrunner as as the C standard mandates.
    // (y_core.c does that instead, now  ..)
    // 
    // y_rand() depends on rand() for it's output, so that cannot go above 32767.
    // Update: y_rand() uses Y_RAND_MAX now - slightly over 1 billion.
    // Unfortunately, the list with weights that we use has numbers bigger than that. 
    // 
    // So we'll need to get a bit creative, and multiply the result of y_rand() with
    // the maximum (the total of the browser chances) divided by Y_RAND_MAX to scale things up again.
    // (At the cost of precision ..)
    // 
    // Update: y_rand() now returns a 31 bit number, giving it an upper bound of 2147483647 (Y_RAND_MAX).
    // That should reduce the need for this code by a bit ..
    // 

    roll = y_rand() % browser_list_chance_total;
    //lr_log_message("browser_list_chance_total = %d, RAND_MAX = %d, roll %d", browser_list_chance_total, RAND_MAX, roll);
    if( Y_RAND_MAX < browser_list_chance_total)
    {
        roll = roll * ((browser_list_chance_total / RAND_MAX));
    }
    //lr_log_message("Roll: %d", roll);

    for( browser = browser_list_head; browser != NULL; browser = browser->next)
    {
        cursor += browser->chance;
        // lr_log_message("Chance cursor: %d for browser: %s", cursor, browser->name);

        if(roll <= cursor)
        {
            //lr_log_message("Chosen browser:");
            //y_log_browser(browser);
            return browser;
        }
    }
    // This code should be unreachable.
    lr_error_message("y_browseremulation.c: Roll result out of bounds: roll: %d, cursor: %d, browser_list_chance_total %d", roll, cursor, browser_list_chance_total);
    return browser;
}

y_browser* y_choose_browser()
{
    return y_choose_browser_from_list(y_browser_list_head, y_browser_list_chance_total);
}

int y_emulate_browser(y_browser* new_browser)
{
    char str_max_connections[12];
    char str_max_connections_per_host[12];
    int max_connections;
    static y_browser* previous_browser;
    y_browser* browser;

    if( new_browser == NULL )
    {
        if( previous_browser == NULL )
        {
            lr_error_message("y_browser_emulation.c: Attempt to emulate the NULL browser: Ignored.");
            return -1;
        }
        else
        {
            browser = previous_browser;
        }
    }
    else
    {
        browser = new_browser;
        previous_browser = browser;
    }

    lr_log_message("Emulating browser:");
    y_log_browser(browser);

    // Loadrunner doesn't accept values higher than 50 for this sockets option, so we'll just log it and set it to 50.
    max_connections = browser->max_connections;
    if( max_connections > 50 )
    {
        lr_log_message("y_browser_emulation.c: Loadrunner does not support using more than 50 browser connections. Using 50 connections instead of %d.", max_connections);
        max_connections = 50;
    }

    snprintf(str_max_connections,          sizeof str_max_connections,          "%d", max_connections);
    snprintf(str_max_connections_per_host, sizeof str_max_connections_per_host, "%d", browser->max_connections_per_host);

    // Now finally set the correct settings for the chosen browser:
    web_set_sockets_option("MAX_CONNECTIONS_PER_HOST", str_max_connections_per_host);
    web_set_sockets_option("MAX_TOTAL_CONNECTIONS",    str_max_connections);
    web_add_auto_header("User-Agent", browser->user_agent_string);
    return 0;
}


// --------------------------------------------------------------------------------------------------
#endif // _Y_BROWSER_EMULATION_C_