← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/drizzled.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/drizzled.cc
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
#include "mysql_priv.h"
17
 
#include <m_ctype.h>
18
 
#include <my_dir.h>
19
 
#include <my_bit.h>
 
17
#include <mysys/my_bit.h>
20
18
#include "slave.h"
21
19
#include "rpl_mi.h"
22
20
#include "sql_repl.h"
24
22
#include "repl_failsafe.h"
25
23
#include "stacktrace.h"
26
24
#include "mysqld_suffix.h"
27
 
#include "mysys_err.h"
 
25
#include <mysys/mysys_err.h>
 
26
#include <sys/poll.h>
 
27
#include <netinet/tcp.h>
28
28
 
29
 
#include "../storage/myisam/ha_myisam.h"
 
29
#include <storage/myisam/ha_myisam.h>
30
30
 
31
31
#ifdef HAVE_SYS_PRCTL_H
32
32
#include <sys/prctl.h>
36
36
#define DEFAULT_SKIP_THREAD_PRIORITY 0
37
37
#endif
38
38
 
39
 
#include <thr_alarm.h>
40
 
#include <errmsg.h>
 
39
#include <mysys/thr_alarm.h>
 
40
#include <libdrizzle/errmsg.h>
41
41
 
42
42
#define mysqld_charset &my_charset_latin1
43
43
 
65
65
#ifndef __GNU_LIBRARY__
66
66
#define __GNU_LIBRARY__                         // Skip warnings in getopt.h
67
67
#endif
68
 
#include <my_getopt.h>
 
68
#include <mysys/my_getopt.h>
69
69
#ifdef HAVE_SYSENT_H
70
70
#include <sysent.h>
71
71
#endif
75
75
#ifdef HAVE_GRP_H
76
76
#include <grp.h>
77
77
#endif
78
 
#include <my_net.h>
79
78
 
80
79
#include <sys/resource.h>
81
80
 
145
144
 
146
145
#define MYSQL_KILL_SIGNAL SIGTERM
147
146
 
148
 
#include <my_pthread.h>                 // For thr_setconcurency()
 
147
#include <mysys/my_pthread.h>                   // For thr_setconcurency()
149
148
 
150
149
#ifdef SOLARIS
151
150
extern "C" int gethostname(char *name, int namelen);
208
207
 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row},
209
208
 {&Arg_comparator::compare_decimal,    &Arg_comparator::compare_e_decimal}};
210
209
 
211
 
const char *log_output_names[] = { "NONE", "FILE", "TABLE", NullS};
212
 
static const unsigned int log_output_names_len[]= { 4, 4, 5, 0 };
 
210
const char *log_output_names[] = { "NONE", "FILE", NullS};
 
211
static const unsigned int log_output_names_len[]= { 4, 4, 0 };
213
212
TYPELIB log_output_typelib= {array_elements(log_output_names)-1,"",
214
213
                             log_output_names, 
215
214
                             (unsigned int *) log_output_names_len};
217
216
/* static variables */
218
217
 
219
218
/* the default log output is log tables */
220
 
static bool lower_case_table_names_used= 0;
221
219
static bool volatile select_thread_in_use, signal_thread_in_use;
222
220
static bool volatile ready_to_exit;
223
221
static bool opt_debugging= 0, opt_console= 0;
248
246
ulong log_output_options;
249
247
bool opt_log_queries_not_using_indexes= false;
250
248
bool opt_error_log= IF_WIN(1,0);
251
 
bool opt_disable_networking= false;
252
249
bool opt_skip_show_db= false;
253
250
bool opt_character_set_client_handshake= 1;
254
251
bool server_id_supplied = 0;
265
262
bool opt_safe_user_create = 0;
266
263
bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
267
264
bool opt_log_slave_updates= 0;
 
265
static struct pollfd fds[UINT8_MAX];
 
266
static uint8_t pollfd_count= 0;
268
267
 
269
268
/*
270
269
  Legacy global handlerton. These will be removed (please do not add more).
280
279
char* opt_secure_file_priv= 0;
281
280
bool opt_log_slow_admin_statements= 0;
282
281
bool opt_log_slow_slave_statements= 0;
283
 
bool lower_case_file_system= 0;
284
282
bool opt_old_style_user_limits= 0;
285
283
bool trust_function_creators= 0;
286
284
/*
303
301
uint mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
304
302
uint mysqld_port_timeout;
305
303
uint delay_key_write_options, protocol_version;
306
 
uint lower_case_table_names;
 
304
uint lower_case_table_names= 1;
307
305
uint tc_heuristic_recover= 0;
308
306
uint volatile thread_count, thread_running;
309
307
uint64_t thd_startup_options;
403
401
Ge_creator ge_creator;
404
402
Le_creator le_creator;
405
403
 
406
 
FILE *bootstrap_file;
407
 
int bootstrap_error;
408
404
FILE *stderror_file=0;
409
405
 
410
406
I_List<THD> threads;
462
458
#ifdef HAVE_STACK_TRACE_ON_SEGV
463
459
static bool opt_do_pstack;
464
460
#endif /* HAVE_STACK_TRACE_ON_SEGV */
465
 
static bool opt_bootstrap, opt_myisam_log;
 
461
static bool opt_myisam_log;
466
462
static int cleanup_done;
467
463
static ulong opt_specialflag, opt_myisam_block_size;
468
464
static char *opt_binlog_index_name;
472
468
static char **defaults_argv;
473
469
static char *opt_bin_logname;
474
470
 
475
 
static my_socket ip_sock;
476
471
struct rand_struct sql_rand; ///< used by sql_class.cc:THD::THD()
477
472
 
478
473
struct passwd *user_info;
508
503
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
509
504
                                   const char *option);
510
505
static void clean_up(bool print_message);
511
 
static int test_if_case_insensitive(const char *dir_name);
512
506
 
513
507
static void usage(void);
514
508
static void start_signal_handler(void);
562
556
 
563
557
 
564
558
  /* Abort listening to new connections */
565
 
  if (!opt_disable_networking )
566
559
  {
567
 
    if (ip_sock != INVALID_SOCKET)
 
560
    int x;
 
561
    
 
562
    for (x= 0; x < pollfd_count; x++)
568
563
    {
569
 
      (void) shutdown(ip_sock, SHUT_RDWR);
570
 
      (void) closesocket(ip_sock);
571
 
      ip_sock= INVALID_SOCKET;
 
564
      if (fds[x].fd != INVALID_SOCKET)
 
565
      {
 
566
        (void) shutdown(fds[x].fd, SHUT_RDWR);
 
567
        (void) closesocket(fds[x].fd);
 
568
        fds[x].fd= INVALID_SOCKET;
 
569
      }
572
570
    }
573
571
  }
 
572
 
574
573
  end_thr_alarm(0);                      // Abort old alarms.
575
574
 
576
575
  /*
651
650
static void close_server_sock()
652
651
{
653
652
#ifdef HAVE_CLOSE_SERVER_SOCK
654
 
  my_socket tmp_sock;
655
 
  tmp_sock=ip_sock;
656
 
  if (tmp_sock != INVALID_SOCKET)
657
653
  {
658
 
    ip_sock=INVALID_SOCKET;
659
 
    VOID(shutdown(tmp_sock, SHUT_RDWR));
 
654
    int x;
 
655
    
 
656
    for (x= 0; x < pollfd_count; x++)
 
657
    {
 
658
      if (fds[x].fd != INVALID_SOCKET)
 
659
      {
 
660
        (void) shutdown(fds[x].fd, SHUT_RDWR);
 
661
        (void) closesocket(fds[x].fd);
 
662
        fds[x].fd= INVALID_SOCKET;
 
663
      }
 
664
    }
660
665
  }
661
 
  return;;
662
666
#endif
663
667
}
664
668
 
788
792
    sql_print_error("Aborting\n");
789
793
  else if (opt_help)
790
794
    usage();
791
 
  clean_up(!opt_help && (exit_code || !opt_bootstrap)); /* purecov: inspected */
 
795
  clean_up(!opt_help && (exit_code)); /* purecov: inspected */
792
796
  mysqld_exit(exit_code);
793
797
}
794
798
 
860
864
  delete rpl_filter;
861
865
  vio_end();
862
866
 
863
 
  if (!opt_bootstrap)
864
 
    (void) my_delete(pidfile_name,MYF(0));      // This may not always exist
 
867
  (void) my_delete(pidfile_name,MYF(0));        // This may not always exist
 
868
 
865
869
  if (print_message && errmesg && server_start_time)
866
870
    sql_print_information(ER(ER_SHUTDOWN_COMPLETE),my_progname);
867
871
  thread_scheduler.end();
939
943
static void set_ports()
940
944
{
941
945
  char  *env;
942
 
  if (!mysqld_port && !opt_disable_networking)
 
946
  if (!mysqld_port)
943
947
  {                                     // Get port if not from commandline
944
948
    mysqld_port= MYSQL_PORT;
945
949
 
953
957
      line options.
954
958
    */
955
959
 
956
 
#if MYSQL_PORT_DEFAULT == 0
957
960
    struct  servent *serv_ptr;
958
961
    if ((serv_ptr= getservbyname("mysql", "tcp")))
959
962
      mysqld_port= ntohs((u_short) serv_ptr->s_port); /* purecov: inspected */
960
 
#endif
 
963
 
961
964
    if ((env = getenv("MYSQL_TCP_PORT")))
962
965
      mysqld_port= (uint) atoi(env);            /* purecov: inspected */
 
966
 
 
967
    assert(mysqld_port);
963
968
  }
964
969
}
965
970
 
988
993
  }
989
994
  if (!user)
990
995
  {
991
 
    if (!opt_bootstrap)
992
 
    {
993
 
      sql_print_error("Fatal error: Please read \"Security\" section of the manual to find out how to run mysqld as root!\n");
994
 
      unireg_abort(1);
995
 
    }
 
996
    sql_print_error("Fatal error: Please read \"Security\" section of the manual to find out how to run mysqld as root!\n");
 
997
    unireg_abort(1);
 
998
 
996
999
    return NULL;
997
1000
  }
998
1001
  /* purecov: begin tested */
1086
1089
 
1087
1090
static void network_init(void)
1088
1091
{
1089
 
  int   arg;
1090
1092
  int   ret;
1091
1093
  uint  waited;
1092
1094
  uint  this_wait;
1093
1095
  uint  retry;
1094
1096
  char port_buf[NI_MAXSERV];
 
1097
  struct addrinfo *ai;
 
1098
  struct addrinfo *next;
 
1099
  struct addrinfo hints;
 
1100
  int error;
1095
1101
 
1096
1102
  if (thread_scheduler.init())
1097
1103
    unireg_abort(1);                    /* purecov: inspected */
1098
1104
 
1099
1105
  set_ports();
1100
1106
 
1101
 
  if (mysqld_port != 0 && !opt_disable_networking && !opt_bootstrap)
1102
 
  {
1103
 
    struct addrinfo *ai;
1104
 
    struct addrinfo hints;
1105
 
    int error;
1106
 
 
1107
 
    bzero(&hints, sizeof (hints));
1108
 
    hints.ai_flags= AI_PASSIVE;
1109
 
    hints.ai_socktype= SOCK_STREAM;
1110
 
    hints.ai_family= AF_UNSPEC;
1111
 
 
1112
 
    snprintf(port_buf, NI_MAXSERV, "%d", mysqld_port);
1113
 
    error= getaddrinfo(my_bind_addr_str, port_buf, &hints, &ai);
1114
 
    if (error != 0)
1115
 
    {
1116
 
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
1117
 
      unireg_abort(1);                          /* purecov: tested */
1118
 
    }
1119
 
 
1120
 
 
1121
 
    ip_sock= socket(ai->ai_family, ai->ai_socktype,
1122
 
                    ai->ai_protocol);
 
1107
  memset(fds, 0, sizeof(struct pollfd) * UINT8_MAX);
 
1108
  memset(&hints, 0, sizeof (hints));
 
1109
  hints.ai_flags= AI_PASSIVE;
 
1110
  hints.ai_socktype= SOCK_STREAM;
 
1111
  hints.ai_family= AF_INET;
 
1112
  hints.ai_protocol= IPPROTO_TCP;
 
1113
 
 
1114
  snprintf(port_buf, NI_MAXSERV, "%d", mysqld_port);
 
1115
  error= getaddrinfo(my_bind_addr_str, port_buf, &hints, &ai);
 
1116
  if (error != 0)
 
1117
  {
 
1118
    sql_perror(ER(ER_IPSOCK_ERROR));            /* purecov: tested */
 
1119
    unireg_abort(1);                            /* purecov: tested */
 
1120
  }
 
1121
 
 
1122
  for (next= ai, pollfd_count= 0; next; next= next->ai_next, pollfd_count++)
 
1123
  {
 
1124
    int ip_sock;
 
1125
 
 
1126
    ip_sock= socket(next->ai_family, next->ai_socktype, next->ai_protocol);
1123
1127
 
1124
1128
    if (ip_sock == INVALID_SOCKET)
1125
1129
    {
1127
1131
      unireg_abort(1);                          /* purecov: tested */
1128
1132
    }
1129
1133
 
1130
 
    /*
1131
 
      We should not use SO_REUSEADDR on windows as this would enable a
1132
 
      user to open two mysqld servers with the same TCP/IP port.
1133
 
    */
1134
 
    arg= 1;
1135
 
    (void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
 
1134
    fds[pollfd_count].fd= ip_sock;
 
1135
    fds[pollfd_count].events= POLLIN | POLLERR;
1136
1136
 
1137
 
#ifdef IPV6_V6ONLY
1138
 
     /*
1139
 
       For interoperability with older clients, IPv6 socket should
1140
 
       listen on both IPv6 and IPv4 wildcard addresses.
1141
 
       Turn off IPV6_V6ONLY option.
1142
 
     */
1143
 
    if (ai->ai_family == AF_INET6)
 
1137
    /* Add options for our listening socket */
1144
1138
    {
1145
 
      arg= 0;      
1146
 
      (void) setsockopt(ip_sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&arg,
1147
 
                sizeof(arg));
 
1139
      struct linger ling = {0, 0};
 
1140
      int flags =1;
 
1141
 
 
1142
      (void) setsockopt(ip_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&flags, sizeof(flags));
 
1143
      (void) setsockopt(ip_sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
 
1144
      (void) setsockopt(ip_sock, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
 
1145
      (void) setsockopt(ip_sock, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
1148
1146
    }
1149
 
#endif
 
1147
 
 
1148
 
1150
1149
    /*
1151
1150
      Sometimes the port is not released fast enough when stopping and
1152
1151
      restarting the server. This happens quite often with the test suite
1157
1156
    */
1158
1157
    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)
1159
1158
    {
1160
 
      if (((ret= bind(ip_sock, ai->ai_addr, ai->ai_addrlen)) >= 0 ) ||
 
1159
      if (((ret= bind(ip_sock, next->ai_addr, next->ai_addrlen)) >= 0 ) ||
1161
1160
          (socket_errno != SOCKET_EADDRINUSE) ||
1162
1161
          (waited >= mysqld_port_timeout))
1163
1162
        break;
1169
1168
    if (ret < 0)
1170
1169
    {
1171
1170
      sql_perror("Can't start server: Bind on TCP/IP port");
1172
 
      sql_print_error("Do you already have another mysqld server running on port: %d ?",mysqld_port);
 
1171
      sql_print_error("Do you already have another drizzled server running on port: %d ?",mysqld_port);
1173
1172
      unireg_abort(1);
1174
1173
    }
1175
1174
    if (listen(ip_sock,(int) back_log) < 0)
1181
1180
    }
1182
1181
  }
1183
1182
 
1184
 
  return;;
 
1183
  return;
1185
1184
}
1186
1185
 
1187
1186
/**
1383
1382
{
1384
1383
  time_t curr_time;
1385
1384
  struct tm tm;
1386
 
  THD *thd=current_thd;
1387
1385
 
1388
1386
  /*
1389
1387
    Strictly speaking, one needs a mutex here
1431
1429
  fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
1432
1430
 
1433
1431
#ifdef HAVE_STACKTRACE
 
1432
  THD *thd= current_thd;
 
1433
 
1434
1434
  if (!(test_flags & TEST_NO_STACKTRACE))
1435
1435
  {
1436
1436
    fprintf(stderr,"thd: 0x%lx\n",(long) thd);
1665
1665
  (void) sigaddset(&set,SIGTSTP);
1666
1666
 
1667
1667
  /* Save pid to this process (or thread on Linux) */
1668
 
  if (!opt_bootstrap)
1669
 
    create_pid_file();
 
1668
  create_pid_file();
1670
1669
 
1671
1670
#ifdef HAVE_STACK_TRACE_ON_SEGV
1672
1671
  if (opt_do_pstack)
1745
1744
                      REFRESH_THREADS | REFRESH_HOSTS),
1746
1745
                     (TABLE_LIST*) 0, &not_used); // Flush logs
1747
1746
      }
1748
 
      /* reenable logs after the options were reloaded */
1749
 
      if (log_output_options & LOG_NONE)
1750
 
      {
1751
 
        logger.set_handlers(LOG_FILE,
1752
 
                            opt_slow_log ? LOG_TABLE : LOG_NONE,
1753
 
                            opt_log ? LOG_TABLE : LOG_NONE);
1754
 
      }
1755
 
      else
1756
 
      {
1757
 
        logger.set_handlers(LOG_FILE,
1758
 
                            opt_slow_log ? log_output_options : LOG_NONE,
1759
 
                            opt_log ? log_output_options : LOG_NONE);
1760
 
      }
 
1747
      logger.set_handlers(LOG_FILE,
 
1748
                          opt_slow_log ? log_output_options : LOG_NONE,
 
1749
                          opt_log ? log_output_options : LOG_NONE);
1761
1750
      break;
1762
1751
#ifdef USE_ONE_SIGNAL_HAND
1763
1752
    case THR_SERVER_ALARM:
1774
1763
  return(0);                                    /* purecov: deadcode */
1775
1764
}
1776
1765
 
1777
 
static void check_data_home(const char *path __attribute__((__unused__)))
 
1766
static void check_data_home(const char *path __attribute__((unused)))
1778
1767
{}
1779
1768
 
1780
1769
#endif  /* __WIN__*/
2226
2215
  if (my_database_names_init())
2227
2216
    return 1;
2228
2217
 
2229
 
  /*
2230
 
    Ensure that lower_case_table_names is set on system where we have case
2231
 
    insensitive names.  If this is not done the users MyISAM tables will
2232
 
    get corrupted if accesses with names of different case.
2233
 
  */
2234
 
  lower_case_file_system= test_if_case_insensitive(mysql_real_data_home);
2235
 
  if (!lower_case_table_names && lower_case_file_system == 1)
2236
 
  {
2237
 
    if (lower_case_table_names_used)
2238
 
    {
2239
 
      if (global_system_variables.log_warnings)
2240
 
        sql_print_warning("\
2241
 
You have forced lower_case_table_names to 0 through a command-line \
2242
 
option, even though your file system '%s' is case insensitive.  This means \
2243
 
that you can corrupt a MyISAM table by accessing it with different cases. \
2244
 
You should consider changing lower_case_table_names to 1 or 2",
2245
 
                        mysql_real_data_home);
2246
 
    }
2247
 
    else
2248
 
    {
2249
 
      if (global_system_variables.log_warnings)
2250
 
        sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);
2251
 
      lower_case_table_names= 2;
2252
 
    }
2253
 
  }
2254
 
  else if (lower_case_table_names == 2 &&
2255
 
           !(lower_case_file_system=
2256
 
             (test_if_case_insensitive(mysql_real_data_home) == 1)))
2257
 
  {
2258
 
    if (global_system_variables.log_warnings)
2259
 
      sql_print_warning("lower_case_table_names was set to 2, even though your "
2260
 
                        "the file system '%s' is case sensitive.  Now setting "
2261
 
                        "lower_case_table_names to 0 to avoid future problems.",
2262
 
                        mysql_real_data_home);
2263
 
    lower_case_table_names= 0;
2264
 
  }
2265
 
  else
2266
 
  {
2267
 
    lower_case_file_system=
2268
 
      (test_if_case_insensitive(mysql_real_data_home) == 1);
2269
 
  }
2270
2218
 
2271
2219
  /* Reset table_alias_charset, now that lower_case_table_names is set. */
2272
 
  table_alias_charset= (lower_case_table_names ?
2273
 
                        files_charset_info :
2274
 
                        &my_charset_bin);
 
2220
  lower_case_table_names= 1; /* This we need to look at */
 
2221
  table_alias_charset= files_charset_info;
2275
2222
 
2276
2223
  return 0;
2277
2224
}
2523
2470
    }
2524
2471
    if (!ha_storage_engine_is_enabled(hton))
2525
2472
    {
2526
 
      if (!opt_bootstrap)
2527
 
      {
2528
 
        sql_print_error("Default storage engine (%s) is not available",
2529
 
                        default_storage_engine_str);
2530
 
        unireg_abort(1);
2531
 
      }
 
2473
      sql_print_error("Default storage engine (%s) is not available",
 
2474
                      default_storage_engine_str);
 
2475
      unireg_abort(1);
2532
2476
      assert(global_system_variables.table_plugin);
2533
2477
    }
2534
2478
    else
2701
2645
  error_handler_hook= my_message_sql;
2702
2646
  start_signal_handler();                               // Creates pidfile
2703
2647
 
2704
 
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
 
2648
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name, false))
2705
2649
  {
2706
2650
    abort_loop=1;
2707
2651
    select_thread_in_use=0;
2708
2652
    (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
2709
2653
 
2710
 
    if (!opt_bootstrap)
2711
 
      (void) my_delete(pidfile_name,MYF(MY_WME));       // Not needed anymore
 
2654
    (void) my_delete(pidfile_name,MYF(MY_WME)); // Not needed anymore
2712
2655
 
2713
2656
    exit(1);
2714
2657
  }
2715
2658
 
2716
2659
  init_status_vars();
2717
 
  if (opt_bootstrap) /* If running with bootstrap, do not start replication. */
2718
 
    opt_skip_slave_start= 1;
2719
2660
  /*
2720
2661
    init_slave() must be called after the thread keys are created.
2721
2662
    Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other
2820
2761
inline void kill_broken_server()
2821
2762
{
2822
2763
  /* hack to get around signals ignored in syscalls for problem OS's */
2823
 
  if ((!opt_disable_networking && ip_sock == INVALID_SOCKET))
 
2764
  if ((ip_sock == INVALID_SOCKET))
2824
2765
  {
2825
2766
    select_thread_in_use = 0;
2826
2767
    /* The following call will never return */
2836
2777
 
2837
2778
void handle_connections_sockets()
2838
2779
{
 
2780
  int x;
2839
2781
  my_socket sock,new_sock;
2840
2782
  uint error_count=0;
2841
 
  uint max_used_connection= (uint)ip_sock+1;
2842
 
  fd_set readFDs,clientFDs;
2843
2783
  THD *thd;
2844
2784
  struct sockaddr_storage cAddr;
2845
 
  int ip_flags=0, flags;
2846
2785
  st_vio *vio_tmp;
2847
2786
 
2848
 
  FD_ZERO(&clientFDs);
2849
 
  if (ip_sock != INVALID_SOCKET)
2850
 
  {
2851
 
    FD_SET(ip_sock,&clientFDs);
2852
 
    ip_flags = fcntl(ip_sock, F_GETFL, 0);
2853
 
  }
2854
2787
  MAYBE_BROKEN_SYSCALL;
2855
2788
  while (!abort_loop)
2856
2789
  {
2857
 
    readFDs=clientFDs;
2858
 
    if (select((int) max_used_connection,&readFDs,0,0,0) < 0)
 
2790
    int number_of;
 
2791
 
 
2792
    if ((number_of= poll(fds, pollfd_count, -1)) == -1)
2859
2793
    {
2860
2794
      if (socket_errno != SOCKET_EINTR)
2861
2795
      {
2865
2799
      MAYBE_BROKEN_SYSCALL
2866
2800
      continue;
2867
2801
    }
 
2802
    if (number_of == 0)
 
2803
      continue;
 
2804
    
 
2805
#ifdef FIXME_IF_WE_WERE_KEEPING_THIS
 
2806
    assert(number_of > 1); /* Not handling this at the moment */
 
2807
#endif
 
2808
 
2868
2809
    if (abort_loop)
2869
2810
    {
2870
2811
      MAYBE_BROKEN_SYSCALL;
2871
2812
      break;
2872
2813
    }
2873
2814
 
2874
 
    /* Is this a new connection request ? */
 
2815
    for (x= 0, sock= -1; x < pollfd_count; x++)
2875
2816
    {
2876
 
      sock = ip_sock;
2877
 
      flags= ip_flags;
 
2817
      if (fds[x].revents == POLLIN)
 
2818
      {
 
2819
        sock= fds[x].fd;
 
2820
        break;
 
2821
      }
2878
2822
    }
 
2823
    assert(sock != -1);
2879
2824
 
2880
 
#if !defined(NO_FCNTL_NONBLOCK)
2881
 
    if (!(test_flags & TEST_BLOCKING))
2882
 
    {
2883
 
#if defined(O_NONBLOCK)
2884
 
      fcntl(sock, F_SETFL, flags | O_NONBLOCK);
2885
 
#elif defined(O_NDELAY)
2886
 
      fcntl(sock, F_SETFL, flags | O_NDELAY);
2887
 
#endif
2888
 
    }
2889
 
#endif /* NO_FCNTL_NONBLOCK */
2890
2825
    for (uint retry=0; retry < MAX_ACCEPT_RETRY; retry++)
2891
2826
    {
2892
2827
      size_socket length= sizeof(struct sockaddr_storage);
2893
2828
      new_sock= accept(sock, (struct sockaddr *)(&cAddr),
2894
2829
                       &length);
2895
 
      if (new_sock != INVALID_SOCKET ||
2896
 
          (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
 
2830
      if (new_sock != INVALID_SOCKET || (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
2897
2831
        break;
2898
 
      MAYBE_BROKEN_SYSCALL;
2899
 
#if !defined(NO_FCNTL_NONBLOCK)
2900
 
      if (!(test_flags & TEST_BLOCKING))
2901
 
      {
2902
 
        if (retry == MAX_ACCEPT_RETRY - 1)
2903
 
          fcntl(sock, F_SETFL, flags);          // Try without O_NONBLOCK
2904
 
      }
2905
 
#endif
2906
2832
    }
2907
 
#if !defined(NO_FCNTL_NONBLOCK)
2908
 
    if (!(test_flags & TEST_BLOCKING))
2909
 
      fcntl(sock, F_SETFL, flags);
2910
 
#endif
 
2833
 
 
2834
 
2911
2835
    if (new_sock == INVALID_SOCKET)
2912
2836
    {
2913
2837
      if ((error_count++ & 255) == 0)           // This can happen often
3650
3574
   "The argument will be treated as a decimal value with microsecond precission.",
3651
3575
   (char**) &long_query_time, (char**) &long_query_time, 0, GET_DOUBLE,
3652
3576
   REQUIRED_ARG, 10, 0, LONG_TIMEOUT, 0, 0, 0},
3653
 
  {"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,
3654
 
   "If set to 1 table names are stored in lowercase on disk and table names will be case-insensitive.  Should be set to 2 if you are using a case insensitive file system",
3655
 
   (char**) &lower_case_table_names,
3656
 
   (char**) &lower_case_table_names, 0, GET_UINT, OPT_ARG,
3657
 
#ifdef FN_NO_CASE_SENCE
3658
 
    1
3659
 
#else
3660
 
    0
3661
 
#endif
3662
 
   , 0, 2, 0, 1, 0},
3663
3577
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
3664
3578
   "Max packetlength to send/receive from to server.",
3665
3579
   (char**) &global_system_variables.max_allowed_packet,
3970
3884
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
3971
3885
};
3972
3886
 
3973
 
static int show_net_compression(THD *thd __attribute__((__unused__)),
 
3887
static int show_net_compression(THD *thd __attribute__((unused)),
3974
3888
                                SHOW_VAR *var,
3975
 
                                char *buff __attribute__((__unused__)))
 
3889
                                char *buff __attribute__((unused)))
3976
3890
{
3977
3891
  var->type= SHOW_MY_BOOL;
3978
3892
  var->value= (char *)&thd->net.compress;
4004
3918
static st_show_var_func_container
4005
3919
show_flushstatustime_cont= { &show_flushstatustime };
4006
3920
 
4007
 
static int show_slave_running(THD *thd __attribute__((__unused__)),
 
3921
static int show_slave_running(THD *thd __attribute__((unused)),
4008
3922
                              SHOW_VAR *var, char *buff)
4009
3923
{
4010
3924
  var->type= SHOW_MY_BOOL;
4019
3933
static st_show_var_func_container
4020
3934
show_slave_running_cont= { &show_slave_running };
4021
3935
 
4022
 
static int show_slave_retried_trans(THD *thd __attribute__((__unused__)),
 
3936
static int show_slave_retried_trans(THD *thd __attribute__((unused)),
4023
3937
                                    SHOW_VAR *var, char *buff)
4024
3938
{
4025
3939
  /*
4044
3958
static st_show_var_func_container
4045
3959
show_slave_retried_trans_cont= { &show_slave_retried_trans };
4046
3960
 
4047
 
static int show_slave_received_heartbeats(THD *thd __attribute__((__unused__)),
 
3961
static int show_slave_received_heartbeats(THD *thd __attribute__((unused)),
4048
3962
                                          SHOW_VAR *var, char *buff)
4049
3963
{
4050
3964
  pthread_mutex_lock(&LOCK_active_mi);
4065
3979
static st_show_var_func_container
4066
3980
show_slave_received_heartbeats_cont= { &show_slave_received_heartbeats };
4067
3981
 
4068
 
static int show_heartbeat_period(THD *thd __attribute__((__unused__)),
 
3982
static int show_heartbeat_period(THD *thd __attribute__((unused)),
4069
3983
                                 SHOW_VAR *var, char *buff)
4070
3984
{
4071
3985
  pthread_mutex_lock(&LOCK_active_mi);
4084
3998
static st_show_var_func_container
4085
3999
show_heartbeat_period_cont= { &show_heartbeat_period};
4086
4000
 
4087
 
static int show_open_tables(THD *thd __attribute__((__unused__)),
 
4001
static int show_open_tables(THD *thd __attribute__((unused)),
4088
4002
                            SHOW_VAR *var, char *buff)
4089
4003
{
4090
4004
  var->type= SHOW_LONG;
4093
4007
  return 0;
4094
4008
}
4095
4009
 
4096
 
static int show_table_definitions(THD *thd __attribute__((__unused__)),
 
4010
static int show_table_definitions(THD *thd __attribute__((unused)),
4097
4011
                                  SHOW_VAR *var, char *buff)
4098
4012
{
4099
4013
  var->type= SHOW_LONG;
4258
4172
  opt_log= opt_slow_log= 0;
4259
4173
  log_output_options= find_bit_type(log_output_str, &log_output_typelib);
4260
4174
  opt_bin_log= 0;
4261
 
  opt_disable_networking= opt_skip_show_db=0;
 
4175
  opt_skip_show_db=0;
4262
4176
  opt_logname= opt_binlog_index_name= opt_slow_logname= 0;
4263
4177
  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !
4264
4178
  opt_secure_auth= 0;
4265
4179
  opt_secure_file_priv= 0;
4266
 
  opt_bootstrap= opt_myisam_log= 0;
 
4180
  opt_myisam_log= 0;
4267
4181
  segfaulted= kill_in_progress= 0;
4268
4182
  cleanup_done= 0;
4269
4183
  defaults_argc= 0;
4284
4198
  mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;
4285
4199
  errmesg= 0;
4286
4200
  opt_mysql_tmpdir= my_bind_addr_str= NullS;
4287
 
  bzero((uchar*) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
4288
 
  bzero((char *) &global_status_var, sizeof(global_status_var));
 
4201
  memset((uchar*) &mysql_tmpdir_list, 0, sizeof(mysql_tmpdir_list));
 
4202
  memset((char *) &global_status_var, 0, sizeof(global_status_var));
4289
4203
  key_map_full.set_all();
4290
4204
 
4291
4205
  /* Character sets */
4303
4217
  slave_exec_mode_options= (uint)
4304
4218
    find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);
4305
4219
  opt_specialflag= SPECIAL_ENGLISH;
4306
 
  ip_sock= INVALID_SOCKET;
4307
4220
  mysql_home_ptr= mysql_home;
4308
4221
  pidfile_name_ptr= pidfile_name;
4309
4222
  log_error_file_ptr= log_error_file;
4461
4374
    opt_error_log= 1;
4462
4375
    break;
4463
4376
  case (int)OPT_REPLICATE_IGNORE_DB:
4464
 
  {
4465
 
    rpl_filter->add_ignore_db(argument);
4466
 
    break;
4467
 
  }
 
4377
    {
 
4378
      rpl_filter->add_ignore_db(argument);
 
4379
      break;
 
4380
    }
4468
4381
  case (int)OPT_REPLICATE_DO_DB:
4469
 
  {
4470
 
    rpl_filter->add_do_db(argument);
4471
 
    break;
4472
 
  }
 
4382
    {
 
4383
      rpl_filter->add_do_db(argument);
 
4384
      break;
 
4385
    }
4473
4386
  case (int)OPT_REPLICATE_REWRITE_DB:
4474
 
  {
4475
 
    char* key = argument,*p, *val;
4476
 
 
4477
 
    if (!(p= strstr(argument, "->")))
4478
 
    {
4479
 
      fprintf(stderr,
4480
 
              "Bad syntax in replicate-rewrite-db - missing '->'!\n");
4481
 
      exit(1);
4482
 
    }
4483
 
    val= p--;
4484
 
    while (my_isspace(mysqld_charset, *p) && p > argument)
4485
 
      *p-- = 0;
4486
 
    if (p == argument)
4487
 
    {
4488
 
      fprintf(stderr,
4489
 
              "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
4490
 
      exit(1);
4491
 
    }
4492
 
    *val= 0;
4493
 
    val+= 2;
4494
 
    while (*val && my_isspace(mysqld_charset, *val))
4495
 
      *val++;
4496
 
    if (!*val)
4497
 
    {
4498
 
      fprintf(stderr,
4499
 
              "Bad syntax in replicate-rewrite-db - empty TO db!\n");
4500
 
      exit(1);
4501
 
    }
4502
 
 
4503
 
    rpl_filter->add_db_rewrite(key, val);
4504
 
    break;
4505
 
  }
 
4387
    {
 
4388
      char* key = argument,*p, *val;
 
4389
 
 
4390
      if (!(p= strstr(argument, "->")))
 
4391
      {
 
4392
        fprintf(stderr,
 
4393
                "Bad syntax in replicate-rewrite-db - missing '->'!\n");
 
4394
        exit(1);
 
4395
      }
 
4396
      val= p--;
 
4397
      while (my_isspace(mysqld_charset, *p) && p > argument)
 
4398
        *p-- = 0;
 
4399
      if (p == argument)
 
4400
      {
 
4401
        fprintf(stderr,
 
4402
                "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
 
4403
        exit(1);
 
4404
      }
 
4405
      *val= 0;
 
4406
      val+= 2;
 
4407
      while (*val && my_isspace(mysqld_charset, *val))
 
4408
        *val++;
 
4409
      if (!*val)
 
4410
      {
 
4411
        fprintf(stderr,
 
4412
                "Bad syntax in replicate-rewrite-db - empty TO db!\n");
 
4413
        exit(1);
 
4414
      }
 
4415
 
 
4416
      rpl_filter->add_db_rewrite(key, val);
 
4417
      break;
 
4418
    }
4506
4419
 
4507
4420
  case (int)OPT_BINLOG_IGNORE_DB:
4508
 
  {
4509
 
    binlog_filter->add_ignore_db(argument);
4510
 
    break;
4511
 
  }
 
4421
    {
 
4422
      binlog_filter->add_ignore_db(argument);
 
4423
      break;
 
4424
    }
4512
4425
  case OPT_BINLOG_FORMAT:
4513
 
  {
4514
 
    int id;
4515
 
    id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
4516
 
    global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
4517
 
    break;
4518
 
  }
 
4426
    {
 
4427
      int id;
 
4428
      id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
 
4429
      global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
 
4430
      break;
 
4431
    }
4519
4432
  case (int)OPT_BINLOG_DO_DB:
4520
 
  {
4521
 
    binlog_filter->add_do_db(argument);
4522
 
    break;
4523
 
  }
 
4433
    {
 
4434
      binlog_filter->add_do_db(argument);
 
4435
      break;
 
4436
    }
4524
4437
  case (int)OPT_REPLICATE_DO_TABLE:
4525
 
  {
4526
 
    if (rpl_filter->add_do_table(argument))
4527
4438
    {
4528
 
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
4529
 
      exit(1);
 
4439
      if (rpl_filter->add_do_table(argument))
 
4440
      {
 
4441
        fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4442
        exit(1);
 
4443
      }
 
4444
      break;
4530
4445
    }
4531
 
    break;
4532
 
  }
4533
4446
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
4534
 
  {
4535
 
    if (rpl_filter->add_wild_do_table(argument))
4536
4447
    {
4537
 
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
4538
 
      exit(1);
 
4448
      if (rpl_filter->add_wild_do_table(argument))
 
4449
      {
 
4450
        fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
 
4451
        exit(1);
 
4452
      }
 
4453
      break;
4539
4454
    }
4540
 
    break;
4541
 
  }
4542
4455
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
4543
 
  {
4544
 
    if (rpl_filter->add_wild_ignore_table(argument))
4545
4456
    {
4546
 
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
4547
 
      exit(1);
 
4457
      if (rpl_filter->add_wild_ignore_table(argument))
 
4458
      {
 
4459
        fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4460
        exit(1);
 
4461
      }
 
4462
      break;
4548
4463
    }
4549
 
    break;
4550
 
  }
4551
4464
  case (int)OPT_REPLICATE_IGNORE_TABLE:
4552
 
  {
4553
 
    if (rpl_filter->add_ignore_table(argument))
4554
4465
    {
4555
 
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
4556
 
      exit(1);
 
4466
      if (rpl_filter->add_ignore_table(argument))
 
4467
      {
 
4468
        fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
 
4469
        exit(1);
 
4470
      }
 
4471
      break;
4557
4472
    }
4558
 
    break;
4559
 
  }
4560
4473
  case (int) OPT_SLOW_QUERY_LOG:
4561
4474
    opt_slow_log= 1;
4562
4475
    break;
4563
4476
#ifdef WITH_CSV_STORAGE_ENGINE
4564
4477
  case  OPT_LOG_OUTPUT:
4565
 
  {
4566
 
    if (!argument || !argument[0])
4567
4478
    {
4568
 
      log_output_options= LOG_FILE;
4569
 
      log_output_str= log_output_typelib.type_names[1];
 
4479
      if (!argument || !argument[0])
 
4480
      {
 
4481
        log_output_options= LOG_FILE;
 
4482
        log_output_str= log_output_typelib.type_names[1];
 
4483
      }
 
4484
      else
 
4485
      {
 
4486
        log_output_str= argument;
 
4487
        log_output_options=
 
4488
          find_bit_type_or_exit(argument, &log_output_typelib, opt->name);
 
4489
      }
 
4490
      break;
4570
4491
    }
4571
 
    else
4572
 
    {
4573
 
      log_output_str= argument;
4574
 
      log_output_options=
4575
 
        find_bit_type_or_exit(argument, &log_output_typelib, opt->name);
4576
 
  }
4577
 
    break;
4578
 
  }
4579
4492
#endif
4580
4493
  case (int) OPT_SKIP_NEW:
4581
4494
    opt_specialflag|= SPECIAL_NO_NEW_FUNC;
4611
4524
    {
4612
4525
      struct addrinfo *res_lst, hints;    
4613
4526
 
4614
 
      bzero(&hints, sizeof(struct addrinfo));
 
4527
      memset(&hints, 0, sizeof(struct addrinfo));
4615
4528
      hints.ai_socktype= SOCK_STREAM;
4616
4529
      hints.ai_protocol= IPPROTO_TCP;
4617
4530
 
4640
4553
    thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
4641
4554
    global_system_variables.low_priority_updates=1;
4642
4555
    break;
4643
 
  case OPT_BOOTSTRAP:
4644
 
    opt_noacl=opt_bootstrap=1;
4645
 
    break;
4646
4556
  case OPT_SERVER_ID:
4647
4557
    server_id_supplied = 1;
4648
4558
    break;
4667
4577
    charsets_dir = mysql_charsets_dir;
4668
4578
    break;
4669
4579
  case OPT_TX_ISOLATION:
4670
 
  {
4671
 
    int type;
4672
 
    type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
4673
 
    global_system_variables.tx_isolation= (type-1);
4674
 
    break;
4675
 
  }
 
4580
    {
 
4581
      int type;
 
4582
      type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
 
4583
      global_system_variables.tx_isolation= (type-1);
 
4584
      break;
 
4585
    }
4676
4586
  case OPT_MYISAM_RECOVER:
4677
 
  {
4678
 
    if (!argument)
4679
 
    {
4680
 
      myisam_recover_options=    HA_RECOVER_DEFAULT;
4681
 
      myisam_recover_options_str= myisam_recover_typelib.type_names[0];
4682
 
    }
4683
 
    else if (!argument[0])
4684
 
    {
4685
 
      myisam_recover_options= HA_RECOVER_NONE;
4686
 
      myisam_recover_options_str= "OFF";
4687
 
    }
4688
 
    else
4689
 
    {
4690
 
      myisam_recover_options_str=argument;
4691
 
      myisam_recover_options=
4692
 
        find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
4693
 
    }
4694
 
    ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
4695
 
    break;
4696
 
  }
 
4587
    {
 
4588
      if (!argument)
 
4589
      {
 
4590
        myisam_recover_options=    HA_RECOVER_DEFAULT;
 
4591
        myisam_recover_options_str= myisam_recover_typelib.type_names[0];
 
4592
      }
 
4593
      else if (!argument[0])
 
4594
      {
 
4595
        myisam_recover_options= HA_RECOVER_NONE;
 
4596
        myisam_recover_options_str= "OFF";
 
4597
      }
 
4598
      else
 
4599
      {
 
4600
        myisam_recover_options_str=argument;
 
4601
        myisam_recover_options=
 
4602
          find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
 
4603
      }
 
4604
      ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
 
4605
      break;
 
4606
    }
4697
4607
  case OPT_TC_HEURISTIC_RECOVER:
4698
4608
    tc_heuristic_recover= find_type_or_exit(argument,
4699
4609
                                            &tc_heuristic_recover_typelib,
4700
4610
                                            opt->name);
4701
4611
    break;
4702
4612
  case OPT_MYISAM_STATS_METHOD:
4703
 
  {
4704
 
    ulong method_conv;
4705
 
    int method;
 
4613
    {
 
4614
      ulong method_conv;
 
4615
      int method;
4706
4616
 
4707
 
    myisam_stats_method_str= argument;
4708
 
    method= find_type_or_exit(argument, &myisam_stats_method_typelib,
4709
 
                              opt->name);
4710
 
    switch (method-1) {
4711
 
    case 2:
4712
 
      method_conv= MI_STATS_METHOD_IGNORE_NULLS;
4713
 
      break;
4714
 
    case 1:
4715
 
      method_conv= MI_STATS_METHOD_NULLS_EQUAL;
4716
 
      break;
4717
 
    case 0:
4718
 
    default:
4719
 
      method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
 
4617
      myisam_stats_method_str= argument;
 
4618
      method= find_type_or_exit(argument, &myisam_stats_method_typelib,
 
4619
                                opt->name);
 
4620
      switch (method-1) {
 
4621
      case 2:
 
4622
        method_conv= MI_STATS_METHOD_IGNORE_NULLS;
 
4623
        break;
 
4624
      case 1:
 
4625
        method_conv= MI_STATS_METHOD_NULLS_EQUAL;
 
4626
        break;
 
4627
      case 0:
 
4628
      default:
 
4629
        method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
 
4630
        break;
 
4631
      }
 
4632
      global_system_variables.myisam_stats_method= method_conv;
4720
4633
      break;
4721
4634
    }
4722
 
    global_system_variables.myisam_stats_method= method_conv;
4723
 
    break;
4724
 
  }
4725
 
  case OPT_LOWER_CASE_TABLE_NAMES:
4726
 
    lower_case_table_names= argument ? atoi(argument) : 1;
4727
 
    lower_case_table_names_used= 1;
4728
 
    break;
4729
4635
  }
4730
4636
  return 0;
4731
4637
}
4773
4679
  va_start(args, format);
4774
4680
 
4775
4681
  /* Don't print warnings for --loose options during bootstrap */
4776
 
  if (level == ERROR_LEVEL || !opt_bootstrap ||
4777
 
      global_system_variables.log_warnings)
 
4682
  if (level == ERROR_LEVEL || global_system_variables.log_warnings)
4778
4683
  {
4779
4684
    vprint_msg_to_log(level, format, args);
4780
4685
  }
5064
4969
 
5065
4970
 
5066
4971
/**
5067
 
  Check if file system used for databases is case insensitive.
5068
 
 
5069
 
  @param dir_name                       Directory to test
5070
 
 
5071
 
  @retval
5072
 
    -1  Don't know (Test failed)
5073
 
  @retval
5074
 
    0   File system is case sensitive
5075
 
  @retval
5076
 
    1   File system is case insensitive
5077
 
*/
5078
 
 
5079
 
static int test_if_case_insensitive(const char *dir_name)
5080
 
{
5081
 
  int result= 0;
5082
 
  File file;
5083
 
  char buff[FN_REFLEN], buff2[FN_REFLEN];
5084
 
  struct stat stat_info;
5085
 
 
5086
 
  fn_format(buff, glob_hostname, dir_name, ".lower-test",
5087
 
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
5088
 
  fn_format(buff2, glob_hostname, dir_name, ".LOWER-TEST",
5089
 
            MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
5090
 
  (void) my_delete(buff2, MYF(0));
5091
 
  if ((file= my_create(buff, 0666, O_RDWR, MYF(0))) < 0)
5092
 
  {
5093
 
    sql_print_warning("Can't create test file %s", buff);
5094
 
    return(-1);
5095
 
  }
5096
 
  my_close(file, MYF(0));
5097
 
  if (!stat(buff2, &stat_info))
5098
 
    result= 1;                                  // Can access file
5099
 
  (void) my_delete(buff, MYF(MY_WME));
5100
 
  return(result);
5101
 
}
5102
 
 
5103
 
 
5104
 
/**
5105
4972
  Create file to store pid number.
5106
4973
*/
5107
4974
static void create_pid_file()
5133
5000
  add_to_status(&global_status_var, &thd->status_var);
5134
5001
 
5135
5002
  /* Reset thread's status variables */
5136
 
  bzero((uchar*) &thd->status_var, sizeof(thd->status_var));
 
5003
  memset((uchar*) &thd->status_var, 0, sizeof(thd->status_var));
5137
5004
 
5138
5005
  /* Reset some global variables */
5139
5006
  reset_status_vars();