ospfd/ospf_snmp.c

   1 /* OSPFv2 SNMP support
   2  * Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
   3  * Copyright (C) 2000 IP Infusion Inc.
   4  *
   5  * Written by Kunihiro Ishiguro <kunihiro@zebra.org>
   6  *
   7  * This file is part of GNU Zebra.
   8  *
   9  * GNU Zebra is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by the
  11  * Free Software Foundation; either version 2, or (at your option) any
  12  * later version.
  13  *
  14  * GNU Zebra is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  21  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  22  * 02111-1307, USA.
  23  */
  24
  25 #include <zebra.h>
  26
  27 #ifdef HAVE_SNMP
  28 #ifdef HAVE_NETSNMP
  29 #include <net-snmp/net-snmp-config.h>
  30 #include <net-snmp/net-snmp-includes.h>
  31 #else
  32 #include <asn1.h>
  33 #include <snmp.h>
  34 #include <snmp_impl.h>
  35 #endif
  36
  37 #include "if.h"
  38 #include "log.h"
  39 #include "prefix.h"
  40 #include "table.h"
  41 #include "command.h"
  42 #include "memory.h"
  43 #include "smux.h"
  44
  45 #include "ospfd/ospfd.h"
  46 #include "ospfd/ospf_interface.h"
  47 #include "ospfd/ospf_asbr.h"
  48 #include "ospfd/ospf_lsa.h"
  49 #include "ospfd/ospf_lsdb.h"
  50 #include "ospfd/ospf_abr.h"
  51 #include "ospfd/ospf_neighbor.h"
  52 #include "ospfd/ospf_nsm.h"
  53 #include "ospfd/ospf_flood.h"
  54 #include "ospfd/ospf_ism.h"
  55 #include "ospfd/ospf_dump.h"
  56 #include "ospfd/ospf_snmp.h"
  57 \f
  58 /* OSPF2-MIB. */
  59 #define OSPF2MIB 1,3,6,1,2,1,14
  60
  61 /* OSPF MIB General Group values. */
  62 #define OSPFROUTERID                     1
  63 #define OSPFADMINSTAT                    2
  64 #define OSPFVERSIONNUMBER                3
  65 #define OSPFAREABDRRTRSTATUS             4
  66 #define OSPFASBDRRTRSTATUS               5
  67 #define OSPFEXTERNLSACOUNT               6
  68 #define OSPFEXTERNLSACKSUMSUM            7
  69 #define OSPFTOSSUPPORT                   8
  70 #define OSPFORIGINATENEWLSAS             9
  71 #define OSPFRXNEWLSAS                    10
  72 #define OSPFEXTLSDBLIMIT                 11
  73 #define OSPFMULTICASTEXTENSIONS          12
  74 #define OSPFEXITOVERFLOWINTERVAL         13
  75 #define OSPFDEMANDEXTENSIONS             14
  76
  77 /* OSPF MIB ospfAreaTable. */
  78 #define OSPFAREAID                       1
  79 #define OSPFAUTHTYPE                     2
  80 #define OSPFIMPORTASEXTERN               3
  81 #define OSPFSPFRUNS                      4
  82 #define OSPFAREABDRRTRCOUNT              5
  83 #define OSPFASBDRRTRCOUNT                6
  84 #define OSPFAREALSACOUNT                 7
  85 #define OSPFAREALSACKSUMSUM              8
  86 #define OSPFAREASUMMARY                  9
  87 #define OSPFAREASTATUS                   10
  88
  89 /* OSPF MIB ospfStubAreaTable. */
  90 #define OSPFSTUBAREAID                   1
  91 #define OSPFSTUBTOS                      2
  92 #define OSPFSTUBMETRIC                   3
  93 #define OSPFSTUBSTATUS                   4
  94 #define OSPFSTUBMETRICTYPE               5
  95
  96 /* OSPF MIB ospfLsdbTable. */
  97 #define OSPFLSDBAREAID                   1
  98 #define OSPFLSDBTYPE                     2
  99 #define OSPFLSDBLSID                     3
 100 #define OSPFLSDBROUTERID                 4
 101 #define OSPFLSDBSEQUENCE                 5
 102 #define OSPFLSDBAGE                      6
 103 #define OSPFLSDBCHECKSUM                 7
 104 #define OSPFLSDBADVERTISEMENT            8
 105
 106 /* OSPF MIB ospfAreaRangeTable. */
 107 #define OSPFAREARANGEAREAID              1
 108 #define OSPFAREARANGENET                 2
 109 #define OSPFAREARANGEMASK                3
 110 #define OSPFAREARANGESTATUS              4
 111 #define OSPFAREARANGEEFFECT              5
 112
 113 /* OSPF MIB ospfHostTable. */
 114 #define OSPFHOSTIPADDRESS                1
 115 #define OSPFHOSTTOS                      2
 116 #define OSPFHOSTMETRIC                   3
 117 #define OSPFHOSTSTATUS                   4
 118 #define OSPFHOSTAREAID                   5
 119
 120 /* OSPF MIB ospfIfTable. */
 121 #define OSPFIFIPADDRESS                  1
 122 #define OSPFADDRESSLESSIF                2
 123 #define OSPFIFAREAID                     3
 124 #define OSPFIFTYPE                       4
 125 #define OSPFIFADMINSTAT                  5
 126 #define OSPFIFRTRPRIORITY                6
 127 #define OSPFIFTRANSITDELAY               7
 128 #define OSPFIFRETRANSINTERVAL            8
 129 #define OSPFIFHELLOINTERVAL              9
 130 #define OSPFIFRTRDEADINTERVAL            10
 131 #define OSPFIFPOLLINTERVAL               11
 132 #define OSPFIFSTATE                      12
 133 #define OSPFIFDESIGNATEDROUTER           13
 134 #define OSPFIFBACKUPDESIGNATEDROUTER     14
 135 #define OSPFIFEVENTS                     15
 136 #define OSPFIFAUTHKEY                    16
 137 #define OSPFIFSTATUS                     17
 138 #define OSPFIFMULTICASTFORWARDING        18
 139 #define OSPFIFDEMAND                     19
 140 #define OSPFIFAUTHTYPE                   20
 141
 142 /* OSPF MIB ospfIfMetricTable. */
 143 #define OSPFIFMETRICIPADDRESS            1
 144 #define OSPFIFMETRICADDRESSLESSIF        2
 145 #define OSPFIFMETRICTOS                  3
 146 #define OSPFIFMETRICVALUE                4
 147 #define OSPFIFMETRICSTATUS               5
 148
 149 /* OSPF MIB ospfVirtIfTable. */
 150 #define OSPFVIRTIFAREAID                 1
 151 #define OSPFVIRTIFNEIGHBOR               2
 152 #define OSPFVIRTIFTRANSITDELAY           3
 153 #define OSPFVIRTIFRETRANSINTERVAL        4
 154 #define OSPFVIRTIFHELLOINTERVAL          5
 155 #define OSPFVIRTIFRTRDEADINTERVAL        6
 156 #define OSPFVIRTIFSTATE                  7
 157 #define OSPFVIRTIFEVENTS                 8
 158 #define OSPFVIRTIFAUTHKEY                9
 159 #define OSPFVIRTIFSTATUS                 10
 160 #define OSPFVIRTIFAUTHTYPE               11
 161
 162 /* OSPF MIB ospfNbrTable. */
 163 #define OSPFNBRIPADDR                    1
 164 #define OSPFNBRADDRESSLESSINDEX          2
 165 #define OSPFNBRRTRID                     3
 166 #define OSPFNBROPTIONS                   4
 167 #define OSPFNBRPRIORITY                  5
 168 #define OSPFNBRSTATE                     6
 169 #define OSPFNBREVENTS                    7
 170 #define OSPFNBRLSRETRANSQLEN             8
 171 #define OSPFNBMANBRSTATUS                9
 172 #define OSPFNBMANBRPERMANENCE            10
 173 #define OSPFNBRHELLOSUPPRESSED           11
 174
 175 /* OSPF MIB ospfVirtNbrTable. */
 176 #define OSPFVIRTNBRAREA                  1
 177 #define OSPFVIRTNBRRTRID                 2
 178 #define OSPFVIRTNBRIPADDR                3
 179 #define OSPFVIRTNBROPTIONS               4
 180 #define OSPFVIRTNBRSTATE                 5
 181 #define OSPFVIRTNBREVENTS                6
 182 #define OSPFVIRTNBRLSRETRANSQLEN         7
 183 #define OSPFVIRTNBRHELLOSUPPRESSED       8
 184
 185 /* OSPF MIB ospfExtLsdbTable. */
 186 #define OSPFEXTLSDBTYPE                  1
 187 #define OSPFEXTLSDBLSID                  2
 188 #define OSPFEXTLSDBROUTERID              3
 189 #define OSPFEXTLSDBSEQUENCE              4
 190 #define OSPFEXTLSDBAGE                   5
 191 #define OSPFEXTLSDBCHECKSUM              6
 192 #define OSPFEXTLSDBADVERTISEMENT         7
 193
 194 /* OSPF MIB ospfAreaAggregateTable. */
 195 #define OSPFAREAAGGREGATEAREAID          1
 196 #define OSPFAREAAGGREGATELSDBTYPE        2
 197 #define OSPFAREAAGGREGATENET             3
 198 #define OSPFAREAAGGREGATEMASK            4
 199 #define OSPFAREAAGGREGATESTATUS          5
 200 #define OSPFAREAAGGREGATEEFFECT          6
 201
 202 /* SYNTAX Status from OSPF-MIB. */
 203 #define OSPF_STATUS_ENABLED  1
 204 #define OSPF_STATUS_DISABLED 2
 205
 206 /* SNMP value hack. */
 207 #define COUNTER     ASN_COUNTER
 208 #define INTEGER     ASN_INTEGER
 209 #define GAUGE       ASN_GAUGE
 210 #define TIMETICKS   ASN_TIMETICKS
 211 #define IPADDRESS   ASN_IPADDRESS
 212 #define STRING      ASN_OCTET_STR
 213 \f
 214 /* Declare static local variables for convenience. */
 215 SNMP_LOCAL_VARIABLES
 216
 217 /* OSPF-MIB instances. */
 218 oid ospf_oid [] = { OSPF2MIB };
 219
 220 /* IP address 0.0.0.0. */
 221 static struct in_addr ospf_empty_addr = {0};
 222
 223 /* Hook functions. */
 224 static u_char *ospfGeneralGroup (struct variable *, oid *, size_t *,
 225                                  int, size_t *, WriteMethod **);
 226 static u_char *ospfAreaEntry (struct variable *, oid *, size_t *, int,
 227                               size_t *, WriteMethod **);
 228 static u_char *ospfStubAreaEntry (struct variable *, oid *, size_t *,
 229                                   int, size_t *, WriteMethod **);
 230 static u_char *ospfLsdbEntry (struct variable *, oid *, size_t *, int,
 231                               size_t *, WriteMethod **);
 232 static u_char *ospfAreaRangeEntry (struct variable *, oid *, size_t *, int,
 233                                    size_t *, WriteMethod **);
 234 static u_char *ospfHostEntry (struct variable *, oid *, size_t *, int,
 235                               size_t *, WriteMethod **);
 236 static u_char *ospfIfEntry (struct variable *, oid *, size_t *, int,
 237                             size_t *, WriteMethod **);
 238 static u_char *ospfIfMetricEntry (struct variable *, oid *, size_t *, int,
 239                                   size_t *, WriteMethod **);
 240 static u_char *ospfVirtIfEntry (struct variable *, oid *, size_t *, int,
 241                                 size_t *, WriteMethod **);
 242 static u_char *ospfNbrEntry (struct variable *, oid *, size_t *, int,
 243                              size_t *, WriteMethod **);
 244 static u_char *ospfVirtNbrEntry (struct variable *, oid *, size_t *, int,
 245                                  size_t *, WriteMethod **);
 246 static u_char *ospfExtLsdbEntry (struct variable *, oid *, size_t *, int,
 247                                  size_t *, WriteMethod **);
 248 static u_char *ospfAreaAggregateEntry (struct variable *, oid *, size_t *,
 249                                        int, size_t *, WriteMethod **);
 250
 251 struct variable ospf_variables[] =
 252 {
 253   /* OSPF general variables */
 254   {OSPFROUTERID,              IPADDRESS, RWRITE, ospfGeneralGroup,
 255    2, {1, 1}},
 256   {OSPFADMINSTAT,             INTEGER, RWRITE, ospfGeneralGroup,
 257    2, {1, 2}},
 258   {OSPFVERSIONNUMBER,         INTEGER, RONLY, ospfGeneralGroup,
 259    2, {1, 3}},
 260   {OSPFAREABDRRTRSTATUS,      INTEGER, RONLY, ospfGeneralGroup,
 261    2, {1, 4}},
 262   {OSPFASBDRRTRSTATUS,        INTEGER, RWRITE, ospfGeneralGroup,
 263    2, {1, 5}},
 264   {OSPFEXTERNLSACOUNT,        GAUGE, RONLY, ospfGeneralGroup,
 265    2, {1, 6}},
 266   {OSPFEXTERNLSACKSUMSUM,     INTEGER, RONLY, ospfGeneralGroup,
 267    2, {1, 7}},
 268   {OSPFTOSSUPPORT,            INTEGER, RWRITE, ospfGeneralGroup,
 269    2, {1, 8}},
 270   {OSPFORIGINATENEWLSAS,      COUNTER, RONLY, ospfGeneralGroup,
 271    2, {1, 9}},
 272   {OSPFRXNEWLSAS,             COUNTER, RONLY, ospfGeneralGroup,
 273    2, {1, 10}},
 274   {OSPFEXTLSDBLIMIT,          INTEGER, RWRITE, ospfGeneralGroup,
 275    2, {1, 11}},
 276   {OSPFMULTICASTEXTENSIONS,   INTEGER, RWRITE, ospfGeneralGroup,
 277    2, {1, 12}},
 278   {OSPFEXITOVERFLOWINTERVAL,  INTEGER, RWRITE, ospfGeneralGroup,
 279    2, {1, 13}},
 280   {OSPFDEMANDEXTENSIONS,      INTEGER, RWRITE, ospfGeneralGroup,
 281    2, {1, 14}},
 282
 283   /* OSPF area data structure. */
 284   {OSPFAREAID,                IPADDRESS, RONLY, ospfAreaEntry,
 285    3, {2, 1, 1}},
 286   {OSPFAUTHTYPE,              INTEGER, RWRITE, ospfAreaEntry,
 287    3, {2, 1, 2}},
 288   {OSPFIMPORTASEXTERN,        INTEGER, RWRITE, ospfAreaEntry,
 289    3, {2, 1, 3}},
 290   {OSPFSPFRUNS,               COUNTER, RONLY, ospfAreaEntry,
 291    3, {2, 1, 4}},
 292   {OSPFAREABDRRTRCOUNT,       GAUGE, RONLY, ospfAreaEntry,
 293    3, {2, 1, 5}},
 294   {OSPFASBDRRTRCOUNT,         GAUGE, RONLY, ospfAreaEntry,
 295    3, {2, 1, 6}},
 296   {OSPFAREALSACOUNT,          GAUGE, RONLY, ospfAreaEntry,
 297    3, {2, 1, 7}},
 298   {OSPFAREALSACKSUMSUM,       INTEGER, RONLY, ospfAreaEntry,
 299    3, {2, 1, 8}},
 300   {OSPFAREASUMMARY,           INTEGER, RWRITE, ospfAreaEntry,
 301    3, {2, 1, 9}},
 302   {OSPFAREASTATUS,            INTEGER, RWRITE, ospfAreaEntry,
 303    3, {2, 1, 10}},
 304
 305   /* OSPF stub area information. */
 306   {OSPFSTUBAREAID,            IPADDRESS, RONLY, ospfStubAreaEntry,
 307    3, {3, 1, 1}},
 308   {OSPFSTUBTOS,               INTEGER, RONLY, ospfStubAreaEntry,
 309    3, {3, 1, 2}},
 310   {OSPFSTUBMETRIC,            INTEGER, RWRITE, ospfStubAreaEntry,
 311    3, {3, 1, 3}},
 312   {OSPFSTUBSTATUS,            INTEGER, RWRITE, ospfStubAreaEntry,
 313    3, {3, 1, 4}},
 314   {OSPFSTUBMETRICTYPE,        INTEGER, RWRITE, ospfStubAreaEntry,
 315    3, {3, 1, 5}},
 316
 317   /* OSPF link state database. */
 318   {OSPFLSDBAREAID,            IPADDRESS, RONLY, ospfLsdbEntry,
 319    3, {4, 1, 1}},
 320   {OSPFLSDBTYPE,              INTEGER, RONLY, ospfLsdbEntry,
 321    3, {4, 1, 2}},
 322   {OSPFLSDBLSID,              IPADDRESS, RONLY, ospfLsdbEntry,
 323    3, {4, 1, 3}},
 324   {OSPFLSDBROUTERID,          IPADDRESS, RONLY, ospfLsdbEntry,
 325    3, {4, 1, 4}},
 326   {OSPFLSDBSEQUENCE,          INTEGER, RONLY, ospfLsdbEntry,
 327    3, {4, 1, 5}},
 328   {OSPFLSDBAGE,               INTEGER, RONLY, ospfLsdbEntry,
 329    3, {4, 1, 6}},
 330   {OSPFLSDBCHECKSUM,          INTEGER, RONLY, ospfLsdbEntry,
 331    3, {4, 1, 7}},
 332   {OSPFLSDBADVERTISEMENT,     STRING, RONLY, ospfLsdbEntry,
 333    3, {4, 1, 8}},
 334
 335   /* Area range table. */
 336   {OSPFAREARANGEAREAID,       IPADDRESS, RONLY, ospfAreaRangeEntry,
 337    3, {5, 1, 1}},
 338   {OSPFAREARANGENET,          IPADDRESS, RONLY, ospfAreaRangeEntry,
 339    3, {5, 1, 2}},
 340   {OSPFAREARANGEMASK,         IPADDRESS, RWRITE, ospfAreaRangeEntry,
 341    3, {5, 1, 3}},
 342   {OSPFAREARANGESTATUS,       INTEGER, RWRITE, ospfAreaRangeEntry,
 343    3, {5, 1, 4}},
 344   {OSPFAREARANGEEFFECT,       INTEGER, RWRITE, ospfAreaRangeEntry,
 345    3, {5, 1, 5}},
 346
 347   /* OSPF host table. */
 348   {OSPFHOSTIPADDRESS,         IPADDRESS, RONLY, ospfHostEntry,
 349    3, {6, 1, 1}},
 350   {OSPFHOSTTOS,               INTEGER, RONLY, ospfHostEntry,
 351    3, {6, 1, 2}},
 352   {OSPFHOSTMETRIC,            INTEGER, RWRITE, ospfHostEntry,
 353    3, {6, 1, 3}},
 354   {OSPFHOSTSTATUS,            INTEGER, RWRITE, ospfHostEntry,
 355    3, {6, 1, 4}},
 356   {OSPFHOSTAREAID,            IPADDRESS, RONLY, ospfHostEntry,
 357    3, {6, 1, 5}},
 358
 359   /* OSPF interface table. */
 360   {OSPFIFIPADDRESS,           IPADDRESS, RONLY, ospfIfEntry,
 361    3, {7, 1, 1}},
 362   {OSPFADDRESSLESSIF,         INTEGER, RONLY, ospfIfEntry,
 363    3, {7, 1, 2}},
 364   {OSPFIFAREAID,              IPADDRESS, RWRITE, ospfIfEntry,
 365    3, {7, 1, 3}},
 366   {OSPFIFTYPE,                INTEGER, RWRITE, ospfIfEntry,
 367    3, {7, 1, 4}},
 368   {OSPFIFADMINSTAT,           INTEGER, RWRITE, ospfIfEntry,
 369    3, {7, 1, 5}},
 370   {OSPFIFRTRPRIORITY,         INTEGER, RWRITE, ospfIfEntry,
 371    3, {7, 1, 6}},
 372   {OSPFIFTRANSITDELAY,        INTEGER, RWRITE, ospfIfEntry,
 373    3, {7, 1, 7}},
 374   {OSPFIFRETRANSINTERVAL,     INTEGER, RWRITE, ospfIfEntry,
 375    3, {7, 1, 8}},
 376   {OSPFIFHELLOINTERVAL,       INTEGER, RWRITE, ospfIfEntry,
 377    3, {7, 1, 9}},
 378   {OSPFIFRTRDEADINTERVAL,     INTEGER, RWRITE, ospfIfEntry,
 379    3, {7, 1, 10}},
 380   {OSPFIFPOLLINTERVAL,        INTEGER, RWRITE, ospfIfEntry,
 381    3, {7, 1, 11}},
 382   {OSPFIFSTATE,               INTEGER, RONLY, ospfIfEntry,
 383    3, {7, 1, 12}},
 384   {OSPFIFDESIGNATEDROUTER,    IPADDRESS, RONLY, ospfIfEntry,
 385    3, {7, 1, 13}},
 386   {OSPFIFBACKUPDESIGNATEDROUTER, IPADDRESS, RONLY, ospfIfEntry,
 387    3, {7, 1, 14}},
 388   {OSPFIFEVENTS,              COUNTER, RONLY, ospfIfEntry,
 389    3, {7, 1, 15}},
 390   {OSPFIFAUTHKEY,             STRING,  RWRITE, ospfIfEntry,
 391    3, {7, 1, 16}},
 392   {OSPFIFSTATUS,              INTEGER, RWRITE, ospfIfEntry,
 393    3, {7, 1, 17}},
 394   {OSPFIFMULTICASTFORWARDING, INTEGER, RWRITE, ospfIfEntry,
 395    3, {7, 1, 18}},
 396   {OSPFIFDEMAND,              INTEGER, RWRITE, ospfIfEntry,
 397    3, {7, 1, 19}},
 398   {OSPFIFAUTHTYPE,            INTEGER, RWRITE, ospfIfEntry,
 399    3, {7, 1, 20}},
 400
 401   /* OSPF interface metric table. */
 402   {OSPFIFMETRICIPADDRESS,     IPADDRESS, RONLY, ospfIfMetricEntry,
 403    3, {8, 1, 1}},
 404   {OSPFIFMETRICADDRESSLESSIF, INTEGER, RONLY, ospfIfMetricEntry,
 405    3, {8, 1, 2}},
 406   {OSPFIFMETRICTOS,           INTEGER, RONLY, ospfIfMetricEntry,
 407    3, {8, 1, 3}},
 408   {OSPFIFMETRICVALUE,         INTEGER, RWRITE, ospfIfMetricEntry,
 409    3, {8, 1, 4}},
 410   {OSPFIFMETRICSTATUS,        INTEGER, RWRITE, ospfIfMetricEntry,
 411    3, {8, 1, 5}},
 412
 413   /* OSPF virtual interface table. */
 414   {OSPFVIRTIFAREAID,          IPADDRESS, RONLY, ospfVirtIfEntry,
 415    3, {9, 1, 1}},
 416   {OSPFVIRTIFNEIGHBOR,        IPADDRESS, RONLY, ospfVirtIfEntry,
 417    3, {9, 1, 2}},
 418   {OSPFVIRTIFTRANSITDELAY,    INTEGER, RWRITE, ospfVirtIfEntry,
 419    3, {9, 1, 3}},
 420   {OSPFVIRTIFRETRANSINTERVAL, INTEGER, RWRITE, ospfVirtIfEntry,
 421    3, {9, 1, 4}},
 422   {OSPFVIRTIFHELLOINTERVAL,   INTEGER, RWRITE, ospfVirtIfEntry,
 423    3, {9, 1, 5}},
 424   {OSPFVIRTIFRTRDEADINTERVAL, INTEGER, RWRITE, ospfVirtIfEntry,
 425    3, {9, 1, 6}},
 426   {OSPFVIRTIFSTATE,           INTEGER, RONLY, ospfVirtIfEntry,
 427    3, {9, 1, 7}},
 428   {OSPFVIRTIFEVENTS,          COUNTER, RONLY, ospfVirtIfEntry,
 429    3, {9, 1, 8}},
 430   {OSPFVIRTIFAUTHKEY,         STRING,  RWRITE, ospfVirtIfEntry,
 431    3, {9, 1, 9}},
 432   {OSPFVIRTIFSTATUS,          INTEGER, RWRITE, ospfVirtIfEntry,
 433    3, {9, 1, 10}},
 434   {OSPFVIRTIFAUTHTYPE,        INTEGER, RWRITE, ospfVirtIfEntry,
 435    3, {9, 1, 11}},
 436
 437   /* OSPF neighbor table. */
 438   {OSPFNBRIPADDR,             IPADDRESS, RONLY, ospfNbrEntry,
 439    3, {10, 1, 1}},
 440   {OSPFNBRADDRESSLESSINDEX,   INTEGER, RONLY, ospfNbrEntry,
 441    3, {10, 1, 2}},
 442   {OSPFNBRRTRID,              IPADDRESS, RONLY, ospfNbrEntry,
 443    3, {10, 1, 3}},
 444   {OSPFNBROPTIONS,            INTEGER, RONLY, ospfNbrEntry,
 445    3, {10, 1, 4}},
 446   {OSPFNBRPRIORITY,           INTEGER, RWRITE, ospfNbrEntry,
 447    3, {10, 1, 5}},
 448   {OSPFNBRSTATE,              INTEGER, RONLY, ospfNbrEntry,
 449    3, {10, 1, 6}},
 450   {OSPFNBREVENTS,             COUNTER, RONLY, ospfNbrEntry,
 451    3, {10, 1, 7}},
 452   {OSPFNBRLSRETRANSQLEN,      GAUGE, RONLY, ospfNbrEntry,
 453    3, {10, 1, 8}},
 454   {OSPFNBMANBRSTATUS,         INTEGER, RWRITE, ospfNbrEntry,
 455    3, {10, 1, 9}},
 456   {OSPFNBMANBRPERMANENCE,     INTEGER, RONLY, ospfNbrEntry,
 457    3, {10, 1, 10}},
 458   {OSPFNBRHELLOSUPPRESSED,    INTEGER, RONLY, ospfNbrEntry,
 459    3, {10, 1, 11}},
 460
 461   /* OSPF virtual neighbor table. */
 462   {OSPFVIRTNBRAREA,           IPADDRESS, RONLY, ospfVirtNbrEntry,
 463    3, {11, 1, 1}},
 464   {OSPFVIRTNBRRTRID,          IPADDRESS, RONLY, ospfVirtNbrEntry,
 465    3, {11, 1, 2}},
 466   {OSPFVIRTNBRIPADDR,         IPADDRESS, RONLY, ospfVirtNbrEntry,
 467    3, {11, 1, 3}},
 468   {OSPFVIRTNBROPTIONS,        INTEGER, RONLY, ospfVirtNbrEntry,
 469    3, {11, 1, 4}},
 470   {OSPFVIRTNBRSTATE,          INTEGER, RONLY, ospfVirtNbrEntry,
 471    3, {11, 1, 5}},
 472   {OSPFVIRTNBREVENTS,         COUNTER, RONLY, ospfVirtNbrEntry,
 473    3, {11, 1, 6}},
 474   {OSPFVIRTNBRLSRETRANSQLEN,  INTEGER, RONLY, ospfVirtNbrEntry,
 475    3, {11, 1, 7}},
 476   {OSPFVIRTNBRHELLOSUPPRESSED, INTEGER, RONLY, ospfVirtNbrEntry,
 477    3, {11, 1, 8}},
 478
 479   /* OSPF link state database, external. */
 480   {OSPFEXTLSDBTYPE,           INTEGER, RONLY, ospfExtLsdbEntry,
 481    3, {12, 1, 1}},
 482   {OSPFEXTLSDBLSID,           IPADDRESS, RONLY, ospfExtLsdbEntry,
 483    3, {12, 1, 2}},
 484   {OSPFEXTLSDBROUTERID,       IPADDRESS, RONLY, ospfExtLsdbEntry,
 485    3, {12, 1, 3}},
 486   {OSPFEXTLSDBSEQUENCE,       INTEGER, RONLY, ospfExtLsdbEntry,
 487    3, {12, 1, 4}},
 488   {OSPFEXTLSDBAGE,            INTEGER, RONLY, ospfExtLsdbEntry,
 489    3, {12, 1, 5}},
 490   {OSPFEXTLSDBCHECKSUM,       INTEGER, RONLY, ospfExtLsdbEntry,
 491    3, {12, 1, 6}},
 492   {OSPFEXTLSDBADVERTISEMENT,  STRING,  RONLY, ospfExtLsdbEntry,
 493    3, {12, 1, 7}},
 494
 495   /* OSPF area aggregate table. */
 496   {OSPFAREAAGGREGATEAREAID,   IPADDRESS, RONLY, ospfAreaAggregateEntry,
 497    3, {14, 1, 1}},
 498   {OSPFAREAAGGREGATELSDBTYPE, INTEGER, RONLY, ospfAreaAggregateEntry,
 499    3, {14, 1, 2}},
 500   {OSPFAREAAGGREGATENET,      IPADDRESS, RONLY, ospfAreaAggregateEntry,
 501    3, {14, 1, 3}},
 502   {OSPFAREAAGGREGATEMASK,     IPADDRESS, RONLY, ospfAreaAggregateEntry,
 503    3, {14, 1, 4}},
 504   {OSPFAREAAGGREGATESTATUS,   INTEGER, RWRITE, ospfAreaAggregateEntry,
 505    3, {14, 1, 5}},
 506   {OSPFAREAAGGREGATEEFFECT,   INTEGER, RWRITE, ospfAreaAggregateEntry,
 507    3, {14, 1, 6}}
 508 };
 509 \f
 510 /* The administrative status of OSPF.  When OSPF is enbled on at least
 511    one interface return 1. */
 512 static int
 513 ospf_admin_stat (struct ospf *ospf)
 514 {
 515   struct listnode *node;
 516   struct ospf_interface *oi;
 517
 518   if (ospf == NULL)
 519     return 0;
 520
 521   for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
 522     if (oi && oi->address)
 523       return 1;
 524
 525   return 0;
 526 }
 527
 528 static u_char *
 529 ospfGeneralGroup (struct variable *v, oid *name, size_t *length,
 530                   int exact, size_t *var_len, WriteMethod **write_method)
 531 {
 532   struct ospf *ospf;
 533
 534   ospf = ospf_lookup ();
 535
 536   /* Check whether the instance identifier is valid */
 537   if (smux_header_generic (v, name, length, exact, var_len, write_method)
 538       == MATCH_FAILED)
 539     return NULL;
 540
 541   /* Return the current value of the variable */
 542   switch (v->magic)
 543     {
 544     case OSPFROUTERID:          /* 1 */
 545       /* Router-ID of this OSPF instance. */
 546       if (ospf)
 547         return SNMP_IPADDRESS (ospf->router_id);
 548       else
 549         return SNMP_IPADDRESS (ospf_empty_addr);
 550       break;
 551     case OSPFADMINSTAT:         /* 2 */
 552       /* The administrative status of OSPF in the router. */
 553       if (ospf_admin_stat (ospf))
 554         return SNMP_INTEGER (OSPF_STATUS_ENABLED);
 555       else
 556         return SNMP_INTEGER (OSPF_STATUS_DISABLED);
 557       break;
 558     case OSPFVERSIONNUMBER:     /* 3 */
 559       /* OSPF version 2. */
 560       return SNMP_INTEGER (OSPF_VERSION);
 561       break;
 562     case OSPFAREABDRRTRSTATUS:  /* 4 */
 563       /* Area Border router status. */
 564       if (ospf && CHECK_FLAG (ospf->flags, OSPF_FLAG_ABR))
 565         return SNMP_INTEGER (SNMP_TRUE);
 566       else
 567         return SNMP_INTEGER (SNMP_FALSE);
 568       break;
 569     case OSPFASBDRRTRSTATUS:    /* 5 */
 570       /* AS Border router status. */
 571       if (ospf && CHECK_FLAG (ospf->flags, OSPF_FLAG_ASBR))
 572         return SNMP_INTEGER (SNMP_TRUE);
 573       else
 574         return SNMP_INTEGER (SNMP_FALSE);
 575       break;
 576     case OSPFEXTERNLSACOUNT:    /* 6 */
 577       /* External LSA counts. */
 578       if (ospf)
 579         return SNMP_INTEGER (ospf_lsdb_count_all (ospf->lsdb));
 580       else
 581         return SNMP_INTEGER (0);
 582       break;
 583     case OSPFEXTERNLSACKSUMSUM: /* 7 */
 584       /* External LSA checksum. */
 585       return SNMP_INTEGER (0);
 586       break;
 587     case OSPFTOSSUPPORT:        /* 8 */
 588       /* TOS is not supported. */
 589       return SNMP_INTEGER (SNMP_FALSE);
 590       break;
 591     case OSPFORIGINATENEWLSAS:  /* 9 */
 592       /* The number of new link-state advertisements. */
 593       if (ospf)
 594         return SNMP_INTEGER (ospf->lsa_originate_count);
 595       else
 596         return SNMP_INTEGER (0);
 597       break;
 598     case OSPFRXNEWLSAS:         /* 10 */
 599       /* The number of link-state advertisements received determined
 600          to be new instantiations. */
 601       if (ospf)
 602         return SNMP_INTEGER (ospf->rx_lsa_count);
 603       else
 604         return SNMP_INTEGER (0);
 605       break;
 606     case OSPFEXTLSDBLIMIT:      /* 11 */
 607       /* There is no limit for the number of non-default
 608          AS-external-LSAs. */
 609       return SNMP_INTEGER (-1);
 610       break;
 611     case OSPFMULTICASTEXTENSIONS: /* 12 */
 612       /* Multicast Extensions to OSPF is not supported. */
 613       return SNMP_INTEGER (0);
 614       break;
 615     case OSPFEXITOVERFLOWINTERVAL: /* 13 */
 616       /* Overflow is not supported. */
 617       return SNMP_INTEGER (0);
 618       break;
 619     case OSPFDEMANDEXTENSIONS:  /* 14 */
 620       /* Demand routing is not supported. */
 621       return SNMP_INTEGER (SNMP_FALSE);
 622       break;
 623     default:
 624       return NULL;
 625     }
 626   return NULL;
 627 }
 628
 629 static struct ospf_area *
 630 ospf_area_lookup_next (struct ospf *ospf, struct in_addr *area_id, int first)
 631 {
 632   struct ospf_area *area;
 633   struct listnode *node;
 634
 635   if (ospf == NULL)
 636     return NULL;
 637
 638   if (first)
 639     {
 640       node = listhead (ospf->areas);
 641       if (node)
 642         {
 643           area = listgetdata (node);
 644           *area_id = area->area_id;
 645           return area;
 646         }
 647       return NULL;
 648     }
 649   for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
 650     {
 651       if (ntohl (area->area_id.s_addr) > ntohl (area_id->s_addr))
 652         {
 653           *area_id = area->area_id;
 654           return area;
 655         }
 656     }
 657   return NULL;
 658 }
 659
 660 static struct ospf_area *
 661 ospfAreaLookup (struct variable *v, oid name[], size_t *length,
 662                 struct in_addr *addr, int exact)
 663 {
 664   struct ospf *ospf;
 665   struct ospf_area *area;
 666   int len;
 667
 668   ospf = ospf_lookup ();
 669   if (ospf == NULL)
 670     return NULL;
 671
 672   if (exact)
 673     {
 674       /* Length is insufficient to lookup OSPF area. */
 675       if (*length - v->namelen != sizeof (struct in_addr))
 676         return NULL;
 677
 678       oid2in_addr (name + v->namelen, sizeof (struct in_addr), addr);
 679
 680       area = ospf_area_lookup_by_area_id (ospf, *addr);
 681
 682       return area;
 683     }
 684   else
 685     {
 686       len = *length - v->namelen;
 687       if (len > 4)
 688         len = 4;
 689
 690       oid2in_addr (name + v->namelen, len, addr);
 691
 692       area = ospf_area_lookup_next (ospf, addr, len == 0 ? 1 : 0);
 693
 694       if (area == NULL)
 695         return NULL;
 696
 697       oid_copy_addr (name + v->namelen, addr, sizeof (struct in_addr));
 698       *length = sizeof (struct in_addr) + v->namelen;
 699
 700       return area;
 701     }
 702   return NULL;
 703 }
 704
 705 static u_char *
 706 ospfAreaEntry (struct variable *v, oid *name, size_t *length, int exact,
 707                size_t *var_len, WriteMethod **write_method)
 708 {
 709   struct ospf_area *area;
 710   struct in_addr addr;
 711
 712   memset (&addr, 0, sizeof (struct in_addr));
 713
 714   area = ospfAreaLookup (v, name, length, &addr, exact);
 715   if (! area)
 716     return NULL;
 717
 718   /* Return the current value of the variable */
 719   switch (v->magic)
 720     {
 721     case OSPFAREAID:            /* 1 */
 722       return SNMP_IPADDRESS (area->area_id);
 723       break;
 724     case OSPFAUTHTYPE:          /* 2 */
 725       return SNMP_INTEGER (area->auth_type);
 726       break;
 727     case OSPFIMPORTASEXTERN:    /* 3 */
 728       return SNMP_INTEGER (area->external_routing + 1);
 729       break;
 730     case OSPFSPFRUNS:           /* 4 */
 731       return SNMP_INTEGER (area->spf_calculation);
 732       break;
 733     case OSPFAREABDRRTRCOUNT:   /* 5 */
 734       return SNMP_INTEGER (area->abr_count);
 735       break;
 736     case OSPFASBDRRTRCOUNT:     /* 6 */
 737       return SNMP_INTEGER (area->asbr_count);
 738       break;
 739     case OSPFAREALSACOUNT:      /* 7 */
 740       return SNMP_INTEGER (area->lsdb->total);
 741       break;
 742     case OSPFAREALSACKSUMSUM:   /* 8 */
 743       return SNMP_INTEGER (0);
 744       break;
 745     case OSPFAREASUMMARY:       /* 9 */
 746 #define OSPF_noAreaSummary   1
 747 #define OSPF_sendAreaSummary 2
 748       if (area->no_summary)
 749         return SNMP_INTEGER (OSPF_noAreaSummary);
 750       else
 751         return SNMP_INTEGER (OSPF_sendAreaSummary);
 752       break;
 753     case OSPFAREASTATUS:        /* 10 */
 754       return SNMP_INTEGER (SNMP_VALID);
 755       break;
 756     default:
 757       return NULL;
 758       break;
 759     }
 760   return NULL;
 761 }
 762
 763 static struct ospf_area *
 764 ospf_stub_area_lookup_next (struct in_addr *area_id, int first)
 765 {
 766   struct ospf_area *area;
 767   struct listnode *node;
 768   struct ospf *ospf;
 769
 770   ospf = ospf_lookup ();
 771   if (ospf == NULL)
 772     return NULL;
 773
 774   for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
 775     {
 776       if (area->external_routing == OSPF_AREA_STUB)
 777         {
 778           if (first)
 779             {
 780               *area_id = area->area_id;
 781               return area;
 782             }
 783           else if (ntohl (area->area_id.s_addr) > ntohl (area_id->s_addr))
 784             {
 785               *area_id = area->area_id;
 786               return area;
 787             }
 788         }
 789     }
 790   return NULL;
 791 }
 792
 793 static struct ospf_area *
 794 ospfStubAreaLookup (struct variable *v, oid name[], size_t *length,
 795                     struct in_addr *addr, int exact)
 796 {
 797   struct ospf *ospf;
 798   struct ospf_area *area;
 799   int len;
 800
 801   ospf = ospf_lookup ();
 802   if (ospf == NULL)
 803     return NULL;
 804
 805   /* Exact lookup. */
 806   if (exact)
 807     {
 808       /* ospfStubAreaID + ospfStubTOS. */
 809       if (*length != v->namelen + sizeof (struct in_addr) + 1)
 810         return NULL;
 811
 812       /* Check ospfStubTOS is zero. */
 813       if (name[*length - 1] != 0)
 814         return NULL;
 815
 816       oid2in_addr (name + v->namelen, sizeof (struct in_addr), addr);
 817
 818       area = ospf_area_lookup_by_area_id (ospf, *addr);
 819
 820       if (area->external_routing == OSPF_AREA_STUB)
 821         return area;
 822       else
 823         return NULL;
 824     }
 825   else
 826     {
 827       len = *length - v->namelen;
 828       if (len > 4)
 829         len = 4;
 830
 831       oid2in_addr (name + v->namelen, len, addr);
 832
 833       area = ospf_stub_area_lookup_next (addr, len == 0 ? 1 : 0);
 834
 835       if (area == NULL)
 836         return NULL;
 837
 838       oid_copy_addr (name + v->namelen, addr, sizeof (struct in_addr));
 839       /* Set TOS 0. */
 840       name[v->namelen + sizeof (struct in_addr)] = 0;
 841       *length = v->namelen + sizeof (struct in_addr) + 1;
 842
 843       return area;
 844     }
 845   return NULL;
 846 }
 847
 848 static u_char *
 849 ospfStubAreaEntry (struct variable *v, oid *name, size_t *length,
 850                    int exact, size_t *var_len, WriteMethod **write_method)
 851 {
 852   struct ospf_area *area;
 853   struct in_addr addr;
 854
 855   memset (&addr, 0, sizeof (struct in_addr));
 856
 857   area = ospfStubAreaLookup (v, name, length, &addr, exact);
 858   if (! area)
 859     return NULL;
 860
 861   /* Return the current value of the variable */
 862   switch (v->magic)
 863     {
 864     case OSPFSTUBAREAID:        /* 1 */
 865       /* OSPF stub area id. */
 866       return SNMP_IPADDRESS (area->area_id);
 867       break;
 868     case OSPFSTUBTOS:           /* 2 */
 869       /* TOS value is not supported. */
 870       return SNMP_INTEGER (0);
 871       break;
 872     case OSPFSTUBMETRIC:        /* 3 */
 873       /* Default cost to stub area. */
 874       return SNMP_INTEGER (area->default_cost);
 875       break;
 876     case OSPFSTUBSTATUS:        /* 4 */
 877       /* Status of the stub area. */
 878       return SNMP_INTEGER (SNMP_VALID);
 879       break;
 880     case OSPFSTUBMETRICTYPE:    /* 5 */
 881       /* OSPF Metric type. */
 882 #define OSPF_ospfMetric     1
 883 #define OSPF_comparableCost 2
 884 #define OSPF_nonComparable  3
 885       return SNMP_INTEGER (OSPF_ospfMetric);
 886       break;
 887     default:
 888       return NULL;
 889       break;
 890     }
 891   return NULL;
 892 }
 893
 894 static struct ospf_lsa *
 895 lsdb_lookup_next (struct ospf_area *area, u_char *type, int type_next,
 896                   struct in_addr *ls_id, int ls_id_next,
 897                   struct in_addr *router_id, int router_id_next)
 898 {
 899   struct ospf_lsa *lsa;
 900   int i;
 901
 902   if (type_next)
 903     i = OSPF_MIN_LSA;
 904   else
 905     i = *type;
 906
 907   /* Sanity check, if LSA type unknwon
 908      merley skip any LSA */
 909   if ((i < OSPF_MIN_LSA) || (i >= OSPF_MAX_LSA))
 910     {
 911       zlog_debug("Strange request with LSA type %d\n", i);
 912       return NULL;
 913     }
 914
 915   for (; i < OSPF_MAX_LSA; i++)
 916     {
 917       *type = i;
 918
 919       lsa = ospf_lsdb_lookup_by_id_next (area->lsdb, *type, *ls_id, *router_id,
 920                                         ls_id_next);
 921       if (lsa)
 922         return lsa;
 923
 924       ls_id_next = 1;
 925     }
 926   return NULL;
 927 }
 928
 929 static struct ospf_lsa *
 930 ospfLsdbLookup (struct variable *v, oid *name, size_t *length,
 931                 struct in_addr *area_id, u_char *type,
 932                 struct in_addr *ls_id, struct in_addr *router_id, int exact)
 933 {
 934   struct ospf *ospf;
 935   struct ospf_area *area;
 936   struct ospf_lsa *lsa;
 937   unsigned int len;
 938   int type_next;
 939   int ls_id_next;
 940   int router_id_next;
 941   oid *offset;
 942   int offsetlen;
 943
 944   ospf = ospf_lookup ();
 945
 946 #define OSPF_LSDB_ENTRY_OFFSET \
 947           (IN_ADDR_SIZE + 1 + IN_ADDR_SIZE + IN_ADDR_SIZE)
 948
 949   if (exact)
 950     {
 951       /* Area ID + Type + LS ID + Router ID. */
 952       if (*length - v->namelen != OSPF_LSDB_ENTRY_OFFSET)
 953         return NULL;
 954
 955       /* Set OID offset for Area ID. */
 956       offset = name + v->namelen;
 957
 958       /* Lookup area first. */
 959       oid2in_addr (offset, IN_ADDR_SIZE, area_id);
 960       area = ospf_area_lookup_by_area_id (ospf, *area_id);
 961       if (! area)
 962         return NULL;
 963       offset += IN_ADDR_SIZE;
 964
 965       /* Type. */
 966       *type = *offset;
 967       offset++;
 968
 969       /* LS ID. */
 970       oid2in_addr (offset, IN_ADDR_SIZE, ls_id);
 971       offset += IN_ADDR_SIZE;
 972
 973       /* Router ID. */
 974       oid2in_addr (offset, IN_ADDR_SIZE, router_id);
 975
 976       /* Lookup LSDB. */
 977       return ospf_lsdb_lookup_by_id (area->lsdb, *type, *ls_id, *router_id);
 978     }
 979   else
 980     {
 981       /* Get variable length. */
 982       offset = name + v->namelen;
 983       offsetlen = *length - v->namelen;
 984       len = offsetlen;
 985
 986       if (len > IN_ADDR_SIZE)
 987         len = IN_ADDR_SIZE;
 988
 989       oid2in_addr (offset, len, area_id);
 990
 991       /* First we search area. */
 992       if (len == IN_ADDR_SIZE)
 993         area = ospf_area_lookup_by_area_id (ospf, *area_id);
 994       else
 995         area = ospf_area_lookup_next (ospf, area_id, len == 0 ? 1 : 0);
 996
 997       if (area == NULL)
 998         return NULL;
 999
1000       do
1001         {
1002           /* Next we lookup type. */
1003           offset += IN_ADDR_SIZE;
1004           offsetlen -= IN_ADDR_SIZE;
1005           len = offsetlen;
1006
1007           if (len <= 0)
1008             type_next = 1;
1009           else
1010             {
1011               len = 1;
1012               type_next = 0;
1013               *type = *offset;
1014             }
1015
1016           /* LS ID. */
1017           offset++;
1018           offsetlen--;
1019           len = offsetlen;
1020
1021           if (len <= 0)
1022             ls_id_next = 1;
1023           else
1024             {
1025               ls_id_next = 0;
1026               if (len > IN_ADDR_SIZE)
1027                 len = IN_ADDR_SIZE;
1028
1029               oid2in_addr (offset, len, ls_id);
1030             }
1031
1032           /* Router ID. */
1033           offset += IN_ADDR_SIZE;
1034           offsetlen -= IN_ADDR_SIZE;
1035           len = offsetlen;
1036
1037           if (len <= 0)
1038             router_id_next = 1;
1039           else
1040             {
1041               router_id_next = 0;
1042               if (len > IN_ADDR_SIZE)
1043                 len = IN_ADDR_SIZE;
1044
1045               oid2in_addr (offset, len, router_id);
1046             }
1047
1048           lsa = lsdb_lookup_next (area, type, type_next, ls_id, ls_id_next,
1049                                   router_id, router_id_next);
1050
1051           if (lsa)
1052             {
1053               /* Fill in length. */
1054               *length = v->namelen + OSPF_LSDB_ENTRY_OFFSET;
1055
1056               /* Fill in value. */
1057               offset = name + v->namelen;
1058               oid_copy_addr (offset, area_id, IN_ADDR_SIZE);
1059               offset += IN_ADDR_SIZE;
1060               *offset = lsa->data->type;
1061               offset++;
1062               oid_copy_addr (offset, &lsa->data->id, IN_ADDR_SIZE);
1063               offset += IN_ADDR_SIZE;
1064               oid_copy_addr (offset, &lsa->data->adv_router, IN_ADDR_SIZE);
1065
1066               return lsa;
1067             }
1068         }
1069       while ((area = ospf_area_lookup_next (ospf, area_id, 0)) != NULL);
1070     }
1071   return NULL;
1072 }
1073
1074 static u_char *
1075 ospfLsdbEntry (struct variable *v, oid *name, size_t *length, int exact,
1076                size_t *var_len, WriteMethod **write_method)
1077 {
1078   struct ospf_lsa *lsa;
1079   struct lsa_header *lsah;
1080   struct in_addr area_id;
1081   u_char type;
1082   struct in_addr ls_id;
1083   struct in_addr router_id;
1084   struct ospf *ospf;
1085
1086   /* INDEX { ospfLsdbAreaId, ospfLsdbType,
1087      ospfLsdbLsid, ospfLsdbRouterId } */
1088
1089   memset (&area_id, 0, sizeof (struct in_addr));
1090   type = 0;
1091   memset (&ls_id, 0, sizeof (struct in_addr));
1092   memset (&router_id, 0, sizeof (struct in_addr));
1093
1094   /* Check OSPF instance. */
1095   ospf = ospf_lookup ();
1096   if (ospf == NULL)
1097     return NULL;
1098
1099   lsa = ospfLsdbLookup (v, name, length, &area_id, &type, &ls_id, &router_id,
1100                         exact);
1101   if (! lsa)
1102     return NULL;
1103
1104   lsah = lsa->data;
1105
1106   /* Return the current value of the variable */
1107   switch (v->magic)
1108     {
1109     case OSPFLSDBAREAID:        /* 1 */
1110       return SNMP_IPADDRESS (lsa->area->area_id);
1111       break;
1112     case OSPFLSDBTYPE:          /* 2 */
1113       return SNMP_INTEGER (lsah->type);
1114       break;
1115     case OSPFLSDBLSID:          /* 3 */
1116       return SNMP_IPADDRESS (lsah->id);
1117       break;
1118     case OSPFLSDBROUTERID:      /* 4 */
1119       return SNMP_IPADDRESS (lsah->adv_router);
1120       break;
1121     case OSPFLSDBSEQUENCE:      /* 5 */
1122       return SNMP_INTEGER (lsah->ls_seqnum);
1123       break;
1124     case OSPFLSDBAGE:           /* 6 */
1125       return SNMP_INTEGER (lsah->ls_age);
1126       break;
1127     case OSPFLSDBCHECKSUM:      /* 7 */
1128       return SNMP_INTEGER (lsah->checksum);
1129       break;
1130     case OSPFLSDBADVERTISEMENT: /* 8 */
1131       *var_len = ntohs (lsah->length);
1132       return (u_char *) lsah;
1133       break;
1134     default:
1135       return NULL;
1136       break;
1137     }
1138   return NULL;
1139 }
1140
1141 static struct ospf_area_range *
1142 ospfAreaRangeLookup (struct variable *v, oid *name, size_t *length,
1143                      struct in_addr *area_id, struct in_addr *range_net,
1144                      int exact)
1145 {
1146   oid *offset;
1147   int offsetlen;
1148   unsigned int len;
1149   struct ospf *ospf;
1150   struct ospf_area *area;
1151   struct ospf_area_range *range;
1152   struct prefix_ipv4 p;
1153   p.family = AF_INET;
1154   p.prefixlen = IPV4_MAX_BITLEN;
1155
1156   ospf = ospf_lookup ();
1157
1158   if (exact)
1159     {
1160       /* Area ID + Range Network. */
1161       if (v->namelen + IN_ADDR_SIZE + IN_ADDR_SIZE != *length)
1162         return NULL;
1163
1164       /* Set OID offset for Area ID. */
1165       offset = name + v->namelen;
1166
1167       /* Lookup area first. */
1168       oid2in_addr (offset, IN_ADDR_SIZE, area_id);
1169
1170       area = ospf_area_lookup_by_area_id (ospf, *area_id);
1171       if (! area)
1172         return NULL;
1173
1174       offset += IN_ADDR_SIZE;
1175
1176       /* Lookup area range. */
1177       oid2in_addr (offset, IN_ADDR_SIZE, range_net);
1178       p.prefix = *range_net;
1179
1180       return ospf_area_range_lookup (area, &p);
1181     }
1182   else
1183     {
1184       /* Set OID offset for Area ID. */
1185       offset = name + v->namelen;
1186       offsetlen = *length - v->namelen;
1187
1188       len = offsetlen;
1189       if (len > IN_ADDR_SIZE)
1190         len = IN_ADDR_SIZE;
1191
1192       oid2in_addr (offset, len, area_id);
1193
1194       /* First we search area. */
1195       if (len == IN_ADDR_SIZE)
1196         area = ospf_area_lookup_by_area_id (ospf,*area_id);
1197       else
1198         area = ospf_area_lookup_next (ospf, area_id, len == 0 ? 1 : 0);
1199
1200       if (area == NULL)
1201         return NULL;
1202
1203       do
1204         {
1205           offset += IN_ADDR_SIZE;
1206           offsetlen -= IN_ADDR_SIZE;
1207           len = offsetlen;
1208
1209           if (len < 0)
1210             len = 0;
1211           if (len > IN_ADDR_SIZE)
1212             len = IN_ADDR_SIZE;
1213
1214           oid2in_addr (offset, len, range_net);
1215
1216           range = ospf_area_range_lookup_next (area, range_net,
1217                                                len == 0 ? 1 : 0);
1218
1219           if (range)
1220             {
1221               /* Fill in length. */
1222               *length = v->namelen + IN_ADDR_SIZE + IN_ADDR_SIZE;
1223
1224               /* Fill in value. */
1225               offset = name + v->namelen;
1226               oid_copy_addr (offset, area_id, IN_ADDR_SIZE);
1227               offset += IN_ADDR_SIZE;
1228               oid_copy_addr (offset, range_net, IN_ADDR_SIZE);
1229
1230               return range;
1231             }
1232         }
1233       while ((area = ospf_area_lookup_next (ospf, area_id, 0)) != NULL);
1234     }
1235   return NULL;
1236 }
1237
1238 static u_char *
1239 ospfAreaRangeEntry (struct variable *v, oid *name, size_t *length, int exact,
1240                     size_t *var_len, WriteMethod **write_method)
1241 {
1242   struct ospf_area_range *range;
1243   struct in_addr area_id;
1244   struct in_addr range_net;
1245   struct in_addr mask;
1246   struct ospf *ospf;
1247
1248   /* Check OSPF instance. */
1249   ospf = ospf_lookup ();
1250   if (ospf == NULL)
1251     return NULL;
1252
1253   memset (&area_id, 0, IN_ADDR_SIZE);
1254   memset (&range_net, 0, IN_ADDR_SIZE);
1255
1256   range = ospfAreaRangeLookup (v, name, length, &area_id, &range_net, exact);
1257   if (! range)
1258     return NULL;
1259
1260   /* Convert prefixlen to network mask format. */
1261   masklen2ip (range->subst_masklen, &mask);
1262
1263   /* Return the current value of the variable */
1264   switch (v->magic)
1265     {
1266     case OSPFAREARANGEAREAID:   /* 1 */
1267       return SNMP_IPADDRESS (area_id);
1268       break;
1269     case OSPFAREARANGENET:      /* 2 */
1270       return SNMP_IPADDRESS (range_net);
1271       break;
1272     case OSPFAREARANGEMASK:     /* 3 */
1273       return SNMP_IPADDRESS (mask);
1274       break;
1275     case OSPFAREARANGESTATUS:   /* 4 */
1276       return SNMP_INTEGER (SNMP_VALID);
1277       break;
1278     case OSPFAREARANGEEFFECT:   /* 5 */
1279 #define OSPF_advertiseMatching      1
1280 #define OSPF_doNotAdvertiseMatching 2
1281       return SNMP_INTEGER (OSPF_advertiseMatching);
1282       break;
1283     default:
1284       return NULL;
1285       break;
1286     }
1287   return NULL;
1288 }
1289
1290 static struct ospf_nbr_nbma *
1291 ospfHostLookup (struct variable *v, oid *name, size_t *length,
1292                 struct in_addr *addr, int exact)
1293 {
1294   int len;
1295   struct ospf_nbr_nbma *nbr_nbma;
1296   struct ospf *ospf;
1297
1298   ospf = ospf_lookup ();
1299   if (ospf == NULL)
1300     return NULL;
1301
1302   if (exact)
1303     {
1304       /* INDEX { ospfHostIpAddress, ospfHostTOS } */
1305       if (*length != v->namelen + IN_ADDR_SIZE + 1)
1306         return NULL;
1307
1308       /* Check ospfHostTOS. */
1309       if (name[*length - 1] != 0)
1310         return NULL;
1311
1312       oid2in_addr (name + v->namelen, IN_ADDR_SIZE, addr);
1313
1314       nbr_nbma = ospf_nbr_nbma_lookup (ospf, *addr);
1315
1316       return nbr_nbma;
1317     }
1318   else
1319     {
1320       len = *length - v->namelen;
1321       if (len > 4)
1322         len = 4;
1323
1324       oid2in_addr (name + v->namelen, len, addr);
1325
1326       nbr_nbma = ospf_nbr_nbma_lookup_next (ospf, addr, len == 0 ? 1 : 0);
1327
1328       if (nbr_nbma == NULL)
1329         return NULL;
1330
1331       oid_copy_addr (name + v->namelen, addr, IN_ADDR_SIZE);
1332
1333       /* Set TOS 0. */
1334       name[v->namelen + IN_ADDR_SIZE] = 0;
1335
1336       *length = v->namelen + IN_ADDR_SIZE + 1;
1337
1338       return nbr_nbma;
1339     }
1340   return NULL;
1341 }
1342
1343 static u_char *
1344 ospfHostEntry (struct variable *v, oid *name, size_t *length, int exact,
1345                size_t *var_len, WriteMethod **write_method)
1346 {
1347   struct ospf_nbr_nbma *nbr_nbma;
1348   struct ospf_interface *oi;
1349   struct in_addr addr;
1350   struct ospf *ospf;
1351
1352   /* Check OSPF instance. */
1353   ospf = ospf_lookup ();
1354   if (ospf == NULL)
1355     return NULL;
1356
1357   memset (&addr, 0, sizeof (struct in_addr));
1358
1359   nbr_nbma = ospfHostLookup (v, name, length, &addr, exact);
1360   if (nbr_nbma == NULL)
1361     return NULL;
1362
1363   oi = nbr_nbma->oi;
1364
1365   /* Return the current value of the variable */
1366   switch (v->magic)
1367     {
1368     case OSPFHOSTIPADDRESS:     /* 1 */
1369       return SNMP_IPADDRESS (nbr_nbma->addr);
1370       break;
1371     case OSPFHOSTTOS:           /* 2 */
1372       return SNMP_INTEGER (0);
1373       break;
1374     case OSPFHOSTMETRIC:        /* 3 */
1375       if (oi)
1376         return SNMP_INTEGER (oi->output_cost);
1377       else
1378         return SNMP_INTEGER (1);
1379       break;
1380     case OSPFHOSTSTATUS:        /* 4 */
1381       return SNMP_INTEGER (SNMP_VALID);
1382       break;
1383     case OSPFHOSTAREAID:        /* 5 */
1384       if (oi && oi->area)
1385         return SNMP_IPADDRESS (oi->area->area_id);
1386       else
1387         return SNMP_IPADDRESS (ospf_empty_addr);
1388       break;
1389     default:
1390       return NULL;
1391       break;
1392     }
1393   return NULL;
1394 }
1395 \f
1396 struct list *ospf_snmp_iflist;
1397
1398 struct ospf_snmp_if
1399 {
1400   struct in_addr addr;
1401   unsigned int ifindex;
1402   struct interface *ifp;
1403 };
1404
1405 static struct ospf_snmp_if *
1406 ospf_snmp_if_new (void)
1407 {
1408   return XCALLOC (0, sizeof (struct ospf_snmp_if));
1409 }
1410
1411 static void
1412 ospf_snmp_if_free (struct ospf_snmp_if *osif)
1413 {
1414   XFREE (0, osif);
1415 }
1416
1417 void
1418 ospf_snmp_if_delete (struct interface *ifp)
1419 {
1420   struct listnode *node, *nnode;
1421   struct ospf_snmp_if *osif;
1422
1423   for (ALL_LIST_ELEMENTS (ospf_snmp_iflist, node, nnode, osif))
1424     {
1425       if (osif->ifp == ifp)
1426         {
1427           list_delete_node (ospf_snmp_iflist, node);
1428           ospf_snmp_if_free (osif);
1429           return;
1430         }
1431     }
1432 }
1433
1434 void
1435 ospf_snmp_if_update (struct interface *ifp)
1436 {
1437   struct listnode *node;
1438   struct listnode *pn;
1439   struct connected *ifc;
1440   struct prefix *p;
1441   struct ospf_snmp_if *osif;
1442   struct in_addr *addr;
1443   unsigned int ifindex;
1444
1445   ospf_snmp_if_delete (ifp);
1446
1447   p = NULL;
1448   addr = NULL;
1449   ifindex = 0;
1450
1451   /* Lookup first IPv4 address entry. */
1452   for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, ifc))
1453     {
1454       p = CONNECTED_ID(ifc);
1455
1456       if (p->family == AF_INET)
1457         {
1458           addr = &p->u.prefix4;
1459           break;
1460         }
1461     }
1462   if (! addr)
1463     ifindex = ifp->ifindex;
1464
1465   /* Add interface to the list. */
1466   pn = NULL;
1467   for (ALL_LIST_ELEMENTS_RO (ospf_snmp_iflist, node, osif))
1468     {
1469       if (addr)
1470         {
1471           /* Usual interfaces --> Sort them based on interface IPv4 addresses */
1472           if (ntohl (osif->addr.s_addr) > ntohl (addr->s_addr))
1473             break;
1474         }
1475       else
1476         {
1477           /* Unnumbered interfaces --> Sort them based on interface indexes */
1478           if (osif->addr.s_addr != 0 || osif->ifindex > ifindex)
1479             break;
1480         }
1481       pn = node;
1482     }
1483
1484   osif = ospf_snmp_if_new ();
1485   if (addr) /* Usual interface */
1486   {
1487     osif->addr = *addr;
1488
1489     /* This field is used for storing ospfAddressLessIf OID value,
1490      * conform to RFC1850 OSPF-MIB specification, it must be 0 for
1491      * usual interface */
1492     osif->ifindex = 0;
1493   }
1494   else  /* Unnumbered interface */
1495     osif->ifindex = ifindex;
1496   osif->ifp = ifp;
1497
1498   listnode_add_after (ospf_snmp_iflist, pn, osif);
1499 }
1500
1501 static int
1502 ospf_snmp_is_if_have_addr (struct interface *ifp)
1503 {
1504   struct listnode *nn;
1505   struct connected *ifc;
1506
1507   /* Is this interface having any connected IPv4 address ? */
1508   for (ALL_LIST_ELEMENTS_RO (ifp->connected, nn, ifc))
1509   {
1510     if (CONNECTED_PREFIX(ifc)->family == AF_INET)
1511       return 1;
1512   }
1513
1514   return 0;
1515 }
1516
1517 static struct ospf_interface *
1518 ospf_snmp_if_lookup (struct in_addr *ifaddr, unsigned int *ifindex)
1519 {
1520   struct listnode *node;
1521   struct ospf_snmp_if *osif;
1522   struct ospf_interface *oi = NULL;
1523   struct ospf *ospf = ospf_lookup ();
1524
1525   for (ALL_LIST_ELEMENTS_RO (ospf_snmp_iflist, node, osif))
1526     {
1527       if (ifaddr->s_addr)
1528         {
1529               if (IPV4_ADDR_SAME (&osif->addr, ifaddr))
1530             oi = ospf_if_lookup_by_local_addr (ospf, osif->ifp, *ifaddr);
1531         }
1532       else
1533         {
1534               if (osif->ifindex == *ifindex)
1535             oi = ospf_if_lookup_by_local_addr (ospf, osif->ifp, *ifaddr);
1536         }
1537     }
1538   return oi;
1539 }
1540
1541 static struct ospf_interface *
1542 ospf_snmp_if_lookup_next (struct in_addr *ifaddr, unsigned int *ifindex,
1543                           int ifaddr_next, int ifindex_next)
1544 {
1545   struct ospf_snmp_if *osif;
1546   struct listnode *nn;
1547   struct ospf *ospf = ospf_lookup ();
1548   struct ospf_interface *oi = NULL;
1549
1550   if (ospf == NULL)
1551     return NULL;
1552
1553   /* No instance is specified --> Return the first OSPF interface */
1554   if (ifaddr_next)
1555     {
1556       for (ALL_LIST_ELEMENTS_RO (ospf_snmp_iflist, nn, osif))
1557         {
1558           osif = listgetdata (nn);
1559           *ifaddr = osif->addr;
1560           *ifindex = osif->ifindex;
1561           /* Because no instance is specified, we don't care about the kind of
1562            * interface (usual or unnumbered), just returning the first valid
1563            * OSPF interface */
1564           oi = ospf_if_lookup_by_local_addr (ospf, osif->ifp, *ifaddr);
1565           if (oi)
1566             return (oi);
1567         }
1568       return NULL;
1569     }
1570
1571   /* An instance is specified --> Return the next OSPF interface */
1572   for (ALL_LIST_ELEMENTS_RO (ospf_snmp_iflist, nn, osif))
1573     {
1574       /* Usual interface */
1575       if (ifaddr->s_addr)
1576         {
1577           /* The interface must have valid AF_INET connected address */
1578           /* it must have lager IPv4 address value than the lookup entry */
1579           if ((ospf_snmp_is_if_have_addr(osif->ifp)) &&
1580               (ntohl (osif->addr.s_addr) > ntohl (ifaddr->s_addr)))
1581             {
1582               *ifaddr = osif->addr;
1583               *ifindex = osif->ifindex;
1584
1585               /* and it must be an OSPF interface */
1586               oi = ospf_if_lookup_by_local_addr (ospf, osif->ifp, *ifaddr);
1587               if (oi)
1588                 return oi;
1589             }
1590         }
1591       /* Unnumbered interface */
1592       else
1593         /* The interface must NOT have valid AF_INET connected address */
1594         /* it must have lager interface index than the lookup entry */
1595         if ((!ospf_snmp_is_if_have_addr(osif->ifp)) &&
1596             (osif->ifindex > *ifindex))
1597           {
1598             *ifaddr = osif->addr;
1599             *ifindex = osif->ifindex;
1600
1601             /* and it must be an OSPF interface */
1602             oi = ospf_if_lookup_by_local_addr (ospf, osif->ifp, *ifaddr);
1603             if (oi)
1604               return oi;
1605           }
1606     }
1607   return NULL;
1608 }
1609
1610 static int
1611 ospf_snmp_iftype (struct interface *ifp)
1612 {
1613 #define ospf_snmp_iftype_broadcast         1
1614 #define ospf_snmp_iftype_nbma              2
1615 #define ospf_snmp_iftype_pointToPoint      3
1616 #define ospf_snmp_iftype_pointToMultipoint 5
1617   if (if_is_broadcast (ifp))
1618     return ospf_snmp_iftype_broadcast;
1619   if (if_is_pointopoint (ifp))
1620     return ospf_snmp_iftype_pointToPoint;
1621   return ospf_snmp_iftype_broadcast;
1622 }
1623
1624 static struct ospf_interface *
1625 ospfIfLookup (struct variable *v, oid *name, size_t *length,
1626               struct in_addr *ifaddr, unsigned int *ifindex, int exact)
1627 {
1628   unsigned int len;
1629   int ifaddr_next = 0;
1630   int ifindex_next = 0;
1631   struct ospf_interface *oi;
1632   oid *offset;
1633
1634   if (exact)
1635     {
1636       if (*length != v->namelen + IN_ADDR_SIZE + 1)
1637         return NULL;
1638
1639       oid2in_addr (name + v->namelen, IN_ADDR_SIZE, ifaddr);
1640       *ifindex = name[v->namelen + IN_ADDR_SIZE];
1641
1642       return ospf_snmp_if_lookup (ifaddr, ifindex);
1643     }
1644   else
1645     {
1646       len = *length - v->namelen;
1647       if (len >= IN_ADDR_SIZE)
1648         len = IN_ADDR_SIZE;
1649       if (len <= 0)
1650         ifaddr_next = 1;
1651
1652       oid2in_addr (name + v->namelen, len, ifaddr);
1653
1654       len = *length - v->namelen - IN_ADDR_SIZE;
1655       if (len >= 1)
1656         len = 1;
1657       else
1658         ifindex_next = 1;
1659
1660       if (len == 1)
1661         *ifindex = name[v->namelen + IN_ADDR_SIZE];
1662
1663       oi = ospf_snmp_if_lookup_next (ifaddr, ifindex, ifaddr_next,
1664                                       ifindex_next);
1665       if (oi)
1666         {
1667           *length = v->namelen + IN_ADDR_SIZE + 1;
1668           offset = name + v->namelen;
1669           oid_copy_addr (offset, ifaddr, IN_ADDR_SIZE);
1670           offset += IN_ADDR_SIZE;
1671           *offset = *ifindex;
1672           return oi;
1673         }
1674     }
1675   return NULL;
1676 }
1677
1678 static u_char *
1679 ospfIfEntry (struct variable *v, oid *name, size_t *length, int exact,
1680              size_t *var_len, WriteMethod **write_method)
1681 {
1682   unsigned int ifindex;
1683   struct in_addr ifaddr;
1684   struct ospf_interface *oi;
1685   struct ospf *ospf;
1686
1687   ifindex = 0;
1688   memset (&ifaddr, 0, sizeof (struct in_addr));
1689
1690   /* Check OSPF instance. */
1691   ospf = ospf_lookup ();
1692   if (ospf == NULL)
1693     return NULL;
1694
1695   oi = ospfIfLookup (v, name, length, &ifaddr, &ifindex, exact);
1696   if (oi == NULL)
1697     return NULL;
1698
1699   /* Return the current value of the variable */
1700   switch (v->magic)
1701     {
1702     case OSPFIFIPADDRESS:       /* 1 */
1703       return SNMP_IPADDRESS (ifaddr);
1704       break;
1705     case OSPFADDRESSLESSIF:     /* 2 */
1706       return SNMP_INTEGER (ifindex);
1707       break;
1708     case OSPFIFAREAID:          /* 3 */
1709       if (oi->area)
1710         return SNMP_IPADDRESS (oi->area->area_id);
1711       else
1712         return SNMP_IPADDRESS (ospf_empty_addr);
1713       break;
1714     case OSPFIFTYPE:            /* 4 */
1715       return SNMP_INTEGER (ospf_snmp_iftype (oi->ifp));
1716       break;
1717     case OSPFIFADMINSTAT:       /* 5 */
1718       if (oi)
1719         return SNMP_INTEGER (OSPF_STATUS_ENABLED);
1720       else
1721         return SNMP_INTEGER (OSPF_STATUS_DISABLED);
1722       break;
1723     case OSPFIFRTRPRIORITY:     /* 6 */
1724       return SNMP_INTEGER (PRIORITY (oi));
1725       break;
1726     case OSPFIFTRANSITDELAY:    /* 7 */
1727       return SNMP_INTEGER (OSPF_IF_PARAM (oi, transmit_delay));
1728       break;
1729     case OSPFIFRETRANSINTERVAL: /* 8 */
1730       return SNMP_INTEGER (OSPF_IF_PARAM (oi, retransmit_interval));
1731       break;
1732     case OSPFIFHELLOINTERVAL:   /* 9 */
1733       return SNMP_INTEGER (OSPF_IF_PARAM (oi, v_hello));
1734       break;
1735     case OSPFIFRTRDEADINTERVAL: /* 10 */
1736       return SNMP_INTEGER (OSPF_IF_PARAM (oi, v_wait));
1737       break;
1738     case OSPFIFPOLLINTERVAL:    /* 11 */
1739       return SNMP_INTEGER (OSPF_POLL_INTERVAL_DEFAULT);
1740       break;
1741     case OSPFIFSTATE:           /* 12 */
1742       return SNMP_INTEGER (ISM_SNMP(oi->state));
1743       break;
1744     case OSPFIFDESIGNATEDROUTER: /* 13 */
1745       return SNMP_IPADDRESS (DR (oi));
1746       break;
1747     case OSPFIFBACKUPDESIGNATEDROUTER: /* 14 */
1748       return SNMP_IPADDRESS (BDR (oi));
1749       break;
1750     case OSPFIFEVENTS:          /* 15 */
1751       return SNMP_INTEGER (oi->state_change);
1752       break;
1753     case OSPFIFAUTHKEY:         /* 16 */
1754       *var_len = 0;
1755       return (u_char *) OSPF_IF_PARAM (oi, auth_simple);
1756       break;
1757     case OSPFIFSTATUS:          /* 17 */
1758       return SNMP_INTEGER (SNMP_VALID);
1759       break;
1760     case OSPFIFMULTICASTFORWARDING: /* 18 */
1761 #define ospf_snmp_multiforward_blocked    1
1762 #define ospf_snmp_multiforward_multicast  2
1763 #define ospf_snmp_multiforward_unicast    3
1764       return SNMP_INTEGER (ospf_snmp_multiforward_blocked);
1765       break;
1766     case OSPFIFDEMAND:          /* 19 */
1767       return SNMP_INTEGER (SNMP_FALSE);
1768       break;
1769     case OSPFIFAUTHTYPE:        /* 20 */
1770       if (oi->area)
1771         return SNMP_INTEGER (oi->area->auth_type);
1772       else
1773         return SNMP_INTEGER (0);
1774       break;
1775     default:
1776       return NULL;
1777       break;
1778     }
1779   return NULL;
1780 }
1781
1782 #define OSPF_SNMP_METRIC_VALUE 1
1783
1784 static struct ospf_interface *
1785 ospfIfMetricLookup (struct variable *v, oid *name, size_t *length,
1786                     struct in_addr *ifaddr, unsigned int *ifindex, int exact)
1787 {
1788   unsigned int len;
1789   int ifaddr_next = 0;
1790   int ifindex_next = 0;
1791   struct ospf_interface *oi;
1792   oid *offset;
1793   int metric;
1794
1795   if (exact)
1796     {
1797       if (*length != v->namelen + IN_ADDR_SIZE + 1 + 1)
1798         return NULL;
1799
1800       oid2in_addr (name + v->namelen, IN_ADDR_SIZE, ifaddr);
1801       *ifindex = name[v->namelen + IN_ADDR_SIZE];
1802       metric = name[v->namelen + IN_ADDR_SIZE + 1];
1803
1804       if (metric != OSPF_SNMP_METRIC_VALUE)
1805         return NULL;
1806
1807       return ospf_snmp_if_lookup (ifaddr, ifindex);
1808     }
1809   else
1810     {
1811       len = *length - v->namelen;
1812       if (len >= IN_ADDR_SIZE)
1813         len = IN_ADDR_SIZE;
1814       else
1815         ifaddr_next = 1;
1816
1817       oid2in_addr (name + v->namelen, len, ifaddr);
1818
1819       len = *length - v->namelen - IN_ADDR_SIZE;
1820       if (len >= 1)
1821         len = 1;
1822       else
1823         ifindex_next = 1;
1824
1825       if (len == 1)
1826         *ifindex = name[v->namelen + IN_ADDR_SIZE];
1827
1828       oi = ospf_snmp_if_lookup_next (ifaddr, ifindex, ifaddr_next,
1829                                       ifindex_next);
1830       if (oi)
1831         {
1832           *length = v->namelen + IN_ADDR_SIZE + 1 + 1;
1833           offset = name + v->namelen;
1834           oid_copy_addr (offset, ifaddr, IN_ADDR_SIZE);
1835           offset += IN_ADDR_SIZE;
1836           *offset = *ifindex;
1837           offset++;
1838           *offset = OSPF_SNMP_METRIC_VALUE;
1839           return oi;
1840         }
1841     }
1842   return NULL;
1843 }
1844
1845 static u_char *
1846 ospfIfMetricEntry (struct variable *v, oid *name, size_t *length, int exact,
1847                    size_t *var_len, WriteMethod **write_method)
1848 {
1849   /* Currently we support metric 1 only. */
1850   unsigned int ifindex;
1851   struct in_addr ifaddr;
1852   struct ospf_interface *oi;
1853   struct ospf *ospf;
1854
1855   ifindex = 0;
1856   memset (&ifaddr, 0, sizeof (struct in_addr));
1857
1858   /* Check OSPF instance. */
1859   ospf = ospf_lookup ();
1860   if (ospf == NULL)
1861     return NULL;
1862
1863   oi = ospfIfMetricLookup (v, name, length, &ifaddr, &ifindex, exact);
1864   if (oi == NULL)
1865     return NULL;
1866
1867   /* Return the current value of the variable */
1868   switch (v->magic)
1869     {
1870     case OSPFIFMETRICIPADDRESS:
1871       return SNMP_IPADDRESS (ifaddr);
1872       break;
1873     case OSPFIFMETRICADDRESSLESSIF:
1874       return SNMP_INTEGER (ifindex);
1875       break;
1876     case OSPFIFMETRICTOS:
1877       return SNMP_INTEGER (0);
1878       break;
1879     case OSPFIFMETRICVALUE:
1880       return SNMP_INTEGER (OSPF_SNMP_METRIC_VALUE);
1881       break;
1882     case OSPFIFMETRICSTATUS:
1883       return SNMP_INTEGER (1);
1884       break;
1885     default:
1886       return NULL;
1887       break;
1888     }
1889   return NULL;
1890 }
1891 \f
1892 struct route_table *ospf_snmp_vl_table;
1893
1894 void
1895 ospf_snmp_vl_add (struct ospf_vl_data *vl_data)
1896 {
1897   struct prefix_ls lp;
1898   struct route_node *rn;
1899
1900   memset (&lp, 0, sizeof (struct prefix_ls));
1901   lp.family = 0;
1902   lp.prefixlen = 64;
1903   lp.id = vl_data->vl_area_id;
1904   lp.adv_router = vl_data->vl_peer;
1905
1906   rn = route_node_get (ospf_snmp_vl_table, (struct prefix *) &lp);
1907   rn->info = vl_data;
1908 }
1909
1910 void
1911 ospf_snmp_vl_delete (struct ospf_vl_data *vl_data)
1912 {
1913   struct prefix_ls lp;
1914   struct route_node *rn;
1915
1916   memset (&lp, 0, sizeof (struct prefix_ls));
1917   lp.family = 0;
1918   lp.prefixlen = 64;
1919   lp.id = vl_data->vl_area_id;
1920   lp.adv_router = vl_data->vl_peer;
1921
1922   rn = route_node_lookup (ospf_snmp_vl_table, (struct prefix *) &lp);
1923   if (! rn)
1924     return;
1925   rn->info = NULL;
1926   route_unlock_node (rn);
1927   route_unlock_node (rn);
1928 }
1929
1930 static struct ospf_vl_data *
1931 ospf_snmp_vl_lookup (struct in_addr *area_id, struct in_addr *neighbor)
1932 {
1933   struct prefix_ls lp;
1934   struct route_node *rn;
1935   struct ospf_vl_data *vl_data;
1936
1937   memset (&lp, 0, sizeof (struct prefix_ls));
1938   lp.family = 0;
1939   lp.prefixlen = 64;
1940   lp.id = *area_id;
1941   lp.adv_router = *neighbor;
1942
1943   rn = route_node_lookup (ospf_snmp_vl_table, (struct prefix *) &lp);
1944   if (rn)
1945     {
1946       vl_data = rn->info;
1947       route_unlock_node (rn);
1948       return vl_data;
1949     }
1950   return NULL;
1951 }
1952
1953 static struct ospf_vl_data *
1954 ospf_snmp_vl_lookup_next (struct in_addr *area_id, struct in_addr *neighbor,
1955                           int first)
1956 {
1957   struct prefix_ls lp;
1958   struct route_node *rn;
1959   struct ospf_vl_data *vl_data;
1960
1961   memset (&lp, 0, sizeof (struct prefix_ls));
1962   lp.family = 0;
1963   lp.prefixlen = 64;
1964   lp.id = *area_id;
1965   lp.adv_router = *neighbor;
1966
1967   if (first)
1968     rn = route_top (ospf_snmp_vl_table);
1969   else
1970     {
1971       rn = route_node_get (ospf_snmp_vl_table, (struct prefix *) &lp);
1972       rn = route_next (rn);
1973     }
1974
1975   for (; rn; rn = route_next (rn))
1976     if (rn->info)
1977       break;
1978
1979   if (rn && rn->info)
1980     {
1981       vl_data = rn->info;
1982       *area_id = vl_data->vl_area_id;
1983       *neighbor = vl_data->vl_peer;
1984       route_unlock_node (rn);
1985       return vl_data;
1986     }
1987   return NULL;
1988 }
1989
1990 static struct ospf_vl_data *
1991 ospfVirtIfLookup (struct variable *v, oid *name, size_t *length,
1992                   struct in_addr *area_id, struct in_addr *neighbor, int exact)
1993 {
1994   int first;
1995   unsigned int len;
1996   struct ospf_vl_data *vl_data;
1997
1998   if (exact)
1999     {
2000       if (*length != v->namelen + IN_ADDR_SIZE + IN_ADDR_SIZE)
2001         return NULL;
2002
2003       oid2in_addr (name + v->namelen, IN_ADDR_SIZE, area_id);
2004       oid2in_addr (name + v->namelen + IN_ADDR_SIZE, IN_ADDR_SIZE, neighbor);
2005
2006       return ospf_snmp_vl_lookup (area_id, neighbor);
2007     }
2008   else
2009     {
2010       first = 0;
2011
2012       len = *length - v->namelen;
2013       if (len <= 0)
2014         first = 1;
2015       if (len > IN_ADDR_SIZE)
2016         len = IN_ADDR_SIZE;
2017       oid2in_addr (name + v->namelen, len, area_id);
2018
2019       len = *length - v->namelen - IN_ADDR_SIZE;
2020       if (len > IN_ADDR_SIZE)
2021         len = IN_ADDR_SIZE;
2022       oid2in_addr (name + v->namelen + IN_ADDR_SIZE, len, neighbor);
2023
2024       vl_data = ospf_snmp_vl_lookup_next (area_id, neighbor, first);
2025
2026       if (vl_data)
2027         {
2028           *length = v->namelen + IN_ADDR_SIZE + IN_ADDR_SIZE;
2029           oid_copy_addr (name + v->namelen, area_id, IN_ADDR_SIZE);
2030           oid_copy_addr (name + v->namelen + IN_ADDR_SIZE, neighbor,
2031                          IN_ADDR_SIZE);
2032           return vl_data;
2033         }
2034     }
2035   return NULL;
2036 }
2037
2038 static u_char *
2039 ospfVirtIfEntry (struct variable *v, oid *name, size_t *length, int exact,
2040                  size_t *var_len, WriteMethod **write_method)
2041 {
2042   struct ospf_vl_data *vl_data;
2043   struct ospf_interface *oi;
2044   struct in_addr area_id;
2045   struct in_addr neighbor;
2046
2047   memset (&area_id, 0, sizeof (struct in_addr));
2048   memset (&neighbor, 0, sizeof (struct in_addr));
2049
2050   vl_data = ospfVirtIfLookup (v, name, length, &area_id, &neighbor, exact);
2051   if (! vl_data)
2052     return NULL;
2053   oi = vl_data->vl_oi;
2054   if (! oi)
2055     return NULL;
2056
2057   /* Return the current value of the variable */
2058   switch (v->magic)
2059     {
2060     case OSPFVIRTIFAREAID:
2061       return SNMP_IPADDRESS (area_id);
2062       break;
2063     case OSPFVIRTIFNEIGHBOR:
2064       return SNMP_IPADDRESS (neighbor);
2065       break;
2066     case OSPFVIRTIFTRANSITDELAY:
2067       return SNMP_INTEGER (OSPF_IF_PARAM (oi, transmit_delay));
2068       break;
2069     case OSPFVIRTIFRETRANSINTERVAL:
2070       return SNMP_INTEGER (OSPF_IF_PARAM (oi, retransmit_interval));
2071       break;
2072     case OSPFVIRTIFHELLOINTERVAL:
2073       return SNMP_INTEGER (OSPF_IF_PARAM (oi, v_hello));
2074       break;
2075     case OSPFVIRTIFRTRDEADINTERVAL:
2076       return SNMP_INTEGER (OSPF_IF_PARAM (oi, v_wait));
2077       break;
2078     case OSPFVIRTIFSTATE:
2079       return SNMP_INTEGER (oi->state);
2080       break;
2081     case OSPFVIRTIFEVENTS:
2082       return SNMP_INTEGER (oi->state_change);
2083       break;
2084     case OSPFVIRTIFAUTHKEY:
2085       *var_len = 0;
2086       return (u_char *) OSPF_IF_PARAM (oi, auth_simple);
2087       break;
2088     case OSPFVIRTIFSTATUS:
2089       return SNMP_INTEGER (SNMP_VALID);
2090       break;
2091     case OSPFVIRTIFAUTHTYPE:
2092       if (oi->area)
2093         return SNMP_INTEGER (oi->area->auth_type);
2094       else
2095         return SNMP_INTEGER (0);
2096       break;
2097     default:
2098       return NULL;
2099       break;
2100     }
2101   return NULL;
2102 }
2103 \f
2104 static struct ospf_neighbor *
2105 ospf_snmp_nbr_lookup (struct ospf *ospf, struct in_addr *nbr_addr,
2106                       unsigned int *ifindex)
2107 {
2108   struct listnode *node, *nnode;
2109   struct ospf_interface *oi;
2110   struct ospf_neighbor *nbr;
2111   struct route_node *rn;
2112
2113   for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
2114     {
2115       for (rn = route_top (oi->nbrs); rn; rn = route_next (rn))
2116         if ((nbr = rn->info) != NULL
2117             && nbr != oi->nbr_self
2118 /* If EXACT match is needed, provide ALL entry found
2119             && nbr->state != NSM_Down
2120  */
2121             && nbr->src.s_addr != 0)
2122           {
2123             if (IPV4_ADDR_SAME (&nbr->src, nbr_addr))
2124               {
2125                 route_unlock_node (rn);
2126                 return nbr;
2127               }
2128           }
2129     }
2130   return NULL;
2131 }
2132
2133 static struct ospf_neighbor *
2134 ospf_snmp_nbr_lookup_next (struct in_addr *nbr_addr, unsigned int *ifindex,
2135                            int first)
2136 {
2137   struct listnode *nn;
2138   struct ospf_interface *oi;
2139   struct ospf_neighbor *nbr;
2140   struct route_node *rn;
2141   struct ospf_neighbor *min = NULL;
2142   struct ospf *ospf = ospf;
2143
2144   ospf = ospf_lookup ();
2145
2146   for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, nn, oi))
2147     {
2148       for (rn = route_top (oi->nbrs); rn; rn = route_next (rn))
2149         if ((nbr = rn->info) != NULL
2150             && nbr != oi->nbr_self
2151             && nbr->state != NSM_Down
2152             && nbr->src.s_addr != 0)
2153           {
2154             if (first)
2155               {
2156                 if (! min)
2157                   min = nbr;
2158                 else if (ntohl (nbr->src.s_addr) < ntohl (min->src.s_addr))
2159                   min = nbr;
2160               }
2161             else if (ntohl (nbr->src.s_addr) > ntohl (nbr_addr->s_addr))
2162               {
2163                 if (! min)
2164                   min = nbr;
2165                 else if (ntohl (nbr->src.s_addr) < ntohl (min->src.s_addr))
2166                   min = nbr;
2167               }
2168           }
2169     }
2170   if (min)
2171     {
2172       *nbr_addr = min->src;
2173       *ifindex = 0;
2174       return min;
2175     }
2176   return NULL;
2177 }
2178
2179 static struct ospf_neighbor *
2180 ospfNbrLookup (struct variable *v, oid *name, size_t *length,
2181                struct in_addr *nbr_addr, unsigned int *ifindex, int exact)
2182 {
2183   unsigned int len;
2184   int first;
2185   struct ospf_neighbor *nbr;
2186   struct ospf *ospf;
2187
2188   ospf = ospf_lookup ();
2189
2190   if (! ospf)
2191     return NULL;
2192
2193   if (exact)
2194     {
2195       if (*length != v->namelen + IN_ADDR_SIZE + 1)
2196         return NULL;
2197
2198       oid2in_addr (name + v->namelen, IN_ADDR_SIZE, nbr_addr);
2199       *ifindex = name[v->namelen + IN_ADDR_SIZE];
2200
2201       return ospf_snmp_nbr_lookup (ospf, nbr_addr, ifindex);
2202     }
2203   else
2204     {
2205       first = 0;
2206       len = *length - v->namelen;
2207
2208       if (len <= 0)
2209         first = 1;
2210
2211       if (len > IN_ADDR_SIZE)
2212         len = IN_ADDR_SIZE;
2213
2214       oid2in_addr (name + v->namelen, len, nbr_addr);
2215
2216       len = *length - v->namelen - IN_ADDR_SIZE;
2217       if (len >= 1)
2218         *ifindex = name[v->namelen + IN_ADDR_SIZE];
2219
2220       nbr = ospf_snmp_nbr_lookup_next (nbr_addr, ifindex, first);
2221
2222       if (nbr)
2223         {
2224           *length = v->namelen + IN_ADDR_SIZE + 1;
2225           oid_copy_addr (name + v->namelen, nbr_addr, IN_ADDR_SIZE);
2226           name[v->namelen + IN_ADDR_SIZE] = *ifindex;
2227           return nbr;
2228         }
2229     }
2230   return NULL;
2231 }
2232
2233 /* map internal quagga neighbor states to official MIB values:
2234
2235 ospfNbrState OBJECT-TYPE
2236         SYNTAX   INTEGER    {
2237                     down (1),
2238                     attempt (2),
2239                     init (3),
2240                     twoWay (4),
2241                     exchangeStart (5),
2242                     exchange (6),
2243                     loading (7),
2244                     full (8)
2245                   }
2246 */
2247 static int32_t
2248 ospf_snmp_neighbor_state(u_char nst)
2249 {
2250   switch (nst)
2251     {
2252     case NSM_Attempt:
2253       return 2;
2254     case NSM_Init:
2255       return 3;
2256     case NSM_TwoWay:
2257       return 4;
2258     case NSM_ExStart:
2259       return 5;
2260     case NSM_Exchange:
2261       return 6;
2262     case NSM_Loading:
2263       return 7;
2264     case NSM_Full:
2265       return 8;
2266     default:
2267       return 1; /* down */
2268     }
2269 }
2270
2271 static u_char *
2272 ospfNbrEntry (struct variable *v, oid *name, size_t *length, int exact,
2273               size_t *var_len, WriteMethod **write_method)
2274 {
2275   struct in_addr nbr_addr;
2276   unsigned int ifindex;
2277   struct ospf_neighbor *nbr;
2278   struct ospf_interface *oi;
2279
2280   memset (&nbr_addr, 0, sizeof (struct in_addr));
2281   ifindex = 0;
2282
2283   nbr = ospfNbrLookup (v, name, length, &nbr_addr, &ifindex, exact);
2284   if (! nbr)
2285     return NULL;
2286   oi = nbr->oi;
2287   if (! oi)
2288     return NULL;
2289
2290   /* Return the current value of the variable */
2291   switch (v->magic)
2292     {
2293     case OSPFNBRIPADDR:
2294       return SNMP_IPADDRESS (nbr_addr);
2295       break;
2296     case OSPFNBRADDRESSLESSINDEX:
2297       return SNMP_INTEGER (ifindex);
2298       break;
2299     case OSPFNBRRTRID:
2300       return SNMP_IPADDRESS (nbr->router_id);
2301       break;
2302     case OSPFNBROPTIONS:
2303       return SNMP_INTEGER (oi->nbr_self->options);
2304       break;
2305     case OSPFNBRPRIORITY:
2306       return SNMP_INTEGER (nbr->priority);
2307       break;
2308     case OSPFNBRSTATE:
2309       return SNMP_INTEGER (ospf_snmp_neighbor_state(nbr->state));
2310       break;
2311     case OSPFNBREVENTS:
2312       return SNMP_INTEGER (nbr->state_change);
2313       break;
2314     case OSPFNBRLSRETRANSQLEN:
2315       return SNMP_INTEGER (ospf_ls_retransmit_count (nbr));
2316       break;
2317     case OSPFNBMANBRSTATUS:
2318       return SNMP_INTEGER (SNMP_VALID);
2319       break;
2320     case OSPFNBMANBRPERMANENCE:
2321       return SNMP_INTEGER (2);
2322       break;
2323     case OSPFNBRHELLOSUPPRESSED:
2324       return SNMP_INTEGER (SNMP_FALSE);
2325       break;
2326     default:
2327       return NULL;
2328       break;
2329     }
2330   return NULL;
2331 }
2332 \f
2333 static u_char *
2334 ospfVirtNbrEntry (struct variable *v, oid *name, size_t *length, int exact,
2335                   size_t *var_len, WriteMethod **write_method)
2336 {
2337   struct ospf_vl_data *vl_data;
2338   struct in_addr area_id;
2339   struct in_addr neighbor;
2340   struct ospf *ospf;
2341
2342   memset (&area_id, 0, sizeof (struct in_addr));
2343   memset (&neighbor, 0, sizeof (struct in_addr));
2344
2345   /* Check OSPF instance. */
2346   ospf = ospf_lookup ();
2347   if (ospf == NULL)
2348     return NULL;
2349
2350   vl_data = ospfVirtIfLookup (v, name, length, &area_id, &neighbor, exact);
2351   if (! vl_data)
2352     return NULL;
2353
2354   /* Return the current value of the variable */
2355   switch (v->magic)
2356     {
2357     case OSPFVIRTNBRAREA:
2358       return (u_char *) NULL;
2359       break;
2360     case OSPFVIRTNBRRTRID:
2361       return (u_char *) NULL;
2362       break;
2363     case OSPFVIRTNBRIPADDR:
2364       return (u_char *) NULL;
2365       break;
2366     case OSPFVIRTNBROPTIONS:
2367       return (u_char *) NULL;
2368       break;
2369     case OSPFVIRTNBRSTATE:
2370       return (u_char *) NULL;
2371       break;
2372     case OSPFVIRTNBREVENTS:
2373       return (u_char *) NULL;
2374       break;
2375     case OSPFVIRTNBRLSRETRANSQLEN:
2376       return (u_char *) NULL;
2377       break;
2378     case OSPFVIRTNBRHELLOSUPPRESSED:
2379       return (u_char *) NULL;
2380       break;
2381     default:
2382       return NULL;
2383       break;
2384     }
2385   return NULL;
2386 }
2387 \f
2388 static struct ospf_lsa *
2389 ospfExtLsdbLookup (struct variable *v, oid *name, size_t *length, u_char *type,
2390                    struct in_addr *ls_id, struct in_addr *router_id, int exact)
2391 {
2392   int first;
2393   oid *offset;
2394   int offsetlen;
2395   u_char lsa_type;
2396   unsigned int len;
2397   struct ospf_lsa *lsa;
2398   struct ospf *ospf;
2399
2400   ospf = ospf_lookup ();
2401   if (exact)
2402     {
2403       if (*length != v->namelen + 1 + IN_ADDR_SIZE + IN_ADDR_SIZE)
2404         return NULL;
2405
2406       offset = name + v->namelen;
2407
2408       /* Make it sure given value match to type. */
2409       lsa_type = *offset;
2410       offset++;
2411
2412       if (lsa_type != *type)
2413         return NULL;
2414
2415       /* LS ID. */
2416       oid2in_addr (offset, IN_ADDR_SIZE, ls_id);
2417       offset += IN_ADDR_SIZE;
2418
2419       /* Router ID. */
2420       oid2in_addr (offset, IN_ADDR_SIZE, router_id);
2421
2422       return ospf_lsdb_lookup_by_id (ospf->lsdb, *type, *ls_id, *router_id);
2423     }
2424   else
2425     {
2426       /* Get variable length. */
2427       first = 0;
2428       offset = name + v->namelen;
2429       offsetlen = *length - v->namelen;
2430
2431       /* LSA type value. */
2432       lsa_type = *offset;
2433       offset++;
2434       offsetlen--;
2435
2436       if (offsetlen <= 0 || lsa_type < OSPF_AS_EXTERNAL_LSA)
2437         first = 1;
2438
2439       /* LS ID. */
2440       len = offsetlen;
2441       if (len > IN_ADDR_SIZE)
2442         len = IN_ADDR_SIZE;
2443
2444       oid2in_addr (offset, len, ls_id);
2445
2446       offset += IN_ADDR_SIZE;
2447       offsetlen -= IN_ADDR_SIZE;
2448
2449       /* Router ID. */
2450       len = offsetlen;
2451       if (len > IN_ADDR_SIZE)
2452         len = IN_ADDR_SIZE;
2453
2454       oid2in_addr (offset, len, router_id);
2455
2456       lsa = ospf_lsdb_lookup_by_id_next (ospf->lsdb, *type, *ls_id,
2457                                         *router_id, first);
2458
2459       if (lsa)
2460         {
2461           /* Fill in length. */
2462           *length = v->namelen + 1 + IN_ADDR_SIZE + IN_ADDR_SIZE;
2463
2464           /* Fill in value. */
2465           offset = name + v->namelen;
2466
2467           *offset = OSPF_AS_EXTERNAL_LSA;
2468           offset++;
2469           oid_copy_addr (offset, &lsa->data->id, IN_ADDR_SIZE);
2470           offset += IN_ADDR_SIZE;
2471           oid_copy_addr (offset, &lsa->data->adv_router, IN_ADDR_SIZE);
2472
2473           return lsa;
2474         }
2475     }
2476   return NULL;
2477 }
2478
2479 static u_char *
2480 ospfExtLsdbEntry (struct variable *v, oid *name, size_t *length, int exact,
2481                   size_t *var_len, WriteMethod **write_method)
2482 {
2483   struct ospf_lsa *lsa;
2484   struct lsa_header *lsah;
2485   u_char type;
2486   struct in_addr ls_id;
2487   struct in_addr router_id;
2488   struct ospf *ospf;
2489
2490   type = OSPF_AS_EXTERNAL_LSA;
2491   memset (&ls_id, 0, sizeof (struct in_addr));
2492   memset (&router_id, 0, sizeof (struct in_addr));
2493
2494   /* Check OSPF instance. */
2495   ospf = ospf_lookup ();
2496   if (ospf == NULL)
2497     return NULL;
2498
2499   lsa = ospfExtLsdbLookup (v, name, length, &type, &ls_id, &router_id, exact);
2500   if (! lsa)
2501     return NULL;
2502
2503   lsah = lsa->data;
2504
2505   /* Return the current value of the variable */
2506   switch (v->magic)
2507     {
2508     case OSPFEXTLSDBTYPE:
2509       return SNMP_INTEGER (OSPF_AS_EXTERNAL_LSA);
2510       break;
2511     case OSPFEXTLSDBLSID:
2512       return SNMP_IPADDRESS (lsah->id);
2513       break;
2514     case OSPFEXTLSDBROUTERID:
2515       return SNMP_IPADDRESS (lsah->adv_router);
2516       break;
2517     case OSPFEXTLSDBSEQUENCE:
2518       return SNMP_INTEGER (lsah->ls_seqnum);
2519       break;
2520     case OSPFEXTLSDBAGE:
2521       return SNMP_INTEGER (lsah->ls_age);
2522       break;
2523     case OSPFEXTLSDBCHECKSUM:
2524       return SNMP_INTEGER (lsah->checksum);
2525       break;
2526     case OSPFEXTLSDBADVERTISEMENT:
2527       *var_len = ntohs (lsah->length);
2528       return (u_char *) lsah;
2529       break;
2530     default:
2531       return NULL;
2532       break;
2533     }
2534   return NULL;
2535 }
2536 \f
2537 static u_char *
2538 ospfAreaAggregateEntry (struct variable *v, oid *name, size_t *length,
2539                         int exact, size_t *var_len, WriteMethod **write_method)
2540 {
2541   /* Return the current value of the variable */
2542   switch (v->magic)
2543     {
2544     case OSPFAREAAGGREGATEAREAID:
2545       return (u_char *) NULL;
2546       break;
2547     case OSPFAREAAGGREGATELSDBTYPE:
2548       return (u_char *) NULL;
2549       break;
2550     case OSPFAREAAGGREGATENET:
2551       return (u_char *) NULL;
2552       break;
2553     case OSPFAREAAGGREGATEMASK:
2554       return (u_char *) NULL;
2555       break;
2556     case OSPFAREAAGGREGATESTATUS:
2557       return (u_char *) NULL;
2558       break;
2559     case OSPFAREAAGGREGATEEFFECT:
2560       return (u_char *) NULL;
2561       break;
2562     default:
2563       return NULL;
2564       break;
2565     }
2566   return NULL;
2567 }
2568 \f
2569 /* OSPF Traps. */
2570 #define IFSTATECHANGE      16
2571 #define VIRTIFSTATECHANGE   1
2572 #define NBRSTATECHANGE      2
2573 #define VIRTNBRSTATECHANGE  3
2574
2575 struct trap_object ospfNbrTrapList[] =
2576 {
2577   {ospfGeneralGroup, -2, {1, OSPFROUTERID}},
2578   {ospfNbrEntry, 3, {10, 1, OSPFNBRIPADDR}},
2579   {ospfNbrEntry, 3, {10, 1, OSPFNBRRTRID}},
2580   {ospfNbrEntry, 3, {10, 1, OSPFNBRSTATE}}
2581 };
2582
2583
2584 struct trap_object ospfVirtNbrTrapList[] =
2585 {
2586   {ospfGeneralGroup, -2, {1, 1}},
2587   {ospfVirtNbrEntry, 3, {11, 1, OSPFVIRTNBRAREA}},
2588   {ospfVirtNbrEntry, 3, {11, 1, OSPFVIRTNBRRTRID}},
2589   {ospfVirtNbrEntry, 3, {11, 1, OSPFVIRTNBRSTATE}}
2590 };
2591
2592 struct trap_object ospfIfTrapList[] =
2593 {
2594   {ospfGeneralGroup, -2, {1, OSPFROUTERID}},
2595   {ospfIfEntry, 3, {7, 1, OSPFIFIPADDRESS}},
2596   {ospfIfEntry, 3, {7, 1, OSPFADDRESSLESSIF}},
2597   {ospfIfEntry, 3, {7, 1, OSPFIFSTATE}}
2598 };
2599
2600 struct trap_object ospfVirtIfTrapList[] =
2601 {
2602   {ospfGeneralGroup, -2, {1, OSPFROUTERID}},
2603   {ospfVirtIfEntry, 3, {9, 1, OSPFVIRTIFAREAID}},
2604   {ospfVirtIfEntry, 3, {9, 1, OSPFVIRTIFNEIGHBOR}},
2605   {ospfVirtIfEntry, 3, {9, 1, OSPFVIRTIFSTATE}}
2606 };
2607
2608 void
2609 ospfTrapNbrStateChange (struct ospf_neighbor *on)
2610 {
2611   oid index[sizeof (oid) * (IN_ADDR_SIZE + 1)];
2612   char msgbuf[16];
2613
2614   ospf_nbr_state_message(on, msgbuf, sizeof(msgbuf));
2615   zlog (NULL, LOG_INFO, "ospfTrapNbrStateChange trap sent: %s now %s",
2616         inet_ntoa(on->address.u.prefix4), msgbuf);
2617
2618   oid_copy_addr (index, &(on->address.u.prefix4), IN_ADDR_SIZE);
2619   index[IN_ADDR_SIZE] = 0;
2620
2621   smux_trap (ospf_oid, sizeof ospf_oid / sizeof (oid),
2622              index,  IN_ADDR_SIZE + 1,
2623              ospfNbrTrapList,
2624              sizeof ospfNbrTrapList / sizeof (struct trap_object),
2625              time (NULL), NBRSTATECHANGE);
2626 }
2627
2628 void
2629 ospfTrapVirtNbrStateChange (struct ospf_neighbor *on)
2630 {
2631   oid index[sizeof (oid) * (IN_ADDR_SIZE + 1)];
2632
2633   zlog (NULL, LOG_INFO, "ospfTrapVirtNbrStateChange trap sent");
2634
2635   oid_copy_addr (index, &(on->address.u.prefix4), IN_ADDR_SIZE);
2636   index[IN_ADDR_SIZE] = 0;
2637
2638   smux_trap (ospf_oid, sizeof ospf_oid / sizeof (oid),
2639              index,  IN_ADDR_SIZE + 1,
2640              ospfVirtNbrTrapList,
2641              sizeof ospfVirtNbrTrapList / sizeof (struct trap_object),
2642              time (NULL), VIRTNBRSTATECHANGE);
2643 }
2644
2645 void
2646 ospfTrapIfStateChange (struct ospf_interface *oi)
2647 {
2648   oid index[sizeof (oid) * (IN_ADDR_SIZE + 1)];
2649
2650   zlog (NULL, LOG_INFO, "ospfTrapIfStateChange trap sent: %s now %s",
2651         inet_ntoa(oi->address->u.prefix4),
2652         LOOKUP(ospf_ism_state_msg, oi->state));
2653
2654   oid_copy_addr (index, &(oi->address->u.prefix4), IN_ADDR_SIZE);
2655   index[IN_ADDR_SIZE] = 0;
2656
2657   smux_trap (ospf_oid, sizeof ospf_oid / sizeof (oid),
2658              index, IN_ADDR_SIZE + 1,
2659              ospfIfTrapList,
2660              sizeof ospfIfTrapList / sizeof (struct trap_object),
2661              time (NULL), IFSTATECHANGE);
2662 }
2663
2664 void
2665 ospfTrapVirtIfStateChange (struct ospf_interface *oi)
2666 {
2667   oid index[sizeof (oid) * (IN_ADDR_SIZE + 1)];
2668
2669   zlog (NULL, LOG_INFO, "ospfTrapVirtIfStateChange trap sent");
2670
2671   oid_copy_addr (index, &(oi->address->u.prefix4), IN_ADDR_SIZE);
2672   index[IN_ADDR_SIZE] = 0;
2673
2674   smux_trap (ospf_oid, sizeof ospf_oid / sizeof (oid),
2675              index, IN_ADDR_SIZE + 1,
2676              ospfVirtIfTrapList,
2677              sizeof ospfVirtIfTrapList / sizeof (struct trap_object),
2678              time (NULL), VIRTIFSTATECHANGE);
2679 }
2680 /* Register OSPF2-MIB. */
2681 void
2682 ospf_snmp_init ()
2683 {
2684   ospf_snmp_iflist = list_new ();
2685   ospf_snmp_vl_table = route_table_init ();
2686   smux_init (om->master);
2687   REGISTER_MIB("mibII/ospf", ospf_variables, variable, ospf_oid);
2688 }
2689 #endif /* HAVE_SNMP */