]> git.stg.codes - stg.git/blob - stglibs/conffiles.lib/conffiles.cpp
Проведен легкий рефакторинг плагина пингера. Инициализация нотификаторов
[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 #include <errno.h>
32 #include <string.h>
33 #include <stdlib.h>
34 #include <fstream>
35 #include <algorithm>
36 #include "conffiles.h"
37 #include "common.h"
38
39 using namespace std;
40
41 //---------------------------------------------------------------------------
42 bool StringCaseCmp(const string & str1, const string & str2)
43 {
44 return (strcasecmp(str1.c_str(), str2.c_str()) < 0);
45 }
46 //---------------------------------------------------------------------------
47 CONFIGFILE::CONFIGFILE(const string &fn):
48 param_val(StringCaseCmp)
49 {
50 fileName = fn;
51 f = fopen(fn.c_str(), "rt");
52
53 error = 0;
54 param_val.clear();
55
56 if (!f)
57     {
58     error = -1;
59     return;
60     }
61
62 string line, parameter, value;
63
64 unsigned long pos;
65 bool emptyLine;
66 unsigned char c;
67
68 while (!feof(f))
69     {
70     line.erase(line.begin(), line.end());
71
72     c = fgetc(f);
73     while (!feof(f))
74         {
75         //printf("%c", c);
76         if (c == '\n')
77             break;
78         line.push_back(c);
79         c = fgetc(f);
80         }
81
82     pos = line.find('#');
83     if (pos != string::npos)
84         line.resize(pos);
85
86     emptyLine = true;
87     for (unsigned int i = 0; i < line.size(); i++)
88         {
89         if (line[i] != ' ' && line[i] != '\t' && line[i] != '\n' && line[i] != '\r')
90             {
91             emptyLine = false;
92             break;
93             }
94         }
95     if (emptyLine)
96         {
97         continue;
98         }
99
100     pos = line.find("=");
101     if (pos == string::npos)
102         {
103         fclose(f);
104         error = -1;
105         //printf("%s find(=) error\n", __FILE__);
106         return;
107         }
108     parameter = line.substr(0, pos);
109     //transform(parameter.begin(), parameter.end(), parameter.begin(), tolower);
110     value = line.substr(pos + 1);
111     //cout << parameter << "==" << value << endl;
112     param_val[parameter] = value;
113     //cout << parameter << "==" << param_val[parameter] << endl;
114     }
115
116 fclose(f);
117 }
118 //---------------------------------------------------------------------------
119 CONFIGFILE::~CONFIGFILE()
120 {
121
122 }
123 //---------------------------------------------------------------------------
124 const string & CONFIGFILE::GetFileName() const
125 {
126 return fileName;
127 }
128 //---------------------------------------------------------------------------
129 int CONFIGFILE::Error()
130 {
131 int e = error;
132 error = 0;
133 return e;
134 }
135 //---------------------------------------------------------------------------
136 int CONFIGFILE::FindParameter(const string &parameter, string * value) const
137 {
138 it = param_val.find(parameter);
139 if (it == param_val.end())
140     return -1;
141
142 *value = param_val[parameter];
143 return 0;
144 }
145 //---------------------------------------------------------------------------
146 int CONFIGFILE::Flush()
147 {
148 fstream f(fileName.c_str(), ios::out);
149 if (!f.is_open())
150     {
151     error = EIO;
152     return EIO;
153     }
154
155 it = param_val.begin();
156 while (it != param_val.end())
157     {
158     f << it->first << "=" << it->second << endl;
159     it++;
160     }
161
162 f.close();
163
164 return 0;
165 }
166 //---------------------------------------------------------------------------
167 int CONFIGFILE::ReadString(const string & param, char * str, int * maxLen, const char * defaultVal) const
168 {
169 it = param_val.find(param);
170 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
171
172 if (it != param_val.end())
173     {
174     // þÔÏ-ÔÏ ÓÔÏÉÔ
175     strncpy(str, param_val[param].c_str(), *maxLen);
176     *maxLen = param_val[param].size();
177     return 0;
178     }
179
180 strncpy(str, defaultVal, *maxLen);
181 *maxLen = strlen(defaultVal);
182 return -1;
183 }
184 //---------------------------------------------------------------------------
185 int CONFIGFILE::ReadString(const string & param, string * val, const string & defaultVal) const
186 {
187 it = param_val.find(param);
188 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
189
190 if (it != param_val.end())
191     {
192     // þÔÏ-ÔÏ ÓÔÏÉÔ
193     *val = param_val[param];
194     return 0;
195     }
196
197 *val = defaultVal;
198 return -1;
199 }
200 //---------------------------------------------------------------------------
201 int CONFIGFILE::WriteString(const string & param, const char * val)
202 {
203 WriteString(param, string(val));
204 return 0;
205 }
206 //---------------------------------------------------------------------------
207 int CONFIGFILE::WriteString(const string & param, const string &val)
208 {
209 param_val[param] = val;
210 Flush();
211 return 0;
212 }
213 //---------------------------------------------------------------------------
214 int CONFIGFILE::ReadTime(const string & param, time_t * val, time_t defaultVal) const
215 {
216 it = param_val.find(param);
217
218 if (it != param_val.end())
219     {
220     char *res;
221     *val = strtol(param_val[param].c_str(), &res, 10);
222     if (*res != 0)
223         {
224         *val = defaultVal; //Error!
225         return EINVAL;
226         }
227     return 0;
228     }
229
230 *val = defaultVal;
231 return -1;
232 }
233 //---------------------------------------------------------------------------
234 int CONFIGFILE::ReadInt(const string & param, int * val, int defaultVal) const
235 {
236 it = param_val.find(param);
237 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
238
239 if (it != param_val.end())
240     {
241     // þÔÏ-ÔÏ ÓÔÏÉÔ
242     char *res;
243     *val = strtol(param_val[param].c_str(), &res, 10);
244     if (*res != 0)
245         {
246         *val = defaultVal; //Error!
247         return EINVAL;
248         }
249     return 0;
250     }
251
252 *val = defaultVal;
253 return -1;
254 }
255 //---------------------------------------------------------------------------
256 int CONFIGFILE::ReadUInt(const string & param, unsigned int * val, unsigned int defaultVal) const
257 {
258 it = param_val.find(param);
259 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
260
261 if (it != param_val.end())
262     {
263     // þÔÏ-ÔÏ ÓÔÏÉÔ
264     char *res;
265     *val = strtoul(param_val[param].c_str(), &res, 10);
266     if (*res != 0)
267         {
268         *val = defaultVal; //Error!
269         return EINVAL;
270         }
271     return 0;
272     }
273
274 *val = defaultVal;
275 return -1;
276 }
277 //---------------------------------------------------------------------------
278 int CONFIGFILE::ReadLongInt(const string & param, long int * val, long int defaultVal) const
279 {
280 it = param_val.find(param);
281 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
282
283 if (it != param_val.end())
284     {
285     // þÔÏ-ÔÏ ÓÔÏÉÔ
286     char *res;
287     *val = strtol(param_val[param].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::ReadULongInt(const string & param, unsigned long int * val, unsigned long int defaultVal) const
301 {
302 it = param_val.find(param);
303 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
304
305 if (it != param_val.end())
306     {
307     // þÔÏ-ÔÏ ÓÔÏÉÔ
308     char *res;
309     *val = strtoul(param_val[param].c_str(), &res, 10);
310     if (*res != 0)
311         {
312         *val = defaultVal; //Error!
313         return EINVAL;
314         }
315     return 0;
316     }
317
318 *val = defaultVal;
319 return -1;
320 }
321 //---------------------------------------------------------------------------
322 int CONFIGFILE::ReadLongLongInt(const string & param, int64_t * val, int64_t defaultVal) const
323 {
324 it = param_val.find(param);
325 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
326
327 if (it != param_val.end())
328     {
329     // þÔÏ-ÔÏ ÓÔÏÉÔ
330     char *res;
331     *val = strtoll(param_val[param].c_str(), &res, 10);
332     if (*res != 0)
333         {
334         *val = defaultVal; //Error!
335         return EINVAL;
336         }
337     return 0;
338     }
339
340 *val = defaultVal;
341 return -1;
342 }
343 //---------------------------------------------------------------------------
344 int CONFIGFILE::ReadULongLongInt(const string & param, uint64_t * val, uint64_t defaultVal) const
345 {
346 it = param_val.find(param);
347 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
348
349 if (it != param_val.end())
350     {
351     // þÔÏ-ÔÏ ÓÔÏÉÔ
352     char *res;
353     *val = strtoull(param_val[param].c_str(), &res, 10);
354     if (*res != 0)
355         {
356         *val = defaultVal; //Error!
357         return EINVAL;
358         }
359     return 0;
360     }
361
362 *val = defaultVal;
363 return -1;
364 }
365 //---------------------------------------------------------------------------
366 int CONFIGFILE::ReadShortInt(const string & param, short int * val, short int defaultVal) const
367 {
368 it = param_val.find(param);
369 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
370
371 if (it != param_val.end())
372     {
373     // þÔÏ-ÔÏ ÓÔÏÉÔ
374     char *res;
375     *val = (short)strtol(param_val[param].c_str(), &res, 10);
376     if (*res != 0)
377         {
378         *val = defaultVal; //Error!
379         return EINVAL;
380         }
381     return 0;
382     }
383
384 *val = defaultVal;
385 return -1;
386 }
387 //---------------------------------------------------------------------------
388 int CONFIGFILE::ReadUShortInt(const string & param, unsigned short int * val, unsigned short int defaultVal) const
389 {
390 it = param_val.find(param);
391 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
392
393 if (it != param_val.end())
394     {
395     // þÔÏ-ÔÏ ÓÔÏÉÔ
396     char *res;
397     *val = (short)strtoul(param_val[param].c_str(), &res, 10);
398     if (*res != 0)
399         {
400         *val = defaultVal; //Error!
401         return EINVAL;
402         }
403     return 0;
404     }
405
406 *val = defaultVal;
407 return -1;
408 }
409 //---------------------------------------------------------------------------
410 int CONFIGFILE::WriteInt(const string & param, int64_t val)
411 {
412 string s;
413 //sprintf(s, "%lld", val);
414 x2str(val, s);
415 param_val[param] = s;
416 Flush();
417 return 0;
418 }
419 //---------------------------------------------------------------------------
420 int CONFIGFILE::ReadDouble(const string & param, double * val, double defaultVal) const
421 {
422 it = param_val.find(param);
423 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
424
425 if (it != param_val.end())
426     {
427     // þÔÏ-ÔÏ ÓÔÏÉÔ
428     char *res;
429     *val = strtod(param_val[param].c_str(), &res);
430     if (*res != 0)
431         {
432         //cout << param << "=" << param_val[param] << " Error!!!\n";
433         *val = defaultVal; //Error!
434         return EINVAL;
435         }
436     return 0;
437     }
438
439 //cout << "îÉÞÅÇÏ ÎÅÔ!!!\n";
440
441 *val = defaultVal;
442 return -1;
443 }
444 //---------------------------------------------------------------------------
445 int CONFIGFILE::WriteDouble(const string & param, double val)
446 {
447 char s[30];
448 sprintf(s, "%f", val);
449 param_val[param] = s;
450 Flush();
451 return 0;
452 }
453 //---------------------------------------------------------------------------
454
455