y_core.c

Go to the documentation of this file.

/*
 * Ylib Loadrunner function library.
 * Copyright (C) 2005-2014 Floris Kraak <randakar@gmail.com> | <fkraak@ymor.nl>
 * Copyright (C) 2009 Raymond de Jongh <ferretproof@gmail.com> | <rdjongh@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_CORE_C_
#define _Y_CORE_C_

#include "vugen.h"

int y_virtual_user_id = 0;
char* y_virtual_user_group = NULL;
int y_scid;
int y_is_vugen_run_bool = 0;

#ifndef RAND_MAX

#define RAND_MAX 32767
#endif

#ifdef WINNT
    #define Y_RAND_MAX 2147483647
#else
    #define Y_RAND_MAX 1073741823
#endif

void y_setup()
{
    // if this is filled y_setup() has already been called.
    if( y_virtual_user_group != NULL )
    {
        return;
    }

    // Loadrunner sets the locale to "", causing scripts running in locales other than en_US to misbehave.
    // Let's set it to something sensible, that actually works for people who don't want to mess with this stuff.
    setlocale(LC_ALL, "C");

    // Global variables, handle with care
    lr_whoami(&y_virtual_user_id, &y_virtual_user_group, &y_scid);
    y_is_vugen_run_bool = y_virtual_user_id == -1;
    
    // srand() no longer required on Windows but rand() may still be used in user code so we leave it in.
    srand(time(NULL) + y_virtual_user_id + ((int)y_virtual_user_group) & 1023);
}

#define vuser_init() vuser_init() { y_setup(); return y_vuser_init(); } y_vuser_init()

#define y_is_vugen_run() y_is_vugen_run_bool

long y_rand(void)
{
   // Because rand() does not return numbers above 32767 and we want to get at least 30 of the 31 bits
   // of randomness that a long affords us we are going to roll multiple numbers and basically 
   // concatenate them together using bit shifts.
   // 
   // (If we were to go to 32 bits this function would return negative numbers, which would be undesirable
   // because it will break people's expectations of what rand() does.)
#ifdef WINNT
    // On Windows we can use rand_s which returns a truly 32 bit random number. But we strip off the sign bit. 
    unsigned int randomValue;
    rand_s(&randomValue);
    return randomValue & Y_RAND_MAX;
#else
    return rand() << 15 | rand();
#endif
}

double y_drand(void)
{
#ifdef WINNT
    // On Windows we can use rand_s which returns a truly 32 bit random number. 
    unsigned int randomValue;
    rand_s(&randomValue);
    return (double)randomValue / 4294967296.;
#else
    return (rand() << 15 | rand())/1073741824.;
#endif
}


char *y_mem_alloc(size_t size)
{
    char *buff;
    buff = malloc(size);
    if (!buff)
    {
        lr_error_message("Insufficient memory available, requested %u bytes", size);
        // If this happens you're pretty much screwed anyway.
        lr_abort(); 
    }
    return buff;
}


char *y_array_alloc(size_t length, size_t size)
{
    char *buff;
    buff = calloc(length, size);
    if (!buff)
    {
        lr_error_message("Insufficient memory available, requested %u * %u bytes", length, size);
        // If this happens you're pretty much screwed anyway.
        lr_abort();
    }
    return buff;
}


char* y_strdup(char* source)
{
    char* result = strdup(source);
    if (!result)
    {
        lr_error_message("Out of memory while calling strdup()");
        lr_abort();
    }
    return result;
}

char* y_get_parameter_eval_string(const char *param_name)
{
    size_t size = strlen(param_name) +3; // parameter name + "{}" + '\0' (end of string)
    char *result = y_mem_alloc( size ); 

    snprintf(result, size, "{%s}", param_name );
    return result;
}

int y_is_empty_parameter(const char *param_name)
{
    char* param_eval_string = y_get_parameter_eval_string(param_name);
    char* param = lr_eval_string(param_eval_string);
    
    int result = *param == 0 || strcmp(param, param_eval_string) == 0;
    free(param_eval_string);

    return result;
}

char* y_get_parameter(const char* param_name)
{
   char* tmp = y_get_parameter_eval_string(param_name);
   char* parameter = lr_eval_string(tmp);
   free(tmp);
   
   return parameter;
}


char* y_get_parameter_or_null(const char* param_name)
{
    char* param_eval_string = y_get_parameter_eval_string(param_name);
    char* param = lr_eval_string(param_eval_string);

    int exists = strcmp(param, param_eval_string) != 0; // Result doesn't match the param eval string (eg: '{param}')
    //lr_log_message("y_get_parameter_or_null for param_name %s, pre-eval string is %s, lr_eval_string result is %s, exists: %d", param_name, param_eval_string, param, exists);
    free(param_eval_string);
    //lr_abort();

    return exists ? param: NULL;
}


char* y_get_parameter_with_malloc_or_null(const char *src_param)
{
    char *src = y_get_parameter_or_null(src_param);
    //lr_log_message("Copying source data: %s", src);
    return src ? y_strdup(src): NULL;
}

#define y_get_parameter_malloc_string 0_please_use_y_get_parameter_with_malloc_or_null

char* y_get_parameter_ext(const char *source_param)
{
    char* buffer;
    unsigned long size;
    char* source = y_get_parameter_eval_string(source_param); // Puts the parameter name into parameter seperators { }.
    lr_eval_string_ext(source, strlen(source), &buffer, &size, 0, 0, -1); // Evaluates the result and copy the data into buffer.
    free(source);                                             // Free the intermediate parameter name.
    return buffer;
}


#endif // _Y_CORE_C_