← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/default_modify.c

Fixed sql_builtin.cc.in... stupid generated files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/default_modify.c
 
1
/* Copyright (C) 2005 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
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 */
 
15
 
 
16
#include "my_global.h"
 
17
#include "mysys_priv.h"
 
18
#include <mystrings/m_string.h>
 
19
#include <my_dir.h>
 
20
 
 
21
#define BUFF_SIZE 1024
 
22
#define RESERVE 1024                   /* Extend buffer with this extent */
 
23
 
 
24
#define NEWLINE "\n"
 
25
#define NEWLINE_LEN 1
 
26
 
 
27
static char *add_option(char *dst, const char *option_value,
 
28
                        const char *option, int remove_option);
 
29
 
 
30
 
 
31
/*
 
32
  Add/remove option to the option file section.
 
33
 
 
34
  SYNOPSYS
 
35
    modify_defaults_file()
 
36
    file_location     The location of configuration file to edit
 
37
    option            The name of the option to look for (can be NULL)
 
38
    option value      The value of the option we would like to set (can be NULL)
 
39
    section_name      The name of the section (must be NOT NULL)
 
40
    remove_option     This defines what we want to remove:
 
41
                        - MY_REMOVE_NONE -- nothing to remove;
 
42
                        - MY_REMOVE_OPTION -- remove the specified option;
 
43
                        - MY_REMOVE_SECTION -- remove the specified section;
 
44
  IMPLEMENTATION
 
45
    We open the option file first, then read the file line-by-line,
 
46
    looking for the section we need. At the same time we put these lines
 
47
    into a buffer. Then we look for the option within this section and
 
48
    change/remove it. In the end we get a buffer with modified version of the
 
49
    file. Then we write it to the file, truncate it if needed and close it.
 
50
    Note that there is a small time gap, when the file is incomplete,
 
51
    and this theoretically might introduce a problem.
 
52
 
 
53
  RETURN
 
54
    0 - ok
 
55
    1 - some error has occured. Probably due to the lack of resourses
 
56
    2 - cannot open the file
 
57
*/
 
58
 
 
59
int modify_defaults_file(const char *file_location, const char *option,
 
60
                         const char *option_value,
 
61
                         const char *section_name, int remove_option)
 
62
{
 
63
  FILE *cnf_file;
 
64
  struct stat file_stat;
 
65
  char linebuff[BUFF_SIZE], *src_ptr, *dst_ptr, *file_buffer;
 
66
  size_t opt_len= 0, optval_len= 0, sect_len;
 
67
  uint nr_newlines= 0, buffer_size;
 
68
  bool in_section= false, opt_applied= 0;
 
69
  uint reserve_extended;
 
70
  uint new_opt_len;
 
71
  int reserve_occupied= 0;
 
72
 
 
73
  if (!(cnf_file= my_fopen(file_location, O_RDWR | O_BINARY, MYF(0))))
 
74
    return(2);
 
75
 
 
76
  if (fstat(fileno(cnf_file), &file_stat))
 
77
    goto malloc_err;
 
78
 
 
79
  if (option && option_value)
 
80
  {
 
81
    opt_len= strlen(option);
 
82
    optval_len= strlen(option_value);
 
83
  }
 
84
 
 
85
  new_opt_len= opt_len + 1 + optval_len + NEWLINE_LEN;
 
86
 
 
87
  /* calculate the size of the buffer we need */
 
88
  reserve_extended= (opt_len +
 
89
                     1 +                        /* For '=' char */
 
90
                     optval_len +               /* Option value len */
 
91
                     NEWLINE_LEN +              /* Space for newline */
 
92
                     RESERVE);                  /* Some additional space */
 
93
 
 
94
  buffer_size= (file_stat.st_size +
 
95
                1);                             /* The ending zero */
 
96
 
 
97
  /*
 
98
    Reserve space to read the contents of the file and some more
 
99
    for the option we want to add.
 
100
  */
 
101
  if (!(file_buffer= (char*) my_malloc(buffer_size + reserve_extended,
 
102
                                       MYF(MY_WME))))
 
103
    goto malloc_err;
 
104
 
 
105
  sect_len= strlen(section_name);
 
106
 
 
107
  for (dst_ptr= file_buffer; fgets(linebuff, BUFF_SIZE, cnf_file); )
 
108
  {
 
109
    /* Skip over whitespaces */
 
110
    for (src_ptr= linebuff; my_isspace(&my_charset_latin1, *src_ptr);
 
111
         src_ptr++)
 
112
    {}
 
113
 
 
114
    if (!*src_ptr) /* Empty line */
 
115
    {
 
116
      nr_newlines++;
 
117
      continue;
 
118
    }
 
119
 
 
120
    /* correct the option (if requested) */
 
121
    if (option && in_section && !strncmp(src_ptr, option, opt_len) &&
 
122
        (*(src_ptr + opt_len) == '=' ||
 
123
         my_isspace(&my_charset_latin1, *(src_ptr + opt_len)) ||
 
124
         *(src_ptr + opt_len) == '\0'))
 
125
    {
 
126
      char *old_src_ptr= src_ptr;
 
127
      src_ptr= strend(src_ptr+ opt_len);        /* Find the end of the line */
 
128
 
 
129
      /* could be negative */
 
130
      reserve_occupied+= (int) new_opt_len - (int) (src_ptr - old_src_ptr);
 
131
      if (reserve_occupied >= (int) reserve_extended)
 
132
      {
 
133
        reserve_extended= (uint) reserve_occupied + RESERVE;
 
134
        if (!(file_buffer= (char*) my_realloc(file_buffer, buffer_size +
 
135
                                              reserve_extended,
 
136
                                              MYF(MY_WME|MY_FREE_ON_ERROR))))
 
137
          goto malloc_err;
 
138
      }
 
139
      opt_applied= 1;
 
140
      dst_ptr= add_option(dst_ptr, option_value, option, remove_option);
 
141
    }
 
142
    else
 
143
    {
 
144
      /*
 
145
        If we are going to the new group and have an option to apply, do
 
146
        it now. If we are removing a single option or the whole section
 
147
        this will only trigger opt_applied flag.
 
148
      */
 
149
 
 
150
      if (in_section && !opt_applied && *src_ptr == '[')
 
151
      {
 
152
        dst_ptr= add_option(dst_ptr, option_value, option, remove_option);
 
153
        opt_applied= 1;           /* set the flag to do write() later */
 
154
        reserve_occupied= new_opt_len+ opt_len + 1 + NEWLINE_LEN;
 
155
      }
 
156
 
 
157
      for (; nr_newlines; nr_newlines--)
 
158
        dst_ptr= strmov(dst_ptr, NEWLINE);
 
159
 
 
160
      /* Skip the section if MY_REMOVE_SECTION was given */
 
161
      if (!in_section || remove_option != MY_REMOVE_SECTION)
 
162
        dst_ptr= strmov(dst_ptr, linebuff);
 
163
    }
 
164
    /* Look for a section */
 
165
    if (*src_ptr == '[')
 
166
    {
 
167
      /* Copy the line to the buffer */
 
168
      if (!strncmp(++src_ptr, section_name, sect_len))
 
169
      {
 
170
        src_ptr+= sect_len;
 
171
        /* Skip over whitespaces. They are allowed after section name */
 
172
        for (; my_isspace(&my_charset_latin1, *src_ptr); src_ptr++)
 
173
        {}
 
174
 
 
175
        if (*src_ptr != ']')
 
176
        {
 
177
          in_section= false;
 
178
          continue; /* Missing closing parenthesis. Assume this was no group */
 
179
        }
 
180
 
 
181
        if (remove_option == MY_REMOVE_SECTION)
 
182
          dst_ptr= dst_ptr - strlen(linebuff);
 
183
 
 
184
        in_section= true;
 
185
      }
 
186
      else
 
187
        in_section= false; /* mark that this section is of no interest to us */
 
188
    }
 
189
  }
 
190
 
 
191
  /*
 
192
    File ended. Apply an option or set opt_applied flag (in case of
 
193
    MY_REMOVE_SECTION) so that the changes are saved. Do not do anything
 
194
    if we are removing non-existent option.
 
195
  */
 
196
 
 
197
  if (!opt_applied && in_section && (remove_option != MY_REMOVE_OPTION))
 
198
  {
 
199
    /* New option still remains to apply at the end */
 
200
    if (!remove_option && *(dst_ptr - 1) != '\n')
 
201
      dst_ptr= strmov(dst_ptr, NEWLINE);
 
202
    dst_ptr= add_option(dst_ptr, option_value, option, remove_option);
 
203
    opt_applied= 1;
 
204
  }
 
205
  for (; nr_newlines; nr_newlines--)
 
206
    dst_ptr= strmov(dst_ptr, NEWLINE);
 
207
 
 
208
  if (opt_applied)
 
209
  {
 
210
    /* Don't write the file if there are no changes to be made */
 
211
    if (ftruncate(fileno(cnf_file), (my_off_t) (dst_ptr - file_buffer)) ||
 
212
        my_fseek(cnf_file, 0, MY_SEEK_SET, MYF(0)) ||
 
213
        my_fwrite(cnf_file, (uchar*) file_buffer, (size_t) (dst_ptr - file_buffer),
 
214
                  MYF(MY_NABP)))
 
215
      goto err;
 
216
  }
 
217
  if (my_fclose(cnf_file, MYF(MY_WME)))
 
218
    return(1);
 
219
 
 
220
  my_free(file_buffer, MYF(0));
 
221
  return(0);
 
222
 
 
223
err:
 
224
  my_free(file_buffer, MYF(0));
 
225
malloc_err:
 
226
  my_fclose(cnf_file, MYF(0));
 
227
  return(1); /* out of resources */
 
228
}
 
229
 
 
230
 
 
231
static char *add_option(char *dst, const char *option_value,
 
232
                        const char *option, int remove_option)
 
233
{
 
234
  if (!remove_option)
 
235
  {
 
236
    dst= strmov(dst, option);
 
237
    if (*option_value)
 
238
    {
 
239
      *dst++= '=';
 
240
      dst= strmov(dst, option_value);
 
241
    }
 
242
    /* add a newline */
 
243
    dst= strmov(dst, NEWLINE);
 
244
  }
 
245
  return dst;
 
246
}