← Back to branch summary

~ubuntu-branches/ubuntu/trusty/net-snmp/trusty

« back to all changes in this revision

Viewing changes to agent/mibgroup/Rmon/agutil.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2004-09-13 12:06:21 UTC
  • Revision ID: james.westby@ubuntu.com-20040913120621-g952ntonlleihcvm
Tags: upstream-5.1.1
Import upstream version 5.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
agent/mibgroup/Rmon/agutil.c
 
1
/**************************************************************
 
2
 * Copyright (C) 2001 Alex Rozin, Optical Access 
 
3
 *
 
4
 *                     All Rights Reserved
 
5
 *
 
6
 * Permission to use, copy, modify and distribute this software and its
 
7
 * documentation for any purpose and without fee is hereby granted,
 
8
 * provided that the above copyright notice appear in all copies and that
 
9
 * both that copyright notice and this permission notice appear in
 
10
 * supporting documentation.
 
11
 * 
 
12
 * ALEX ROZIN DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
 
13
 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
 
14
 * ALEX ROZIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
 
15
 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 
16
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 
17
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 
18
 * SOFTWARE.
 
19
 ******************************************************************/
 
20
 
 
21
#include <net-snmp/net-snmp-config.h>
 
22
#include <net-snmp/net-snmp-includes.h>
 
23
#include <net-snmp/agent/net-snmp-agent-includes.h>
 
24
 
 
25
#include "util_funcs.h"
 
26
 
 
27
#include "agutil.h"
 
28
#include "agutil_api.h"
 
29
 
 
30
#ifndef OPTICALL_ACESS          /* in OpticalAccess case : find them in ~agent/mibgroup/nbase directory */
 
31
void
 
32
ag_trace(const char *format, ...)
 
33
{
 
34
#define AG_MAX_MSG_LEN  120
 
35
    char            msg[AG_MAX_MSG_LEN];
 
36
    va_list         args;
 
37
 
 
38
    /*
 
39
     * create msg 
 
40
     */
 
41
    va_start(args, format);
 
42
    vsnprintf(msg, AG_MAX_MSG_LEN - 1, format, args);
 
43
 
 
44
    snmp_log(LOG_INFO, "%s\n", msg);
 
45
    va_end(args);
 
46
}
 
47
 
 
48
int
 
49
AGUTIL_advance_index_name(struct variable *vp, oid * name,
 
50
                          size_t * length, int exact)
 
51
{
 
52
    int             result;
 
53
 
 
54
    if (exact)
 
55
        return 0;
 
56
 
 
57
    if (*length <= vp->namelen) {
 
58
        result =
 
59
            snmp_oid_compare(name, *length, vp->name, (int) vp->namelen);
 
60
        memcpy((char *) name, (char *) vp->name,
 
61
               ((int) vp->namelen) * sizeof(oid));
 
62
        *length = vp->namelen;
 
63
    } else {
 
64
        /*
 
65
         * If the name is given with indexes - compare only the oids. 
 
66
         */
 
67
        result =
 
68
            snmp_oid_compare(name, (int) vp->namelen, vp->name,
 
69
                             (int) vp->namelen);
 
70
        /*
 
71
         * If it's not the same oid - change name to the new oid 
 
72
         */
 
73
        if (result < 0) {
 
74
            memcpy((char *) name, (char *) vp->name,
 
75
                   ((int) vp->namelen) * sizeof(oid));
 
76
            *length = vp->namelen;
 
77
        }
 
78
    }
 
79
 
 
80
    if (result > 0) {
 
81
        ag_trace("*length=%d result=%d !!!", (int) *length, (int) result);
 
82
        return -1;
 
83
    }
 
84
    return 0;
 
85
}
 
86
 
 
87
/*********************************************************************
 
88
 * Function: AGUTIL_get_int_value
 
89
 *
 
90
 * Description:
 
91
 *   Check/Get long value from the PDU..
 
92
 *   The parameters 'min_value' & 'max_value' allow to check the diaposon
 
93
 *   of the value. If (max_value <= min_value) we avoid this checking.
 
94
 *
 
95
 * Returns:
 
96
 *   SNMP_ERR_NOERROR
 
97
 *   SNMP_ERR_WRONGTYPE
 
98
 *   SNMP_ERR_WRONGLENGTH
 
99
 *   SNMP_ERR_WRONGENCODING
 
100
 *   SNMP_ERR_BADVALUE
 
101
 *********************************************************************/
 
102
int
 
103
AGUTIL_get_int_value(u_char * var_val, u_char var_val_type,
 
104
                     size_t var_val_len, long min_value, long max_value,
 
105
                     long *long_tmp)
 
106
{
 
107
    if (var_val_type != ASN_INTEGER && var_val_type != ASN_TIMETICKS) {
 
108
        ag_trace("not ASN_INTEGER 0x%lx", (long) var_val_type);
 
109
        return SNMP_ERR_WRONGTYPE;
 
110
    }
 
111
 
 
112
    if (var_val_len > sizeof(long)) {
 
113
        ag_trace("wrong len=%d", (int) var_val_len);
 
114
        return SNMP_ERR_WRONGLENGTH;
 
115
    }
 
116
 
 
117
    *long_tmp = *((long *) var_val);
 
118
 
 
119
    if (max_value > min_value) {
 
120
        if (*long_tmp < min_value) {
 
121
            ag_trace("%ld=long_tmp < min=%ld", (long) *long_tmp,
 
122
                     (long) min_value);
 
123
            return SNMP_ERR_BADVALUE;
 
124
        }
 
125
 
 
126
        if (*long_tmp > max_value) {
 
127
            ag_trace("%ld=long_tmp > max=%ld", (long) *long_tmp,
 
128
                     (long) max_value);
 
129
            return SNMP_ERR_BADVALUE;
 
130
        }
 
131
    }
 
132
 
 
133
    return SNMP_ERR_NOERROR;
 
134
}
 
135
 
 
136
 
 
137
/*********************************************************************
 
138
 * Function: AGUTIL_get_string_value
 
139
 *
 
140
 * Description:
 
141
 *   Check/Get 'DisplayString' value from the PDU..
 
142
 *
 
143
 * Returns:
 
144
 *   SNMP_ERR_NOERROR
 
145
 *   SNMP_ERR_WRONGTYPE
 
146
 *   SNMP_ERR_WRONGLENGTH
 
147
 *   SNMP_ERR_WRONGENCODING
 
148
 *   SNMP_ERR_BADVALUE
 
149
 *********************************************************************/
 
150
int
 
151
AGUTIL_get_string_value(u_char * var_val, u_char var_val_type,
 
152
                        size_t var_val_len, size_t buffer_max_size,
 
153
                        u_char should_zero_limited,
 
154
                        size_t * buffer_actual_size, char *buffer)
 
155
{
 
156
    if (var_val_type != ASN_OCTET_STR) {
 
157
        ag_trace("not ASN_OCTET_STR 0x%lx", (long) var_val_type);
 
158
        return SNMP_ERR_WRONGTYPE;
 
159
    }
 
160
 
 
161
    if (var_val_len > buffer_max_size) {
 
162
        ag_trace("wrong len=%d > %d", (int) var_val_len, buffer_max_size);
 
163
        return SNMP_ERR_WRONGLENGTH;
 
164
    }
 
165
 
 
166
    if (buffer_actual_size)
 
167
        *buffer_actual_size = var_val_len;
 
168
 
 
169
    memcpy(buffer, var_val, var_val_len);
 
170
    if (should_zero_limited) {
 
171
        buffer[var_val_len] = 0;
 
172
        if (buffer_actual_size)
 
173
            *buffer_actual_size += 1;
 
174
    }
 
175
 
 
176
    return SNMP_ERR_NOERROR;
 
177
}
 
178
 
 
179
#endif
 
180
 
 
181
int
 
182
AGUTIL_get_oid_value(u_char * var_val, u_char var_val_type,
 
183
                     size_t var_val_len, VAR_OID_T * data_source_ptr)
 
184
{
 
185
    register int    iii;
 
186
    register oid   *oid_var;
 
187
 
 
188
    if (var_val_len > MAX_OID_LEN) {
 
189
        ag_trace("wrong len=%d > %d", (int) var_val_len, MAX_OID_LEN);
 
190
        return SNMP_ERR_WRONGLENGTH;
 
191
    }
 
192
 
 
193
    var_val_len /= sizeof(oid);
 
194
    data_source_ptr->length = var_val_len;
 
195
    oid_var = (oid *) var_val;
 
196
    for (iii = 0; iii < (int)data_source_ptr->length; iii++)
 
197
        data_source_ptr->objid[iii] = oid_var[iii];
 
198
 
 
199
    return SNMP_ERR_NOERROR;
 
200
}
 
201
 
 
202
u_long
 
203
AGUTIL_sys_up_time(void)
 
204
{
 
205
    struct timeval  current, delta;
 
206
    extern struct timeval starttime;
 
207
 
 
208
    gettimeofday(&current, NULL);
 
209
    current.tv_sec--;
 
210
    current.tv_usec += 1000000L;
 
211
    delta.tv_sec = current.tv_sec - starttime.tv_sec;
 
212
    delta.tv_usec = current.tv_usec - starttime.tv_usec;
 
213
    if (delta.tv_usec > 1000000L) {
 
214
        delta.tv_usec -= 1000000L;
 
215
        delta.tv_sec++;
 
216
    }
 
217
 
 
218
    return delta.tv_sec * 100 + delta.tv_usec / 10000;
 
219
}
 
220
 
 
221
/*
 
222
 * NOTE: this function is a template for system dependent
 
223
 * implementation. Actually it (in debug purposes) returns
 
224
 * random (but likely) data */
 
225
void
 
226
SYSTEM_get_eth_statistics(VAR_OID_T * data_source, ETH_STATS_T * where)
 
227
{
 
228
#if OPTICALL_ACESS
 
229
    where->ifIndex = data_source->objid[data_source->length - 1];
 
230
    agent_get_Rmon_ethernet_statistics(where->ifIndex, 1,       /* exact */
 
231
                                       where);
 
232
#else                           /* OPTICALL_ACESS */
 
233
    static ETH_STATS_T prev = { -1, -1 };
 
234
    static time_t   ifLastRead = 0;
 
235
    time_t          curr_time;
 
236
    u_char          need_to_read;
 
237
    u_long          rc;
 
238
 
 
239
    where->ifIndex = data_source->objid[data_source->length - 1];
 
240
    need_to_read = (where->ifIndex != prev.ifIndex);
 
241
    if (!need_to_read) {
 
242
        curr_time = time(NULL);
 
243
        need_to_read = (curr_time - ifLastRead > 1);
 
244
    }
 
245
 
 
246
    if (need_to_read) {
 
247
        rc = (u_long) (1.0 +
 
248
                       ((double) rand() / (double) RAND_MAX) * 100.0);
 
249
        ifLastRead = time(NULL);
 
250
        prev.ifIndex = where->ifIndex;
 
251
    } else
 
252
        rc = 0;
 
253
 
 
254
    memcpy(where, &prev, sizeof(ETH_STATS_T));
 
255
    where->octets += rc * 100 * 200;
 
256
    where->packets += rc * 100;
 
257
    where->bcast_pkts += rc * 2;
 
258
    where->mcast_pkts += rc * 3;
 
259
    where->crc_align += rc;
 
260
    where->undersize += 0;
 
261
    where->oversize += 0;
 
262
    where->fragments += rc / 2;
 
263
    where->jabbers += 0;
 
264
    where->collisions += rc / 4;
 
265
 
 
266
    where->pkts_64 += rc * 10;
 
267
    where->pkts_65_127 += rc * 50;
 
268
    where->pkts_128_255 += rc * 20;
 
269
    where->pkts_256_511 += rc * 10;
 
270
    where->pkts_512_1023 += rc * 15;
 
271
    where->pkts_1024_1518 += rc * 5;
 
272
 
 
273
    need_to_read = prev.ifIndex;
 
274
    memcpy(&prev, where, sizeof(ETH_STATS_T));
 
275
    prev.ifIndex = need_to_read;
 
276
#endif                          /* OPTICALL_ACESS */
 
277
}
 
278
 
 
279
#if 0                           /* for memory debug */
 
280
static u_long   dbg_mem_cnt = 0;
 
281
 
 
282
void           *
 
283
dbg_f_AGMALLOC(size_t size)
 
284
{
 
285
    dbg_mem_cnt++;
 
286
    return malloc(size);
 
287
}
 
288
 
 
289
void
 
290
dbg_f_AGFREE(void *ptr)
 
291
{
 
292
    dbg_mem_cnt--;
 
293
    free(ptr);
 
294
}
 
295
 
 
296
char           *
 
297
dbg_f_AGSTRDUP(const char *s)
 
298
{
 
299
    dbg_mem_cnt++;
 
300
    return strdup(s);
 
301
}
 
302
 
 
303
void
 
304
dbg_f_AG_MEM_REPORT(void)
 
305
{
 
306
    ag_trace("dbg_mem_cnt=%ld", (long) dbg_mem_cnt);
 
307
}
 
308
 
 
309
#endif
 
310
 
 
311
void
 
312
init_agutil(void)
 
313
{
 
314
}