audit_log_buffer_t *audit_log_buffer_init(size_t size, int drop_if_full,
audit_log_write_func write_func, void *data)
{
audit_log_buffer_t *log= (audit_log_buffer_t*)
calloc(sizeof(audit_log_buffer_t) + size, 1);
#ifdef HAVE_PSI_INTERFACE
if(PSI_server)
{
PSI_server->register_mutex("server_audit",
mutex_key_list, array_elements(mutex_key_list));
PSI_server->register_cond("server_audit",
cond_key_list, array_elements(cond_key_list));
}
#endif /* HAVE_PSI_INTERFACE */
if (log != NULL)
{
log->buf= ((char*) log + sizeof(audit_log_buffer_t));
log->drop_if_full= drop_if_full;
log->write_func= write_func;
log->write_func_data= data;
log->size= size;
mysql_mutex_init(key_log_mutex, &log->mutex, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_log_flushed_cond, &log->flushed_cond, NULL);
mysql_cond_init(key_log_written_cond, &log->written_cond, NULL);
pthread_create(&log->flush_worker_thread, NULL,
audit_log_flush_worker, log);
}
return log;
}
void init_heap_psi_keys()
{
const char* category= "memory";
int count;
count= array_elements(all_heap_mutexes);
mysql_mutex_register(category, all_heap_mutexes, count);
count= array_elements(all_heap_memory);
mysql_memory_register(category, all_heap_memory, count);
}
void my_handler_error_register(void)
{
/*
If you got compilation error here about compile_time_assert array, check
that every HA_ERR_xxx constant has a corresponding error message in
handler_error_messages[] list (check mysys/ma_handler_errors.h and
include/my_base.h).
*/
compile_time_assert(HA_ERR_FIRST + array_elements(handler_error_messages) ==
HA_ERR_LAST + 1);
my_error_register(get_handler_error_messages, HA_ERR_FIRST,
HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
}
static void init_available_charsets_IB(char* fname)
{
myf myflags = MYF(0);
if (!charset_initialized)
{
CHARSET_INFO **cs;
bzero(&all_charsets,sizeof(all_charsets));
init_compiled_charsets(myflags);
/* Copy compiled charsets */
for (cs=all_charsets;
cs < all_charsets+array_elements(all_charsets)-1 ;
cs++)
{
if (*cs)
{
if (cs[0]->ctype)
if (init_state_maps(*cs))
*cs= NULL;
}
}
my_read_charset_file(fname,myflags);
charset_initialized=1;
}
}
CHARSET_INFO *get_charset(uint cs_number, myf flags)
{
CHARSET_INFO *cs;
MY_CHARSET_LOADER loader;
if (cs_number == default_charset_info->number)
return default_charset_info;
my_pthread_once(&charsets_initialized, init_available_charsets);
if (cs_number >= array_elements(all_charsets))
return NULL;
my_charset_loader_init_mysys(&loader);
cs= get_internal_charset(&loader, cs_number, flags);
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)], cs_string[23];
my_stpcpy(get_charsets_dir(index_file),MY_CHARSET_INDEX);
cs_string[0]='#';
int10_to_str(cs_number, cs_string+1, 10);
my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_string, index_file);
}
return cs;
}
static void init_available_charsets(void)
{
char fname[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
CHARSET_INFO **cs;
MY_CHARSET_LOADER loader;
memset(&all_charsets, 0, sizeof(all_charsets));
init_compiled_charsets(MYF(0));
/* Copy compiled charsets */
for (cs=all_charsets;
cs < all_charsets+array_elements(all_charsets)-1 ;
cs++)
{
if (*cs)
{
if (cs[0]->ctype)
if (init_state_maps(*cs))
*cs= NULL;
}
}
my_charset_loader_init_mysys(&loader);
my_stpcpy(get_charsets_dir(fname), MY_CHARSET_INDEX);
my_read_charset_file(&loader, fname, MYF(0));
}
CHARSET_INFO *get_charset_IB(char* charsets_dir, uint cs_number, myf flags)
{
CHARSET_INFO *cs;
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
if (cs_number == default_charset_info->number)
return default_charset_info;
strcpy(index_file, charsets_dir);
strcat(index_file, MY_CHARSET_INDEX);
init_available_charsets_IB(index_file); /* If it isn't initialized */
if (!cs_number || cs_number >= array_elements(all_charsets)-1)
return NULL;
cs=get_internal_charset_IB(charsets_dir, cs_number, flags);
if (!cs && (flags & MY_WME))
{
char cs_string[23];
cs_string[0]='#';
int10_to_str(cs_number, cs_string+1, 10);
my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_string, index_file);
}
return cs;
}
int allow_cookie_domain(unsigned char *server, unsigned char *domain)
{
int sl = (int)strlen(cast_const_char server);
int dl = (int)strlen(cast_const_char domain);
if (dl > sl) return 0;
if (casestrcmp(domain, server + sl - dl)) return 0;
if (dl == sl) return 1;
if (!numeric_ip_address(server, NULL)) return 0;
#ifdef SUPPORT_IPV6
if (!numeric_ipv6_address(server, NULL, NULL)) return 0;
#endif
if (server[sl - dl - 1] != '.') return 0;
if (search_list_and_wildcards(domain_suffix_x, array_elements(domain_suffix_x), domain)) return 1;
if (!strchr(cast_const_char domain, '.')) return 0;
if (search_list_and_wildcards(domain_suffix, array_elements(domain_suffix), domain)) return 0;
return 1;
}
int is_tld(unsigned char *name)
{
char *end;
unsigned long l;
if (strlen(cast_const_char name) == 2 && upcase(name[0]) >= 'A' && upcase(name[0]) <= 'Z' && upcase(name[1]) >= 'A' && upcase(name[1]) <= 'Z' && casestrcmp(name, cast_uchar "gz"))
return 1;
l = strtoul(cast_const_char name, &end, 10);
if (!*end && l <= 255)
return 1;
return search_list(domain_suffix, array_elements(domain_suffix), name);
}
static int get_charset_number(const char *charset_name)
{
CHARSET_INFO *cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs->name && !strcmp(cs->name, charset_name))
return cs->number;
}
return 0;
}
static uint
get_collation_number_internal(const char *name)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->name &&
!my_strcasecmp(&my_charset_latin1, cs[0]->name, name))
return cs[0]->number;
}
return 0;
}
const char *get_charset_name(uint charset_number)
{
my_pthread_once(&charsets_initialized, init_available_charsets);
if (charset_number < array_elements(all_charsets))
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->name)
return (char*) cs->name;
}
return "?"; /* this mimics find_type() */
}
size_t vio_write_shared_memory(Vio *vio, const uchar *buf, size_t size)
{
size_t length, remain, sz;
HANDLE pos;
const uchar *current_position;
HANDLE events[2];
DWORD timeout;
DBUG_ENTER("vio_write_shared_memory");
remain= size;
current_position= buf;
timeout= vio->write_timeout >= 0 ? vio->write_timeout : INFINITE;
events[0]= vio->event_server_read;
events[1]= vio->event_conn_closed;
while (remain != 0)
{
DWORD wait_status;
wait_status= WaitForMultipleObjects(array_elements(events), events,
FALSE, timeout);
if (wait_status != WAIT_OBJECT_0)
{
/* Set error code to indicate a timeout error or disconnect. */
if (wait_status == WAIT_TIMEOUT)
SetLastError(SOCKET_ETIMEDOUT);
else
SetLastError(ERROR_GRACEFUL_DISCONNECT);
DBUG_RETURN((size_t) -1);
}
sz= (remain > shared_memory_buffer_length ? shared_memory_buffer_length :
remain);
int4store(vio->handle_map, sz);
pos= vio->handle_map + 4;
memcpy(pos, current_position, sz);
remain-= sz;
current_position+= sz;
if (!SetEvent(vio->event_client_wrote))
DBUG_RETURN((size_t) -1);
}
length= size;
DBUG_RETURN(length);
}
static uint
get_charset_number_internal(const char *charset_name, uint cs_flags)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->csname && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->csname, charset_name))
return cs[0]->number;
}
return 0;
}
uint get_charset_number(const char *charset_name, uint cs_flags)
{
CHARSET_INFO **cs;
init_available_charsets(MYF(0));
for (cs= all_charsets;
cs < all_charsets+array_elements(all_charsets)-1 ;
cs++)
{
if ( cs[0] && cs[0]->csname && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->csname, charset_name))
return cs[0]->number;
}
return 0;
}
static CHARSET_INFO *
get_internal_charset(MY_CHARSET_LOADER *loader, uint cs_number, myf flags)
{
char buf[FN_REFLEN];
CHARSET_INFO *cs;
DBUG_ASSERT(cs_number < array_elements(all_charsets));
if ((cs= all_charsets[cs_number]))
{
if (cs->state & MY_CS_READY) /* if CS is already initialized */
return cs;
/*
To make things thread safe we are not allowing other threads to interfere
while we may changing the cs_info_table
*/
mysql_mutex_lock(&THR_LOCK_charset);
if (!(cs->state & (MY_CS_COMPILED|MY_CS_LOADED))) /* if CS is not in memory */
{
MY_CHARSET_LOADER loader;
strxmov(get_charsets_dir(buf), cs->csname, ".xml", NullS);
my_charset_loader_init_mysys(&loader);
my_read_charset_file(&loader, buf, flags);
}
if (cs->state & MY_CS_AVAILABLE)
{
if (!(cs->state & MY_CS_READY))
{
if ((cs->cset->init && cs->cset->init(cs, loader)) ||
(cs->coll->init && cs->coll->init(cs, loader)))
{
cs= NULL;
}
else
cs->state|= MY_CS_READY;
}
}
else
cs= NULL;
mysql_mutex_unlock(&THR_LOCK_charset);
}
return cs;
}
void method_remove_optimized_sending(struct object_heap* oh, struct Symbol* symbol) {
if (oh->optimizedMethods.empty()) return;
for (std::multiset<struct CompiledMethod*>::iterator i = oh->optimizedMethods.begin(); i != oh->optimizedMethods.end(); i++) {
struct CompiledMethod* method = *i;
/*resend?*/
if (method->selector == symbol) {
method_unoptimize(oh, method);
continue;
}
for (int j = 0; j < array_size(method->selectors); j++) {
if (array_elements(method->selectors)[j] == (struct Object*)symbol) {
method_unoptimize(oh, method);
break;
}
}
}
}
static my_bool init_available_charsets(myf myflags)
#endif
{
char fname[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
my_bool error=FALSE;
/*
We have to use charset_initialized to not lock on THR_LOCK_charset
inside get_internal_charset...
*/
if (!charset_initialized)
{
CHARSET_INFO **cs;
/*
To make things thread safe we are not allowing other threads to interfere
while we may changing the cs_info_table
*/
pthread_mutex_lock(&THR_LOCK_charset);
if (!charset_initialized)
{
bzero(&all_charsets,sizeof(all_charsets));
init_compiled_charsets(myflags);
/* Copy compiled charsets */
for (cs=all_charsets;
cs < all_charsets+array_elements(all_charsets)-1 ;
cs++)
{
if (*cs)
{
if (cs[0]->ctype)
if (init_state_maps(*cs))
*cs= NULL;
}
}
strmov(get_charsets_dir(fname), MY_CHARSET_INDEX);
error= my_read_charset_file(fname,myflags);
charset_initialized=1;
}
pthread_mutex_unlock(&THR_LOCK_charset);
}
return error;
}
const char *mysql_errno_to_sqlstate(uint mysql_errno)
{
uint first=0, end= array_elements(sqlstate_map)-1;
struct st_map_errno_to_sqlstate *map;
/* Do binary search in the sorted array */
while (first != end)
{
uint mid= (first+end)/2;
map= sqlstate_map+mid;
if (map->mysql_errno < mysql_errno)
first= mid+1;
else
end= mid;
}
map= sqlstate_map+first;
if (map->mysql_errno == mysql_errno)
return map->odbc_state;
return "HY000"; /* General error */
}
void my_init_mysys_psi_keys()
{
const char* category= "mysys";
int count;
count= sizeof(all_mysys_mutexes)/sizeof(all_mysys_mutexes[0]);
mysql_mutex_register(category, all_mysys_mutexes, count);
count= sizeof(all_mysys_conds)/sizeof(all_mysys_conds[0]);
mysql_cond_register(category, all_mysys_conds, count);
#ifdef USE_ALARM_THREAD
count= sizeof(all_mysys_threads)/sizeof(all_mysys_threads[0]);
mysql_thread_register(category, all_mysys_threads, count);
#endif /* USE_ALARM_THREAD */
count= sizeof(all_mysys_files)/sizeof(all_mysys_files[0]);
mysql_file_register(category, all_mysys_files, count);
count= array_elements(all_mysys_stages);
mysql_stage_register(category, all_mysys_stages, count);
}
int main()
{
size_t i, failed= 0;
plan(2);
diag("Testing my_like_range_xxx() functions");
for (i= 0; i < array_elements(charset_list); i++)
{
CHARSET_INFO *cs= charset_list[i];
if (test_like_range_for_charset(cs, "abc%", 4))
{
++failed;
diag("Failed for %s", cs->name);
}
}
ok(failed == 0, "Testing my_like_range_xxx() functions");
diag("Testing cs->coll->strnncollsp()");
failed= test_strcollsp();
ok(failed == 0, "Testing cs->coll->strnncollsp()");
return exit_status();
}
static void init_available_charsets(void)
{
char fname[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
CHARSET_INFO **cs;
bzero(&all_charsets,sizeof(all_charsets));
init_compiled_charsets(MYF(0));
/* Copy compiled charsets */
for (cs=all_charsets;
cs < all_charsets+array_elements(all_charsets)-1 ;
cs++)
{
if (*cs)
{
if (cs[0]->ctype)
if (init_state_maps(*cs))
*cs= NULL;
}
}
strmov(get_charsets_dir(fname), MY_CHARSET_INDEX);
my_read_charset_file(fname, MYF(0));
}
size_t vio_read_shared_memory(Vio *vio, uchar *buf, size_t size)
{
size_t length;
size_t remain_local;
char *current_position;
HANDLE events[2];
DWORD timeout;
DBUG_ENTER("vio_read_shared_memory");
remain_local= size;
current_position= buf;
timeout= vio->read_timeout >= 0 ? vio->read_timeout : INFINITE;
events[0]= vio->event_server_wrote;
events[1]= vio->event_conn_closed;
do
{
if (vio->shared_memory_remain == 0)
{
DWORD wait_status;
wait_status= WaitForMultipleObjects(array_elements(events), events,
FALSE, timeout);
/*
WaitForMultipleObjects can return next values:
WAIT_OBJECT_0+0 - event from vio->event_server_wrote
WAIT_OBJECT_0+1 - event from vio->event_conn_closed.
We can't read anything
WAIT_ABANDONED_0 and WAIT_TIMEOUT - fail. We can't read anything
*/
if (wait_status != WAIT_OBJECT_0)
{
/*
If wait_status is WAIT_TIMEOUT, set error code to indicate a
timeout error. If vio->event_conn_closed was set, use an EOF
condition (return value of zero) to indicate that the operation
has been aborted.
*/
if (wait_status == WAIT_TIMEOUT)
SetLastError(SOCKET_ETIMEDOUT);
else if (wait_status == (WAIT_OBJECT_0 + 1))
DBUG_RETURN(0);
DBUG_RETURN(-1);
}
vio->shared_memory_pos= vio->handle_map;
vio->shared_memory_remain= uint4korr((ulong*)vio->shared_memory_pos);
vio->shared_memory_pos+= 4;
}
length= size;
if (vio->shared_memory_remain < length)
length= vio->shared_memory_remain;
if (length > remain_local)
length= remain_local;
memcpy(current_position, vio->shared_memory_pos, length);
vio->shared_memory_remain-= length;
vio->shared_memory_pos+= length;
current_position+= length;
remain_local-= length;
if (!vio->shared_memory_remain)
{
if (!SetEvent(vio->event_client_read))
DBUG_RETURN(-1);
}
} while (remain_local);
length= size;
DBUG_RETURN(length);
}
for (i= 0; i < from->count; i++)
{
if (!(to->type_names[i]= strmake_root(root, from->type_names[i],
from->type_lengths[i])))
return NULL;
to->type_lengths[i]= from->type_lengths[i];
}
to->type_names[to->count]= NULL;
to->type_lengths[to->count]= 0;
return to;
}
static const char *on_off_default_names[]= { "off","on","default", 0};
static TYPELIB on_off_default_typelib= {array_elements(on_off_default_names)-1,
"", on_off_default_names, 0};
/**
Parse a TYPELIB name from the buffer
@param lib Set of names to scan for.
@param strpos INOUT Start of the buffer (updated to point to the next
character after the name)
@param end End of the buffer
@note
The buffer is assumed to contain one of the names specified in the TYPELIB,
followed by comma, '=', or end of the buffer.
@retval
void my_handler_error_unregister(void)
{
my_error_unregister(HA_ERR_FIRST,
HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
}
static int test_wl4166_1(MYSQL *mysql)
{
MYSQL_STMT *stmt;
int int_data;
char str_data[50];
char tiny_data;
short small_data;
longlong big_data;
float real_data;
double double_data;
ulong length[7];
my_bool is_null[7];
MYSQL_BIND my_bind[7];
static char *query;
int rc;
int i;
if (mysql_get_server_version(mysql) < 50100) {
diag("Test requires MySQL Server version 5.1 or above");
return SKIP;
}
rc= mysql_query(mysql, "DROP TABLE IF EXISTS table_4166");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "CREATE TABLE table_4166(col1 tinyint NOT NULL, "
"col2 varchar(15), col3 int, "
"col4 smallint, col5 bigint, "
"col6 float, col7 double, "
"colX varchar(10) default NULL)");
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
FAIL_IF(!stmt, mysql_error(mysql));
query= "INSERT INTO table_4166(col1, col2, col3, col4, col5, col6, col7) "
"VALUES(?, ?, ?, ?, ?, ?, ?)";
rc= mysql_stmt_prepare(stmt, query, strlen(query));
check_stmt_rc(rc, stmt);
FAIL_IF(mysql_stmt_param_count(stmt) != 7, "param_count != 7");
memset(my_bind, '\0', sizeof(my_bind));
/* tinyint */
my_bind[0].buffer_type= MYSQL_TYPE_TINY;
my_bind[0].buffer= (void *)&tiny_data;
/* string */
my_bind[1].buffer_type= MYSQL_TYPE_STRING;
my_bind[1].buffer= (void *)str_data;
my_bind[1].buffer_length= 1000; /* Max string length */
/* integer */
my_bind[2].buffer_type= MYSQL_TYPE_LONG;
my_bind[2].buffer= (void *)&int_data;
/* short */
my_bind[3].buffer_type= MYSQL_TYPE_SHORT;
my_bind[3].buffer= (void *)&small_data;
/* bigint */
my_bind[4].buffer_type= MYSQL_TYPE_LONGLONG;
my_bind[4].buffer= (void *)&big_data;
/* float */
my_bind[5].buffer_type= MYSQL_TYPE_FLOAT;
my_bind[5].buffer= (void *)&real_data;
/* double */
my_bind[6].buffer_type= MYSQL_TYPE_DOUBLE;
my_bind[6].buffer= (void *)&double_data;
for (i= 0; i < (int) array_elements(my_bind); i++)
{
my_bind[i].length= &length[i];
my_bind[i].is_null= &is_null[i];
is_null[i]= 0;
}
rc= mysql_stmt_bind_param(stmt, my_bind);
check_stmt_rc(rc, stmt);
int_data= 320;
small_data= 1867;
big_data= 1000;
real_data= 2;
double_data= 6578.001;
/* now, execute the prepared statement to insert 10 records.. */
for (tiny_data= 0; tiny_data < 10; tiny_data++)
{
length[1]= sprintf(str_data, "MySQL%d", int_data);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
int_data += 25;
small_data += 10;
big_data += 100;
real_data += 1;
double_data += 10.09;
}
/* force a re-prepare with some DDL */
rc= mysql_query(mysql,
"ALTER TABLE table_4166 change colX colX varchar(20) default NULL");
check_mysql_rc(rc, mysql);
/*
execute the prepared statement again,
without changing the types of parameters already bound.
*/
for (tiny_data= 50; tiny_data < 60; tiny_data++)
{
length[1]= sprintf(str_data, "MySQL%d", int_data);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
int_data += 25;
small_data += 10;
big_data += 100;
real_data += 1;
double_data += 10.09;
}
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP TABLE table_4166");
check_mysql_rc(rc, mysql);
return OK;
}
double my_strtod(const char *str, char **end_ptr, int *error)
{
double result= 0.0;
uint negative= 0, ndigits, dec_digits= 0, neg_exp= 0;
int exponent= 0, digits_after_dec_point= 0, tmp_exp, step;
const char *old_str, *end= *end_ptr, *start_of_number;
char next_char;
my_bool overflow=0;
double scaler= 1.0;
*error= 0;
if (str >= end)
goto done;
while (my_isspace(&my_charset_latin1, *str))
{
if (++str == end)
goto done;
}
start_of_number= str;
if ((negative= (*str == '-')) || *str=='+')
{
if (++str == end)
goto done; /* Could be changed to error */
}
/* Skip pre-zero for easier calculation of overflows */
while (*str == '0')
{
if (++str == end)
goto done;
start_of_number= 0; /* Found digit */
}
old_str= str;
while ((next_char= *str) >= '0' && next_char <= '9')
{
result= result*10.0 + (next_char - '0');
scaler= scaler*10.0;
if (++str == end)
{
next_char= 0; /* Found end of string */
break;
}
start_of_number= 0; /* Found digit */
}
ndigits= (uint) (str-old_str);
if (next_char == '.' && str < end-1)
{
/*
Continue to add numbers after decimal point to the result, as if there
was no decimal point. We will later (in the exponent handling) shift
the number down with the required number of fractions. We do it this
way to be able to get maximum precision for numbers like 123.45E+02,
which are normal for some ODBC applications.
*/
old_str= ++str;
while (my_isdigit(&my_charset_latin1, (next_char= *str)))
{
result= result*10.0 + (next_char - '0');
digits_after_dec_point++;
scaler= scaler*10.0;
if (++str == end)
{
next_char= 0;
break;
}
}
/* If we found just '+.' or '.' then point at first character */
if (!(dec_digits= (uint) (str-old_str)) && start_of_number)
str= start_of_number; /* Point at '+' or '.' */
}
if ((next_char == 'e' || next_char == 'E') &&
dec_digits + ndigits != 0 && str < end-1)
{
const char *old_str2= str++;
if ((neg_exp= (*str == '-')) || *str == '+')
str++;
if (str == end || !my_isdigit(&my_charset_latin1, *str))
str= old_str2;
else
{
do
{
if (exponent < 9999) /* prot. against exp overfl. */
exponent= exponent*10 + (*str - '0');
str++;
} while (str < end && my_isdigit(&my_charset_latin1, *str));
}
}
tmp_exp= (neg_exp ? exponent + digits_after_dec_point :
exponent - digits_after_dec_point);
if (tmp_exp)
{
int order;
/*
Check for underflow/overflow.
order is such an integer number that f = C * 10 ^ order,
where f is the resulting floating point number and 1 <= C < 10.
Here we compute the modulus
*/
order= exponent + (neg_exp ? -1 : 1) * (ndigits - 1);
if (order < 0)
order= -order;
if (order >= MAX_DBL_EXP && !neg_exp && result)
{
double c;
/* Compute modulus of C (see comment above) */
c= result / scaler * 10.0;
if (order > MAX_DBL_EXP || c > MAX_RESULT_FOR_MAX_EXP)
{
overflow= 1;
goto done;
}
}
exponent= tmp_exp;
if (exponent < 0)
{
exponent= -exponent;
neg_exp= 1; /* neg_exp was 0 before */
}
step= array_elements(log_10) - 1;
for (; exponent > step; exponent-= step)
result= neg_exp ? result / log_10[step] : result * log_10[step];
result= neg_exp ? result / log_10[exponent] : result * log_10[exponent];
}
done:
*end_ptr= (char*) str; /* end of number */
if (overflow || my_isinf(result))
{
result= DBL_MAX;
*error= EOVERFLOW;
}
return negative ? -result : result;
}
void do_tests()
{
DBUG_ENTER("do_tests");
skip_all(": this module is not used in MySQL");
plan(12);
compile_time_assert(THREADS >= 4);
DBUG_PRINT("wt", ("================= initialization ==================="));
bad= my_atomic_initialize();
ok(!bad, "my_atomic_initialize() returned %d", bad);
mysql_cond_init(0, &thread_sync, 0);
mysql_mutex_init(0, &lock, 0);
wt_init();
for (cnt=0; cnt < THREADS; cnt++)
mysql_mutex_init(0, & thds[cnt].lock, 0);
{
WT_RESOURCE_ID resid[4];
for (i=0; i < array_elements(resid); i++)
{
wt_thd_lazy_init(& thds[i].thd,
& wt_deadlock_search_depth_short, & wt_timeout_short,
& wt_deadlock_search_depth_long, & wt_timeout_long);
resid[i].value= i+1;
resid[i].type= &restype;
}
DBUG_PRINT("wt", ("================= manual test ==================="));
#define ok_wait(X,Y, R) \
ok(wt_thd_will_wait_for(& thds[X].thd, & thds[Y].thd, &resid[R]) == 0, \
"thd[" #X "] will wait for thd[" #Y "]")
#define ok_deadlock(X,Y,R) \
ok(wt_thd_will_wait_for(& thds[X].thd, & thds[Y].thd, &resid[R]) == WT_DEADLOCK, \
"thd[" #X "] will wait for thd[" #Y "] - deadlock")
ok_wait(0,1,0);
ok_wait(0,2,0);
ok_wait(0,3,0);
mysql_mutex_lock(&lock);
bad= wt_thd_cond_timedwait(& thds[0].thd, &lock);
mysql_mutex_unlock(&lock);
ok(bad == WT_TIMEOUT, "timeout test returned %d", bad);
ok_wait(0,1,0);
ok_wait(1,2,1);
ok_deadlock(2,0,2);
mysql_mutex_lock(&lock);
ok(wt_thd_cond_timedwait(& thds[0].thd, &lock) == WT_TIMEOUT, "as always");
ok(wt_thd_cond_timedwait(& thds[1].thd, &lock) == WT_TIMEOUT, "as always");
wt_thd_release_all(& thds[0].thd);
wt_thd_release_all(& thds[1].thd);
wt_thd_release_all(& thds[2].thd);
wt_thd_release_all(& thds[3].thd);
for (i=0; i < array_elements(resid); i++)
{
wt_thd_release_all(& thds[i].thd);
wt_thd_destroy(& thds[i].thd);
}
mysql_mutex_unlock(&lock);
}
wt_deadlock_search_depth_short=6;
wt_timeout_short=1000;
wt_timeout_long= 100;
wt_deadlock_search_depth_long=16;
DBUG_PRINT("wt", ("================= stress test ==================="));
diag("timeout_short=%lu us, deadlock_search_depth_short=%lu",
wt_timeout_short, wt_deadlock_search_depth_short);
diag("timeout_long=%lu us, deadlock_search_depth_long=%lu",
wt_timeout_long, wt_deadlock_search_depth_long);
#define test_kill_strategy(X) \
diag("kill strategy: " #X); \
DBUG_EXECUTE("reset_file", \
{ rewind(DBUG_FILE); my_chsize(fileno(DBUG_FILE), 0, 0, MYF(0)); }); \
DBUG_PRINT("info", ("kill strategy: " #X)); \
kill_strategy=X; \
do_one_test();
test_kill_strategy(LATEST);
test_kill_strategy(RANDOM);
/*
these two take looong time on sol10-amd64-a
the server doesn't use this code now, so we disable these tests
test_kill_strategy(YOUNGEST);
test_kill_strategy(LOCKS);
*/
DBUG_PRINT("wt", ("================= cleanup ==================="));
for (cnt=0; cnt < THREADS; cnt++)
mysql_mutex_destroy(& thds[cnt].lock);
wt_end();
mysql_mutex_destroy(&lock);
mysql_cond_destroy(&thread_sync);
DBUG_VOID_RETURN;
}
static int add_collation(CHARSET_INFO *cs)
{
if (cs->name && (cs->number ||
(cs->number=get_collation_number_internal(cs->name))) &&
cs->number < array_elements(all_charsets))
{
if (!all_charsets[cs->number])
{
if (!(all_charsets[cs->number]=
(CHARSET_INFO*) my_once_alloc(sizeof(CHARSET_INFO),MYF(0))))
return MY_XML_ERROR;
bzero((void*)all_charsets[cs->number],sizeof(CHARSET_INFO));
}
if (cs->primary_number == cs->number)
cs->state |= MY_CS_PRIMARY;
if (cs->binary_number == cs->number)
cs->state |= MY_CS_BINSORT;
all_charsets[cs->number]->state|= cs->state;
if (!(all_charsets[cs->number]->state & MY_CS_COMPILED))
{
CHARSET_INFO *newcs= all_charsets[cs->number];
if (cs_copy_data(all_charsets[cs->number],cs))
return MY_XML_ERROR;
newcs->caseup_multiply= newcs->casedn_multiply= 1;
if (!strcmp(cs->csname,"ucs2") )
{
#if defined(HAVE_CHARSET_ucs2) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, &my_charset_ucs2_unicode_ci);
newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;
#endif
}
else if (!strcmp(cs->csname, "utf8") || !strcmp(cs->csname, "utf8mb3"))
{
#if defined (HAVE_CHARSET_utf8) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, &my_charset_utf8_unicode_ci);
newcs->ctype= my_charset_utf8_unicode_ci.ctype;
if (init_state_maps(newcs))
return MY_XML_ERROR;
#endif
}
else if (!strcmp(cs->csname, "utf8mb4"))
{
#if defined (HAVE_CHARSET_utf8mb4) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, &my_charset_utf8mb4_unicode_ci);
newcs->ctype= my_charset_utf8mb4_unicode_ci.ctype;
newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED;
#endif
}
else if (!strcmp(cs->csname, "utf16"))
{
#if defined (HAVE_CHARSET_utf16) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, &my_charset_utf16_unicode_ci);
newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;
#endif
}
else if (!strcmp(cs->csname, "utf32"))
{
#if defined (HAVE_CHARSET_utf32) && defined(HAVE_UCA_COLLATIONS)
copy_uca_collation(newcs, &my_charset_utf32_unicode_ci);
newcs->state|= MY_CS_AVAILABLE | MY_CS_LOADED | MY_CS_NONASCII;
#endif
}
else
{
uchar *sort_order= all_charsets[cs->number]->sort_order;
simple_cs_init_functions(all_charsets[cs->number]);
newcs->mbminlen= 1;
newcs->mbmaxlen= 1;
if (simple_cs_is_full(all_charsets[cs->number]))
{
all_charsets[cs->number]->state |= MY_CS_LOADED;
}
all_charsets[cs->number]->state|= MY_CS_AVAILABLE;
/*
Check if case sensitive sort order: A < a < B.
We need MY_CS_FLAG for regex library, and for
case sensitivity flag for 5.0 client protocol,
to support isCaseSensitive() method in JDBC driver
*/
if (sort_order && sort_order['A'] < sort_order['a'] &&
sort_order['a'] < sort_order['B'])
all_charsets[cs->number]->state|= MY_CS_CSSORT;
if (my_charset_is_8bit_pure_ascii(all_charsets[cs->number]))
all_charsets[cs->number]->state|= MY_CS_PUREASCII;
if (!my_charset_is_ascii_compatible(cs))
all_charsets[cs->number]->state|= MY_CS_NONASCII;
}
}
else
{
/*
We need the below to make get_charset_name()
and get_charset_number() working even if a
character set has not been really incompiled.
The above functions are used for example
in error message compiler extra/comp_err.c.
If a character set was compiled, this information
will get lost and overwritten in add_compiled_collation().
*/
CHARSET_INFO *dst= all_charsets[cs->number];
dst->number= cs->number;
if (cs->comment)
if (!(dst->comment= my_once_strdup(cs->comment,MYF(MY_WME))))
return MY_XML_ERROR;
if (cs->csname)
if (!(dst->csname= my_once_strdup(cs->csname,MYF(MY_WME))))
return MY_XML_ERROR;
if (cs->name)
if (!(dst->name= my_once_strdup(cs->name,MYF(MY_WME))))
return MY_XML_ERROR;
}
cs->number= 0;
cs->primary_number= 0;
cs->binary_number= 0;
cs->name= NULL;
cs->state= 0;
cs->sort_order= NULL;
cs->state= 0;
}
return MY_XML_OK;
}
void add_compiled_collation(CHARSET_INFO *cs)
{
DBUG_ASSERT(cs->number < array_elements(all_charsets));
all_charsets[cs->number]= cs;
cs->state|= MY_CS_AVAILABLE;
}
