← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/default_modify.cc

Small fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/default_modify.cc
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 "mysys_priv.h"
17
 
#include <mystrings/m_string.h>
18
 
#include <mysys/my_dir.h>
19
 
 
20
 
#include <stdio.h>
21
 
 
22
 
#define BUFF_SIZE 1024
23
 
#define RESERVE 1024                   /* Extend buffer with this extent */
24
 
 
25
 
#define NEWLINE "\n"
26
 
#define NEWLINE_LEN 1
27
 
 
28
 
static char *add_option(char *dst, const char *option_value,
29
 
                        const char *option, int remove_option);
30
 
 
31
 
 
32
 
/*
33
 
  Add/remove option to the option file section.
34
 
 
35
 
  SYNOPSYS
36
 
    modify_defaults_file()
37
 
    file_location     The location of configuration file to edit
38
 
    option            The name of the option to look for (can be NULL)
39
 
    option value      The value of the option we would like to set (can be NULL)
40
 
    section_name      The name of the section (must be NOT NULL)
41
 
    remove_option     This defines what we want to remove:
42
 
                        - MY_REMOVE_NONE -- nothing to remove;
43
 
                        - MY_REMOVE_OPTION -- remove the specified option;
44
 
                        - MY_REMOVE_SECTION -- remove the specified section;
45
 
  IMPLEMENTATION
46
 
    We open the option file first, then read the file line-by-line,
47
 
    looking for the section we need. At the same time we put these lines
48
 
    into a buffer. Then we look for the option within this section and
49
 
    change/remove it. In the end we get a buffer with modified version of the
50
 
    file. Then we write it to the file, truncate it if needed and close it.
51
 
    Note that there is a small time gap, when the file is incomplete,
52
 
    and this theoretically might introduce a problem.
53
 
 
54
 
  RETURN
55
 
    0 - ok
56
 
    1 - some error has occured. Probably due to the lack of resourses
57
 
    2 - cannot open the file
58
 
*/
59
 
 
60
 
int modify_defaults_file(const char *file_location, const char *option,
61
 
                         const char *option_value,
62
 
                         const char *section_name, int remove_option)
63
 
{
64
 
  FILE *cnf_file;
65
 
  struct stat file_stat;
66
 
  char linebuff[BUFF_SIZE], *src_ptr, *dst_ptr, *file_buffer;
67
 
  size_t opt_len= 0, optval_len= 0, sect_len;
68
 
  uint32_t nr_newlines= 0;
69
 
  size_t buffer_size;
70
 
  bool in_section= false, opt_applied= 0;
71
 
  size_t reserve_extended;
72
 
  uint32_t new_opt_len;
73
 
  int reserve_occupied= 0;
74
 
 
75
 
  if (!(cnf_file= my_fopen(file_location, O_RDWR, MYF(0))))
76
 
    return(2);
77
 
 
78
 
  if (fstat(fileno(cnf_file), &file_stat))
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= (size_t)cmax((uint64_t)file_stat.st_size + 1, (uint64_t)SIZE_MAX);
97
 
 
98
 
  /*
99
 
    Reserve space to read the contents of the file and some more
100
 
    for the option we want to add.
101
 
  */
102
 
  if (!(file_buffer= (char*) malloc(cmax(buffer_size + reserve_extended,
103
 
                                         SIZE_MAX))))
104
 
    goto malloc_err;
105
 
 
106
 
  sect_len= strlen(section_name);
107
 
 
108
 
  for (dst_ptr= file_buffer; fgets(linebuff, BUFF_SIZE, cnf_file); )
109
 
  {
110
 
    /* Skip over whitespaces */
111
 
    for (src_ptr= linebuff; my_isspace(&my_charset_utf8_general_ci, *src_ptr);
112
 
         src_ptr++)
113
 
    {}
114
 
 
115
 
    if (!*src_ptr) /* Empty line */
116
 
    {
117
 
      nr_newlines++;
118
 
      continue;
119
 
    }
120
 
 
121
 
    /* correct the option (if requested) */
122
 
    if (option && in_section && !strncmp(src_ptr, option, opt_len) &&
123
 
        (*(src_ptr + opt_len) == '=' ||
124
 
         my_isspace(&my_charset_utf8_general_ci, *(src_ptr + opt_len)) ||
125
 
         *(src_ptr + opt_len) == '\0'))
126
 
    {
127
 
      char *old_src_ptr= src_ptr;
128
 
      src_ptr= strchr(src_ptr+ opt_len, '\0');        /* Find the end of the line */
129
 
 
130
 
      /* could be negative */
131
 
      reserve_occupied+= (int) new_opt_len - (int) (src_ptr - old_src_ptr);
132
 
      if (reserve_occupied >= (int) reserve_extended)
133
 
      {
134
 
        reserve_extended= (uint) reserve_occupied + RESERVE;
135
 
        if (!(file_buffer= (char*) realloc(file_buffer, buffer_size +
136
 
                                           reserve_extended)))
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= strcpy(dst_ptr, NEWLINE)+NEWLINE_LEN;
159
 
 
160
 
      /* Skip the section if MY_REMOVE_SECTION was given */
161
 
      if (!in_section || remove_option != MY_REMOVE_SECTION)
162
 
        dst_ptr= strcpy(dst_ptr, linebuff);
163
 
        dst_ptr+= strlen(linebuff);
164
 
    }
165
 
    /* Look for a section */
166
 
    if (*src_ptr == '[')
167
 
    {
168
 
      /* Copy the line to the buffer */
169
 
      if (!strncmp(++src_ptr, section_name, sect_len))
170
 
      {
171
 
        src_ptr+= sect_len;
172
 
        /* Skip over whitespaces. They are allowed after section name */
173
 
        for (; my_isspace(&my_charset_utf8_general_ci, *src_ptr); src_ptr++)
174
 
        {}
175
 
 
176
 
        if (*src_ptr != ']')
177
 
        {
178
 
          in_section= false;
179
 
          continue; /* Missing closing parenthesis. Assume this was no group */
180
 
        }
181
 
 
182
 
        if (remove_option == MY_REMOVE_SECTION)
183
 
          dst_ptr= dst_ptr - strlen(linebuff);
184
 
 
185
 
        in_section= true;
186
 
      }
187
 
      else
188
 
        in_section= false; /* mark that this section is of no interest to us */
189
 
    }
190
 
  }
191
 
 
192
 
  /*
193
 
    File ended. Apply an option or set opt_applied flag (in case of
194
 
    MY_REMOVE_SECTION) so that the changes are saved. Do not do anything
195
 
    if we are removing non-existent option.
196
 
  */
197
 
 
198
 
  if (!opt_applied && in_section && (remove_option != MY_REMOVE_OPTION))
199
 
  {
200
 
    /* New option still remains to apply at the end */
201
 
    if (!remove_option && *(dst_ptr - 1) != '\n')
202
 
      dst_ptr= strcpy(dst_ptr, NEWLINE)+NEWLINE_LEN;
203
 
    dst_ptr= add_option(dst_ptr, option_value, option, remove_option);
204
 
    opt_applied= 1;
205
 
  }
206
 
  for (; nr_newlines; nr_newlines--)
207
 
    dst_ptr= strcpy(dst_ptr, NEWLINE)+NEWLINE_LEN;
208
 
 
209
 
  if (opt_applied)
210
 
  {
211
 
    /* Don't write the file if there are no changes to be made */
212
 
    if (ftruncate(fileno(cnf_file), (size_t) (dst_ptr - file_buffer)) ||
213
 
        fseeko(cnf_file, 0, SEEK_SET) ||
214
 
        fwrite(file_buffer, 1, (size_t) (dst_ptr - file_buffer), cnf_file))
215
 
      goto err;
216
 
  }
217
 
  if (my_fclose(cnf_file, MYF(MY_WME)))
218
 
    return(1);
219
 
 
220
 
  free(file_buffer);
221
 
  return(0);
222
 
 
223
 
err:
224
 
  free(file_buffer);
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= strcpy(dst, option);
237
 
    dst+= strlen(option);
238
 
    if (*option_value)
239
 
    {
240
 
      *dst++= '=';
241
 
      dst= strcpy(dst, option_value);
242
 
      dst+= strlen(option_value);
243
 
    }
244
 
    /* add a newline */
245
 
    dst= strcpy(dst, NEWLINE)+NEWLINE_LEN;
246
 
  }
247
 
  return dst;
248
 
}