mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-21 11:13:30 +00:00
1675 lines
38 KiB
C
1675 lines
38 KiB
C
/*
|
|
* Copyright (c) 2001-2003
|
|
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
|
|
* All rights reserved.
|
|
*
|
|
* Author: Harti Brandt <harti@freebsd.org>
|
|
* Kendy Kutzner
|
|
*
|
|
* Redistribution of this software and documentation and use in source and
|
|
* binary forms, with or without modification, are permitted provided that
|
|
* the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code or documentation must retain the above
|
|
* copyright notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the Institute nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY FRAUNHOFER FOKUS
|
|
* AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
* FRAUNHOFER FOKUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* $Begemot: bsnmp/lib/snmpclient.c,v 1.27 2003/12/08 17:11:58 hbb Exp $
|
|
*
|
|
* Support functions for SNMP clients.
|
|
*/
|
|
#include <sys/types.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <netdb.h>
|
|
#include <inttypes.h>
|
|
#include <err.h>
|
|
#include <limits.h>
|
|
|
|
#include "asn1.h"
|
|
#include "snmp.h"
|
|
#include "snmpclient.h"
|
|
#include "snmppriv.h"
|
|
|
|
/* global context */
|
|
struct snmp_client snmp_client;
|
|
|
|
|
|
/* List of all outstanding requests */
|
|
struct sent_pdu {
|
|
int reqid;
|
|
struct snmp_pdu *pdu;
|
|
struct timeval time;
|
|
u_int retrycount;
|
|
snmp_send_cb_f callback;
|
|
void *arg;
|
|
void *timeout_id;
|
|
LIST_ENTRY(sent_pdu) entries;
|
|
};
|
|
LIST_HEAD(sent_pdu_list, sent_pdu);
|
|
|
|
static struct sent_pdu_list sent_pdus;
|
|
|
|
/*
|
|
* Prototype table entry. All C-structure produced by the table function must
|
|
* start with these two fields. This relies on the fact, that all TAILQ_ENTRY
|
|
* are compatible with each other in the sense implied by ANSI-C.
|
|
*/
|
|
struct entry {
|
|
TAILQ_ENTRY(entry) link;
|
|
u_int64_t found;
|
|
};
|
|
TAILQ_HEAD(table, entry);
|
|
|
|
/*
|
|
* working list entry. This list is used to hold the Index part of the
|
|
* table row's. The entry list and the work list parallel each other.
|
|
*/
|
|
struct work {
|
|
TAILQ_ENTRY(work) link;
|
|
struct asn_oid index;
|
|
};
|
|
TAILQ_HEAD(worklist, work);
|
|
|
|
/*
|
|
* Table working data
|
|
*/
|
|
struct tabwork {
|
|
const struct snmp_table *descr;
|
|
struct table *table;
|
|
struct worklist worklist;
|
|
u_int32_t last_change;
|
|
int first;
|
|
u_int iter;
|
|
snmp_table_cb_f callback;
|
|
void *arg;
|
|
struct snmp_pdu pdu;
|
|
};
|
|
|
|
/*
|
|
* Set the error string
|
|
*/
|
|
static void
|
|
seterr(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
vsnprintf(snmp_client.error, sizeof(snmp_client.error), fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
/*
|
|
* Free the entire table and work list. If table is NULL only the worklist
|
|
* is freed.
|
|
*/
|
|
static void
|
|
table_free(struct tabwork *work, int all)
|
|
{
|
|
struct work *w;
|
|
struct entry *e;
|
|
const struct snmp_table_entry *d;
|
|
u_int i;
|
|
|
|
while ((w = TAILQ_FIRST(&work->worklist)) != NULL) {
|
|
TAILQ_REMOVE(&work->worklist, w, link);
|
|
free(w);
|
|
}
|
|
|
|
if (all == 0)
|
|
return;
|
|
|
|
while ((e = TAILQ_FIRST(work->table)) != NULL) {
|
|
for (i = 0; work->descr->entries[i].syntax != SNMP_SYNTAX_NULL;
|
|
i++) {
|
|
d = &work->descr->entries[i];
|
|
if (d->syntax == SNMP_SYNTAX_OCTETSTRING &&
|
|
(e->found & ((u_int64_t)1 << i)))
|
|
free(*(void **)(void *)
|
|
((u_char *)e + d->offset));
|
|
}
|
|
TAILQ_REMOVE(work->table, e, link);
|
|
free(e);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Find the correct table entry for the given variable. If non exists,
|
|
* create one.
|
|
*/
|
|
static struct entry *
|
|
table_find(struct tabwork *work, const struct asn_oid *var)
|
|
{
|
|
struct entry *e, *e1;
|
|
struct work *w, *w1;
|
|
u_int i, p, j;
|
|
size_t len;
|
|
u_char *ptr;
|
|
struct asn_oid oid;
|
|
|
|
/* get index */
|
|
asn_slice_oid(&oid, var, work->descr->table.len + 2, var->len);
|
|
|
|
e = TAILQ_FIRST(work->table);
|
|
w = TAILQ_FIRST(&work->worklist);
|
|
while (e != NULL) {
|
|
if (asn_compare_oid(&w->index, &oid) == 0)
|
|
return (e);
|
|
e = TAILQ_NEXT(e, link);
|
|
w = TAILQ_NEXT(w, link);
|
|
}
|
|
|
|
/* Not found create new one */
|
|
if ((e = malloc(work->descr->entry_size)) == NULL) {
|
|
seterr("no memory for table entry");
|
|
return (NULL);
|
|
}
|
|
if ((w = malloc(sizeof(*w))) == NULL) {
|
|
seterr("no memory for table entry");
|
|
free(e);
|
|
return (NULL);
|
|
}
|
|
w->index = oid;
|
|
memset(e, 0, work->descr->entry_size);
|
|
|
|
/* decode index */
|
|
p = work->descr->table.len + 2;
|
|
for (i = 0; i < work->descr->index_size; i++) {
|
|
switch (work->descr->entries[i].syntax) {
|
|
|
|
case SNMP_SYNTAX_INTEGER:
|
|
if (var->len < p + 1) {
|
|
seterr("bad index: need integer");
|
|
goto err;
|
|
}
|
|
if (var->subs[p] > INT32_MAX) {
|
|
seterr("bad index: integer too large");
|
|
goto err;
|
|
}
|
|
*(int32_t *)(void *)((u_char *)e +
|
|
work->descr->entries[i].offset) = var->subs[p++];
|
|
break;
|
|
|
|
case SNMP_SYNTAX_OCTETSTRING:
|
|
if (var->len < p + 1) {
|
|
seterr("bad index: need string length");
|
|
goto err;
|
|
}
|
|
len = var->subs[p++];
|
|
if (var->len < p + len) {
|
|
seterr("bad index: string too short");
|
|
goto err;
|
|
}
|
|
if ((ptr = malloc(len + 1)) == NULL) {
|
|
seterr("no memory for index string");
|
|
goto err;
|
|
}
|
|
for (j = 0; j < len; j++) {
|
|
if (var->subs[p] > UCHAR_MAX) {
|
|
seterr("bad index: char too large");
|
|
free(ptr);
|
|
goto err;
|
|
}
|
|
ptr[j] = var->subs[p++];
|
|
}
|
|
ptr[j] = '\0';
|
|
*(u_char **)(void *)((u_char *)e +
|
|
work->descr->entries[i].offset) = ptr;
|
|
*(size_t *)(void *)((u_char *)e +
|
|
work->descr->entries[i].offset + sizeof(u_char *))
|
|
= len;
|
|
break;
|
|
|
|
case SNMP_SYNTAX_OID:
|
|
if (var->len < p + 1) {
|
|
seterr("bad index: need oid length");
|
|
goto err;
|
|
}
|
|
oid.len = var->subs[p++];
|
|
if (var->len < p + oid.len) {
|
|
seterr("bad index: oid too short");
|
|
goto err;
|
|
}
|
|
for (j = 0; j < oid.len; j++)
|
|
oid.subs[j] = var->subs[p++];
|
|
*(struct asn_oid *)(void *)((u_char *)e +
|
|
work->descr->entries[i].offset) = oid;
|
|
break;
|
|
|
|
case SNMP_SYNTAX_IPADDRESS:
|
|
if (var->len < p + 4) {
|
|
seterr("bad index: need ip-address");
|
|
goto err;
|
|
}
|
|
for (j = 0; j < 4; j++) {
|
|
if (var->subs[p] > 0xff) {
|
|
seterr("bad index: ipaddress too large");
|
|
goto err;
|
|
}
|
|
((u_char *)e +
|
|
work->descr->entries[i].offset)[j] =
|
|
var->subs[p++];
|
|
}
|
|
break;
|
|
|
|
case SNMP_SYNTAX_GAUGE:
|
|
if (var->len < p + 1) {
|
|
seterr("bad index: need unsigned");
|
|
goto err;
|
|
}
|
|
if (var->subs[p] > UINT32_MAX) {
|
|
seterr("bad index: unsigned too large");
|
|
goto err;
|
|
}
|
|
*(u_int32_t *)(void *)((u_char *)e +
|
|
work->descr->entries[i].offset) = var->subs[p++];
|
|
break;
|
|
|
|
case SNMP_SYNTAX_COUNTER:
|
|
case SNMP_SYNTAX_TIMETICKS:
|
|
case SNMP_SYNTAX_COUNTER64:
|
|
case SNMP_SYNTAX_NULL:
|
|
case SNMP_SYNTAX_NOSUCHOBJECT:
|
|
case SNMP_SYNTAX_NOSUCHINSTANCE:
|
|
case SNMP_SYNTAX_ENDOFMIBVIEW:
|
|
abort();
|
|
}
|
|
e->found |= (u_int64_t)1 << i;
|
|
}
|
|
|
|
/* link into the correct place */
|
|
e1 = TAILQ_FIRST(work->table);
|
|
w1 = TAILQ_FIRST(&work->worklist);
|
|
while (e1 != NULL) {
|
|
if (asn_compare_oid(&w1->index, &w->index) > 0)
|
|
break;
|
|
e1 = TAILQ_NEXT(e1, link);
|
|
w1 = TAILQ_NEXT(w1, link);
|
|
}
|
|
if (e1 == NULL) {
|
|
TAILQ_INSERT_TAIL(work->table, e, link);
|
|
TAILQ_INSERT_TAIL(&work->worklist, w, link);
|
|
} else {
|
|
TAILQ_INSERT_BEFORE(e1, e, link);
|
|
TAILQ_INSERT_BEFORE(w1, w, link);
|
|
}
|
|
|
|
return (e);
|
|
|
|
err:
|
|
/*
|
|
* Error happend. Free all octet string index parts and the entry
|
|
* itself.
|
|
*/
|
|
for (i = 0; i < work->descr->index_size; i++) {
|
|
if (work->descr->entries[i].syntax == SNMP_SYNTAX_OCTETSTRING &&
|
|
(e->found & ((u_int64_t)1 << i)))
|
|
free(*(void **)(void *)((u_char *)e +
|
|
work->descr->entries[i].offset));
|
|
}
|
|
free(e);
|
|
free(w);
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Assign the value
|
|
*/
|
|
static int
|
|
table_value(const struct snmp_table *descr, struct entry *e,
|
|
const struct snmp_value *b)
|
|
{
|
|
u_int i;
|
|
u_char *ptr;
|
|
|
|
for (i = descr->index_size;
|
|
descr->entries[i].syntax != SNMP_SYNTAX_NULL; i++)
|
|
if (descr->entries[i].subid ==
|
|
b->var.subs[descr->table.len + 1])
|
|
break;
|
|
if (descr->entries[i].syntax == SNMP_SYNTAX_NULL)
|
|
return (0);
|
|
|
|
/* check syntax */
|
|
if (b->syntax != descr->entries[i].syntax) {
|
|
seterr("bad syntax (%u instead of %u)", b->syntax,
|
|
descr->entries[i].syntax);
|
|
return (-1);
|
|
}
|
|
|
|
switch (b->syntax) {
|
|
|
|
case SNMP_SYNTAX_INTEGER:
|
|
*(int32_t *)(void *)((u_char *)e + descr->entries[i].offset) =
|
|
b->v.integer;
|
|
break;
|
|
|
|
case SNMP_SYNTAX_OCTETSTRING:
|
|
if ((ptr = malloc(b->v.octetstring.len + 1)) == NULL) {
|
|
seterr("no memory for string");
|
|
return (-1);
|
|
}
|
|
memcpy(ptr, b->v.octetstring.octets, b->v.octetstring.len);
|
|
ptr[b->v.octetstring.len] = '\0';
|
|
*(u_char **)(void *)((u_char *)e + descr->entries[i].offset) =
|
|
ptr;
|
|
*(size_t *)(void *)((u_char *)e + descr->entries[i].offset +
|
|
sizeof(u_char *)) = b->v.octetstring.len;
|
|
break;
|
|
|
|
case SNMP_SYNTAX_OID:
|
|
*(struct asn_oid *)(void *)((u_char *)e + descr->entries[i].offset) =
|
|
b->v.oid;
|
|
break;
|
|
|
|
case SNMP_SYNTAX_IPADDRESS:
|
|
memcpy((u_char *)e + descr->entries[i].offset,
|
|
b->v.ipaddress, 4);
|
|
break;
|
|
|
|
case SNMP_SYNTAX_COUNTER:
|
|
case SNMP_SYNTAX_GAUGE:
|
|
case SNMP_SYNTAX_TIMETICKS:
|
|
*(u_int32_t *)(void *)((u_char *)e + descr->entries[i].offset) =
|
|
b->v.uint32;
|
|
break;
|
|
|
|
case SNMP_SYNTAX_COUNTER64:
|
|
*(u_int64_t *)(void *)((u_char *)e + descr->entries[i].offset) =
|
|
b->v.counter64;
|
|
break;
|
|
|
|
case SNMP_SYNTAX_NULL:
|
|
case SNMP_SYNTAX_NOSUCHOBJECT:
|
|
case SNMP_SYNTAX_NOSUCHINSTANCE:
|
|
case SNMP_SYNTAX_ENDOFMIBVIEW:
|
|
abort();
|
|
}
|
|
e->found |= (u_int64_t)1 << i;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Initialize the first PDU to send
|
|
*/
|
|
static void
|
|
table_init_pdu(const struct snmp_table *descr, struct snmp_pdu *pdu)
|
|
{
|
|
if (snmp_client.version == SNMP_V1)
|
|
snmp_pdu_create(pdu, SNMP_PDU_GETNEXT);
|
|
else {
|
|
snmp_pdu_create(pdu, SNMP_PDU_GETBULK);
|
|
pdu->error_index = 10;
|
|
}
|
|
if (descr->last_change.len != 0) {
|
|
pdu->bindings[pdu->nbindings].syntax = SNMP_SYNTAX_NULL;
|
|
pdu->bindings[pdu->nbindings].var = descr->last_change;
|
|
pdu->nbindings++;
|
|
if (pdu->version != SNMP_V1)
|
|
pdu->error_status++;
|
|
}
|
|
pdu->bindings[pdu->nbindings].var = descr->table;
|
|
pdu->bindings[pdu->nbindings].syntax = SNMP_SYNTAX_NULL;
|
|
pdu->nbindings++;
|
|
}
|
|
|
|
/*
|
|
* Return code:
|
|
* 0 - End Of Table
|
|
* -1 - Error
|
|
* -2 - Last change changed - again
|
|
* +1 - ok, continue
|
|
*/
|
|
static int
|
|
table_check_response(struct tabwork *work, const struct snmp_pdu *resp)
|
|
{
|
|
const struct snmp_value *b;
|
|
struct entry *e;
|
|
|
|
if (resp->error_status != SNMP_ERR_NOERROR) {
|
|
if (snmp_client.version == SNMP_V1 &&
|
|
resp->error_status == SNMP_ERR_NOSUCHNAME &&
|
|
resp->error_index ==
|
|
(work->descr->last_change.len == 0) ? 1 : 2)
|
|
/* EOT */
|
|
return (0);
|
|
/* Error */
|
|
seterr("error fetching table: status=%d index=%d",
|
|
resp->error_status, resp->error_index);
|
|
return (-1);
|
|
}
|
|
|
|
for (b = resp->bindings; b < resp->bindings + resp->nbindings; b++) {
|
|
if (work->descr->last_change.len != 0 && b == resp->bindings) {
|
|
if (!asn_is_suboid(&work->descr->last_change, &b->var) ||
|
|
b->var.len != work->descr->last_change.len + 1 ||
|
|
b->var.subs[work->descr->last_change.len] != 0) {
|
|
seterr("last_change: bad response");
|
|
return (-1);
|
|
}
|
|
if (b->syntax != SNMP_SYNTAX_TIMETICKS) {
|
|
seterr("last_change: bad syntax %u", b->syntax);
|
|
return (-1);
|
|
}
|
|
if (work->first) {
|
|
work->last_change = b->v.uint32;
|
|
work->first = 0;
|
|
|
|
} else if (work->last_change != b->v.uint32) {
|
|
if (++work->iter >= work->descr->max_iter) {
|
|
seterr("max iteration count exceeded");
|
|
return (-1);
|
|
}
|
|
table_free(work, 1);
|
|
return (-2);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
if (!asn_is_suboid(&work->descr->table, &b->var) ||
|
|
b->syntax == SNMP_SYNTAX_ENDOFMIBVIEW)
|
|
return (0);
|
|
|
|
if ((e = table_find(work, &b->var)) == NULL)
|
|
return (-1);
|
|
if (table_value(work->descr, e, b))
|
|
return (-1);
|
|
}
|
|
return (+1);
|
|
}
|
|
|
|
/*
|
|
* Check table consistency
|
|
*/
|
|
static int
|
|
table_check_cons(struct tabwork *work)
|
|
{
|
|
struct entry *e;
|
|
|
|
TAILQ_FOREACH(e, work->table, link)
|
|
if ((e->found & work->descr->req_mask) !=
|
|
work->descr->req_mask) {
|
|
if (work->descr->last_change.len == 0) {
|
|
if (++work->iter >= work->descr->max_iter) {
|
|
seterr("max iteration count exceeded");
|
|
return (-1);
|
|
}
|
|
return (-2);
|
|
}
|
|
seterr("inconsistency detected %llx %llx",
|
|
e->found, work->descr->req_mask);
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Fetch a table. Returns 0 if ok, -1 on errors.
|
|
* This is the synchronuous variant.
|
|
*/
|
|
int
|
|
snmp_table_fetch(const struct snmp_table *descr, void *list)
|
|
{
|
|
struct snmp_pdu resp;
|
|
struct tabwork work;
|
|
int ret;
|
|
|
|
work.descr = descr;
|
|
work.table = (struct table *)list;
|
|
work.iter = 0;
|
|
TAILQ_INIT(work.table);
|
|
TAILQ_INIT(&work.worklist);
|
|
work.callback = NULL;
|
|
work.arg = NULL;
|
|
|
|
again:
|
|
/*
|
|
* We come to this label when the code detects that the table
|
|
* has changed while fetching it.
|
|
*/
|
|
work.first = 1;
|
|
work.last_change = 0;
|
|
table_init_pdu(descr, &work.pdu);
|
|
|
|
for (;;) {
|
|
if (snmp_dialog(&work.pdu, &resp)) {
|
|
seterr("SNMP error: no response");
|
|
table_free(&work, 1);
|
|
return (-1);
|
|
}
|
|
if ((ret = table_check_response(&work, &resp)) == 0) {
|
|
snmp_pdu_free(&resp);
|
|
break;
|
|
}
|
|
if (ret == -1) {
|
|
snmp_pdu_free(&resp);
|
|
table_free(&work, 1);
|
|
return (-1);
|
|
}
|
|
if (ret == -2) {
|
|
snmp_pdu_free(&resp);
|
|
goto again;
|
|
}
|
|
|
|
work.pdu.bindings[work.pdu.nbindings - 1].var =
|
|
resp.bindings[resp.nbindings - 1].var;
|
|
|
|
snmp_pdu_free(&resp);
|
|
}
|
|
|
|
if ((ret = table_check_cons(&work)) == -1) {
|
|
table_free(&work, 1);
|
|
return (-1);
|
|
}
|
|
if (ret == -2) {
|
|
table_free(&work, 1);
|
|
goto again;
|
|
}
|
|
/*
|
|
* Free index list
|
|
*/
|
|
table_free(&work, 0);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Callback for table
|
|
*/
|
|
static void
|
|
table_cb(struct snmp_pdu *req __unused, struct snmp_pdu *resp, void *arg)
|
|
{
|
|
struct tabwork *work = arg;
|
|
int ret;
|
|
|
|
if (resp == NULL) {
|
|
/* timeout */
|
|
seterr("no response to fetch table request");
|
|
table_free(work, 1);
|
|
work->callback(work->table, work->arg, -1);
|
|
free(work);
|
|
return;
|
|
}
|
|
|
|
if ((ret = table_check_response(work, resp)) == 0) {
|
|
/* EOT */
|
|
snmp_pdu_free(resp);
|
|
|
|
if ((ret = table_check_cons(work)) == -1) {
|
|
/* error happend */
|
|
table_free(work, 1);
|
|
work->callback(work->table, work->arg, -1);
|
|
free(work);
|
|
return;
|
|
}
|
|
if (ret == -2) {
|
|
/* restart */
|
|
again:
|
|
table_free(work, 1);
|
|
work->first = 1;
|
|
work->last_change = 0;
|
|
table_init_pdu(work->descr, &work->pdu);
|
|
if (snmp_pdu_send(&work->pdu, table_cb, work) == -1) {
|
|
work->callback(work->table, work->arg, -1);
|
|
free(work);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
/*
|
|
* Free index list
|
|
*/
|
|
table_free(work, 0);
|
|
work->callback(work->table, work->arg, 0);
|
|
free(work);
|
|
return;
|
|
}
|
|
|
|
if (ret == -1) {
|
|
/* error */
|
|
snmp_pdu_free(resp);
|
|
table_free(work, 1);
|
|
work->callback(work->table, work->arg, -1);
|
|
free(work);
|
|
return;
|
|
}
|
|
|
|
if (ret == -2) {
|
|
/* again */
|
|
snmp_pdu_free(resp);
|
|
goto again;
|
|
}
|
|
|
|
/* next part */
|
|
|
|
work->pdu.bindings[work->pdu.nbindings - 1].var =
|
|
resp->bindings[resp->nbindings - 1].var;
|
|
|
|
snmp_pdu_free(resp);
|
|
|
|
if (snmp_pdu_send(&work->pdu, table_cb, work) == -1) {
|
|
table_free(work, 1);
|
|
work->callback(work->table, work->arg, -1);
|
|
free(work);
|
|
return;
|
|
}
|
|
}
|
|
|
|
int
|
|
snmp_table_fetch_async(const struct snmp_table *descr, void *list,
|
|
snmp_table_cb_f func, void *arg)
|
|
{
|
|
struct tabwork *work;
|
|
|
|
if ((work = malloc(sizeof(*work))) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
|
|
work->descr = descr;
|
|
work->table = (struct table *)list;
|
|
work->iter = 0;
|
|
TAILQ_INIT(work->table);
|
|
TAILQ_INIT(&work->worklist);
|
|
|
|
work->callback = func;
|
|
work->arg = arg;
|
|
|
|
/*
|
|
* Start by sending the first PDU
|
|
*/
|
|
work->first = 1;
|
|
work->last_change = 0;
|
|
table_init_pdu(descr, &work->pdu);
|
|
|
|
if (snmp_pdu_send(&work->pdu, table_cb, work) == -1)
|
|
return (-1);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Append an index to an oid
|
|
*/
|
|
int
|
|
snmp_oid_append(struct asn_oid *oid, const char *fmt, ...)
|
|
{
|
|
va_list va;
|
|
int size;
|
|
char *nextptr;
|
|
const u_char *str;
|
|
size_t len;
|
|
struct in_addr ina;
|
|
int ret;
|
|
|
|
va_start(va, fmt);
|
|
|
|
size = 0;
|
|
|
|
ret = 0;
|
|
while (*fmt != '\0') {
|
|
switch (*fmt++) {
|
|
case 'i':
|
|
/* just an integer more */
|
|
if (oid->len + 1 > ASN_MAXOIDLEN) {
|
|
warnx("%s: OID too long for integer", __func__);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
oid->subs[oid->len++] = va_arg(va, asn_subid_t);
|
|
break;
|
|
|
|
case 'a':
|
|
/* append an IP address */
|
|
if (oid->len + 4 > ASN_MAXOIDLEN) {
|
|
warnx("%s: OID too long for ip-addr", __func__);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
ina = va_arg(va, struct in_addr);
|
|
ina.s_addr = ntohl(ina.s_addr);
|
|
oid->subs[oid->len++] = (ina.s_addr >> 24) & 0xff;
|
|
oid->subs[oid->len++] = (ina.s_addr >> 16) & 0xff;
|
|
oid->subs[oid->len++] = (ina.s_addr >> 8) & 0xff;
|
|
oid->subs[oid->len++] = (ina.s_addr >> 0) & 0xff;
|
|
break;
|
|
|
|
case 's':
|
|
/* append a null-terminated string,
|
|
* length is computed */
|
|
str = (const u_char *)va_arg(va, const char *);
|
|
len = strlen((const char *)str);
|
|
if (oid->len + len + 1 > ASN_MAXOIDLEN) {
|
|
warnx("%s: OID too long for string", __func__);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
oid->subs[oid->len++] = len;
|
|
while (len--)
|
|
oid->subs[oid->len++] = *str++;
|
|
break;
|
|
|
|
case '(':
|
|
/* the integer value between ( and ) is stored
|
|
* in size */
|
|
size = strtol(fmt, &nextptr, 10);
|
|
if (*nextptr != ')')
|
|
abort();
|
|
fmt = ++nextptr;
|
|
break;
|
|
|
|
case 'b':
|
|
/* append `size` characters */
|
|
str = (const u_char *)va_arg(va, const char *);
|
|
if (oid->len + size > ASN_MAXOIDLEN) {
|
|
warnx("%s: OID too long for string", __func__);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
while (size--)
|
|
oid->subs[oid->len++] = *str++;
|
|
break;
|
|
|
|
case 'c':
|
|
/* get size and the octets from the arguments */
|
|
size = va_arg(va, size_t);
|
|
str = va_arg(va, const u_char *);
|
|
if (oid->len + size + 1 > ASN_MAXOIDLEN) {
|
|
warnx("%s: OID too long for string", __func__);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
oid->subs[oid->len++] = size;
|
|
while (size--)
|
|
oid->subs[oid->len++] = *str++;
|
|
break;
|
|
|
|
default:
|
|
abort();
|
|
}
|
|
}
|
|
va_end(va);
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Initialize a client structure
|
|
*/
|
|
void
|
|
snmp_client_init(struct snmp_client *c)
|
|
{
|
|
memset(c, 0, sizeof(*c));
|
|
|
|
c->version = SNMP_V2c;
|
|
c->trans = SNMP_TRANS_UDP;
|
|
c->chost = NULL;
|
|
c->cport = NULL;
|
|
|
|
strcpy(c->read_community, "public");
|
|
strcpy(c->write_community, "private");
|
|
|
|
c->timeout.tv_sec = 3;
|
|
c->timeout.tv_usec = 0;
|
|
c->retries = 3;
|
|
c->dump_pdus = 0;
|
|
c->txbuflen = c->rxbuflen = 10000;
|
|
|
|
c->fd = -1;
|
|
|
|
c->max_reqid = INT32_MAX;
|
|
c->min_reqid = 0;
|
|
c->next_reqid = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Open UDP client socket
|
|
*/
|
|
static int
|
|
open_client_udp(const char *host, const char *port)
|
|
{
|
|
int error;
|
|
char *ptr;
|
|
struct addrinfo hints, *res0, *res;
|
|
|
|
/* copy host- and portname */
|
|
if (snmp_client.chost == NULL) {
|
|
if ((snmp_client.chost = malloc(1 + sizeof(DEFAULT_HOST)))
|
|
== NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
strcpy(snmp_client.chost, DEFAULT_HOST);
|
|
}
|
|
if (host != NULL) {
|
|
if ((ptr = malloc(1 + strlen(host))) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
free(snmp_client.chost);
|
|
snmp_client.chost = ptr;
|
|
strcpy(snmp_client.chost, host);
|
|
}
|
|
if (snmp_client.cport == NULL) {
|
|
if ((snmp_client.cport = malloc(1 + sizeof(DEFAULT_PORT)))
|
|
== NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
strcpy(snmp_client.cport, DEFAULT_PORT);
|
|
}
|
|
if (port != NULL) {
|
|
if ((ptr = malloc(1 + strlen(port))) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
free(snmp_client.cport);
|
|
snmp_client.cport = ptr;
|
|
strcpy(snmp_client.cport, port);
|
|
}
|
|
|
|
/* open connection */
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_flags = AI_CANONNAME;
|
|
hints.ai_family = AF_INET;
|
|
hints.ai_socktype = SOCK_DGRAM;
|
|
hints.ai_protocol = 0;
|
|
error = getaddrinfo(snmp_client.chost, snmp_client.cport, &hints, &res0);
|
|
if (error != 0) {
|
|
seterr("%s: %s", snmp_client.chost, gai_strerror(error));
|
|
return (-1);
|
|
}
|
|
res = res0;
|
|
for (;;) {
|
|
if ((snmp_client.fd = socket(res->ai_family, res->ai_socktype,
|
|
res->ai_protocol)) == -1) {
|
|
if ((res = res->ai_next) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
freeaddrinfo(res0);
|
|
return (-1);
|
|
}
|
|
} else if (connect(snmp_client.fd, res->ai_addr,
|
|
res->ai_addrlen) == -1) {
|
|
if ((res = res->ai_next) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
freeaddrinfo(res0);
|
|
return (-1);
|
|
}
|
|
} else
|
|
break;
|
|
}
|
|
freeaddrinfo(res0);
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
remove_local(void)
|
|
{
|
|
(void)remove(snmp_client.local_path);
|
|
}
|
|
|
|
/*
|
|
* Open local socket
|
|
*/
|
|
static int
|
|
open_client_local(const char *path)
|
|
{
|
|
struct sockaddr_un sa;
|
|
char *ptr;
|
|
int stype;
|
|
|
|
if (snmp_client.chost == NULL) {
|
|
if ((snmp_client.chost = malloc(1 + sizeof(DEFAULT_LOCAL)))
|
|
== NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
strcpy(snmp_client.chost, DEFAULT_LOCAL);
|
|
}
|
|
if (path != NULL) {
|
|
if ((ptr = malloc(1 + strlen(path))) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
free(snmp_client.chost);
|
|
snmp_client.chost = ptr;
|
|
strcpy(snmp_client.chost, path);
|
|
}
|
|
|
|
if (snmp_client.trans == SNMP_TRANS_LOC_DGRAM)
|
|
stype = SOCK_DGRAM;
|
|
else
|
|
stype = SOCK_STREAM;
|
|
|
|
if ((snmp_client.fd = socket(PF_LOCAL, stype, 0)) == -1) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
|
|
snprintf(snmp_client.local_path, sizeof(snmp_client.local_path),
|
|
"%s", SNMP_LOCAL_PATH);
|
|
|
|
if (mktemp(snmp_client.local_path) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
(void)close(snmp_client.fd);
|
|
snmp_client.fd = -1;
|
|
return (-1);
|
|
}
|
|
|
|
sa.sun_family = AF_LOCAL;
|
|
sa.sun_len = sizeof(sa);
|
|
strcpy(sa.sun_path, snmp_client.local_path);
|
|
|
|
if (bind(snmp_client.fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
|
|
seterr("%s", strerror(errno));
|
|
(void)close(snmp_client.fd);
|
|
snmp_client.fd = -1;
|
|
(void)remove(snmp_client.local_path);
|
|
return (-1);
|
|
}
|
|
atexit(remove_local);
|
|
|
|
sa.sun_family = AF_LOCAL;
|
|
sa.sun_len = offsetof(struct sockaddr_un, sun_path) +
|
|
strlen(snmp_client.chost);
|
|
strncpy(sa.sun_path, snmp_client.chost, sizeof(sa.sun_path) - 1);
|
|
sa.sun_path[sizeof(sa.sun_path) - 1] = '\0';
|
|
|
|
if (connect(snmp_client.fd, (struct sockaddr *)&sa, sa.sun_len) == -1) {
|
|
seterr("%s", strerror(errno));
|
|
(void)close(snmp_client.fd);
|
|
snmp_client.fd = -1;
|
|
(void)remove(snmp_client.local_path);
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* SNMP_OPEN
|
|
*/
|
|
int
|
|
snmp_open(const char *host, const char *port, const char *readcomm,
|
|
const char *writecomm)
|
|
{
|
|
struct timeval tout;
|
|
|
|
/* still open ? */
|
|
if (snmp_client.fd != -1) {
|
|
errno = EBUSY;
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
|
|
/* copy community strings */
|
|
if (readcomm != NULL)
|
|
strlcpy(snmp_client.read_community, readcomm,
|
|
sizeof(snmp_client.read_community));
|
|
if (writecomm != NULL)
|
|
strlcpy(snmp_client.write_community, writecomm,
|
|
sizeof(snmp_client.write_community));
|
|
|
|
switch (snmp_client.trans) {
|
|
|
|
case SNMP_TRANS_UDP:
|
|
if (open_client_udp(host, port))
|
|
return (-1);
|
|
break;
|
|
|
|
case SNMP_TRANS_LOC_DGRAM:
|
|
case SNMP_TRANS_LOC_STREAM:
|
|
if (open_client_local(host))
|
|
return (-1);
|
|
break;
|
|
|
|
default:
|
|
seterr("bad transport mapping");
|
|
return (-1);
|
|
}
|
|
tout.tv_sec = 0;
|
|
tout.tv_usec = 0;
|
|
if (setsockopt(snmp_client.fd, SOL_SOCKET, SO_SNDTIMEO,
|
|
&tout, sizeof(struct timeval)) == -1) {
|
|
seterr("%s", strerror(errno));
|
|
(void)close(snmp_client.fd);
|
|
snmp_client.fd = -1;
|
|
if (snmp_client.local_path[0] != '\0')
|
|
(void)remove(snmp_client.local_path);
|
|
return (-1);
|
|
}
|
|
|
|
/* initialize list */
|
|
LIST_INIT(&sent_pdus);
|
|
|
|
return (0);
|
|
}
|
|
|
|
|
|
/*
|
|
* SNMP_CLOSE
|
|
*
|
|
* closes connection to snmp server
|
|
* - function cannot fail
|
|
* - clears connection
|
|
* - clears list of sent pdus
|
|
*
|
|
* input:
|
|
* void
|
|
* return:
|
|
* void
|
|
*/
|
|
void
|
|
snmp_close(void)
|
|
{
|
|
struct sent_pdu *p1;
|
|
|
|
if (snmp_client.fd != -1) {
|
|
(void)close(snmp_client.fd);
|
|
snmp_client.fd = -1;
|
|
if (snmp_client.local_path[0] != '\0')
|
|
(void)remove(snmp_client.local_path);
|
|
}
|
|
while(!LIST_EMPTY(&sent_pdus)){
|
|
p1 = LIST_FIRST(&sent_pdus);
|
|
if (p1->timeout_id != NULL)
|
|
snmp_client.timeout_stop(p1->timeout_id);
|
|
LIST_REMOVE(p1, entries);
|
|
free(p1);
|
|
}
|
|
free(snmp_client.chost);
|
|
free(snmp_client.cport);
|
|
}
|
|
|
|
/*
|
|
* initialize a snmp_pdu structure
|
|
*/
|
|
void
|
|
snmp_pdu_create(struct snmp_pdu *pdu, u_int op)
|
|
{
|
|
memset(pdu,0,sizeof(struct snmp_pdu));
|
|
if (op == SNMP_PDU_SET)
|
|
strlcpy(pdu->community, snmp_client.write_community,
|
|
sizeof(pdu->community));
|
|
else
|
|
strlcpy(pdu->community, snmp_client.read_community,
|
|
sizeof(pdu->community));
|
|
|
|
pdu->type = op;
|
|
pdu->version = snmp_client.version;
|
|
pdu->error_status = 0;
|
|
pdu->error_index = 0;
|
|
pdu->nbindings = 0;
|
|
}
|
|
|
|
/* add pairs of (struct asn_oid, enum snmp_syntax) to an existing pdu */
|
|
/* added 10/04/02 by kek: check for MAX_BINDINGS */
|
|
int
|
|
snmp_add_binding(struct snmp_v1_pdu *pdu, ...)
|
|
{
|
|
va_list ap;
|
|
const struct asn_oid *oid;
|
|
u_int ret;
|
|
|
|
va_start(ap, pdu);
|
|
|
|
ret = pdu->nbindings;
|
|
while ((oid = va_arg(ap, const struct asn_oid *)) != NULL) {
|
|
if (pdu->nbindings >= SNMP_MAX_BINDINGS){
|
|
va_end(ap);
|
|
return (-1);
|
|
}
|
|
pdu->bindings[pdu->nbindings].var = *oid;
|
|
pdu->bindings[pdu->nbindings].syntax =
|
|
va_arg(ap, enum snmp_syntax);
|
|
pdu->nbindings++;
|
|
}
|
|
va_end(ap);
|
|
return (ret);
|
|
}
|
|
|
|
|
|
static int32_t
|
|
snmp_next_reqid(struct snmp_client * c)
|
|
{
|
|
int32_t i;
|
|
|
|
i = c->next_reqid;
|
|
if (c->next_reqid >= c->max_reqid)
|
|
c->next_reqid = c->min_reqid;
|
|
else
|
|
c->next_reqid++;
|
|
return (i);
|
|
}
|
|
|
|
/*
|
|
* Send request and return request id.
|
|
*/
|
|
static int32_t
|
|
snmp_send_packet(struct snmp_pdu * pdu)
|
|
{
|
|
u_char *buf;
|
|
struct asn_buf b;
|
|
ssize_t ret;
|
|
|
|
if ((buf = malloc(snmp_client.txbuflen)) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
|
|
pdu->request_id = snmp_next_reqid(&snmp_client);
|
|
|
|
b.asn_ptr = buf;
|
|
b.asn_len = snmp_client.txbuflen;
|
|
if (snmp_pdu_encode(pdu, &b)) {
|
|
seterr("%s", strerror(errno));
|
|
free(buf);
|
|
return (-1);
|
|
}
|
|
|
|
if (snmp_client.dump_pdus)
|
|
snmp_pdu_dump(pdu);
|
|
|
|
if ((ret = send(snmp_client.fd, buf, b.asn_ptr - buf, 0)) == -1) {
|
|
seterr("%s", strerror(errno));
|
|
free(buf);
|
|
return (-1);
|
|
}
|
|
free(buf);
|
|
|
|
return pdu->request_id;
|
|
}
|
|
|
|
/*
|
|
* to be called when a snmp request timed out
|
|
*/
|
|
static void
|
|
snmp_timeout(void * listentry_ptr)
|
|
{
|
|
struct sent_pdu *listentry = listentry_ptr;
|
|
|
|
#if 0
|
|
warnx("snmp request %i timed out, attempt (%i/%i)",
|
|
listentry->reqid, listentry->retrycount, snmp_client.retries);
|
|
#endif
|
|
|
|
listentry->retrycount++;
|
|
if (listentry->retrycount > snmp_client.retries) {
|
|
/* there is no answer at all */
|
|
LIST_REMOVE(listentry, entries);
|
|
listentry->callback(listentry->pdu, NULL, listentry->arg);
|
|
free(listentry);
|
|
} else {
|
|
/* try again */
|
|
/* new request with new request ID */
|
|
listentry->reqid = snmp_send_packet(listentry->pdu);
|
|
listentry->timeout_id =
|
|
snmp_client.timeout_start(&snmp_client.timeout,
|
|
snmp_timeout, listentry);
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
snmp_pdu_send(struct snmp_pdu *pdu, snmp_send_cb_f func, void *arg)
|
|
{
|
|
struct sent_pdu *listentry;
|
|
int32_t id;
|
|
|
|
if ((listentry = malloc(sizeof(struct sent_pdu))) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
|
|
/* here we really send */
|
|
if ((id = snmp_send_packet(pdu)) == -1) {
|
|
free(listentry);
|
|
return (-1);
|
|
}
|
|
|
|
/* add entry to list of sent PDUs */
|
|
listentry->pdu = pdu;
|
|
if (gettimeofday(&listentry->time, NULL) == -1)
|
|
warn("gettimeofday() failed");
|
|
|
|
listentry->reqid = pdu->request_id;
|
|
listentry->callback = func;
|
|
listentry->arg = arg;
|
|
listentry->retrycount=1;
|
|
listentry->timeout_id =
|
|
snmp_client.timeout_start(&snmp_client.timeout, snmp_timeout,
|
|
listentry);
|
|
|
|
LIST_INSERT_HEAD(&sent_pdus, listentry, entries);
|
|
|
|
return (id);
|
|
}
|
|
|
|
/*
|
|
* Receive an SNMP packet.
|
|
*
|
|
* tv controls how we wait for a packet: if tv is a NULL pointer,
|
|
* the receive blocks forever, if tv points to a structure with all
|
|
* members 0 the socket is polled, in all other cases tv specifies the
|
|
* maximum time to wait for a packet.
|
|
*
|
|
* Return:
|
|
* -1 on errors
|
|
* 0 on timeout
|
|
* +1 if packet received
|
|
*/
|
|
static int
|
|
snmp_receive_packet(struct snmp_pdu *pdu, struct timeval *tv)
|
|
{
|
|
int dopoll, setpoll;
|
|
int flags;
|
|
int saved_errno;
|
|
u_char *buf;
|
|
int ret;
|
|
struct asn_buf abuf;
|
|
int32_t ip;
|
|
socklen_t optlen;
|
|
|
|
if ((buf = malloc(snmp_client.rxbuflen)) == NULL) {
|
|
seterr("%s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
dopoll = setpoll = 0;
|
|
flags = 0;
|
|
if (tv != NULL) {
|
|
/* poll or timeout */
|
|
if (tv->tv_sec != 0 || tv->tv_usec != 0) {
|
|
/* wait with timeout */
|
|
if (setsockopt(snmp_client.fd, SOL_SOCKET, SO_RCVTIMEO,
|
|
tv, sizeof(*tv)) == -1) {
|
|
seterr("setsockopt: %s", strerror(errno));
|
|
free(buf);
|
|
return (-1);
|
|
}
|
|
optlen = sizeof(*tv);
|
|
if (getsockopt(snmp_client.fd, SOL_SOCKET, SO_RCVTIMEO,
|
|
tv, &optlen) == -1) {
|
|
seterr("getsockopt: %s", strerror(errno));
|
|
free(buf);
|
|
return (-1);
|
|
}
|
|
/* at this point tv_sec and tv_usec may appear
|
|
* as 0. This happens for timeouts lesser than
|
|
* the clock granularity. The kernel rounds these to
|
|
* 0 and this would result in a blocking receive.
|
|
* Instead of an else we check tv_sec and tv_usec
|
|
* again below and if this rounding happens,
|
|
* switch to a polling receive. */
|
|
}
|
|
if (tv->tv_sec == 0 && tv->tv_usec == 0) {
|
|
/* poll */
|
|
dopoll = 1;
|
|
if ((flags = fcntl(snmp_client.fd, F_GETFL, 0)) == -1) {
|
|
seterr("fcntl: %s", strerror(errno));
|
|
free(buf);
|
|
return (-1);
|
|
}
|
|
if (!(flags & O_NONBLOCK)) {
|
|
setpoll = 1;
|
|
flags |= O_NONBLOCK;
|
|
if (fcntl(snmp_client.fd, F_SETFL, flags) == -1) {
|
|
seterr("fcntl: %s", strerror(errno));
|
|
free(buf);
|
|
return (-1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ret = recv(snmp_client.fd, buf, snmp_client.rxbuflen, 0);
|
|
saved_errno = errno;
|
|
if (tv != NULL) {
|
|
if (dopoll) {
|
|
if (setpoll) {
|
|
flags &= ~O_NONBLOCK;
|
|
(void)fcntl(snmp_client.fd, F_SETFL, flags);
|
|
}
|
|
} else {
|
|
tv->tv_sec = 0;
|
|
tv->tv_usec = 0;
|
|
(void)setsockopt(snmp_client.fd, SOL_SOCKET, SO_RCVTIMEO,
|
|
tv, sizeof(*tv));
|
|
}
|
|
}
|
|
if (ret == -1) {
|
|
free(buf);
|
|
if (errno == EAGAIN || errno == EWOULDBLOCK)
|
|
return (0);
|
|
seterr("recv: %s", strerror(saved_errno));
|
|
return (-1);
|
|
}
|
|
if (ret == 0)
|
|
abort();
|
|
|
|
abuf.asn_ptr = buf;
|
|
abuf.asn_len = ret;
|
|
|
|
if (SNMP_CODE_OK != (ret = snmp_pdu_decode(&abuf, pdu, &ip))) {
|
|
seterr("snmp_decode_pdu: failed %d", ret);
|
|
free(buf);
|
|
return (-1);
|
|
}
|
|
free(buf);
|
|
if (snmp_client.dump_pdus)
|
|
snmp_pdu_dump(pdu);
|
|
|
|
return (+1);
|
|
}
|
|
|
|
static int
|
|
snmp_deliver_packet(struct snmp_pdu * resp)
|
|
{
|
|
struct sent_pdu *listentry;
|
|
|
|
if (resp->type != SNMP_PDU_RESPONSE) {
|
|
warn("ignoring snmp pdu %u", resp->type);
|
|
return (-1);
|
|
}
|
|
|
|
LIST_FOREACH(listentry, &sent_pdus, entries)
|
|
if (listentry->reqid == resp->request_id)
|
|
break;
|
|
if (listentry == NULL)
|
|
return (-1);
|
|
|
|
LIST_REMOVE(listentry, entries);
|
|
listentry->callback(listentry->pdu, resp, listentry->arg);
|
|
|
|
snmp_client.timeout_stop(listentry->timeout_id);
|
|
|
|
free(listentry);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
snmp_receive(int blocking)
|
|
{
|
|
int ret;
|
|
|
|
struct timeval tv;
|
|
struct snmp_pdu * resp;
|
|
|
|
memset(&tv, 0, sizeof(tv));
|
|
|
|
resp = malloc(sizeof(struct snmp_pdu));
|
|
if (resp == NULL) {
|
|
seterr("no memory for returning PDU");
|
|
return (-1) ;
|
|
}
|
|
|
|
if ((ret = snmp_receive_packet(resp, blocking ? NULL : &tv)) <= 0) {
|
|
free(resp);
|
|
return (ret);
|
|
}
|
|
ret = snmp_deliver_packet(resp);
|
|
snmp_pdu_free(resp);
|
|
free(resp);
|
|
return (ret);
|
|
}
|
|
|
|
|
|
/*
|
|
* Check a GETNEXT response. Here we have three possible outcomes: -1 an
|
|
* unexpected error happened. +1 response is ok and is within the table 0
|
|
* response is ok, but is behind the table or error is NOSUCHNAME. The req
|
|
* should point to a template PDU which contains the base OIDs and the
|
|
* syntaxes. This is really only useful to sweep non-sparse tables.
|
|
*/
|
|
static int
|
|
ok_getnext(const struct snmp_pdu * req, const struct snmp_pdu * resp)
|
|
{
|
|
u_int i;
|
|
|
|
if (resp->version != req->version) {
|
|
warnx("SNMP GETNEXT: response has wrong version");
|
|
return (-1);
|
|
}
|
|
|
|
if (resp->error_status == SNMP_ERR_NOSUCHNAME)
|
|
return (0);
|
|
|
|
if (resp->error_status != SNMP_ERR_NOERROR) {
|
|
warnx("SNMP GETNEXT: error %d", resp->error_status);
|
|
return (-1);
|
|
}
|
|
if (resp->nbindings != req->nbindings) {
|
|
warnx("SNMP GETNEXT: bad number of bindings in response");
|
|
return (-1);
|
|
}
|
|
for (i = 0; i < req->nbindings; i++) {
|
|
if (!asn_is_suboid(&req->bindings[i].var,
|
|
&resp->bindings[i].var)) {
|
|
if (i != 0)
|
|
warnx("SNMP GETNEXT: inconsistent table "
|
|
"response");
|
|
return (0);
|
|
}
|
|
if (resp->version != SNMP_V1 &&
|
|
resp->bindings[i].syntax == SNMP_SYNTAX_ENDOFMIBVIEW)
|
|
return (0);
|
|
|
|
if (resp->bindings[i].syntax != req->bindings[i].syntax) {
|
|
warnx("SNMP GETNEXT: bad syntax in response");
|
|
return (0);
|
|
}
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Check a GET response. Here we have three possible outcomes: -1 an
|
|
* unexpected error happened. +1 response is ok. 0 NOSUCHNAME The req should
|
|
* point to a template PDU which contains the OIDs and the syntaxes. This
|
|
* is only useful for SNMPv1 or single object GETS.
|
|
*/
|
|
static int
|
|
ok_get(const struct snmp_pdu * req, const struct snmp_pdu * resp)
|
|
{
|
|
u_int i;
|
|
|
|
if (resp->version != req->version) {
|
|
warnx("SNMP GET: response has wrong version");
|
|
return (-1);
|
|
}
|
|
|
|
if (resp->error_status == SNMP_ERR_NOSUCHNAME)
|
|
return (0);
|
|
|
|
if (resp->error_status != SNMP_ERR_NOERROR) {
|
|
warnx("SNMP GET: error %d", resp->error_status);
|
|
return (-1);
|
|
}
|
|
|
|
if (resp->nbindings != req->nbindings) {
|
|
warnx("SNMP GET: bad number of bindings in response");
|
|
return (-1);
|
|
}
|
|
for (i = 0; i < req->nbindings; i++) {
|
|
if (asn_compare_oid(&req->bindings[i].var,
|
|
&resp->bindings[i].var) != 0) {
|
|
warnx("SNMP GET: bad OID in response");
|
|
return (-1);
|
|
}
|
|
if (snmp_client.version != SNMP_V1 &&
|
|
(resp->bindings[i].syntax == SNMP_SYNTAX_NOSUCHOBJECT ||
|
|
resp->bindings[i].syntax == SNMP_SYNTAX_NOSUCHINSTANCE))
|
|
return (0);
|
|
if (resp->bindings[i].syntax != req->bindings[i].syntax) {
|
|
warnx("SNMP GET: bad syntax in response");
|
|
return (-1);
|
|
}
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Check the reponse to a SET PDU. We check: - the error status must be 0 -
|
|
* the number of bindings must be equal in response and request - the
|
|
* syntaxes must be the same in response and request - the OIDs must be the
|
|
* same in response and request
|
|
*/
|
|
static int
|
|
ok_set(const struct snmp_pdu * req, const struct snmp_pdu * resp)
|
|
{
|
|
u_int i;
|
|
|
|
if (resp->version != req->version) {
|
|
warnx("SNMP SET: response has wrong version");
|
|
return (-1);
|
|
}
|
|
|
|
if (resp->error_status == SNMP_ERR_NOSUCHNAME) {
|
|
warnx("SNMP SET: error %d", resp->error_status);
|
|
return (0);
|
|
}
|
|
if (resp->error_status != SNMP_ERR_NOERROR) {
|
|
warnx("SNMP SET: error %d", resp->error_status);
|
|
return (-1);
|
|
}
|
|
|
|
if (resp->nbindings != req->nbindings) {
|
|
warnx("SNMP SET: bad number of bindings in response");
|
|
return (-1);
|
|
}
|
|
for (i = 0; i < req->nbindings; i++) {
|
|
if (asn_compare_oid(&req->bindings[i].var,
|
|
&resp->bindings[i].var) != 0) {
|
|
warnx("SNMP SET: wrong OID in response to SET");
|
|
return (-1);
|
|
}
|
|
if (resp->bindings[i].syntax != req->bindings[i].syntax) {
|
|
warnx("SNMP SET: bad syntax in response");
|
|
return (-1);
|
|
}
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Simple checks for response PDUs against request PDUs. Return values: 1=ok,
|
|
* 0=nosuchname or similar, -1=failure, -2=no response at all
|
|
*/
|
|
int
|
|
snmp_pdu_check(const struct snmp_pdu *req,
|
|
const struct snmp_pdu *resp)
|
|
{
|
|
if (resp == NULL)
|
|
return (-2);
|
|
|
|
switch (req->type) {
|
|
|
|
case SNMP_PDU_GET:
|
|
return (ok_get(req, resp));
|
|
|
|
case SNMP_PDU_SET:
|
|
return (ok_set(req, resp));
|
|
|
|
case SNMP_PDU_GETNEXT:
|
|
return (ok_getnext(req, resp));
|
|
|
|
}
|
|
errx(1, "%s: bad pdu type %i", __func__, req->type);
|
|
}
|
|
|
|
int
|
|
snmp_dialog(struct snmp_v1_pdu *req, struct snmp_v1_pdu *resp)
|
|
{
|
|
u_int i;
|
|
int32_t reqid;
|
|
int ret;
|
|
struct timeval tv = snmp_client.timeout;
|
|
struct timeval end;
|
|
|
|
for (i = 0; i <= snmp_client.retries; i++) {
|
|
(void)gettimeofday(&end, NULL);
|
|
timeradd(&end, &snmp_client.timeout, &end);
|
|
if ((reqid = snmp_send_packet(req)) == -1)
|
|
return (-1);
|
|
for (;;) {
|
|
(void)gettimeofday(&tv, NULL);
|
|
if (timercmp(&end, &tv, <=))
|
|
break;
|
|
timersub(&end, &tv, &tv);
|
|
if ((ret = snmp_receive_packet(resp, &tv)) == 0)
|
|
/* timeout */
|
|
break;
|
|
|
|
if (ret > 0) {
|
|
if (reqid == resp->request_id)
|
|
return (0);
|
|
/* not for us */
|
|
(void)snmp_deliver_packet(resp);
|
|
}
|
|
}
|
|
}
|
|
seterr("retry count exceeded");
|
|
return (-1);
|
|
}
|
|
|
|
int
|
|
snmp_client_set_host(struct snmp_client *cl, const char *h)
|
|
{
|
|
char *np;
|
|
|
|
if (h == NULL) {
|
|
if (cl->chost != NULL)
|
|
free(cl->chost);
|
|
cl->chost = NULL;
|
|
} else {
|
|
if ((np = malloc(strlen(h) + 1)) == NULL)
|
|
return (-1);
|
|
strcpy(np, h);
|
|
if (cl->chost != NULL)
|
|
free(cl->chost);
|
|
cl->chost = np;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
snmp_client_set_port(struct snmp_client *cl, const char *p)
|
|
{
|
|
char *np;
|
|
|
|
if (p == NULL) {
|
|
if (cl->cport != NULL)
|
|
free(cl->cport);
|
|
cl->cport = NULL;
|
|
} else {
|
|
if ((np = malloc(strlen(p) + 1)) == NULL)
|
|
return (-1);
|
|
strcpy(np, p);
|
|
if (cl->cport != NULL)
|
|
free(cl->cport);
|
|
cl->cport = np;
|
|
}
|
|
return (0);
|
|
}
|