]> git.stg.codes - stg.git/blob - stglibs/conffiles.lib/conffiles.cpp
Correction of adding parameters' values in methods USER_IMPL::Connect, USER_IMPL...
[stg.git] / stglibs / conffiles.lib / conffiles.cpp
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
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
17 /*
18  *    Date: 27.10.2002
19  */
20
21 /*
22  *    Author : Boris Mikhailenko <stg34@ua.fm>
23  */
24
25  /*
26  $Revision: 1.5 $
27  $Date: 2009/10/22 11:40:22 $
28  */
29
30 //---------------------------------------------------------------------------
31
32 // getpid
33 #include <sys/types.h>
34 #include <unistd.h>
35
36 #include <cerrno> // E*
37 #include <cstring>
38 #include <cstdlib>
39 #include <cstdio>
40
41 #include <fstream>
42
43 #include "stg/conffiles.h"
44
45 namespace
46 {
47 //---------------------------------------------------------------------------
48 std::string TrimL(std::string val)
49 {
50 size_t pos = val.find_first_not_of(" \t");
51 if (pos == std::string::npos)
52     {
53     val.erase(val.begin(), val.end());
54     }
55 else
56     {
57     val.erase(0, pos);
58     }
59 return val;
60 }
61 //---------------------------------------------------------------------------
62 std::string TrimR(std::string val)
63 {
64 size_t pos = val.find_last_not_of(" \t");
65 if (pos != std::string::npos)
66     {
67     val.erase(pos + 1);
68     }
69 return val;
70 }
71 //---------------------------------------------------------------------------
72 std::string Trim(std::string val)
73 {
74 return TrimR(TrimL(val));
75 }
76 //---------------------------------------------------------------------------
77 } // namespace anonymous
78
79 //---------------------------------------------------------------------------
80 bool StringCaseCmp(const std::string & str1, const std::string & str2)
81 {
82 return (strcasecmp(str1.c_str(), str2.c_str()) < 0);
83 }
84 //---------------------------------------------------------------------------
85 CONFIGFILE::CONFIGFILE(const std::string & fn, bool nook)
86     : param_val(StringCaseCmp),
87       fileName(fn),
88       error(0),
89       changed(false)
90 {
91 std::ifstream f(fileName.c_str());
92
93 if (!f)
94     {
95     if (!nook)
96         error = -1;
97     return;
98     }
99
100 std::string line;
101 while (getline(f, line))
102     {
103     size_t pos = line.find('#');
104     if (pos != std::string::npos)
105         line.resize(pos);
106
107     if (line.find_first_not_of(" \t\r") == std::string::npos)
108         continue;
109
110     pos = line.find_first_of('=');
111     if (pos == std::string::npos)
112         {
113         error = -1;
114         return;
115         }
116
117     std::string parameter = Trim(line.substr(0, pos));
118     std::string value = Trim(line.substr(pos + 1));
119     param_val[parameter] = value;
120     }
121 }
122 //---------------------------------------------------------------------------
123 CONFIGFILE::~CONFIGFILE()
124 {
125 Flush();
126 }
127 //---------------------------------------------------------------------------
128 const std::string & CONFIGFILE::GetFileName() const
129 {
130 return fileName;
131 }
132 //---------------------------------------------------------------------------
133 int CONFIGFILE::Error() const
134 {
135 int e = error;
136 error = 0;
137 return e;
138 }
139 //---------------------------------------------------------------------------
140 int CONFIGFILE::ReadString(const std::string & param, std::string * val, const std::string & defaultVal) const
141 {
142 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
143
144 if (it != param_val.end())
145     {
146     *val = it->second;
147     return 0;
148     }
149
150 *val = defaultVal;
151 return -1;
152 }
153 //---------------------------------------------------------------------------
154 void CONFIGFILE::WriteString(const std::string & param, const std::string &val)
155 {
156 param_val[param] = val;
157 changed = true;
158 }
159 //---------------------------------------------------------------------------
160 int CONFIGFILE::ReadTime(const std::string & param, time_t * val, time_t defaultVal) const
161 {
162 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
163
164 if (it != param_val.end())
165     {
166     char *res;
167     *val = strtol(it->second.c_str(), &res, 10);
168     if (*res != 0)
169         {
170         *val = defaultVal; //Error!
171         return EINVAL;
172         }
173     return 0;
174     }
175
176 *val = defaultVal;
177 return -1;
178 }
179 //---------------------------------------------------------------------------
180 int CONFIGFILE::ReadInt(const std::string & param, int * val, int defaultVal) const
181 {
182 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
183
184 if (it != param_val.end())
185     {
186     char *res;
187     *val = static_cast<int>(strtol(it->second.c_str(), &res, 10));
188     if (*res != 0)
189         {
190         *val = defaultVal; //Error!
191         return EINVAL;
192         }
193     return 0;
194     }
195
196 *val = defaultVal;
197 return -1;
198 }
199 //---------------------------------------------------------------------------
200 int CONFIGFILE::ReadUInt(const std::string & param, unsigned int * val, unsigned int defaultVal) const
201 {
202 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
203
204 if (it != param_val.end())
205     {
206     char *res;
207     *val = static_cast<unsigned int>(strtoul(it->second.c_str(), &res, 10));
208     if (*res != 0)
209         {
210         *val = defaultVal; //Error!
211         return EINVAL;
212         }
213     return 0;
214     }
215
216 *val = defaultVal;
217 return -1;
218 }
219 //---------------------------------------------------------------------------
220 int CONFIGFILE::ReadLongInt(const std::string & param, long int * val, long int defaultVal) const
221 {
222 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
223
224 if (it != param_val.end())
225     {
226     char *res;
227     *val = strtol(it->second.c_str(), &res, 10);
228     if (*res != 0)
229         {
230         *val = defaultVal; //Error!
231         return EINVAL;
232         }
233     return 0;
234     }
235
236 *val = defaultVal;
237 return -1;
238 }
239 //---------------------------------------------------------------------------
240 int CONFIGFILE::ReadULongInt(const std::string & param, unsigned long int * val, unsigned long int defaultVal) const
241 {
242 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
243
244 if (it != param_val.end())
245     {
246     char *res;
247     *val = strtoul(it->second.c_str(), &res, 10);
248     if (*res != 0)
249         {
250         *val = defaultVal; //Error!
251         return EINVAL;
252         }
253     return 0;
254     }
255
256 *val = defaultVal;
257 return -1;
258 }
259 //---------------------------------------------------------------------------
260 int CONFIGFILE::ReadLongLongInt(const std::string & param, int64_t * val, int64_t defaultVal) const
261 {
262 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
263
264 if (it != param_val.end())
265     {
266     char *res;
267     *val = strtoll(it->second.c_str(), &res, 10);
268     if (*res != 0)
269         {
270         *val = defaultVal; //Error!
271         return EINVAL;
272         }
273     return 0;
274     }
275
276 *val = defaultVal;
277 return -1;
278 }
279 //---------------------------------------------------------------------------
280 int CONFIGFILE::ReadULongLongInt(const std::string & param, uint64_t * val, uint64_t defaultVal) const
281 {
282 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
283
284 if (it != param_val.end())
285     {
286     char *res;
287     *val = strtoull(it->second.c_str(), &res, 10);
288     if (*res != 0)
289         {
290         *val = defaultVal; //Error!
291         return EINVAL;
292         }
293     return 0;
294     }
295
296 *val = defaultVal;
297 return -1;
298 }
299 //---------------------------------------------------------------------------
300 int CONFIGFILE::ReadShortInt(const std::string & param, short int * val, short int defaultVal) const
301 {
302 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
303
304 if (it != param_val.end())
305     {
306     char *res;
307     *val = (short)strtol(it->second.c_str(), &res, 10);
308     if (*res != 0)
309         {
310         *val = defaultVal; //Error!
311         return EINVAL;
312         }
313     return 0;
314     }
315
316 *val = defaultVal;
317 return -1;
318 }
319 //---------------------------------------------------------------------------
320 int CONFIGFILE::ReadUShortInt(const std::string & param, unsigned short int * val, unsigned short int defaultVal) const
321 {
322 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
323
324 if (it != param_val.end())
325     {
326     char *res;
327     *val = (short)strtoul(it->second.c_str(), &res, 10);
328     if (*res != 0)
329         {
330         *val = defaultVal; //Error!
331         return EINVAL;
332         }
333     return 0;
334     }
335
336 *val = defaultVal;
337 return -1;
338 }
339 //---------------------------------------------------------------------------
340 void CONFIGFILE::WriteInt(const std::string & param, int64_t val)
341 {
342 char buf[32];
343 snprintf(buf, sizeof(buf), "%lld", static_cast<long long int>(val));
344 param_val[param] = buf;
345 changed = true;
346 }
347 //---------------------------------------------------------------------------
348 int CONFIGFILE::ReadDouble(const std::string & param, double * val, double defaultVal) const
349 {
350 const std::map<std::string, std::string>::const_iterator it(param_val.find(param));
351
352 if (it != param_val.end())
353     {
354     char *res;
355     *val = strtod(it->second.c_str(), &res);
356     if (*res != 0)
357         {
358         *val = defaultVal; //Error!
359         return EINVAL;
360         }
361     return 0;
362     }
363
364 *val = defaultVal;
365 return -1;
366 }
367 //---------------------------------------------------------------------------
368 void CONFIGFILE::WriteDouble(const std::string & param, double val)
369 {
370 char s[30];
371 snprintf(s, 30, "%f", val);
372 param_val[param] = s;
373 changed = true;
374 }
375 //---------------------------------------------------------------------------
376 int CONFIGFILE::Flush(const std::string & path) const
377 {
378 std::ofstream f(path.c_str());
379 if (!f.is_open())
380     {
381     error = EIO;
382     return EIO;
383     }
384
385 std::map<std::string, std::string>::const_iterator it = param_val.begin();
386 while (it != param_val.end())
387     {
388     f << it->first << "=" << it->second << "\n";
389     ++it;
390     }
391
392 f.close();
393 return 0;
394 }
395 //---------------------------------------------------------------------------
396 int CONFIGFILE::Flush() const
397 {
398 if (!changed)
399     return 0;
400
401 char pid[6];
402 snprintf(pid, sizeof(pid), "%d", getpid());
403
404 if (Flush(fileName + "." + pid))
405     return -1;
406
407 if (rename((fileName + "." + pid).c_str(), fileName.c_str()))
408     return -1;
409
410 changed = false;
411
412 return 0;
413 }
414 //---------------------------------------------------------------------------