← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/libs/zbxsysinfo/osx/diskio.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/zbxsysinfo/osx/diskio.c
17
17
** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
18
**/
19
19
 
20
 
#include "config.h"
21
 
 
22
20
#include "common.h"
 
21
 
23
22
#include "sysinfo.h"
24
23
 
25
 
static int      DISKREADOPS1(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
26
 
{
27
 
        char    key[MAX_STRING_LEN];
28
 
 
29
 
        snprintf(key,sizeof(key)-1,"disk_read_ops1[%s]",param);
30
 
 
31
 
        return  get_stat(key, flags, result);
32
 
}
33
 
 
34
 
static int      DISKREADOPS5(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
35
 
{
36
 
        char    key[MAX_STRING_LEN];
37
 
 
38
 
        snprintf(key,sizeof(key)-1,"disk_read_ops5[%s]",param);
39
 
 
40
 
        return  get_stat(key, flags, result);
41
 
}
42
 
 
43
 
static int      DISKREADOPS15(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
44
 
{
45
 
        char    key[MAX_STRING_LEN];
46
 
 
47
 
        snprintf(key,sizeof(key)-1,"disk_read_ops15[%s]",param);
48
 
 
49
 
        return  get_stat(key, flags, result);
50
 
}
51
 
 
52
 
static int      DISKREADBLKS1(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
53
 
{
54
 
        char    key[MAX_STRING_LEN];
55
 
 
56
 
        snprintf(key,sizeof(key)-1,"disk_read_blks1[%s]",param);
57
 
 
58
 
        return  get_stat(key, flags, result);
59
 
}
60
 
 
61
 
static int      DISKREADBLKS5(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
62
 
{
63
 
        char    key[MAX_STRING_LEN];
64
 
 
65
 
        snprintf(key,sizeof(key)-1,"disk_read_blks5[%s]",param);
66
 
 
67
 
        return  get_stat(key, flags, result);
68
 
}
69
 
 
70
 
static int      DISKREADBLKS15(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
71
 
{
72
 
        char    key[MAX_STRING_LEN];
73
 
 
74
 
        snprintf(key,sizeof(key)-1,"disk_read_blks15[%s]",param);
75
 
 
76
 
        return  get_stat(key, flags, result);
77
 
}
78
 
 
79
 
static int      DISKWRITEOPS1(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
80
 
{
81
 
        char    key[MAX_STRING_LEN];
82
 
 
83
 
        snprintf(key,sizeof(key)-1,"disk_write_ops1[%s]",param);
84
 
 
85
 
        return  get_stat(key, flags, result);
86
 
}
87
 
 
88
 
static int      DISKWRITEOPS5(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
89
 
{
90
 
        char    key[MAX_STRING_LEN];
91
 
 
92
 
        snprintf(key,sizeof(key)-1,"disk_write_ops5[%s]",param);
93
 
 
94
 
        return  get_stat(key, flags, result);
95
 
}
96
 
 
97
 
static int      DISKWRITEOPS15(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
98
 
{
99
 
        char    key[MAX_STRING_LEN];
100
 
 
101
 
        snprintf(key,sizeof(key)-1,"disk_write_ops15[%s]",param);
102
 
 
103
 
        return  get_stat(key, flags, result);
104
 
}
105
 
 
106
 
static int      DISKWRITEBLKS1(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
107
 
{
108
 
        char    key[MAX_STRING_LEN];
109
 
 
110
 
        snprintf(key,sizeof(key)-1,"disk_write_blks1[%s]",param);
111
 
 
112
 
        return  get_stat(key, flags, result);
113
 
}
114
 
 
115
 
static int      DISKWRITEBLKS5(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
116
 
{
117
 
        char    key[MAX_STRING_LEN];
118
 
 
119
 
        snprintf(key,sizeof(key)-1,"disk_write_blks5[%s]",param);
120
 
 
121
 
        return  get_stat(key, flags, result);
122
 
}
123
 
 
124
 
static int      DISKWRITEBLKS15(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
125
 
{
126
 
        char    key[MAX_STRING_LEN];
127
 
 
128
 
        snprintf(key,sizeof(key)-1,"disk_write_blks15[%s]",param);
129
 
 
130
 
        return  get_stat(key, flags, result);
131
 
}
132
 
 
133
24
int     VFS_DEV_WRITE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
134
25
{
135
 
 
136
 
#define DEV_FNCLIST struct dev_fnclist_s
137
 
DEV_FNCLIST
138
 
{
139
 
        char *type;
140
 
        char *mode;
141
 
        int (*function)();
142
 
};
143
 
 
144
 
        DEV_FNCLIST fl[] = 
145
 
        {
146
 
                {"ops", "avg1" ,        DISKWRITEOPS1},
147
 
                {"ops", "avg5" ,        DISKWRITEOPS5},
148
 
                {"ops", "avg15",        DISKWRITEOPS15},
149
 
                {"bps", "avg1" ,        DISKWRITEBLKS1},
150
 
                {"bps", "avg5" ,        DISKWRITEBLKS5},
151
 
                {"bps", "avg15",        DISKWRITEBLKS15},
152
 
                {0,     0,              0}
153
 
        };
154
 
 
 
26
#ifndef TODO
 
27
        return SYSINFO_RET_FAIL; 
 
28
#else
 
29
        /* !!!TODO!!! */
155
30
        char devname[MAX_STRING_LEN];
156
31
        char type[MAX_STRING_LEN];
157
32
        char mode[MAX_STRING_LEN];
158
 
        int i;
159
33
        
160
34
        assert(result);
161
35
 
166
40
                return SYSINFO_RET_FAIL;
167
41
        }
168
42
 
169
 
        if(get_param(param, 1, devname, MAX_STRING_LEN) != 0)
 
43
        if(get_param(param, 1, devname, sizeof(devname)) != 0)
170
44
        {
171
45
                return SYSINFO_RET_FAIL;
172
46
        }
173
47
        
174
 
        if(get_param(param, 2, type, MAX_STRING_LEN) != 0)
 
48
        if(get_param(param, 2, type, sizeof(type)) != 0)
175
49
        {
176
50
                type[0] = '\0';
177
51
        }
178
52
        if(type[0] == '\0')
179
53
        {
180
54
                /* default parameter */
181
 
                sprintf(type, "bps");
 
55
                zbx_snprintf(type, sizeof(type), "bps");
182
56
        }
183
57
        
184
 
        if(get_param(param, 3, mode, MAX_STRING_LEN) != 0)
 
58
        if(get_param(param, 3, mode, sizeof(mode)) != 0)
185
59
        {
186
60
                mode[0] = '\0';
187
61
        }
189
63
        if(mode[0] == '\0')
190
64
        {
191
65
                /* default parameter */
192
 
                sprintf(mode, "avg1");
193
 
        }
194
 
        
195
 
        for(i=0; fl[i].type!=0; i++)
196
 
        {
197
 
                if(strncmp(type, fl[i].type, MAX_STRING_LEN)==0)
198
 
                {
199
 
                        if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
200
 
                        {
201
 
                                return (fl[i].function)(cmd, devname, flags, result);
202
 
                        }
203
 
                }
204
 
        }
205
 
        
206
 
        return SYSINFO_RET_FAIL;
 
66
                zbx_snprintf(mode, sizeof(mode), "avg1");
 
67
        }
 
68
 
 
69
        if(NULL == collector)
 
70
        {
 
71
                SET_MSG_RESULT(result, strdup("Collector is not started!"));
 
72
                return SYSINFO_RET_OK;
 
73
        }
 
74
 
 
75
        if( 0 == strcmp(type,"ops"))
 
76
        {
 
77
                if( 0 == strcmp(mode,"avg1"))           SET_DBL_RESULT(result, collector->diskdevices.XXX1)
 
78
                else if( 0 == strcmp(mode,"avg5"))      SET_DBL_RESULT(result, collector->diskdevices.XXX5)
 
79
                else if( 0 == strcmp(mode,"avg15"))     SET_DBL_RESULT(result, collector->diskdevices.XXX15)
 
80
                else return SYSINFO_RET_FAIL;
 
81
 
 
82
        }
 
83
        else if( 0 == strcmp(type,"bps"))
 
84
        {
 
85
                if( 0 == strcmp(mode,"avg1"))           SET_DBL_RESULT(result, collector->diskdevices.XXX1)
 
86
                else if( 0 == strcmp(mode,"avg5"))      SET_DBL_RESULT(result, collector->diskdevices.XXX5)
 
87
                else if( 0 == strcmp(mode,"avg15"))     SET_DBL_RESULT(result, collector->diskdevices.XXX15)
 
88
                else return SYSINFO_RET_FAIL;
 
89
 
 
90
        }
 
91
        else
 
92
        {
 
93
                return SYSINFO_RET_FAIL;
 
94
        }
 
95
 
 
96
        return SYSINFO_RET_OK;
 
97
#endif /* TODO */
207
98
}
208
99
 
209
100
int     VFS_DEV_READ(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
210
101
{
211
 
 
212
 
#define DEV_FNCLIST struct dev_fnclist_s
213
 
DEV_FNCLIST
214
 
{
215
 
        char *type;
216
 
        char *mode;
217
 
        int (*function)();
218
 
};
219
 
 
220
 
        DEV_FNCLIST fl[] = 
221
 
        {
222
 
                {"ops", "avg1" ,        DISKREADOPS1},
223
 
                {"ops", "avg5" ,        DISKREADOPS5},
224
 
                {"ops", "avg15",        DISKREADOPS15},
225
 
                {"bps", "avg1" ,        DISKREADBLKS1},
226
 
                {"bps", "avg5" ,        DISKREADBLKS5},
227
 
                {"bps", "avg15",        DISKREADBLKS15},
228
 
                {0,     0,              0}
229
 
        };
230
 
 
 
102
#ifndef TODO
 
103
        return SYSINFO_RET_FAIL; 
 
104
#else
 
105
        /* !!!TODO!!! */
231
106
        char devname[MAX_STRING_LEN];
232
107
        char type[MAX_STRING_LEN];
233
108
        char mode[MAX_STRING_LEN];
234
 
        int i;
235
109
        
236
110
        assert(result);
237
111
 
242
116
                return SYSINFO_RET_FAIL;
243
117
        }
244
118
 
245
 
        if(get_param(param, 1, devname, MAX_STRING_LEN) != 0)
 
119
        if(get_param(param, 1, devname, sizeof(devname)) != 0)
246
120
        {
247
121
                return SYSINFO_RET_FAIL;
248
122
        }
249
123
        
250
 
        if(get_param(param, 2, type, MAX_STRING_LEN) != 0)
 
124
        if(get_param(param, 2, type, sizeof(type)) != 0)
251
125
        {
252
126
                type[0] = '\0';
253
127
        }
254
128
        if(type[0] == '\0')
255
129
        {
256
130
                /* default parameter */
257
 
                sprintf(type, "bps");
 
131
                zbx_snprintf(type, sizeof(type), "bps");
258
132
        }
259
133
        
260
 
        if(get_param(param, 3, mode, MAX_STRING_LEN) != 0)
 
134
        if(get_param(param, 3, mode, sizeof(mode)) != 0)
261
135
        {
262
136
                mode[0] = '\0';
263
137
        }
265
139
        if(mode[0] == '\0')
266
140
        {
267
141
                /* default parameter */
268
 
                sprintf(mode, "avg1");
269
 
        }
270
 
        
271
 
        for(i=0; fl[i].type!=0; i++)
272
 
        {
273
 
                if(strncmp(type, fl[i].type, MAX_STRING_LEN)==0)
274
 
                {
275
 
                        if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
276
 
                        {
277
 
                                return (fl[i].function)(cmd, devname, flags, result);
278
 
                        }
279
 
                }
280
 
        }
281
 
        
282
 
        return SYSINFO_RET_FAIL;
 
142
                zbx_snprintf(mode, sizeof(mode), "avg1");
 
143
        }
 
144
 
 
145
        if(NULL == collector)
 
146
        {
 
147
                SET_MSG_RESULT(result, strdup("Collector is not started!"));
 
148
                return SYSINFO_RET_OK;
 
149
        }
 
150
 
 
151
        if( 0 == strcmp(type,"ops"))
 
152
        {
 
153
                if( 0 == strcmp(mode,"avg1"))           SET_DBL_RESULT(result, collector->diskdevices.XXX1)
 
154
                else if( 0 == strcmp(mode,"avg5"))      SET_DBL_RESULT(result, collector->diskdevices.XXX5)
 
155
                else if( 0 == strcmp(mode,"avg15"))     SET_DBL_RESULT(result, collector->diskdevices.XXX15)
 
156
                else return SYSINFO_RET_FAIL;
 
157
 
 
158
        }
 
159
        else if( 0 == strcmp(type,"bps"))
 
160
        {
 
161
                if( 0 == strcmp(mode,"avg1"))           SET_DBL_RESULT(result, collector->diskdevices.XXX1)
 
162
                else if( 0 == strcmp(mode,"avg5"))      SET_DBL_RESULT(result, collector->diskdevices.XXX5)
 
163
                else if( 0 == strcmp(mode,"avg15"))     SET_DBL_RESULT(result, collector->diskdevices.XXX15)
 
164
                else return SYSINFO_RET_FAIL;
 
165
 
 
166
        }
 
167
        else
 
168
        {
 
169
                return SYSINFO_RET_FAIL;
 
170
        }
 
171
 
 
172
        return SYSINFO_RET_OK;
 
173
#endif /* TODO */
283
174
}
284
175
 
285
176
static int      DISK_IO(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
341
232
                return SYSINFO_RET_FAIL;
342
233
        }
343
234
 
344
 
        if(get_param(param, 1, key, MAX_STRING_LEN) != 0)
 
235
        if(get_param(param, 1, key, sizeof(key)) != 0)
345
236
        {
346
237
                return SYSINFO_RET_FAIL;
347
238
        }