← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/default.c

  • Committer: Mark Atwood
  • Date: 2008-10-03 01:39:40 UTC
  • mto: This revision was merged to the branch mainline in revision 437.
  • Revision ID: mark@fallenpegasus.com-20081003013940-mvefjo725dltz41h
rename logging_noop to logging_query

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/default.c
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/****************************************************************************
17
17
 Add all options from files named "group".cnf from the default_directories
33
33
 --print-defaults         ; Print the modified command line and exit
34
34
****************************************************************************/
35
35
 
36
 
#include <config.h>
37
 
 
38
 
#include <drizzled/internal/my_sys.h>
39
 
#include <drizzled/internal/m_string.h>
40
 
#include <drizzled/charset_info.h>
41
 
#include <drizzled/typelib.h>
42
 
#include <drizzled/configmake.h>
43
 
#include <drizzled/gettext.h>
44
 
 
45
 
#include <drizzled/cached_directory.h>
46
 
 
47
 
#ifdef HAVE_SYS_STAT_H
48
 
# include <sys/stat.h>
49
 
#endif
50
 
 
51
 
#include <cstdio>
52
 
#include <algorithm>
53
 
 
54
 
using namespace std;
55
 
 
56
 
namespace drizzled
57
 
{
58
 
namespace internal
59
 
{
 
36
#include "mysys_priv.h"
 
37
#include <mystrings/m_string.h>
 
38
#include <mystrings/m_ctype.h>
 
39
#include <my_dir.h>
60
40
 
61
41
const char *my_defaults_file=0;
62
42
const char *my_defaults_group_suffix=0;
68
48
const char *default_directories[MAX_DEFAULT_DIRS + 1];
69
49
 
70
50
static const char *f_extensions[]= { ".cnf", 0 };
 
51
#define NEWLINE "\n"
71
52
 
72
 
int handle_default_option(void *in_ctx, const char *group_name,
73
 
                          const char *option);
 
53
static int handle_default_option(void *in_ctx, const char *group_name,
 
54
                                 const char *option);
74
55
 
75
56
/*
76
57
   This structure defines the context that we pass to callback
81
62
 
82
63
struct handle_option_ctx
83
64
{
84
 
   memory::Root *alloc;
 
65
   MEM_ROOT *alloc;
85
66
   DYNAMIC_ARRAY *args;
86
67
   TYPELIB *group;
87
68
};
145
126
*/
146
127
 
147
128
int my_search_option_files(const char *conf_file, int *argc, char ***argv,
148
 
                           uint32_t *args_used, Process_option_func func,
 
129
                           uint *args_used, Process_option_func func,
149
130
                           void *func_ctx)
150
131
{
151
132
  const char **dirs, *forced_default_file, *forced_extra_defaults;
158
139
                                    (char **) &my_defaults_group_suffix);
159
140
 
160
141
  if (! my_defaults_group_suffix)
161
 
    my_defaults_group_suffix= getenv("DRIZZLE_GROUP_SUFFIX");
 
142
    my_defaults_group_suffix= getenv(STRINGIFY_ARG(DEFAULT_GROUP_SUFFIX_ENV));
162
143
 
163
144
  if (forced_extra_defaults)
164
145
    my_defaults_extra_file= (char *) forced_extra_defaults;
165
 
 
 
146
  
166
147
  if (forced_default_file)
167
148
    my_defaults_file= forced_default_file;
168
149
 
171
152
    load_defaults() as otherwise we can't know the type of 'func_ctx'
172
153
  */
173
154
 
174
 
  if (my_defaults_group_suffix && (func == handle_default_option))
 
155
  if (my_defaults_group_suffix && func == handle_default_option)
175
156
  {
176
157
    /* Handle --defaults-group-suffix= */
177
 
    uint32_t i;
 
158
    uint i;
178
159
    const char **extra_groups;
179
 
    const size_t instance_len= strlen(my_defaults_group_suffix);
 
160
    const uint instance_len= strlen(my_defaults_group_suffix); 
180
161
    struct handle_option_ctx *ctx= (struct handle_option_ctx*) func_ctx;
181
162
    char *ptr;
182
163
    TYPELIB *group= ctx->group;
183
 
 
184
 
    if (!(extra_groups=
185
 
          (const char**)ctx->alloc->alloc_root(
 
164
    
 
165
    if (!(extra_groups= 
 
166
          (const char**)alloc_root(ctx->alloc,
186
167
                                   (2*group->count+1)*sizeof(char*))))
187
168
      goto err;
188
 
 
 
169
    
189
170
    for (i= 0; i < group->count; i++)
190
171
    {
191
 
      size_t len;
 
172
      uint len;
192
173
      extra_groups[i]= group->type_names[i]; /** copy group */
193
 
 
 
174
      
194
175
      len= strlen(extra_groups[i]);
195
 
      if (!(ptr= (char *)ctx->alloc->alloc_root( len+instance_len+1)))
 
176
      if (!(ptr= alloc_root(ctx->alloc, len+instance_len+1)))
196
177
        goto err;
197
 
 
 
178
      
198
179
      extra_groups[i+group->count]= ptr;
199
 
 
 
180
      
200
181
      /** Construct new group */
201
182
      memcpy(ptr, extra_groups[i], len);
202
183
      memcpy(ptr+len, my_defaults_group_suffix, instance_len+1);
203
184
    }
204
 
 
 
185
    
205
186
    group->count*= 2;
206
187
    group->type_names= extra_groups;
207
188
    group->type_names[group->count]= 0;
208
189
  }
209
 
 
 
190
  
210
191
  if (forced_default_file)
211
192
  {
212
193
    if ((error= search_default_file_with_ext(func, func_ctx, "", "",
221
202
  }
222
203
  else if (dirname_length(conf_file))
223
204
  {
224
 
    if ((error= search_default_file(func, func_ctx, NULL, conf_file)) < 0)
 
205
    if ((error= search_default_file(func, func_ctx, NullS, conf_file)) < 0)
225
206
      goto err;
226
207
  }
227
208
  else
253
234
err:
254
235
  fprintf(stderr,"Fatal error in defaults handling. Program aborted\n");
255
236
  exit(1);
 
237
  return 0;                                     /* Keep compiler happy */
256
238
}
257
239
 
258
240
 
279
261
    1 - error occured
280
262
*/
281
263
 
282
 
int handle_default_option(void *in_ctx, const char *group_name,
283
 
                          const char *option)
 
264
static int handle_default_option(void *in_ctx, const char *group_name,
 
265
                                 const char *option)
284
266
{
285
267
  char *tmp;
286
268
  struct handle_option_ctx *ctx= (struct handle_option_ctx *) in_ctx;
288
270
  if (!option)
289
271
    return 0;
290
272
 
291
 
  if (ctx->group->find_type(const_cast<char*>(group_name), 3))
 
273
  if (find_type((char *)group_name, ctx->group, 3))
292
274
  {
293
 
    if (!(tmp= (char *)ctx->alloc->alloc_root(strlen(option) + 1)))
294
 
      return 1;
295
 
    if (insert_dynamic(ctx->args, (unsigned char*) &tmp))
296
 
      return 1;
297
 
    strcpy(tmp, option);
 
275
    if (!(tmp= alloc_root(ctx->alloc, strlen(option) + 1)))
 
276
      return 1;
 
277
    if (insert_dynamic(ctx->args, (uchar*) &tmp))
 
278
      return 1;
 
279
    stpcpy(tmp, option);
298
280
  }
299
281
 
300
282
  return 0;
325
307
  int org_argc= argc, prev_argc= 0;
326
308
  *defaults= *extra_defaults= *group_suffix= 0;
327
309
 
328
 
  const std::string DEFAULTS_FILE("--defaults-file=");
329
 
  const std::string DEFAULTS_EXTRA_FILE("--defaults-extra-file=");
330
 
  const std::string DEFAULTS_GROUP_SUFFIX("--defaults-group-suffix=");
331
 
 
332
310
  while (argc >= 2 && argc != prev_argc)
333
311
  {
334
312
    /* Skip program name or previously handled argument */
335
313
    argv++;
336
314
    prev_argc= argc;                            /* To check if we found */
337
 
    if (!*defaults && (strncmp(*argv,
338
 
                               DEFAULTS_FILE.c_str(),
339
 
                               DEFAULTS_FILE.size()) == 0))
 
315
    if (!*defaults && is_prefix(*argv,"--defaults-file="))
340
316
    {
341
 
      *defaults= *argv + DEFAULTS_FILE.size();
 
317
      *defaults= *argv + sizeof("--defaults-file=")-1;
342
318
       argc--;
343
319
       continue;
344
320
    }
345
 
    if (!*extra_defaults && (strncmp(*argv, 
346
 
                                     DEFAULTS_EXTRA_FILE.c_str(),
347
 
                                     DEFAULTS_EXTRA_FILE.size()) == 0))
 
321
    if (!*extra_defaults && is_prefix(*argv,"--defaults-extra-file="))
348
322
    {
349
 
      *extra_defaults= *argv + DEFAULTS_EXTRA_FILE.size();
 
323
      *extra_defaults= *argv + sizeof("--defaults-extra-file=")-1;
350
324
      argc--;
351
325
      continue;
352
326
    }
353
 
    if (!*group_suffix && (strncmp(*argv, 
354
 
                                   DEFAULTS_GROUP_SUFFIX.c_str(),
355
 
                                   DEFAULTS_GROUP_SUFFIX.size()) == 0))
356
 
 
 
327
    if (!*group_suffix && is_prefix(*argv, "--defaults-group-suffix="))
357
328
    {
358
 
      *group_suffix= *argv + DEFAULTS_GROUP_SUFFIX.size();
 
329
      *group_suffix= *argv + sizeof("--defaults-group-suffix=")-1;
359
330
      argc--;
360
331
      continue;
361
332
    }
385
356
   NOTES
386
357
    In case of fatal error, the function will print a warning and do
387
358
    exit(1)
388
 
 
 
359
 
389
360
    To free used memory one should call free_defaults() with the argument
390
361
    that was put in *argv
391
362
 
400
371
{
401
372
  DYNAMIC_ARRAY args;
402
373
  TYPELIB group;
403
 
  uint32_t args_used= 0;
 
374
  bool found_print_defaults= 0;
 
375
  uint args_used= 0;
404
376
  int error= 0;
405
 
  memory::Root alloc(512);
 
377
  MEM_ROOT alloc;
406
378
  char *ptr,**res;
407
379
  struct handle_option_ctx ctx;
408
380
 
409
381
  init_default_directories();
 
382
  init_alloc_root(&alloc,512,0);
410
383
  /*
411
384
    Check if the user doesn't want any default option processing
412
385
    --no-defaults is always the first option
414
387
  if (*argc >= 2 && !strcmp(argv[0][1],"--no-defaults"))
415
388
  {
416
389
    /* remove the --no-defaults argument and return only the other arguments */
417
 
    uint32_t i;
418
 
    if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (*argc + 1)*sizeof(char*))))
 
390
    uint i;
 
391
    if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
 
392
                                 (*argc + 1)*sizeof(char*))))
419
393
      goto err;
420
394
    res= (char**) (ptr+sizeof(alloc));
421
 
    memset(res,0,(*argc + 1));
422
395
    res[0]= **argv;                             /* Copy program name */
423
 
    for (i=2 ; i < (uint32_t) *argc ; i++)
 
396
    for (i=2 ; i < (uint) *argc ; i++)
424
397
      res[i-1]=argv[0][i];
425
398
    res[i-1]=0;                                 /* End pointer */
426
399
    (*argc)--;
427
400
    *argv=res;
428
 
    *(memory::Root*) ptr= alloc;                        /* Save alloc root for free */
 
401
    *(MEM_ROOT*) ptr= alloc;                    /* Save alloc root for free */
429
402
    return(0);
430
403
  }
431
404
 
449
422
    Here error contains <> 0 only if we have a fully specified conf_file
450
423
    or a forced default file
451
424
  */
452
 
  if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (args.elements + *argc +1) *sizeof(char*))))
 
425
  if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
 
426
                               (args.elements + *argc +1) *sizeof(char*))))
453
427
    goto err;
454
428
  res= (char**) (ptr+sizeof(alloc));
455
429
 
464
438
    Check if we wan't to see the new argument list
465
439
    This options must always be the last of the default options
466
440
  */
 
441
  if (*argc >= 2 && !strcmp(argv[0][1],"--print-defaults"))
 
442
  {
 
443
    found_print_defaults=1;
 
444
    --*argc; ++*argv;                           /* skip argument */
 
445
  }
 
446
 
467
447
  if (*argc)
468
448
    memcpy(res+1+args.elements, *argv + 1, (*argc-1)*sizeof(char*));
469
449
  res[args.elements+ *argc]=0;                  /* last null */
470
450
 
471
 
  (*argc)+=int(args.elements);
472
 
  *argv= static_cast<char**>(res);
473
 
  *(memory::Root*) ptr= alloc;                  /* Save alloc root for free */
 
451
  (*argc)+=args.elements;
 
452
  *argv= (char**) res;
 
453
  *(MEM_ROOT*) ptr= alloc;                      /* Save alloc root for free */
474
454
  delete_dynamic(&args);
475
 
 
 
455
  if (found_print_defaults)
 
456
  {
 
457
    int i;
 
458
    printf("%s would have been started with the following arguments:\n",
 
459
           **argv);
 
460
    for (i=1 ; i < *argc ; i++)
 
461
      printf("%s ", (*argv)[i]);
 
462
    puts("");
 
463
    exit(0);
 
464
  }
476
465
  return(error);
477
466
 
478
467
 err:
479
468
  fprintf(stderr,"Fatal error in defaults handling. Program aborted\n");
480
469
  exit(1);
 
470
  return 0;                                     /* Keep compiler happy */
481
471
}
482
472
 
483
473
 
484
474
void free_defaults(char **argv)
485
475
{
486
 
  memory::Root ptr;
 
476
  MEM_ROOT ptr;
487
477
  memcpy(&ptr, (char*) argv - sizeof(ptr), sizeof(ptr));
488
 
  ptr.free_root(MYF(0));
 
478
  free_root(&ptr,MYF(0));
489
479
}
490
480
 
491
481
 
527
517
*/
528
518
 
529
519
static char *get_argument(const char *keyword, size_t kwlen,
530
 
                          char *ptr, char *name, uint32_t line)
 
520
                          char *ptr, char *name, uint line)
531
521
{
532
522
  char *end;
533
523
 
534
524
  /* Skip over "include / includedir keyword" and following whitespace */
535
525
 
536
526
  for (ptr+= kwlen - 1;
537
 
       my_isspace(&my_charset_utf8_general_ci, ptr[0]);
 
527
       my_isspace(&my_charset_latin1, ptr[0]);
538
528
       ptr++)
539
529
  {}
540
530
 
544
534
    Note that my_isspace() is true for \r and \n
545
535
  */
546
536
  for (end= ptr + strlen(ptr) - 1;
547
 
       my_isspace(&my_charset_utf8_general_ci, *(end - 1));
 
537
       my_isspace(&my_charset_latin1, *(end - 1));
548
538
       end--)
549
539
  {}
550
540
  end[0]= 0;                                    /* Cut off end space */
568
558
    search_default_file_with_ext()
569
559
    opt_handler                 Option handler function. It is used to process
570
560
                                every separate option.
571
 
    handler_ctx                 Pointer to the structure to store actual
 
561
    handler_ctx                 Pointer to the structure to store actual 
572
562
                                parameters of the function.
573
563
    dir                         directory to read
574
564
    ext                         Extension for configuration file
596
586
  static const char include_keyword[]= "include";
597
587
  const int max_recursion_level= 10;
598
588
  FILE *fp;
599
 
  uint32_t line=0;
 
589
  uint line=0;
600
590
  bool found_group=0;
 
591
  uint i;
 
592
  MY_DIR *search_dir;
 
593
  FILEINFO *search_file;
601
594
 
602
595
  if ((dir ? strlen(dir) : 0 )+strlen(config_file) >= FN_REFLEN-3)
603
596
    return 0;                                   /* Ignore wrong paths */
604
597
  if (dir)
605
598
  {
606
 
    end=convert_dirname(name, dir, NULL);
 
599
    end=convert_dirname(name, dir, NullS);
607
600
    if (dir[0] == FN_HOMELIB)           /* Add . to filenames in home */
608
601
      *end++='.';
609
 
    sprintf(end,"%s%s",config_file,ext);
 
602
    strxmov(end,config_file,ext,NullS);
610
603
  }
611
604
  else
612
605
  {
613
 
    strcpy(name,config_file);
 
606
    stpcpy(name,config_file);
614
607
  }
615
608
  fn_format(name,name,"","",4);
616
609
  {
620
613
    /*
621
614
      Ignore world-writable regular files.
622
615
      This is mainly done to protect us to not read a file created by
623
 
      the mysqld server, but the check is still valid in most context.
 
616
      the mysqld server, but the check is still valid in most context. 
624
617
    */
625
618
    if ((stat_info.st_mode & S_IWOTH) &&
626
619
        (stat_info.st_mode & S_IFMT) == S_IFREG)
630
623
      return 0;
631
624
    }
632
625
  }
633
 
  if (!(fp= fopen(name, "r")))
 
626
  if (!(fp= my_fopen(name, O_RDONLY, MYF(0))))
634
627
    return 1;                                   /* Ignore wrong files */
635
628
 
636
 
  memset(buff,0,sizeof(buff));
637
629
  while (fgets(buff, sizeof(buff) - 1, fp))
638
630
  {
639
631
    line++;
640
632
    /* Ignore comment and empty lines */
641
 
    for (ptr= buff; my_isspace(&my_charset_utf8_general_ci, *ptr); ptr++)
 
633
    for (ptr= buff; my_isspace(&my_charset_latin1, *ptr); ptr++)
642
634
    {}
643
635
 
644
636
    if (*ptr == '#' || *ptr == ';' || !*ptr)
649
641
    {
650
642
      if (recursion_level >= max_recursion_level)
651
643
      {
652
 
        for (end= ptr + strlen(ptr) - 1;
653
 
             my_isspace(&my_charset_utf8_general_ci, *(end - 1));
 
644
        for (end= ptr + strlen(ptr) - 1; 
 
645
             my_isspace(&my_charset_latin1, *(end - 1));
654
646
             end--)
655
647
        {}
656
648
        end[0]= 0;
662
654
      }
663
655
 
664
656
      /* skip over `!' and following whitespace */
665
 
      for (++ptr; my_isspace(&my_charset_utf8_general_ci, ptr[0]); ptr++)
 
657
      for (++ptr; my_isspace(&my_charset_latin1, ptr[0]); ptr++)
666
658
      {}
667
659
 
668
660
      if ((!strncmp(ptr, includedir_keyword,
669
661
                    sizeof(includedir_keyword) - 1)) &&
670
 
          my_isspace(&my_charset_utf8_general_ci, ptr[sizeof(includedir_keyword) - 1]))
 
662
          my_isspace(&my_charset_latin1, ptr[sizeof(includedir_keyword) - 1]))
671
663
      {
672
664
        if (!(ptr= get_argument(includedir_keyword,
673
665
                                sizeof(includedir_keyword),
674
666
                                ptr, name, line)))
675
667
          goto err;
676
668
 
677
 
        CachedDirectory dir_cache(ptr);
678
 
 
679
 
        if (dir_cache.fail())
680
 
        {
681
 
          /**
682
 
           * @todo
683
 
           * Since clients still use this code, we use fprintf here.
684
 
           * This fprintf needs to be turned into errmsg_printf
685
 
           * as soon as the client programs no longer use mysys
686
 
           * and can use the pluggable error message system.
687
 
           */
688
 
          fprintf(stderr, _("error: could not open directory: %s\n"), ptr);
 
669
        if (!(search_dir= my_dir(ptr, MYF(MY_WME))))
689
670
          goto err;
690
 
        }
691
 
 
692
 
        CachedDirectory::Entries files= dir_cache.getEntries();
693
 
        CachedDirectory::Entries::iterator file_iter= files.begin();
694
 
 
695
 
        while (file_iter != files.end())
 
671
 
 
672
        for (i= 0; i < (uint) search_dir->number_off_files; i++)
696
673
        {
697
 
          CachedDirectory::Entry *entry= *file_iter;
698
 
          ext= fn_ext(entry->filename.c_str());
 
674
          search_file= search_dir->dir_entry + i;
 
675
          ext= fn_ext(search_file->name);
699
676
 
700
677
          /* check extension */
701
678
          for (tmp_ext= (char**) f_extensions; *tmp_ext; tmp_ext++)
702
679
          {
703
680
            if (!strcmp(ext, *tmp_ext))
704
 
            {
705
 
              fn_format(tmp, entry->filename.c_str(), ptr, "",
706
 
                        MY_UNPACK_FILENAME | MY_SAFE_PATH);
707
 
 
708
 
              search_default_file_with_ext(opt_handler, handler_ctx, "", "",
709
 
                                           tmp, recursion_level + 1);
710
 
            }
711
 
          }
712
 
 
713
 
          ++file_iter;
 
681
              break;
 
682
          }
 
683
 
 
684
          if (*tmp_ext)
 
685
          {
 
686
            fn_format(tmp, search_file->name, ptr, "",
 
687
                      MY_UNPACK_FILENAME | MY_SAFE_PATH);
 
688
 
 
689
            search_default_file_with_ext(opt_handler, handler_ctx, "", "", tmp,
 
690
                                         recursion_level + 1);
 
691
          }
714
692
        }
 
693
 
 
694
        my_dirend(search_dir);
715
695
      }
716
696
      else if ((!strncmp(ptr, include_keyword, sizeof(include_keyword) - 1)) &&
717
 
               my_isspace(&my_charset_utf8_general_ci, ptr[sizeof(include_keyword)-1]))
 
697
               my_isspace(&my_charset_latin1, ptr[sizeof(include_keyword)-1]))
718
698
      {
719
699
        if (!(ptr= get_argument(include_keyword,
720
700
                                sizeof(include_keyword), ptr,
739
719
        goto err;
740
720
      }
741
721
      /* Remove end space */
742
 
      for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) ; end--) ;
 
722
      for ( ; my_isspace(&my_charset_latin1,end[-1]) ; end--) ;
743
723
      end[0]=0;
744
724
 
745
 
      strncpy(curr_gr, ptr, min((size_t) (end-ptr)+1, sizeof(curr_gr)-1));
746
 
      curr_gr[min((size_t)(end-ptr)+1, sizeof(curr_gr)-1)] = '\0';
 
725
      strmake(curr_gr, ptr, min((size_t) (end-ptr)+1, sizeof(curr_gr)-1));
747
726
 
748
727
      /* signal that a new group is found */
749
728
      opt_handler(handler_ctx, curr_gr, NULL);
757
736
              name,line);
758
737
      goto err;
759
738
    }
760
 
 
761
 
 
 
739
    
 
740
   
762
741
    end= remove_end_comment(ptr);
763
742
    if ((value= strchr(ptr, '=')))
764
743
      end= value;                               /* Option without argument */
765
 
    for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) || end[-1]== '\n'; end--) ;
 
744
    for ( ; my_isspace(&my_charset_latin1,end[-1]) ; end--) ;
766
745
    if (!value)
767
746
    {
768
 
      strncpy(strcpy(option,"--")+2,ptr,strlen(ptr)+1);
 
747
      strmake(stpcpy(option,"--"),ptr, (size_t) (end-ptr));
769
748
      if (opt_handler(handler_ctx, curr_gr, option))
770
749
        goto err;
771
750
    }
773
752
    {
774
753
      /* Remove pre- and end space */
775
754
      char *value_end;
776
 
      for (value++ ; my_isspace(&my_charset_utf8_general_ci,*value); value++) ;
 
755
      for (value++ ; my_isspace(&my_charset_latin1,*value); value++) ;
777
756
      value_end= strchr(value, '\0');
778
757
      /*
779
 
       We don't have to test for value_end >= value as we know there is
780
 
       an '=' before
 
758
        We don't have to test for value_end >= value as we know there is
 
759
        an '=' before
781
760
      */
782
 
      for ( ; my_isspace(&my_charset_utf8_general_ci,value_end[-1]) ; value_end--) ;
 
761
      for ( ; my_isspace(&my_charset_latin1,value_end[-1]) ; value_end--) ;
783
762
      if (value_end < value)                    /* Empty string */
784
 
        value_end=value;
 
763
        value_end=value;
785
764
 
786
765
      /* remove quotes around argument */
787
766
      if ((*value == '\"' || *value == '\'') && /* First char is quote */
788
767
          (value + 1 < value_end ) && /* String is longer than 1 */
789
768
          *value == value_end[-1] ) /* First char is equal to last char */
790
769
      {
791
 
        value++;
792
 
        value_end--;
 
770
        value++;
 
771
        value_end--;
793
772
      }
794
 
      
795
 
      memset(option,0,2+(size_t)(end-ptr)+1);
796
 
      ptr= strncpy(strcpy(option,"--")+2,ptr,(size_t) (end-ptr));
797
 
      ptr[end-ptr]= '\0';
798
 
      ptr+= strlen(ptr);
 
773
      ptr=stpncpy(stpcpy(option,"--"),ptr,(size_t) (end-ptr));
799
774
      *ptr++= '=';
800
775
 
801
776
      for ( ; value != value_end; value++)
841
816
        goto err;
842
817
    }
843
818
  }
844
 
  fclose(fp);
 
819
  my_fclose(fp,MYF(0));
845
820
  return(0);
846
821
 
847
822
 err:
848
 
  fclose(fp);
849
 
 
 
823
  my_fclose(fp,MYF(0));
850
824
  return -1;                                    /* Fatal error */
851
825
}
852
826
 
903
877
          pos= my_defaults_extra_file;
904
878
        else
905
879
          continue;
906
 
        end= convert_dirname(name, pos, NULL);
 
880
        end= convert_dirname(name, pos, NullS);
907
881
        if (name[0] == FN_HOMELIB)      /* Add . to filenames in home */
908
882
          *end++='.';
909
 
  sprintf(end,"%s%s ",conf_file, *ext);
 
883
        strxmov(end, conf_file, *ext, " ", NullS);
910
884
        fputs(name,stdout);
911
885
      }
912
886
    }
937
911
    }
938
912
  }
939
913
  puts("\nThe following options may be given as the first argument:\n\
940
 
  --no-defaults         Don't read default options from any options file\n\
941
 
  --defaults-file=#     Only read default options from the given file #\n\
942
 
  --defaults-extra-file=# Read this file after the global files are read");
 
914
--print-defaults        Print the program argument list and exit\n\
 
915
--no-defaults           Don't read default options from any options file\n\
 
916
--defaults-file=#       Only read default options from the given file #\n\
 
917
--defaults-extra-file=# Read this file after the global files are read");
943
918
}
944
919
 
945
920
/*
946
921
  This extra complexity is to avoid declaring 'rc' if it won't be
947
922
  used.
948
923
*/
949
 
static void add_directory(const char* dir)
950
 
{
951
 
  array_append_string_unique(dir, default_directories, array_elements(default_directories));
952
 
}
953
 
 
954
 
static void add_common_directories()
955
 
{
956
 
  const char *env= getenv("DRIZZLE_HOME"); 
957
 
  if (env) 
958
 
    add_directory(env); 
959
 
  // Placeholder for --defaults-extra-file=<path>
960
 
  add_directory(""); 
961
 
}
 
924
#define ADD_DIRECTORY(DIR)  (void) array_append_string_unique((DIR), default_directories, \
 
925
                             array_elements(default_directories))
 
926
 
 
927
#define ADD_COMMON_DIRECTORIES() \
 
928
  do { \
 
929
    char *env; \
 
930
    if ((env= getenv(STRINGIFY_ARG(DEFAULT_HOME_ENV)))) \
 
931
      ADD_DIRECTORY(env); \
 
932
    /* Placeholder for --defaults-extra-file=<path> */ \
 
933
    ADD_DIRECTORY(""); \
 
934
  } while (0)
 
935
 
962
936
 
963
937
/**
964
938
  Initialize default directories for Unix
965
939
 
966
940
  @details
967
941
    1. /etc/
968
 
    2. /etc/drizzle/
 
942
    2. /etc/mysql/
969
943
    3. --sysconfdir=<path> (compile-time option)
970
 
    4. getenv("DRIZZLE_HOME")
 
944
    4. getenv(DEFAULT_HOME_ENV)
971
945
    5. --defaults-extra-file=<path> (run-time option)
972
946
    6. "~/"
973
947
*/
975
949
static void init_default_directories(void)
976
950
{
977
951
  memset(default_directories, 0, sizeof(default_directories));
978
 
  add_directory("/etc/");
979
 
  add_directory("/etc/drizzle/");
980
 
  add_directory(SYSCONFDIR);
981
 
  add_common_directories();
982
 
  add_directory("~/");
 
952
  ADD_DIRECTORY("/etc/");
 
953
  ADD_DIRECTORY("/etc/mysql/");
 
954
#if defined(DEFAULT_SYSCONFDIR)
 
955
    ADD_DIRECTORY(DEFAULT_SYSCONFDIR);
 
956
#endif
 
957
  ADD_COMMON_DIRECTORIES();
 
958
  ADD_DIRECTORY("~/");
983
959
}
984
 
 
985
 
} /* namespace internal */
986
 
} /* namespace drizzled */