proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-08-09 14:50:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ldpd: Add support for the read-only snmp mib objects that are statistics

Browse Source 
Add support for the read-only snmp mib objects as described in RFC 3815
that are statistics.

Signed-off-by: Lynne Morrison <lynne@voltanet.io>
Signed-off-by: Karen Schoener <karen@voltanet.io>
This commit is contained in:
Karen Schoener 2021-03-15 13:44:12 -04:00
parent 81ef5048dd
commit d4d6e7d87e
4 changed files with 261 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

157
ldpd/ldp_snmp.c
View File

@ -374,6 +374,76 @@ static uint8_t *ldpEntityTable(struct variable *v, oid name[], size_t *length,
return NULL; return NULL;
} }
static uint8_t *ldpEntityStatsTable(struct variable *v, oid name[],
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
{
struct in_addr entityLdpId = {.s_addr = 0};
int len;
*write_method = NULL;
if (smux_header_table(v, name, length, exact, var_len, write_method)
== MATCH_FAILED)
return NULL;
if (exact) {
if (*length != LDP_ENTITY_TOTAL_LEN)
return NULL;
} else {
len = *length - v->namelen - LDP_ENTITY_MAX_IDX_LEN;
if (len > 0)
return NULL;
entityLdpId.s_addr = ldp_rtr_id_get(leconf);
/* Copy the name out */
memcpy(name, v->name, v->namelen * sizeof(oid));
/* Append index */
*length = LDP_ENTITY_TOTAL_LEN;
oid_copy_addr(name + v->namelen, &entityLdpId,
IN_ADDR_SIZE);
name[v->namelen + 4] = 0;
name[v->namelen + 5] = 0;
name[v->namelen + 6] = LDP_DEFAULT_ENTITY_INDEX;
}
/* Return the current value of the variable */
switch (v->magic) {
case MPLSLDPENTITYSTATSSESSIONATTEMPTS:
return SNMP_INTEGER(leconf->stats.session_attempts);
case MPLSLDPENTITYSTATSSESSIONREJHELLO:
return SNMP_INTEGER(leconf->stats.session_rejects_hello);
case MPLSLDPENTITYSTATSSESSIONREJAD:
return SNMP_INTEGER(leconf->stats.session_rejects_ad);
case MPLSLDPENTITYSTATSSESSIONREJMAXPDU:
return SNMP_INTEGER(leconf->stats.session_rejects_max_pdu);
case MPLSLDPENTITYSTATSSESSIONREJLR:
return SNMP_INTEGER(leconf->stats.session_rejects_lr);
case MPLSLDPENTITYSTATSBADLDPID:
return SNMP_INTEGER(leconf->stats.bad_ldp_id);
case MPLSLDPENTITYSTATSBADPDULENGTH:
return SNMP_INTEGER(leconf->stats.bad_pdu_len);
case MPLSLDPENTITYSTATSBADMSGLENGTH:
return SNMP_INTEGER(leconf->stats.bad_msg_len);
case MPLSLDPENTITYSTATSBADTLVLENGTH:
return SNMP_INTEGER(leconf->stats.bad_tlv_len);
case MPLSLDPENTITYSTATSMALFORMEDTLV:
return SNMP_INTEGER(leconf->stats.malformed_tlv);
case MPLSLDPENTITYSTATSKEEPALIVEEXP:
return SNMP_INTEGER(leconf->stats.keepalive_timer_exp);
case MPLSLDPENTITYSTATSSHUTDOWNRCVNOTIFY:
return SNMP_INTEGER(leconf->stats.shutdown_rcv_notify);
case MPLSLDPENTITYSTATSSHUTDOWNSENTNOTIFY:
return SNMP_INTEGER(leconf->stats.shutdown_send_notify);
default:
return NULL;
}
return NULL;
}
#define LDP_ADJACENCY_ENTRY_MAX_IDX_LEN 14 #define LDP_ADJACENCY_ENTRY_MAX_IDX_LEN 14
static void ldpHelloAdjacencyTable_oid_to_index( static void ldpHelloAdjacencyTable_oid_to_index(
@ -863,6 +933,59 @@ static uint8_t *ldpSessionTable(struct variable *v, oid name[], size_t *length,
return NULL; return NULL;
} }
static uint8_t *ldpSessionStatsTable(struct variable *v, oid name[],
size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
{
struct in_addr entityLdpId = {.s_addr = 0};
uint32_t entityIndex = 0;
struct in_addr peerLdpId = {.s_addr = 0};
if (smux_header_table(v, name, length, exact, var_len, write_method)
== MATCH_FAILED)
return NULL;
struct ctl_nbr *ctl_nbr = ldpPeerTable_lookup(v, name, length, exact,
&entityLdpId, &entityIndex, &peerLdpId);
if (!ctl_nbr)
return NULL;
if (!exact) {
entityLdpId.s_addr = ldp_rtr_id_get(leconf);
entityIndex = LDP_DEFAULT_ENTITY_INDEX;
peerLdpId = ctl_nbr->id;
/* Copy the name out */
memcpy(name, v->name, v->namelen * sizeof(oid));
/* Append index */
oid_copy_addr(name + v->namelen, &entityLdpId,
sizeof(struct in_addr));
name[v->namelen + 4] = 0;
name[v->namelen + 5] = 0;
name[v->namelen + 6] = entityIndex;
oid_copy_addr(name + v->namelen + 7, &peerLdpId,
sizeof(struct in_addr));
name[v->namelen + 11] = 0;
name[v->namelen + 12] = 0;
*length = v->namelen + LDP_PEER_ENTRY_MAX_IDX_LEN;
}
switch (v->magic) {
case MPLSLDPSESSIONSTATSUNKNOWNMESTYPEERRORS:
return SNMP_INTEGER(ctl_nbr->stats.unknown_msg);
case MPLSLDPSESSIONSTATSUNKNOWNTLVERRORS:
return SNMP_INTEGER(ctl_nbr->stats.unknown_tlv);
default:
return NULL;
}
return NULL;
}
static struct variable ldpe_variables[] = { static struct variable ldpe_variables[] = {
{MPLS_LDP_LSR_ID, STRING, RONLY, ldpLsrId, 3, {1, 1, 1}}, {MPLS_LDP_LSR_ID, STRING, RONLY, ldpLsrId, 3, {1, 1, 1}},
{MPLS_LDP_LSR_LOOP_DETECTION_CAPABLE, INTEGER, RONLY, {MPLS_LDP_LSR_LOOP_DETECTION_CAPABLE, INTEGER, RONLY,
@ -920,6 +1043,34 @@ static struct variable ldpe_variables[] = {
{MPLSLDPENTITYROWSTATUS, INTEGER, RONLY, ldpEntityTable, {MPLSLDPENTITYROWSTATUS, INTEGER, RONLY, ldpEntityTable,
5, {1, 2, 3, 1, 23}}, 5, {1, 2, 3, 1, 23}},
/* MPLS LDP mplsLdpEntityStatsTable. */
{ MPLSLDPENTITYSTATSSESSIONATTEMPTS, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 1}},
{ MPLSLDPENTITYSTATSSESSIONREJHELLO, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 2}},
{ MPLSLDPENTITYSTATSSESSIONREJAD, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 3}},
{ MPLSLDPENTITYSTATSSESSIONREJMAXPDU, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 4}},
{ MPLSLDPENTITYSTATSSESSIONREJLR, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 5}},
{ MPLSLDPENTITYSTATSBADLDPID, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 6}},
{ MPLSLDPENTITYSTATSBADPDULENGTH, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 7}},
{ MPLSLDPENTITYSTATSBADMSGLENGTH, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 8}},
{ MPLSLDPENTITYSTATSBADTLVLENGTH, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 9}},
{ MPLSLDPENTITYSTATSMALFORMEDTLV, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 10}},
{ MPLSLDPENTITYSTATSKEEPALIVEEXP, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 11}},
{ MPLSLDPENTITYSTATSSHUTDOWNRCVNOTIFY, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 12}},
{ MPLSLDPENTITYSTATSSHUTDOWNSENTNOTIFY, COUNTER32, RONLY,
ldpEntityStatsTable, 5, {1, 2, 4, 1, 13}},
/* MPLS LDP mplsLdpPeerTable */ /* MPLS LDP mplsLdpPeerTable */
{MPLSLDPPEERLDPID, STRING, RONLY, ldpPeerTable, 5, {1, 3, 2, 1, 1}}, {MPLSLDPPEERLDPID, STRING, RONLY, ldpPeerTable, 5, {1, 3, 2, 1, 1}},
{MPLSLDPPEERLABELDISTMETHOD, INTEGER, RONLY, ldpPeerTable, {MPLSLDPPEERLABELDISTMETHOD, INTEGER, RONLY, ldpPeerTable,
@ -949,6 +1100,12 @@ static struct variable ldpe_variables[] = {
{MPLSLDPSESSIONDISCONTINUITYTIME, TIMESTAMP, RONLY, ldpSessionTable, {MPLSLDPSESSIONDISCONTINUITYTIME, TIMESTAMP, RONLY, ldpSessionTable,
5, {1, 3, 3, 1, 8}}, 5, {1, 3, 3, 1, 8}},
/* MPLS LDP mplsLdpSessionStatsTable */
{MPLSLDPSESSIONSTATSUNKNOWNMESTYPEERRORS, COUNTER32, RONLY,
ldpSessionStatsTable, 5, {1, 3, 4, 1, 1}},
{MPLSLDPSESSIONSTATSUNKNOWNTLVERRORS, COUNTER32, RONLY,
ldpSessionStatsTable, 5, {1, 3, 4, 1, 2}},
/* MPLS LDP mplsLdpHelloAdjacencyTable. */ /* MPLS LDP mplsLdpHelloAdjacencyTable. */
{MPLSLDPHELLOADJACENCYINDEX, UNSIGNED32, RONLY, {MPLSLDPHELLOADJACENCYINDEX, UNSIGNED32, RONLY,
ldpHelloAdjacencyTable, 6, {1, 3, 5, 1, 1, 1}}, ldpHelloAdjacencyTable, 6, {1, 3, 5, 1, 1, 1}},

19
ldpd/ldpd.h
View File

@ -435,9 +435,27 @@ struct ldp_stats {
uint32_t labelrel_rcvd; uint32_t labelrel_rcvd;
uint32_t labelabreq_sent; uint32_t labelabreq_sent;
uint32_t labelabreq_rcvd; uint32_t labelabreq_rcvd;
uint32_t unknown_tlv;
uint32_t unknown_msg;
}; };
struct ldp_entity_stats {
uint32_t session_attempts;
uint32_t session_rejects_hello;
uint32_t session_rejects_ad;
uint32_t session_rejects_max_pdu;
uint32_t session_rejects_lr;
uint32_t bad_ldp_id;
uint32_t bad_pdu_len;
uint32_t bad_msg_len;
uint32_t bad_tlv_len;
uint32_t malformed_tlv;
uint32_t keepalive_timer_exp;
uint32_t shutdown_rcv_notify;
uint32_t shutdown_send_notify;
};
struct l2vpn_if { struct l2vpn_if {
RB_ENTRY(l2vpn_if) entry; RB_ENTRY(l2vpn_if) entry;
struct l2vpn *l2vpn; struct l2vpn *l2vpn;
@ -565,6 +583,7 @@ struct ldpd_conf {
uint16_t wait_for_sync_interval; uint16_t wait_for_sync_interval;
int flags; int flags;
time_t config_change_time; time_t config_change_time;
struct ldp_entity_stats stats;
QOBJ_FIELDS QOBJ_FIELDS
}; };
DECLARE_QOBJ_TYPE(ldpd_conf) DECLARE_QOBJ_TYPE(ldpd_conf)

79
ldpd/notification.c
View File

@ -69,6 +69,36 @@ send_notification_full(struct tcp_conn *tcp, struct notify_msg *nm)
tcp->nbr->stats.notif_sent++; tcp->nbr->stats.notif_sent++;
} }
/* update SNMP session counters */
switch (nm->status_code) {
case S_NO_HELLO:
leconf->stats.session_rejects_hello++;
break;
case S_BAD_LDP_ID:
leconf->stats.bad_ldp_id++;
break;
case S_BAD_PDU_LEN:
leconf->stats.bad_pdu_len++;
break;
case S_BAD_MSG_LEN:
leconf->stats.bad_msg_len++;
break;
case S_BAD_TLV_LEN:
leconf->stats.bad_tlv_len++;
break;
case S_BAD_TLV_VAL:
leconf->stats.malformed_tlv++;
break;
case S_KEEPALIVE_TMR:
leconf->stats.keepalive_timer_exp++;
break;
case S_SHUTDOWN:
leconf->stats.shutdown_send_notify++;
break;
default:
break;
}
evbuf_enqueue(&tcp->wbuf, buf); evbuf_enqueue(&tcp->wbuf, buf);
} }
@ -122,6 +152,7 @@ recv_notification(struct nbr *nbr, char *buf, uint16_t len)
if (len < STATUS_SIZE) { if (len < STATUS_SIZE) {
session_shutdown(nbr, S_BAD_MSG_LEN, msg.id, msg.type); session_shutdown(nbr, S_BAD_MSG_LEN, msg.id, msg.type);
leconf->stats.bad_msg_len++;
return (-1); return (-1);
} }
memcpy(&st, buf, sizeof(st)); memcpy(&st, buf, sizeof(st));
@ -129,6 +160,7 @@ recv_notification(struct nbr *nbr, char *buf, uint16_t len)
if (ntohs(st.length) > STATUS_SIZE - TLV_HDR_SIZE || if (ntohs(st.length) > STATUS_SIZE - TLV_HDR_SIZE ||
ntohs(st.length) > len - TLV_HDR_SIZE) { ntohs(st.length) > len - TLV_HDR_SIZE) {
session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type); session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
leconf->stats.bad_tlv_len++;
return (-1); return (-1);
} }
buf += STATUS_SIZE; buf += STATUS_SIZE;
@ -145,6 +177,7 @@ recv_notification(struct nbr *nbr, char *buf, uint16_t len)
if (len < sizeof(tlv)) { if (len < sizeof(tlv)) {
session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type); session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
leconf->stats.bad_tlv_len++;
return (-1); return (-1);
} }
@ -153,6 +186,7 @@ recv_notification(struct nbr *nbr, char *buf, uint16_t len)
tlv_len = ntohs(tlv.length); tlv_len = ntohs(tlv.length);
if (tlv_len + TLV_HDR_SIZE > len) { if (tlv_len + TLV_HDR_SIZE > len) {
session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type); session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
leconf->stats.bad_tlv_len++;
return (-1); return (-1);
} }
buf += TLV_HDR_SIZE; buf += TLV_HDR_SIZE;
@ -182,14 +216,17 @@ recv_notification(struct nbr *nbr, char *buf, uint16_t len)
if (tlen != tlv_len) { if (tlen != tlv_len) {
session_shutdown(nbr, S_BAD_TLV_VAL, session_shutdown(nbr, S_BAD_TLV_VAL,
msg.id, msg.type); msg.id, msg.type);
leconf->stats.bad_tlv_len++;
return (-1); return (-1);
} }
nm.flags |= F_NOTIF_FEC; nm.flags |= F_NOTIF_FEC;
break; break;
default: default:
if (!(ntohs(tlv.type) & UNKNOWN_FLAG)) if (!(ntohs(tlv.type) & UNKNOWN_FLAG)) {
nbr->stats.unknown_tlv++;
send_notification_rtlvs(nbr, S_UNKNOWN_TLV, send_notification_rtlvs(nbr, S_UNKNOWN_TLV,
msg.id, msg.type, tlv_type, tlv_len, buf); msg.id, msg.type, tlv_type, tlv_len, buf);
}
/* ignore unknown tlv */ /* ignore unknown tlv */
break; break;
} }
@ -243,21 +280,57 @@ recv_notification(struct nbr *nbr, char *buf, uint16_t len)
* initialization, it SHOULD transmit a Shutdown message and * initialization, it SHOULD transmit a Shutdown message and
* then close the transport connection". * then close the transport connection".
*/ */
if (nbr->state != NBR_STA_OPER && nm.status_code == S_SHUTDOWN) if (nbr->state != NBR_STA_OPER &&
nm.status_code == S_SHUTDOWN) {
leconf->stats.session_attempts++;
send_notification(nbr->tcp, S_SHUTDOWN, send_notification(nbr->tcp, S_SHUTDOWN,
msg.id, msg.type); msg.id, msg.type);
}
leconf->stats.shutdown_rcv_notify++;
nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION); nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
return (-1); return (-1);
} }
/* lde needs to know about a few notification messages */ /* lde needs to know about a few notification messages
* and update SNMP session counters
*/
switch (nm.status_code) { switch (nm.status_code) {
case S_PW_STATUS: case S_PW_STATUS:
case S_ENDOFLIB: case S_ENDOFLIB:
ldpe_imsg_compose_lde(IMSG_NOTIFICATION, nbr->peerid, 0, ldpe_imsg_compose_lde(IMSG_NOTIFICATION, nbr->peerid, 0,
&nm, sizeof(nm)); &nm, sizeof(nm));
break; break;
case S_NO_HELLO:
leconf->stats.session_rejects_hello++;
break;
case S_PARM_ADV_MODE:
leconf->stats.session_rejects_ad++;
break;
case S_MAX_PDU_LEN:
leconf->stats.session_rejects_max_pdu++;
break;
case S_PARM_L_RANGE:
leconf->stats.session_rejects_lr++;
break;
case S_BAD_LDP_ID:
leconf->stats.bad_ldp_id++;
break;
case S_BAD_PDU_LEN:
leconf->stats.bad_pdu_len++;
break;
case S_BAD_MSG_LEN:
leconf->stats.bad_msg_len++;
break;
case S_BAD_TLV_LEN:
leconf->stats.bad_tlv_len++;
break;
case S_BAD_TLV_VAL:
leconf->stats.malformed_tlv++;
break;
case S_SHUTDOWN:
leconf->stats.shutdown_rcv_notify++;
break;
default: default:
break; break;
} }

10
ldpd/packet.c
View File

@ -560,9 +560,11 @@ session_read(struct thread *thread)
default: default:
log_debug("%s: unknown LDP message from nbr %pI4", log_debug("%s: unknown LDP message from nbr %pI4",
__func__, &nbr->id); __func__, &nbr->id);
if (!(ntohs(msg->type) & UNKNOWN_FLAG)) if (!(ntohs(msg->type) & UNKNOWN_FLAG)) {
nbr->stats.unknown_msg++;
send_notification(nbr->tcp, send_notification(nbr->tcp,
S_UNKNOWN_MSG, msg->id, msg->type); S_UNKNOWN_MSG, msg->id, msg->type);
}
/* ignore the message */ /* ignore the message */
ret = 0; ret = 0;
break; break;
@ -667,6 +669,12 @@ session_shutdown(struct nbr *nbr, uint32_t status, uint32_t msg_id,
case NBR_STA_INITIAL: case NBR_STA_INITIAL:
case NBR_STA_OPENREC: case NBR_STA_OPENREC:
case NBR_STA_OPENSENT: case NBR_STA_OPENSENT:
/* update SNMP session counters during initialization */
leconf->stats.session_attempts++;
send_notification(nbr->tcp, status, msg_id, msg_type);
nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
break;
case NBR_STA_OPER: case NBR_STA_OPER:
send_notification(nbr->tcp, status, msg_id, msg_type); send_notification(nbr->tcp, status, msg_id, msg_type);