~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/default_modify.c

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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 "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
  MY_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
  my_bool in_section= FALSE, opt_applied= 0;
 
69
  uint reserve_extended;
 
70
  uint new_opt_len;
 
71
  int reserve_occupied= 0;
 
72
  DBUG_ENTER("modify_defaults_file");
 
73
 
 
74
  if (!(cnf_file= my_fopen(file_location, O_RDWR | O_BINARY, MYF(0))))
 
75
    DBUG_RETURN(2);
 
76
 
 
77
  /* my_fstat doesn't use the flag parameter */
 
78
  if (my_fstat(fileno(cnf_file), &file_stat, MYF(0)))
 
79
    goto malloc_err;
 
80
 
 
81
  if (option && option_value)
 
82
  {
 
83
    opt_len= strlen(option);
 
84
    optval_len= strlen(option_value);
 
85
  }
 
86
 
 
87
  new_opt_len= opt_len + 1 + optval_len + NEWLINE_LEN;
 
88
 
 
89
  /* calculate the size of the buffer we need */
 
90
  reserve_extended= (opt_len +
 
91
                     1 +                        /* For '=' char */
 
92
                     optval_len +               /* Option value len */
 
93
                     NEWLINE_LEN +              /* Space for newline */
 
94
                     RESERVE);                  /* Some additional space */
 
95
 
 
96
  buffer_size= (file_stat.st_size +
 
97
                1);                             /* The ending zero */
 
98
 
 
99
  /*
 
100
    Reserve space to read the contents of the file and some more
 
101
    for the option we want to add.
 
102
  */
 
103
  if (!(file_buffer= (char*) my_malloc(buffer_size + reserve_extended,
 
104
                                       MYF(MY_WME))))
 
105
    goto malloc_err;
 
106
 
 
107
  sect_len= strlen(section_name);
 
108
 
 
109
  for (dst_ptr= file_buffer; fgets(linebuff, BUFF_SIZE, cnf_file); )
 
110
  {
 
111
    /* Skip over whitespaces */
 
112
    for (src_ptr= linebuff; my_isspace(&my_charset_latin1, *src_ptr);
 
113
         src_ptr++)
 
114
    {}
 
115
 
 
116
    if (!*src_ptr) /* Empty line */
 
117
    {
 
118
      nr_newlines++;
 
119
      continue;
 
120
    }
 
121
 
 
122
    /* correct the option (if requested) */
 
123
    if (option && in_section && !strncmp(src_ptr, option, opt_len) &&
 
124
        (*(src_ptr + opt_len) == '=' ||
 
125
         my_isspace(&my_charset_latin1, *(src_ptr + opt_len)) ||
 
126
         *(src_ptr + opt_len) == '\0'))
 
127
    {
 
128
      char *old_src_ptr= src_ptr;
 
129
      src_ptr= strend(src_ptr+ opt_len);        /* Find the end of the line */
 
130
 
 
131
      /* could be negative */
 
132
      reserve_occupied+= (int) new_opt_len - (int) (src_ptr - old_src_ptr);
 
133
      if (reserve_occupied >= (int) reserve_extended)
 
134
      {
 
135
        reserve_extended= (uint) reserve_occupied + RESERVE;
 
136
        if (!(file_buffer= (char*) my_realloc(file_buffer, buffer_size +
 
137
                                              reserve_extended,
 
138
                                              MYF(MY_WME|MY_FREE_ON_ERROR))))
 
139
          goto malloc_err;
 
140
      }
 
141
      opt_applied= 1;
 
142
      dst_ptr= add_option(dst_ptr, option_value, option, remove_option);
 
143
    }
 
144
    else
 
145
    {
 
146
      /*
 
147
        If we are going to the new group and have an option to apply, do
 
148
        it now. If we are removing a single option or the whole section
 
149
        this will only trigger opt_applied flag.
 
150
      */
 
151
 
 
152
      if (in_section && !opt_applied && *src_ptr == '[')
 
153
      {
 
154
        dst_ptr= add_option(dst_ptr, option_value, option, remove_option);
 
155
        opt_applied= 1;           /* set the flag to do write() later */
 
156
        reserve_occupied= new_opt_len+ opt_len + 1 + NEWLINE_LEN;
 
157
      }
 
158
 
 
159
      for (; nr_newlines; nr_newlines--)
 
160
        dst_ptr= strmov(dst_ptr, NEWLINE);
 
161
 
 
162
      /* Skip the section if MY_REMOVE_SECTION was given */
 
163
      if (!in_section || remove_option != MY_REMOVE_SECTION)
 
164
        dst_ptr= strmov(dst_ptr, linebuff);
 
165
    }
 
166
    /* Look for a section */
 
167
    if (*src_ptr == '[')
 
168
    {
 
169
      /* Copy the line to the buffer */
 
170
      if (!strncmp(++src_ptr, section_name, sect_len))
 
171
      {
 
172
        src_ptr+= sect_len;
 
173
        /* Skip over whitespaces. They are allowed after section name */
 
174
        for (; my_isspace(&my_charset_latin1, *src_ptr); src_ptr++)
 
175
        {}
 
176
 
 
177
        if (*src_ptr != ']')
 
178
        {
 
179
          in_section= FALSE;
 
180
          continue; /* Missing closing parenthesis. Assume this was no group */
 
181
        }
 
182
 
 
183
        if (remove_option == MY_REMOVE_SECTION)
 
184
          dst_ptr= dst_ptr - strlen(linebuff);
 
185
 
 
186
        in_section= TRUE;
 
187
      }
 
188
      else
 
189
        in_section= FALSE; /* mark that this section is of no interest to us */
 
190
    }
 
191
  }
 
192
 
 
193
  /*
 
194
    File ended. Apply an option or set opt_applied flag (in case of
 
195
    MY_REMOVE_SECTION) so that the changes are saved. Do not do anything
 
196
    if we are removing non-existent option.
 
197
  */
 
198
 
 
199
  if (!opt_applied && in_section && (remove_option != MY_REMOVE_OPTION))
 
200
  {
 
201
    /* New option still remains to apply at the end */
 
202
    if (!remove_option && *(dst_ptr - 1) != '\n')
 
203
      dst_ptr= strmov(dst_ptr, NEWLINE);
 
204
    dst_ptr= add_option(dst_ptr, option_value, option, remove_option);
 
205
    opt_applied= 1;
 
206
  }
 
207
  for (; nr_newlines; nr_newlines--)
 
208
    dst_ptr= strmov(dst_ptr, NEWLINE);
 
209
 
 
210
  if (opt_applied)
 
211
  {
 
212
    /* Don't write the file if there are no changes to be made */
 
213
    if (my_chsize(fileno(cnf_file), (my_off_t) (dst_ptr - file_buffer), 0,
 
214
                  MYF(MY_WME)) ||
 
215
        my_fseek(cnf_file, 0, MY_SEEK_SET, MYF(0)) ||
 
216
        my_fwrite(cnf_file, (uchar*) file_buffer, (size_t) (dst_ptr - file_buffer),
 
217
                  MYF(MY_NABP)))
 
218
      goto err;
 
219
  }
 
220
  if (my_fclose(cnf_file, MYF(MY_WME)))
 
221
    DBUG_RETURN(1);
 
222
 
 
223
  my_free(file_buffer, MYF(0));
 
224
  DBUG_RETURN(0);
 
225
 
 
226
err:
 
227
  my_free(file_buffer, MYF(0));
 
228
malloc_err:
 
229
  my_fclose(cnf_file, MYF(0));
 
230
  DBUG_RETURN(1); /* out of resources */
 
231
}
 
232
 
 
233
 
 
234
static char *add_option(char *dst, const char *option_value,
 
235
                        const char *option, int remove_option)
 
236
{
 
237
  if (!remove_option)
 
238
  {
 
239
    dst= strmov(dst, option);
 
240
    if (*option_value)
 
241
    {
 
242
      *dst++= '=';
 
243
      dst= strmov(dst, option_value);
 
244
    }
 
245
    /* add a newline */
 
246
    dst= strmov(dst, NEWLINE);
 
247
  }
 
248
  return dst;
 
249
}