← Back to branch summary

~ubuntu-dev/ubuntu/lucid/zabbix/lucid-201002110857

« back to all changes in this revision

Viewing changes to src/libs/zbxconf/cfg.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Ablassmeier
  • Date: 2007-07-02 09:06:51 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070702090651-8l6fl3fjw9rh6l2u
Tags: 1:1.4.1-2
Add patch from SVN in order to fix Incorrect processing of character '%'
in user parameters and remote commands.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs/zbxconf/cfg.c
17
17
** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
18
**/
19
19
 
20
 
 
21
 
#include <stdio.h>
22
 
#include <stdlib.h>
23
 
#include <string.h>
24
 
 
25
20
#include "common.h"
26
21
#include "cfg.h"
 
22
#include "log.h"
 
23
 
 
24
 
 
25
char    *CONFIG_FILE                    = NULL;
 
26
int     CONFIG_ZABBIX_FORKS             = 5;
 
27
 
 
28
 
 
29
char    *CONFIG_LOG_FILE                = NULL;
 
30
int     CONFIG_LOG_FILE_SIZE            = 1;
 
31
char    CONFIG_ALLOW_ROOT               = 0;
 
32
int     CONFIG_TIMEOUT                  = AGENT_TIMEOUT;
27
33
 
28
34
/******************************************************************************
29
35
 *                                                                            *
38
44
 *               FAIL - error processing config file                          *
39
45
 *                                                                            *
40
46
 * Author: Alexei Vladishev                                                   *
 
47
 *         Eugene Grigorjev                                                   *
41
48
 *                                                                            *
42
49
 * Comments:                                                                  *
43
50
 *                                                                            *
44
51
 ******************************************************************************/
45
 
int     parse_cfg_file(char *cfg_file,struct cfg_line *cfg)
 
52
int     parse_cfg_file(const char *cfg_file,struct cfg_line *cfg)
46
53
{
47
54
        FILE    *file;
48
 
        char    line[MAX_STRING_LEN];
49
 
        char    parameter[MAX_STRING_LEN];
50
 
        char    *value;
51
 
        int     lineno;
52
 
        int     i,var;
53
 
        char    **c;
54
 
        int     (*func)();
55
 
 
56
 
 
57
 
 
58
 
        file=fopen(cfg_file,"r");
59
 
        if(NULL == file)
60
 
        {
61
 
                fprintf(stderr, "Cannot open config file [%s] [%s]\n",cfg_file,strerror(errno));
62
 
                return  FAIL;
63
 
        }
64
 
 
65
 
        lineno=0;
66
 
        while(fgets(line,MAX_STRING_LEN,file) != NULL)
67
 
        {
68
 
                lineno++;
69
 
 
70
 
                if(line[0]=='#')        continue;
71
 
                if(strlen(line)==1)     continue;
72
 
 
73
 
                strscpy(parameter,line);
74
 
 
75
 
                value=strstr(line,"=");
76
 
 
77
 
                if(NULL == value)
78
 
                {
79
 
                        fprintf(stderr, "Error in line [%s] Line %d\n", line, lineno);
80
 
                        return  FAIL;
81
 
                }
82
 
                value++;
83
 
                value[strlen(value)-1]=0;
84
 
 
85
 
                parameter[value-line-1]=0;
86
 
 
87
 
                i=0;
88
 
                while(cfg[i].parameter != 0)
89
 
                {
90
 
                        if(strcmp(cfg[i].parameter, parameter) == 0)
91
 
                        {
92
 
                                if(cfg[i].function != 0)
93
 
                                {
94
 
                                        func=cfg[i].function;
95
 
                                        if(func(value)!=SUCCEED)
96
 
                                        {
97
 
                                                fprintf(stderr, "Wrong value of [%s] in line %d.\n", cfg[i].parameter, lineno);
98
 
                                                return  FAIL;
99
 
                                        }
100
 
                                }
101
 
                                else
102
 
                                {
103
 
                                if(cfg[i].type == TYPE_INT)
104
 
                                {
105
 
                                        var=atoi(value);
106
 
                                        if( (cfg[i].min!=0) || (cfg[i].max!=0))
107
 
                                        {
108
 
                                                if( (var<cfg[i].min) || (var>cfg[i].max) )
109
 
                                                {
110
 
                                                        fprintf(stderr, "Wrong value of [%s] in line %d. Should be between %d and %d.\n", cfg[i].parameter, lineno, cfg[i].min, cfg[i].max);
111
 
                                                        return  FAIL;
112
 
                                                }
113
 
                                                
114
 
                                        }
115
 
                                        *((int*)cfg[i].variable)=var;
116
 
                                }
117
 
                                else
118
 
                                {
119
 
/* Can this be done without "c" ? */ 
120
 
                                        c=(char **)cfg[i].variable;
121
 
                                        *c=(char *)strdup(value);
122
 
/*                                      *((char*)cfg[i].variable)=strdup(value);*/
123
 
                                }
124
 
                                }
125
 
                        }
126
 
                        i++;
127
 
                }
128
 
        }
129
 
 
130
 
/* Check for mandatory parameters */
131
 
        i=0;
132
 
        while(cfg[i].parameter != 0)
133
 
        {
134
 
                if(cfg[i].mandatory ==1)
135
 
                {
136
 
                        if(cfg[i].type == TYPE_INT)
137
 
                        {
138
 
/*                              pointer=(int *)cfg[i].variable;
139
 
                                if(*pointer==0)*/
140
 
                                if(*((int*)cfg[i].variable) == 0)
141
 
                                {
142
 
                                        fprintf(stderr,"Missing mandatory parameter [%s]\n", cfg[i].parameter);
143
 
                                        return  FAIL;
144
 
                                }
145
 
                        }
146
 
                        if(cfg[i].type == TYPE_STRING)
147
 
                        {
148
 
                                c=(char **)cfg[i].variable;
149
 
                                if(*c==NULL)
150
 
                                {
151
 
                                        fprintf(stderr, "Missing mandatory parameter [%s]\n", cfg[i].parameter);
152
 
                                        return  FAIL;
153
 
                                }
154
 
                        }
155
 
                }
156
 
                i++;
 
55
 
 
56
        static int level = 0;
 
57
 
 
58
#define ZBX_MAX_INCLUDE_LEVEL 10
 
59
 
 
60
#define ZBX_CFG_LTRIM_CHARS "\t "
 
61
#define ZBX_CFG_RTRIM_CHARS ZBX_CFG_LTRIM_CHARS "\r\n\0"
 
62
 
 
63
        register int
 
64
                i, lineno;
 
65
 
 
66
        char    
 
67
                line[MAX_STRING_LEN],
 
68
                *parameter,
 
69
                *value;
 
70
 
 
71
        int     var;
 
72
 
 
73
        int     result = SUCCEED;
 
74
 
 
75
        assert(cfg);
 
76
 
 
77
        if(++level > ZBX_MAX_INCLUDE_LEVEL)
 
78
        {
 
79
                /* Ignore include files of depth 10 */
 
80
                return result;
 
81
        }
 
82
 
 
83
        if(cfg_file)
 
84
        {
 
85
                if( NULL == (file = fopen(cfg_file,"r")) )
 
86
                {
 
87
                        goto lbl_cannot_open;
 
88
                }
 
89
                else
 
90
                {
 
91
                        for(lineno = 1; fgets(line,MAX_STRING_LEN,file) != NULL; lineno++)
 
92
                        {
 
93
                                zbx_ltrim(line, ZBX_CFG_LTRIM_CHARS);
 
94
 
 
95
                                if(line[0]=='#')        continue;
 
96
                                if(strlen(line) < 3)    continue;
 
97
 
 
98
                                parameter       = line;
 
99
 
 
100
                                value           = strstr(line,"=");
 
101
                                if(NULL == value)
 
102
                                {
 
103
                                        zbx_error("Error in line [%d] \"%s\"", lineno, line);
 
104
                                        result = FAIL;
 
105
                                        break;
 
106
                                }
 
107
 
 
108
                                *value = '\0';
 
109
                                value++;
 
110
 
 
111
                                zbx_rtrim(parameter, ZBX_CFG_RTRIM_CHARS);
 
112
 
 
113
                                zbx_ltrim(value, ZBX_CFG_LTRIM_CHARS);
 
114
                                zbx_rtrim(value, ZBX_CFG_RTRIM_CHARS);
 
115
 
 
116
                                zabbix_log(LOG_LEVEL_DEBUG, "cfg: para: [%s] val [%s]", parameter, value);
 
117
 
 
118
                                if(strcmp(parameter, "Include") == 0)
 
119
                                {
 
120
                                        parse_cfg_file(value, cfg);
 
121
                                }
 
122
 
 
123
                                for(i = 0; value[i] != '\0'; i++)
 
124
                                {
 
125
                                        if(value[i] == '\n')
 
126
                                        {
 
127
                                                value[i] = '\0';
 
128
                                                break;
 
129
                                        }
 
130
                                }
 
131
 
 
132
 
 
133
                                for(i = 0; cfg[i].parameter != 0; i++)
 
134
                                {
 
135
                                        if(strcmp(cfg[i].parameter, parameter))
 
136
                                                continue;
 
137
 
 
138
                                        zabbix_log(LOG_LEVEL_DEBUG, "Accepted configuration parameter: '%s' = '%s'",parameter, value);
 
139
 
 
140
                                        if(cfg[i].function != 0)
 
141
                                        {
 
142
                                                if(cfg[i].function(value) != SUCCEED)
 
143
                                                        goto lbl_incorrect_config;
 
144
                                        }
 
145
                                        else if(TYPE_INT == cfg[i].type)
 
146
                                        {
 
147
                                                var = atoi(value);
 
148
 
 
149
                                                if ( (cfg[i].min && var < cfg[i].min) ||
 
150
                                                        (cfg[i].max && var > cfg[i].max) )
 
151
                                                                goto lbl_incorrect_config;
 
152
 
 
153
                                                *((int*)cfg[i].variable) = var;
 
154
                                        }
 
155
                                        else
 
156
                                        {
 
157
                                                *((char **)cfg[i].variable) = strdup(value);
 
158
                                        }
 
159
                                }
 
160
                        }
 
161
                        fclose(file);
 
162
                }
 
163
        }
 
164
 
 
165
        /* Check for mandatory parameters */
 
166
        for(i = 0; cfg[i].parameter != 0; i++)
 
167
        {
 
168
                if(PARM_MAND != cfg[i].mandatory)
 
169
                        continue;
 
170
 
 
171
                if(TYPE_INT == cfg[i].type)
 
172
                {
 
173
                        if(*((int*)cfg[i].variable) == 0)
 
174
                                goto lbl_missing_mandatory;
 
175
                }
 
176
                else if(TYPE_STRING == cfg[i].type)
 
177
                {
 
178
                        if((*(char **)cfg[i].variable) == NULL)
 
179
                                goto lbl_missing_mandatory;
 
180
                }
157
181
        }
158
182
 
159
183
        return  SUCCEED;
 
184
 
 
185
lbl_cannot_open:
 
186
        zbx_error("Cannot open config file [%s] [%s].",cfg_file,strerror(errno));
 
187
        exit(1);
 
188
 
 
189
lbl_missing_mandatory:
 
190
        zbx_error("Missing mandatory parameter [%s].", cfg[i].parameter);
 
191
        exit(1);
 
192
 
 
193
lbl_incorrect_config:
 
194
        zbx_error("Wrong value of [%s] in line %d.", cfg[i].parameter, lineno);
 
195
        exit(1);
160
196
}