← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/mysqltest.c

  • Committer: Stewart Smith
  • Date: 2008-06-30 05:33:25 UTC
  • mfrom: (12.2.8 drizzle)
  • mto: This revision was merged to the branch mainline in revision 19.
  • Revision ID: stewart@flamingspork.com-20080630053325-mwrv6bjaufcpvj8n
merge my work

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/mysqltest.c
45
45
#ifdef HAVE_SYS_WAIT_H
46
46
#include <sys/wait.h>
47
47
#endif
48
 
#ifdef __WIN__
49
 
#include <direct.h>
50
 
#endif
51
 
 
52
 
 
53
 
/* Use cygwin for --exec and --system before 5.0 */
54
 
#if MYSQL_VERSION_ID < 50000
55
 
#define USE_CYGWIN
56
 
#endif
 
48
 
 
49
 
57
50
 
58
51
#define MAX_VAR_NAME_LENGTH    256
59
52
#define MAX_COLUMNS            256
435
428
void str_to_file(const char *fname, char *str, int size);
436
429
void str_to_file2(const char *fname, char *str, int size, my_bool append);
437
430
 
438
 
#ifdef __WIN__
439
 
void free_tmp_sh_file();
440
 
void free_win_path_patterns();
441
 
#endif
442
 
 
443
 
 
444
431
/* For replace_column */
445
432
static char *replace_column[MAX_COLUMNS];
446
433
static uint max_replace_column= 0;
938
925
  my_free(opt_pass,MYF(MY_ALLOW_ZERO_PTR));
939
926
  free_defaults(default_argv);
940
927
  free_re();
941
 
#ifdef __WIN__
942
 
  free_tmp_sh_file();
943
 
  free_win_path_patterns();
944
 
#endif
945
928
 
946
929
  /* Only call mysql_server_end if mysql_server_init has been called */
947
930
  if (server_initialized)
1275
1258
  DBUG_ENTER("run_tool");
1276
1259
  DBUG_PRINT("enter", ("tool_path: %s", tool_path));
1277
1260
 
1278
 
  if (init_dynamic_string(&ds_cmdline, IF_WIN("\"", ""), FN_REFLEN, FN_REFLEN))
 
1261
  if (init_dynamic_string(&ds_cmdline, "", FN_REFLEN, FN_REFLEN))
1279
1262
    die("Out of memory");
1280
1263
 
1281
1264
  dynstr_append_os_quoted(&ds_cmdline, tool_path, NullS);
1295
1278
 
1296
1279
  va_end(args);
1297
1280
 
1298
 
#ifdef __WIN__
1299
 
  dynstr_append(&ds_cmdline, "\"");
1300
 
#endif
1301
 
 
1302
1281
  DBUG_PRINT("info", ("Running: %s", ds_cmdline.str));
1303
1282
  ret= run_command(ds_cmdline.str, ds_res);
1304
1283
  DBUG_PRINT("exit", ("ret: %d", ret));
1362
1341
"Instead the whole content of the two files was shown for you to diff manually. ;)\n\n"
1363
1342
"To get a better report you should install 'diff' on your system, which you\n"
1364
1343
"for example can get from http://www.gnu.org/software/diffutils/diffutils.html\n"
1365
 
#ifdef __WIN__
1366
 
"or http://gnuwin32.sourceforge.net/packages/diffutils.htm\n"
1367
 
#endif
1368
1344
"\n");
1369
1345
 
1370
1346
      dynstr_append(&ds_tmp, " --- ");
2262
2238
}
2263
2239
 
2264
2240
 
2265
 
#if defined __WIN__
2266
 
 
2267
 
#ifdef USE_CYGWIN
2268
 
/* Variables used for temporary sh files used for emulating Unix on Windows */
2269
 
char tmp_sh_name[64], tmp_sh_cmd[70];
2270
 
#endif
2271
 
 
2272
 
void init_tmp_sh_file()
2273
 
{
2274
 
#ifdef USE_CYGWIN
2275
 
  /* Format a name for the tmp sh file that is unique for this process */
2276
 
  my_snprintf(tmp_sh_name, sizeof(tmp_sh_name), "tmp_%d.sh", getpid());
2277
 
  /* Format the command to execute in order to run the script */
2278
 
  my_snprintf(tmp_sh_cmd, sizeof(tmp_sh_cmd), "sh %s", tmp_sh_name);
2279
 
#endif
2280
 
}
2281
 
 
2282
 
 
2283
 
void free_tmp_sh_file()
2284
 
{
2285
 
#ifdef USE_CYGWIN
2286
 
  my_delete(tmp_sh_name, MYF(0));
2287
 
#endif
2288
 
}
2289
 
#endif
2290
 
 
2291
 
 
2292
2241
FILE* my_popen(DYNAMIC_STRING *ds_cmd, const char *mode)
2293
2242
{
2294
 
#if defined __WIN__ && defined USE_CYGWIN
2295
 
  /* Dump the command into a sh script file and execute with popen */
2296
 
  str_to_file(tmp_sh_name, ds_cmd->str, ds_cmd->length);
2297
 
  return popen(tmp_sh_cmd, mode);
2298
 
#else
2299
2243
  return popen(ds_cmd->str, mode);
2300
 
#endif
2301
2244
}
2302
2245
 
2303
2246
 
2304
2247
static void init_builtin_echo(void)
2305
2248
{
2306
 
#ifdef __WIN__
2307
 
  size_t echo_length;
2308
 
 
2309
 
  /* Look for "echo.exe" in same dir as mysqltest was started from */
2310
 
  dirname_part(builtin_echo, my_progname, &echo_length);
2311
 
  fn_format(builtin_echo, ".\\echo.exe",
2312
 
            builtin_echo, "", MYF(MY_REPLACE_DIR));
2313
 
 
2314
 
  /* Make sure echo.exe exists */
2315
 
  if (access(builtin_echo, F_OK) != 0)
2316
 
    builtin_echo[0]= 0;
2317
 
  return;
2318
 
 
2319
 
#else
2320
 
 
2321
2249
  builtin_echo[0]= 0;
2322
2250
  return;
2323
 
 
2324
 
#endif
2325
2251
}
2326
2252
 
2327
2253
 
2409
2335
    replace(&ds_cmd, "echo", 4, builtin_echo, strlen(builtin_echo));
2410
2336
  }
2411
2337
 
2412
 
#ifdef __WIN__
2413
 
#ifndef USE_CYGWIN
2414
 
  /* Replace /dev/null with NUL */
2415
 
  while(replace(&ds_cmd, "/dev/null", 9, "NUL", 3) == 0)
2416
 
    ;
2417
 
  /* Replace "closed stdout" with non existing output fd */
2418
 
  while(replace(&ds_cmd, ">&-", 3, ">&4", 3) == 0)
2419
 
    ;
2420
 
#endif
2421
 
#endif
2422
 
 
2423
2338
  DBUG_PRINT("info", ("Executing '%s' as '%s'",
2424
2339
                      command->first_argument, ds_cmd.str));
2425
2340
 
2553
2468
 
2554
2469
int my_system(DYNAMIC_STRING* ds_cmd)
2555
2470
{
2556
 
#if defined __WIN__ && defined USE_CYGWIN
2557
 
  /* Dump the command into a sh script file and execute with system */
2558
 
  str_to_file(tmp_sh_name, ds_cmd->str, ds_cmd->length);
2559
 
  return system(tmp_sh_cmd);
2560
 
#else
2561
2471
  return system(ds_cmd->str);
2562
 
#endif
2563
2472
}
2564
2473
 
2565
2474
 
2589
2498
  /* Eval the system command, thus replacing all environment variables */
2590
2499
  do_eval(&ds_cmd, command->first_argument, command->end, !is_windows);
2591
2500
 
2592
 
#ifdef __WIN__
2593
 
#ifndef USE_CYGWIN
2594
 
   /* Replace /dev/null with NUL */
2595
 
   while(replace(&ds_cmd, "/dev/null", 9, "NUL", 3) == 0)
2596
 
     ;
2597
 
#endif
2598
 
#endif
2599
 
 
2600
 
 
2601
2501
  DBUG_PRINT("info", ("running system command '%s' as '%s'",
2602
2502
                      command->first_argument, ds_cmd.str));
2603
2503
  if (my_system(&ds_cmd))
5404
5304
  }
5405
5305
}
5406
5306
 
5407
 
 
5408
 
#ifdef __WIN__
5409
 
 
5410
 
DYNAMIC_ARRAY patterns;
5411
 
 
5412
 
/*
5413
 
  init_win_path_patterns
5414
 
 
5415
 
  DESCRIPTION
5416
 
  Setup string patterns that will be used to detect filenames that
5417
 
  needs to be converted from Win to Unix format
5418
 
 
5419
 
*/
5420
 
 
5421
 
void init_win_path_patterns()
5422
 
{
5423
 
  /* List of string patterns to match in order to find paths */
5424
 
  const char* paths[] = { "$MYSQL_TEST_DIR",
5425
 
                          "$MYSQL_TMP_DIR",
5426
 
                          "$MYSQLTEST_VARDIR",
5427
 
                          "./test/" };
5428
 
  int num_paths= sizeof(paths)/sizeof(char*);
5429
 
  int i;
5430
 
  char* p;
5431
 
 
5432
 
  DBUG_ENTER("init_win_path_patterns");
5433
 
 
5434
 
  my_init_dynamic_array(&patterns, sizeof(const char*), 16, 16);
5435
 
 
5436
 
  /* Loop through all paths in the array */
5437
 
  for (i= 0; i < num_paths; i++)
5438
 
  {
5439
 
    VAR* v;
5440
 
    if (*(paths[i]) == '$')
5441
 
    {
5442
 
      v= var_get(paths[i], 0, 0, 0);
5443
 
      p= my_strdup(v->str_val, MYF(MY_FAE));
5444
 
    }
5445
 
    else
5446
 
      p= my_strdup(paths[i], MYF(MY_FAE));
5447
 
 
5448
 
    /* Don't insert zero length strings in patterns array */
5449
 
    if (strlen(p) == 0)
5450
 
    {
5451
 
      my_free(p, MYF(0));
5452
 
      continue;
5453
 
    }
5454
 
 
5455
 
    if (insert_dynamic(&patterns, (uchar*) &p))
5456
 
      die(NullS);
5457
 
 
5458
 
    DBUG_PRINT("info", ("p: %s", p));
5459
 
    while (*p)
5460
 
    {
5461
 
      if (*p == '/')
5462
 
        *p='\\';
5463
 
      p++;
5464
 
    }
5465
 
  }
5466
 
  DBUG_VOID_RETURN;
5467
 
}
5468
 
 
5469
 
void free_win_path_patterns()
5470
 
{
5471
 
  uint i= 0;
5472
 
  for (i=0 ; i < patterns.elements ; i++)
5473
 
  {
5474
 
    const char** pattern= dynamic_element(&patterns, i, const char**);
5475
 
    my_free((char*) *pattern, MYF(0));
5476
 
  }
5477
 
  delete_dynamic(&patterns);
5478
 
}
5479
 
 
5480
 
/*
5481
 
  fix_win_paths
5482
 
 
5483
 
  DESCRIPTION
5484
 
  Search the string 'val' for the patterns that are known to be
5485
 
  strings that contain filenames. Convert all \ to / in the
5486
 
  filenames that are found.
5487
 
 
5488
 
  Ex:
5489
 
  val = 'Error "c:\mysql\mysql-test\var\test\t1.frm" didn't exist'
5490
 
  => $MYSQL_TEST_DIR is found by strstr
5491
 
  => all \ from c:\mysql\m... until next space is converted into /
5492
 
*/
5493
 
 
5494
 
void fix_win_paths(const char *val, int len)
5495
 
{
5496
 
  uint i;
5497
 
  char *p;
5498
 
 
5499
 
  DBUG_ENTER("fix_win_paths");
5500
 
  for (i= 0; i < patterns.elements; i++)
5501
 
  {
5502
 
    const char** pattern= dynamic_element(&patterns, i, const char**);
5503
 
    DBUG_PRINT("info", ("pattern: %s", *pattern));
5504
 
 
5505
 
    /* Search for the path in string */
5506
 
    while ((p= strstr(val, *pattern)))
5507
 
    {
5508
 
      DBUG_PRINT("info", ("Found %s in val p: %s", *pattern, p));
5509
 
 
5510
 
      while (*p && !my_isspace(charset_info, *p))
5511
 
      {
5512
 
        if (*p == '\\')
5513
 
          *p= '/';
5514
 
        p++;
5515
 
      }
5516
 
      DBUG_PRINT("info", ("Converted \\ to /, p: %s", p));
5517
 
    }
5518
 
  }
5519
 
  DBUG_PRINT("exit", (" val: %s, len: %d", val, len));
5520
 
  DBUG_VOID_RETURN;
5521
 
}
5522
 
#endif
5523
 
 
5524
 
 
5525
 
 
5526
5307
/*
5527
5308
  Append the result for one field to the dynamic string ds
5528
5309
*/
5540
5321
    val= "NULL";
5541
5322
    len= 4;
5542
5323
  }
5543
 
#ifdef __WIN__
5544
 
  else if ((field->type == MYSQL_TYPE_DOUBLE ||
5545
 
            field->type == MYSQL_TYPE_FLOAT ) &&
5546
 
           field->decimals >= 31)
5547
 
  {
5548
 
    /* Convert 1.2e+018 to 1.2e+18 and 1.2e-018 to 1.2e-18 */
5549
 
    char *start= strchr(val, 'e');
5550
 
    if (start && strlen(start) >= 5 &&
5551
 
        (start[1] == '-' || start[1] == '+') && start[2] == '0')
5552
 
    {
5553
 
      start+=2; /* Now points at first '0' */
5554
 
      /* Move all chars after the first '0' one step left */
5555
 
      memmove(start, start + 1, strlen(start));
5556
 
      len--;
5557
 
    }
5558
 
  }
5559
 
#endif
5560
5324
 
5561
5325
  if (!display_result_vertically)
5562
5326
  {
6767
6531
  my_bool q_send_flag= 0, abort_flag= 0;
6768
6532
  uint command_executed= 0, last_command_executed= 0;
6769
6533
  char save_file[FN_REFLEN];
6770
 
  MY_STAT res_info;
 
6534
  struct stat res_info;
6771
6535
  MY_INIT(argv[0]);
6772
6536
 
6773
6537
  save_file[0]= 0;
6816
6580
  memset(&var_reg, 0, sizeof(var_reg));
6817
6581
 
6818
6582
  init_builtin_echo();
6819
 
#ifdef __WIN__
6820
 
#ifndef USE_CYGWIN
6821
 
  is_windows= 1;
6822
 
#endif
6823
 
  init_tmp_sh_file();
6824
 
  init_win_path_patterns();
6825
 
#endif
6826
6583
 
6827
6584
  init_dynamic_string(&ds_res, "", 65536, 65536);
6828
6585
  init_dynamic_string(&ds_progress, "", 0, 2048);
7242
6999
  }
7243
7000
 
7244
7001
  if (!command_executed &&
7245
 
      result_file_name && my_stat(result_file_name, &res_info, 0))
 
7002
      result_file_name && !stat(result_file_name, &res_info))
7246
7003
  {
7247
7004
    /*
7248
7005
      my_stat() successful on result file. Check if we have not run a
8608
8365
void replace_dynstr_append_mem(DYNAMIC_STRING *ds,
8609
8366
                               const char *val, int len)
8610
8367
{
8611
 
#ifdef __WIN__
8612
 
  fix_win_paths(val, len);
8613
 
#endif
8614
 
 
8615
8368
  if (glob_replace_regex)
8616
8369
  {
8617
8370
    /* Regex replace */