1 diff -ruN net-snmp-5.2.1.2.orig/snmplib/asn1.c net-snmp-5.2.1.2/snmplib/asn1.c
2 --- net-snmp-5.2.1.2.orig/snmplib/asn1.c 2004-12-10 15:07:16.000000000 +0000
3 +++ net-snmp-5.2.1.2/snmplib/asn1.c 2007-02-17 23:54:03.000000000 +0000
6 value = (value << 8) | *bufp++;
8 +/*#if SIZEOF_LONG != 4
9 + if ((unsigned long)value > 0xffffffff) {
10 + snmp_log(LOG_ERR,"truncating integer value to 32 bits\n");
11 + value &= 0xffffffff;
15 DEBUGMSG(("dumpv_recv", " Integer:\t%ld (0x%.2X)\n", value, value));
20 value = (value << 8) | *bufp++;
23 + if (value > 0xffffffff) {
24 + snmp_log(LOG_ERR,"truncating uinteger value to 32 bits\n");
25 + value &= 0xffffffff;
29 DEBUGMSG(("dumpv_recv", " UInteger:\t%ld (0x%.2X)\n", value, value));
37 + if ((unsigned long)integer > 0xffffffff) {
38 + snmp_log(LOG_ERR,"truncating integer value to 32 bits\n");
39 + integer &= 0xffffffff;
43 * Truncate "unnecessary" bytes off of the most significant end of this
44 * 2's complement integer. There should be no sequence of 9
50 + if (integer > 0xffffffff) {
51 + snmp_log(LOG_ERR,"truncating uinteger value to 32 bits\n");
52 + integer &= 0xffffffff;
55 mask = ((u_long) 0xFF) << (8 * (sizeof(long) - 1));
57 * mask is 0xFF000000 on a big-endian machine
58 @@ -1286,18 +1312,13 @@
59 (subidentifier << 7) + (*(u_char *) bufp & ~ASN_BIT8);
61 } while (*(u_char *) bufp++ & ASN_BIT8); /* last byte has high bit clear */
63 - * ?? note, this test will never be true, since the largest value
64 - * of subidentifier is the value of MAX_SUBID!
66 - * Yes: PC-LINT says the same thing
67 - * No!: the agent can be configured to use a char instead of a long
68 - * for OIDs, in which case this test is essential.
71 +#if defined(EIGHTBIT_SUBIDS) || (SIZEOF_LONG != 4)
72 if (subidentifier > (u_long) MAX_SUBID) {
73 ERROR_MSG("subidentifier too large");
77 *oidp++ = (oid) subidentifier;
80 @@ -1439,6 +1460,12 @@
81 if (i >= (int) objidlength)
83 objid_val = *op++; /* XXX - doesn't handle 2.X (X > 40) */
85 + if (objid_val > 0xffffffff) {
86 + snmp_log(LOG_ERR,"truncating objid value to 32 bits\n");
87 + objid_val &= 0xffffffff;
93 @@ -1454,8 +1481,13 @@
95 for (i = 1, objid_val = first_objid_val, op = objid + 2;
96 i < (int) objidlength; i++) {
100 +#if SIZEOF_LONG != 4
101 + if (objid_val > 0xffffffff) /* already logged warning above */
102 + objid_val &= 0xffffffff;
105 switch (objid_size[i]) {
107 *data++ = (u_char) objid_val;
108 @@ -1783,6 +1815,17 @@
109 low = (low << 8) | *bufp++;
112 +#if SIZEOF_LONG != 4
113 + if (high > 0xffffffff) {
114 + snmp_log(LOG_ERR,"truncating counter64 high value to 32 bits\n");
115 + high &= 0xffffffff;
117 + if (low > 0xffffffff) {
118 + snmp_log(LOG_ERR,"truncating counter64 low value to 32 bits\n");
126 @@ -1843,6 +1886,16 @@
130 +#if SIZEOF_LONG != 4
131 + if (high > 0xffffffff) {
132 + snmp_log(LOG_ERR,"truncating counter64 high value to 32 bits\n");
133 + high &= 0xffffffff;
135 + if (low > 0xffffffff) {
136 + snmp_log(LOG_ERR,"truncating counter64 low value to 32 bits\n");
140 mask = ((u_long) 0xFF) << (8 * (sizeof(long) - 1));
142 * mask is 0xFF000000 on a big-endian machine
143 @@ -2041,6 +2094,17 @@
144 low = (low << 8) | *bufp++;
147 +#if SIZEOF_LONG != 4
148 + if (high > 0xffffffff) {
149 + snmp_log(LOG_ERR,"truncating counter64 high value to 32 bits\n");
150 + high &= 0xffffffff;
152 + if (low > 0xffffffff) {
153 + snmp_log(LOG_ERR,"truncating counter64 low value to 32 bits\n");
161 @@ -2103,6 +2167,16 @@
162 memcpy(&c64, cp, sizeof(struct counter64)); /* we're may modify it */
165 +#if SIZEOF_LONG != 4
166 + if (high > 0xffffffff) {
167 + snmp_log(LOG_ERR,"truncating counter64 high value to 32 bits\n");
168 + high &= 0xffffffff;
170 + if (low > 0xffffffff) {
171 + snmp_log(LOG_ERR,"truncating counter64 low value to 32 bits\n");
177 * Truncate "unnecessary" bytes off of the most significant end of this
178 @@ -2673,6 +2747,12 @@
179 _asn_size_err(errpre, intsize, sizeof(long));
182 +#if SIZEOF_LONG != 4
183 + if ((unsigned long)integer > 0xffffffff) {
184 + snmp_log(LOG_ERR,"truncating integer value to 32 bits\n");
185 + integer &= 0xffffffff;
189 if (((*pkt_len - *offset) < 1) && !(r && asn_realloc(pkt, pkt_len))) {
191 @@ -2825,6 +2905,13 @@
195 +#if SIZEOF_LONG != 4
196 + if (integer > 0xffffffff) {
197 + snmp_log(LOG_ERR,"truncating uinteger value to 32 bits\n");
198 + integer &= 0xffffffff;
202 if (((*pkt_len - *offset) < 1) && !(r && asn_realloc(pkt, pkt_len))) {
205 @@ -2960,6 +3047,12 @@
207 for (i = objidlength; i > 2; i--) {
208 tmpint = objid[i - 1];
209 +#if SIZEOF_LONG != 4
210 + if ((unsigned long)tmpint > 0xffffffff) {
211 + snmp_log(LOG_ERR,"truncating oid subid to 32 bits\n");
212 + tmpint &= 0xffffffff;
216 if (((*pkt_len - *offset) < 1)
217 && !(r && asn_realloc(pkt, pkt_len))) {
218 @@ -3176,6 +3269,16 @@
219 sizeof(struct counter64));
222 +#if SIZEOF_LONG != 4
223 + if (high > 0xffffffff) {
224 + snmp_log(LOG_ERR,"truncating counter64 high value to 32 bits\n");
225 + high &= 0xffffffff;
227 + if (low > 0xffffffff) {
228 + snmp_log(LOG_ERR,"truncating counter64 low value to 32 bits\n");
234 * Encode the low 4 bytes first.
235 @@ -3359,6 +3462,17 @@
239 +#if SIZEOF_LONG != 4
240 + if (high > 0xffffffff) {
241 + snmp_log(LOG_ERR,"truncating counter64 high value to 32 bits\n");
242 + high &= 0xffffffff;
244 + if (low > 0xffffffff) {
245 + snmp_log(LOG_ERR,"truncating counter64 low value to 32 bits\n");
251 * Encode the low 4 bytes first.
253 diff -ruN net-snmp-5.2.1.2.orig/snmplib/int64.c net-snmp-5.2.1.2/snmplib/int64.c
254 --- net-snmp-5.2.1.2.orig/snmplib/int64.c 2004-07-11 04:28:45.000000000 +0000
255 +++ net-snmp-5.2.1.2/snmplib/int64.c 2007-02-17 23:54:03.000000000 +0000
258 pu64->low = (ulT1 + u16) & 0x0FFFFFFFFL;
261 +#if SIZEOF_LONG != 4
262 + pu64->high &= 0xffffffff;
271 - if (pu64->low < tmp)
272 +#if SIZEOF_LONG != 4
273 + pu64->low &= 0xffffffff;
275 + if (pu64->low < tmp) {
277 +#if SIZEOF_LONG != 4
278 + pu64->high &= 0xffffffff;
285 u64Incr(U64 * pu64out, const U64 * pu64one)
287 pu64out->high += pu64one->high;
288 +#if SIZEOF_LONG != 4
289 + pu64out->high &= 0xffffffff;
291 incrByU32(pu64out, pu64one->low);
304 if (new_val->high == old_val->high) {
305 DEBUGMSGTL(("c64:check_wrap", "32 bit wrap\n"));
309 +#if SIZEOF_LONG != 4
310 + new_val->high &= 0xffffffff;
315 else if ((new_val->high == (old_val->high + 1)) ||
316 diff -ruN net-snmp-5.2.1.2.orig/snmplib/snmp_client.c net-snmp-5.2.1.2/snmplib/snmp_client.c
317 --- net-snmp-5.2.1.2.orig/snmplib/snmp_client.c 2004-12-10 02:21:38.000000000 +0000
318 +++ net-snmp-5.2.1.2/snmplib/snmp_client.c 2007-02-17 23:54:43.000000000 +0000
321 #include <net-snmp/library/snmp_api.h>
322 #include <net-snmp/library/snmp_client.h>
323 +#include <net-snmp/library/snmp_logging.h>
324 #include <net-snmp/library/snmp_secmod.h>
325 #include <net-snmp/library/mib.h>
327 @@ -714,41 +715,193 @@
331 -snmp_set_var_value(netsnmp_variable_list * newvar,
332 - const u_char * val_str, size_t val_len)
333 +snmp_set_var_value(netsnmp_variable_list * vars,
334 + const u_char * value, size_t len)
339 * xxx-rks: why the unconditional free? why not use existing
340 - * memory, if val_len < newvar->val_len ?
341 + * memory, if len < vars->val_len ?
343 - if (newvar->val.string && newvar->val.string != newvar->buf) {
344 - free(newvar->val.string);
345 + if (vars->val.string && vars->val.string != vars->buf) {
346 + free(vars->val.string);
349 - newvar->val.string = 0;
350 - newvar->val_len = 0;
351 + vars->val.string = 0;
355 - * need a pointer and a length to copy a string value.
356 + * use built-in storage for smaller values
358 - if (val_str && val_len) {
359 - if (val_len <= sizeof(newvar->buf))
360 - newvar->val.string = newvar->buf;
362 - newvar->val.string = (u_char *) malloc(val_len);
363 - if (!newvar->val.string)
366 - memmove(newvar->val.string, val_str, val_len);
367 - newvar->val_len = val_len;
368 - } else if (val_str) {
369 + if (len <= (sizeof(vars->buf) - 1)) {
370 + vars->val.string = (u_char *) vars->buf;
374 + if ((0 == len) || (NULL == value)) {
375 + vars->val.string[0] = 0;
379 + vars->val_len = len;
380 + switch (vars->type) {
383 + case ASN_TIMETICKS:
384 + case ASN_IPADDRESS:
387 + if (vars->val_len == sizeof(int)) {
388 + if (ASN_INTEGER == vars->type) {
390 + = (const int *) value;
391 + *(vars->val.integer) = (long) *val_int;
393 + const u_int *val_uint
394 + = (const u_int *) value;
395 + *(vars->val.integer) = (unsigned long) *val_uint;
398 +#if SIZEOF_LONG != SIZEOF_INT
399 + else if (vars->val_len == sizeof(long)){
400 + const u_long *val_ulong
401 + = (const u_long *) value;
402 + *(vars->val.integer) = *val_ulong;
403 + if (*(vars->val.integer) > 0xffffffff) {
404 + snmp_log(LOG_ERR,"truncating integer value > 32 bits\n");
405 + *(vars->val.integer) &= 0xffffffff;
409 +#if SIZEOF_LONG != SIZEOF_LONG_LONG
410 + else if (vars->val_len == sizeof(long long)){
411 + const unsigned long long *val_ullong
412 + = (const unsigned long long *) value;
413 + *(vars->val.integer) = (long) *val_ullong;
414 + if (*(vars->val.integer) > 0xffffffff) {
415 + snmp_log(LOG_ERR,"truncating integer value > 32 bits\n");
416 + *(vars->val.integer) &= 0xffffffff;
420 +#if SIZEOF_SHORT != SIZEOF_INT
421 + else if (vars->val_len == sizeof(short)) {
422 + if (ASN_INTEGER == vars->type) {
423 + const short *val_short
424 + = (const short *) value;
425 + *(vars->val.integer) = (long) *val_short;
427 + const u_short *val_ushort
428 + = (const u_short *) value;
429 + *(vars->val.integer) = (unsigned long) *val_ushort;
433 + else if (vars->val_len == sizeof(char)) {
434 + if (ASN_INTEGER == vars->type) {
435 + const char *val_char
436 + = (const char *) value;
437 + *(vars->val.integer) = (long) *val_char;
439 + *(vars->val.integer) = (unsigned long) *value;
443 + snmp_log(LOG_ERR,"bad size for integer-like type (%d)\n",
448 + *(vars->val.integer) = 0;
449 + vars->val_len = sizeof(long);
452 + case ASN_OBJECT_ID:
453 + case ASN_PRIV_IMPLIED_OBJECT_ID:
454 + case ASN_PRIV_INCL_RANGE:
455 + case ASN_PRIV_EXCL_RANGE:
457 + vars->val.objid = (oid *) malloc(vars->val_len);
459 + if (vars->val.objid == NULL) {
460 + snmp_log(LOG_ERR,"no storage for OID\n");
463 + memmove(vars->val.objid, value, vars->val_len);
466 + case ASN_PRIV_IMPLIED_OCTET_STR:
467 + case ASN_OCTET_STR:
472 + vars->val.string = (u_char *) malloc(vars->val_len + 1);
474 + if (vars->val.string == NULL) {
475 + snmp_log(LOG_ERR,"no storage for OID\n");
478 + memmove(vars->val.string, value, vars->val_len);
480 - * NULL STRING != NULL ptr
481 + * Make sure the string is zero-terminated; some bits of code make
482 + * this assumption. Easier to do this here than fix all these wrong
485 - newvar->val.string = newvar->buf;
486 - newvar->val.string[0] = '\0';
487 - newvar->val_len = 0;
488 + vars->val.string[vars->val_len] = '\0';
491 + case SNMP_NOSUCHOBJECT:
492 + case SNMP_NOSUCHINSTANCE:
493 + case SNMP_ENDOFMIBVIEW:
496 + vars->val.string = NULL;
499 +#ifdef OPAQUE_SPECIAL_TYPES
500 + case ASN_OPAQUE_U64:
501 + case ASN_OPAQUE_I64:
502 +#endif /* OPAQUE_SPECIAL_TYPES */
503 + case ASN_COUNTER64:
505 + snmp_log(LOG_ERR,"bad size for counter 64 (%d)\n",
509 + vars->val_len = sizeof(struct counter64);
510 + memmove(vars->val.counter64, value, vars->val_len);
513 +#ifdef OPAQUE_SPECIAL_TYPES
514 + case ASN_OPAQUE_FLOAT:
516 + snmp_log(LOG_ERR,"bad size for opaque float (%d)\n",
520 + vars->val_len = sizeof(float);
521 + memmove(vars->val.floatVal, value, vars->val_len);
524 + case ASN_OPAQUE_DOUBLE:
526 + snmp_log(LOG_ERR,"bad size for opaque double (%d)\n",
530 + vars->val_len = sizeof(double);
531 + memmove(vars->val.doubleVal, value, vars->val_len);
534 +#endif /* OPAQUE_SPECIAL_TYPES */
537 + snmp_log(LOG_ERR,"no storage for OID\n");
538 + snmp_set_detail("Internal error in type switching\n");