[mirror_frr.git] / ripd / rip_snmp.c

/* RIP SNMP support
 * Copyright (C) 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GNU Zebra; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.  
 */

#include <zebra.h>

#ifdef HAVE_SNMP
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>

#include "if.h"
#include "log.h"
#include "prefix.h"
#include "command.h"
#include "table.h"
#include "smux.h"

#include "ripd/ripd.h"

/* RIPv2-MIB. */
#define RIPV2MIB 1,3,6,1,2,1,23

/* RIPv2-MIB rip2Globals values. */
#define RIP2GLOBALROUTECHANGES  1
#define RIP2GLOBALQUERIES       2

/* RIPv2-MIB rip2IfStatEntry. */
#define RIP2IFSTATENTRY         1

/* RIPv2-MIB rip2IfStatTable. */
#define RIP2IFSTATADDRESS       1
#define RIP2IFSTATRCVBADPACKETS 2
#define RIP2IFSTATRCVBADROUTES  3
#define RIP2IFSTATSENTUPDATES   4
#define RIP2IFSTATSTATUS        5

/* RIPv2-MIB rip2IfConfTable. */
#define RIP2IFCONFADDRESS       1
#define RIP2IFCONFDOMAIN        2
#define RIP2IFCONFAUTHTYPE      3
#define RIP2IFCONFAUTHKEY       4
#define RIP2IFCONFSEND          5
#define RIP2IFCONFRECEIVE       6
#define RIP2IFCONFDEFAULTMETRIC 7
#define RIP2IFCONFSTATUS        8
#define RIP2IFCONFSRCADDRESS    9

/* RIPv2-MIB rip2PeerTable. */
#define RIP2PEERADDRESS         1
#define RIP2PEERDOMAIN          2
#define RIP2PEERLASTUPDATE      3
#define RIP2PEERVERSION         4
#define RIP2PEERRCVBADPACKETS   5
#define RIP2PEERRCVBADROUTES    6

/* SNMP value hack. */
#define COUNTER     ASN_COUNTER
#define INTEGER     ASN_INTEGER
#define TIMETICKS   ASN_TIMETICKS
#define IPADDRESS   ASN_IPADDRESS
#define STRING      ASN_OCTET_STR

/* Define SNMP local variables. */
SNMP_LOCAL_VARIABLES

/* RIP-MIB instances. */
oid rip_oid [] = { RIPV2MIB };

/* Interface cache table sorted by interface's address. */
struct route_table *rip_ifaddr_table;

/* Hook functions. */
static u_char *rip2Globals (struct variable *, oid [], size_t *,
			    int, size_t *, WriteMethod **);
static u_char *rip2IfStatEntry (struct variable *, oid [], size_t *,
				int, size_t *, WriteMethod **);
static u_char *rip2IfConfAddress (struct variable *, oid [], size_t *,
				  int, size_t *, WriteMethod **);
static u_char *rip2PeerTable (struct variable *, oid [], size_t *,
			      int, size_t *, WriteMethod **);

struct variable rip_variables[] = 
{
  /* RIP Global Counters. */
  {RIP2GLOBALROUTECHANGES,    COUNTER, RONLY, rip2Globals,
   2, {1, 1}},
  {RIP2GLOBALQUERIES,         COUNTER, RONLY, rip2Globals,
   2, {1, 2}},
  /* RIP Interface Tables. */
  {RIP2IFSTATADDRESS,         IPADDRESS, RONLY, rip2IfStatEntry,
   3, {2, 1, 1}},
  {RIP2IFSTATRCVBADPACKETS,   COUNTER, RONLY, rip2IfStatEntry,
   3, {2, 1, 2}},
  {RIP2IFSTATRCVBADROUTES,    COUNTER, RONLY, rip2IfStatEntry,
   3, {2, 1, 3}},
  {RIP2IFSTATSENTUPDATES,     COUNTER, RONLY, rip2IfStatEntry,
   3, {2, 1, 4}},
  {RIP2IFSTATSTATUS,          COUNTER, RWRITE, rip2IfStatEntry,
   3, {2, 1, 5}},
  {RIP2IFCONFADDRESS,         IPADDRESS, RONLY, rip2IfConfAddress,
   /* RIP Interface Configuration Table. */
   3, {3, 1, 1}},
  {RIP2IFCONFDOMAIN,          STRING, RONLY, rip2IfConfAddress,
   3, {3, 1, 2}},
  {RIP2IFCONFAUTHTYPE,        COUNTER, RONLY, rip2IfConfAddress,
   3, {3, 1, 3}},
  {RIP2IFCONFAUTHKEY,         STRING, RONLY, rip2IfConfAddress,
   3, {3, 1, 4}},
  {RIP2IFCONFSEND,            COUNTER, RONLY, rip2IfConfAddress,
   3, {3, 1, 5}},
  {RIP2IFCONFRECEIVE,         COUNTER, RONLY, rip2IfConfAddress,
   3, {3, 1, 6}},
  {RIP2IFCONFDEFAULTMETRIC,   COUNTER, RONLY, rip2IfConfAddress,
   3, {3, 1, 7}},
  {RIP2IFCONFSTATUS,          COUNTER, RONLY, rip2IfConfAddress,
   3, {3, 1, 8}},
  {RIP2IFCONFSRCADDRESS,      IPADDRESS, RONLY, rip2IfConfAddress,
   3, {3, 1, 9}},
  {RIP2PEERADDRESS,           IPADDRESS, RONLY, rip2PeerTable,
   /* RIP Peer Table. */
   3, {4, 1, 1}},
  {RIP2PEERDOMAIN,            STRING, RONLY, rip2PeerTable,
   3, {4, 1, 2}},
  {RIP2PEERLASTUPDATE,        TIMETICKS, RONLY, rip2PeerTable,
   3, {4, 1, 3}},
  {RIP2PEERVERSION,           INTEGER, RONLY, rip2PeerTable,
   3, {4, 1, 4}},
  {RIP2PEERRCVBADPACKETS,     COUNTER, RONLY, rip2PeerTable,
   3, {4, 1, 5}},
  {RIP2PEERRCVBADROUTES,      COUNTER, RONLY, rip2PeerTable,
   3, {4, 1, 6}}
};

extern struct thread_master *master;

static u_char *
rip2Globals (struct variable *v, oid name[], size_t *length,
	     int exact, size_t *var_len, WriteMethod **write_method)
{
  if (smux_header_generic(v, name, length, exact, var_len, write_method)
      == MATCH_FAILED)
    return NULL;

  /* Retrun global counter. */
  switch (v->magic)
    {
    case RIP2GLOBALROUTECHANGES:
      return SNMP_INTEGER (rip_global_route_changes);
      break;
    case RIP2GLOBALQUERIES:
      return SNMP_INTEGER (rip_global_queries);
      break;
    default:
      return NULL;
      break;
    }
  return NULL;
}

void
rip_ifaddr_add (struct interface *ifp, struct connected *ifc)
{
  struct prefix *p;
  struct route_node *rn;

  p = ifc->address;

  if (p->family != AF_INET)
    return;

  rn = route_node_get (rip_ifaddr_table, p);
  rn->info = ifp;
}

void
rip_ifaddr_delete (struct interface *ifp, struct connected *ifc)
{
  struct prefix *p;
  struct route_node *rn;
  struct interface *i;

  p = ifc->address;

  if (p->family != AF_INET)
    return;

  rn = route_node_lookup (rip_ifaddr_table, p);
  if (! rn)
    return;
  i = rn->info;
  if (rn && !strncmp(i->name,ifp->name,INTERFACE_NAMSIZ))
    {
      rn->info = NULL;
      route_unlock_node (rn);
      route_unlock_node (rn);
    }
}

static struct interface *
rip_ifaddr_lookup_next (struct in_addr *addr)
{
  struct prefix_ipv4 p;
  struct route_node *rn;
  struct interface *ifp;

  p.family = AF_INET;
  p.prefixlen = IPV4_MAX_BITLEN;
  p.prefix = *addr;

  rn = route_node_get (rip_ifaddr_table, (struct prefix *) &p);

  for (rn = route_next (rn); rn; rn = route_next (rn))
    if (rn->info)
      break;

  if (rn && rn->info)
    {
      ifp = rn->info;
      *addr = rn->p.u.prefix4;
      route_unlock_node (rn);
      return ifp;
    }
  return NULL;
}

static struct interface *
rip2IfLookup (struct variable *v, oid name[], size_t *length, 
	      struct in_addr *addr, int exact)
{
  int len;
  struct interface *ifp;
  
  if (exact)
    {
      /* Check the length. */
      if (*length - v->namelen != sizeof (struct in_addr))
	return NULL;

      oid2in_addr (name + v->namelen, sizeof (struct in_addr), addr);

      return if_lookup_exact_address ((void *)addr, AF_INET);
    }
  else
    {
      len = *length - v->namelen;
      if (len > 4) len = 4;

      oid2in_addr (name + v->namelen, len, addr);

      ifp = rip_ifaddr_lookup_next (addr);

      if (ifp == NULL)
	return NULL;

      oid_copy_addr (name + v->namelen, addr, sizeof (struct in_addr));

      *length = v->namelen + sizeof (struct in_addr);

      return ifp;
    }
  return NULL;
}

static struct rip_peer *
rip2PeerLookup (struct variable *v, oid name[], size_t *length, 
		struct in_addr *addr, int exact)
{
  int len;
  struct rip_peer *peer;
  
  if (exact)
    {
      /* Check the length. */
      if (*length - v->namelen != sizeof (struct in_addr) + 1)
	return NULL;

      oid2in_addr (name + v->namelen, sizeof (struct in_addr), addr);

      peer = rip_peer_lookup (addr);

      if (peer->domain == (int)name[v->namelen + sizeof (struct in_addr)])
	return peer;

      return NULL;
    }
  else
    {
      len = *length - v->namelen;
      if (len > 4) len = 4;

      oid2in_addr (name + v->namelen, len, addr);

      len = *length - v->namelen;
      peer = rip_peer_lookup (addr);
      if (peer)
	{
	  if ((len < (int)sizeof (struct in_addr) + 1) ||
	      (peer->domain > (int)name[v->namelen + sizeof (struct in_addr)]))
	    {
	      oid_copy_addr (name + v->namelen, &peer->addr,
			     sizeof (struct in_addr));
	      name[v->namelen + sizeof (struct in_addr)] = peer->domain;
	      *length = sizeof (struct in_addr) + v->namelen + 1;
	      return peer;
	    }
        } 
      peer = rip_peer_lookup_next (addr);

      if (! peer)
	return NULL;

      oid_copy_addr (name + v->namelen, &peer->addr,
		     sizeof (struct in_addr));
      name[v->namelen + sizeof (struct in_addr)] = peer->domain;
      *length = sizeof (struct in_addr) + v->namelen + 1;

      return peer;
    }
  return NULL;
}

static u_char *
rip2IfStatEntry (struct variable *v, oid name[], size_t *length,
	         int exact, size_t *var_len, WriteMethod **write_method)
{
  struct interface *ifp;
  struct rip_interface *ri;
  static struct in_addr addr;
  static long valid = SNMP_VALID;

  if (smux_header_table(v, name, length, exact, var_len, write_method)
      == MATCH_FAILED)
    return NULL;

  memset (&addr, 0, sizeof (struct in_addr));
  
  /* Lookup interface. */
  ifp = rip2IfLookup (v, name, length, &addr, exact);
  if (! ifp)
    return NULL;

  /* Fetch rip_interface information. */
  ri = ifp->info;

  switch (v->magic)
    {
    case RIP2IFSTATADDRESS:
      return SNMP_IPADDRESS (addr);
      break;
    case RIP2IFSTATRCVBADPACKETS:
      *var_len = sizeof (long);
      return (u_char *) &ri->recv_badpackets;

    case RIP2IFSTATRCVBADROUTES:
      *var_len = sizeof (long);
      return (u_char *) &ri->recv_badroutes;

    case RIP2IFSTATSENTUPDATES:
      *var_len = sizeof (long);
      return (u_char *) &ri->sent_updates;

    case RIP2IFSTATSTATUS:
      *var_len = sizeof (long);
      v->type = ASN_INTEGER;
      return (u_char *) &valid;

    default:
      return NULL;

    }
  return NULL;
}

static long
rip2IfConfSend (struct rip_interface *ri)
{
#define doNotSend       1
#define ripVersion1     2
#define rip1Compatible  3
#define ripVersion2     4
#define ripV1Demand     5
#define ripV2Demand     6

  if (! ri->running)
    return doNotSend;
    
  if (ri->ri_send & RIPv2)
    return ripVersion2;
  else if (ri->ri_send & RIPv1)
    return ripVersion1;
  else if (rip)
    {
      if (rip->version_send == RIPv2)
	return ripVersion2;
      else if (rip->version_send == RIPv1)
	return ripVersion1;
    }
  return doNotSend;
}

static long
rip2IfConfReceive (struct rip_interface *ri)
{
#define rip1            1
#define rip2            2
#define rip1OrRip2      3
#define doNotReceive    4

  int recvv;

  if (! ri->running)
    return doNotReceive;

  recvv = (ri->ri_receive == RI_RIP_UNSPEC) ?  rip->version_recv :
                                               ri->ri_receive;
  if (recvv == RI_RIP_VERSION_1_AND_2)
    return rip1OrRip2;
  else if (recvv & RIPv2)
    return rip2;
  else if (recvv & RIPv1)
    return rip1;
  else
    return doNotReceive;
}

static u_char *
rip2IfConfAddress (struct variable *v, oid name[], size_t *length,
	           int exact, size_t *val_len, WriteMethod **write_method)
{
  static struct in_addr addr;
  static long valid = SNMP_INVALID;
  static long domain = 0;
  static long config = 0;
  static u_int auth = 0;
  struct interface *ifp;
  struct rip_interface *ri;

  if (smux_header_table(v, name, length, exact, val_len, write_method)
      == MATCH_FAILED)
    return NULL;

  memset (&addr, 0, sizeof (struct in_addr));
  
  /* Lookup interface. */
  ifp = rip2IfLookup (v, name, length, &addr, exact);
  if (! ifp)
    return NULL;

  /* Fetch rip_interface information. */
  ri = ifp->info;

  switch (v->magic)
    {
    case RIP2IFCONFADDRESS:
      *val_len = sizeof (struct in_addr);
      return (u_char *) &addr;

    case RIP2IFCONFDOMAIN:
      *val_len = 2;
      return (u_char *) &domain;

    case RIP2IFCONFAUTHTYPE:
      auth = ri->auth_type;
      *val_len = sizeof (long);
      v->type = ASN_INTEGER;
      return (u_char *)&auth;

    case RIP2IFCONFAUTHKEY:
      *val_len = 0;
      return (u_char *) &domain;
    case RIP2IFCONFSEND:
      config = rip2IfConfSend (ri);
      *val_len = sizeof (long);
      v->type = ASN_INTEGER;
      return (u_char *) &config;
    case RIP2IFCONFRECEIVE:
      config = rip2IfConfReceive (ri);
      *val_len = sizeof (long);
      v->type = ASN_INTEGER;
      return (u_char *) &config;

    case RIP2IFCONFDEFAULTMETRIC:
      *val_len = sizeof (long);
      v->type = ASN_INTEGER;
      return (u_char *) &ifp->metric;
    case RIP2IFCONFSTATUS:
      *val_len = sizeof (long);
      v->type = ASN_INTEGER;
      return (u_char *) &valid;
    case RIP2IFCONFSRCADDRESS:
      *val_len = sizeof (struct in_addr);
      return (u_char *) &addr;

    default:
      return NULL;

    }
  return NULL;
}

static u_char *
rip2PeerTable (struct variable *v, oid name[], size_t *length,
	       int exact, size_t *val_len, WriteMethod **write_method)
{
  static struct in_addr addr;
  static int domain = 0;
  static int version;
  /* static time_t uptime; */

  struct rip_peer *peer;

  if (smux_header_table(v, name, length, exact, val_len, write_method)
      == MATCH_FAILED)
    return NULL;

  memset (&addr, 0, sizeof (struct in_addr));
  
  /* Lookup interface. */
  peer = rip2PeerLookup (v, name, length, &addr, exact);
  if (! peer)
    return NULL;

  switch (v->magic)
    {
    case RIP2PEERADDRESS:
      *val_len = sizeof (struct in_addr);
      return (u_char *) &peer->addr;

    case RIP2PEERDOMAIN:
      *val_len = 2;
      return (u_char *) &domain;

    case RIP2PEERLASTUPDATE:
#if 0 
      /* We don't know the SNMP agent startup time. We have two choices here:
       * - assume ripd startup time equals SNMP agent startup time
       * - don't support this variable, at all
       * Currently, we do the latter...
       */
      *val_len = sizeof (time_t);
      uptime = peer->uptime; /* now - snmp_agent_startup - peer->uptime */
      return (u_char *) &uptime;
#else
      return (u_char *) NULL;
#endif

    case RIP2PEERVERSION:
      *val_len = sizeof (int);
      version = peer->version;
      return (u_char *) &version;

    case RIP2PEERRCVBADPACKETS:
      *val_len = sizeof (int);
      return (u_char *) &peer->recv_badpackets;

    case RIP2PEERRCVBADROUTES:
      *val_len = sizeof (int);
      return (u_char *) &peer->recv_badroutes;

    default:
      return NULL;

    }
  return NULL;
}

/* Register RIPv2-MIB. */
void
rip_snmp_init ()
{
  rip_ifaddr_table = route_table_init ();

  smux_init (master);
  REGISTER_MIB("mibII/rip", rip_variables, variable, rip_oid);
}
#endif /* HAVE_SNMP */
Commit	Line	Data
718e3744	1	/* RIP 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
07661cb5	25	#include <net-snmp/net-snmp-config.h>
fb62a3ce	26	#include <net-snmp/net-snmp-includes.h>
718e3744	27
	28	#include "if.h"
	29	#include "log.h"
	30	#include "prefix.h"
	31	#include "command.h"
	32	#include "table.h"
	33	#include "smux.h"
	34
	35	#include "ripd/ripd.h"
6b0655a2	36
718e3744	37	/* RIPv2-MIB. */
	38	#define RIPV2MIB 1,3,6,1,2,1,23
	39
718e3744	40	/* RIPv2-MIB rip2Globals values. */
	41	#define RIP2GLOBALROUTECHANGES 1
	42	#define RIP2GLOBALQUERIES 2
	43
	44	/* RIPv2-MIB rip2IfStatEntry. */
	45	#define RIP2IFSTATENTRY 1
	46
	47	/* RIPv2-MIB rip2IfStatTable. */
	48	#define RIP2IFSTATADDRESS 1
	49	#define RIP2IFSTATRCVBADPACKETS 2
	50	#define RIP2IFSTATRCVBADROUTES 3
	51	#define RIP2IFSTATSENTUPDATES 4
	52	#define RIP2IFSTATSTATUS 5
	53
	54	/* RIPv2-MIB rip2IfConfTable. */
	55	#define RIP2IFCONFADDRESS 1
	56	#define RIP2IFCONFDOMAIN 2
	57	#define RIP2IFCONFAUTHTYPE 3
	58	#define RIP2IFCONFAUTHKEY 4
	59	#define RIP2IFCONFSEND 5
	60	#define RIP2IFCONFRECEIVE 6
	61	#define RIP2IFCONFDEFAULTMETRIC 7
	62	#define RIP2IFCONFSTATUS 8
	63	#define RIP2IFCONFSRCADDRESS 9
	64
	65	/* RIPv2-MIB rip2PeerTable. */
	66	#define RIP2PEERADDRESS 1
	67	#define RIP2PEERDOMAIN 2
	68	#define RIP2PEERLASTUPDATE 3
	69	#define RIP2PEERVERSION 4
	70	#define RIP2PEERRCVBADPACKETS 5
	71	#define RIP2PEERRCVBADROUTES 6
	72
	73	/* SNMP value hack. */
	74	#define COUNTER ASN_COUNTER
	75	#define INTEGER ASN_INTEGER
	76	#define TIMETICKS ASN_TIMETICKS
	77	#define IPADDRESS ASN_IPADDRESS
	78	#define STRING ASN_OCTET_STR
6b0655a2	79
718e3744	80	/* Define SNMP local variables. */
	81	SNMP_LOCAL_VARIABLES
	82
	83	/* RIP-MIB instances. */
	84	oid rip_oid [] = { RIPV2MIB };
718e3744	85
	86	/* Interface cache table sorted by interface's address. */
	87	struct route_table *rip_ifaddr_table;
	88
	89	/* Hook functions. */
0be8dfb2 CC	90	static u_char rip2Globals (struct variable , oid [], size_t *,
	91	int, size_t , WriteMethod *);
	92	static u_char rip2IfStatEntry (struct variable , oid [], size_t *,
	93	int, size_t , WriteMethod *);
	94	static u_char rip2IfConfAddress (struct variable , oid [], size_t *,
	95	int, size_t , WriteMethod *);
	96	static u_char rip2PeerTable (struct variable , oid [], size_t *,
	97	int, size_t , WriteMethod *);
718e3744	98
	99	struct variable rip_variables[] =
	100	{
	101	/* RIP Global Counters. */
	102	{RIP2GLOBALROUTECHANGES, COUNTER, RONLY, rip2Globals,
	103	2, {1, 1}},
	104	{RIP2GLOBALQUERIES, COUNTER, RONLY, rip2Globals,
	105	2, {1, 2}},
	106	/* RIP Interface Tables. */
	107	{RIP2IFSTATADDRESS, IPADDRESS, RONLY, rip2IfStatEntry,
	108	3, {2, 1, 1}},
	109	{RIP2IFSTATRCVBADPACKETS, COUNTER, RONLY, rip2IfStatEntry,
	110	3, {2, 1, 2}},
	111	{RIP2IFSTATRCVBADROUTES, COUNTER, RONLY, rip2IfStatEntry,
	112	3, {2, 1, 3}},
	113	{RIP2IFSTATSENTUPDATES, COUNTER, RONLY, rip2IfStatEntry,
	114	3, {2, 1, 4}},
	115	{RIP2IFSTATSTATUS, COUNTER, RWRITE, rip2IfStatEntry,
	116	3, {2, 1, 5}},
	117	{RIP2IFCONFADDRESS, IPADDRESS, RONLY, rip2IfConfAddress,
	118	/* RIP Interface Configuration Table. */
	119	3, {3, 1, 1}},
	120	{RIP2IFCONFDOMAIN, STRING, RONLY, rip2IfConfAddress,
	121	3, {3, 1, 2}},
	122	{RIP2IFCONFAUTHTYPE, COUNTER, RONLY, rip2IfConfAddress,
	123	3, {3, 1, 3}},
	124	{RIP2IFCONFAUTHKEY, STRING, RONLY, rip2IfConfAddress,
	125	3, {3, 1, 4}},
	126	{RIP2IFCONFSEND, COUNTER, RONLY, rip2IfConfAddress,
	127	3, {3, 1, 5}},
	128	{RIP2IFCONFRECEIVE, COUNTER, RONLY, rip2IfConfAddress,
	129	3, {3, 1, 6}},
	130	{RIP2IFCONFDEFAULTMETRIC, COUNTER, RONLY, rip2IfConfAddress,
	131	3, {3, 1, 7}},
	132	{RIP2IFCONFSTATUS, COUNTER, RONLY, rip2IfConfAddress,
	133	3, {3, 1, 8}},
	134	{RIP2IFCONFSRCADDRESS, IPADDRESS, RONLY, rip2IfConfAddress,
	135	3, {3, 1, 9}},
	136	{RIP2PEERADDRESS, IPADDRESS, RONLY, rip2PeerTable,
	137	/* RIP Peer Table. */
	138	3, {4, 1, 1}},
fbf5d033	139	{RIP2PEERDOMAIN, STRING, RONLY, rip2PeerTable,
718e3744	140	3, {4, 1, 2}},
	141	{RIP2PEERLASTUPDATE, TIMETICKS, RONLY, rip2PeerTable,
	142	3, {4, 1, 3}},
	143	{RIP2PEERVERSION, INTEGER, RONLY, rip2PeerTable,
	144	3, {4, 1, 4}},
	145	{RIP2PEERRCVBADPACKETS, COUNTER, RONLY, rip2PeerTable,
	146	3, {4, 1, 5}},
	147	{RIP2PEERRCVBADROUTES, COUNTER, RONLY, rip2PeerTable,
	148	3, {4, 1, 6}}
	149	};
dd488a78	150
dd488a78	151	extern struct thread_master *master;
6b0655a2	152
718e3744	153	static u_char *
	154	rip2Globals (struct variable v, oid name[], size_t length,
	155	int exact, size_t var_len, WriteMethod *write_method)
	156	{
	157	if (smux_header_generic(v, name, length, exact, var_len, write_method)
	158	== MATCH_FAILED)
	159	return NULL;
	160
	161	/* Retrun global counter. */
	162	switch (v->magic)
	163	{
	164	case RIP2GLOBALROUTECHANGES:
	165	return SNMP_INTEGER (rip_global_route_changes);
	166	break;
	167	case RIP2GLOBALQUERIES:
	168	return SNMP_INTEGER (rip_global_queries);
	169	break;
	170	default:
	171	return NULL;
	172	break;
	173	}
	174	return NULL;
	175	}
	176
	177	void
	178	rip_ifaddr_add (struct interface ifp, struct connected ifc)
	179	{
	180	struct prefix *p;
	181	struct route_node *rn;
	182
	183	p = ifc->address;
	184
	185	if (p->family != AF_INET)
	186	return;
	187
	188	rn = route_node_get (rip_ifaddr_table, p);
	189	rn->info = ifp;
	190	}
	191
	192	void
	193	rip_ifaddr_delete (struct interface ifp, struct connected ifc)
	194	{
	195	struct prefix *p;
	196	struct route_node *rn;
	197	struct interface *i;
	198
	199	p = ifc->address;
	200
	201	if (p->family != AF_INET)
	202	return;
	203
	204	rn = route_node_lookup (rip_ifaddr_table, p);
	205	if (! rn)
	206	return;
	207	i = rn->info;
	208	if (rn && !strncmp(i->name,ifp->name,INTERFACE_NAMSIZ))
	209	{
	210	rn->info = NULL;
	211	route_unlock_node (rn);
	212	route_unlock_node (rn);
	213	}
	214	}
	215
0be8dfb2	216	static struct interface *
718e3744	217	rip_ifaddr_lookup_next (struct in_addr *addr)
	218	{
	219	struct prefix_ipv4 p;
	220	struct route_node *rn;
	221	struct interface *ifp;
	222
	223	p.family = AF_INET;
	224	p.prefixlen = IPV4_MAX_BITLEN;
	225	p.prefix = *addr;
	226
	227	rn = route_node_get (rip_ifaddr_table, (struct prefix *) &p);
	228
	229	for (rn = route_next (rn); rn; rn = route_next (rn))
	230	if (rn->info)
	231	break;
	232
	233	if (rn && rn->info)
	234	{
	235	ifp = rn->info;
	236	*addr = rn->p.u.prefix4;
	237	route_unlock_node (rn);
	238	return ifp;
	239	}
	240	return NULL;
	241	}
	242
	243	static struct interface *
	244	rip2IfLookup (struct variable v, oid name[], size_t length,
	245	struct in_addr *addr, int exact)
	246	{
	247	int len;
	248	struct interface *ifp;
	249
	250	if (exact)
	251	{
	252	/* Check the length. */
	253	if (*length - v->namelen != sizeof (struct in_addr))
	254	return NULL;
	255
	256	oid2in_addr (name + v->namelen, sizeof (struct in_addr), addr);
	257
0aabccc0	258	return if_lookup_exact_address ((void *)addr, AF_INET);
718e3744	259	}
	260	else
	261	{
	262	len = *length - v->namelen;
	263	if (len > 4) len = 4;
	264
	265	oid2in_addr (name + v->namelen, len, addr);
	266
	267	ifp = rip_ifaddr_lookup_next (addr);
	268
	269	if (ifp == NULL)
	270	return NULL;
	271
	272	oid_copy_addr (name + v->namelen, addr, sizeof (struct in_addr));
	273
	274	*length = v->namelen + sizeof (struct in_addr);
	275
	276	return ifp;
	277	}
	278	return NULL;
	279	}
	280
	281	static struct rip_peer *
	282	rip2PeerLookup (struct variable v, oid name[], size_t length,
	283	struct in_addr *addr, int exact)
	284	{
	285	int len;
	286	struct rip_peer *peer;
	287
	288	if (exact)
	289	{
	290	/* Check the length. */
	291	if (*length - v->namelen != sizeof (struct in_addr) + 1)
	292	return NULL;
	293
	294	oid2in_addr (name + v->namelen, sizeof (struct in_addr), addr);
	295
	296	peer = rip_peer_lookup (addr);
	297
7e635035	298	if (peer->domain == (int)name[v->namelen + sizeof (struct in_addr)])
718e3744	299	return peer;
	300
	301	return NULL;
	302	}
	303	else
	304	{
	305	len = *length - v->namelen;
	306	if (len > 4) len = 4;
	307
	308	oid2in_addr (name + v->namelen, len, addr);
	309
	310	len = *length - v->namelen;
	311	peer = rip_peer_lookup (addr);
	312	if (peer)
	313	{
7e635035 DL	314	if ((len < (int)sizeof (struct in_addr) + 1) \|\|
7e635035 DL	315	(peer->domain > (int)name[v->namelen + sizeof (struct in_addr)]))
718e3744	316	{
	317	oid_copy_addr (name + v->namelen, &peer->addr,
	318	sizeof (struct in_addr));
	319	name[v->namelen + sizeof (struct in_addr)] = peer->domain;
	320	*length = sizeof (struct in_addr) + v->namelen + 1;
	321	return peer;
	322	}
	323	}
	324	peer = rip_peer_lookup_next (addr);
	325
	326	if (! peer)
	327	return NULL;
	328
	329	oid_copy_addr (name + v->namelen, &peer->addr,
	330	sizeof (struct in_addr));
	331	name[v->namelen + sizeof (struct in_addr)] = peer->domain;
	332	*length = sizeof (struct in_addr) + v->namelen + 1;
	333
	334	return peer;
	335	}
	336	return NULL;
	337	}
	338
	339	static u_char *
	340	rip2IfStatEntry (struct variable v, oid name[], size_t length,
	341	int exact, size_t var_len, WriteMethod *write_method)
	342	{
	343	struct interface *ifp;
	344	struct rip_interface *ri;
	345	static struct in_addr addr;
	346	static long valid = SNMP_VALID;
	347
8046ba6e VB	348	if (smux_header_table(v, name, length, exact, var_len, write_method)
	349	== MATCH_FAILED)
	350	return NULL;
	351
718e3744	352	memset (&addr, 0, sizeof (struct in_addr));
	353
	354	/* Lookup interface. */
	355	ifp = rip2IfLookup (v, name, length, &addr, exact);
	356	if (! ifp)
	357	return NULL;
	358
	359	/* Fetch rip_interface information. */
	360	ri = ifp->info;
	361
	362	switch (v->magic)
	363	{
	364	case RIP2IFSTATADDRESS:
	365	return SNMP_IPADDRESS (addr);
	366	break;
	367	case RIP2IFSTATRCVBADPACKETS:
	368	*var_len = sizeof (long);
	369	return (u_char *) &ri->recv_badpackets;
	370
	371	case RIP2IFSTATRCVBADROUTES:
	372	*var_len = sizeof (long);
	373	return (u_char *) &ri->recv_badroutes;
	374
	375	case RIP2IFSTATSENTUPDATES:
	376	*var_len = sizeof (long);
	377	return (u_char *) &ri->sent_updates;
	378
	379	case RIP2IFSTATSTATUS:
	380	*var_len = sizeof (long);
	381	v->type = ASN_INTEGER;
	382	return (u_char *) &valid;
	383
	384	default:
	385	return NULL;
	386
	387	}
	388	return NULL;
	389	}
	390
	391	static long
	392	rip2IfConfSend (struct rip_interface *ri)
	393	{
	394	#define doNotSend 1
	395	#define ripVersion1 2
	396	#define rip1Compatible 3
	397	#define ripVersion2 4
	398	#define ripV1Demand 5
	399	#define ripV2Demand 6
	400
	401	if (! ri->running)
	402	return doNotSend;
	403
	404	if (ri->ri_send & RIPv2)
	405	return ripVersion2;
	406	else if (ri->ri_send & RIPv1)
	407	return ripVersion1;
	408	else if (rip)
	409	{
dd488a78	410	if (rip->version_send == RIPv2)
718e3744	411	return ripVersion2;
dd488a78	412	else if (rip->version_send == RIPv1)
718e3744	413	return ripVersion1;
	414	}
	415	return doNotSend;
	416	}
	417
	418	static long
	419	rip2IfConfReceive (struct rip_interface *ri)
	420	{
	421	#define rip1 1
	422	#define rip2 2
	423	#define rip1OrRip2 3
	424	#define doNotReceive 4
	425
fbf5d033	426	int recvv;
fbf5d033	427
718e3744	428	if (! ri->running)
	429	return doNotReceive;
	430
fbf5d033	431	recvv = (ri->ri_receive == RI_RIP_UNSPEC) ? rip->version_recv :
	432	ri->ri_receive;
	433	if (recvv == RI_RIP_VERSION_1_AND_2)
718e3744	434	return rip1OrRip2;
fbf5d033	435	else if (recvv & RIPv2)
	436	return rip2;
	437	else if (recvv & RIPv1)
	438	return rip1;
718e3744	439	else
	440	return doNotReceive;
	441	}
	442
	443	static u_char *
	444	rip2IfConfAddress (struct variable v, oid name[], size_t length,
	445	int exact, size_t val_len, WriteMethod *write_method)
	446	{
	447	static struct in_addr addr;
	448	static long valid = SNMP_INVALID;
	449	static long domain = 0;
	450	static long config = 0;
	451	static u_int auth = 0;
	452	struct interface *ifp;
	453	struct rip_interface *ri;
	454
8046ba6e VB	455	if (smux_header_table(v, name, length, exact, val_len, write_method)
	456	== MATCH_FAILED)
	457	return NULL;
	458
718e3744	459	memset (&addr, 0, sizeof (struct in_addr));
	460
	461	/* Lookup interface. */
	462	ifp = rip2IfLookup (v, name, length, &addr, exact);
	463	if (! ifp)
	464	return NULL;
	465
	466	/* Fetch rip_interface information. */
	467	ri = ifp->info;
	468
	469	switch (v->magic)
	470	{
	471	case RIP2IFCONFADDRESS:
	472	*val_len = sizeof (struct in_addr);
	473	return (u_char *) &addr;
	474
	475	case RIP2IFCONFDOMAIN:
	476	*val_len = 2;
	477	return (u_char *) &domain;
	478
	479	case RIP2IFCONFAUTHTYPE:
	480	auth = ri->auth_type;
	481	*val_len = sizeof (long);
	482	v->type = ASN_INTEGER;
	483	return (u_char *)&auth;
	484
	485	case RIP2IFCONFAUTHKEY:
	486	*val_len = 0;
	487	return (u_char *) &domain;
	488	case RIP2IFCONFSEND:
	489	config = rip2IfConfSend (ri);
	490	*val_len = sizeof (long);
	491	v->type = ASN_INTEGER;
	492	return (u_char *) &config;
	493	case RIP2IFCONFRECEIVE:
	494	config = rip2IfConfReceive (ri);
	495	*val_len = sizeof (long);
	496	v->type = ASN_INTEGER;
	497	return (u_char *) &config;
	498
	499	case RIP2IFCONFDEFAULTMETRIC:
	500	*val_len = sizeof (long);
	501	v->type = ASN_INTEGER;
	502	return (u_char *) &ifp->metric;
	503	case RIP2IFCONFSTATUS:
	504	*val_len = sizeof (long);
	505	v->type = ASN_INTEGER;
	506	return (u_char *) &valid;
	507	case RIP2IFCONFSRCADDRESS:
	508	*val_len = sizeof (struct in_addr);
	509	return (u_char *) &addr;
	510
	511	default:
	512	return NULL;
	513
	514	}
	515	return NULL;
	516	}
	517
	518	static u_char *
	519	rip2PeerTable (struct variable v, oid name[], size_t length,
	520	int exact, size_t val_len, WriteMethod *write_method)
	521	{
	522	static struct in_addr addr;
fbf5d033	523	static int domain = 0;
718e3744	524	static int version;
	525	/* static time_t uptime; */
	526
	527	struct rip_peer *peer;
	528
8046ba6e VB	529	if (smux_header_table(v, name, length, exact, val_len, write_method)
	530	== MATCH_FAILED)
	531	return NULL;
	532
718e3744	533	memset (&addr, 0, sizeof (struct in_addr));
	534
	535	/* Lookup interface. */
	536	peer = rip2PeerLookup (v, name, length, &addr, exact);
	537	if (! peer)
	538	return NULL;
	539
	540	switch (v->magic)
	541	{
	542	case RIP2PEERADDRESS:
	543	*val_len = sizeof (struct in_addr);
	544	return (u_char *) &peer->addr;
	545
	546	case RIP2PEERDOMAIN:
fbf5d033	547	*val_len = 2;
fbf5d033	548	return (u_char *) &domain;
718e3744	549
	550	case RIP2PEERLASTUPDATE:
	551	#if 0
	552	/* We don't know the SNMP agent startup time. We have two choices here:
	553	* - assume ripd startup time equals SNMP agent startup time
	554	* - don't support this variable, at all
	555	* Currently, we do the latter...
	556	*/
	557	*val_len = sizeof (time_t);
	558	uptime = peer->uptime; /* now - snmp_agent_startup - peer->uptime */
	559	return (u_char *) &uptime;
	560	#else
	561	return (u_char *) NULL;
	562	#endif
	563
	564	case RIP2PEERVERSION:
	565	*val_len = sizeof (int);
	566	version = peer->version;
	567	return (u_char *) &version;
	568
	569	case RIP2PEERRCVBADPACKETS:
	570	*val_len = sizeof (int);
	571	return (u_char *) &peer->recv_badpackets;
	572
	573	case RIP2PEERRCVBADROUTES:
	574	*val_len = sizeof (int);
	575	return (u_char *) &peer->recv_badroutes;
	576
	577	default:
	578	return NULL;
	579
	580	}
	581	return NULL;
	582	}
	583
	584	/* Register RIPv2-MIB. */
	585	void
	586	rip_snmp_init ()
	587	{
	588	rip_ifaddr_table = route_table_init ();
	589
c75105ab	590	smux_init (master);
718e3744	591	REGISTER_MIB("mibII/rip", rip_variables, variable, rip_oid);
718e3744	592	}
718e3744	593	#endif /* HAVE_SNMP */