← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/default.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/default.cc
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  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 "mysys_priv.h"
37
 
#include <mystrings/m_string.h>
38
 
#include <mystrings/m_ctype.h>
39
 
#include <mysys/my_dir.h>
40
 
 
41
 
#include <stdio.h>
 
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
{
42
60
 
43
61
const char *my_defaults_file=0;
44
62
const char *my_defaults_group_suffix=0;
63
81
 
64
82
struct handle_option_ctx
65
83
{
66
 
   MEM_ROOT *alloc;
 
84
   memory::Root *alloc;
67
85
   DYNAMIC_ARRAY *args;
68
86
   TYPELIB *group;
69
87
};
140
158
                                    (char **) &my_defaults_group_suffix);
141
159
 
142
160
  if (! my_defaults_group_suffix)
143
 
    my_defaults_group_suffix= getenv(STRINGIFY_ARG(DEFAULT_GROUP_SUFFIX_ENV));
 
161
    my_defaults_group_suffix= getenv("DRIZZLE_GROUP_SUFFIX");
144
162
 
145
163
  if (forced_extra_defaults)
146
164
    my_defaults_extra_file= (char *) forced_extra_defaults;
147
 
  
 
165
 
148
166
  if (forced_default_file)
149
167
    my_defaults_file= forced_default_file;
150
168
 
158
176
    /* Handle --defaults-group-suffix= */
159
177
    uint32_t i;
160
178
    const char **extra_groups;
161
 
    const uint32_t instance_len= strlen(my_defaults_group_suffix); 
 
179
    const size_t instance_len= strlen(my_defaults_group_suffix);
162
180
    struct handle_option_ctx *ctx= (struct handle_option_ctx*) func_ctx;
163
181
    char *ptr;
164
182
    TYPELIB *group= ctx->group;
165
 
    
166
 
    if (!(extra_groups= 
167
 
          (const char**)alloc_root(ctx->alloc,
 
183
 
 
184
    if (!(extra_groups=
 
185
          (const char**)ctx->alloc->alloc_root(
168
186
                                   (2*group->count+1)*sizeof(char*))))
169
187
      goto err;
170
 
    
 
188
 
171
189
    for (i= 0; i < group->count; i++)
172
190
    {
173
 
      uint32_t len;
 
191
      size_t len;
174
192
      extra_groups[i]= group->type_names[i]; /** copy group */
175
 
      
 
193
 
176
194
      len= strlen(extra_groups[i]);
177
 
      if (!(ptr= (char *)alloc_root(ctx->alloc, len+instance_len+1)))
 
195
      if (!(ptr= (char *)ctx->alloc->alloc_root( len+instance_len+1)))
178
196
        goto err;
179
 
      
 
197
 
180
198
      extra_groups[i+group->count]= ptr;
181
 
      
 
199
 
182
200
      /** Construct new group */
183
201
      memcpy(ptr, extra_groups[i], len);
184
202
      memcpy(ptr+len, my_defaults_group_suffix, instance_len+1);
185
203
    }
186
 
    
 
204
 
187
205
    group->count*= 2;
188
206
    group->type_names= extra_groups;
189
207
    group->type_names[group->count]= 0;
190
208
  }
191
 
  
 
209
 
192
210
  if (forced_default_file)
193
211
  {
194
212
    if ((error= search_default_file_with_ext(func, func_ctx, "", "",
270
288
  if (!option)
271
289
    return 0;
272
290
 
273
 
  if (find_type((char *)group_name, ctx->group, 3))
 
291
  if (ctx->group->find_type(const_cast<char*>(group_name), 3))
274
292
  {
275
 
    if (!(tmp= (char *)alloc_root(ctx->alloc, strlen(option) + 1)))
 
293
    if (!(tmp= (char *)ctx->alloc->alloc_root(strlen(option) + 1)))
276
294
      return 1;
277
295
    if (insert_dynamic(ctx->args, (unsigned char*) &tmp))
278
296
      return 1;
307
325
  int org_argc= argc, prev_argc= 0;
308
326
  *defaults= *extra_defaults= *group_suffix= 0;
309
327
 
 
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
 
310
332
  while (argc >= 2 && argc != prev_argc)
311
333
  {
312
334
    /* Skip program name or previously handled argument */
313
335
    argv++;
314
336
    prev_argc= argc;                            /* To check if we found */
315
 
    if (!*defaults && is_prefix(*argv,"--defaults-file="))
 
337
    if (!*defaults && (strncmp(*argv,
 
338
                               DEFAULTS_FILE.c_str(),
 
339
                               DEFAULTS_FILE.size()) == 0))
316
340
    {
317
 
      *defaults= *argv + sizeof("--defaults-file=")-1;
 
341
      *defaults= *argv + DEFAULTS_FILE.size();
318
342
       argc--;
319
343
       continue;
320
344
    }
321
 
    if (!*extra_defaults && is_prefix(*argv,"--defaults-extra-file="))
 
345
    if (!*extra_defaults && (strncmp(*argv, 
 
346
                                     DEFAULTS_EXTRA_FILE.c_str(),
 
347
                                     DEFAULTS_EXTRA_FILE.size()) == 0))
322
348
    {
323
 
      *extra_defaults= *argv + sizeof("--defaults-extra-file=")-1;
 
349
      *extra_defaults= *argv + DEFAULTS_EXTRA_FILE.size();
324
350
      argc--;
325
351
      continue;
326
352
    }
327
 
    if (!*group_suffix && is_prefix(*argv, "--defaults-group-suffix="))
 
353
    if (!*group_suffix && (strncmp(*argv, 
 
354
                                   DEFAULTS_GROUP_SUFFIX.c_str(),
 
355
                                   DEFAULTS_GROUP_SUFFIX.size()) == 0))
 
356
 
328
357
    {
329
 
      *group_suffix= *argv + sizeof("--defaults-group-suffix=")-1;
 
358
      *group_suffix= *argv + DEFAULTS_GROUP_SUFFIX.size();
330
359
      argc--;
331
360
      continue;
332
361
    }
356
385
   NOTES
357
386
    In case of fatal error, the function will print a warning and do
358
387
    exit(1)
359
 
 
 
388
 
360
389
    To free used memory one should call free_defaults() with the argument
361
390
    that was put in *argv
362
391
 
371
400
{
372
401
  DYNAMIC_ARRAY args;
373
402
  TYPELIB group;
374
 
  bool found_print_defaults= 0;
375
403
  uint32_t args_used= 0;
376
404
  int error= 0;
377
 
  MEM_ROOT alloc;
 
405
  memory::Root alloc(512);
378
406
  char *ptr,**res;
379
407
  struct handle_option_ctx ctx;
380
408
 
381
409
  init_default_directories();
382
 
  init_alloc_root(&alloc,512,0);
383
410
  /*
384
411
    Check if the user doesn't want any default option processing
385
412
    --no-defaults is always the first option
388
415
  {
389
416
    /* remove the --no-defaults argument and return only the other arguments */
390
417
    uint32_t i;
391
 
    if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
392
 
                                 (*argc + 1)*sizeof(char*))))
 
418
    if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (*argc + 1)*sizeof(char*))))
393
419
      goto err;
394
420
    res= (char**) (ptr+sizeof(alloc));
 
421
    memset(res,0,(*argc + 1));
395
422
    res[0]= **argv;                             /* Copy program name */
396
 
    for (i=2 ; i < (uint) *argc ; i++)
 
423
    for (i=2 ; i < (uint32_t) *argc ; i++)
397
424
      res[i-1]=argv[0][i];
398
425
    res[i-1]=0;                                 /* End pointer */
399
426
    (*argc)--;
400
427
    *argv=res;
401
 
    *(MEM_ROOT*) ptr= alloc;                    /* Save alloc root for free */
 
428
    *(memory::Root*) ptr= alloc;                        /* Save alloc root for free */
402
429
    return(0);
403
430
  }
404
431
 
422
449
    Here error contains <> 0 only if we have a fully specified conf_file
423
450
    or a forced default file
424
451
  */
425
 
  if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
426
 
                               (args.elements + *argc +1) *sizeof(char*))))
 
452
  if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (args.elements + *argc +1) *sizeof(char*))))
427
453
    goto err;
428
454
  res= (char**) (ptr+sizeof(alloc));
429
455
 
438
464
    Check if we wan't to see the new argument list
439
465
    This options must always be the last of the default options
440
466
  */
441
 
  if (*argc >= 2 && !strcmp(argv[0][1],"--print-defaults"))
442
 
  {
443
 
    found_print_defaults=1;
444
 
    --*argc; ++*argv;                           /* skip argument */
445
 
  }
446
 
 
447
467
  if (*argc)
448
468
    memcpy(res+1+args.elements, *argv + 1, (*argc-1)*sizeof(char*));
449
469
  res[args.elements+ *argc]=0;                  /* last null */
450
470
 
451
 
  (*argc)+=args.elements;
452
 
  *argv= (char**) res;
453
 
  *(MEM_ROOT*) ptr= alloc;                      /* Save alloc root for free */
 
471
  (*argc)+=int(args.elements);
 
472
  *argv= static_cast<char**>(res);
 
473
  *(memory::Root*) ptr= alloc;                  /* Save alloc root for free */
454
474
  delete_dynamic(&args);
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
 
  }
 
475
 
465
476
  return(error);
466
477
 
467
478
 err:
472
483
 
473
484
void free_defaults(char **argv)
474
485
{
475
 
  MEM_ROOT ptr;
 
486
  memory::Root ptr;
476
487
  memcpy(&ptr, (char*) argv - sizeof(ptr), sizeof(ptr));
477
 
  free_root(&ptr,MYF(0));
 
488
  ptr.free_root(MYF(0));
478
489
}
479
490
 
480
491
 
557
568
    search_default_file_with_ext()
558
569
    opt_handler                 Option handler function. It is used to process
559
570
                                every separate option.
560
 
    handler_ctx                 Pointer to the structure to store actual 
 
571
    handler_ctx                 Pointer to the structure to store actual
561
572
                                parameters of the function.
562
573
    dir                         directory to read
563
574
    ext                         Extension for configuration file
587
598
  FILE *fp;
588
599
  uint32_t line=0;
589
600
  bool found_group=0;
590
 
  uint32_t i;
591
 
  MY_DIR *search_dir;
592
 
  FILEINFO *search_file;
593
601
 
594
602
  if ((dir ? strlen(dir) : 0 )+strlen(config_file) >= FN_REFLEN-3)
595
603
    return 0;                                   /* Ignore wrong paths */
598
606
    end=convert_dirname(name, dir, NULL);
599
607
    if (dir[0] == FN_HOMELIB)           /* Add . to filenames in home */
600
608
      *end++='.';
601
 
    strxmov(end,config_file,ext,NULL);
 
609
    sprintf(end,"%s%s",config_file,ext);
602
610
  }
603
611
  else
604
612
  {
612
620
    /*
613
621
      Ignore world-writable regular files.
614
622
      This is mainly done to protect us to not read a file created by
615
 
      the mysqld server, but the check is still valid in most context. 
 
623
      the mysqld server, but the check is still valid in most context.
616
624
    */
617
625
    if ((stat_info.st_mode & S_IWOTH) &&
618
626
        (stat_info.st_mode & S_IFMT) == S_IFREG)
622
630
      return 0;
623
631
    }
624
632
  }
625
 
  if (!(fp= my_fopen(name, O_RDONLY, MYF(0))))
 
633
  if (!(fp= fopen(name, "r")))
626
634
    return 1;                                   /* Ignore wrong files */
627
635
 
 
636
  memset(buff,0,sizeof(buff));
628
637
  while (fgets(buff, sizeof(buff) - 1, fp))
629
638
  {
630
639
    line++;
640
649
    {
641
650
      if (recursion_level >= max_recursion_level)
642
651
      {
643
 
        for (end= ptr + strlen(ptr) - 1; 
 
652
        for (end= ptr + strlen(ptr) - 1;
644
653
             my_isspace(&my_charset_utf8_general_ci, *(end - 1));
645
654
             end--)
646
655
        {}
665
674
                                ptr, name, line)))
666
675
          goto err;
667
676
 
668
 
        if (!(search_dir= my_dir(ptr, MYF(MY_WME))))
 
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
689
          goto err;
670
 
 
671
 
        for (i= 0; i < (uint) search_dir->number_off_files; i++)
 
690
        }
 
691
 
 
692
        CachedDirectory::Entries files= dir_cache.getEntries();
 
693
        CachedDirectory::Entries::iterator file_iter= files.begin();
 
694
 
 
695
        while (file_iter != files.end())
672
696
        {
673
 
          search_file= search_dir->dir_entry + i;
674
 
          ext= fn_ext(search_file->name);
 
697
          CachedDirectory::Entry *entry= *file_iter;
 
698
          ext= fn_ext(entry->filename.c_str());
675
699
 
676
700
          /* check extension */
677
701
          for (tmp_ext= (char**) f_extensions; *tmp_ext; tmp_ext++)
678
702
          {
679
703
            if (!strcmp(ext, *tmp_ext))
680
 
              break;
681
 
          }
682
 
 
683
 
          if (*tmp_ext)
684
 
          {
685
 
            fn_format(tmp, search_file->name, ptr, "",
686
 
                      MY_UNPACK_FILENAME | MY_SAFE_PATH);
687
 
 
688
 
            search_default_file_with_ext(opt_handler, handler_ctx, "", "", tmp,
689
 
                                         recursion_level + 1);
690
 
          }
 
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;
691
714
        }
692
 
 
693
 
        my_dirend(search_dir);
694
715
      }
695
716
      else if ((!strncmp(ptr, include_keyword, sizeof(include_keyword) - 1)) &&
696
717
               my_isspace(&my_charset_utf8_general_ci, ptr[sizeof(include_keyword)-1]))
721
742
      for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) ; end--) ;
722
743
      end[0]=0;
723
744
 
724
 
      strncpy(curr_gr, ptr, cmin((size_t) (end-ptr)+1, sizeof(curr_gr)-1));
725
 
      curr_gr[cmin((size_t)(end-ptr)+1, sizeof(curr_gr)-1)] = '\0';
 
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';
726
747
 
727
748
      /* signal that a new group is found */
728
749
      opt_handler(handler_ctx, curr_gr, NULL);
736
757
              name,line);
737
758
      goto err;
738
759
    }
739
 
    
740
 
   
 
760
 
 
761
 
741
762
    end= remove_end_comment(ptr);
742
763
    if ((value= strchr(ptr, '=')))
743
764
      end= value;                               /* Option without argument */
744
 
    for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) ; end--) ;
 
765
    for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) || end[-1]== '\n'; end--) ;
745
766
    if (!value)
746
767
    {
747
768
      strncpy(strcpy(option,"--")+2,ptr,strlen(ptr)+1);
755
776
      for (value++ ; my_isspace(&my_charset_utf8_general_ci,*value); value++) ;
756
777
      value_end= strchr(value, '\0');
757
778
      /*
758
 
        We don't have to test for value_end >= value as we know there is
759
 
        an '=' before
 
779
       We don't have to test for value_end >= value as we know there is
 
780
       an '=' before
760
781
      */
761
782
      for ( ; my_isspace(&my_charset_utf8_general_ci,value_end[-1]) ; value_end--) ;
762
783
      if (value_end < value)                    /* Empty string */
763
 
        value_end=value;
 
784
        value_end=value;
764
785
 
765
786
      /* remove quotes around argument */
766
787
      if ((*value == '\"' || *value == '\'') && /* First char is quote */
770
791
        value++;
771
792
        value_end--;
772
793
      }
773
 
      ptr= my_stpncpy(strcpy(option,"--")+2,ptr,(size_t) (end-ptr));
 
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);
774
799
      *ptr++= '=';
775
800
 
776
801
      for ( ; value != value_end; value++)
816
841
        goto err;
817
842
    }
818
843
  }
819
 
  my_fclose(fp,MYF(0));
 
844
  fclose(fp);
820
845
  return(0);
821
846
 
822
847
 err:
823
 
  my_fclose(fp,MYF(0));
 
848
  fclose(fp);
 
849
 
824
850
  return -1;                                    /* Fatal error */
825
851
}
826
852
 
880
906
        end= convert_dirname(name, pos, NULL);
881
907
        if (name[0] == FN_HOMELIB)      /* Add . to filenames in home */
882
908
          *end++='.';
883
 
        strxmov(end, conf_file, *ext, " ", NULL);
 
909
  sprintf(end,"%s%s ",conf_file, *ext);
884
910
        fputs(name,stdout);
885
911
      }
886
912
    }
911
937
    }
912
938
  }
913
939
  puts("\nThe following options may be given as the first argument:\n\
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");
 
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");
918
943
}
919
944
 
920
945
/*
921
946
  This extra complexity is to avoid declaring 'rc' if it won't be
922
947
  used.
923
948
*/
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
 
 
 
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
}
936
962
 
937
963
/**
938
964
  Initialize default directories for Unix
941
967
    1. /etc/
942
968
    2. /etc/drizzle/
943
969
    3. --sysconfdir=<path> (compile-time option)
944
 
    4. getenv(DEFAULT_HOME_ENV)
 
970
    4. getenv("DRIZZLE_HOME")
945
971
    5. --defaults-extra-file=<path> (run-time option)
946
972
    6. "~/"
947
973
*/
949
975
static void init_default_directories(void)
950
976
{
951
977
  memset(default_directories, 0, sizeof(default_directories));
952
 
  ADD_DIRECTORY("/etc/");
953
 
  ADD_DIRECTORY("/etc/drizzle/");
954
 
#if defined(DEFAULT_SYSCONFDIR)
955
 
    ADD_DIRECTORY(DEFAULT_SYSCONFDIR);
956
 
#endif
957
 
  ADD_COMMON_DIRECTORIES();
958
 
  ADD_DIRECTORY("~/");
 
978
  add_directory("/etc/");
 
979
  add_directory("/etc/drizzle/");
 
980
  add_directory(SYSCONFDIR);
 
981
  add_common_directories();
 
982
  add_directory("~/");
959
983
}
 
984
 
 
985
} /* namespace internal */
 
986
} /* namespace drizzled */