← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/default.c

  • Committer: Monty Taylor
  • Date: 2008-08-02 18:45:35 UTC
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080802184535-p4ze46mgiock6tzi
Backed up charsets automake change.

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