static int search_default_file(Process_option_func opt_handler, void *handler_ctx, const char *dir, const char *config_file) { char **ext; const char *empty_list[]= { "", 0 }; my_bool have_ext= fn_ext(config_file)[0] != 0; const char **exts_to_use= have_ext ? empty_list : f_extensions; my_bool found= FALSE; for (ext= (char**) exts_to_use; *ext; ext++) { int error; if ((error= search_default_file_with_ext(opt_handler, handler_ctx, dir, *ext, config_file, 0)) < 0) return error; if (error == 0) { found= TRUE; } } if (!found) return 1; return 0; }
static int search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc, const char *dir, const char *config_file, TYPELIB *group) { char **ext; for (ext= (char**) f_extensions; *ext; *ext++) { int error; if ((error= search_default_file_with_ext(args, alloc, dir, *ext, config_file, group, 0)) < 0) return error; } return 0; }
static int search_default_file_with_ext(Process_option_func opt_handler, void *handler_ctx, const char *dir, const char *ext, const char *config_file, int recursion_level) { char name[FN_REFLEN + 10], buff[4096], curr_gr[4096], *ptr, *end, **tmp_ext; char *value, option[4096+2], tmp[FN_REFLEN]; static const char includedir_keyword[]= "includedir"; static const char include_keyword[]= "include"; const int max_recursion_level= 10; MYSQL_FILE *fp; uint line=0; my_bool found_group=0; uint i; MY_DIR *search_dir; FILEINFO *search_file; if ((dir ? strlen(dir) : 0 )+strlen(config_file) >= FN_REFLEN-3) return 0; /* Ignore wrong paths */ if (dir) { end=convert_dirname(name, dir, NullS); if (dir[0] == FN_HOMELIB) /* Add . to filenames in home */ *end++='.'; strxmov(end,config_file,ext,NullS); } else { strmov(name,config_file); } fn_format(name,name,"","",4); #if !defined(__WIN__) { MY_STAT stat_info; if (!my_stat(name,&stat_info,MYF(0))) return 1; /* Ignore world-writable regular files. This is mainly done to protect us to not read a file created by the mysqld server, but the check is still valid in most context. */ if ((stat_info.st_mode & S_IWOTH) && (stat_info.st_mode & S_IFMT) == S_IFREG) { fprintf(stderr, "Warning: World-writable config file '%s' is ignored\n", name); return 0; } } #endif if (!(fp= mysql_file_fopen(key_file_cnf, name, O_RDONLY, MYF(0)))) return 1; /* Ignore wrong files */ while (mysql_file_fgets(buff, sizeof(buff) - 1, fp)) { line++; /* Ignore comment and empty lines */ for (ptr= buff; my_isspace(&my_charset_latin1, *ptr); ptr++) {} if (*ptr == '#' || *ptr == ';' || !*ptr) continue; /* Configuration File Directives */ if (*ptr == '!') { if (recursion_level >= max_recursion_level) { for (end= ptr + strlen(ptr) - 1; my_isspace(&my_charset_latin1, *(end - 1)); end--) {} end[0]= 0; fprintf(stderr, "Warning: skipping '%s' directive as maximum include" "recursion level was reached in file %s at line %d\n", ptr, name, line); continue; } /* skip over `!' and following whitespace */ for (++ptr; my_isspace(&my_charset_latin1, ptr[0]); ptr++) {} if ((!strncmp(ptr, includedir_keyword, sizeof(includedir_keyword) - 1)) && my_isspace(&my_charset_latin1, ptr[sizeof(includedir_keyword) - 1])) { if (!(ptr= get_argument(includedir_keyword, sizeof(includedir_keyword), ptr, name, line))) goto err; if (!(search_dir= my_dir(ptr, MYF(MY_WME)))) goto err; for (i= 0; i < (uint) search_dir->number_of_files; i++) { search_file= search_dir->dir_entry + i; ext= fn_ext(search_file->name); /* check extension */ for (tmp_ext= (char**) f_extensions; *tmp_ext; tmp_ext++) { if (!strcmp(ext, *tmp_ext)) break; } if (*tmp_ext) { fn_format(tmp, search_file->name, ptr, "", MY_UNPACK_FILENAME | MY_SAFE_PATH); search_default_file_with_ext(opt_handler, handler_ctx, "", "", tmp, recursion_level + 1); } } my_dirend(search_dir); } else if ((!strncmp(ptr, include_keyword, sizeof(include_keyword) - 1)) && my_isspace(&my_charset_latin1, ptr[sizeof(include_keyword)-1])) { if (!(ptr= get_argument(include_keyword, sizeof(include_keyword), ptr, name, line))) goto err; search_default_file_with_ext(opt_handler, handler_ctx, "", "", ptr, recursion_level + 1); } continue; } if (*ptr == '[') /* Group name */ { found_group=1; if (!(end=(char *) strchr(++ptr,']'))) { fprintf(stderr, "error: Wrong group definition in config file: %s at line %d\n", name,line); goto err; } /* Remove end space */ for ( ; my_isspace(&my_charset_latin1,end[-1]) ; end--) ; end[0]=0; strmake(curr_gr, ptr, MY_MIN((size_t) (end-ptr)+1, sizeof(curr_gr)-1)); /* signal that a new group is found */ opt_handler(handler_ctx, curr_gr, NULL); continue; } if (!found_group) { fprintf(stderr, "error: Found option without preceding group in config file: %s at line: %d\n", name,line); goto err; } end= remove_end_comment(ptr); if ((value= strchr(ptr, '='))) end= value; /* Option without argument */ for ( ; my_isspace(&my_charset_latin1,end[-1]) ; end--) ; if (!value) { strmake(strmov(option,"--"),ptr, (size_t) (end-ptr)); if (opt_handler(handler_ctx, curr_gr, option)) goto err; } else { /* Remove pre- and end space */ char *value_end; for (value++ ; my_isspace(&my_charset_latin1,*value); value++) ; value_end=strend(value); /* We don't have to test for value_end >= value as we know there is an '=' before */ for ( ; my_isspace(&my_charset_latin1,value_end[-1]) ; value_end--) ; if (value_end < value) /* Empty string */ value_end=value; /* remove quotes around argument */ if ((*value == '\"' || *value == '\'') && /* First char is quote */ (value + 1 < value_end ) && /* String is longer than 1 */ *value == value_end[-1] ) /* First char is equal to last char */ { value++; value_end--; } ptr=strnmov(strmov(option,"--"),ptr,(size_t) (end-ptr)); *ptr++= '='; for ( ; value != value_end; value++) { if (*value == '\\' && value != value_end-1) { switch(*++value) { case 'n': *ptr++='\n'; break; case 't': *ptr++= '\t'; break; case 'r': *ptr++ = '\r'; break; case 'b': *ptr++ = '\b'; break; case 's': *ptr++= ' '; /* space */ break; case '\"': *ptr++= '\"'; break; case '\'': *ptr++= '\''; break; case '\\': *ptr++= '\\'; break; default: /* Unknown; Keep '\' */ *ptr++= '\\'; *ptr++= *value; break; } } else *ptr++= *value; } *ptr=0; if (opt_handler(handler_ctx, curr_gr, option)) goto err; } } mysql_file_fclose(fp, MYF(0)); return(0); err: mysql_file_fclose(fp, MYF(0)); return -1; /* Fatal error */ }
int my_search_option_files(const char *conf_file, int *argc, char ***argv, uint *args_used, Process_option_func func, void *func_ctx, const char **default_directories) { const char **dirs, *forced_default_file, *forced_extra_defaults; int error= 0; DBUG_ENTER("my_search_option_files"); /* Check if we want to force the use a specific default file */ *args_used+= get_defaults_options(*argc - *args_used, *argv + *args_used, (char **) &forced_default_file, (char **) &forced_extra_defaults, (char **) &my_defaults_group_suffix); if (! my_defaults_group_suffix) my_defaults_group_suffix= getenv(STRINGIFY_ARG(DEFAULT_GROUP_SUFFIX_ENV)); if (forced_extra_defaults && !defaults_already_read) { int error= fn_expand(forced_extra_defaults, my_defaults_extra_file_buffer); if (error) DBUG_RETURN(error); my_defaults_extra_file= my_defaults_extra_file_buffer; } if (forced_default_file && !defaults_already_read) { int error= fn_expand(forced_default_file, my_defaults_file_buffer); if (error) DBUG_RETURN(error); my_defaults_file= my_defaults_file_buffer; } defaults_already_read= TRUE; /* We can only handle 'defaults-group-suffix' if we are called from load_defaults() as otherwise we can't know the type of 'func_ctx' */ if (my_defaults_group_suffix && func == handle_default_option) { /* Handle --defaults-group-suffix= */ uint i; const char **extra_groups; const size_t instance_len= strlen(my_defaults_group_suffix); struct handle_option_ctx *ctx= (struct handle_option_ctx*) func_ctx; char *ptr; TYPELIB *group= ctx->group; if (!(extra_groups= (const char**)alloc_root(ctx->alloc, (2*group->count+1)*sizeof(char*)))) DBUG_RETURN(2); for (i= 0; i < group->count; i++) { size_t len; extra_groups[i]= group->type_names[i]; /** copy group */ len= strlen(extra_groups[i]); if (!(ptr= alloc_root(ctx->alloc, (uint) (len+instance_len+1)))) DBUG_RETURN(2); extra_groups[i+group->count]= ptr; /** Construct new group */ memcpy(ptr, extra_groups[i], len); memcpy(ptr+len, my_defaults_group_suffix, instance_len+1); } group->count*= 2; group->type_names= extra_groups; group->type_names[group->count]= 0; } if (my_defaults_file) { if ((error= search_default_file_with_ext(func, func_ctx, "", "", my_defaults_file, 0)) < 0) goto err; if (error > 0) { fprintf(stderr, "Could not open required defaults file: %s\n", my_defaults_file); goto err; } } else if (dirname_length(conf_file)) { if ((error= search_default_file(func, func_ctx, NullS, conf_file)) < 0) goto err; } else { my_bool found_conf= FALSE; for (dirs= default_directories ; *dirs; dirs++) { if (**dirs) { int file_err= search_default_file(func, func_ctx, *dirs, conf_file); if (file_err < 0) goto err; else if (file_err == 0) found_conf= TRUE; } else if (my_defaults_extra_file) { if ((error= search_default_file_with_ext(func, func_ctx, "", "", my_defaults_extra_file, 0)) < 0) goto err; /* Fatal error */ if (error > 0) { fprintf(stderr, "Could not open required defaults file: %s\n", my_defaults_extra_file); goto err; } found_conf= TRUE; } } if (!found_conf) { goto err; } } DBUG_RETURN(0); err: DBUG_RETURN(1); }
int load_defaults(const char *conf_file, const char **groups, int *argc, char ***argv) { DYNAMIC_ARRAY args; const char **dirs, *forced_default_file, *forced_extra_defaults; TYPELIB group; my_bool found_print_defaults=0; uint args_used=0; int error= 0; MEM_ROOT alloc; char *ptr, **res; DBUG_ENTER("load_defaults"); init_alloc_root(&alloc,512,0); if (*argc >= 2 && !strcmp(argv[0][1],"--no-defaults")) { /* remove the --no-defaults argument and return only the other arguments */ uint i; if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+ (*argc + 1)*sizeof(char*)))) goto err; res= (char**) (ptr+sizeof(alloc)); res[0]= **argv; /* Copy program name */ for (i=2 ; i < (uint) *argc ; i++) res[i-1]=argv[0][i]; res[i-1]=0; /* End pointer */ (*argc)--; *argv=res; *(MEM_ROOT*) ptr= alloc; /* Save alloc root for free */ DBUG_RETURN(0); } get_defaults_files(*argc, *argv, (char **)&forced_default_file, (char **)&forced_extra_defaults); if (forced_default_file) forced_default_file= strchr(forced_default_file,'=')+1; if (forced_extra_defaults) defaults_extra_file= strchr(forced_extra_defaults,'=')+1; args_used+= (forced_default_file ? 1 : 0) + (forced_extra_defaults ? 1 : 0); group.count=0; group.name= "defaults"; group.type_names= groups; for (; *groups ; groups++) group.count++; if (my_init_dynamic_array(&args, sizeof(char*),*argc, 32)) goto err; if (forced_default_file) { if ((error= search_default_file_with_ext(&args, &alloc, "", "", forced_default_file, &group, 0)) < 0) goto err; if (error > 0) { fprintf(stderr, "Could not open required defaults file: %s\n", forced_default_file); goto err; } } else if (dirname_length(conf_file)) { if ((error= search_default_file(&args, &alloc, NullS, conf_file, &group)) < 0) goto err; } else { #ifdef __WIN__ char system_dir[FN_REFLEN]; GetWindowsDirectory(system_dir,sizeof(system_dir)); if ((search_default_file(&args, &alloc, system_dir, conf_file, &group))) goto err; #endif #if defined(__EMX__) || defined(OS2) { const char *etc; if ((etc= getenv("ETC")) && (search_default_file(&args, &alloc, etc, conf_file, &group)) < 0) goto err; } #endif for (dirs=default_directories ; *dirs; dirs++) { if (**dirs) { if (search_default_file(&args, &alloc, *dirs, conf_file, &group) < 0) goto err; } else if (defaults_extra_file) { if (search_default_file(&args, &alloc, NullS, defaults_extra_file, &group) < 0) goto err; /* Fatal error */ } } } /* Here error contains <> 0 only if we have a fully specified conf_file or a forced default file */ if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+ (args.elements + *argc +1) *sizeof(char*)))) goto err; res= (char**) (ptr+sizeof(alloc)); /* copy name + found arguments + command line arguments to new array */ res[0]= argv[0][0]; /* Name MUST be set, even by embedded library */ memcpy((gptr) (res+1), args.buffer, args.elements*sizeof(char*)); /* Skip --defaults-file and --defaults-extra-file */ (*argc)-= args_used; (*argv)+= args_used; /* Check if we wan't to see the new argument list */ if (*argc >= 2 && !strcmp(argv[0][1],"--print-defaults")) { found_print_defaults=1; --*argc; ++*argv; /* skip argument */ } if (*argc) memcpy((gptr) (res+1+args.elements), (char*) ((*argv)+1), (*argc-1)*sizeof(char*)); res[args.elements+ *argc]=0; /* last null */ (*argc)+=args.elements; *argv= (char**) res; *(MEM_ROOT*) ptr= alloc; /* Save alloc root for free */ delete_dynamic(&args); if (found_print_defaults) { int i; printf("%s would have been started with the following arguments:\n", **argv); for (i=1 ; i < *argc ; i++) printf("%s ", (*argv)[i]); puts(""); exit(0); } DBUG_RETURN(error); err: fprintf(stderr,"Fatal error in defaults handling. Program aborted\n"); exit(1); return 0; /* Keep compiler happy */ }
int my_search_option_files(const char *conf_file, int *argc, char ***argv, uint *args_used, Process_option_func func, void *func_ctx) { const char **dirs, *forced_default_file, *forced_extra_defaults; int error= 0; DBUG_ENTER("my_search_option_files"); /* Check if we want to force the use a specific default file */ *args_used+= get_defaults_options(*argc - *args_used, *argv + *args_used, (char **) &forced_default_file, (char **) &forced_extra_defaults, (char **) &my_defaults_group_suffix); if (! my_defaults_group_suffix) my_defaults_group_suffix= getenv(STRINGIFY_ARG(DEFAULT_GROUP_SUFFIX_ENV)); if (forced_extra_defaults) my_defaults_extra_file= (char *) forced_extra_defaults; if (forced_default_file) my_defaults_file= forced_default_file; /* We can only handle 'defaults-group-suffix' if we are called from load_defaults() as otherwise we can't know the type of 'func_ctx' */ if (my_defaults_group_suffix && func == handle_default_option) { /* Handle --defaults-group-suffix= */ uint i; const char **extra_groups; const uint instance_len= strlen(my_defaults_group_suffix); struct handle_option_ctx *ctx= (struct handle_option_ctx*) func_ctx; char *ptr; TYPELIB *group= ctx->group; if (!(extra_groups= (const char**)alloc_root(ctx->alloc, (2*group->count+1)*sizeof(char*)))) goto err; for (i= 0; i < group->count; i++) { uint len; extra_groups[i]= group->type_names[i]; /** copy group */ len= strlen(extra_groups[i]); if (!(ptr= alloc_root(ctx->alloc, len+instance_len+1))) goto err; extra_groups[i+group->count]= ptr; /** Construct new group */ memcpy(ptr, extra_groups[i], len); memcpy(ptr+len, my_defaults_group_suffix, instance_len+1); } group->count*= 2; group->type_names= extra_groups; group->type_names[group->count]= 0; } if (forced_default_file) { if ((error= search_default_file_with_ext(func, func_ctx, "", "", forced_default_file, 0)) < 0) goto err; if (error > 0) { fprintf(stderr, "Could not open required defaults file: %s\n", forced_default_file); goto err; } } else if (dirname_length(conf_file)) { if ((error= search_default_file(func, func_ctx, NullS, conf_file)) < 0) goto err; } else { for (dirs= default_directories ; *dirs; dirs++) { if (**dirs) { if (search_default_file(func, func_ctx, *dirs, conf_file) < 0) goto err; } else if (my_defaults_extra_file) { if ((error= search_default_file_with_ext(func, func_ctx, "", "", my_defaults_extra_file, 0)) < 0) goto err; /* Fatal error */ if (error > 0) { fprintf(stderr, "Could not open required defaults file: %s\n", my_defaults_extra_file); goto err; } } } } DBUG_RETURN(error); err: fprintf(stderr,"Fatal error in defaults handling. Program aborted\n"); exit(1); return 0; /* Keep compiler happy */ }