| 1 |
#include <net-snmp/net-snmp-config.h> |
| 2 |
|
| 3 |
#include <ctype.h> |
| 4 |
#include <stddef.h> |
| 5 |
#include <stdio.h> |
| 6 |
#ifdef HAVE_STRING_H |
| 7 |
#include <string.h> |
| 8 |
#else |
| 9 |
#include <strings.h> |
| 10 |
#endif |
| 11 |
|
| 12 |
#include <net-snmp/net-snmp-includes.h> |
| 13 |
#include <net-snmp/agent/net-snmp-agent-includes.h> |
| 14 |
#include "mibgroup/util_funcs.h" |
| 15 |
#include "pass_common.h" |
| 16 |
|
| 17 |
static int |
| 18 |
netsnmp_internal_asc2bin(char *p) |
| 19 |
{ |
| 20 |
char *r, *q = p; |
| 21 |
char c; |
| 22 |
int n = 0; |
| 23 |
|
| 24 |
for (;;) { |
| 25 |
c = (char) strtol(q, &r, 16); |
| 26 |
if (r == q) |
| 27 |
break; |
| 28 |
*p++ = c; |
| 29 |
q = r; |
| 30 |
n++; |
| 31 |
} |
| 32 |
return n; |
| 33 |
} |
| 34 |
|
| 35 |
static int |
| 36 |
netsnmp_internal_bin2asc(char *p, size_t n) |
| 37 |
{ |
| 38 |
int i, flag = 0; |
| 39 |
char buffer[SNMP_MAXBUF]; |
| 40 |
|
| 41 |
/* prevent buffer overflow */ |
| 42 |
if ((int)n > (sizeof(buffer) - 1)) |
| 43 |
n = sizeof(buffer) - 1; |
| 44 |
|
| 45 |
for (i = 0; i < (int) n; i++) { |
| 46 |
buffer[i] = p[i]; |
| 47 |
if (!isprint((unsigned char) (p[i]))) |
| 48 |
flag = 1; |
| 49 |
} |
| 50 |
if (flag == 0) { |
| 51 |
p[n] = 0; |
| 52 |
return n; |
| 53 |
} |
| 54 |
for (i = 0; i < (int) n; i++) { |
| 55 |
sprintf(p, "%02x ", (unsigned char) (buffer[i] & 0xff)); |
| 56 |
p += 3; |
| 57 |
} |
| 58 |
*--p = 0; |
| 59 |
return 3 * n - 1; |
| 60 |
} |
| 61 |
|
| 62 |
int |
| 63 |
netsnmp_internal_pass_str_to_errno(const char *buf) |
| 64 |
{ |
| 65 |
if (!strncasecmp(buf, "too-big", 7)) { |
| 66 |
/* Shouldn't happen */ |
| 67 |
return SNMP_ERR_TOOBIG; |
| 68 |
} else if (!strncasecmp(buf, "no-such-name", 12)) { |
| 69 |
return SNMP_ERR_NOSUCHNAME; |
| 70 |
} else if (!strncasecmp(buf, "bad-value", 9)) { |
| 71 |
return SNMP_ERR_BADVALUE; |
| 72 |
} else if (!strncasecmp(buf, "read-only", 9)) { |
| 73 |
return SNMP_ERR_READONLY; |
| 74 |
} else if (!strncasecmp(buf, "gen-error", 9)) { |
| 75 |
return SNMP_ERR_GENERR; |
| 76 |
} else if (!strncasecmp(buf, "no-access", 9)) { |
| 77 |
return SNMP_ERR_NOACCESS; |
| 78 |
} else if (!strncasecmp(buf, "wrong-type", 10)) { |
| 79 |
return SNMP_ERR_WRONGTYPE; |
| 80 |
} else if (!strncasecmp(buf, "wrong-length", 12)) { |
| 81 |
return SNMP_ERR_WRONGLENGTH; |
| 82 |
} else if (!strncasecmp(buf, "wrong-encoding", 14)) { |
| 83 |
return SNMP_ERR_WRONGENCODING; |
| 84 |
} else if (!strncasecmp(buf, "wrong-value", 11)) { |
| 85 |
return SNMP_ERR_WRONGVALUE; |
| 86 |
} else if (!strncasecmp(buf, "no-creation", 11)) { |
| 87 |
return SNMP_ERR_NOCREATION; |
| 88 |
} else if (!strncasecmp(buf, "inconsistent-value", 18)) { |
| 89 |
return SNMP_ERR_INCONSISTENTVALUE; |
| 90 |
} else if (!strncasecmp(buf, "resource-unavailable", 20)) { |
| 91 |
return SNMP_ERR_RESOURCEUNAVAILABLE; |
| 92 |
} else if (!strncasecmp(buf, "commit-failed", 13)) { |
| 93 |
return SNMP_ERR_COMMITFAILED; |
| 94 |
} else if (!strncasecmp(buf, "undo-failed", 11)) { |
| 95 |
return SNMP_ERR_UNDOFAILED; |
| 96 |
} else if (!strncasecmp(buf, "authorization-error", 19)) { |
| 97 |
return SNMP_ERR_AUTHORIZATIONERROR; |
| 98 |
} else if (!strncasecmp(buf, "not-writable", 12)) { |
| 99 |
return SNMP_ERR_NOTWRITABLE; |
| 100 |
} else if (!strncasecmp(buf, "inconsistent-name", 17)) { |
| 101 |
return SNMP_ERR_INCONSISTENTNAME; |
| 102 |
} |
| 103 |
|
| 104 |
return SNMP_ERR_NOERROR; |
| 105 |
} |
| 106 |
|
| 107 |
unsigned char * |
| 108 |
netsnmp_internal_pass_parse(char * buf, |
| 109 |
char * buf2, |
| 110 |
size_t * var_len, |
| 111 |
struct variable *vp) |
| 112 |
{ |
| 113 |
static long long_ret; |
| 114 |
static in_addr_t addr_ret; |
| 115 |
int newlen; |
| 116 |
static oid objid[MAX_OID_LEN]; |
| 117 |
|
| 118 |
/* |
| 119 |
* buf contains the return type, and buf2 contains the data |
| 120 |
*/ |
| 121 |
if (!strncasecmp(buf, "string", 6)) { |
| 122 |
buf2[strlen(buf2) - 1] = 0; /* zap the linefeed */ |
| 123 |
if (buf2[strlen(buf2) - 1] == '\r') |
| 124 |
buf2[strlen(buf2) - 1] = 0; /* zap the carriage-return */ |
| 125 |
*var_len = strlen(buf2); |
| 126 |
vp->type = ASN_OCTET_STR; |
| 127 |
return ((unsigned char *) buf2); |
| 128 |
} |
| 129 |
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES |
| 130 |
else if (!strncasecmp(buf, "integer64", 9)) { |
| 131 |
static struct counter64 c64; |
| 132 |
uint64_t v64 = strtoull(buf2, NULL, 10); |
| 133 |
c64.high = (unsigned long)(v64 >> 32); |
| 134 |
c64.low = (unsigned long)(v64 & 0xffffffff); |
| 135 |
*var_len = sizeof(c64); |
| 136 |
vp->type = ASN_OPAQUE_I64; |
| 137 |
return ((unsigned char *) &c64); |
| 138 |
} |
| 139 |
#endif |
| 140 |
else if (!strncasecmp(buf, "integer", 7)) { |
| 141 |
*var_len = sizeof(long_ret); |
| 142 |
long_ret = strtol(buf2, NULL, 10); |
| 143 |
vp->type = ASN_INTEGER; |
| 144 |
return ((unsigned char *) &long_ret); |
| 145 |
} else if (!strncasecmp(buf, "unsigned", 8)) { |
| 146 |
*var_len = sizeof(long_ret); |
| 147 |
long_ret = strtoul(buf2, NULL, 10); |
| 148 |
vp->type = ASN_UNSIGNED; |
| 149 |
return ((unsigned char *) &long_ret); |
| 150 |
} |
| 151 |
else if (!strncasecmp(buf, "counter64", 9)) { |
| 152 |
static struct counter64 c64; |
| 153 |
uint64_t v64 = strtoull(buf2, NULL, 10); |
| 154 |
c64.high = (unsigned long)(v64 >> 32); |
| 155 |
c64.low = (unsigned long)(v64 & 0xffffffff); |
| 156 |
*var_len = sizeof(c64); |
| 157 |
vp->type = ASN_COUNTER64; |
| 158 |
return ((unsigned char *) &c64); |
| 159 |
} |
| 160 |
else if (!strncasecmp(buf, "counter", 7)) { |
| 161 |
*var_len = sizeof(long_ret); |
| 162 |
long_ret = strtoul(buf2, NULL, 10); |
| 163 |
vp->type = ASN_COUNTER; |
| 164 |
return ((unsigned char *) &long_ret); |
| 165 |
} else if (!strncasecmp(buf, "octet", 5)) { |
| 166 |
*var_len = netsnmp_internal_asc2bin(buf2); |
| 167 |
vp->type = ASN_OCTET_STR; |
| 168 |
return ((unsigned char *) buf2); |
| 169 |
} else if (!strncasecmp(buf, "opaque", 6)) { |
| 170 |
*var_len = netsnmp_internal_asc2bin(buf2); |
| 171 |
vp->type = ASN_OPAQUE; |
| 172 |
return ((unsigned char *) buf2); |
| 173 |
} else if (!strncasecmp(buf, "gauge", 5)) { |
| 174 |
*var_len = sizeof(long_ret); |
| 175 |
long_ret = strtoul(buf2, NULL, 10); |
| 176 |
vp->type = ASN_GAUGE; |
| 177 |
return ((unsigned char *) &long_ret); |
| 178 |
} else if (!strncasecmp(buf, "objectid", 8)) { |
| 179 |
newlen = parse_miboid(buf2, objid); |
| 180 |
*var_len = newlen * sizeof(oid); |
| 181 |
vp->type = ASN_OBJECT_ID; |
| 182 |
return ((unsigned char *) objid); |
| 183 |
} else if (!strncasecmp(buf, "timetick", 8)) { |
| 184 |
*var_len = sizeof(long_ret); |
| 185 |
long_ret = strtoul(buf2, NULL, 10); |
| 186 |
vp->type = ASN_TIMETICKS; |
| 187 |
return ((unsigned char *) &long_ret); |
| 188 |
} else if (!strncasecmp(buf, "ipaddress", 9)) { |
| 189 |
newlen = parse_miboid(buf2, objid); |
| 190 |
if (newlen != 4) { |
| 191 |
snmp_log(LOG_ERR, "invalid ipaddress returned: %s\n", buf2); |
| 192 |
*var_len = 0; |
| 193 |
return (NULL); |
| 194 |
} |
| 195 |
addr_ret = |
| 196 |
(objid[0] << (8 * 3)) + (objid[1] << (8 * 2)) + |
| 197 |
(objid[2] << 8) + objid[3]; |
| 198 |
addr_ret = htonl(addr_ret); |
| 199 |
*var_len = sizeof(addr_ret); |
| 200 |
vp->type = ASN_IPADDRESS; |
| 201 |
return ((unsigned char *) &addr_ret); |
| 202 |
} |
| 203 |
*var_len = 0; |
| 204 |
return (NULL); |
| 205 |
} |
| 206 |
|
| 207 |
void |
| 208 |
netsnmp_internal_pass_set_format(char *buf, |
| 209 |
const u_char *var_val, |
| 210 |
u_char var_val_type, |
| 211 |
size_t var_val_len) |
| 212 |
{ |
| 213 |
char buf2[SNMP_MAXBUF]; |
| 214 |
long tmp; |
| 215 |
unsigned long utmp; |
| 216 |
|
| 217 |
switch (var_val_type) { |
| 218 |
case ASN_INTEGER: |
| 219 |
case ASN_COUNTER: |
| 220 |
case ASN_GAUGE: |
| 221 |
case ASN_TIMETICKS: |
| 222 |
tmp = *((const long *) var_val); |
| 223 |
switch (var_val_type) { |
| 224 |
case ASN_INTEGER: |
| 225 |
sprintf(buf, "integer %d\n", (int) tmp); |
| 226 |
break; |
| 227 |
case ASN_COUNTER: |
| 228 |
sprintf(buf, "counter %d\n", (int) tmp); |
| 229 |
break; |
| 230 |
case ASN_GAUGE: |
| 231 |
sprintf(buf, "gauge %d\n", (int) tmp); |
| 232 |
break; |
| 233 |
case ASN_TIMETICKS: |
| 234 |
sprintf(buf, "timeticks %d\n", (int) tmp); |
| 235 |
break; |
| 236 |
} |
| 237 |
break; |
| 238 |
case ASN_IPADDRESS: |
| 239 |
utmp = *((const u_long *) var_val); |
| 240 |
utmp = ntohl(utmp); |
| 241 |
sprintf(buf, "ipaddress %d.%d.%d.%d\n", |
| 242 |
(int) ((utmp & 0xff000000) >> (8 * 3)), |
| 243 |
(int) ((utmp & 0xff0000) >> (8 * 2)), |
| 244 |
(int) ((utmp & 0xff00) >> (8)), |
| 245 |
(int) ((utmp & 0xff))); |
| 246 |
break; |
| 247 |
case ASN_OCTET_STR: |
| 248 |
memcpy(buf2, var_val, var_val_len); |
| 249 |
if (var_val_len == 0) |
| 250 |
sprintf(buf, "string \"\"\n"); |
| 251 |
else if (netsnmp_internal_bin2asc(buf2, var_val_len) == |
| 252 |
(int) var_val_len) |
| 253 |
snprintf(buf, SNMP_MAXBUF, "string \"%s\"\n", buf2); |
| 254 |
else |
| 255 |
snprintf(buf, SNMP_MAXBUF, "octet \"%s\"\n", buf2); |
| 256 |
buf[ SNMP_MAXBUF-1 ] = 0; |
| 257 |
break; |
| 258 |
case ASN_OBJECT_ID: |
| 259 |
sprint_mib_oid(buf2, (const oid *) var_val, var_val_len/sizeof(oid)); |
| 260 |
snprintf(buf, SNMP_MAXBUF, "objectid \"%s\"\n", buf2); |
| 261 |
buf[ SNMP_MAXBUF-1 ] = 0; |
| 262 |
break; |
| 263 |
} |
| 264 |
} |