contrib/bsnmp/lib/snmpagent.c

   1 /*
   2  * Copyright (c) 2001-2003
   3  *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
   4  *      All rights reserved.
   5  *
   6  * Author: Harti Brandt <harti@freebsd.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $Begemot: bsnmp/lib/snmpagent.c,v 1.20 2005/10/04 11:21:33 brandt_h Exp $
  30  *
  31  * SNMP Agent functions
  32  */
  33 #include <sys/types.h>
  34 #include <sys/queue.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <stddef.h>
  38 #include <stdarg.h>
  39 #ifdef HAVE_STDINT_H
  40 #include <stdint.h>
  41 #elif defined(HAVE_INTTYPES_H)
  42 #include <inttypes.h>
  43 #endif
  44 #include <string.h>
  45
  46 #include "asn1.h"
  47 #include "snmp.h"
  48 #include "snmppriv.h"
  49 #include "snmpagent.h"
  50
  51 static void snmp_debug_func(const char *fmt, ...);
  52
  53 void (*snmp_debug)(const char *fmt, ...) = snmp_debug_func;
  54
  55 struct snmp_node *tree;
  56 u_int  tree_size;
  57
  58 /*
  59  * Structure to hold dependencies during SET processing
  60  * The last two members of this structure must be the
  61  * dependency visible by the user and the user data.
  62  */
  63 struct depend {
  64         TAILQ_ENTRY(depend) link;
  65         size_t  len;            /* size of data part */
  66         snmp_depop_t    func;
  67         struct snmp_dependency dep;
  68 #if defined(__GNUC__) && __GNUC__ < 3
  69         u_char  data[0];
  70 #else
  71         u_char  data[];
  72 #endif
  73 };
  74 TAILQ_HEAD(depend_list, depend);
  75
  76 /*
  77  * Set context
  78  */
  79 struct context {
  80         struct snmp_context     ctx;
  81         struct depend_list      dlist;
  82         const struct snmp_node  *node[SNMP_MAX_BINDINGS];
  83         struct snmp_scratch     scratch[SNMP_MAX_BINDINGS];
  84         struct depend           *depend;
  85 };
  86
  87 #define TR(W)   (snmp_trace & SNMP_TRACE_##W)
  88 u_int snmp_trace = 0;
  89
  90 static char oidbuf[ASN_OIDSTRLEN];
  91
  92 /*
  93  * Allocate a context
  94  */
  95 struct snmp_context *
  96 snmp_init_context(void)
  97 {
  98         struct context *context;
  99
 100         if ((context = malloc(sizeof(*context))) == NULL)
 101                 return (NULL);
 102
 103         memset(context, 0, sizeof(*context));
 104         TAILQ_INIT(&context->dlist);
 105
 106         return (&context->ctx);
 107 }
 108
 109 /*
 110  * Find a variable for SET/GET and the first GETBULK pass.
 111  * Return the node pointer. If the search fails, set the errp to
 112  * the correct SNMPv2 GET exception code.
 113  */
 114 static struct snmp_node *
 115 find_node(const struct snmp_value *value, enum snmp_syntax *errp)
 116 {
 117         struct snmp_node *tp;
 118
 119         if (TR(FIND))
 120                 snmp_debug("find: searching %s",
 121                     asn_oid2str_r(&value->var, oidbuf));
 122
 123         /*
 124          * If we have an exact match (the entry in the table is a
 125          * sub-oid from the variable) we have found what we are for.
 126          * If the table oid is higher than the variable, there is no match.
 127          */
 128         for (tp = tree; tp < tree + tree_size; tp++) {
 129                 if (asn_is_suboid(&tp->oid, &value->var))
 130                         goto found;
 131                 if (asn_compare_oid(&tp->oid, &value->var) >= 0)
 132                         break;
 133         }
 134
 135         if (TR(FIND))
 136                 snmp_debug("find: no match");
 137         *errp = SNMP_SYNTAX_NOSUCHOBJECT;
 138         return (NULL);
 139
 140   found:
 141         /* leafs must have a 0 instance identifier */
 142         if (tp->type == SNMP_NODE_LEAF &&
 143             (value->var.len != tp->oid.len + 1 ||
 144              value->var.subs[tp->oid.len] != 0)) {
 145                 if (TR(FIND))
 146                         snmp_debug("find: bad leaf index");
 147                 *errp = SNMP_SYNTAX_NOSUCHINSTANCE;
 148                 return (NULL);
 149         }
 150         if (TR(FIND))
 151                 snmp_debug("find: found %s",
 152                     asn_oid2str_r(&value->var, oidbuf));
 153         return (tp);
 154 }
 155
 156 static struct snmp_node *
 157 find_subnode(const struct snmp_value *value)
 158 {
 159         struct snmp_node *tp;
 160
 161         for (tp = tree; tp < tree + tree_size; tp++) {
 162                 if (asn_is_suboid(&value->var, &tp->oid))
 163                         return (tp);
 164         }
 165         return (NULL);
 166 }
 167
 168 /*
 169  * Execute a GET operation. The tree is rooted at the global 'root'.
 170  * Build the response PDU on the fly. If the return code is SNMP_RET_ERR
 171  * the pdu error status and index will be set.
 172  */
 173 enum snmp_ret
 174 snmp_get(struct snmp_pdu *pdu, struct asn_buf *resp_b,
 175     struct snmp_pdu *resp, void *data)
 176 {
 177         int ret;
 178         u_int i;
 179         struct snmp_node *tp;
 180         enum snmp_syntax except;
 181         struct context context;
 182         enum asn_err err;
 183
 184         memset(&context, 0, sizeof(context));
 185         context.ctx.data = data;
 186
 187         memset(resp, 0, sizeof(*resp));
 188         strcpy(resp->community, pdu->community);
 189         resp->version = pdu->version;
 190         resp->type = SNMP_PDU_RESPONSE;
 191         resp->request_id = pdu->request_id;
 192         resp->version = pdu->version;
 193
 194         if (snmp_pdu_encode_header(resp_b, resp) != SNMP_CODE_OK)
 195                 /* cannot even encode header - very bad */
 196                 return (SNMP_RET_IGN);
 197
 198         for (i = 0; i < pdu->nbindings; i++) {
 199                 resp->bindings[i].var = pdu->bindings[i].var;
 200                 if ((tp = find_node(&pdu->bindings[i], &except)) == NULL) {
 201                         if (pdu->version == SNMP_V1) {
 202                                 if (TR(GET))
 203                                         snmp_debug("get: nosuchname");
 204                                 pdu->error_status = SNMP_ERR_NOSUCHNAME;
 205                                 pdu->error_index = i + 1;
 206                                 snmp_pdu_free(resp);
 207                                 return (SNMP_RET_ERR);
 208                         }
 209                         if (TR(GET))
 210                                 snmp_debug("get: exception %u", except);
 211                         resp->bindings[i].syntax = except;
 212
 213                 } else {
 214                         /* call the action to fetch the value. */
 215                         resp->bindings[i].syntax = tp->syntax;
 216                         ret = (*tp->op)(&context.ctx, &resp->bindings[i],
 217                             tp->oid.len, tp->index, SNMP_OP_GET);
 218                         if (TR(GET))
 219                                 snmp_debug("get: action returns %d", ret);
 220
 221                         if (ret == SNMP_ERR_NOSUCHNAME) {
 222                                 if (pdu->version == SNMP_V1) {
 223                                         pdu->error_status = SNMP_ERR_NOSUCHNAME;
 224                                         pdu->error_index = i + 1;
 225                                         snmp_pdu_free(resp);
 226                                         return (SNMP_RET_ERR);
 227                                 }
 228                                 if (TR(GET))
 229                                         snmp_debug("get: exception noSuchInstance");
 230                                 resp->bindings[i].syntax = SNMP_SYNTAX_NOSUCHINSTANCE;
 231
 232                         } else if (ret != SNMP_ERR_NOERROR) {
 233                                 pdu->error_status = SNMP_ERR_GENERR;
 234                                 pdu->error_index = i + 1;
 235                                 snmp_pdu_free(resp);
 236                                 return (SNMP_RET_ERR);
 237                         }
 238                 }
 239                 resp->nbindings++;
 240
 241                 err = snmp_binding_encode(resp_b, &resp->bindings[i]);
 242
 243                 if (err == ASN_ERR_EOBUF) {
 244                         pdu->error_status = SNMP_ERR_TOOBIG;
 245                         pdu->error_index = 0;
 246                         snmp_pdu_free(resp);
 247                         return (SNMP_RET_ERR);
 248                 }
 249                 if (err != ASN_ERR_OK) {
 250                         if (TR(GET))
 251                                 snmp_debug("get: binding encoding: %u", err);
 252                         pdu->error_status = SNMP_ERR_GENERR;
 253                         pdu->error_index = i + 1;
 254                         snmp_pdu_free(resp);
 255                         return (SNMP_RET_ERR);
 256                 }
 257         }
 258
 259         return (snmp_fix_encoding(resp_b, resp));
 260 }
 261
 262 static struct snmp_node *
 263 next_node(const struct snmp_value *value, int *pnext)
 264 {
 265         struct snmp_node *tp;
 266
 267         if (TR(FIND))
 268                 snmp_debug("next: searching %s",
 269                     asn_oid2str_r(&value->var, oidbuf));
 270
 271         *pnext = 0;
 272         for (tp = tree; tp < tree + tree_size; tp++) {
 273                 if (asn_is_suboid(&tp->oid, &value->var)) {
 274                         /* the tree OID is a sub-oid of the requested OID. */
 275                         if (tp->type == SNMP_NODE_LEAF) {
 276                                 if (tp->oid.len == value->var.len) {
 277                                         /* request for scalar type */
 278                                         if (TR(FIND))
 279                                                 snmp_debug("next: found scalar %s",
 280                                                     asn_oid2str_r(&tp->oid, oidbuf));
 281                                         return (tp);
 282                                 }
 283                                 /* try next */
 284                         } else {
 285                                 if (TR(FIND))
 286                                         snmp_debug("next: found column %s",
 287                                             asn_oid2str_r(&tp->oid, oidbuf));
 288                                 return (tp);
 289                         }
 290                 } else if (asn_is_suboid(&value->var, &tp->oid) ||
 291                     asn_compare_oid(&tp->oid, &value->var) >= 0) {
 292                         if (TR(FIND))
 293                                 snmp_debug("next: found %s",
 294                                     asn_oid2str_r(&tp->oid, oidbuf));
 295                         *pnext = 1;
 296                         return (tp);
 297                 }
 298         }
 299
 300         if (TR(FIND))
 301                 snmp_debug("next: failed");
 302
 303         return (NULL);
 304 }
 305
 306 static enum snmp_ret
 307 do_getnext(struct context *context, const struct snmp_value *inb,
 308     struct snmp_value *outb, struct snmp_pdu *pdu)
 309 {
 310         const struct snmp_node *tp;
 311         int ret, next;
 312
 313         if ((tp = next_node(inb, &next)) == NULL)
 314                 goto eofMib;
 315
 316         /* retain old variable if we are doing a GETNEXT on an exact
 317          * matched leaf only */
 318         if (tp->type == SNMP_NODE_LEAF || next)
 319                 outb->var = tp->oid;
 320         else
 321                 outb->var = inb->var;
 322
 323         for (;;) {
 324                 outb->syntax = tp->syntax;
 325                 if (tp->type == SNMP_NODE_LEAF) {
 326                         /* make a GET operation */
 327                         outb->var.subs[outb->var.len++] = 0;
 328                         ret = (*tp->op)(&context->ctx, outb, tp->oid.len,
 329                             tp->index, SNMP_OP_GET);
 330                 } else {
 331                         /* make a GETNEXT */
 332                         ret = (*tp->op)(&context->ctx, outb, tp->oid.len,
 333                              tp->index, SNMP_OP_GETNEXT);
 334                 }
 335                 if (ret != SNMP_ERR_NOSUCHNAME) {
 336                         /* got something */
 337                         if (ret != SNMP_ERR_NOERROR && TR(GETNEXT))
 338                                 snmp_debug("getnext: %s returns %u",
 339                                     asn_oid2str(&outb->var), ret);
 340                         break;
 341                 }
 342
 343                 /* object has no data - try next */
 344                 if (++tp == tree + tree_size)
 345                         break;
 346
 347                 if (TR(GETNEXT))
 348                         snmp_debug("getnext: no data - avancing to %s",
 349                             asn_oid2str(&tp->oid));
 350
 351                 outb->var = tp->oid;
 352         }
 353
 354         if (ret == SNMP_ERR_NOSUCHNAME) {
 355   eofMib:
 356                 outb->var = inb->var;
 357                 if (pdu->version == SNMP_V1) {
 358                         pdu->error_status = SNMP_ERR_NOSUCHNAME;
 359                         return (SNMP_RET_ERR);
 360                 }
 361                 outb->syntax = SNMP_SYNTAX_ENDOFMIBVIEW;
 362
 363         } else if (ret != SNMP_ERR_NOERROR) {
 364                 pdu->error_status = SNMP_ERR_GENERR;
 365                 return (SNMP_RET_ERR);
 366         }
 367         return (SNMP_RET_OK);
 368 }
 369
 370
 371 /*
 372  * Execute a GETNEXT operation. The tree is rooted at the global 'root'.
 373  * Build the response PDU on the fly. The return is:
 374  */
 375 enum snmp_ret
 376 snmp_getnext(struct snmp_pdu *pdu, struct asn_buf *resp_b,
 377     struct snmp_pdu *resp, void *data)
 378 {
 379         struct context context;
 380         u_int i;
 381         enum asn_err err;
 382         enum snmp_ret result;
 383
 384         memset(&context, 0, sizeof(context));
 385         context.ctx.data = data;
 386
 387         memset(resp, 0, sizeof(*resp));
 388         strcpy(resp->community, pdu->community);
 389         resp->type = SNMP_PDU_RESPONSE;
 390         resp->request_id = pdu->request_id;
 391         resp->version = pdu->version;
 392
 393         if (snmp_pdu_encode_header(resp_b, resp))
 394                 return (SNMP_RET_IGN);
 395
 396         for (i = 0; i < pdu->nbindings; i++) {
 397                 result = do_getnext(&context, &pdu->bindings[i],
 398                     &resp->bindings[i], pdu);
 399
 400                 if (result != SNMP_RET_OK) {
 401                         pdu->error_index = i + 1;
 402                         snmp_pdu_free(resp);
 403                         return (result);
 404                 }
 405
 406                 resp->nbindings++;
 407
 408                 err = snmp_binding_encode(resp_b, &resp->bindings[i]);
 409
 410                 if (err == ASN_ERR_EOBUF) {
 411                         pdu->error_status = SNMP_ERR_TOOBIG;
 412                         pdu->error_index = 0;
 413                         snmp_pdu_free(resp);
 414                         return (SNMP_RET_ERR);
 415                 }
 416                 if (err != ASN_ERR_OK) {
 417                         if (TR(GET))
 418                                 snmp_debug("getnext: binding encoding: %u", err);
 419                         pdu->error_status = SNMP_ERR_GENERR;
 420                         pdu->error_index = i + 1;
 421                         snmp_pdu_free(resp);
 422                         return (SNMP_RET_ERR);
 423                 }
 424         }
 425         return (snmp_fix_encoding(resp_b, resp));
 426 }
 427
 428 enum snmp_ret
 429 snmp_getbulk(struct snmp_pdu *pdu, struct asn_buf *resp_b,
 430     struct snmp_pdu *resp, void *data)
 431 {
 432         struct context context;
 433         u_int i;
 434         int cnt;
 435         u_int non_rep;
 436         int eomib;
 437         enum snmp_ret result;
 438         enum asn_err err;
 439
 440         memset(&context, 0, sizeof(context));
 441         context.ctx.data = data;
 442
 443         memset(resp, 0, sizeof(*resp));
 444         strcpy(resp->community, pdu->community);
 445         resp->version = pdu->version;
 446         resp->type = SNMP_PDU_RESPONSE;
 447         resp->request_id = pdu->request_id;
 448         resp->version = pdu->version;
 449
 450         if (snmp_pdu_encode_header(resp_b, resp) != SNMP_CODE_OK)
 451                 /* cannot even encode header - very bad */
 452                 return (SNMP_RET_IGN);
 453
 454         if ((non_rep = pdu->error_status) > pdu->nbindings)
 455                 non_rep = pdu->nbindings;
 456
 457         /* non-repeaters */
 458         for (i = 0; i < non_rep; i++) {
 459                 result = do_getnext(&context, &pdu->bindings[i],
 460                     &resp->bindings[resp->nbindings], pdu);
 461
 462                 if (result != SNMP_RET_OK) {
 463                         pdu->error_index = i + 1;
 464                         snmp_pdu_free(resp);
 465                         return (result);
 466                 }
 467
 468                 err = snmp_binding_encode(resp_b,
 469                     &resp->bindings[resp->nbindings++]);
 470
 471                 if (err == ASN_ERR_EOBUF)
 472                         goto done;
 473
 474                 if (err != ASN_ERR_OK) {
 475                         if (TR(GET))
 476                                 snmp_debug("getnext: binding encoding: %u", err);
 477                         pdu->error_status = SNMP_ERR_GENERR;
 478                         pdu->error_index = i + 1;
 479                         snmp_pdu_free(resp);
 480                         return (SNMP_RET_ERR);
 481                 }
 482         }
 483
 484         if (non_rep == pdu->nbindings)
 485                 goto done;
 486
 487         /* repeates */
 488         for (cnt = 0; cnt < pdu->error_index; cnt++) {
 489                 eomib = 1;
 490                 for (i = non_rep; i < pdu->nbindings; i++) {
 491                         if (cnt == 0)
 492                                 result = do_getnext(&context, &pdu->bindings[i],
 493                                     &resp->bindings[resp->nbindings], pdu);
 494                         else
 495                                 result = do_getnext(&context,
 496                                     &resp->bindings[resp->nbindings -
 497                                     (pdu->nbindings - non_rep)],
 498                                     &resp->bindings[resp->nbindings], pdu);
 499
 500                         if (result != SNMP_RET_OK) {
 501                                 pdu->error_index = i + 1;
 502                                 snmp_pdu_free(resp);
 503                                 return (result);
 504                         }
 505                         if (resp->bindings[resp->nbindings].syntax !=
 506                             SNMP_SYNTAX_ENDOFMIBVIEW)
 507                                 eomib = 0;
 508
 509                         err = snmp_binding_encode(resp_b,
 510                             &resp->bindings[resp->nbindings++]);
 511
 512                         if (err == ASN_ERR_EOBUF)
 513                                 goto done;
 514
 515                         if (err != ASN_ERR_OK) {
 516                                 if (TR(GET))
 517                                         snmp_debug("getnext: binding encoding: %u", err);
 518                                 pdu->error_status = SNMP_ERR_GENERR;
 519                                 pdu->error_index = i + 1;
 520                                 snmp_pdu_free(resp);
 521                                 return (SNMP_RET_ERR);
 522                         }
 523                 }
 524                 if (eomib)
 525                         break;
 526         }
 527
 528   done:
 529         return (snmp_fix_encoding(resp_b, resp));
 530 }
 531
 532 /*
 533  * Rollback a SET operation. Failed index is 'i'.
 534  */
 535 static void
 536 rollback(struct context *context, struct snmp_pdu *pdu, u_int i)
 537 {
 538         struct snmp_value *b;
 539         const struct snmp_node *np;
 540         int ret;
 541
 542         while (i-- > 0) {
 543                 b = &pdu->bindings[i];
 544                 np = context->node[i];
 545
 546                 context->ctx.scratch = &context->scratch[i];
 547
 548                 ret = (*np->op)(&context->ctx, b, np->oid.len, np->index,
 549                     SNMP_OP_ROLLBACK);
 550
 551                 if (ret != SNMP_ERR_NOERROR) {
 552                         snmp_error("set: rollback failed (%d) on variable %s "
 553                             "index %u", ret, asn_oid2str(&b->var), i);
 554                         if (pdu->version != SNMP_V1) {
 555                                 pdu->error_status = SNMP_ERR_UNDO_FAILED;
 556                                 pdu->error_index = 0;
 557                         }
 558                 }
 559         }
 560 }
 561
 562 /*
 563  * Commit dependencies.
 564  */
 565 int
 566 snmp_dep_commit(struct snmp_context *ctx)
 567 {
 568         struct context *context = (struct context *)ctx;
 569         int ret;
 570
 571         TAILQ_FOREACH(context->depend, &context->dlist, link) {
 572                 ctx->dep = &context->depend->dep;
 573
 574                 if (TR(SET))
 575                         snmp_debug("set: dependency commit %s",
 576                             asn_oid2str(&ctx->dep->obj));
 577
 578                 ret = context->depend->func(ctx, ctx->dep, SNMP_DEPOP_COMMIT);
 579
 580                 if (ret != SNMP_ERR_NOERROR) {
 581                         if (TR(SET))
 582                                 snmp_debug("set: dependency failed %d", ret);
 583                         return (ret);
 584                 }
 585         }
 586         return (SNMP_ERR_NOERROR);
 587 }
 588
 589 /*
 590  * Rollback dependencies
 591  */
 592 int
 593 snmp_dep_rollback(struct snmp_context *ctx)
 594 {
 595         struct context *context = (struct context *)ctx;
 596         int ret, ret1;
 597         char objbuf[ASN_OIDSTRLEN];
 598         char idxbuf[ASN_OIDSTRLEN];
 599
 600         ret1 = SNMP_ERR_NOERROR;
 601         while ((context->depend =
 602             TAILQ_PREV(context->depend, depend_list, link)) != NULL) {
 603                 ctx->dep = &context->depend->dep;
 604
 605                 if (TR(SET))
 606                         snmp_debug("set: dependency rollback %s",
 607                             asn_oid2str(&ctx->dep->obj));
 608
 609                 ret = context->depend->func(ctx, ctx->dep, SNMP_DEPOP_ROLLBACK);
 610
 611                 if (ret != SNMP_ERR_NOERROR) {
 612                         snmp_debug("set: dep rollback returns %u: %s %s", ret,
 613                             asn_oid2str_r(&ctx->dep->obj, objbuf),
 614                             asn_oid2str_r(&ctx->dep->idx, idxbuf));
 615                         if (ret1 == SNMP_ERR_NOERROR)
 616                                 ret1 = ret;
 617                 }
 618         }
 619         return (ret1);
 620 }
 621
 622 void
 623 snmp_dep_finish(struct snmp_context *ctx)
 624 {
 625         struct context *context = (struct context *)ctx;
 626         struct depend *d;
 627
 628         while ((d = TAILQ_FIRST(&context->dlist)) != NULL) {
 629                 ctx->dep = &d->dep;
 630                 (void)d->func(ctx, ctx->dep, SNMP_DEPOP_FINISH);
 631                 TAILQ_REMOVE(&context->dlist, d, link);
 632                 free(d);
 633         }
 634 }
 635
 636 /*
 637  * Do a SET operation.
 638  */
 639 enum snmp_ret
 640 snmp_set(struct snmp_pdu *pdu, struct asn_buf *resp_b,
 641     struct snmp_pdu *resp, void *data)
 642 {
 643         int ret;
 644         u_int i;
 645         enum asn_err asnerr;
 646         struct context context;
 647         const struct snmp_node *np;
 648         struct snmp_value *b;
 649         enum snmp_syntax except;
 650
 651         memset(&context, 0, sizeof(context));
 652         TAILQ_INIT(&context.dlist);
 653         context.ctx.data = data;
 654
 655         memset(resp, 0, sizeof(*resp));
 656         strcpy(resp->community, pdu->community);
 657         resp->type = SNMP_PDU_RESPONSE;
 658         resp->request_id = pdu->request_id;
 659         resp->version = pdu->version;
 660
 661         if (snmp_pdu_encode_header(resp_b, resp))
 662                 return (SNMP_RET_IGN);
 663
 664         /*
 665          * 1. Find all nodes, check that they are writeable and
 666          *    that the syntax is ok, copy over the binding to the response.
 667          */
 668         for (i = 0; i < pdu->nbindings; i++) {
 669                 b = &pdu->bindings[i];
 670
 671                 if ((np = context.node[i] = find_node(b, &except)) == NULL) {
 672                         /* not found altogether or LEAF with wrong index */
 673                         if (TR(SET))
 674                                 snmp_debug("set: node not found %s",
 675                                     asn_oid2str_r(&b->var, oidbuf));
 676                         if (pdu->version == SNMP_V1) {
 677                                 pdu->error_index = i + 1;
 678                                 pdu->error_status = SNMP_ERR_NOSUCHNAME;
 679                         } else if ((np = find_subnode(b)) != NULL) {
 680                                 /* 2. intermediate object */
 681                                 pdu->error_index = i + 1;
 682                                 pdu->error_status = SNMP_ERR_NOT_WRITEABLE;
 683                         } else if (except == SNMP_SYNTAX_NOSUCHOBJECT) {
 684                                 pdu->error_index = i + 1;
 685                                 pdu->error_status = SNMP_ERR_NO_ACCESS;
 686                         } else {
 687                                 pdu->error_index = i + 1;
 688                                 pdu->error_status = SNMP_ERR_NO_CREATION;
 689                         }
 690                         snmp_pdu_free(resp);
 691                         return (SNMP_RET_ERR);
 692                 }
 693                 /*
 694                  * 2. write/createable?
 695                  * Can check this for leafs only, because in v2 we have
 696                  * to differentiate between NOT_WRITEABLE and NO_CREATION
 697                  * and only the action routine for COLUMNS knows, whether
 698                  * a column exists.
 699                  */
 700                 if (np->type == SNMP_NODE_LEAF &&
 701                     !(np->flags & SNMP_NODE_CANSET)) {
 702                         if (pdu->version == SNMP_V1) {
 703                                 pdu->error_index = i + 1;
 704                                 pdu->error_status = SNMP_ERR_NOSUCHNAME;
 705                         } else {
 706                                 pdu->error_index = i + 1;
 707                                 pdu->error_status = SNMP_ERR_NOT_WRITEABLE;
 708                         }
 709                         snmp_pdu_free(resp);
 710                         return (SNMP_RET_ERR);
 711                 }
 712                 /*
 713                  * 3. Ensure the right syntax
 714                  */
 715                 if (np->syntax != b->syntax) {
 716                         if (pdu->version == SNMP_V1) {
 717                                 pdu->error_index = i + 1;
 718                                 pdu->error_status = SNMP_ERR_BADVALUE; /* v2: wrongType */
 719                         } else {
 720                                 pdu->error_index = i + 1;
 721                                 pdu->error_status = SNMP_ERR_WRONG_TYPE;
 722                         }
 723                         snmp_pdu_free(resp);
 724                         return (SNMP_RET_ERR);
 725                 }
 726                 /*
 727                  * 4. Copy binding
 728                  */
 729                 if (snmp_value_copy(&resp->bindings[i], b)) {
 730                         pdu->error_index = i + 1;
 731                         pdu->error_status = SNMP_ERR_GENERR;
 732                         snmp_pdu_free(resp);
 733                         return (SNMP_RET_ERR);
 734                 }
 735                 asnerr = snmp_binding_encode(resp_b, &resp->bindings[i]);
 736                 if (asnerr == ASN_ERR_EOBUF) {
 737                         pdu->error_index = i + 1;
 738                         pdu->error_status = SNMP_ERR_TOOBIG;
 739                         snmp_pdu_free(resp);
 740                         return (SNMP_RET_ERR);
 741                 } else if (asnerr != ASN_ERR_OK) {
 742                         pdu->error_index = i + 1;
 743                         pdu->error_status = SNMP_ERR_GENERR;
 744                         snmp_pdu_free(resp);
 745                         return (SNMP_RET_ERR);
 746                 }
 747                 resp->nbindings++;
 748         }
 749
 750         context.ctx.code = SNMP_RET_OK;
 751
 752         /*
 753          * 2. Call the SET method for each node. If a SET fails, rollback
 754          *    everything. Map error codes depending on the version.
 755          */
 756         for (i = 0; i < pdu->nbindings; i++) {
 757                 b = &pdu->bindings[i];
 758                 np = context.node[i];
 759
 760                 context.ctx.var_index = i + 1;
 761                 context.ctx.scratch = &context.scratch[i];
 762
 763                 ret = (*np->op)(&context.ctx, b, np->oid.len, np->index,
 764                     SNMP_OP_SET);
 765
 766                 if (TR(SET))
 767                         snmp_debug("set: action %s returns %d", np->name, ret);
 768
 769                 if (pdu->version == SNMP_V1) {
 770                         switch (ret) {
 771                           case SNMP_ERR_NO_ACCESS:
 772                                 ret = SNMP_ERR_NOSUCHNAME;
 773                                 break;
 774                           case SNMP_ERR_WRONG_TYPE:
 775                                 /* should no happen */
 776                                 ret = SNMP_ERR_BADVALUE;
 777                                 break;
 778                           case SNMP_ERR_WRONG_LENGTH:
 779                                 ret = SNMP_ERR_BADVALUE;
 780                                 break;
 781                           case SNMP_ERR_WRONG_ENCODING:
 782                                 /* should not happen */
 783                                 ret = SNMP_ERR_BADVALUE;
 784                                 break;
 785                           case SNMP_ERR_WRONG_VALUE:
 786                                 ret = SNMP_ERR_BADVALUE;
 787                                 break;
 788                           case SNMP_ERR_NO_CREATION:
 789                                 ret = SNMP_ERR_NOSUCHNAME;
 790                                 break;
 791                           case SNMP_ERR_INCONS_VALUE:
 792                                 ret = SNMP_ERR_BADVALUE;
 793                                 break;
 794                           case SNMP_ERR_RES_UNAVAIL:
 795                                 ret = SNMP_ERR_GENERR;
 796                                 break;
 797                           case SNMP_ERR_COMMIT_FAILED:
 798                                 ret = SNMP_ERR_GENERR;
 799                                 break;
 800                           case SNMP_ERR_UNDO_FAILED:
 801                                 ret = SNMP_ERR_GENERR;
 802                                 break;
 803                           case SNMP_ERR_AUTH_ERR:
 804                                 /* should not happen */
 805                                 ret = SNMP_ERR_GENERR;
 806                                 break;
 807                           case SNMP_ERR_NOT_WRITEABLE:
 808                                 ret = SNMP_ERR_NOSUCHNAME;
 809                                 break;
 810                           case SNMP_ERR_INCONS_NAME:
 811                                 ret = SNMP_ERR_BADVALUE;
 812                                 break;
 813                         }
 814                 }
 815                 if (ret != SNMP_ERR_NOERROR) {
 816                         pdu->error_index = i + 1;
 817                         pdu->error_status = ret;
 818
 819                         rollback(&context, pdu, i);
 820                         snmp_pdu_free(resp);
 821
 822                         context.ctx.code = SNMP_RET_ERR;
 823
 824                         goto errout;
 825                 }
 826         }
 827
 828         /*
 829          * 3. Call dependencies
 830          */
 831         if (TR(SET))
 832                 snmp_debug("set: set operations ok");
 833
 834         if ((ret = snmp_dep_commit(&context.ctx)) != SNMP_ERR_NOERROR) {
 835                 pdu->error_status = ret;
 836                 pdu->error_index = context.ctx.var_index;
 837
 838                 if ((ret = snmp_dep_rollback(&context.ctx)) != SNMP_ERR_NOERROR) {
 839                         if (pdu->version != SNMP_V1) {
 840                                 pdu->error_status = SNMP_ERR_UNDO_FAILED;
 841                                 pdu->error_index = 0;
 842                         }
 843                 }
 844                 rollback(&context, pdu, i);
 845                 snmp_pdu_free(resp);
 846
 847                 context.ctx.code = SNMP_RET_ERR;
 848
 849                 goto errout;
 850         }
 851
 852         /*
 853          * 4. Commit and copy values from the original packet to the response.
 854          *    This is not the commit operation from RFC 1905 but rather an
 855          *    'FREE RESOURCES' operation. It shouldn't fail.
 856          */
 857         if (TR(SET))
 858                 snmp_debug("set: commiting");
 859
 860         for (i = 0; i < pdu->nbindings; i++) {
 861                 b = &resp->bindings[i];
 862                 np = context.node[i];
 863
 864                 context.ctx.var_index = i + 1;
 865                 context.ctx.scratch = &context.scratch[i];
 866
 867                 ret = (*np->op)(&context.ctx, b, np->oid.len, np->index,
 868                     SNMP_OP_COMMIT);
 869
 870                 if (ret != SNMP_ERR_NOERROR)
 871                         snmp_error("set: commit failed (%d) on"
 872                             " variable %s index %u", ret,
 873                             asn_oid2str_r(&b->var, oidbuf), i);
 874         }
 875
 876         if (snmp_fix_encoding(resp_b, resp) != SNMP_CODE_OK) {
 877                 snmp_error("set: fix_encoding failed");
 878                 snmp_pdu_free(resp);
 879                 context.ctx.code = SNMP_RET_IGN;
 880         }
 881
 882         /*
 883          * Done
 884          */
 885   errout:
 886         snmp_dep_finish(&context.ctx);
 887
 888         if (TR(SET))
 889                 snmp_debug("set: returning %d", context.ctx.code);
 890
 891         return (context.ctx.code);
 892 }
 893 /*
 894  * Lookup a dependency. If it doesn't exist, create one
 895  */
 896 struct snmp_dependency *
 897 snmp_dep_lookup(struct snmp_context *ctx, const struct asn_oid *obj,
 898     const struct asn_oid *idx, size_t len, snmp_depop_t func)
 899 {
 900         struct context *context;
 901         struct depend *d;
 902
 903         context = (struct context *)(void *)
 904             ((char *)ctx - offsetof(struct context, ctx));
 905         if (TR(DEPEND)) {
 906                 snmp_debug("depend: looking for %s", asn_oid2str(obj));
 907                 if (idx)
 908                         snmp_debug("depend: index is %s", asn_oid2str(idx));
 909         }
 910         TAILQ_FOREACH(d, &context->dlist, link)
 911                 if (asn_compare_oid(obj, &d->dep.obj) == 0 &&
 912                     ((idx == NULL && d->dep.idx.len == 0) ||
 913                      (idx != NULL && asn_compare_oid(idx, &d->dep.idx) == 0))) {
 914                         if(TR(DEPEND))
 915                                 snmp_debug("depend: found");
 916                         return (&d->dep);
 917                 }
 918
 919         if(TR(DEPEND))
 920                 snmp_debug("depend: creating");
 921
 922         if ((d = malloc(offsetof(struct depend, dep) + len)) == NULL)
 923                 return (NULL);
 924         memset(&d->dep, 0, len);
 925
 926         d->dep.obj = *obj;
 927         if (idx == NULL)
 928                 d->dep.idx.len = 0;
 929         else
 930                 d->dep.idx = *idx;
 931         d->len = len;
 932         d->func = func;
 933
 934         TAILQ_INSERT_TAIL(&context->dlist, d, link);
 935
 936         return (&d->dep);
 937 }
 938
 939 /*
 940  * Make an error response from a PDU. We do this without decoding the
 941  * variable bindings. This means we can sent the junk back to a caller
 942  * that has sent us junk in the first place.
 943  */
 944 enum snmp_ret
 945 snmp_make_errresp(const struct snmp_pdu *pdu, struct asn_buf *pdu_b,
 946     struct asn_buf *resp_b)
 947 {
 948         asn_len_t len;
 949         struct snmp_pdu resp;
 950         enum asn_err err;
 951         enum snmp_code code;
 952
 953         memset(&resp, 0, sizeof(resp));
 954
 955         /* Message sequence */
 956         if (asn_get_sequence(pdu_b, &len) != ASN_ERR_OK)
 957                 return (SNMP_RET_IGN);
 958         if (pdu_b->asn_len < len)
 959                 return (SNMP_RET_IGN);
 960
 961         err = snmp_parse_message_hdr(pdu_b, &resp, &len);
 962         if (ASN_ERR_STOPPED(err))
 963                 return (SNMP_RET_IGN);
 964         if (pdu_b->asn_len < len)
 965                 return (SNMP_RET_IGN);
 966         pdu_b->asn_len = len;
 967
 968         err = snmp_parse_pdus_hdr(pdu_b, &resp, &len);
 969         if (ASN_ERR_STOPPED(err))
 970                 return (SNMP_RET_IGN);
 971         if (pdu_b->asn_len < len)
 972                 return (SNMP_RET_IGN);
 973         pdu_b->asn_len = len;
 974
 975         /* now we have the bindings left - construct new message */
 976         resp.error_status = pdu->error_status;
 977         resp.error_index = pdu->error_index;
 978         resp.type = SNMP_PDU_RESPONSE;
 979
 980         code = snmp_pdu_encode_header(resp_b, &resp);
 981         if (code != SNMP_CODE_OK)
 982                 return (SNMP_RET_IGN);
 983
 984         if (pdu_b->asn_len > resp_b->asn_len)
 985                 /* too short */
 986                 return (SNMP_RET_IGN);
 987         (void)memcpy(resp_b->asn_ptr, pdu_b->asn_cptr, pdu_b->asn_len);
 988         resp_b->asn_len -= pdu_b->asn_len;
 989         resp_b->asn_ptr += pdu_b->asn_len;
 990
 991         code = snmp_fix_encoding(resp_b, &resp);
 992         if (code != SNMP_CODE_OK)
 993                 return (SNMP_RET_IGN);
 994
 995         return (SNMP_RET_OK);
 996 }
 997
 998 static void
 999 snmp_debug_func(const char *fmt, ...)
1000 {
1001         va_list ap;
1002
1003         va_start(ap, fmt);
1004         vfprintf(stderr, fmt, ap);
1005         va_end(ap);
1006         fprintf(stderr, "\n");
1007 }