Annotation of embedaddon/quagga/lib/smux.c, revision 1.1
1.1 ! misho 1: /* SNMP support
! 2: * Copyright (C) 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
! 3: *
! 4: * This file is part of GNU Zebra.
! 5: *
! 6: * GNU Zebra is free software; you can redistribute it and/or modify it
! 7: * under the terms of the GNU General Public License as published by the
! 8: * Free Software Foundation; either version 2, or (at your option) any
! 9: * later version.
! 10: *
! 11: * GNU Zebra is distributed in the hope that it will be useful, but
! 12: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 14: * General Public License for more details.
! 15: *
! 16: * You should have received a copy of the GNU General Public License
! 17: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 18: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 19: * 02111-1307, USA.
! 20: */
! 21:
! 22: #include <zebra.h>
! 23:
! 24: #ifdef HAVE_SNMP
! 25: #ifdef HAVE_NETSNMP
! 26: #include <net-snmp/net-snmp-config.h>
! 27: #include <net-snmp/net-snmp-includes.h>
! 28: #else
! 29: #include <asn1.h>
! 30: #include <snmp.h>
! 31: #include <snmp_impl.h>
! 32: #endif
! 33:
! 34: #include "log.h"
! 35: #include "thread.h"
! 36: #include "linklist.h"
! 37: #include "command.h"
! 38: #include <lib/version.h>
! 39: #include "memory.h"
! 40: #include "sockunion.h"
! 41: #include "smux.h"
! 42:
! 43: #define min(A,B) ((A) < (B) ? (A) : (B))
! 44:
! 45: enum smux_event {SMUX_SCHEDULE, SMUX_CONNECT, SMUX_READ};
! 46:
! 47: void smux_event (enum smux_event, int);
! 48:
! 49:
! 50: /* SMUX socket. */
! 51: int smux_sock = -1;
! 52:
! 53: /* SMUX subtree list. */
! 54: struct list *treelist;
! 55:
! 56: /* SMUX oid. */
! 57: oid *smux_oid = NULL;
! 58: size_t smux_oid_len;
! 59:
! 60: /* SMUX password. */
! 61: char *smux_passwd = NULL;
! 62:
! 63: /* SMUX read threads. */
! 64: struct thread *smux_read_thread;
! 65:
! 66: /* SMUX connect thrads. */
! 67: struct thread *smux_connect_thread;
! 68:
! 69: /* SMUX debug flag. */
! 70: int debug_smux = 0;
! 71:
! 72: /* SMUX failure count. */
! 73: int fail = 0;
! 74:
! 75: /* SMUX node. */
! 76: static struct cmd_node smux_node =
! 77: {
! 78: SMUX_NODE,
! 79: "" /* SMUX has no interface. */
! 80: };
! 81:
! 82: /* thread master */
! 83: static struct thread_master *master;
! 84:
! 85: void *
! 86: oid_copy (void *dest, const void *src, size_t size)
! 87: {
! 88: return memcpy (dest, src, size * sizeof (oid));
! 89: }
! 90:
! 91: void
! 92: oid2in_addr (oid oid[], int len, struct in_addr *addr)
! 93: {
! 94: int i;
! 95: u_char *pnt;
! 96:
! 97: if (len == 0)
! 98: return;
! 99:
! 100: pnt = (u_char *) addr;
! 101:
! 102: for (i = 0; i < len; i++)
! 103: *pnt++ = oid[i];
! 104: }
! 105:
! 106: void
! 107: oid_copy_addr (oid oid[], struct in_addr *addr, int len)
! 108: {
! 109: int i;
! 110: u_char *pnt;
! 111:
! 112: if (len == 0)
! 113: return;
! 114:
! 115: pnt = (u_char *) addr;
! 116:
! 117: for (i = 0; i < len; i++)
! 118: oid[i] = *pnt++;
! 119: }
! 120:
! 121: int
! 122: oid_compare (oid *o1, int o1_len, oid *o2, int o2_len)
! 123: {
! 124: int i;
! 125:
! 126: for (i = 0; i < min (o1_len, o2_len); i++)
! 127: {
! 128: if (o1[i] < o2[i])
! 129: return -1;
! 130: else if (o1[i] > o2[i])
! 131: return 1;
! 132: }
! 133: if (o1_len < o2_len)
! 134: return -1;
! 135: if (o1_len > o2_len)
! 136: return 1;
! 137:
! 138: return 0;
! 139: }
! 140:
! 141: static int
! 142: oid_compare_part (oid *o1, int o1_len, oid *o2, int o2_len)
! 143: {
! 144: int i;
! 145:
! 146: for (i = 0; i < min (o1_len, o2_len); i++)
! 147: {
! 148: if (o1[i] < o2[i])
! 149: return -1;
! 150: else if (o1[i] > o2[i])
! 151: return 1;
! 152: }
! 153: if (o1_len < o2_len)
! 154: return -1;
! 155:
! 156: return 0;
! 157: }
! 158:
! 159: static void
! 160: smux_oid_dump (const char *prefix, const oid *oid, size_t oid_len)
! 161: {
! 162: unsigned int i;
! 163: int first = 1;
! 164: char buf[MAX_OID_LEN * 3];
! 165:
! 166: buf[0] = '\0';
! 167:
! 168: for (i = 0; i < oid_len; i++)
! 169: {
! 170: sprintf (buf + strlen (buf), "%s%d", first ? "" : ".", (int) oid[i]);
! 171: first = 0;
! 172: }
! 173: zlog_debug ("%s: %s", prefix, buf);
! 174: }
! 175:
! 176: static int
! 177: smux_socket (void)
! 178: {
! 179: int ret;
! 180: #ifdef HAVE_IPV6
! 181: struct addrinfo hints, *res0, *res;
! 182: int gai;
! 183: #else
! 184: struct sockaddr_in serv;
! 185: struct servent *sp;
! 186: #endif
! 187: int sock = 0;
! 188:
! 189: #ifdef HAVE_IPV6
! 190: memset(&hints, 0, sizeof(hints));
! 191: hints.ai_family = PF_UNSPEC;
! 192: hints.ai_socktype = SOCK_STREAM;
! 193: gai = getaddrinfo(NULL, "smux", &hints, &res0);
! 194: if (gai == EAI_SERVICE)
! 195: {
! 196: char servbuf[NI_MAXSERV];
! 197: sprintf(servbuf,"%d",SMUX_PORT_DEFAULT);
! 198: servbuf[sizeof (servbuf) - 1] = '\0';
! 199: gai = getaddrinfo(NULL, servbuf, &hints, &res0);
! 200: }
! 201: if (gai)
! 202: {
! 203: zlog_warn("Cannot locate loopback service smux");
! 204: return -1;
! 205: }
! 206: for(res=res0; res; res=res->ai_next)
! 207: {
! 208: if (res->ai_family != AF_INET
! 209: #ifdef HAVE_IPV6
! 210: && res->ai_family != AF_INET6
! 211: #endif /* HAVE_IPV6 */
! 212: )
! 213: continue;
! 214:
! 215: sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
! 216: if (sock < 0)
! 217: continue;
! 218: sockopt_reuseaddr (sock);
! 219: sockopt_reuseport (sock);
! 220: ret = connect (sock, res->ai_addr, res->ai_addrlen);
! 221: if (ret < 0)
! 222: {
! 223: close(sock);
! 224: sock = -1;
! 225: continue;
! 226: }
! 227: break;
! 228: }
! 229: freeaddrinfo(res0);
! 230: if (sock < 0)
! 231: zlog_warn ("Can't connect to SNMP agent with SMUX");
! 232: #else
! 233: sock = socket (AF_INET, SOCK_STREAM, 0);
! 234: if (sock < 0)
! 235: {
! 236: zlog_warn ("Can't make socket for SNMP");
! 237: return -1;
! 238: }
! 239:
! 240: memset (&serv, 0, sizeof (struct sockaddr_in));
! 241: serv.sin_family = AF_INET;
! 242: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 243: serv.sin_len = sizeof (struct sockaddr_in);
! 244: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 245:
! 246: sp = getservbyname ("smux", "tcp");
! 247: if (sp != NULL)
! 248: serv.sin_port = sp->s_port;
! 249: else
! 250: serv.sin_port = htons (SMUX_PORT_DEFAULT);
! 251:
! 252: serv.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
! 253:
! 254: sockopt_reuseaddr (sock);
! 255: sockopt_reuseport (sock);
! 256:
! 257: ret = connect (sock, (struct sockaddr *) &serv, sizeof (struct sockaddr_in));
! 258: if (ret < 0)
! 259: {
! 260: close (sock);
! 261: smux_sock = -1;
! 262: zlog_warn ("Can't connect to SNMP agent with SMUX");
! 263: return -1;
! 264: }
! 265: #endif
! 266: return sock;
! 267: }
! 268:
! 269: static void
! 270: smux_getresp_send (oid objid[], size_t objid_len, long reqid, long errstat,
! 271: long errindex, u_char val_type, void *arg, size_t arg_len)
! 272: {
! 273: int ret;
! 274: u_char buf[BUFSIZ];
! 275: u_char *ptr, *h1, *h1e, *h2, *h2e;
! 276: size_t len, length;
! 277:
! 278: ptr = buf;
! 279: len = BUFSIZ;
! 280: length = len;
! 281:
! 282: if (debug_smux)
! 283: {
! 284: zlog_debug ("SMUX GETRSP send");
! 285: zlog_debug ("SMUX GETRSP reqid: %ld", reqid);
! 286: }
! 287:
! 288: h1 = ptr;
! 289: /* Place holder h1 for complete sequence */
! 290: ptr = asn_build_sequence (ptr, &len, (u_char) SMUX_GETRSP, 0);
! 291: h1e = ptr;
! 292:
! 293: ptr = asn_build_int (ptr, &len,
! 294: (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 295: &reqid, sizeof (reqid));
! 296:
! 297: if (debug_smux)
! 298: zlog_debug ("SMUX GETRSP errstat: %ld", errstat);
! 299:
! 300: ptr = asn_build_int (ptr, &len,
! 301: (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 302: &errstat, sizeof (errstat));
! 303: if (debug_smux)
! 304: zlog_debug ("SMUX GETRSP errindex: %ld", errindex);
! 305:
! 306: ptr = asn_build_int (ptr, &len,
! 307: (u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 308: &errindex, sizeof (errindex));
! 309:
! 310: h2 = ptr;
! 311: /* Place holder h2 for one variable */
! 312: ptr = asn_build_sequence (ptr, &len,
! 313: (u_char)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
! 314: 0);
! 315: h2e = ptr;
! 316:
! 317: ptr = snmp_build_var_op (ptr, objid, &objid_len,
! 318: val_type, arg_len, arg, &len);
! 319:
! 320: /* Now variable size is known, fill in size */
! 321: asn_build_sequence(h2,&length,(u_char)(ASN_SEQUENCE|ASN_CONSTRUCTOR),ptr-h2e);
! 322:
! 323: /* Fill in size of whole sequence */
! 324: asn_build_sequence(h1,&length,(u_char)SMUX_GETRSP,ptr-h1e);
! 325:
! 326: if (debug_smux)
! 327: zlog_debug ("SMUX getresp send: %td", (ptr - buf));
! 328:
! 329: ret = send (smux_sock, buf, (ptr - buf), 0);
! 330: }
! 331:
! 332: static u_char *
! 333: smux_var (u_char *ptr, size_t len, oid objid[], size_t *objid_len,
! 334: size_t *var_val_len,
! 335: u_char *var_val_type,
! 336: void **var_value)
! 337: {
! 338: u_char type;
! 339: u_char val_type;
! 340: size_t val_len;
! 341: u_char *val;
! 342:
! 343: if (debug_smux)
! 344: zlog_debug ("SMUX var parse: len %zd", len);
! 345:
! 346: /* Parse header. */
! 347: ptr = asn_parse_header (ptr, &len, &type);
! 348:
! 349: if (debug_smux)
! 350: {
! 351: zlog_debug ("SMUX var parse: type %d len %zd", type, len);
! 352: zlog_debug ("SMUX var parse: type must be %d",
! 353: (ASN_SEQUENCE | ASN_CONSTRUCTOR));
! 354: }
! 355:
! 356: /* Parse var option. */
! 357: *objid_len = MAX_OID_LEN;
! 358: ptr = snmp_parse_var_op(ptr, objid, objid_len, &val_type,
! 359: &val_len, &val, &len);
! 360:
! 361: if (var_val_len)
! 362: *var_val_len = val_len;
! 363:
! 364: if (var_value)
! 365: *var_value = (void*) val;
! 366:
! 367: if (var_val_type)
! 368: *var_val_type = val_type;
! 369:
! 370: /* Requested object id length is objid_len. */
! 371: if (debug_smux)
! 372: smux_oid_dump ("Request OID", objid, *objid_len);
! 373:
! 374: if (debug_smux)
! 375: zlog_debug ("SMUX val_type: %d", val_type);
! 376:
! 377: /* Check request value type. */
! 378: if (debug_smux)
! 379: switch (val_type)
! 380: {
! 381: case ASN_NULL:
! 382: /* In case of SMUX_GET or SMUX_GET_NEXT val_type is set to
! 383: ASN_NULL. */
! 384: zlog_debug ("ASN_NULL");
! 385: break;
! 386:
! 387: case ASN_INTEGER:
! 388: zlog_debug ("ASN_INTEGER");
! 389: break;
! 390: case ASN_COUNTER:
! 391: case ASN_GAUGE:
! 392: case ASN_TIMETICKS:
! 393: case ASN_UINTEGER:
! 394: zlog_debug ("ASN_COUNTER");
! 395: break;
! 396: case ASN_COUNTER64:
! 397: zlog_debug ("ASN_COUNTER64");
! 398: break;
! 399: case ASN_IPADDRESS:
! 400: zlog_debug ("ASN_IPADDRESS");
! 401: break;
! 402: case ASN_OCTET_STR:
! 403: zlog_debug ("ASN_OCTET_STR");
! 404: break;
! 405: case ASN_OPAQUE:
! 406: case ASN_NSAP:
! 407: case ASN_OBJECT_ID:
! 408: zlog_debug ("ASN_OPAQUE");
! 409: break;
! 410: case SNMP_NOSUCHOBJECT:
! 411: zlog_debug ("SNMP_NOSUCHOBJECT");
! 412: break;
! 413: case SNMP_NOSUCHINSTANCE:
! 414: zlog_debug ("SNMP_NOSUCHINSTANCE");
! 415: break;
! 416: case SNMP_ENDOFMIBVIEW:
! 417: zlog_debug ("SNMP_ENDOFMIBVIEW");
! 418: break;
! 419: case ASN_BIT_STR:
! 420: zlog_debug ("ASN_BIT_STR");
! 421: break;
! 422: default:
! 423: zlog_debug ("Unknown type");
! 424: break;
! 425: }
! 426: return ptr;
! 427: }
! 428:
! 429: /* NOTE: all 3 functions (smux_set, smux_get & smux_getnext) are based on
! 430: ucd-snmp smux and as such suppose, that the peer receives in the message
! 431: only one variable. Fortunately, IBM seems to do the same in AIX. */
! 432:
! 433: static int
! 434: smux_set (oid *reqid, size_t *reqid_len,
! 435: u_char val_type, void *val, size_t val_len, int action)
! 436: {
! 437: int j;
! 438: struct subtree *subtree;
! 439: struct variable *v;
! 440: int subresult;
! 441: oid *suffix;
! 442: size_t suffix_len;
! 443: int result;
! 444: u_char *statP = NULL;
! 445: WriteMethod *write_method = NULL;
! 446: struct listnode *node, *nnode;
! 447:
! 448: /* Check */
! 449: for (ALL_LIST_ELEMENTS (treelist, node, nnode, subtree))
! 450: {
! 451: subresult = oid_compare_part (reqid, *reqid_len,
! 452: subtree->name, subtree->name_len);
! 453:
! 454: /* Subtree matched. */
! 455: if (subresult == 0)
! 456: {
! 457: /* Prepare suffix. */
! 458: suffix = reqid + subtree->name_len;
! 459: suffix_len = *reqid_len - subtree->name_len;
! 460: result = subresult;
! 461:
! 462: /* Check variables. */
! 463: for (j = 0; j < subtree->variables_num; j++)
! 464: {
! 465: v = &subtree->variables[j];
! 466:
! 467: /* Always check suffix */
! 468: result = oid_compare_part (suffix, suffix_len,
! 469: v->name, v->namelen);
! 470:
! 471: /* This is exact match so result must be zero. */
! 472: if (result == 0)
! 473: {
! 474: if (debug_smux)
! 475: zlog_debug ("SMUX function call index is %d", v->magic);
! 476:
! 477: statP = (*v->findVar) (v, suffix, &suffix_len, 1,
! 478: &val_len, &write_method);
! 479:
! 480: if (write_method)
! 481: {
! 482: return (*write_method)(action, val, val_type, val_len,
! 483: statP, suffix, suffix_len, v);
! 484: }
! 485: else
! 486: {
! 487: return SNMP_ERR_READONLY;
! 488: }
! 489: }
! 490:
! 491: /* If above execution is failed or oid is small (so
! 492: there is no further match). */
! 493: if (result < 0)
! 494: return SNMP_ERR_NOSUCHNAME;
! 495: }
! 496: }
! 497: }
! 498: return SNMP_ERR_NOSUCHNAME;
! 499: }
! 500:
! 501: static int
! 502: smux_get (oid *reqid, size_t *reqid_len, int exact,
! 503: u_char *val_type,void **val, size_t *val_len)
! 504: {
! 505: int j;
! 506: struct subtree *subtree;
! 507: struct variable *v;
! 508: int subresult;
! 509: oid *suffix;
! 510: size_t suffix_len;
! 511: int result;
! 512: WriteMethod *write_method=NULL;
! 513: struct listnode *node, *nnode;
! 514:
! 515: /* Check */
! 516: for (ALL_LIST_ELEMENTS (treelist, node, nnode,subtree))
! 517: {
! 518: subresult = oid_compare_part (reqid, *reqid_len,
! 519: subtree->name, subtree->name_len);
! 520:
! 521: /* Subtree matched. */
! 522: if (subresult == 0)
! 523: {
! 524: /* Prepare suffix. */
! 525: suffix = reqid + subtree->name_len;
! 526: suffix_len = *reqid_len - subtree->name_len;
! 527: result = subresult;
! 528:
! 529: /* Check variables. */
! 530: for (j = 0; j < subtree->variables_num; j++)
! 531: {
! 532: v = &subtree->variables[j];
! 533:
! 534: /* Always check suffix */
! 535: result = oid_compare_part (suffix, suffix_len,
! 536: v->name, v->namelen);
! 537:
! 538: /* This is exact match so result must be zero. */
! 539: if (result == 0)
! 540: {
! 541: if (debug_smux)
! 542: zlog_debug ("SMUX function call index is %d", v->magic);
! 543:
! 544: *val = (*v->findVar) (v, suffix, &suffix_len, exact,
! 545: val_len, &write_method);
! 546:
! 547: /* There is no instance. */
! 548: if (*val == NULL)
! 549: return SNMP_NOSUCHINSTANCE;
! 550:
! 551: /* Call is suceed. */
! 552: *val_type = v->type;
! 553:
! 554: return 0;
! 555: }
! 556:
! 557: /* If above execution is failed or oid is small (so
! 558: there is no further match). */
! 559: if (result < 0)
! 560: return SNMP_ERR_NOSUCHNAME;
! 561: }
! 562: }
! 563: }
! 564: return SNMP_ERR_NOSUCHNAME;
! 565: }
! 566:
! 567: static int
! 568: smux_getnext (oid *reqid, size_t *reqid_len, int exact,
! 569: u_char *val_type,void **val, size_t *val_len)
! 570: {
! 571: int j;
! 572: oid save[MAX_OID_LEN];
! 573: int savelen = 0;
! 574: struct subtree *subtree;
! 575: struct variable *v;
! 576: int subresult;
! 577: oid *suffix;
! 578: size_t suffix_len;
! 579: int result;
! 580: WriteMethod *write_method=NULL;
! 581: struct listnode *node, *nnode;
! 582:
! 583:
! 584: /* Save incoming request. */
! 585: oid_copy (save, reqid, *reqid_len);
! 586: savelen = *reqid_len;
! 587:
! 588: /* Check */
! 589: for (ALL_LIST_ELEMENTS (treelist, node, nnode, subtree))
! 590: {
! 591: subresult = oid_compare_part (reqid, *reqid_len,
! 592: subtree->name, subtree->name_len);
! 593:
! 594: /* If request is in the tree. The agent has to make sure we
! 595: only receive requests we have registered for. */
! 596: /* Unfortunately, that's not true. In fact, a SMUX subagent has to
! 597: behave as if it manages the whole SNMP MIB tree itself. It's the
! 598: duty of the master agent to collect the best answer and return it
! 599: to the manager. See RFC 1227 chapter 3.1.6 for the glory details
! 600: :-). ucd-snmp really behaves bad here as it actually might ask
! 601: multiple times for the same GETNEXT request as it throws away the
! 602: answer when it expects it in a different subtree and might come
! 603: back later with the very same request. --jochen */
! 604:
! 605: if (subresult <= 0)
! 606: {
! 607: /* Prepare suffix. */
! 608: suffix = reqid + subtree->name_len;
! 609: suffix_len = *reqid_len - subtree->name_len;
! 610: if (subresult < 0)
! 611: {
! 612: oid_copy(reqid, subtree->name, subtree->name_len);
! 613: *reqid_len = subtree->name_len;
! 614: }
! 615: for (j = 0; j < subtree->variables_num; j++)
! 616: {
! 617: result = subresult;
! 618: v = &subtree->variables[j];
! 619:
! 620: /* Next then check result >= 0. */
! 621: if (result == 0)
! 622: result = oid_compare_part (suffix, suffix_len,
! 623: v->name, v->namelen);
! 624:
! 625: if (result <= 0)
! 626: {
! 627: if (debug_smux)
! 628: zlog_debug ("SMUX function call index is %d", v->magic);
! 629: if(result<0)
! 630: {
! 631: oid_copy(suffix, v->name, v->namelen);
! 632: suffix_len = v->namelen;
! 633: }
! 634: *val = (*v->findVar) (v, suffix, &suffix_len, exact,
! 635: val_len, &write_method);
! 636: *reqid_len = suffix_len + subtree->name_len;
! 637: if (*val)
! 638: {
! 639: *val_type = v->type;
! 640: return 0;
! 641: }
! 642: }
! 643: }
! 644: }
! 645: }
! 646: memcpy (reqid, save, savelen * sizeof(oid));
! 647: *reqid_len = savelen;
! 648:
! 649: return SNMP_ERR_NOSUCHNAME;
! 650: }
! 651:
! 652: /* GET message header. */
! 653: static u_char *
! 654: smux_parse_get_header (u_char *ptr, size_t *len, long *reqid)
! 655: {
! 656: u_char type;
! 657: long errstat;
! 658: long errindex;
! 659:
! 660: /* Request ID. */
! 661: ptr = asn_parse_int (ptr, len, &type, reqid, sizeof (*reqid));
! 662:
! 663: if (debug_smux)
! 664: zlog_debug ("SMUX GET reqid: %d len: %d", (int) *reqid, (int) *len);
! 665:
! 666: /* Error status. */
! 667: ptr = asn_parse_int (ptr, len, &type, &errstat, sizeof (errstat));
! 668:
! 669: if (debug_smux)
! 670: zlog_debug ("SMUX GET errstat %ld len: %zd", errstat, *len);
! 671:
! 672: /* Error index. */
! 673: ptr = asn_parse_int (ptr, len, &type, &errindex, sizeof (errindex));
! 674:
! 675: if (debug_smux)
! 676: zlog_debug ("SMUX GET errindex %ld len: %zd", errindex, *len);
! 677:
! 678: return ptr;
! 679: }
! 680:
! 681: static void
! 682: smux_parse_set (u_char *ptr, size_t len, int action)
! 683: {
! 684: long reqid;
! 685: oid oid[MAX_OID_LEN];
! 686: size_t oid_len;
! 687: u_char val_type;
! 688: void *val;
! 689: size_t val_len;
! 690: int ret;
! 691:
! 692: if (debug_smux)
! 693: zlog_debug ("SMUX SET(%s) message parse: len %zd",
! 694: (RESERVE1 == action) ? "RESERVE1" : ((FREE == action) ? "FREE" : "COMMIT"),
! 695: len);
! 696:
! 697: /* Parse SET message header. */
! 698: ptr = smux_parse_get_header (ptr, &len, &reqid);
! 699:
! 700: /* Parse SET message object ID. */
! 701: ptr = smux_var (ptr, len, oid, &oid_len, &val_len, &val_type, &val);
! 702:
! 703: ret = smux_set (oid, &oid_len, val_type, val, val_len, action);
! 704: if (debug_smux)
! 705: zlog_debug ("SMUX SET ret %d", ret);
! 706:
! 707: /* Return result. */
! 708: if (RESERVE1 == action)
! 709: smux_getresp_send (oid, oid_len, reqid, ret, 3, ASN_NULL, NULL, 0);
! 710: }
! 711:
! 712: static void
! 713: smux_parse_get (u_char *ptr, size_t len, int exact)
! 714: {
! 715: long reqid;
! 716: oid oid[MAX_OID_LEN];
! 717: size_t oid_len;
! 718: u_char val_type;
! 719: void *val;
! 720: size_t val_len;
! 721: int ret;
! 722:
! 723: if (debug_smux)
! 724: zlog_debug ("SMUX GET message parse: len %zd", len);
! 725:
! 726: /* Parse GET message header. */
! 727: ptr = smux_parse_get_header (ptr, &len, &reqid);
! 728:
! 729: /* Parse GET message object ID. We needn't the value come */
! 730: ptr = smux_var (ptr, len, oid, &oid_len, NULL, NULL, NULL);
! 731:
! 732: /* Traditional getstatptr. */
! 733: if (exact)
! 734: ret = smux_get (oid, &oid_len, exact, &val_type, &val, &val_len);
! 735: else
! 736: ret = smux_getnext (oid, &oid_len, exact, &val_type, &val, &val_len);
! 737:
! 738: /* Return result. */
! 739: if (ret == 0)
! 740: smux_getresp_send (oid, oid_len, reqid, 0, 0, val_type, val, val_len);
! 741: else
! 742: smux_getresp_send (oid, oid_len, reqid, ret, 3, ASN_NULL, NULL, 0);
! 743: }
! 744:
! 745: /* Parse SMUX_CLOSE message. */
! 746: static void
! 747: smux_parse_close (u_char *ptr, int len)
! 748: {
! 749: long reason = 0;
! 750:
! 751: while (len--)
! 752: {
! 753: reason = (reason << 8) | (long) *ptr;
! 754: ptr++;
! 755: }
! 756: zlog_info ("SMUX_CLOSE with reason: %ld", reason);
! 757: }
! 758:
! 759: /* SMUX_RRSP message. */
! 760: static void
! 761: smux_parse_rrsp (u_char *ptr, size_t len)
! 762: {
! 763: u_char val;
! 764: long errstat;
! 765:
! 766: ptr = asn_parse_int (ptr, &len, &val, &errstat, sizeof (errstat));
! 767:
! 768: if (debug_smux)
! 769: zlog_debug ("SMUX_RRSP value: %d errstat: %ld", val, errstat);
! 770: }
! 771:
! 772: /* Parse SMUX message. */
! 773: static int
! 774: smux_parse (u_char *ptr, size_t len)
! 775: {
! 776: /* This buffer we'll use for SOUT message. We could allocate it with
! 777: malloc and save only static pointer/lenght, but IMHO static
! 778: buffer is a faster solusion. */
! 779: static u_char sout_save_buff[SMUXMAXPKTSIZE];
! 780: static int sout_save_len = 0;
! 781:
! 782: int len_income = len; /* see note below: YYY */
! 783: u_char type;
! 784: u_char rollback;
! 785:
! 786: rollback = ptr[2]; /* important only for SMUX_SOUT */
! 787:
! 788: process_rest: /* see note below: YYY */
! 789:
! 790: /* Parse SMUX message type and subsequent length. */
! 791: ptr = asn_parse_header (ptr, &len, &type);
! 792:
! 793: if (debug_smux)
! 794: zlog_debug ("SMUX message received type: %d rest len: %zd", type, len);
! 795:
! 796: switch (type)
! 797: {
! 798: case SMUX_OPEN:
! 799: /* Open must be not send from SNMP agent. */
! 800: zlog_warn ("SMUX_OPEN received: resetting connection.");
! 801: return -1;
! 802: break;
! 803: case SMUX_RREQ:
! 804: /* SMUX_RREQ message is invalid for us. */
! 805: zlog_warn ("SMUX_RREQ received: resetting connection.");
! 806: return -1;
! 807: break;
! 808: case SMUX_SOUT:
! 809: /* SMUX_SOUT message is now valied for us. */
! 810: if (debug_smux)
! 811: zlog_debug ("SMUX_SOUT(%s)", rollback ? "rollback" : "commit");
! 812:
! 813: if (sout_save_len > 0)
! 814: {
! 815: smux_parse_set (sout_save_buff, sout_save_len, rollback ? FREE : COMMIT);
! 816: sout_save_len = 0;
! 817: }
! 818: else
! 819: zlog_warn ("SMUX_SOUT sout_save_len=%d - invalid", (int) sout_save_len);
! 820:
! 821: if (len_income > 3)
! 822: {
! 823: /* YYY: this strange code has to solve the "slow peer"
! 824: problem: When agent sends SMUX_SOUT message it doesn't
! 825: wait any responce and may send some next message to
! 826: subagent. Then the peer in 'smux_read()' will recieve
! 827: from socket the 'concatenated' buffer, contaning both
! 828: SMUX_SOUT message and the next one
! 829: (SMUX_GET/SMUX_GETNEXT/SMUX_GET). So we should check: if
! 830: the buffer is longer than 3 ( length of SMUX_SOUT ), we
! 831: must process the rest of it. This effect may be observed
! 832: if 'debug_smux' is set to '1' */
! 833: ptr++;
! 834: len = len_income - 3;
! 835: goto process_rest;
! 836: }
! 837: break;
! 838: case SMUX_GETRSP:
! 839: /* SMUX_GETRSP message is invalid for us. */
! 840: zlog_warn ("SMUX_GETRSP received: resetting connection.");
! 841: return -1;
! 842: break;
! 843: case SMUX_CLOSE:
! 844: /* Close SMUX connection. */
! 845: if (debug_smux)
! 846: zlog_debug ("SMUX_CLOSE");
! 847: smux_parse_close (ptr, len);
! 848: return -1;
! 849: break;
! 850: case SMUX_RRSP:
! 851: /* This is response for register message. */
! 852: if (debug_smux)
! 853: zlog_debug ("SMUX_RRSP");
! 854: smux_parse_rrsp (ptr, len);
! 855: break;
! 856: case SMUX_GET:
! 857: /* Exact request for object id. */
! 858: if (debug_smux)
! 859: zlog_debug ("SMUX_GET");
! 860: smux_parse_get (ptr, len, 1);
! 861: break;
! 862: case SMUX_GETNEXT:
! 863: /* Next request for object id. */
! 864: if (debug_smux)
! 865: zlog_debug ("SMUX_GETNEXT");
! 866: smux_parse_get (ptr, len, 0);
! 867: break;
! 868: case SMUX_SET:
! 869: /* SMUX_SET is supported with some limitations. */
! 870: if (debug_smux)
! 871: zlog_debug ("SMUX_SET");
! 872:
! 873: /* save the data for future SMUX_SOUT */
! 874: memcpy (sout_save_buff, ptr, len);
! 875: sout_save_len = len;
! 876: smux_parse_set (ptr, len, RESERVE1);
! 877: break;
! 878: default:
! 879: zlog_info ("Unknown type: %d", type);
! 880: break;
! 881: }
! 882: return 0;
! 883: }
! 884:
! 885: /* SMUX message read function. */
! 886: static int
! 887: smux_read (struct thread *t)
! 888: {
! 889: int sock;
! 890: int len;
! 891: u_char buf[SMUXMAXPKTSIZE];
! 892: int ret;
! 893:
! 894: /* Clear thread. */
! 895: sock = THREAD_FD (t);
! 896: smux_read_thread = NULL;
! 897:
! 898: if (debug_smux)
! 899: zlog_debug ("SMUX read start");
! 900:
! 901: /* Read message from SMUX socket. */
! 902: len = recv (sock, buf, SMUXMAXPKTSIZE, 0);
! 903:
! 904: if (len < 0)
! 905: {
! 906: zlog_warn ("Can't read all SMUX packet: %s", safe_strerror (errno));
! 907: close (sock);
! 908: smux_sock = -1;
! 909: smux_event (SMUX_CONNECT, 0);
! 910: return -1;
! 911: }
! 912:
! 913: if (len == 0)
! 914: {
! 915: zlog_warn ("SMUX connection closed: %d", sock);
! 916: close (sock);
! 917: smux_sock = -1;
! 918: smux_event (SMUX_CONNECT, 0);
! 919: return -1;
! 920: }
! 921:
! 922: if (debug_smux)
! 923: zlog_debug ("SMUX read len: %d", len);
! 924:
! 925: /* Parse the message. */
! 926: ret = smux_parse (buf, len);
! 927:
! 928: if (ret < 0)
! 929: {
! 930: close (sock);
! 931: smux_sock = -1;
! 932: smux_event (SMUX_CONNECT, 0);
! 933: return -1;
! 934: }
! 935:
! 936: /* Regiser read thread. */
! 937: smux_event (SMUX_READ, sock);
! 938:
! 939: return 0;
! 940: }
! 941:
! 942: static int
! 943: smux_open (int sock)
! 944: {
! 945: u_char buf[BUFSIZ];
! 946: u_char *ptr;
! 947: size_t len;
! 948: long version;
! 949: u_char progname[] = QUAGGA_PROGNAME "-" QUAGGA_VERSION;
! 950:
! 951: if (debug_smux)
! 952: {
! 953: smux_oid_dump ("SMUX open oid", smux_oid, smux_oid_len);
! 954: zlog_debug ("SMUX open progname: %s", progname);
! 955: zlog_debug ("SMUX open password: %s", smux_passwd);
! 956: }
! 957:
! 958: ptr = buf;
! 959: len = BUFSIZ;
! 960:
! 961: /* SMUX Header. As placeholder. */
! 962: ptr = asn_build_header (ptr, &len, (u_char) SMUX_OPEN, 0);
! 963:
! 964: /* SMUX Open. */
! 965: version = 0;
! 966: ptr = asn_build_int (ptr, &len,
! 967: (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 968: &version, sizeof (version));
! 969:
! 970: /* SMUX connection oid. */
! 971: ptr = asn_build_objid (ptr, &len,
! 972: (u_char)
! 973: (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
! 974: smux_oid, smux_oid_len);
! 975:
! 976: /* SMUX connection description. */
! 977: ptr = asn_build_string (ptr, &len,
! 978: (u_char)
! 979: (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR),
! 980: progname, strlen (progname));
! 981:
! 982: /* SMUX connection password. */
! 983: ptr = asn_build_string (ptr, &len,
! 984: (u_char)
! 985: (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR),
! 986: (u_char *)smux_passwd, strlen (smux_passwd));
! 987:
! 988: /* Fill in real SMUX header. We exclude ASN header size (2). */
! 989: len = BUFSIZ;
! 990: asn_build_header (buf, &len, (u_char) SMUX_OPEN, (ptr - buf) - 2);
! 991:
! 992: return send (sock, buf, (ptr - buf), 0);
! 993: }
! 994:
! 995: int
! 996: smux_trap (const oid *name, size_t namelen,
! 997: const oid *iname, size_t inamelen,
! 998: const struct trap_object *trapobj, size_t trapobjlen,
! 999: unsigned int tick, u_char sptrap)
! 1000: {
! 1001: unsigned int i;
! 1002: u_char buf[BUFSIZ];
! 1003: u_char *ptr;
! 1004: size_t len, length;
! 1005: struct in_addr addr;
! 1006: unsigned long val;
! 1007: u_char *h1, *h1e;
! 1008:
! 1009: ptr = buf;
! 1010: len = BUFSIZ;
! 1011: length = len;
! 1012:
! 1013: /* When SMUX connection is not established. */
! 1014: if (smux_sock < 0)
! 1015: return 0;
! 1016:
! 1017: /* SMUX header. */
! 1018: ptr = asn_build_header (ptr, &len, (u_char) SMUX_TRAP, 0);
! 1019:
! 1020: /* Sub agent enterprise oid. */
! 1021: ptr = asn_build_objid (ptr, &len,
! 1022: (u_char)
! 1023: (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
! 1024: smux_oid, smux_oid_len);
! 1025:
! 1026: /* IP address. */
! 1027: addr.s_addr = 0;
! 1028: ptr = asn_build_string (ptr, &len,
! 1029: (u_char)
! 1030: (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_IPADDRESS),
! 1031: (u_char *)&addr, sizeof (addr));
! 1032:
! 1033: /* Generic trap integer. */
! 1034: val = SNMP_TRAP_ENTERPRISESPECIFIC;
! 1035: ptr = asn_build_int (ptr, &len,
! 1036: (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 1037: (long *)&val, sizeof (val));
! 1038:
! 1039: /* Specific trap integer. */
! 1040: val = sptrap;
! 1041: ptr = asn_build_int (ptr, &len,
! 1042: (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 1043: (long *)&val, sizeof (val));
! 1044:
! 1045: /* Timeticks timestamp. */
! 1046: val = 0;
! 1047: ptr = asn_build_unsigned_int (ptr, &len,
! 1048: (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_TIMETICKS),
! 1049: &val, sizeof (val));
! 1050:
! 1051: /* Variables. */
! 1052: h1 = ptr;
! 1053: ptr = asn_build_sequence (ptr, &len,
! 1054: (u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
! 1055: 0);
! 1056:
! 1057:
! 1058: /* Iteration for each objects. */
! 1059: h1e = ptr;
! 1060: for (i = 0; i < trapobjlen; i++)
! 1061: {
! 1062: int ret;
! 1063: oid oid[MAX_OID_LEN];
! 1064: size_t oid_len;
! 1065: void *val;
! 1066: size_t val_len;
! 1067: u_char val_type;
! 1068:
! 1069: /* Make OID. */
! 1070: if (trapobj[i].namelen > 0)
! 1071: {
! 1072: oid_copy (oid, name, namelen);
! 1073: oid_copy (oid + namelen, trapobj[i].name, trapobj[i].namelen);
! 1074: oid_copy (oid + namelen + trapobj[i].namelen, iname, inamelen);
! 1075: oid_len = namelen + trapobj[i].namelen + inamelen;
! 1076: }
! 1077: else
! 1078: {
! 1079: oid_copy (oid, name, namelen);
! 1080: oid_copy (oid + namelen, trapobj[i].name, trapobj[i].namelen * (-1));
! 1081: oid_len = namelen + trapobj[i].namelen * (-1) ;
! 1082: }
! 1083:
! 1084: if (debug_smux)
! 1085: {
! 1086: smux_oid_dump ("Trap", name, namelen);
! 1087: if (trapobj[i].namelen < 0)
! 1088: smux_oid_dump ("Trap",
! 1089: trapobj[i].name, (- 1) * (trapobj[i].namelen));
! 1090: else
! 1091: {
! 1092: smux_oid_dump ("Trap", trapobj[i].name, (trapobj[i].namelen));
! 1093: smux_oid_dump ("Trap", iname, inamelen);
! 1094: }
! 1095: smux_oid_dump ("Trap", oid, oid_len);
! 1096: zlog_info ("BUFSIZ: %d // oid_len: %lu", BUFSIZ, (u_long)oid_len);
! 1097: }
! 1098:
! 1099: ret = smux_get (oid, &oid_len, 1, &val_type, &val, &val_len);
! 1100:
! 1101: if (debug_smux)
! 1102: zlog_debug ("smux_get result %d", ret);
! 1103:
! 1104: if (ret == 0)
! 1105: ptr = snmp_build_var_op (ptr, oid, &oid_len,
! 1106: val_type, val_len, val, &len);
! 1107: }
! 1108:
! 1109: /* Now variable size is known, fill in size */
! 1110: asn_build_sequence(h1, &length,
! 1111: (u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
! 1112: ptr - h1e);
! 1113:
! 1114: /* Fill in size of whole sequence */
! 1115: len = BUFSIZ;
! 1116: asn_build_header (buf, &len, (u_char) SMUX_TRAP, (ptr - buf) - 2);
! 1117:
! 1118: return send (smux_sock, buf, (ptr - buf), 0);
! 1119: }
! 1120:
! 1121: static int
! 1122: smux_register (int sock)
! 1123: {
! 1124: u_char buf[BUFSIZ];
! 1125: u_char *ptr;
! 1126: int ret;
! 1127: size_t len;
! 1128: long priority;
! 1129: long operation;
! 1130: struct subtree *subtree;
! 1131: struct listnode *node, *nnode;
! 1132:
! 1133: ret = 0;
! 1134:
! 1135: for (ALL_LIST_ELEMENTS (treelist, node, nnode, subtree))
! 1136: {
! 1137: ptr = buf;
! 1138: len = BUFSIZ;
! 1139:
! 1140: /* SMUX RReq Header. */
! 1141: ptr = asn_build_header (ptr, &len, (u_char) SMUX_RREQ, 0);
! 1142:
! 1143: /* Register MIB tree. */
! 1144: ptr = asn_build_objid (ptr, &len,
! 1145: (u_char)
! 1146: (ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
! 1147: subtree->name, subtree->name_len);
! 1148:
! 1149: /* Priority. */
! 1150: priority = -1;
! 1151: ptr = asn_build_int (ptr, &len,
! 1152: (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 1153: &priority, sizeof (priority));
! 1154:
! 1155: /* Operation. */
! 1156: operation = 2; /* Register R/W */
! 1157: ptr = asn_build_int (ptr, &len,
! 1158: (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
! 1159: &operation, sizeof (operation));
! 1160:
! 1161: if (debug_smux)
! 1162: {
! 1163: smux_oid_dump ("SMUX register oid", subtree->name, subtree->name_len);
! 1164: zlog_debug ("SMUX register priority: %ld", priority);
! 1165: zlog_debug ("SMUX register operation: %ld", operation);
! 1166: }
! 1167:
! 1168: len = BUFSIZ;
! 1169: asn_build_header (buf, &len, (u_char) SMUX_RREQ, (ptr - buf) - 2);
! 1170: ret = send (sock, buf, (ptr - buf), 0);
! 1171: if (ret < 0)
! 1172: return ret;
! 1173: }
! 1174: return ret;
! 1175: }
! 1176:
! 1177: /* Try to connect to SNMP agent. */
! 1178: static int
! 1179: smux_connect (struct thread *t)
! 1180: {
! 1181: int ret;
! 1182:
! 1183: if (debug_smux)
! 1184: zlog_debug ("SMUX connect try %d", fail + 1);
! 1185:
! 1186: /* Clear thread poner of myself. */
! 1187: smux_connect_thread = NULL;
! 1188:
! 1189: /* Make socket. Try to connect. */
! 1190: smux_sock = smux_socket ();
! 1191: if (smux_sock < 0)
! 1192: {
! 1193: if (++fail < SMUX_MAX_FAILURE)
! 1194: smux_event (SMUX_CONNECT, 0);
! 1195: return 0;
! 1196: }
! 1197:
! 1198: /* Send OPEN PDU. */
! 1199: ret = smux_open (smux_sock);
! 1200: if (ret < 0)
! 1201: {
! 1202: zlog_warn ("SMUX open message send failed: %s", safe_strerror (errno));
! 1203: close (smux_sock);
! 1204: smux_sock = -1;
! 1205: if (++fail < SMUX_MAX_FAILURE)
! 1206: smux_event (SMUX_CONNECT, 0);
! 1207: return -1;
! 1208: }
! 1209:
! 1210: /* Send any outstanding register PDUs. */
! 1211: ret = smux_register (smux_sock);
! 1212: if (ret < 0)
! 1213: {
! 1214: zlog_warn ("SMUX register message send failed: %s", safe_strerror (errno));
! 1215: close (smux_sock);
! 1216: smux_sock = -1;
! 1217: if (++fail < SMUX_MAX_FAILURE)
! 1218: smux_event (SMUX_CONNECT, 0);
! 1219: return -1;
! 1220: }
! 1221:
! 1222: /* Everything goes fine. */
! 1223: smux_event (SMUX_READ, smux_sock);
! 1224:
! 1225: return 0;
! 1226: }
! 1227:
! 1228: /* Clear all SMUX related resources. */
! 1229: static void
! 1230: smux_stop (void)
! 1231: {
! 1232: if (smux_read_thread)
! 1233: {
! 1234: thread_cancel (smux_read_thread);
! 1235: smux_read_thread = NULL;
! 1236: }
! 1237:
! 1238: if (smux_connect_thread)
! 1239: {
! 1240: thread_cancel (smux_connect_thread);
! 1241: smux_connect_thread = NULL;
! 1242: }
! 1243:
! 1244: if (smux_sock >= 0)
! 1245: {
! 1246: close (smux_sock);
! 1247: smux_sock = -1;
! 1248: }
! 1249: }
! 1250:
! 1251:
! 1252:
! 1253: void
! 1254: smux_event (enum smux_event event, int sock)
! 1255: {
! 1256: switch (event)
! 1257: {
! 1258: case SMUX_SCHEDULE:
! 1259: smux_connect_thread = thread_add_event (master, smux_connect, NULL, 0);
! 1260: break;
! 1261: case SMUX_CONNECT:
! 1262: smux_connect_thread = thread_add_timer (master, smux_connect, NULL, 10);
! 1263: break;
! 1264: case SMUX_READ:
! 1265: smux_read_thread = thread_add_read (master, smux_read, NULL, sock);
! 1266: break;
! 1267: default:
! 1268: break;
! 1269: }
! 1270: }
! 1271:
! 1272: static int
! 1273: smux_str2oid (const char *str, oid *oid, size_t *oid_len)
! 1274: {
! 1275: int len;
! 1276: int val;
! 1277:
! 1278: len = 0;
! 1279: val = 0;
! 1280: *oid_len = 0;
! 1281:
! 1282: if (*str == '.')
! 1283: str++;
! 1284: if (*str == '\0')
! 1285: return 0;
! 1286:
! 1287: while (1)
! 1288: {
! 1289: if (! isdigit (*str))
! 1290: return -1;
! 1291:
! 1292: while (isdigit (*str))
! 1293: {
! 1294: val *= 10;
! 1295: val += (*str - '0');
! 1296: str++;
! 1297: }
! 1298:
! 1299: if (*str == '\0')
! 1300: break;
! 1301: if (*str != '.')
! 1302: return -1;
! 1303:
! 1304: oid[len++] = val;
! 1305: val = 0;
! 1306: str++;
! 1307: }
! 1308:
! 1309: oid[len++] = val;
! 1310: *oid_len = len;
! 1311:
! 1312: return 0;
! 1313: }
! 1314:
! 1315: static oid *
! 1316: smux_oid_dup (oid *objid, size_t objid_len)
! 1317: {
! 1318: oid *new;
! 1319:
! 1320: new = XMALLOC (MTYPE_TMP, sizeof (oid) * objid_len);
! 1321: oid_copy (new, objid, objid_len);
! 1322:
! 1323: return new;
! 1324: }
! 1325:
! 1326: static int
! 1327: smux_peer_oid (struct vty *vty, const char *oid_str, const char *passwd_str)
! 1328: {
! 1329: int ret;
! 1330: oid oid[MAX_OID_LEN];
! 1331: size_t oid_len;
! 1332:
! 1333: ret = smux_str2oid (oid_str, oid, &oid_len);
! 1334: if (ret != 0)
! 1335: {
! 1336: vty_out (vty, "object ID malformed%s", VTY_NEWLINE);
! 1337: return CMD_WARNING;
! 1338: }
! 1339:
! 1340: if (smux_oid)
! 1341: {
! 1342: free (smux_oid);
! 1343: smux_oid = NULL;
! 1344: }
! 1345:
! 1346: /* careful, smux_passwd might point to string constant */
! 1347: if (smux_passwd)
! 1348: {
! 1349: free (smux_passwd);
! 1350: smux_passwd = NULL;
! 1351: }
! 1352:
! 1353: smux_oid = smux_oid_dup (oid, oid_len);
! 1354: smux_oid_len = oid_len;
! 1355:
! 1356: if (passwd_str)
! 1357: smux_passwd = strdup (passwd_str);
! 1358: else
! 1359: smux_passwd = strdup ("");
! 1360:
! 1361: return 0;
! 1362: }
! 1363:
! 1364: int
! 1365: smux_header_generic (struct variable *v, oid *name, size_t *length, int exact,
! 1366: size_t *var_len, WriteMethod **write_method)
! 1367: {
! 1368: oid fulloid[MAX_OID_LEN];
! 1369: int ret;
! 1370:
! 1371: oid_copy (fulloid, v->name, v->namelen);
! 1372: fulloid[v->namelen] = 0;
! 1373: /* Check against full instance. */
! 1374: ret = oid_compare (name, *length, fulloid, v->namelen + 1);
! 1375:
! 1376: /* Check single instance. */
! 1377: if ((exact && (ret != 0)) || (!exact && (ret >= 0)))
! 1378: return MATCH_FAILED;
! 1379:
! 1380: /* In case of getnext, fill in full instance. */
! 1381: memcpy (name, fulloid, (v->namelen + 1) * sizeof (oid));
! 1382: *length = v->namelen + 1;
! 1383:
! 1384: *write_method = 0;
! 1385: *var_len = sizeof(long); /* default to 'long' results */
! 1386:
! 1387: return MATCH_SUCCEEDED;
! 1388: }
! 1389:
! 1390: static int
! 1391: smux_peer_default (void)
! 1392: {
! 1393: if (smux_oid)
! 1394: {
! 1395: free (smux_oid);
! 1396: smux_oid = NULL;
! 1397: }
! 1398:
! 1399: /* careful, smux_passwd might be pointing at string constant */
! 1400: if (smux_passwd)
! 1401: {
! 1402: free (smux_passwd);
! 1403: smux_passwd = NULL;
! 1404: }
! 1405:
! 1406: return CMD_SUCCESS;
! 1407: }
! 1408:
! 1409: DEFUN (smux_peer,
! 1410: smux_peer_cmd,
! 1411: "smux peer OID",
! 1412: "SNMP MUX protocol settings\n"
! 1413: "SNMP MUX peer settings\n"
! 1414: "Object ID used in SMUX peering\n")
! 1415: {
! 1416: if (smux_peer_oid (vty, argv[0], NULL) == 0)
! 1417: {
! 1418: smux_start();
! 1419: return CMD_SUCCESS;
! 1420: }
! 1421: else
! 1422: return CMD_WARNING;
! 1423: }
! 1424:
! 1425: DEFUN (smux_peer_password,
! 1426: smux_peer_password_cmd,
! 1427: "smux peer OID PASSWORD",
! 1428: "SNMP MUX protocol settings\n"
! 1429: "SNMP MUX peer settings\n"
! 1430: "SMUX peering object ID\n"
! 1431: "SMUX peering password\n")
! 1432: {
! 1433: if (smux_peer_oid (vty, argv[0], argv[1]) == 0)
! 1434: {
! 1435: smux_start();
! 1436: return CMD_SUCCESS;
! 1437: }
! 1438: else
! 1439: return CMD_WARNING;
! 1440: }
! 1441:
! 1442: DEFUN (no_smux_peer,
! 1443: no_smux_peer_cmd,
! 1444: "no smux peer",
! 1445: NO_STR
! 1446: "SNMP MUX protocol settings\n"
! 1447: "SNMP MUX peer settings\n")
! 1448: {
! 1449: smux_stop();
! 1450: return smux_peer_default ();
! 1451: }
! 1452:
! 1453: ALIAS (no_smux_peer,
! 1454: no_smux_peer_oid_cmd,
! 1455: "no smux peer OID",
! 1456: NO_STR
! 1457: "SNMP MUX protocol settings\n"
! 1458: "SNMP MUX peer settings\n"
! 1459: "SMUX peering object ID\n")
! 1460:
! 1461: ALIAS (no_smux_peer,
! 1462: no_smux_peer_oid_password_cmd,
! 1463: "no smux peer OID PASSWORD",
! 1464: NO_STR
! 1465: "SNMP MUX protocol settings\n"
! 1466: "SNMP MUX peer settings\n"
! 1467: "SMUX peering object ID\n"
! 1468: "SMUX peering password\n")
! 1469:
! 1470: static int
! 1471: config_write_smux (struct vty *vty)
! 1472: {
! 1473: int first = 1;
! 1474: unsigned int i;
! 1475:
! 1476: if (smux_oid)
! 1477: {
! 1478: vty_out (vty, "smux peer ");
! 1479: for (i = 0; i < smux_oid_len; i++)
! 1480: {
! 1481: vty_out (vty, "%s%d", first ? "" : ".", (int) smux_oid[i]);
! 1482: first = 0;
! 1483: }
! 1484: vty_out (vty, " %s%s", smux_passwd, VTY_NEWLINE);
! 1485: }
! 1486: return 0;
! 1487: }
! 1488:
! 1489: /* Register subtree to smux master tree. */
! 1490: void
! 1491: smux_register_mib (const char *descr, struct variable *var,
! 1492: size_t width, int num,
! 1493: oid name[], size_t namelen)
! 1494: {
! 1495: struct subtree *tree;
! 1496:
! 1497: tree = (struct subtree *)malloc(sizeof(struct subtree));
! 1498: oid_copy (tree->name, name, namelen);
! 1499: tree->name_len = namelen;
! 1500: tree->variables = var;
! 1501: tree->variables_num = num;
! 1502: tree->variables_width = width;
! 1503: tree->registered = 0;
! 1504: listnode_add_sort(treelist, tree);
! 1505: }
! 1506:
! 1507: /* Compare function to keep treelist sorted */
! 1508: static int
! 1509: smux_tree_cmp(struct subtree *tree1, struct subtree *tree2)
! 1510: {
! 1511: return oid_compare(tree1->name, tree1->name_len,
! 1512: tree2->name, tree2->name_len);
! 1513: }
! 1514:
! 1515: /* Initialize some values then schedule first SMUX connection. */
! 1516: void
! 1517: smux_init (struct thread_master *tm)
! 1518: {
! 1519: /* copy callers thread master */
! 1520: master = tm;
! 1521:
! 1522: /* Make MIB tree. */
! 1523: treelist = list_new();
! 1524: treelist->cmp = (int (*)(void *, void *))smux_tree_cmp;
! 1525:
! 1526: /* Install commands. */
! 1527: install_node (&smux_node, config_write_smux);
! 1528:
! 1529: install_element (CONFIG_NODE, &smux_peer_cmd);
! 1530: install_element (CONFIG_NODE, &smux_peer_password_cmd);
! 1531: install_element (CONFIG_NODE, &no_smux_peer_cmd);
! 1532: install_element (CONFIG_NODE, &no_smux_peer_oid_cmd);
! 1533: install_element (CONFIG_NODE, &no_smux_peer_oid_password_cmd);
! 1534: }
! 1535:
! 1536: void
! 1537: smux_start(void)
! 1538: {
! 1539: /* Close any existing connections. */
! 1540: smux_stop();
! 1541:
! 1542: /* Schedule first connection. */
! 1543: smux_event (SMUX_SCHEDULE, 0);
! 1544: }
! 1545: #endif /* HAVE_SNMP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to smux.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib