445 lines
7.8 KiB
C
445 lines
7.8 KiB
C
#include "ipf.h"
|
|
#include "netinet/ipl.h"
|
|
#include "ipmon.h"
|
|
#include <ctype.h>
|
|
|
|
static u_char sysuptime[] = { 6, 8, 0x2b, 6, 1, 2, 1, 1, 3, 0 };
|
|
/*
|
|
* Enterprise number OID:
|
|
* 1.3.6.1.4.1.9932
|
|
*/
|
|
static u_char ipf_trap0_1[] = { 6, 10, 0x2b, 6, 1, 4, 1, 0xcd, 0x4c, 1, 1, 1 };
|
|
static u_char ipf_trap0_2[] = { 6, 10, 0x2b, 6, 1, 4, 1, 0xcd, 0x4c, 1, 1, 2 };
|
|
|
|
static int writeint(u_char *, int);
|
|
static int writelength(u_char *, u_int);
|
|
static int maketrap_v2(char *, u_char *, int, u_char *, int);
|
|
static void snmpv2_destroy(void *);
|
|
static void *snmpv2_dup(void *);
|
|
static int snmpv2_match(void *, void *);
|
|
static void *snmpv2_parse(char **);
|
|
static void snmpv2_print(void *);
|
|
static int snmpv2_send(void *, ipmon_msg_t *);
|
|
|
|
|
|
int sendtrap_v2_0(int, char *, char *, int);
|
|
|
|
static char def_community[] = "public"; /* ublic */
|
|
|
|
typedef struct snmpv2_opts_s {
|
|
char *community;
|
|
char *server;
|
|
int fd;
|
|
int v6;
|
|
int ref;
|
|
#ifdef USE_INET6
|
|
struct sockaddr_in6 sin6;
|
|
#endif
|
|
struct sockaddr_in sin;
|
|
} snmpv2_opts_t;
|
|
|
|
ipmon_saver_t snmpv2saver = {
|
|
"snmpv2",
|
|
snmpv2_destroy,
|
|
snmpv2_dup, /* dup */
|
|
snmpv2_match, /* match */
|
|
snmpv2_parse,
|
|
snmpv2_print,
|
|
snmpv2_send
|
|
};
|
|
|
|
|
|
static int
|
|
snmpv2_match(void *ctx1, void *ctx2)
|
|
{
|
|
snmpv2_opts_t *s1 = ctx1, *s2 = ctx2;
|
|
|
|
if (s1->v6 != s2->v6)
|
|
return (1);
|
|
|
|
if (strcmp(s1->community, s2->community))
|
|
return (1);
|
|
|
|
#ifdef USE_INET6
|
|
if (s1->v6 == 1) {
|
|
if (memcmp(&s1->sin6, &s2->sin6, sizeof(s1->sin6)))
|
|
return (1);
|
|
} else
|
|
#endif
|
|
{
|
|
if (memcmp(&s1->sin, &s2->sin, sizeof(s1->sin)))
|
|
return (1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
|
|
static void *
|
|
snmpv2_dup(void *ctx)
|
|
{
|
|
snmpv2_opts_t *s = ctx;
|
|
|
|
s->ref++;
|
|
return (s);
|
|
}
|
|
|
|
|
|
static void
|
|
snmpv2_print(void *ctx)
|
|
{
|
|
snmpv2_opts_t *snmpv2 = ctx;
|
|
|
|
printf("%s ", snmpv2->community);
|
|
#ifdef USE_INET6
|
|
if (snmpv2->v6 == 1) {
|
|
char buf[80];
|
|
|
|
printf("%s", inet_ntop(AF_INET6, &snmpv2->sin6.sin6_addr, buf,
|
|
sizeof(snmpv2->sin6.sin6_addr)));
|
|
} else
|
|
#endif
|
|
{
|
|
printf("%s", inet_ntoa(snmpv2->sin.sin_addr));
|
|
}
|
|
}
|
|
|
|
|
|
static void *
|
|
snmpv2_parse(char **strings)
|
|
{
|
|
snmpv2_opts_t *ctx;
|
|
int result;
|
|
char *str;
|
|
char *s;
|
|
|
|
if (strings[0] == NULL || strings[0][0] == '\0')
|
|
return (NULL);
|
|
if (strchr(*strings, ' ') == NULL)
|
|
return (NULL);
|
|
|
|
str = strdup(*strings);
|
|
|
|
ctx = calloc(1, sizeof(*ctx));
|
|
if (ctx == NULL) {
|
|
free(str);
|
|
return (NULL);
|
|
}
|
|
|
|
ctx->fd = -1;
|
|
|
|
s = strchr(str, ' ');
|
|
*s++ = '\0';
|
|
ctx->community = str;
|
|
|
|
while (ISSPACE(*s))
|
|
s++;
|
|
if (!*s) {
|
|
free(str);
|
|
free(ctx);
|
|
return (NULL);
|
|
}
|
|
|
|
#ifdef USE_INET6
|
|
if (strchr(s, ':') == NULL) {
|
|
result = inet_pton(AF_INET, s, &ctx->sin.sin_addr);
|
|
if (result == 1) {
|
|
ctx->fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (ctx->fd >= 0) {
|
|
ctx->sin.sin_family = AF_INET;
|
|
ctx->sin.sin_port = htons(162);
|
|
if (connect(ctx->fd,
|
|
(struct sockaddr *)&ctx->sin,
|
|
sizeof(ctx->sin)) != 0) {
|
|
snmpv2_destroy(ctx);
|
|
return (NULL);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
result = inet_pton(AF_INET6, s, &ctx->sin6.sin6_addr);
|
|
if (result == 1) {
|
|
ctx->v6 = 1;
|
|
ctx->fd = socket(AF_INET6, SOCK_DGRAM, 0);
|
|
if (ctx->fd >= 0) {
|
|
ctx->sin6.sin6_family = AF_INET6;
|
|
ctx->sin6.sin6_port = htons(162);
|
|
if (connect(ctx->fd,
|
|
(struct sockaddr *)&ctx->sin6,
|
|
sizeof(ctx->sin6)) != 0) {
|
|
snmpv2_destroy(ctx);
|
|
return (NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
result = inet_aton(s, &ctx->sin.sin_addr);
|
|
if (result == 1) {
|
|
ctx->fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (ctx->fd >= 0) {
|
|
ctx->sin.sin_family = AF_INET;
|
|
ctx->sin.sin_port = htons(162);
|
|
if (connect(ctx->fd, (struct sockaddr *)&ctx->sin,
|
|
sizeof(ctx->sin)) != 0) {
|
|
snmpv2_destroy(ctx);
|
|
return (NULL);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (result != 1) {
|
|
free(str);
|
|
free(ctx);
|
|
return (NULL);
|
|
}
|
|
|
|
ctx->ref = 1;
|
|
|
|
return (ctx);
|
|
}
|
|
|
|
|
|
static void
|
|
snmpv2_destroy(void *ctx)
|
|
{
|
|
snmpv2_opts_t *v2 = ctx;
|
|
|
|
v2->ref--;
|
|
if (v2->ref > 0)
|
|
return;
|
|
|
|
if (v2->community)
|
|
free(v2->community);
|
|
if (v2->fd >= 0)
|
|
close(v2->fd);
|
|
free(v2);
|
|
}
|
|
|
|
|
|
static int
|
|
snmpv2_send(void *ctx, ipmon_msg_t *msg)
|
|
{
|
|
snmpv2_opts_t *v2 = ctx;
|
|
|
|
return (sendtrap_v2_0(v2->fd, v2->community,
|
|
msg->imm_msg, msg->imm_msglen));
|
|
}
|
|
static int
|
|
writelength(u_char *buffer, u_int value)
|
|
{
|
|
u_int n = htonl(value);
|
|
int len;
|
|
|
|
if (value < 128) {
|
|
*buffer = value;
|
|
return (1);
|
|
}
|
|
if (value > 0xffffff)
|
|
len = 4;
|
|
else if (value > 0xffff)
|
|
len = 3;
|
|
else if (value > 0xff)
|
|
len = 2;
|
|
else
|
|
len = 1;
|
|
|
|
*buffer = 0x80 | len;
|
|
|
|
bcopy((u_char *)&n + 4 - len, buffer + 1, len);
|
|
|
|
return (len + 1);
|
|
}
|
|
|
|
|
|
static int
|
|
writeint(u_char *buffer, int value)
|
|
{
|
|
u_char *s = buffer;
|
|
u_int n = value;
|
|
|
|
if (value == 0) {
|
|
*buffer = 0;
|
|
return (1);
|
|
}
|
|
|
|
if (n > 4194304) {
|
|
*s++ = 0x80 | (n / 4194304);
|
|
n -= 4194304 * (n / 4194304);
|
|
}
|
|
if (n > 32768) {
|
|
*s++ = 0x80 | (n / 32768);
|
|
n -= 32768 * (n / 327678);
|
|
}
|
|
if (n > 128) {
|
|
*s++ = 0x80 | (n / 128);
|
|
n -= (n / 128) * 128;
|
|
}
|
|
*s++ = (u_char)n;
|
|
|
|
return (s - buffer);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* First style of traps is:
|
|
* 1.3.6.1.4.1.9932.1.1
|
|
*/
|
|
static int
|
|
maketrap_v2(char *community, u_char *buffer, int bufsize, u_char *msg,
|
|
int msglen)
|
|
{
|
|
u_char *s = buffer, *t, *pdulen;
|
|
u_char *varlen;
|
|
int basesize = 77;
|
|
u_short len;
|
|
int trapmsglen;
|
|
int pdulensz;
|
|
int varlensz;
|
|
int baselensz;
|
|
int n;
|
|
|
|
if (community == NULL || *community == '\0')
|
|
community = def_community;
|
|
basesize += strlen(community) + msglen;
|
|
|
|
if (basesize + 8 > bufsize)
|
|
return (0);
|
|
|
|
memset(buffer, 0xff, bufsize);
|
|
*s++ = 0x30; /* Sequence */
|
|
|
|
if (basesize - 1 >= 128) {
|
|
baselensz = 2;
|
|
basesize++;
|
|
} else {
|
|
baselensz = 1;
|
|
}
|
|
s += baselensz;
|
|
*s++ = 0x02; /* Integer32 */
|
|
*s++ = 0x01; /* length 1 */
|
|
*s++ = 0x01; /* version 2 */
|
|
*s++ = 0x04; /* octet string */
|
|
*s++ = strlen(community); /* length of "public" */
|
|
bcopy(community, s, s[-1]);
|
|
s += s[-1];
|
|
*s++ = 0xA7; /* PDU(7) */
|
|
pdulen = s++;
|
|
if (basesize - (s - buffer) >= 128) {
|
|
pdulensz = 2;
|
|
basesize++;
|
|
s++;
|
|
} else {
|
|
pdulensz = 1;
|
|
}
|
|
/* request id */
|
|
*s++ = 0x2; /* integer */
|
|
*s++ = 0x4; /* len 4 */
|
|
*s++ = 0x0; /* noError */
|
|
*s++ = 0x0; /* noError */
|
|
*s++ = 0x0; /* noError */
|
|
*s++ = 0x0; /* noError */
|
|
|
|
/* error status */
|
|
*s++ = 0x2; /* integer */
|
|
*s++ = 0x1; /* len 1 */
|
|
*s++ = 0x0; /* noError */
|
|
|
|
/* error-index */
|
|
*s++ = 0x2; /* integer */
|
|
*s++ = 0x1; /* len 1 */
|
|
*s++ = 0x0; /* noError */
|
|
|
|
*s++ = 0x30; /* sequence */
|
|
varlen = s++;
|
|
if (basesize - (s - buffer) >= 128) {
|
|
varlensz = 2;
|
|
basesize++;
|
|
s++;
|
|
} else {
|
|
varlensz = 1;
|
|
}
|
|
|
|
*s++ = 0x30; /* sequence */
|
|
*s++ = sizeof(sysuptime) + 6;
|
|
|
|
bcopy(sysuptime, s, sizeof(sysuptime));
|
|
s += sizeof(sysuptime);
|
|
|
|
*s++ = 0x43; /* Timestamp */
|
|
*s++ = 0x04; /* TimeTicks */
|
|
*s++ = 0x0;
|
|
*s++ = 0x0;
|
|
*s++ = 0x0;
|
|
*s++ = 0x0;
|
|
|
|
*s++ = 0x30;
|
|
t = s + 1;
|
|
bcopy(ipf_trap0_1, t, sizeof(ipf_trap0_1));
|
|
t += sizeof(ipf_trap0_1);
|
|
|
|
*t++ = 0x2; /* Integer */
|
|
n = writeint(t + 1, IPFILTER_VERSION);
|
|
*t = n;
|
|
t += n + 1;
|
|
|
|
len = t - s - 1;
|
|
writelength(s, len);
|
|
|
|
s = t;
|
|
*s++ = 0x30;
|
|
if (msglen < 128) {
|
|
if (msglen + 1 + 1 + sizeof(ipf_trap0_2) >= 128)
|
|
trapmsglen = 2;
|
|
else
|
|
trapmsglen = 1;
|
|
} else {
|
|
if (msglen + 2 + 1 + sizeof(ipf_trap0_2) >= 128)
|
|
trapmsglen = 2;
|
|
else
|
|
trapmsglen = 1;
|
|
}
|
|
t = s + trapmsglen;
|
|
bcopy(ipf_trap0_2, t, sizeof(ipf_trap0_2));
|
|
t += sizeof(ipf_trap0_2);
|
|
|
|
*t++ = 0x4; /* Octet string */
|
|
n = writelength(t, msglen);
|
|
t += n;
|
|
bcopy(msg, t, msglen);
|
|
t += msglen;
|
|
|
|
len = t - s - trapmsglen;
|
|
writelength(s, len);
|
|
|
|
len = t - varlen - varlensz;
|
|
writelength(varlen, len); /* pdu length */
|
|
|
|
len = t - pdulen - pdulensz;
|
|
writelength(pdulen, len); /* pdu length */
|
|
|
|
len = t - buffer - baselensz - 1;
|
|
writelength(buffer + 1, len); /* length of trap */
|
|
|
|
return (t - buffer);
|
|
}
|
|
|
|
|
|
int
|
|
sendtrap_v2_0(int fd, char *community, char *msg, int msglen)
|
|
{
|
|
|
|
u_char buffer[1500];
|
|
int n;
|
|
|
|
n = maketrap_v2(community, buffer, sizeof(buffer),
|
|
(u_char *)msg, msglen);
|
|
if (n > 0) {
|
|
return (send(fd, buffer, n, 0));
|
|
}
|
|
|
|
return (0);
|
|
}
|