Mirror/frr
0
0
Fork 1
mirror of https://github.com/FRRouting/frr.git synced 2025-04-30 13:37:17 +02:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

*: use C99 standard fixed-width integer types

Browse source 
The following types are nonstandard:
- u_char
- u_short
- u_int
- u_long
- u_int8_t
- u_int16_t
- u_int32_t

Replace them with the C99 standard types:
- uint8_t
- unsigned short
- unsigned int
- unsigned long
- uint8_t
- uint16_t
- uint32_t

Signed-off-by: Quentin Young <qlyoung@cumulusnetworks.com>
This commit is contained in:
Quentin Young 2018-03-27 15:13:34 -04:00
parent 28ac5a0381
commit d7c0a89a3a
No known key found for this signature in database
GPG key ID: DAF48E0F57E0834F
361 changed files with 4672 additions and 4624 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
babeld/kernel.c
View file

@ -210,7 +210,7 @@ if_eui64(int ifindex, unsigned char *eui)
return -1;
}
u_char len = (u_char) ifp->hw_addr_len;
uint8_t len = (uint8_t)ifp->hw_addr_len;
char *tmp = (void*) ifp->hw_addr;
if (len == 8) {

6
bgpd/bgp_advertise.c
View file

@ -146,7 +146,7 @@ void bgp_advertise_unintern(struct hash *hash, struct bgp_advertise_attr *baa)
}
int bgp_adj_out_lookup(struct peer *peer, struct bgp_node *rn,
u_int32_t addpath_tx_id)
uint32_t addpath_tx_id)
{
struct bgp_adj_out *adj;
struct peer_af *paf;
@ -179,7 +179,7 @@ int bgp_adj_out_lookup(struct peer *peer, struct bgp_node *rn,
void bgp_adj_in_set(struct bgp_node *rn, struct peer *peer, struct attr *attr,
u_int32_t addpath_id)
uint32_t addpath_id)
{
struct bgp_adj_in *adj;
@ -209,7 +209,7 @@ void bgp_adj_in_remove(struct bgp_node *rn, struct bgp_adj_in *bai)
}
int bgp_adj_in_unset(struct bgp_node *rn, struct peer *peer,
u_int32_t addpath_id)
uint32_t addpath_id)
{
struct bgp_adj_in *adj;
struct bgp_adj_in *adj_next;

12
bgpd/bgp_advertise.h
View file

@ -29,7 +29,7 @@ struct update_subgroup;
struct bgp_advertise_fifo {
struct bgp_advertise *next;
struct bgp_advertise *prev;
u_int32_t count;
uint32_t count;
};
/* BGP advertise attribute. */
@ -80,7 +80,7 @@ struct bgp_adj_out {
/* Prefix information. */
struct bgp_node *rn;
u_int32_t addpath_tx_id;
uint32_t addpath_tx_id;
/* Advertised attribute. */
struct attr *attr;
@ -102,7 +102,7 @@ struct bgp_adj_in {
struct attr *attr;
/* Addpath identifier */
u_int32_t addpath_rx_id;
uint32_t addpath_rx_id;
};
/* BGP advertisement list. */
@ -168,10 +168,10 @@ struct bgp_synchronize {
: (F)->next)
/* Prototypes. */
extern int bgp_adj_out_lookup(struct peer *, struct bgp_node *, u_int32_t);
extern int bgp_adj_out_lookup(struct peer *, struct bgp_node *, uint32_t);
extern void bgp_adj_in_set(struct bgp_node *, struct peer *, struct attr *,
u_int32_t);
extern int bgp_adj_in_unset(struct bgp_node *, struct peer *, u_int32_t);
uint32_t);
extern int bgp_adj_in_unset(struct bgp_node *, struct peer *, uint32_t);
extern void bgp_adj_in_remove(struct bgp_node *, struct bgp_adj_in *);
extern void bgp_sync_init(struct peer *);

20
bgpd/bgp_aspath.c
View file

@ -80,8 +80,8 @@
* NOT the internal representation!
*/
struct assegment_header {
u_char type;
u_char length;
uint8_t type;
uint8_t length;
};
/* Hash for aspath. This is the top level structure of AS path. */
@ -109,7 +109,7 @@ const char *aspath_segment_type_str[] = {"as-invalid", "as-set", "as-sequence",
* the caller should immediately assign data to the segment, as the segment
* otherwise is not generally valid
*/
static struct assegment *assegment_new(u_char type, u_short length)
static struct assegment *assegment_new(uint8_t type, unsigned short length)
{
struct assegment *new;
@ -345,7 +345,7 @@ void aspath_unintern(struct aspath **aspath)
/* Return the start or end delimiters for a particular Segment type */
#define AS_SEG_START 0
#define AS_SEG_END 1
static char aspath_delimiter_char(u_char type, u_char which)
static char aspath_delimiter_char(uint8_t type, uint8_t which)
{
int i;
struct {
@ -864,7 +864,7 @@ static void assegment_data_put(struct stream *s, as_t *as, int num,
}
}
static size_t assegment_header_put(struct stream *s, u_char type, int length)
static size_t assegment_header_put(struct stream *s, uint8_t type, int length)
{
size_t lenp;
assert(length <= AS_SEGMENT_MAX);
@ -962,7 +962,7 @@ size_t aspath_put(struct stream *s, struct aspath *as, int use32bit)
* We have no way to manage the storage, so we use a static stream
* wrapper around aspath_put.
*/
u_char *aspath_snmp_pathseg(struct aspath *as, size_t *varlen)
uint8_t *aspath_snmp_pathseg(struct aspath *as, size_t *varlen)
{
#define SNMP_PATHSEG_MAX 1024
@ -1541,7 +1541,7 @@ struct aspath *aspath_filter_exclude(struct aspath *source,
/* Add specified AS to the leftmost of aspath. */
static struct aspath *aspath_add_asns(struct aspath *aspath, as_t asno,
u_char type, unsigned num)
uint8_t type, unsigned num)
{
struct assegment *assegment = aspath->segments;
unsigned i;
@ -1872,7 +1872,7 @@ enum as_token {
/* Return next token and point for string parse. */
static const char *aspath_gettoken(const char *buf, enum as_token *token,
u_long *asno)
unsigned long *asno)
{
const char *p = buf;
@ -1937,8 +1937,8 @@ static const char *aspath_gettoken(const char *buf, enum as_token *token,
struct aspath *aspath_str2aspath(const char *str)
{
enum as_token token = as_token_unknown;
u_short as_type;
u_long asno = 0;
unsigned short as_type;
unsigned long asno = 0;
struct aspath *aspath;
int needtype;

6
bgpd/bgp_aspath.h
View file

@ -51,8 +51,8 @@
struct assegment {
struct assegment *next;
as_t *as;
u_short length;
u_char type;
unsigned short length;
uint8_t type;
};
/* AS path may be include some AsSegments. */
@ -127,6 +127,6 @@ extern struct aspath *aspath_reconcile_as4(struct aspath *, struct aspath *);
extern unsigned int aspath_has_as4(struct aspath *);
/* For SNMP BGP4PATHATTRASPATHSEGMENT, might be useful for debug */
extern u_char *aspath_snmp_pathseg(struct aspath *, size_t *);
extern uint8_t *aspath_snmp_pathseg(struct aspath *, size_t *);
#endif /* _QUAGGA_BGP_ASPATH_H */

143
bgpd/bgp_attr.c
View file

@ -693,7 +693,7 @@ struct attr *bgp_attr_intern(struct attr *attr)
}
/* Make network statement's attribute. */
struct attr *bgp_attr_default_set(struct attr *attr, u_char origin)
struct attr *bgp_attr_default_set(struct attr *attr, uint8_t origin)
{
memset(attr, 0, sizeof(struct attr));
@ -712,10 +712,10 @@ struct attr *bgp_attr_default_set(struct attr *attr, u_char origin)
}
/* Create the attributes for an aggregate */
struct attr *bgp_attr_aggregate_intern(struct bgp *bgp, u_char origin,
struct attr *bgp_attr_aggregate_intern(struct bgp *bgp, uint8_t origin,
struct aspath *aspath,
struct community *community, int as_set,
u_char atomic_aggregate)
uint8_t atomic_aggregate)
{
struct attr attr;
struct attr *new;
@ -737,7 +737,7 @@ struct attr *bgp_attr_aggregate_intern(struct bgp *bgp, u_char origin,
attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP);
if (community) {
u_int32_t gshut = COMMUNITY_GSHUT;
uint32_t gshut = COMMUNITY_GSHUT;
/* If we are not shutting down ourselves and we are
* aggregating a route that contains the GSHUT community we
@ -901,16 +901,16 @@ void bgp_attr_flush(struct attr *attr)
* introduced by the sending neighbour.
*/
static bgp_attr_parse_ret_t
bgp_attr_malformed(struct bgp_attr_parser_args *args, u_char subcode,
bgp_attr_malformed(struct bgp_attr_parser_args *args, uint8_t subcode,
bgp_size_t length)
{
struct peer *const peer = args->peer;
const u_int8_t flags = args->flags;
const uint8_t flags = args->flags;
/* startp and length must be special-cased, as whether or not to
* send the attribute data with the NOTIFY depends on the error,
* the caller therefore signals this with the seperate length argument
*/
u_char *notify_datap = (length > 0 ? args->startp : NULL);
uint8_t *notify_datap = (length > 0 ? args->startp : NULL);
/* Only relax error handling for eBGP peers */
if (peer->sort != BGP_PEER_EBGP) {
@ -976,12 +976,12 @@ bgp_attr_malformed(struct bgp_attr_parser_args *args, u_char subcode,
non-transitive" attribute. */
static void
bgp_attr_flags_diagnose(struct bgp_attr_parser_args *args,
u_int8_t desired_flags /* how RFC says it must be */
)
uint8_t desired_flags /* how RFC says it must be */
)
{
u_char seen = 0, i;
u_char real_flags = args->flags;
const u_int8_t attr_code = args->type;
uint8_t seen = 0, i;
uint8_t real_flags = args->flags;
const uint8_t attr_code = args->type;
desired_flags &= ~BGP_ATTR_FLAG_EXTLEN;
real_flags &= ~BGP_ATTR_FLAG_EXTLEN;
@ -1008,41 +1008,36 @@ bgp_attr_flags_diagnose(struct bgp_attr_parser_args *args,
/* Required flags for attributes. EXTLEN will be masked off when testing,
* as will PARTIAL for optional+transitive attributes.
*/
const u_int8_t attr_flags_values[] = {
[BGP_ATTR_ORIGIN] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AS_PATH] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_NEXT_HOP] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_MULTI_EXIT_DISC] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_LOCAL_PREF] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_ATOMIC_AGGREGATE] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AGGREGATOR] =
BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_COMMUNITIES] =
BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_ORIGINATOR_ID] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_CLUSTER_LIST] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_MP_REACH_NLRI] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_MP_UNREACH_NLRI] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_EXT_COMMUNITIES] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AS4_PATH] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AS4_AGGREGATOR] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_PMSI_TUNNEL] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_LARGE_COMMUNITIES] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_PREFIX_SID] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
const uint8_t attr_flags_values[] = {
[BGP_ATTR_ORIGIN] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AS_PATH] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_NEXT_HOP] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_MULTI_EXIT_DISC] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_LOCAL_PREF] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_ATOMIC_AGGREGATE] = BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AGGREGATOR] = BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_COMMUNITIES] = BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_ORIGINATOR_ID] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_CLUSTER_LIST] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_MP_REACH_NLRI] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_MP_UNREACH_NLRI] = BGP_ATTR_FLAG_OPTIONAL,
[BGP_ATTR_EXT_COMMUNITIES] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AS4_PATH] = BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_AS4_AGGREGATOR] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_PMSI_TUNNEL] = BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_LARGE_COMMUNITIES] =
BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
[BGP_ATTR_PREFIX_SID] = BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
};
static const size_t attr_flags_values_max = array_size(attr_flags_values) - 1;
static int bgp_attr_flag_invalid(struct bgp_attr_parser_args *args)
{
u_int8_t mask = BGP_ATTR_FLAG_EXTLEN;
const u_int8_t flags = args->flags;
const u_int8_t attr_code = args->type;
uint8_t mask = BGP_ATTR_FLAG_EXTLEN;
const uint8_t flags = args->flags;
const uint8_t attr_code = args->type;
/* there may be attributes we don't know about */
if (attr_code > attr_flags_values_max)
@ -1531,7 +1526,7 @@ bgp_attr_community(struct bgp_attr_parser_args *args)
}
attr->community =
community_parse((u_int32_t *)stream_pnt(peer->curr), length);
community_parse((uint32_t *)stream_pnt(peer->curr), length);
/* XXX: fix community_parse to use stream API and remove this */
stream_forward_getp(peer->curr, length);
@ -1723,7 +1718,7 @@ int bgp_mp_reach_parse(struct bgp_attr_parser_args *args,
}
{
u_char val;
uint8_t val;
if ((val = stream_getc(s)))
zlog_warn(
"%s sent non-zero value, %u, for defunct SNPA-length field",
@ -1768,7 +1763,7 @@ int bgp_mp_unreach_parse(struct bgp_attr_parser_args *args,
afi_t afi;
iana_safi_t pkt_safi;
safi_t safi;
u_int16_t withdraw_len;
uint16_t withdraw_len;
struct peer *const peer = args->peer;
struct attr *const attr = args->attr;
const bgp_size_t length = args->length;
@ -1827,7 +1822,7 @@ bgp_attr_large_community(struct bgp_attr_parser_args *args)
}
attr->lcommunity =
lcommunity_parse((u_int8_t *)stream_pnt(peer->curr), length);
lcommunity_parse((uint8_t *)stream_pnt(peer->curr), length);
/* XXX: fix ecommunity_parse to use stream API */
stream_forward_getp(peer->curr, length);
@ -1847,7 +1842,7 @@ bgp_attr_ext_communities(struct bgp_attr_parser_args *args)
struct peer *const peer = args->peer;
struct attr *const attr = args->attr;
const bgp_size_t length = args->length;
u_char sticky = 0;
uint8_t sticky = 0;
if (length == 0) {
attr->ecommunity = NULL;
@ -1856,7 +1851,7 @@ bgp_attr_ext_communities(struct bgp_attr_parser_args *args)
}
attr->ecommunity =
ecommunity_parse((u_int8_t *)stream_pnt(peer->curr), length);
ecommunity_parse((uint8_t *)stream_pnt(peer->curr), length);
/* XXX: fix ecommunity_parse to use stream API */
stream_forward_getp(peer->curr, length);
@ -1883,8 +1878,8 @@ bgp_attr_ext_communities(struct bgp_attr_parser_args *args)
static int bgp_attr_encap(uint8_t type, struct peer *peer, /* IN */
bgp_size_t length, /* IN: attr's length field */
struct attr *attr, /* IN: caller already allocated */
u_char flag, /* IN: attr's flags field */
u_char *startp)
uint8_t flag, /* IN: attr's flags field */
uint8_t *startp)
{
bgp_size_t total;
uint16_t tunneltype = 0;
@ -2017,10 +2012,10 @@ bgp_attr_prefix_sid(struct bgp_attr_parser_args *args,
struct attr *const attr = args->attr;
int type;
int length;
u_int32_t label_index;
uint32_t label_index;
struct in6_addr ipv6_sid;
u_int32_t srgb_base;
u_int32_t srgb_range;
uint32_t srgb_base;
uint32_t srgb_range;
int srgb_count;
attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID);
@ -2116,7 +2111,7 @@ bgp_attr_pmsi_tunnel(struct bgp_attr_parser_args *args)
struct peer *const peer = args->peer;
struct attr *const attr = args->attr;
const bgp_size_t length = args->length;
u_int8_t tnl_type;
uint8_t tnl_type;
/* Verify that the receiver is expecting "ingress replication" as we
* can only support that.
@ -2159,9 +2154,9 @@ static bgp_attr_parse_ret_t bgp_attr_unknown(struct bgp_attr_parser_args *args)
struct transit *transit;
struct peer *const peer = args->peer;
struct attr *const attr = args->attr;
u_char *const startp = args->startp;
const u_char type = args->type;
const u_char flag = args->flags;
uint8_t *const startp = args->startp;
const uint8_t type = args->type;
const uint8_t flag = args->flags;
const bgp_size_t length = args->length;
if (bgp_debug_update(peer, NULL, NULL, 1))
@ -2213,7 +2208,7 @@ static bgp_attr_parse_ret_t bgp_attr_unknown(struct bgp_attr_parser_args *args)
/* Well-known attribute check. */
static int bgp_attr_check(struct peer *peer, struct attr *attr)
{
u_char type = 0;
uint8_t type = 0;
/* BGP Graceful-Restart End-of-RIB for IPv4 unicast is signaled as an
* empty UPDATE. */
@ -2264,12 +2259,12 @@ bgp_attr_parse_ret_t bgp_attr_parse(struct peer *peer, struct attr *attr,
struct bgp_nlri *mp_withdraw)
{
int ret;
u_char flag = 0;
u_char type = 0;
uint8_t flag = 0;
uint8_t type = 0;
bgp_size_t length;
u_char *startp, *endp;
u_char *attr_endp;
u_char seen[BGP_ATTR_BITMAP_SIZE];
uint8_t *startp, *endp;
uint8_t *attr_endp;
uint8_t seen[BGP_ATTR_BITMAP_SIZE];
/* we need the as4_path only until we have synthesized the as_path with
* it */
/* same goes for as4_aggregator */
@ -2742,8 +2737,8 @@ size_t bgp_packet_mpattr_start(struct stream *s, struct peer *peer, afi_t afi,
void bgp_packet_mpattr_prefix(struct stream *s, afi_t afi, safi_t safi,
struct prefix *p, struct prefix_rd *prd,
mpls_label_t *label, u_int32_t num_labels,
int addpath_encode, u_int32_t addpath_tx_id,
mpls_label_t *label, uint32_t num_labels,
int addpath_encode, uint32_t addpath_tx_id,
struct attr *attr)
{
if (safi == SAFI_MPLS_VPN) {
@ -2886,8 +2881,8 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer,
struct bpacket_attr_vec_arr *vecarr,
struct prefix *p, afi_t afi, safi_t safi,
struct peer *from, struct prefix_rd *prd,
mpls_label_t *label, u_int32_t num_labels,
int addpath_encode, u_int32_t addpath_tx_id)
mpls_label_t *label, uint32_t num_labels,
int addpath_encode, uint32_t addpath_tx_id)
{
size_t cp;
size_t aspath_sizep;
@ -3072,7 +3067,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer,
*/
send_as4_aggregator = 1;
} else
stream_putw(s, (u_int16_t)attr->aggregator_as);
stream_putw(s, (uint16_t)attr->aggregator_as);
}
stream_put_ipv4(s, attr->aggregator_addr.s_addr);
}
@ -3179,7 +3174,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer,
stream_put(s, attr->ecommunity->val,
attr->ecommunity->size * 8);
} else {
u_int8_t *pnt;
uint8_t *pnt;
int tbit;
int ecom_tr_size = 0;
int i;
@ -3233,7 +3228,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer,
/* Label index attribute. */
if (safi == SAFI_LABELED_UNICAST) {
if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID)) {
u_int32_t label_index;
uint32_t label_index;
label_index = attr->label_index;
@ -3350,11 +3345,11 @@ size_t bgp_packet_mpunreach_start(struct stream *s, afi_t afi, safi_t safi)
void bgp_packet_mpunreach_prefix(struct stream *s, struct prefix *p, afi_t afi,
safi_t safi, struct prefix_rd *prd,
mpls_label_t *label, u_int32_t num_labels,
int addpath_encode, u_int32_t addpath_tx_id,
mpls_label_t *label, uint32_t num_labels,
int addpath_encode, uint32_t addpath_tx_id,
struct attr *attr)
{
u_char wlabel[3] = {0x80, 0x00, 0x00};
uint8_t wlabel[3] = {0x80, 0x00, 0x00};
if (safi == SAFI_LABELED_UNICAST) {
label = (mpls_label_t *)wlabel;
@ -3404,7 +3399,7 @@ void bgp_dump_routes_attr(struct stream *s, struct attr *attr,
size_t aspath_lenp;
struct aspath *aspath;
int addpath_encode = 0;
u_int32_t addpath_tx_id = 0;
uint32_t addpath_tx_id = 0;
/* Remember current pointer. */
cp = stream_get_endp(s);

54
bgpd/bgp_attr.h
View file

@ -126,19 +126,19 @@ struct attr {
/* Apart from in6_addr, the remaining static attributes */
struct in_addr nexthop;
u_int32_t med;
u_int32_t local_pref;
uint32_t med;
uint32_t local_pref;
ifindex_t nh_ifindex;
/* Path origin attribute */
u_char origin;
uint8_t origin;
/* PMSI tunnel type (RFC 6514). */
enum pta_type pmsi_tnl_type;
/* has the route-map changed any attribute?
Used on the peer outbound side. */
u_int32_t rmap_change_flags;
uint32_t rmap_change_flags;
/* Multi-Protocol Nexthop, AFI IPv6 */
struct in6_addr mp_nexthop_global;
@ -165,28 +165,28 @@ struct attr {
struct in_addr originator_id;
/* Local weight, not actually an attribute */
u_int32_t weight;
uint32_t weight;
/* Aggregator ASN */
as_t aggregator_as;
/* MP Nexthop length */
u_char mp_nexthop_len;
uint8_t mp_nexthop_len;
/* MP Nexthop preference */
u_char mp_nexthop_prefer_global;
uint8_t mp_nexthop_prefer_global;
/* Static MAC for EVPN */
u_char sticky;
uint8_t sticky;
/* Flag for default gateway extended community in EVPN */
u_char default_gw;
uint8_t default_gw;
/* route tag */
route_tag_t tag;
/* Label index */
u_int32_t label_index;
uint32_t label_index;
/* MPLS label */
mpls_label_t label;
@ -201,7 +201,7 @@ struct attr {
struct overlay_index evpn_overlay;
/* EVPN MAC Mobility sequence number, if any. */
u_int32_t mm_seqnum;
uint32_t mm_seqnum;
/* EVPN local router-mac */
struct ethaddr rmac;
@ -227,7 +227,7 @@ struct cluster_list {
struct transit {
unsigned long refcnt;
int length;
u_char *val;
uint8_t *val;
};
/* "(void) 0" will generate a compiler error. this is a safety check to
@ -265,18 +265,17 @@ extern struct attr *bgp_attr_intern(struct attr *attr);
extern void bgp_attr_unintern_sub(struct attr *);
extern void bgp_attr_unintern(struct attr **);
extern void bgp_attr_flush(struct attr *);
extern struct attr *bgp_attr_default_set(struct attr *attr, u_char);
extern struct attr *bgp_attr_aggregate_intern(struct bgp *, u_char,
extern struct attr *bgp_attr_default_set(struct attr *attr, uint8_t);
extern struct attr *bgp_attr_aggregate_intern(struct bgp *, uint8_t,
struct aspath *,
struct community *, int as_set,
u_char);
uint8_t);
extern bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *,
struct stream *, struct attr *,
struct bpacket_attr_vec_arr *vecarr,
struct prefix *, afi_t, safi_t,
struct peer *, struct prefix_rd *,
mpls_label_t *, u_int32_t, int,
u_int32_t);
mpls_label_t *, uint32_t, int, uint32_t);
extern void bgp_dump_routes_attr(struct stream *, struct attr *,
struct prefix *);
extern int attrhash_cmp(const void *, const void *);
@ -298,9 +297,9 @@ struct bgp_attr_parser_args {
bgp_size_t length; /* attribute data length; */
bgp_size_t total; /* total length, inc header */
struct attr *attr;
u_int8_t type;
u_int8_t flags;
u_char *startp;
uint8_t type;
uint8_t flags;
uint8_t *startp;
};
extern int bgp_mp_reach_parse(struct bgp_attr_parser_args *args,
struct bgp_nlri *);
@ -324,9 +323,9 @@ extern size_t bgp_packet_mpattr_start(struct stream *s, struct peer *peer,
struct attr *attr);
extern void bgp_packet_mpattr_prefix(struct stream *s, afi_t afi, safi_t safi,
struct prefix *p, struct prefix_rd *prd,
mpls_label_t *label, u_int32_t num_labels,
int addpath_encode,
u_int32_t addpath_tx_id, struct attr *);
mpls_label_t *label, uint32_t num_labels,
int addpath_encode, uint32_t addpath_tx_id,
struct attr *);
extern size_t bgp_packet_mpattr_prefix_size(afi_t afi, safi_t safi,
struct prefix *p);
extern void bgp_packet_mpattr_end(struct stream *s, size_t sizep);
@ -336,12 +335,11 @@ extern size_t bgp_packet_mpunreach_start(struct stream *s, afi_t afi,
extern void bgp_packet_mpunreach_prefix(struct stream *s, struct prefix *p,
afi_t afi, safi_t safi,
struct prefix_rd *prd, mpls_label_t *,
u_int32_t, int, u_int32_t,
struct attr *);
uint32_t, int, uint32_t, struct attr *);
extern void bgp_packet_mpunreach_end(struct stream *s, size_t attrlen_pnt);
static inline int bgp_rmap_nhop_changed(u_int32_t out_rmap_flags,
u_int32_t in_rmap_flags)
static inline int bgp_rmap_nhop_changed(uint32_t out_rmap_flags,
uint32_t in_rmap_flags)
{
return ((CHECK_FLAG(out_rmap_flags, BATTR_RMAP_NEXTHOP_PEER_ADDRESS)
|| CHECK_FLAG(out_rmap_flags, BATTR_RMAP_NEXTHOP_UNCHANGED)
@ -356,7 +354,7 @@ static inline int bgp_rmap_nhop_changed(u_int32_t out_rmap_flags,
: 0);
}
static inline u_int32_t mac_mobility_seqnum(struct attr *attr)
static inline uint32_t mac_mobility_seqnum(struct attr *attr)
{
return (attr) ? attr->mm_seqnum : 0;
}

26
bgpd/bgp_attr_evpn.c
View file

@ -78,7 +78,7 @@ int str2esi(const char *str, struct eth_segment_id *id)
char *esi2str(struct eth_segment_id *id)
{
char *ptr;
u_char *val;
uint8_t *val;
if (!id)
return NULL;
@ -117,9 +117,9 @@ void bgp_attr_rmac(struct attr *attr, struct ethaddr *rmac)
/* If there is a router mac extended community, set RMAC in attr */
for (i = 0; i < ecom->size; i++) {
u_char *pnt = NULL;
u_char type = 0;
u_char sub_type = 0;
uint8_t *pnt = NULL;
uint8_t type = 0;
uint8_t sub_type = 0;
pnt = (ecom->val + (i * ECOMMUNITY_SIZE));
type = *pnt++;
@ -148,8 +148,8 @@ uint8_t bgp_attr_default_gw(struct attr *attr)
/* If there is a default gw extendd community return true otherwise
* return 0 */
for (i = 0; i < ecom->size; i++) {
u_char *pnt;
u_char type, sub_type;
uint8_t *pnt;
uint8_t type, sub_type;
pnt = (ecom->val + (i * ECOMMUNITY_SIZE));
type = *pnt++;
@ -167,11 +167,11 @@ uint8_t bgp_attr_default_gw(struct attr *attr)
* Fetch and return the sequence number from MAC Mobility extended
* community, if present, else 0.
*/
u_int32_t bgp_attr_mac_mobility_seqnum(struct attr *attr, u_char *sticky)
uint32_t bgp_attr_mac_mobility_seqnum(struct attr *attr, uint8_t *sticky)
{
struct ecommunity *ecom;
int i;
u_char flags = 0;
uint8_t flags = 0;
ecom = attr->ecommunity;
if (!ecom || !ecom->size)
@ -184,9 +184,9 @@ u_int32_t bgp_attr_mac_mobility_seqnum(struct attr *attr, u_char *sticky)
* one.
*/
for (i = 0; i < ecom->size; i++) {
u_char *pnt;
u_char type, sub_type;
u_int32_t seq_num;
uint8_t *pnt;
uint8_t type, sub_type;
uint32_t seq_num;
pnt = (ecom->val + (i * ECOMMUNITY_SIZE));
type = *pnt++;
@ -233,12 +233,12 @@ extern int bgp_build_evpn_prefix(int evpn_type, uint32_t eth_tag,
SET_IPADDR_V4(&p_evpn_p->ip);
memcpy(&p_evpn_p->ip.ipaddr_v4, &src->u.prefix4,
sizeof(struct in_addr));
dst->prefixlen = (u_char)PREFIX_LEN_ROUTE_TYPE_5_IPV4;
dst->prefixlen = (uint8_t)PREFIX_LEN_ROUTE_TYPE_5_IPV4;
} else {
SET_IPADDR_V6(&p_evpn_p->ip);
memcpy(&p_evpn_p->ip.ipaddr_v6, &src->u.prefix6,
sizeof(struct in6_addr));
dst->prefixlen = (u_char)PREFIX_LEN_ROUTE_TYPE_5_IPV6;
dst->prefixlen = (uint8_t)PREFIX_LEN_ROUTE_TYPE_5_IPV6;
}
} else
return -1;

8
bgpd/bgp_attr_evpn.h
View file

@ -34,11 +34,11 @@
#define MAX_ET 0xffffffff
u_long eth_tag_id;
unsigned long eth_tag_id;
struct attr;
struct eth_segment_id {
u_char val[ESI_LEN];
uint8_t val[ESI_LEN];
};
union gw_addr {
@ -60,8 +60,8 @@ extern void bgp_add_routermac_ecom(struct attr *attr,
extern int bgp_build_evpn_prefix(int type, uint32_t eth_tag,
struct prefix *dst);
extern void bgp_attr_rmac(struct attr *attr, struct ethaddr *rmac);
extern u_int32_t bgp_attr_mac_mobility_seqnum(struct attr *attr,
u_char *sticky);
extern uint32_t bgp_attr_mac_mobility_seqnum(struct attr *attr,
uint8_t *sticky);
extern uint8_t bgp_attr_default_gw(struct attr *attr);
#endif /* _QUAGGA_BGP_ATTR_EVPN_H */

12
bgpd/bgp_bfd.c
View file

@ -383,8 +383,8 @@ static int bgp_bfd_dest_update(int command, struct zclient *zclient,
/*
* bgp_bfd_peer_param_set - Set the configured BFD paramter values for peer.
*/
static int bgp_bfd_peer_param_set(struct peer *peer, u_int32_t min_rx,
u_int32_t min_tx, u_int8_t detect_mult,
static int bgp_bfd_peer_param_set(struct peer *peer, uint32_t min_rx,
uint32_t min_tx, uint8_t detect_mult,
int defaults)
{
struct peer_group *group;
@ -526,7 +526,7 @@ void bgp_bfd_peer_config_write(struct vty *vty, struct peer *peer, char *addr)
/*
* bgp_bfd_show_info - Show the peer BFD information.
*/
void bgp_bfd_show_info(struct vty *vty, struct peer *peer, u_char use_json,
void bgp_bfd_show_info(struct vty *vty, struct peer *peer, uint8_t use_json,
json_object *json_neigh)
{
bfd_show_info(vty, (struct bfd_info *)peer->bfd_info,
@ -571,9 +571,9 @@ DEFUN (neighbor_bfd_param,
int idx_number_2 = 4;
int idx_number_3 = 5;
struct peer *peer;
u_int32_t rx_val;
u_int32_t tx_val;
u_int8_t dm_val;
uint32_t rx_val;
uint32_t tx_val;
uint8_t dm_val;
int ret;
peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);

2
bgpd/bgp_bfd.h
View file

@ -35,7 +35,7 @@ extern void bgp_bfd_peer_config_write(struct vty *vty, struct peer *peer,
char *addr);
extern void bgp_bfd_show_info(struct vty *vty, struct peer *peer,
u_char use_json, json_object *json_neigh);
uint8_t use_json, json_object *json_neigh);
extern int bgp_bfd_is_peer_multihop(struct peer *peer);

18
bgpd/bgp_btoa.c
View file

@ -68,12 +68,12 @@ enum MRT_MSG_TYPES {
MSG_TABLE_DUMP /* routing table dump */
};
static int attr_parse(struct stream *s, u_int16_t len)
static int attr_parse(struct stream *s, uint16_t len)
{
u_int flag;
u_int type;
u_int16_t length;
u_int16_t lim;
unsigned int flag;
unsigned int type;
uint16_t length;
uint16_t lim;
lim = s->getp + len;
@ -94,7 +94,7 @@ static int attr_parse(struct stream *s, u_int16_t len)
switch (type) {
case BGP_ATTR_ORIGIN: {
u_char origin;
uint8_t origin;
origin = stream_getc(s);
printf("ORIGIN: %d\n", origin);
} break;
@ -134,7 +134,7 @@ int main(int argc, char **argv)
int family;
struct in_addr sip;
struct in_addr dip;
u_int16_t viewno, seq_num;
uint16_t viewno, seq_num;
struct prefix_ipv4 p;
s = stream_new(10000);
@ -230,10 +230,10 @@ int main(int argc, char **argv)
/* printf ("now read %d\n", len); */
if (type == MSG_TABLE_DUMP) {
u_char status;
uint8_t status;
time_t originated;
struct in_addr peer;
u_int16_t attrlen;
uint16_t attrlen;
viewno = stream_getw(s);
seq_num = stream_getw(s);

30
bgpd/bgp_clist.c
View file

@ -334,13 +334,13 @@ community_list_entry_lookup(struct community_list *list, const void *arg,
static char *community_str_get(struct community *com, int i)
{
int len;
u_int32_t comval;
u_int16_t as;
u_int16_t val;
uint32_t comval;
uint16_t as;
uint16_t val;
char *str;
char *pnt;
memcpy(&comval, com_nthval(com, i), sizeof(u_int32_t));
memcpy(&comval, com_nthval(com, i), sizeof(uint32_t));
comval = ntohl(comval);
switch (comval) {
@ -451,11 +451,11 @@ static int community_regexp_match(struct community *com, regex_t *reg)
static char *lcommunity_str_get(struct lcommunity *lcom, int i)
{
struct lcommunity_val lcomval;
u_int32_t globaladmin;
u_int32_t localdata1;
u_int32_t localdata2;
uint32_t globaladmin;
uint32_t localdata1;
uint32_t localdata2;
char *str;
u_char *ptr;
uint8_t *ptr;
char *pnt;
ptr = lcom->val + (i * LCOMMUNITY_SIZE);
@ -465,7 +465,7 @@ static char *lcommunity_str_get(struct lcommunity *lcom, int i)
/* Allocate memory. 48 bytes taken off bgp_lcommunity.c */
str = pnt = XMALLOC(MTYPE_LCOMMUNITY_STR, 48);
ptr = (u_char *)lcomval.val;
ptr = (uint8_t *)lcomval.val;
ptr = ptr_get_be32(ptr, &globaladmin);
ptr = ptr_get_be32(ptr, &localdata1);
ptr = ptr_get_be32(ptr, &localdata2);
@ -549,7 +549,7 @@ static struct community *
community_regexp_delete (struct community *com, regex_t * reg)
{
int i;
u_int32_t comval;
uint32_t comval;
/* Maximum is "65535:65535" + '\0'. */
char c[12];
const char *str;
@ -560,7 +560,7 @@ community_regexp_delete (struct community *com, regex_t * reg)
i = 0;
while (i < com->size)
{
memcpy (&comval, com_nthval (com, i), sizeof (u_int32_t));
memcpy (&comval, com_nthval (com, i), sizeof (uint32_t));
comval = ntohl (comval);
switch (comval)
@ -694,8 +694,8 @@ struct community *community_list_match_delete(struct community *com,
struct community_list *list)
{
struct community_entry *entry;
u_int32_t val;
u_int32_t com_index_to_delete[com->size];
uint32_t val;
uint32_t com_index_to_delete[com->size];
int delete_index = 0;
int i;
@ -895,8 +895,8 @@ struct lcommunity *lcommunity_list_match_delete(struct lcommunity *lcom,
struct community_list *list)
{
struct community_entry *entry;
u_int32_t com_index_to_delete[lcom->size];
u_char *ptr;
uint32_t com_index_to_delete[lcom->size];
uint8_t *ptr;
int delete_index = 0;
int i;

6
bgpd/bgp_clist.h
View file

@ -68,13 +68,13 @@ struct community_entry {
struct community_entry *prev;
/* Permit or deny. */
u_char direct;
uint8_t direct;
/* Standard or expanded. */
u_char style;
uint8_t style;
/* Any match. */
u_char any;
uint8_t any;
/* Community structure. */
union {

59
bgpd/bgp_community.c
View file

@ -55,7 +55,7 @@ void community_free(struct community *com)
}
/* Add one community value to the community. */
static void community_add_val(struct community *com, u_int32_t val)
static void community_add_val(struct community *com, uint32_t val)
{
com->size++;
if (com->val)
@ -65,11 +65,11 @@ static void community_add_val(struct community *com, u_int32_t val)
com->val = XMALLOC(MTYPE_COMMUNITY_VAL, com_length(com));
val = htonl(val);
memcpy(com_lastval(com), &val, sizeof(u_int32_t));
memcpy(com_lastval(com), &val, sizeof(uint32_t));
}
/* Delete one community. */
void community_del_val(struct community *com, u_int32_t *val)
void community_del_val(struct community *com, uint32_t *val)
{
int i = 0;
int c = 0;
@ -78,7 +78,7 @@ void community_del_val(struct community *com, u_int32_t *val)
return;
while (i < com->size) {
if (memcmp(com->val + i, val, sizeof(u_int32_t)) == 0) {
if (memcmp(com->val + i, val, sizeof(uint32_t)) == 0) {
c = com->size - i - 1;
if (c > 0)
@ -117,11 +117,11 @@ struct community *community_delete(struct community *com1,
/* Callback function from qsort(). */
static int community_compare(const void *a1, const void *a2)
{
u_int32_t v1;
u_int32_t v2;
uint32_t v1;
uint32_t v2;
memcpy(&v1, a1, sizeof(u_int32_t));
memcpy(&v2, a2, sizeof(u_int32_t));
memcpy(&v1, a1, sizeof(uint32_t));
memcpy(&v2, a2, sizeof(uint32_t));
v1 = ntohl(v1);
v2 = ntohl(v2);
@ -132,28 +132,28 @@ static int community_compare(const void *a1, const void *a2)
return 0;
}
int community_include(struct community *com, u_int32_t val)
int community_include(struct community *com, uint32_t val)
{
int i;
val = htonl(val);
for (i = 0; i < com->size; i++)
if (memcmp(&val, com_nthval(com, i), sizeof(u_int32_t)) == 0)
if (memcmp(&val, com_nthval(com, i), sizeof(uint32_t)) == 0)
return 1;
return 0;
}
u_int32_t community_val_get(struct community *com, int i)
uint32_t community_val_get(struct community *com, int i)
{
u_char *p;
u_int32_t val;
uint8_t *p;
uint32_t val;
p = (u_char *)com->val;
p = (uint8_t *)com->val;
p += (i * 4);
memcpy(&val, p, sizeof(u_int32_t));
memcpy(&val, p, sizeof(uint32_t));
return ntohl(val);
}
@ -163,7 +163,7 @@ struct community *community_uniq_sort(struct community *com)
{
int i;
struct community *new;
u_int32_t val;
uint32_t val;
if (!com)
return NULL;
@ -178,7 +178,7 @@ struct community *community_uniq_sort(struct community *com)
community_add_val(new, val);
}
qsort(new->val, new->size, sizeof(u_int32_t), community_compare);
qsort(new->val, new->size, sizeof(uint32_t), community_compare);
return new;
}
@ -201,9 +201,9 @@ static void set_community_string(struct community *com, bool make_json)
char *pnt;
int len;
int first;
u_int32_t comval;
u_int16_t as;
u_int16_t val;
uint32_t comval;
uint16_t as;
uint16_t val;
json_object *json_community_list = NULL;
json_object *json_string = NULL;
@ -234,7 +234,7 @@ static void set_community_string(struct community *com, bool make_json)
len = 0;
for (i = 0; i < com->size; i++) {
memcpy(&comval, com_nthval(com, i), sizeof(u_int32_t));
memcpy(&comval, com_nthval(com, i), sizeof(uint32_t));
comval = ntohl(comval);
switch (comval) {
@ -265,7 +265,7 @@ static void set_community_string(struct community *com, bool make_json)
/* Fill in string. */
for (i = 0; i < com->size; i++) {
memcpy(&comval, com_nthval(com, i), sizeof(u_int32_t));
memcpy(&comval, com_nthval(com, i), sizeof(uint32_t));
comval = ntohl(comval);
if (first)
@ -391,7 +391,7 @@ void community_unintern(struct community **com)
}
/* Create new community attribute. */
struct community *community_parse(u_int32_t *pnt, u_short length)
struct community *community_parse(uint32_t *pnt, unsigned short length)
{
struct community tmp;
struct community *new;
@ -441,7 +441,7 @@ char *community_str(struct community *com, bool make_json)
hash package.*/
unsigned int community_hash_make(struct community *com)
{
u_int32_t *pnt = (u_int32_t *)com->val;
uint32_t *pnt = (uint32_t *)com->val;
return jhash2(pnt, com->size, 0x43ea96c1);
}
@ -462,8 +462,7 @@ int community_match(const struct community *com1, const struct community *com2)
/* Every community on com2 needs to be on com1 for this to match */
while (i < com1->size && j < com2->size) {
if (memcmp(com1->val + i, com2->val + j, sizeof(u_int32_t))
== 0)
if (memcmp(com1->val + i, com2->val + j, sizeof(uint32_t)) == 0)
j++;
i++;
}
@ -518,7 +517,7 @@ enum community_token {
/* Get next community token from string. */
static const char *
community_gettoken(const char *buf, enum community_token *token, u_int32_t *val)
community_gettoken(const char *buf, enum community_token *token, uint32_t *val)
{
const char *p = buf;
@ -573,8 +572,8 @@ community_gettoken(const char *buf, enum community_token *token, u_int32_t *val)
if (isdigit((int)*p)) {
int separator = 0;
int digit = 0;
u_int32_t community_low = 0;
u_int32_t community_high = 0;
uint32_t community_low = 0;
uint32_t community_high = 0;
while (isdigit((int)*p) || *p == ':') {
if (*p == ':') {
@ -624,7 +623,7 @@ struct community *community_str2com(const char *str)
{
struct community *com = NULL;
struct community *com_sort = NULL;
u_int32_t val = 0;
uint32_t val = 0;
enum community_token token = community_token_unknown;
do {

10
bgpd/bgp_community.h
View file

@ -32,7 +32,7 @@ struct community {
int size;
/* Communities value. */
u_int32_t *val;
uint32_t *val;
/* Communities as a json object */
json_object *json;
@ -60,7 +60,7 @@ extern void community_init(void);
extern void community_finish(void);
extern void community_free(struct community *);
extern struct community *community_uniq_sort(struct community *);
extern struct community *community_parse(u_int32_t *, u_short);
extern struct community *community_parse(uint32_t *, unsigned short);
extern struct community *community_intern(struct community *);
extern void community_unintern(struct community **);
extern char *community_str(struct community *, bool make_json);
@ -73,10 +73,10 @@ extern struct community *community_merge(struct community *,
extern struct community *community_delete(struct community *,
struct community *);
extern struct community *community_dup(struct community *);
extern int community_include(struct community *, u_int32_t);
extern void community_del_val(struct community *, u_int32_t *);
extern int community_include(struct community *, uint32_t);
extern void community_del_val(struct community *, uint32_t *);
extern unsigned long community_count(void);
extern struct hash *community_hash(void);
extern u_int32_t community_val_get(struct community *com, int i);
extern uint32_t community_val_get(struct community *com, int i);
#endif /* _QUAGGA_BGP_COMMUNITY_H */

4
bgpd/bgp_damp.c
View file

@ -523,7 +523,7 @@ void bgp_config_write_damp(struct vty *vty)
}
static const char *bgp_get_reuse_time(unsigned int penalty, char *buf,
size_t len, u_char use_json,
size_t len, uint8_t use_json,
json_object *json)
{
time_t reuse_time = 0;
@ -641,7 +641,7 @@ void bgp_damp_info_vty(struct vty *vty, struct bgp_info *binfo,
}
const char *bgp_damp_reuse_time_vty(struct vty *vty, struct bgp_info *binfo,
char *timebuf, size_t len, u_char use_json,
char *timebuf, size_t len, uint8_t use_json,
json_object *json)
{
struct bgp_damp_info *bdi;

4
bgpd/bgp_damp.h
View file

@ -53,7 +53,7 @@ struct bgp_damp_info {
int index;
/* Last time message type. */
u_char lastrecord;
uint8_t lastrecord;
#define BGP_RECORD_UPDATE 1U
#define BGP_RECORD_WITHDRAW 2U
@ -141,7 +141,7 @@ extern void bgp_config_write_damp(struct vty *);
extern void bgp_damp_info_vty(struct vty *, struct bgp_info *,
json_object *json_path);
extern const char *bgp_damp_reuse_time_vty(struct vty *, struct bgp_info *,
char *, size_t, u_char,
char *, size_t, uint8_t,
json_object *);
extern int bgp_show_dampening_parameters(struct vty *vty, afi_t, safi_t);

10
bgpd/bgp_debug.c
View file

@ -469,13 +469,13 @@ const char *bgp_notify_subcode_str(char code, char subcode)
}
/* extract notify admin reason if correctly present */
const char *bgp_notify_admin_message(char *buf, size_t bufsz, u_char *data,
const char *bgp_notify_admin_message(char *buf, size_t bufsz, uint8_t *data,
size_t datalen)
{
if (!data || datalen < 1)
return NULL;
u_char len = data[0];
uint8_t len = data[0];
if (len > 128 || len > datalen - 1)
return NULL;
@ -2159,8 +2159,8 @@ int bgp_debug_zebra(struct prefix *p)
const char *bgp_debug_rdpfxpath2str(afi_t afi, safi_t safi,
struct prefix_rd *prd,
union prefixconstptr pu,
mpls_label_t *label, u_int32_t num_labels,
int addpath_valid, u_int32_t addpath_id,
mpls_label_t *label, uint32_t num_labels,
int addpath_valid, uint32_t addpath_id,
char *str, int size)
{
char rd_buf[RD_ADDRSTRLEN];
@ -2192,7 +2192,7 @@ const char *bgp_debug_rdpfxpath2str(afi_t afi, safi_t safi,
bgp_evpn_label2str(label, num_labels, tag_buf2, 20);
sprintf(tag_buf, " label %s", tag_buf2);
} else {
u_int32_t label_value;
uint32_t label_value;
label_value = decode_label(label);
sprintf(tag_buf, " label %u", label_value);

4
bgpd/bgp_debug.h
View file

@ -161,9 +161,9 @@ extern int bgp_debug_zebra(struct prefix *p);
extern int bgp_debug_count(void);
extern const char *bgp_debug_rdpfxpath2str(afi_t, safi_t, struct prefix_rd *,
union prefixconstptr, mpls_label_t *,
u_int32_t, int, u_int32_t, char *,
uint32_t, int, uint32_t, char *,
int);
const char *bgp_notify_admin_message(char *buf, size_t bufsz, u_char *data,
const char *bgp_notify_admin_message(char *buf, size_t bufsz, uint8_t *data,
size_t datalen);
#endif /* _QUAGGA_BGP_DEBUG_H */

6
bgpd/bgp_dump.c
View file

@ -277,7 +277,7 @@ static void bgp_dump_routes_index_table(struct bgp *bgp)
if (sockunion_family(&peer->su) == AF_INET) {
stream_put_in_addr(obuf, &peer->su.sin.sin_addr);
} else if (sockunion_family(&peer->su) == AF_INET6) {
stream_write(obuf, (u_char *)&peer->su.sin6.sin6_addr,
stream_write(obuf, (uint8_t *)&peer->su.sin6.sin6_addr,
IPV6_MAX_BYTELEN);
}
@ -329,12 +329,12 @@ static struct bgp_info *bgp_dump_route_node_record(int afi, struct bgp_node *rn,
if (afi == AFI_IP) {
/* We'll dump only the useful bits (those not 0), but have to
* align on 8 bits */
stream_write(obuf, (u_char *)&rn->p.u.prefix4,
stream_write(obuf, (uint8_t *)&rn->p.u.prefix4,
(rn->p.prefixlen + 7) / 8);
} else if (afi == AFI_IP6) {
/* We'll dump only the useful bits (those not 0), but have to
* align on 8 bits */
stream_write(obuf, (u_char *)&rn->p.u.prefix6,
stream_write(obuf, (uint8_t *)&rn->p.u.prefix6,
(rn->p.prefixlen + 7) / 8);
}

24
bgpd/bgp_ecommunity.c
View file

@ -68,7 +68,7 @@ static void ecommunity_hash_free(struct ecommunity *ecom)
else return 0. */
int ecommunity_add_val(struct ecommunity *ecom, struct ecommunity_val *eval)
{
u_int8_t *p;
uint8_t *p;
int ret;
int c;
@ -126,7 +126,7 @@ struct ecommunity *ecommunity_uniq_sort(struct ecommunity *ecom)
}
/* Parse Extended Communites Attribute in BGP packet. */
struct ecommunity *ecommunity_parse(u_int8_t *pnt, u_short length)
struct ecommunity *ecommunity_parse(uint8_t *pnt, unsigned short length)
{
struct ecommunity tmp;
struct ecommunity *new;
@ -283,8 +283,8 @@ enum ecommunity_token {
* Encode BGP extended community from passed values. Supports types
* defined in RFC 4360 and well-known sub-types.
*/
static int ecommunity_encode(u_char type, u_char sub_type, int trans, as_t as,
struct in_addr ip, u_int32_t val,
static int ecommunity_encode(uint8_t type, uint8_t sub_type, int trans, as_t as,
struct in_addr ip, uint32_t val,
struct ecommunity_val *eval)
{
assert(eval);
@ -338,8 +338,8 @@ static const char *ecommunity_gettoken(const char *str,
char *endptr;
struct in_addr ip;
as_t as = 0;
u_int32_t val = 0;
u_char ecomm_type;
uint32_t val = 0;
uint8_t ecomm_type;
char buf[INET_ADDRSTRLEN + 1];
/* Skip white space. */
@ -547,7 +547,7 @@ struct ecommunity *ecommunity_str2com(const char *str, int type,
return ecom;
}
static int ecommunity_rt_soo_str(char *buf, u_int8_t *pnt, int type,
static int ecommunity_rt_soo_str(char *buf, uint8_t *pnt, int type,
int sub_type, int format)
{
int len = 0;
@ -628,7 +628,7 @@ static int ecommunity_rt_soo_str(char *buf, u_int8_t *pnt, int type,
char *ecommunity_ecom2str(struct ecommunity *ecom, int format, int filter)
{
int i;
u_int8_t *pnt;
uint8_t *pnt;
int type = 0;
int sub_type = 0;
#define ECOMMUNITY_STR_DEFAULT_LEN 27
@ -712,8 +712,8 @@ char *ecommunity_ecom2str(struct ecommunity *ecom, int format, int filter)
(uint8_t)rmac.octet[5]);
} else if (*pnt
== ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY) {
u_int32_t seqnum;
u_char flags = *++pnt;
uint32_t seqnum;
uint8_t flags = *++pnt;
memcpy(&seqnum, pnt + 2, 4);
seqnum = ntohl(seqnum);
@ -774,7 +774,7 @@ int ecommunity_match(const struct ecommunity *ecom1,
extern struct ecommunity_val *ecommunity_lookup(const struct ecommunity *ecom,
uint8_t type, uint8_t subtype)
{
u_int8_t *p;
uint8_t *p;
int c;
/* If the value already exists in the structure return 0. */
@ -795,7 +795,7 @@ extern struct ecommunity_val *ecommunity_lookup(const struct ecommunity *ecom,
extern int ecommunity_strip(struct ecommunity *ecom, uint8_t type,
uint8_t subtype)
{
u_int8_t *p;
uint8_t *p;
int c, found = 0;
/* When this is fist value, just add it. */
if (ecom == NULL || ecom->val == NULL) {

10
bgpd/bgp_ecommunity.h
View file

@ -64,7 +64,7 @@ struct ecommunity {
int size;
/* Extended Communities value. */
u_int8_t *val;
uint8_t *val;
/* Human readable format string. */
char *str;
@ -90,7 +90,7 @@ struct ecommunity_val {
/*
* Encode BGP Route Target AS:nn.
*/
static inline void encode_route_target_as(as_t as, u_int32_t val,
static inline void encode_route_target_as(as_t as, uint32_t val,
struct ecommunity_val *eval)
{
eval->val[0] = ECOMMUNITY_ENCODE_AS;
@ -106,7 +106,7 @@ static inline void encode_route_target_as(as_t as, u_int32_t val,
/*
* Encode BGP Route Target IP:nn.
*/
static inline void encode_route_target_ip(struct in_addr ip, u_int16_t val,
static inline void encode_route_target_ip(struct in_addr ip, uint16_t val,
struct ecommunity_val *eval)
{
eval->val[0] = ECOMMUNITY_ENCODE_IP;
@ -119,7 +119,7 @@ static inline void encode_route_target_ip(struct in_addr ip, u_int16_t val,
/*
* Encode BGP Route Target AS4:nn.
*/
static inline void encode_route_target_as4(as_t as, u_int16_t val,
static inline void encode_route_target_as4(as_t as, uint16_t val,
struct ecommunity_val *eval)
{
eval->val[0] = ECOMMUNITY_ENCODE_AS4;
@ -135,7 +135,7 @@ static inline void encode_route_target_as4(as_t as, u_int16_t val,
extern void ecommunity_init(void);
extern void ecommunity_finish(void);
extern void ecommunity_free(struct ecommunity **);
extern struct ecommunity *ecommunity_parse(u_int8_t *, u_short);
extern struct ecommunity *ecommunity_parse(uint8_t *, unsigned short);
extern struct ecommunity *ecommunity_dup(struct ecommunity *);
extern struct ecommunity *ecommunity_merge(struct ecommunity *,
struct ecommunity *);

2
bgpd/bgp_encap_types.h
View file

@ -82,7 +82,7 @@ struct bgp_tea_subtlv_color {
/* per draft-rosen-idr-tunnel-encaps */
struct bgp_tea_subtlv_remote_endpoint {
u_char family; /* IPv4 or IPv6 */
uint8_t family; /* IPv4 or IPv6 */
union {
struct in_addr v4;
struct in6_addr v6;

99
bgpd/bgp_evpn.c
View file

@ -335,7 +335,7 @@ static int evpn_route_target_cmp(struct ecommunity *ecom1,
static inline void mask_ecom_global_admin(struct ecommunity_val *dst,
struct ecommunity_val *src)
{
u_char type;
uint8_t type;
type = src->val[0];
dst->val[0] = 0;
@ -488,7 +488,7 @@ static void evpn_convert_nexthop_to_ipv6(struct attr *attr)
static int bgp_zebra_send_remote_macip(struct bgp *bgp, struct bgpevpn *vpn,
struct prefix_evpn *p,
struct in_addr remote_vtep_ip, int add,
u_char flags)
uint8_t flags)
{
struct stream *s;
int ipa_len;
@ -603,7 +603,7 @@ static void build_evpn_type5_route_extcomm(struct bgp *bgp_vrf,
memset(&ecom_encap, 0, sizeof(ecom_encap));
encode_encap_extcomm(tnl_type, &eval);
ecom_encap.size = 1;
ecom_encap.val = (u_int8_t *)eval.val;
ecom_encap.val = (uint8_t *)eval.val;
/* Add Encap */
attr->ecommunity = ecommunity_dup(&ecom_encap);
@ -653,7 +653,7 @@ static void build_evpn_route_extcomm(struct bgpevpn *vpn, struct attr *attr,
bgp_encap_types tnl_type;
struct listnode *node, *nnode;
struct ecommunity *ecom;
u_int32_t seqnum;
uint32_t seqnum;
struct list *vrf_export_rtl = NULL;
/* Encap */
@ -661,7 +661,7 @@ static void build_evpn_route_extcomm(struct bgpevpn *vpn, struct attr *attr,
memset(&ecom_encap, 0, sizeof(ecom_encap));
encode_encap_extcomm(tnl_type, &eval);
ecom_encap.size = 1;
ecom_encap.val = (u_int8_t *)eval.val;
ecom_encap.val = (uint8_t *)eval.val;
/* Add Encap */
attr->ecommunity = ecommunity_dup(&ecom_encap);
@ -689,7 +689,7 @@ static void build_evpn_route_extcomm(struct bgpevpn *vpn, struct attr *attr,
memset(&ecom_sticky, 0, sizeof(ecom_sticky));
encode_mac_mobility_extcomm(1, seqnum, &eval_sticky);
ecom_sticky.size = 1;
ecom_sticky.val = (u_int8_t *)eval_sticky.val;
ecom_sticky.val = (uint8_t *)eval_sticky.val;
attr->ecommunity =
ecommunity_merge(attr->ecommunity, &ecom_sticky);
}
@ -720,13 +720,13 @@ static void build_evpn_route_extcomm(struct bgpevpn *vpn, struct attr *attr,
/*
* Add MAC mobility extended community to attribute.
*/
static void add_mac_mobility_to_attr(u_int32_t seq_num, struct attr *attr)
static void add_mac_mobility_to_attr(uint32_t seq_num, struct attr *attr)
{
struct ecommunity ecom_tmp;
struct ecommunity_val eval;
u_int8_t *ecom_val_ptr;
uint8_t *ecom_val_ptr;
int i;
u_int8_t *pnt;
uint8_t *pnt;
int type = 0;
int sub_type = 0;
@ -745,9 +745,8 @@ static void add_mac_mobility_to_attr(u_int32_t seq_num, struct attr *attr)
if (type == ECOMMUNITY_ENCODE_EVPN
&& sub_type
== ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY) {
ecom_val_ptr =
(u_int8_t *)(attr->ecommunity->val
+ (i * 8));
ecom_val_ptr = (uint8_t *)(attr->ecommunity->val
+ (i * 8));
break;
}
}
@ -761,7 +760,7 @@ static void add_mac_mobility_to_attr(u_int32_t seq_num, struct attr *attr)
else {
memset(&ecom_tmp, 0, sizeof(ecom_tmp));
ecom_tmp.size = 1;
ecom_tmp.val = (u_int8_t *)eval.val;
ecom_tmp.val = (uint8_t *)eval.val;
attr->ecommunity =
ecommunity_merge(attr->ecommunity, &ecom_tmp);
@ -771,7 +770,7 @@ static void add_mac_mobility_to_attr(u_int32_t seq_num, struct attr *attr)
/* Install EVPN route into zebra. */
static int evpn_zebra_install(struct bgp *bgp, struct bgpevpn *vpn,
struct prefix_evpn *p,
struct in_addr remote_vtep_ip, u_char flags)
struct in_addr remote_vtep_ip, uint8_t flags)
{
int ret;
@ -848,7 +847,7 @@ static int evpn_route_select_install(struct bgp *bgp, struct bgpevpn *vpn,
afi_t afi = AFI_L2VPN;
safi_t safi = SAFI_EVPN;
int ret = 0;
u_char flags = 0;
uint8_t flags = 0;
/* Compute the best path. */
bgp_best_selection(bgp, rn, &bgp->maxpaths[afi][safi], &old_and_new,
@ -1111,15 +1110,15 @@ static int update_evpn_type5_route(struct bgp *bgp_vrf, struct prefix_evpn *evp,
static int update_evpn_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
afi_t afi, safi_t safi, struct bgp_node *rn,
struct attr *attr, int add, int vni_table,
struct bgp_info **ri, u_char flags)
struct bgp_info **ri, uint8_t flags)
{
struct bgp_info *tmp_ri;
struct bgp_info *local_ri, *remote_ri;
struct attr *attr_new;
mpls_label_t label[BGP_MAX_LABELS];
u_int32_t num_labels = 1;
uint32_t num_labels = 1;
int route_change = 1;
u_char sticky = 0;
uint8_t sticky = 0;
struct prefix_evpn *evp;
*ri = NULL;
@ -1167,7 +1166,7 @@ static int update_evpn_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
* This will ensure that local routes are preferred for g/w macs
*/
if (remote_ri && !CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_GW)) {
u_int32_t cur_seqnum;
uint32_t cur_seqnum;
/* Add MM extended community to route. */
cur_seqnum = mac_mobility_seqnum(remote_ri->attr);
@ -1260,7 +1259,7 @@ static int update_evpn_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
* and schedule for processing.
*/
static int update_evpn_route(struct bgp *bgp, struct bgpevpn *vpn,
struct prefix_evpn *p, u_char flags)
struct prefix_evpn *p, uint8_t flags)
{
struct bgp_node *rn;
struct attr attr;
@ -2083,8 +2082,8 @@ static int is_route_matching_for_vrf(struct bgp *bgp_vrf, struct bgp_info *ri)
* matches, we're done.
*/
for (i = 0; i < ecom->size; i++) {
u_char *pnt;
u_char type, sub_type;
uint8_t *pnt;
uint8_t type, sub_type;
struct ecommunity_val *eval;
struct ecommunity_val eval_tmp;
struct vrf_irt_node *irt;
@ -2150,8 +2149,8 @@ static int is_route_matching_for_vni(struct bgp *bgp, struct bgpevpn *vpn,
* matches, we're done.
*/
for (i = 0; i < ecom->size; i++) {
u_char *pnt;
u_char type, sub_type;
uint8_t *pnt;
uint8_t type, sub_type;
struct ecommunity_val *eval;
struct ecommunity_val eval_tmp;
struct irt_node *irt;
@ -2519,8 +2518,8 @@ static int install_uninstall_evpn_route(struct bgp *bgp, afi_t afi, safi_t safi,
* the route into matching VNIs/VRFs.
*/
for (i = 0; i < ecom->size; i++) {
u_char *pnt;
u_char type, sub_type;
uint8_t *pnt;
uint8_t type, sub_type;
struct ecommunity_val *eval;
struct ecommunity_val eval_tmp;
struct irt_node *irt; /* import rt for l2vni */
@ -2806,15 +2805,15 @@ static void withdraw_router_id_vni(struct hash_backet *backet, struct bgp *bgp)
* Process received EVPN type-2 route (advertise or withdraw).
*/
static int process_type2_route(struct peer *peer, afi_t afi, safi_t safi,
struct attr *attr, u_char *pfx, int psize,
u_int32_t addpath_id)
struct attr *attr, uint8_t *pfx, int psize,
uint32_t addpath_id)
{
struct prefix_rd prd;
struct prefix_evpn p;
u_char ipaddr_len;
u_char macaddr_len;
uint8_t ipaddr_len;
uint8_t macaddr_len;
mpls_label_t label[BGP_MAX_LABELS]; /* holds the VNI(s) as in packet */
u_int32_t num_labels = 0;
uint32_t num_labels = 0;
int ret;
/* Type-2 route should be either 33, 37 or 49 bytes or an
@ -2915,12 +2914,12 @@ static int process_type2_route(struct peer *peer, afi_t afi, safi_t safi,
* Process received EVPN type-3 route (advertise or withdraw).
*/
static int process_type3_route(struct peer *peer, afi_t afi, safi_t safi,
struct attr *attr, u_char *pfx, int psize,
u_int32_t addpath_id)
struct attr *attr, uint8_t *pfx, int psize,
uint32_t addpath_id)
{
struct prefix_rd prd;
struct prefix_evpn p;
u_char ipaddr_len;
uint8_t ipaddr_len;
int ret;
/* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4),
@ -2988,14 +2987,14 @@ static int process_type3_route(struct peer *peer, afi_t afi, safi_t safi,
* Process received EVPN type-5 route (advertise or withdraw).
*/
static int process_type5_route(struct peer *peer, afi_t afi, safi_t safi,
struct attr *attr, u_char *pfx, int psize,
u_int32_t addpath_id, int withdraw)
struct attr *attr, uint8_t *pfx, int psize,
uint32_t addpath_id, int withdraw)
{
struct prefix_rd prd;
struct prefix_evpn p;
struct bgp_route_evpn evpn;
u_char ippfx_len;
u_int32_t eth_tag;
uint8_t ippfx_len;
uint32_t eth_tag;
mpls_label_t label; /* holds the VNI as in the packet */
int ret;
@ -3087,7 +3086,7 @@ static int process_type5_route(struct peer *peer, afi_t afi, safi_t safi,
static void evpn_mpattr_encode_type5(struct stream *s, struct prefix *p,
struct prefix_rd *prd, mpls_label_t *label,
u_int32_t num_labels, struct attr *attr)
uint32_t num_labels, struct attr *attr)
{
int len;
char temp[16];
@ -3547,7 +3546,7 @@ int bgp_evpn_uninstall_routes(struct bgp *bgp, struct bgpevpn *vpn)
/*
* TODO: Hardcoded for a maximum of 2 VNIs right now
*/
char *bgp_evpn_label2str(mpls_label_t *label, u_int32_t num_labels, char *buf,
char *bgp_evpn_label2str(mpls_label_t *label, uint32_t num_labels, char *buf,
int len)
{
vni_t vni1, vni2;
@ -3596,7 +3595,7 @@ void bgp_evpn_route2json(struct prefix_evpn *p, json_object *json)
buf1,
sizeof(buf1)));
} else {
u_char family;
uint8_t family;
family = IS_EVPN_PREFIX_IPADDR_V4(p) ? AF_INET
: AF_INET6;
@ -3647,7 +3646,7 @@ char *bgp_evpn_route2str(struct prefix_evpn *p, char *buf, int len)
prefix_mac2str(&p->prefix.mac, buf1,
sizeof(buf1)));
else {
u_char family;
uint8_t family;
family = IS_EVPN_PREFIX_IPADDR_V4(p) ? AF_INET
: AF_INET6;
@ -3680,8 +3679,8 @@ char *bgp_evpn_route2str(struct prefix_evpn *p, char *buf, int len)
*/
void bgp_evpn_encode_prefix(struct stream *s, struct prefix *p,
struct prefix_rd *prd, mpls_label_t *label,
u_int32_t num_labels, struct attr *attr,
int addpath_encode, u_int32_t addpath_tx_id)
uint32_t num_labels, struct attr *attr,
int addpath_encode, uint32_t addpath_tx_id)
{
struct prefix_evpn *evp = (struct prefix_evpn *)p;
int len, ipa_len = 0;
@ -3740,15 +3739,15 @@ void bgp_evpn_encode_prefix(struct stream *s, struct prefix *p,
int bgp_nlri_parse_evpn(struct peer *peer, struct attr *attr,
struct bgp_nlri *packet, int withdraw)
{
u_char *pnt;
u_char *lim;
uint8_t *pnt;
uint8_t *lim;
afi_t afi;
safi_t safi;
u_int32_t addpath_id;
uint32_t addpath_id;
int addpath_encoded;
int psize = 0;
u_char rtype;
u_char rlen;
uint8_t rtype;
uint8_t rlen;
struct prefix p;
/* Start processing the NLRI - there may be multiple in the MP_REACH */
@ -4192,7 +4191,7 @@ int bgp_evpn_local_macip_del(struct bgp *bgp, vni_t vni, struct ethaddr *mac,
* Handle add of a local MACIP.
*/
int bgp_evpn_local_macip_add(struct bgp *bgp, vni_t vni, struct ethaddr *mac,
struct ipaddr *ip, u_char flags)
struct ipaddr *ip, uint8_t flags)
{
struct bgpevpn *vpn;
struct prefix_evpn p;

18
bgpd/bgp_evpn.h
View file

@ -36,7 +36,7 @@ static inline int is_evpn_enabled(void)
static inline void vni2label(vni_t vni, mpls_label_t *label)
{
u_char *tag = (u_char *)label;
uint8_t *tag = (uint8_t *)label;
tag[0] = (vni >> 16) & 0xFF;
tag[1] = (vni >> 8) & 0xFF;
@ -45,12 +45,12 @@ static inline void vni2label(vni_t vni, mpls_label_t *label)
static inline vni_t label2vni(mpls_label_t *label)
{
u_char *tag = (u_char *)label;
uint8_t *tag = (uint8_t *)label;
vni_t vni;
vni = ((u_int32_t)*tag++ << 16);
vni |= (u_int32_t)*tag++ << 8;
vni |= (u_int32_t)(*tag & 0xFF);
vni = ((uint32_t)*tag++ << 16);
vni |= (uint32_t)*tag++ << 8;
vni |= (uint32_t)(*tag & 0xFF);
return vni;
}
@ -86,14 +86,14 @@ extern void bgp_evpn_advertise_type5_routes(struct bgp *bgp_vrf, afi_t afi,
safi_t safi);
extern void bgp_evpn_vrf_delete(struct bgp *bgp_vrf);
extern void bgp_evpn_handle_router_id_update(struct bgp *bgp, int withdraw);
extern char *bgp_evpn_label2str(mpls_label_t *label, u_int32_t num_labels,
extern char *bgp_evpn_label2str(mpls_label_t *label, uint32_t num_labels,
char *buf, int len);
extern char *bgp_evpn_route2str(struct prefix_evpn *p, char *buf, int len);
extern void bgp_evpn_route2json(struct prefix_evpn *p, json_object *json);
extern void bgp_evpn_encode_prefix(struct stream *s, struct prefix *p,
struct prefix_rd *prd, mpls_label_t *label,
u_int32_t num_labels, struct attr *attr,
int addpath_encode, u_int32_t addpath_tx_id);
uint32_t num_labels, struct attr *attr,
int addpath_encode, uint32_t addpath_tx_id);
extern int bgp_nlri_parse_evpn(struct peer *peer, struct attr *attr,
struct bgp_nlri *packet, int withdraw);
extern int bgp_evpn_import_route(struct bgp *bgp, afi_t afi, safi_t safi,
@ -105,7 +105,7 @@ extern int bgp_evpn_local_macip_del(struct bgp *bgp, vni_t vni,
struct ethaddr *mac, struct ipaddr *ip);
extern int bgp_evpn_local_macip_add(struct bgp *bgp, vni_t vni,
struct ethaddr *mac, struct ipaddr *ip,
u_char flags);
uint8_t flags);
extern int bgp_evpn_local_l3vni_add(vni_t vni, vrf_id_t vrf_id,
struct ethaddr *rmac,
struct in_addr originator_ip, int filter);

40
bgpd/bgp_evpn_private.h
View file

@ -55,7 +55,7 @@ typedef enum {
struct bgpevpn {
vni_t vni;
vrf_id_t tenant_vrf_id;
u_int32_t flags;
uint32_t flags;
#define VNI_FLAG_CFGD 0x1 /* VNI is user configured */
#define VNI_FLAG_LIVE 0x2 /* VNI is "live" */
#define VNI_FLAG_RD_CFGD 0x4 /* RD is user configured. */
@ -69,31 +69,31 @@ struct bgpevpn {
/* Flag to indicate if we are
* advertising the g/w mac ip for
* this VNI*/
u_int8_t advertise_gw_macip;
uint8_t advertise_gw_macip;
/* Flag to indicate if we are
* advertising subnet for this VNI */
u_int8_t advertise_subnet;
/* Flag to indicate if we are
* advertising subnet for this VNI */
uint8_t advertise_subnet;
/* Id for deriving the RD
* automatically for this VNI */
u_int16_t rd_id;
/* Id for deriving the RD
* automatically for this VNI */
uint16_t rd_id;
/* RD for this VNI. */
struct prefix_rd prd;
/* RD for this VNI. */
struct prefix_rd prd;
/* Route type 3 field */
struct in_addr originator_ip;
/* Route type 3 field */
struct in_addr originator_ip;
/* Import and Export RTs. */
struct list *import_rtl;
struct list *export_rtl;
/* Import and Export RTs. */
struct list *import_rtl;
struct list *export_rtl;
/* Route table for EVPN routes for
* this VNI. */
struct bgp_table *route_table;
/* Route table for EVPN routes for
* this VNI. */
struct bgp_table *route_table;
QOBJ_FIELDS
QOBJ_FIELDS
};
DECLARE_QOBJ_TYPE(bgpevpn)
@ -254,7 +254,7 @@ static inline void encode_default_gw_extcomm(struct ecommunity_val *eval)
eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_DEF_GW;
}
static inline void encode_mac_mobility_extcomm(int static_mac, u_int32_t seq,
static inline void encode_mac_mobility_extcomm(int static_mac, uint32_t seq,
struct ecommunity_val *eval)
{
memset(eval, 0, sizeof(*eval));

62
bgpd/bgp_evpn_vty.c
View file

@ -56,8 +56,8 @@ struct vni_walk_ctx {
static void display_vrf_import_rt(struct vty *vty, struct vrf_irt_node *irt,
json_object *json)
{
u_char *pnt;
u_char type, sub_type;
uint8_t *pnt;
uint8_t type, sub_type;
struct ecommunity_as eas;
struct ecommunity_ip eip;
struct listnode *node, *nnode;
@ -71,7 +71,7 @@ static void display_vrf_import_rt(struct vty *vty, struct vrf_irt_node *irt,
json_vrfs = json_object_new_array();
}
pnt = (u_char *)&irt->rt.val;
pnt = (uint8_t *)&irt->rt.val;
type = *pnt++;
sub_type = *pnt++;
if (sub_type != ECOMMUNITY_ROUTE_TARGET)
@ -164,8 +164,8 @@ static void show_vrf_import_rt_entry(struct hash_backet *backet, void *args[])
static void display_import_rt(struct vty *vty, struct irt_node *irt,
json_object *json)
{
u_char *pnt;
u_char type, sub_type;
uint8_t *pnt;
uint8_t type, sub_type;
struct ecommunity_as eas;
struct ecommunity_ip eip;
struct listnode *node, *nnode;
@ -181,7 +181,7 @@ static void display_import_rt(struct vty *vty, struct irt_node *irt,
/* TODO: This needs to go into a function */
pnt = (u_char *)&irt->rt.val;
pnt = (uint8_t *)&irt->rt.val;
type = *pnt++;
sub_type = *pnt++;
if (sub_type != ECOMMUNITY_ROUTE_TARGET)
@ -274,10 +274,10 @@ static void bgp_evpn_show_route_rd_header(struct vty *vty,
struct bgp_node *rd_rn,
json_object *json)
{
u_int16_t type;
uint16_t type;
struct rd_as rd_as;
struct rd_ip rd_ip;
u_char *pnt;
uint8_t *pnt;
char rd_str[RD_ADDRSTRLEN];
pnt = rd_rn->p.u.val;
@ -495,7 +495,7 @@ static void show_vni_routes(struct bgp *bgp, struct bgpevpn *vpn, int type,
struct bgp_node *rn;
struct bgp_info *ri;
int header = 1;
u_int32_t prefix_cnt, path_cnt;
uint32_t prefix_cnt, path_cnt;
prefix_cnt = path_cnt = 0;
@ -814,7 +814,7 @@ static void show_vni_entry(struct hash_backet *backet, void *args[])
static int bgp_show_ethernet_vpn(struct vty *vty, struct prefix_rd *prd,
enum bgp_show_type type, void *output_arg,
int option, u_char use_json)
int option, uint8_t use_json)
{
afi_t afi = AFI_L2VPN;
struct bgp *bgp;
@ -930,10 +930,10 @@ static int bgp_show_ethernet_vpn(struct vty *vty, struct prefix_rd *prd,
header = 0;
}
if (rd_header) {
u_int16_t type;
uint16_t type;
struct rd_as rd_as;
struct rd_ip rd_ip;
u_char *pnt;
uint8_t *pnt;
pnt = rn->p.u.val;
@ -1103,7 +1103,7 @@ DEFUN(show_ip_bgp_l2vpn_evpn_all_neighbor_routes,
union sockunion su;
struct peer *peer;
int ret;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
@ -1163,7 +1163,7 @@ DEFUN(show_ip_bgp_l2vpn_evpn_rd_neighbor_routes,
union sockunion su;
struct peer *peer;
struct prefix_rd prd;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
argv_find(argv, argc, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community);
argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
@ -1236,7 +1236,7 @@ DEFUN(show_ip_bgp_l2vpn_evpn_all_neighbor_advertised_routes,
int ret;
struct peer *peer;
union sockunion su;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
@ -1294,7 +1294,7 @@ DEFUN(show_ip_bgp_l2vpn_evpn_rd_neighbor_advertised_routes,
struct peer *peer;
struct prefix_rd prd;
union sockunion su;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
argv_find(argv, argc, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community);
argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
@ -1807,7 +1807,7 @@ static void evpn_show_import_rts(struct vty *vty, struct bgp *bgp,
static void evpn_show_routes_vni_all(struct vty *vty, struct bgp *bgp,
struct in_addr vtep_ip, json_object *json)
{
u_int32_t num_vnis;
uint32_t num_vnis;
struct vni_walk_ctx wctx;
num_vnis = hashcount(bgp->vnihash);
@ -1834,7 +1834,7 @@ static void evpn_show_route_vni_multicast(struct vty *vty, struct bgp *bgp,
struct prefix_evpn p;
struct bgp_node *rn;
struct bgp_info *ri;
u_int32_t path_cnt = 0;
uint32_t path_cnt = 0;
afi_t afi;
safi_t safi;
json_object *json_paths = NULL;
@ -1903,7 +1903,7 @@ static void evpn_show_route_vni_macip(struct vty *vty, struct bgp *bgp,
struct prefix_evpn p;
struct bgp_node *rn;
struct bgp_info *ri;
u_int32_t path_cnt = 0;
uint32_t path_cnt = 0;
afi_t afi;
safi_t safi;
json_object *json_paths = NULL;
@ -1998,7 +1998,7 @@ static void evpn_show_route_rd_macip(struct vty *vty, struct bgp *bgp,
struct bgp_info *ri;
afi_t afi;
safi_t safi;
u_int32_t path_cnt = 0;
uint32_t path_cnt = 0;
json_object *json_paths = NULL;
char prefix_str[BUFSIZ];
@ -2065,7 +2065,7 @@ static void evpn_show_route_rd(struct vty *vty, struct bgp *bgp,
int rd_header = 1;
afi_t afi;
safi_t safi;
u_int32_t prefix_cnt, path_cnt;
uint32_t prefix_cnt, path_cnt;
char rd_str[RD_ADDRSTRLEN];
json_object *json_rd = NULL;
int add_rd_to_json = 0;
@ -2187,7 +2187,7 @@ static void evpn_show_all_routes(struct vty *vty, struct bgp *bgp, int type,
int rd_header;
afi_t afi;
safi_t safi;
u_int32_t prefix_cnt, path_cnt;
uint32_t prefix_cnt, path_cnt;
afi = AFI_L2VPN;
safi = SAFI_EVPN;
@ -2313,7 +2313,7 @@ static void evpn_show_all_routes(struct vty *vty, struct bgp *bgp, int type,
static void evpn_show_vni(struct vty *vty, struct bgp *bgp, vni_t vni,
json_object *json)
{
u_char found = 0;
uint8_t found = 0;
struct bgpevpn *vpn;
vpn = bgp_evpn_lookup_vni(bgp, vni);
@ -2906,10 +2906,10 @@ DEFUN(show_bgp_l2vpn_evpn_vni,
struct bgp *bgp_def;
vni_t vni;
int idx = 0;
u_char uj = 0;
uint8_t uj = 0;
json_object *json = NULL;
u_int32_t num_l2vnis = 0;
u_int32_t num_l3vnis = 0;
uint32_t num_l2vnis = 0;
uint32_t num_l3vnis = 0;
uint32_t num_vnis = 0;
struct listnode *node = NULL;
struct bgp *bgp_temp = NULL;
@ -2992,7 +2992,7 @@ DEFUN(show_bgp_l2vpn_evpn_summary,
JSON_STR)
{
int idx_vrf = 0;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
char *vrf = NULL;
if (argv_find(argv, argc, "vrf", &idx_vrf))
@ -3020,7 +3020,7 @@ DEFUN(show_bgp_l2vpn_evpn_route,
struct bgp *bgp;
int type_idx = 0;
int type = 0;
u_char uj = 0;
uint8_t uj = 0;
json_object *json = NULL;
uj = use_json(argc, argv);
@ -3472,7 +3472,7 @@ DEFUN(show_bgp_l2vpn_evpn_vrf_import_rt,
"Show vrf import route target\n"
JSON_STR)
{
u_char uj = 0;
uint8_t uj = 0;
struct bgp *bgp_def = NULL;
json_object *json = NULL;
@ -3509,7 +3509,7 @@ DEFUN(show_bgp_l2vpn_evpn_import_rt,
JSON_STR)
{
struct bgp *bgp;
u_char uj = 0;
uint8_t uj = 0;
json_object *json = NULL;
bgp = bgp_get_default();
@ -3902,7 +3902,7 @@ DEFUN (show_bgp_vrf_l3vni_info,
json_object *json_vnis = NULL;
json_object *json_export_rts = NULL;
json_object *json_import_rts = NULL;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
if (uj) {
json = json_object_new_object();

11
bgpd/bgp_fsm.c
View file

@ -166,8 +166,8 @@ static struct peer *peer_xfer_conn(struct peer *from_peer)
zlog_err(
"[%s] Dropping pending packet on connection transfer:",
peer->host);
u_int16_t type = stream_getc_from(peer->curr,
BGP_MARKER_SIZE + 2);
uint16_t type = stream_getc_from(peer->curr,
BGP_MARKER_SIZE + 2);
bgp_dump_packet(peer, type, peer->curr);
stream_free(peer->curr);
peer->curr = NULL;
@ -763,8 +763,8 @@ int bgp_maxmed_onstartup_active(struct bgp *bgp)
void bgp_maxmed_update(struct bgp *bgp)
{
u_char maxmed_active;
u_int32_t maxmed_value;
uint8_t maxmed_active;
uint32_t maxmed_value;
if (bgp->v_maxmed_admin) {
maxmed_active = 1;
@ -1199,7 +1199,8 @@ static int bgp_stop_with_error(struct peer *peer)
/* something went wrong, send notify and tear down */
static int bgp_stop_with_notify(struct peer *peer, u_char code, u_char sub_code)
static int bgp_stop_with_notify(struct peer *peer, uint8_t code,
uint8_t sub_code)
{
/* Send notify to remote peer */
bgp_notify_send(peer, code, sub_code);

2
bgpd/bgp_io.c
View file

@ -281,7 +281,7 @@ static int bgp_process_reads(struct thread *thread)
*/
static uint16_t bgp_write(struct peer *peer)
{
u_char type;
uint8_t type;
struct stream *s;
int num;
int update_last_write = 0;

22
bgpd/bgp_label.c
View file

@ -48,7 +48,7 @@ int bgp_parse_fec_update(void)
struct bgp *bgp;
struct bgp_table *table;
struct prefix p;
u_int32_t label;
uint32_t label;
afi_t afi;
safi_t safi;
@ -124,7 +124,7 @@ void bgp_reg_dereg_for_label(struct bgp_node *rn, struct bgp_info *ri, int reg)
struct stream *s;
struct prefix *p;
int command;
u_int16_t flags = 0;
uint16_t flags = 0;
size_t flags_pos = 0;
/* Check socket. */
@ -164,13 +164,13 @@ void bgp_reg_dereg_for_label(struct bgp_node *rn, struct bgp_info *ri, int reg)
zclient_send_message(zclient);
}
static int bgp_nlri_get_labels(struct peer *peer, u_char *pnt, u_char plen,
static int bgp_nlri_get_labels(struct peer *peer, uint8_t *pnt, uint8_t plen,
mpls_label_t *label)
{
u_char *data = pnt;
u_char *lim = pnt + plen;
u_char llen = 0;
u_char label_depth = 0;
uint8_t *data = pnt;
uint8_t *lim = pnt + plen;
uint8_t llen = 0;
uint8_t label_depth = 0;
for (; data < lim; data += BGP_LABEL_BYTES) {
memcpy(label, data, BGP_LABEL_BYTES);
@ -200,17 +200,17 @@ static int bgp_nlri_get_labels(struct peer *peer, u_char *pnt, u_char plen,
int bgp_nlri_parse_label(struct peer *peer, struct attr *attr,
struct bgp_nlri *packet)
{
u_char *pnt;
u_char *lim;
uint8_t *pnt;
uint8_t *lim;
struct prefix p;
int psize = 0;
int prefixlen;
afi_t afi;
safi_t safi;
int addpath_encoded;
u_int32_t addpath_id;
uint32_t addpath_id;
mpls_label_t label = MPLS_INVALID_LABEL;
u_char llen;
uint8_t llen;
pnt = packet->nlri;
lim = pnt + packet->length;

20
bgpd/bgp_label.h
View file

@ -51,7 +51,7 @@ static inline int bgp_labeled_safi(safi_t safi)
static inline int bgp_is_withdraw_label(mpls_label_t *label)
{
u_char *pkt = (u_char *)label;
uint8_t *pkt = (uint8_t *)label;
/* The check on pkt[2] for 0x00 or 0x02 is in case bgp_set_valid_label()
* was called on the withdraw label */
@ -63,7 +63,7 @@ static inline int bgp_is_withdraw_label(mpls_label_t *label)
static inline int bgp_is_valid_label(mpls_label_t *label)
{
u_char *t = (u_char *)label;
uint8_t *t = (uint8_t *)label;
if (!t)
return 0;
return (t[2] & 0x02);
@ -71,14 +71,14 @@ static inline int bgp_is_valid_label(mpls_label_t *label)
static inline void bgp_set_valid_label(mpls_label_t *label)
{
u_char *t = (u_char *)label;
uint8_t *t = (uint8_t *)label;
if (t)
t[2] |= 0x02;
}
static inline void bgp_unset_valid_label(mpls_label_t *label)
{
u_char *t = (u_char *)label;
uint8_t *t = (uint8_t *)label;
if (t)
t[2] &= ~0x02;
}
@ -95,17 +95,17 @@ static inline void bgp_unregister_for_label(struct bgp_node *rn)
}
/* Label stream to value */
static inline u_int32_t label_pton(mpls_label_t *label)
static inline uint32_t label_pton(mpls_label_t *label)
{
u_char *t = (u_char *)label;
uint8_t *t = (uint8_t *)label;
return ((((unsigned int)t[0]) << 12) | (((unsigned int)t[1]) << 4)
| ((unsigned int)((t[2] & 0xF0) >> 4)));
}
/* Encode label values */
static inline void label_ntop(u_int32_t l, int bos, mpls_label_t *label)
static inline void label_ntop(uint32_t l, int bos, mpls_label_t *label)
{
u_char *t = (u_char *)label;
uint8_t *t = (uint8_t *)label;
t[0] = ((l & 0x000FF000) >> 12);
t[1] = ((l & 0x00000FF0) >> 4);
t[2] = ((l & 0x0000000F) << 4);
@ -114,9 +114,9 @@ static inline void label_ntop(u_int32_t l, int bos, mpls_label_t *label)
}
/* Return BOS value of label stream */
static inline u_char label_bos(mpls_label_t *label)
static inline uint8_t label_bos(mpls_label_t *label)
{
u_char *t = (u_char *)label;
uint8_t *t = (uint8_t *)label;
return (t[2] & 0x01);
};

20
bgpd/bgp_lcommunity.c
View file

@ -66,7 +66,7 @@ static void lcommunity_hash_free(struct lcommunity *lcom)
static int lcommunity_add_val(struct lcommunity *lcom,
struct lcommunity_val *lval)
{
u_int8_t *p;
uint8_t *p;
int ret;
int c;
@ -124,7 +124,7 @@ struct lcommunity *lcommunity_uniq_sort(struct lcommunity *lcom)
}
/* Parse Large Communites Attribute in BGP packet. */
struct lcommunity *lcommunity_parse(u_int8_t *pnt, u_short length)
struct lcommunity *lcommunity_parse(uint8_t *pnt, unsigned short length)
{
struct lcommunity tmp;
struct lcommunity *new;
@ -291,9 +291,9 @@ static const char *lcommunity_gettoken(const char *str,
if (isdigit((int)*p)) {
int separator = 0;
int digit = 0;
u_int32_t globaladmin = 0;
u_int32_t localdata1 = 0;
u_int32_t localdata2 = 0;
uint32_t globaladmin = 0;
uint32_t localdata1 = 0;
uint32_t localdata2 = 0;
while (isdigit((int)*p) || *p == ':') {
if (*p == ':') {
@ -375,10 +375,10 @@ struct lcommunity *lcommunity_str2com(const char *str)
return lcom;
}
int lcommunity_include(struct lcommunity *lcom, u_char *ptr)
int lcommunity_include(struct lcommunity *lcom, uint8_t *ptr)
{
int i;
u_char *lcom_ptr;
uint8_t *lcom_ptr;
for (i = 0; i < lcom->size; i++) {
lcom_ptr = lcom->val + (i * LCOMMUNITY_SIZE);
@ -394,14 +394,14 @@ int lcommunity_include(struct lcommunity *lcom, u_char *ptr)
char *lcommunity_lcom2str(struct lcommunity *lcom, int format)
{
int i;
u_int8_t *pnt;
uint8_t *pnt;
#define LCOMMUNITY_STR_DEFAULT_LEN 40
int str_size;
int str_pnt;
char *str_buf;
int len = 0;
int first = 1;
u_int32_t globaladmin, localdata1, localdata2;
uint32_t globaladmin, localdata1, localdata2;
if (lcom->size == 0) {
str_buf = XMALLOC(MTYPE_LCOMMUNITY_STR, 1);
@ -472,7 +472,7 @@ int lcommunity_match(const struct lcommunity *lcom1,
}
/* Delete one lcommunity. */
void lcommunity_del_val(struct lcommunity *lcom, u_char *ptr)
void lcommunity_del_val(struct lcommunity *lcom, uint8_t *ptr)
{
int i = 0;
int c = 0;

8
bgpd/bgp_lcommunity.h
View file

@ -38,7 +38,7 @@ struct lcommunity {
int size;
/* Large Communities value. */
u_int8_t *val;
uint8_t *val;
/* Human readable format string. */
char *str;
@ -54,7 +54,7 @@ struct lcommunity_val {
extern void lcommunity_init(void);
extern void lcommunity_finish(void);
extern void lcommunity_free(struct lcommunity **);
extern struct lcommunity *lcommunity_parse(u_int8_t *, u_short);
extern struct lcommunity *lcommunity_parse(uint8_t *, unsigned short);
extern struct lcommunity *lcommunity_dup(struct lcommunity *);
extern struct lcommunity *lcommunity_merge(struct lcommunity *,
struct lcommunity *);
@ -69,6 +69,6 @@ extern char *lcommunity_lcom2str(struct lcommunity *, int);
extern int lcommunity_match(const struct lcommunity *,
const struct lcommunity *);
extern char *lcommunity_str(struct lcommunity *);
extern int lcommunity_include(struct lcommunity *lcom, u_char *ptr);
extern void lcommunity_del_val(struct lcommunity *lcom, u_char *ptr);
extern int lcommunity_include(struct lcommunity *lcom, uint8_t *ptr);
extern void lcommunity_del_val(struct lcommunity *lcom, uint8_t *ptr);
#endif /* _QUAGGA_BGP_LCOMMUNITY_H */

10
bgpd/bgp_mpath.c
View file

@ -46,7 +46,7 @@
* Record maximum-paths configuration for BGP instance
*/
int bgp_maximum_paths_set(struct bgp *bgp, afi_t afi, safi_t safi, int peertype,
u_int16_t maxpaths, u_int16_t options)
uint16_t maxpaths, uint16_t options)
{
if (!bgp || (afi >= AFI_MAX) || (safi >= SAFI_MAX))
return -1;
@ -370,7 +370,7 @@ struct bgp_info *bgp_info_mpath_first(struct bgp_info *binfo)
*
* Given the bestpath bgp_info, return the number of multipath entries
*/
u_int32_t bgp_info_mpath_count(struct bgp_info *binfo)
uint32_t bgp_info_mpath_count(struct bgp_info *binfo)
{
if (!binfo->mpath)
return 0;
@ -382,7 +382,7 @@ u_int32_t bgp_info_mpath_count(struct bgp_info *binfo)
*
* Sets the count of multipaths into bestpath's mpath element
*/
static void bgp_info_mpath_count_set(struct bgp_info *binfo, u_int32_t count)
static void bgp_info_mpath_count_set(struct bgp_info *binfo, uint32_t count)
{
struct bgp_info_mpath *mpath;
if (!count && !binfo->mpath)
@ -432,7 +432,7 @@ void bgp_info_mpath_update(struct bgp_node *rn, struct bgp_info *new_best,
struct bgp_info *old_best, struct list *mp_list,
struct bgp_maxpaths_cfg *mpath_cfg)
{
u_int16_t maxpaths, mpath_count, old_mpath_count;
uint16_t maxpaths, mpath_count, old_mpath_count;
struct listnode *mp_node, *mp_next_node;
struct bgp_info *cur_mpath, *new_mpath, *next_mpath, *prev_mpath;
int mpath_changed, debug;
@ -677,7 +677,7 @@ void bgp_info_mpath_aggregate_update(struct bgp_info *new_best,
struct aspath *aspath;
struct aspath *asmerge;
struct attr *new_attr, *old_attr;
u_char origin;
uint8_t origin;
struct community *community, *commerge;
struct ecommunity *ecomm, *ecommerge;
struct lcommunity *lcomm, *lcommerge;

8
bgpd/bgp_mpath.h
View file

@ -36,15 +36,15 @@ struct bgp_info_mpath {
struct bgp_info *mp_info;
/* When attached to best path, the number of selected multipaths */
u_int32_t mp_count;
uint32_t mp_count;
/* Aggregated attribute for advertising multipath route */
struct attr *mp_attr;
};
/* Functions to support maximum-paths configuration */
extern int bgp_maximum_paths_set(struct bgp *, afi_t, safi_t, int, u_int16_t,
u_int16_t);
extern int bgp_maximum_paths_set(struct bgp *, afi_t, safi_t, int, uint16_t,
uint16_t);
extern int bgp_maximum_paths_unset(struct bgp *, afi_t, safi_t, int);
/* Functions used by bgp_best_selection to record current
@ -70,7 +70,7 @@ extern struct bgp_info *bgp_info_mpath_first(struct bgp_info *);
extern struct bgp_info *bgp_info_mpath_next(struct bgp_info *);
/* Accessors for multipath information */
extern u_int32_t bgp_info_mpath_count(struct bgp_info *);
extern uint32_t bgp_info_mpath_count(struct bgp_info *);
extern struct attr *bgp_info_mpath_attr(struct bgp_info *);
#endif /* _QUAGGA_BGP_MPATH_H */

36
bgpd/bgp_mplsvpn.c
View file

@ -70,20 +70,20 @@ extern int argv_find_and_parse_vpnvx(struct cmd_token **argv, int argc,
return ret;
}
u_int32_t decode_label(mpls_label_t *label_pnt)
uint32_t decode_label(mpls_label_t *label_pnt)
{
u_int32_t l;
u_char *pnt = (u_char *)label_pnt;
uint32_t l;
uint8_t *pnt = (uint8_t *)label_pnt;
l = ((u_int32_t)*pnt++ << 12);
l |= (u_int32_t)*pnt++ << 4;
l |= (u_int32_t)((*pnt & 0xf0) >> 4);
l = ((uint32_t)*pnt++ << 12);
l |= (uint32_t)*pnt++ << 4;
l |= (uint32_t)((*pnt & 0xf0) >> 4);
return l;
}
void encode_label(mpls_label_t label, mpls_label_t *label_pnt)
{
u_char *pnt = (u_char *)label_pnt;
uint8_t *pnt = (uint8_t *)label_pnt;
if (pnt == NULL)
return;
*pnt++ = (label >> 12) & 0xff;
@ -94,12 +94,12 @@ void encode_label(mpls_label_t label, mpls_label_t *label_pnt)
int bgp_nlri_parse_vpn(struct peer *peer, struct attr *attr,
struct bgp_nlri *packet)
{
u_char *pnt;
u_char *lim;
uint8_t *pnt;
uint8_t *lim;
struct prefix p;
int psize = 0;
int prefixlen;
u_int16_t type;
uint16_t type;
struct rd_as rd_as;
struct rd_ip rd_ip;
struct prefix_rd prd;
@ -107,7 +107,7 @@ int bgp_nlri_parse_vpn(struct peer *peer, struct attr *attr,
afi_t afi;
safi_t safi;
int addpath_encoded;
u_int32_t addpath_id;
uint32_t addpath_id;
/* Make prefix_rd */
prd.family = AF_UNSPEC;
@ -340,8 +340,8 @@ static int ecom_intersect(struct ecommunity *e1, struct ecommunity *e2)
static struct bgp_info *
leak_update(struct bgp *bgp, /* destination bgp instance */
struct bgp_node *bn, struct attr *new_attr, /* already interned */
afi_t afi, safi_t safi, struct bgp_info *source_bi, u_char type,
u_char sub_type, mpls_label_t *label, int num_labels, void *parent,
afi_t afi, safi_t safi, struct bgp_info *source_bi, uint8_t type,
uint8_t sub_type, mpls_label_t *label, int num_labels, void *parent,
struct bgp *bgp_orig, struct prefix *nexthop_orig, int debug)
{
struct prefix *p = &bn->p;
@ -1307,7 +1307,7 @@ DEFUN (no_vpnv6_network,
int bgp_show_mpls_vpn(struct vty *vty, afi_t afi, struct prefix_rd *prd,
enum bgp_show_type type, void *output_arg, int tags,
u_char use_json)
uint8_t use_json)
{
struct bgp *bgp;
struct bgp_table *table;
@ -1485,7 +1485,7 @@ DEFUN (show_ip_bgp_vpn_all_neighbor_routes,
union sockunion su;
struct peer *peer;
int ret;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
afi_t afi;
int idx = 0;
@ -1549,7 +1549,7 @@ DEFUN (show_ip_bgp_vpn_rd_neighbor_routes,
union sockunion su;
struct peer *peer;
struct prefix_rd prd;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
afi_t afi;
int idx = 0;
@ -1627,7 +1627,7 @@ DEFUN (show_ip_bgp_vpn_all_neighbor_advertised_routes,
int ret;
struct peer *peer;
union sockunion su;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
afi_t afi;
int idx = 0;
@ -1689,7 +1689,7 @@ DEFUN (show_ip_bgp_vpn_rd_neighbor_advertised_routes,
struct peer *peer;
struct prefix_rd prd;
union sockunion su;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
afi_t afi;
int idx = 0;

4
bgpd/bgp_mplsvpn.h
View file

@ -43,14 +43,14 @@
extern void bgp_mplsvpn_init(void);
extern int bgp_nlri_parse_vpn(struct peer *, struct attr *, struct bgp_nlri *);
extern u_int32_t decode_label(mpls_label_t *);
extern uint32_t decode_label(mpls_label_t *);
extern void encode_label(mpls_label_t, mpls_label_t *);
extern int argv_find_and_parse_vpnvx(struct cmd_token **argv, int argc,
int *index, afi_t *afi);
extern int bgp_show_mpls_vpn(struct vty *vty, afi_t afi, struct prefix_rd *prd,
enum bgp_show_type type, void *output_arg,
int tags, u_char use_json);
int tags, uint8_t use_json);
extern void vpn_leak_from_vrf_update(struct bgp *bgp_vpn, struct bgp *bgp_vrf,
struct bgp_info *info_vrf);

8
bgpd/bgp_nexthop.h
View file

@ -38,13 +38,13 @@
/* BGP nexthop cache value structure. */
struct bgp_nexthop_cache {
/* IGP route's metric. */
u_int32_t metric;
uint32_t metric;
/* Nexthop number and nexthop linked list.*/
u_char nexthop_num;
uint8_t nexthop_num;
struct nexthop *nexthop;
time_t last_update;
u_int16_t flags;
uint16_t flags;
#define BGP_NEXTHOP_VALID (1 << 0)
#define BGP_NEXTHOP_REGISTERED (1 << 1)
@ -53,7 +53,7 @@ struct bgp_nexthop_cache {
#define BGP_STATIC_ROUTE (1 << 4)
#define BGP_STATIC_ROUTE_EXACT_MATCH (1 << 5)
u_int16_t change_flags;
uint16_t change_flags;
#define BGP_NEXTHOP_CHANGED (1 << 0)
#define BGP_NEXTHOP_METRIC_CHANGED (1 << 1)

58
bgpd/bgp_open.c
View file

@ -51,8 +51,8 @@
Next, if we send capability to the peer we want to set my capabilty
inforation at each peer. */
void bgp_capability_vty_out(struct vty *vty, struct peer *peer, u_char use_json,
json_object *json_neigh)
void bgp_capability_vty_out(struct vty *vty, struct peer *peer,
uint8_t use_json, json_object *json_neigh)
{
char *pnt;
char *end;
@ -271,8 +271,8 @@ static int bgp_capability_mp(struct peer *peer, struct capability_header *hdr)
}
static void bgp_capability_orf_not_support(struct peer *peer, iana_afi_t afi,
iana_safi_t safi, u_char type,
u_char mode)
iana_safi_t safi, uint8_t type,
uint8_t mode)
{
if (bgp_debug_neighbor_events(peer))
zlog_debug(
@ -295,15 +295,15 @@ static int bgp_capability_orf_entry(struct peer *peer,
{
struct stream *s = BGP_INPUT(peer);
struct capability_mp_data mpc;
u_char num;
uint8_t num;
iana_afi_t pkt_afi;
afi_t afi;
iana_safi_t pkt_safi;
safi_t safi;
u_char type;
u_char mode;
u_int16_t sm_cap = 0; /* capability send-mode receive */
u_int16_t rm_cap = 0; /* capability receive-mode receive */
uint8_t type;
uint8_t mode;
uint16_t sm_cap = 0; /* capability send-mode receive */
uint16_t rm_cap = 0; /* capability receive-mode receive */
int i;
/* ORF Entry header */
@ -433,7 +433,7 @@ static int bgp_capability_restart(struct peer *peer,
struct capability_header *caphdr)
{
struct stream *s = BGP_INPUT(peer);
u_int16_t restart_flag_time;
uint16_t restart_flag_time;
size_t end = stream_get_getp(s) + caphdr->length;
/* Verify length is a multiple of 4 */
@ -468,7 +468,7 @@ static int bgp_capability_restart(struct peer *peer,
safi_t safi;
iana_afi_t pkt_afi = stream_getw(s);
iana_safi_t pkt_safi = stream_getc(s);
u_char flag = stream_getc(s);
uint8_t flag = stream_getc(s);
/* Convert AFI, SAFI to internal values, check. */
if (bgp_map_afi_safi_iana2int(pkt_afi, pkt_safi, &afi, &safi)) {
@ -545,7 +545,7 @@ static int bgp_capability_addpath(struct peer *peer,
safi_t safi;
iana_afi_t pkt_afi = stream_getw(s);
iana_safi_t pkt_safi = stream_getc(s);
u_char send_receive = stream_getc(s);
uint8_t send_receive = stream_getc(s);
if (bgp_debug_neighbor_events(peer))
zlog_debug(
@ -659,7 +659,7 @@ static int bgp_capability_hostname(struct peer *peer,
struct stream *s = BGP_INPUT(peer);
char str[BGP_MAX_HOSTNAME + 1];
size_t end = stream_get_getp(s) + hdr->length;
u_char len;
uint8_t len;
SET_FLAG(peer->cap, PEER_CAP_HOSTNAME_RCV);
@ -788,7 +788,7 @@ static const size_t cap_modsizes[] = {
* capabilities were encountered.
*/
static int bgp_capability_parse(struct peer *peer, size_t length,
int *mp_capability, u_char **error)
int *mp_capability, uint8_t **error)
{
int ret;
struct stream *s = BGP_INPUT(peer);
@ -798,7 +798,7 @@ static int bgp_capability_parse(struct peer *peer, size_t length,
while (stream_get_getp(s) < end) {
size_t start;
u_char *sp = stream_pnt(s);
uint8_t *sp = stream_pnt(s);
struct capability_header caphdr;
ret = 0;
@ -991,7 +991,7 @@ static int strict_capability_same(struct peer *peer)
/* peek into option, stores ASN to *as4 if the AS4 capability was found.
* Returns 0 if no as4 found, as4cap value otherwise.
*/
as_t peek_for_as4_capability(struct peer *peer, u_char length)
as_t peek_for_as4_capability(struct peer *peer, uint8_t length)
{
struct stream *s = BGP_INPUT(peer);
size_t orig_getp = stream_get_getp(s);
@ -1007,8 +1007,8 @@ as_t peek_for_as4_capability(struct peer *peer, u_char length)
* correctly formatted options.
*/
while (stream_get_getp(s) < end) {
u_char opt_type;
u_char opt_length;
uint8_t opt_type;
uint8_t opt_length;
/* Check the length. */
if (stream_get_getp(s) + 2 > end)
@ -1064,11 +1064,11 @@ end:
*
* @param[out] mp_capability @see bgp_capability_parse() for semantics.
*/
int bgp_open_option_parse(struct peer *peer, u_char length, int *mp_capability)
int bgp_open_option_parse(struct peer *peer, uint8_t length, int *mp_capability)
{
int ret = 0;
u_char *error;
u_char error_data[BGP_MAX_PACKET_SIZE];
uint8_t *error;
uint8_t error_data[BGP_MAX_PACKET_SIZE];
struct stream *s = BGP_INPUT(peer);
size_t end = stream_get_getp(s) + length;
@ -1079,8 +1079,8 @@ int bgp_open_option_parse(struct peer *peer, u_char length, int *mp_capability)
peer->host, length);
while (stream_get_getp(s) < end) {
u_char opt_type;
u_char opt_length;
uint8_t opt_type;
uint8_t opt_length;
/* Must have at least an OPEN option header */
if (STREAM_READABLE(s) < 2) {
@ -1192,10 +1192,10 @@ int bgp_open_option_parse(struct peer *peer, u_char length, int *mp_capability)
}
static void bgp_open_capability_orf(struct stream *s, struct peer *peer,
afi_t afi, safi_t safi, u_char code)
afi_t afi, safi_t safi, uint8_t code)
{
u_char cap_len;
u_char orf_len;
uint8_t cap_len;
uint8_t orf_len;
unsigned long capp;
unsigned long orfp;
unsigned long numberp;
@ -1262,15 +1262,15 @@ static void bgp_open_capability_orf(struct stream *s, struct peer *peer,
/* Fill in capability open option to the packet. */
void bgp_open_capability(struct stream *s, struct peer *peer)
{
u_char len;
uint8_t len;
unsigned long cp, capp, rcapp;
iana_afi_t pkt_afi;
afi_t afi;
safi_t safi;
iana_safi_t pkt_safi;
as_t local_as;
u_int32_t restart_time;
u_char afi_safi_count = 0;
uint32_t restart_time;
uint8_t afi_safi_count = 0;
int adv_addpath_tx = 0;
/* Remember current pointer for Opt Parm Len. */

16
bgpd/bgp_open.h
View file

@ -23,14 +23,14 @@
/* Standard header for capability TLV */
struct capability_header {
u_char code;
u_char length;
uint8_t code;
uint8_t length;
};
/* Generic MP capability data */
struct capability_mp_data {
uint16_t afi; /* iana_afi_t */
u_char reserved;
uint8_t reserved;
uint8_t safi; /* iana_safi_t */
};
@ -41,11 +41,11 @@ struct capability_as4 {
struct graceful_restart_af {
afi_t afi;
safi_t safi;
u_char flag;
uint8_t flag;
};
struct capability_gr {
u_int16_t restart_flag_time;
uint16_t restart_flag_time;
struct graceful_restart_af gr[];
};
@ -93,10 +93,10 @@ struct capability_gr {
#define RESTART_R_BIT 0x8000
#define RESTART_F_BIT 0x80
extern int bgp_open_option_parse(struct peer *, u_char, int *);
extern int bgp_open_option_parse(struct peer *, uint8_t, int *);
extern void bgp_open_capability(struct stream *, struct peer *);
extern void bgp_capability_vty_out(struct vty *, struct peer *, u_char,
extern void bgp_capability_vty_out(struct vty *, struct peer *, uint8_t,
json_object *);
extern as_t peek_for_as4_capability(struct peer *, u_char);
extern as_t peek_for_as4_capability(struct peer *, uint8_t);
#endif /* _QUAGGA_BGP_OPEN_H */

80
bgpd/bgp_packet.c
View file

@ -67,7 +67,7 @@
* @param type the packet type
* @return the size of the stream
*/
int bgp_packet_set_marker(struct stream *s, u_char type)
int bgp_packet_set_marker(struct stream *s, uint8_t type)
{
int i;
@ -497,7 +497,7 @@ void bgp_keepalive_send(struct peer *peer)
void bgp_open_send(struct peer *peer)
{
struct stream *s;
u_int16_t send_holdtime;
uint16_t send_holdtime;
as_t local_as;
if (PEER_OR_GROUP_TIMER_SET(peer))
@ -518,9 +518,8 @@ void bgp_open_send(struct peer *peer)
/* Set open packet values. */
stream_putc(s, BGP_VERSION_4); /* BGP version */
stream_putw(s,
(local_as <= BGP_AS_MAX) ? (u_int16_t)local_as
: BGP_AS_TRANS);
stream_putw(s, (local_as <= BGP_AS_MAX) ? (uint16_t)local_as
: BGP_AS_TRANS);
stream_putw(s, send_holdtime); /* Hold Time */
stream_put_in_addr(s, &peer->local_id); /* BGP Identifier */
@ -560,7 +559,7 @@ void bgp_open_send(struct peer *peer)
static int bgp_write_notify(struct peer *peer)
{
int ret, val;
u_char type;
uint8_t type;
struct stream *s;
/* There should be at least one packet. */
@ -643,8 +642,8 @@ static int bgp_write_notify(struct peer *peer)
* @param data Data portion
* @param datalen length of data portion
*/
void bgp_notify_send_with_data(struct peer *peer, u_char code, u_char sub_code,
u_char *data, size_t datalen)
void bgp_notify_send_with_data(struct peer *peer, uint8_t code,
uint8_t sub_code, uint8_t *data, size_t datalen)
{
struct stream *s;
int length;
@ -753,7 +752,7 @@ void bgp_notify_send_with_data(struct peer *peer, u_char code, u_char sub_code,
* @param code BGP error code
* @param sub_code BGP error subcode
*/
void bgp_notify_send(struct peer *peer, u_char code, u_char sub_code)
void bgp_notify_send(struct peer *peer, uint8_t code, uint8_t sub_code)
{
bgp_notify_send_with_data(peer, code, sub_code, NULL, 0);
}
@ -769,7 +768,8 @@ void bgp_notify_send(struct peer *peer, u_char code, u_char sub_code)
* @param remove Whether to remove ORF for specified AFI/SAFI
*/
void bgp_route_refresh_send(struct peer *peer, afi_t afi, safi_t safi,
u_char orf_type, u_char when_to_refresh, int remove)
uint8_t orf_type, uint8_t when_to_refresh,
int remove)
{
struct stream *s;
struct bgp_filter *filter;
@ -800,7 +800,7 @@ void bgp_route_refresh_send(struct peer *peer, afi_t afi, safi_t safi,
if (orf_type == ORF_TYPE_PREFIX || orf_type == ORF_TYPE_PREFIX_OLD)
if (remove || filter->plist[FILTER_IN].plist) {
u_int16_t orf_len;
uint16_t orf_len;
unsigned long orfp;
orf_refresh = 1;
@ -1033,24 +1033,24 @@ static int bgp_collision_detect(struct peer *new, struct in_addr remote_id)
static int bgp_open_receive(struct peer *peer, bgp_size_t size)
{
int ret;
u_char version;
u_char optlen;
u_int16_t holdtime;
u_int16_t send_holdtime;
uint8_t version;
uint8_t optlen;
uint16_t holdtime;
uint16_t send_holdtime;
as_t remote_as;
as_t as4 = 0;
struct in_addr remote_id;
int mp_capability;
u_int8_t notify_data_remote_as[2];
u_int8_t notify_data_remote_as4[4];
u_int8_t notify_data_remote_id[4];
u_int16_t *holdtime_ptr;
uint8_t notify_data_remote_as[2];
uint8_t notify_data_remote_as4[4];
uint8_t notify_data_remote_id[4];
uint16_t *holdtime_ptr;
/* Parse open packet. */
version = stream_getc(peer->curr);
memcpy(notify_data_remote_as, stream_pnt(peer->curr), 2);
remote_as = stream_getw(peer->curr);
holdtime_ptr = (u_int16_t *)stream_pnt(peer->curr);
holdtime_ptr = (uint16_t *)stream_pnt(peer->curr);
holdtime = stream_getw(peer->curr);
memcpy(notify_data_remote_id, stream_pnt(peer->curr), 4);
remote_id.s_addr = stream_get_ipv4(peer->curr);
@ -1158,7 +1158,7 @@ static int bgp_open_receive(struct peer *peer, bgp_size_t size)
/* Peer BGP version check. */
if (version != BGP_VERSION_4) {
u_int16_t maxver = htons(BGP_VERSION_4);
uint16_t maxver = htons(BGP_VERSION_4);
/* XXX this reply may not be correct if version < 4 XXX */
if (bgp_debug_neighbor_events(peer))
zlog_debug(
@ -1167,7 +1167,7 @@ static int bgp_open_receive(struct peer *peer, bgp_size_t size)
/* Data must be in network byte order here */
bgp_notify_send_with_data(peer, BGP_NOTIFY_OPEN_ERR,
BGP_NOTIFY_OPEN_UNSUP_VERSION,
(u_int8_t *)&maxver, 2);
(uint8_t *)&maxver, 2);
return BGP_Stop;
}
@ -1225,7 +1225,7 @@ static int bgp_open_receive(struct peer *peer, bgp_size_t size)
if (holdtime < 3 && holdtime != 0) {
bgp_notify_send_with_data(peer, BGP_NOTIFY_OPEN_ERR,
BGP_NOTIFY_OPEN_UNACEP_HOLDTIME,
(u_char *)holdtime_ptr, 2);
(uint8_t *)holdtime_ptr, 2);
return BGP_Stop;
}
@ -1367,7 +1367,7 @@ static int bgp_keepalive_receive(struct peer *peer, bgp_size_t size)
static int bgp_update_receive(struct peer *peer, bgp_size_t size)
{
int ret, nlri_ret;
u_char *end;
uint8_t *end;
struct stream *s;
struct attr attr;
bgp_size_t attribute_len;
@ -1680,7 +1680,7 @@ static int bgp_notify_receive(struct peer *peer, bgp_size_t size)
stream_getc(peer->curr));
strcpy(bgp_notify.data, c);
}
bgp_notify.raw_data = (u_char *)peer->notify.data;
bgp_notify.raw_data = (uint8_t *)peer->notify.data;
}
bgp_notify_print(peer, &bgp_notify, "received");
@ -1764,10 +1764,10 @@ static int bgp_route_refresh_receive(struct peer *peer, bgp_size_t size)
}
if (size != BGP_MSG_ROUTE_REFRESH_MIN_SIZE - BGP_HEADER_SIZE) {
u_char *end;
u_char when_to_refresh;
u_char orf_type;
u_int16_t orf_len;
uint8_t *end;
uint8_t when_to_refresh;
uint8_t orf_type;
uint16_t orf_len;
if (size - (BGP_MSG_ROUTE_REFRESH_MIN_SIZE - BGP_HEADER_SIZE)
< 5) {
@ -1792,8 +1792,8 @@ static int bgp_route_refresh_receive(struct peer *peer, bgp_size_t size)
uint8_t *p_pnt = stream_pnt(s);
uint8_t *p_end = stream_pnt(s) + orf_len;
struct orf_prefix orfp;
u_char common = 0;
u_int32_t seq;
uint8_t common = 0;
uint32_t seq;
int psize;
char name[BUFSIZ];
int ret = CMD_SUCCESS;
@ -1839,12 +1839,12 @@ static int bgp_route_refresh_receive(struct peer *peer, bgp_size_t size)
name);
break;
}
ok = ((u_int32_t)(p_end - p_pnt)
>= sizeof(u_int32_t));
ok = ((uint32_t)(p_end - p_pnt)
>= sizeof(uint32_t));
if (ok) {
memcpy(&seq, p_pnt,
sizeof(u_int32_t));
p_pnt += sizeof(u_int32_t);
sizeof(uint32_t));
p_pnt += sizeof(uint32_t);
orfp.seq = ntohl(seq);
} else
p_pnt = p_end;
@ -1988,13 +1988,13 @@ static int bgp_route_refresh_receive(struct peer *peer, bgp_size_t size)
* @param size size of the packet
* @return as in summary
*/
static int bgp_capability_msg_parse(struct peer *peer, u_char *pnt,
static int bgp_capability_msg_parse(struct peer *peer, uint8_t *pnt,
bgp_size_t length)
{
u_char *end;
uint8_t *end;
struct capability_mp_data mpc;
struct capability_header *hdr;
u_char action;
uint8_t action;
iana_afi_t pkt_afi;
afi_t afi;
iana_safi_t pkt_safi;
@ -2106,7 +2106,7 @@ static int bgp_capability_msg_parse(struct peer *peer, u_char *pnt,
*/
int bgp_capability_receive(struct peer *peer, bgp_size_t size)
{
u_char *pnt;
uint8_t *pnt;
/* Fetch pointer. */
pnt = stream_pnt(peer->curr);
@ -2171,7 +2171,7 @@ int bgp_process_packet(struct thread *thread)
unsigned int processed = 0;
while (processed < rpkt_quanta_old) {
u_char type = 0;
uint8_t type = 0;
bgp_size_t size;
char notify_data_length[2];

12
bgpd/bgp_packet.h
View file

@ -39,11 +39,11 @@
/* Packet send and receive function prototypes. */
extern void bgp_keepalive_send(struct peer *);
extern void bgp_open_send(struct peer *);
extern void bgp_notify_send(struct peer *, u_int8_t, u_int8_t);
extern void bgp_notify_send_with_data(struct peer *, u_int8_t, u_int8_t,
u_int8_t *, size_t);
extern void bgp_route_refresh_send(struct peer *, afi_t, safi_t, u_char, u_char,
int);
extern void bgp_notify_send(struct peer *, uint8_t, uint8_t);
extern void bgp_notify_send_with_data(struct peer *, uint8_t, uint8_t,
uint8_t *, size_t);
extern void bgp_route_refresh_send(struct peer *, afi_t, safi_t, uint8_t,
uint8_t, int);
extern void bgp_capability_send(struct peer *, afi_t, safi_t, int, int);
extern void bgp_default_update_send(struct peer *, struct attr *, afi_t, safi_t,
struct peer *);
@ -58,7 +58,7 @@ extern void bgp_update_restarted_peers(struct peer *);
extern void bgp_update_implicit_eors(struct peer *);
extern void bgp_check_update_delay(struct bgp *);
extern int bgp_packet_set_marker(struct stream *s, u_char type);
extern int bgp_packet_set_marker(struct stream *s, uint8_t type);
extern int bgp_packet_set_size(struct stream *s);
extern int bgp_generate_updgrp_packets(struct thread *);

38
bgpd/bgp_rd.c
View file

@ -36,57 +36,57 @@
#include "bgpd/rfapi/rfapi_backend.h"
#endif
u_int16_t decode_rd_type(u_char *pnt)
uint16_t decode_rd_type(uint8_t *pnt)
{
u_int16_t v;
uint16_t v;
v = ((u_int16_t)*pnt++ << 8);
v = ((uint16_t)*pnt++ << 8);
#if ENABLE_BGP_VNC
/*
* VNC L2 stores LHI in lower byte, so omit it
*/
if (v != RD_TYPE_VNC_ETH)
v |= (u_int16_t)*pnt;
v |= (uint16_t)*pnt;
#else /* duplicate code for clarity */
v |= (u_int16_t)*pnt;
v |= (uint16_t)*pnt;
#endif
return v;
}
void encode_rd_type(u_int16_t v, u_char *pnt)
void encode_rd_type(uint16_t v, uint8_t *pnt)
{
*((u_int16_t *)pnt) = htons(v);
*((uint16_t *)pnt) = htons(v);
}
/* type == RD_TYPE_AS */
void decode_rd_as(u_char *pnt, struct rd_as *rd_as)
void decode_rd_as(uint8_t *pnt, struct rd_as *rd_as)
{
rd_as->as = (u_int16_t)*pnt++ << 8;
rd_as->as |= (u_int16_t)*pnt++;
rd_as->as = (uint16_t)*pnt++ << 8;
rd_as->as |= (uint16_t)*pnt++;
ptr_get_be32(pnt, &rd_as->val);
}
/* type == RD_TYPE_AS4 */
void decode_rd_as4(u_char *pnt, struct rd_as *rd_as)
void decode_rd_as4(uint8_t *pnt, struct rd_as *rd_as)
{
pnt = ptr_get_be32(pnt, &rd_as->as);
rd_as->val = ((u_int16_t)*pnt++ << 8);
rd_as->val |= (u_int16_t)*pnt;
rd_as->val = ((uint16_t)*pnt++ << 8);
rd_as->val |= (uint16_t)*pnt;
}
/* type == RD_TYPE_IP */
void decode_rd_ip(u_char *pnt, struct rd_ip *rd_ip)
void decode_rd_ip(uint8_t *pnt, struct rd_ip *rd_ip)
{
memcpy(&rd_ip->ip, pnt, 4);
pnt += 4;
rd_ip->val = ((u_int16_t)*pnt++ << 8);
rd_ip->val |= (u_int16_t)*pnt;
rd_ip->val = ((uint16_t)*pnt++ << 8);
rd_ip->val |= (uint16_t)*pnt;
}
#if ENABLE_BGP_VNC
/* type == RD_TYPE_VNC_ETH */
void decode_rd_vnc_eth(u_char *pnt, struct rd_vnc_eth *rd_vnc_eth)
void decode_rd_vnc_eth(uint8_t *pnt, struct rd_vnc_eth *rd_vnc_eth)
{
rd_vnc_eth->type = RD_TYPE_VNC_ETH;
rd_vnc_eth->local_nve_id = pnt[1];
@ -161,8 +161,8 @@ out:
char *prefix_rd2str(struct prefix_rd *prd, char *buf, size_t size)
{
u_char *pnt;
u_int16_t type;
uint8_t *pnt;
uint16_t type;
struct rd_as rd_as;
struct rd_ip rd_ip;

22
bgpd/bgp_rd.h
View file

@ -35,33 +35,33 @@
#define RD_ADDRSTRLEN 28
struct rd_as {
u_int16_t type;
uint16_t type;
as_t as;
u_int32_t val;
uint32_t val;
};
struct rd_ip {
u_int16_t type;
uint16_t type;
struct in_addr ip;
u_int16_t val;
uint16_t val;
};
#if ENABLE_BGP_VNC
struct rd_vnc_eth {
u_int16_t type;
uint16_t type;
uint8_t local_nve_id;
struct ethaddr macaddr;
};
#endif
extern u_int16_t decode_rd_type(u_char *pnt);
extern void encode_rd_type(u_int16_t, u_char *);
extern uint16_t decode_rd_type(uint8_t *pnt);
extern void encode_rd_type(uint16_t, uint8_t *);
extern void decode_rd_as(u_char *pnt, struct rd_as *rd_as);
extern void decode_rd_as4(u_char *pnt, struct rd_as *rd_as);
extern void decode_rd_ip(u_char *pnt, struct rd_ip *rd_ip);
extern void decode_rd_as(uint8_t *pnt, struct rd_as *rd_as);
extern void decode_rd_as4(uint8_t *pnt, struct rd_as *rd_as);
extern void decode_rd_ip(uint8_t *pnt, struct rd_ip *rd_ip);
#if ENABLE_BGP_VNC
extern void decode_rd_vnc_eth(u_char *pnt, struct rd_vnc_eth *rd_vnc_eth);
extern void decode_rd_vnc_eth(uint8_t *pnt, struct rd_vnc_eth *rd_vnc_eth);
#endif
extern int str2prefix_rd(const char *, struct prefix_rd *);

132
bgpd/bgp_route.c
View file

@ -337,7 +337,7 @@ static int bgp_label_index_differs(struct bgp_info *ri1, struct bgp_info *ri2)
/* Set/unset bgp_info flags, adjusting any other state as needed.
* This is here primarily to keep prefix-count in check.
*/
void bgp_info_set_flag(struct bgp_node *rn, struct bgp_info *ri, u_int32_t flag)
void bgp_info_set_flag(struct bgp_node *rn, struct bgp_info *ri, uint32_t flag)
{
SET_FLAG(ri->flags, flag);
@ -351,7 +351,7 @@ void bgp_info_set_flag(struct bgp_node *rn, struct bgp_info *ri, u_int32_t flag)
}
void bgp_info_unset_flag(struct bgp_node *rn, struct bgp_info *ri,
u_int32_t flag)
uint32_t flag)
{
UNSET_FLAG(ri->flags, flag);
@ -366,7 +366,7 @@ void bgp_info_unset_flag(struct bgp_node *rn, struct bgp_info *ri,
/* Get MED value. If MED value is missing and "bgp bestpath
missing-as-worst" is specified, treat it as the worst value. */
static u_int32_t bgp_med_value(struct attr *attr, struct bgp *bgp)
static uint32_t bgp_med_value(struct attr *attr, struct bgp *bgp)
{
if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))
return attr->med;
@ -397,12 +397,12 @@ static int bgp_info_cmp(struct bgp *bgp, struct bgp_info *new,
struct attr *newattr, *existattr;
bgp_peer_sort_t new_sort;
bgp_peer_sort_t exist_sort;
u_int32_t new_pref;
u_int32_t exist_pref;
u_int32_t new_med;
u_int32_t exist_med;
u_int32_t new_weight;
u_int32_t exist_weight;
uint32_t new_pref;
uint32_t exist_pref;
uint32_t new_med;
uint32_t exist_med;
uint32_t new_weight;
uint32_t exist_weight;
uint32_t newm, existm;
struct in_addr new_id;
struct in_addr exist_id;
@ -413,8 +413,8 @@ static int bgp_info_cmp(struct bgp *bgp, struct bgp_info *new,
int ret = 0;
char new_buf[PATH_ADDPATH_STR_BUFFER];
char exist_buf[PATH_ADDPATH_STR_BUFFER];
u_int32_t new_mm_seq;
u_int32_t exist_mm_seq;
uint32_t new_mm_seq;
uint32_t exist_mm_seq;
*paths_eq = 0;
@ -1181,7 +1181,7 @@ static int bgp_output_modifier(struct peer *peer, struct prefix *p,
struct bgp_info info;
route_map_result_t ret;
struct route_map *rmap = NULL;
u_char rmap_type;
uint8_t rmap_type;
/*
* So if we get to this point and have no rmap_name
@ -1323,7 +1323,7 @@ void bgp_attr_add_gshut_community(struct attr *attr)
}
static void subgroup_announce_reset_nhop(u_char family, struct attr *attr)
static void subgroup_announce_reset_nhop(uint8_t family, struct attr *attr)
{
if (family == AF_INET)
attr->nexthop.s_addr = 0;
@ -1992,7 +1992,7 @@ void bgp_best_selection(struct bgp *bgp, struct bgp_node *rn,
int subgroup_process_announce_selected(struct update_subgroup *subgrp,
struct bgp_info *selected,
struct bgp_node *rn,
u_int32_t addpath_tx_id)
uint32_t addpath_tx_id)
{
struct prefix *p;
struct peer *onlypeer;
@ -2521,7 +2521,7 @@ int bgp_maximum_prefix_overflow(struct peer *peer, afi_t afi, safi_t safi,
pkt_afi = afi_int2iana(afi);
pkt_safi = safi_int2iana(safi);
{
u_int8_t ndata[7];
uint8_t ndata[7];
ndata[0] = (pkt_afi >> 8);
ndata[1] = pkt_afi;
@ -2644,7 +2644,7 @@ static void bgp_rib_withdraw(struct bgp_node *rn, struct bgp_info *ri,
bgp_rib_remove(rn, ri, peer, afi, safi);
}
struct bgp_info *info_make(int type, int sub_type, u_short instance,
struct bgp_info *info_make(int type, int sub_type, unsigned short instance,
struct peer *peer, struct attr *attr,
struct bgp_node *rn)
{
@ -2772,10 +2772,10 @@ static int bgp_update_martian_nexthop(struct bgp *bgp, afi_t afi, safi_t safi,
return ret;
}
int bgp_update(struct peer *peer, struct prefix *p, u_int32_t addpath_id,
int bgp_update(struct peer *peer, struct prefix *p, uint32_t addpath_id,
struct attr *attr, afi_t afi, safi_t safi, int type,
int sub_type, struct prefix_rd *prd, mpls_label_t *label,
u_int32_t num_labels, int soft_reconfig,
uint32_t num_labels, int soft_reconfig,
struct bgp_route_evpn *evpn)
{
int ret;
@ -3424,10 +3424,10 @@ filtered:
return 0;
}
int bgp_withdraw(struct peer *peer, struct prefix *p, u_int32_t addpath_id,
int bgp_withdraw(struct peer *peer, struct prefix *p, uint32_t addpath_id,
struct attr *attr, afi_t afi, safi_t safi, int type,
int sub_type, struct prefix_rd *prd, mpls_label_t *label,
u_int32_t num_labels, struct bgp_route_evpn *evpn)
uint32_t num_labels, struct bgp_route_evpn *evpn)
{
struct bgp *bgp;
char pfx_buf[BGP_PRD_PATH_STRLEN];
@ -3629,7 +3629,7 @@ static void bgp_soft_reconfig_table(struct peer *peer, afi_t afi, safi_t safi,
continue;
struct bgp_info *ri = rn->info;
u_int32_t num_labels = 0;
uint32_t num_labels = 0;
mpls_label_t *label_pnt = NULL;
if (ri && ri->extra)
@ -4087,15 +4087,15 @@ static int bgp_addpath_encode_rx(struct peer *peer, afi_t afi, safi_t safi)
int bgp_nlri_parse_ip(struct peer *peer, struct attr *attr,
struct bgp_nlri *packet)
{
u_char *pnt;
u_char *lim;
uint8_t *pnt;
uint8_t *lim;
struct prefix p;
int psize;
int ret;
afi_t afi;
safi_t safi;
int addpath_encoded;
u_int32_t addpath_id;
uint32_t addpath_id;
pnt = packet->nlri;
lim = pnt + packet->length;
@ -4548,7 +4548,7 @@ static void bgp_static_update_safi(struct bgp *bgp, struct prefix *p,
#if ENABLE_BGP_VNC
mpls_label_t label = 0;
#endif
u_int32_t num_labels = 0;
uint32_t num_labels = 0;
union gw_addr add;
assert(bgp_static);
@ -4713,14 +4713,14 @@ static void bgp_static_update_safi(struct bgp *bgp, struct prefix *p,
route should be installed as valid. */
static int bgp_static_set(struct vty *vty, const char *negate,
const char *ip_str, afi_t afi, safi_t safi,
const char *rmap, int backdoor, u_int32_t label_index)
const char *rmap, int backdoor, uint32_t label_index)
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int ret;
struct prefix p;
struct bgp_static *bgp_static;
struct bgp_node *rn;
u_char need_update = 0;
uint8_t need_update = 0;
/* Convert IP prefix string to struct prefix. */
ret = str2prefix(ip_str, &p);
@ -5329,10 +5329,10 @@ DEFPY(ipv6_bgp_network,
*/
struct bgp_aggregate {
/* Summary-only flag. */
u_char summary_only;
uint8_t summary_only;
/* AS set generation. */
u_char as_set;
uint8_t as_set;
/* Route-map for aggregated route. */
struct route_map *map;
@ -5363,20 +5363,20 @@ static void bgp_aggregate_route(struct bgp *bgp, struct prefix *p,
struct bgp_table *table;
struct bgp_node *top;
struct bgp_node *rn;
u_char origin;
uint8_t origin;
struct aspath *aspath = NULL;
struct aspath *asmerge = NULL;
struct community *community = NULL;
struct community *commerge = NULL;
#if defined(AGGREGATE_NEXTHOP_CHECK)
struct in_addr nexthop;
u_int32_t med = 0;
uint32_t med = 0;
#endif
struct bgp_info *ri;
struct bgp_info *new;
int first = 1;
unsigned long match = 0;
u_char atomic_aggregate = 0;
uint8_t atomic_aggregate = 0;
/* Record adding route's nexthop and med. */
if (rinew) {
@ -5624,12 +5624,12 @@ static void bgp_aggregate_add(struct bgp *bgp, struct prefix *p, afi_t afi,
struct bgp_info *new;
struct bgp_info *ri;
unsigned long match;
u_char origin = BGP_ORIGIN_IGP;
uint8_t origin = BGP_ORIGIN_IGP;
struct aspath *aspath = NULL;
struct aspath *asmerge = NULL;
struct community *community = NULL;
struct community *commerge = NULL;
u_char atomic_aggregate = 0;
uint8_t atomic_aggregate = 0;
table = bgp->rib[afi][safi];
@ -5852,7 +5852,7 @@ static int bgp_aggregate_unset(struct vty *vty, const char *prefix_str,
}
static int bgp_aggregate_set(struct vty *vty, const char *prefix_str, afi_t afi,
safi_t safi, u_char summary_only, u_char as_set)
safi_t safi, uint8_t summary_only, uint8_t as_set)
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int ret;
@ -6039,7 +6039,8 @@ DEFUN (no_ipv6_aggregate_address,
void bgp_redistribute_add(struct bgp *bgp, struct prefix *p,
const union g_addr *nexthop, ifindex_t ifindex,
enum nexthop_types_t nhtype, uint32_t metric,
u_char type, u_short instance, route_tag_t tag)
uint8_t type, unsigned short instance,
route_tag_t tag)
{
struct bgp_info *new;
struct bgp_info *bi;
@ -6196,8 +6197,8 @@ void bgp_redistribute_add(struct bgp *bgp, struct prefix *p,
aspath_unintern(&attr.aspath);
}
void bgp_redistribute_delete(struct bgp *bgp, struct prefix *p, u_char type,
u_short instance)
void bgp_redistribute_delete(struct bgp *bgp, struct prefix *p, uint8_t type,
unsigned short instance)
{
afi_t afi;
struct bgp_node *rn;
@ -6232,7 +6233,7 @@ void bgp_redistribute_delete(struct bgp *bgp, struct prefix *p, u_char type,
/* Withdraw specified route type's route. */
void bgp_redistribute_withdraw(struct bgp *bgp, afi_t afi, int type,
u_short instance)
unsigned short instance)
{
struct bgp_node *rn;
struct bgp_info *ri;
@ -6266,7 +6267,7 @@ static void route_vty_out_route(struct prefix *p, struct vty *vty,
json_object *json)
{
int len = 0;
u_int32_t destination;
uint32_t destination;
char buf[BUFSIZ];
if (p->family == AF_INET) {
@ -6694,7 +6695,7 @@ void route_vty_out(struct vty *vty, struct prefix *p, struct bgp_info *binfo,
/* called from terminal list command */
void route_vty_out_tmp(struct vty *vty, struct prefix *p, struct attr *attr,
safi_t safi, u_char use_json, json_object *json_ar)
safi_t safi, uint8_t use_json, json_object *json_ar)
{
json_object *json_status = NULL;
json_object *json_net = NULL;
@ -7019,7 +7020,7 @@ void route_vty_out_overlay(struct vty *vty, struct prefix *p,
/* dampening route */
static void damp_route_vty_out(struct vty *vty, struct prefix *p,
struct bgp_info *binfo, int display, safi_t safi,
u_char use_json, json_object *json)
uint8_t use_json, json_object *json)
{
struct attr *attr;
int len;
@ -7082,7 +7083,7 @@ static void damp_route_vty_out(struct vty *vty, struct prefix *p,
/* flap route */
static void flap_route_vty_out(struct vty *vty, struct prefix *p,
struct bgp_info *binfo, int display, safi_t safi,
u_char use_json, json_object *json)
uint8_t use_json, json_object *json)
{
struct attr *attr;
struct bgp_damp_info *bdi;
@ -8072,7 +8073,7 @@ static int bgp_show_community(struct vty *vty, struct bgp *bgp,
static int bgp_show_table(struct vty *vty, struct bgp *bgp, safi_t safi,
struct bgp_table *table, enum bgp_show_type type,
void *output_arg, u_char use_json, char *rd,
void *output_arg, uint8_t use_json, char *rd,
int is_last, unsigned long *output_cum,
unsigned long *total_cum,
unsigned long *json_header_depth)
@ -8180,7 +8181,7 @@ static int bgp_show_table(struct vty *vty, struct bgp *bgp, safi_t safi,
continue;
}
if (type == bgp_show_type_cidr_only) {
u_int32_t destination;
uint32_t destination;
destination = ntohl(rn->p.u.prefix4.s_addr);
if (IN_CLASSC(destination)
@ -8357,7 +8358,7 @@ static int bgp_show_table(struct vty *vty, struct bgp *bgp, safi_t safi,
int bgp_show_table_rd(struct vty *vty, struct bgp *bgp, safi_t safi,
struct bgp_table *table, struct prefix_rd *prd_match,
enum bgp_show_type type, void *output_arg,
u_char use_json)
uint8_t use_json)
{
struct bgp_node *rn, *next;
unsigned long output_cum = 0;
@ -8397,7 +8398,7 @@ int bgp_show_table_rd(struct vty *vty, struct bgp *bgp, safi_t safi,
return CMD_SUCCESS;
}
static int bgp_show(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
enum bgp_show_type type, void *output_arg, u_char use_json)
enum bgp_show_type type, void *output_arg, uint8_t use_json)
{
struct bgp_table *table;
unsigned long json_header_depth = 0;
@ -8429,7 +8430,7 @@ static int bgp_show(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
}
static void bgp_show_all_instances_routes_vty(struct vty *vty, afi_t afi,
safi_t safi, u_char use_json)
safi_t safi, uint8_t use_json)
{
struct listnode *node, *nnode;
struct bgp *bgp;
@ -8629,7 +8630,8 @@ static int bgp_show_route_in_table(struct vty *vty, struct bgp *bgp,
struct bgp_table *rib, const char *ip_str,
afi_t afi, safi_t safi,
struct prefix_rd *prd, int prefix_check,
enum bgp_path_type pathtype, u_char use_json)
enum bgp_path_type pathtype,
uint8_t use_json)
{
int ret;
int header;
@ -8759,7 +8761,7 @@ static int bgp_show_route_in_table(struct vty *vty, struct bgp *bgp,
static int bgp_show_route(struct vty *vty, struct bgp *bgp, const char *ip_str,
afi_t afi, safi_t safi, struct prefix_rd *prd,
int prefix_check, enum bgp_path_type pathtype,
u_char use_json)
uint8_t use_json)
{
if (!bgp) {
bgp = bgp_get_default();
@ -8783,7 +8785,7 @@ static int bgp_show_route(struct vty *vty, struct bgp *bgp, const char *ip_str,
static int bgp_show_lcommunity(struct vty *vty, struct bgp *bgp, int argc,
struct cmd_token **argv, afi_t afi, safi_t safi,
u_char uj)
uint8_t uj)
{
struct lcommunity *lcom;
struct buffer *b;
@ -8820,7 +8822,7 @@ static int bgp_show_lcommunity(struct vty *vty, struct bgp *bgp, int argc,
static int bgp_show_lcommunity_list(struct vty *vty, struct bgp *bgp,
const char *lcom, afi_t afi, safi_t safi,
u_char uj)
uint8_t uj)
{
struct community_list *list;
@ -9126,7 +9128,7 @@ DEFUN (show_ip_bgp_route,
char *prefix = NULL;
struct bgp *bgp = NULL;
enum bgp_path_type path_type;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
int idx = 0;
@ -9363,7 +9365,7 @@ static int bgp_show_prefix_longer(struct vty *vty, struct bgp *bgp,
}
static struct peer *peer_lookup_in_view(struct vty *vty, struct bgp *bgp,
const char *ip_str, u_char use_json)
const char *ip_str, uint8_t use_json)
{
int ret;
struct peer *peer;
@ -9762,7 +9764,7 @@ static int bgp_peer_count_walker(struct thread *t)
}
static int bgp_peer_counts(struct vty *vty, struct peer *peer, afi_t afi,
safi_t safi, u_char use_json)
safi_t safi, uint8_t use_json)
{
struct peer_pcounts pcounts = {.peer = peer};
unsigned int i;
@ -9908,7 +9910,7 @@ DEFUN (show_ip_bgp_vpn_neighbor_prefix_counts,
{
int idx_peer = 6;
struct peer *peer;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
peer = peer_lookup_in_view(vty, NULL, argv[idx_peer]->arg, uj);
if (!peer)
@ -9981,7 +9983,7 @@ DEFUN (show_ip_bgp_l2vpn_evpn_all_route_prefix,
static void show_adj_route(struct vty *vty, struct peer *peer, afi_t afi,
safi_t safi, int in, const char *rmap_name,
u_char use_json, json_object *json)
uint8_t use_json, json_object *json)
{
struct bgp_table *table;
struct bgp_adj_in *ain;
@ -10205,7 +10207,7 @@ static void show_adj_route(struct vty *vty, struct peer *peer, afi_t afi,
static int peer_adj_routes(struct vty *vty, struct peer *peer, afi_t afi,
safi_t safi, int in, const char *rmap_name,
u_char use_json)
uint8_t use_json)
{
json_object *json = NULL;
@ -10347,7 +10349,7 @@ DEFUN (show_ip_bgp_neighbor_received_prefix_filter,
argv_find(argv, argc, "neighbors", &idx);
peerstr = argv[++idx]->arg;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
ret = str2sockunion(peerstr, &su);
if (ret < 0) {
@ -10391,7 +10393,7 @@ DEFUN (show_ip_bgp_neighbor_received_prefix_filter,
static int bgp_show_neighbor_route(struct vty *vty, struct peer *peer,
afi_t afi, safi_t safi,
enum bgp_show_type type, u_char use_json)
enum bgp_show_type type, uint8_t use_json)
{
/* labeled-unicast routes live in the unicast table */
if (safi == SAFI_LABELED_UNICAST)
@ -10476,7 +10478,7 @@ struct bgp_table *bgp_distance_table[AFI_MAX][SAFI_MAX];
struct bgp_distance {
/* Distance value for the IP source prefix. */
u_char distance;
uint8_t distance;
/* Name of the access-list to be matched. */
char *access_list;
@ -10532,7 +10534,7 @@ static int bgp_distance_set(struct vty *vty, const char *distance_str,
afi_t afi;
safi_t safi;
struct prefix p;
u_char distance;
uint8_t distance;
struct bgp_node *rn;
struct bgp_distance *bdistance;
@ -10619,8 +10621,8 @@ static int bgp_distance_unset(struct vty *vty, const char *distance_str,
}
/* Apply BGP information to distance method. */
u_char bgp_distance_apply(struct prefix *p, struct bgp_info *rinfo, afi_t afi,
safi_t safi, struct bgp *bgp)
uint8_t bgp_distance_apply(struct prefix *p, struct bgp_info *rinfo, afi_t afi,
safi_t safi, struct bgp *bgp)
{
struct bgp_node *rn;
struct prefix q;
@ -11197,7 +11199,7 @@ void bgp_config_write_network(struct vty *vty, struct bgp *bgp, afi_t afi,
/* "network" configuration display. */
if (bgp_option_check(BGP_OPT_CONFIG_CISCO) && afi == AFI_IP) {
u_int32_t destination;
uint32_t destination;
struct in_addr netmask;
destination = ntohl(p->u.prefix4.s_addr);

66
bgpd/bgp_route.h
View file

@ -76,11 +76,11 @@ struct bgp_info_extra {
int suppress;
/* Nexthop reachability check. */
u_int32_t igpmetric;
uint32_t igpmetric;
/* MPLS label(s) - VNI(s) for EVPN-VxLAN */
mpls_label_t label[BGP_MAX_LABELS];
u_int32_t num_labels;
uint32_t num_labels;
#if ENABLE_BGP_VNC
union {
@ -97,7 +97,7 @@ struct bgp_info_extra {
void *hme; /* encap monitor, if this is a VPN route */
struct prefix_rd
rd; /* import: route's route-distinguisher */
u_char un_family; /* family of cached un address, 0 if
uint8_t un_family; /* family of cached un address, 0 if
unset */
union {
struct in_addr addr4;
@ -174,7 +174,7 @@ struct bgp_info {
int lock;
/* BGP information status. */
u_int16_t flags;
uint16_t flags;
#define BGP_INFO_IGP_CHANGED (1 << 0)
#define BGP_INFO_DAMPED (1 << 1)
#define BGP_INFO_HISTORY (1 << 2)
@ -191,11 +191,11 @@ struct bgp_info {
#define BGP_INFO_RIB_ATTR_CHG (1 << 13)
/* BGP route type. This can be static, RIP, OSPF, BGP etc. */
u_char type;
uint8_t type;
/* When above type is BGP. This sub type specify BGP sub type
information. */
u_char sub_type;
uint8_t sub_type;
#define BGP_ROUTE_NORMAL 0
#define BGP_ROUTE_STATIC 1
#define BGP_ROUTE_AGGREGATE 2
@ -205,11 +205,11 @@ struct bgp_info {
#endif
#define BGP_ROUTE_IMPORTED 5 /* from another bgp instance/safi */
u_short instance;
unsigned short instance;
/* Addpath identifiers */
u_int32_t addpath_rx_id;
u_int32_t addpath_tx_id;
uint32_t addpath_rx_id;
uint32_t addpath_tx_id;
};
/* Structure used in BGP path selection */
@ -224,20 +224,20 @@ struct bgp_static {
int backdoor;
/* Label index configuration; applies to LU prefixes. */
u_int32_t label_index;
uint32_t label_index;
#define BGP_INVALID_LABEL_INDEX 0xFFFFFFFF
/* Import check status. */
u_char valid;
uint8_t valid;
/* IGP metric. */
u_int32_t igpmetric;
uint32_t igpmetric;
/* IGP nexthop. */
struct in_addr igpnexthop;
/* Atomic set reference count (ie cause of pathlimit) */
u_int32_t atomic;
uint32_t atomic;
/* BGP redistribute route-map. */
struct {
@ -348,9 +348,8 @@ extern void bgp_info_add(struct bgp_node *rn, struct bgp_info *ri);
extern void bgp_info_reap(struct bgp_node *rn, struct bgp_info *ri);
extern void bgp_info_delete(struct bgp_node *rn, struct bgp_info *ri);
extern struct bgp_info_extra *bgp_info_extra_get(struct bgp_info *);
extern void bgp_info_set_flag(struct bgp_node *, struct bgp_info *, u_int32_t);
extern void bgp_info_unset_flag(struct bgp_node *, struct bgp_info *,
u_int32_t);
extern void bgp_info_set_flag(struct bgp_node *, struct bgp_info *, uint32_t);
extern void bgp_info_unset_flag(struct bgp_node *, struct bgp_info *, uint32_t);
extern void bgp_info_path_with_addpath_rx_str(struct bgp_info *ri, char *buf);
extern int bgp_nlri_parse_ip(struct peer *, struct attr *, struct bgp_nlri *);
@ -360,11 +359,11 @@ extern int bgp_maximum_prefix_overflow(struct peer *, afi_t, safi_t, int);
extern void bgp_redistribute_add(struct bgp *bgp, struct prefix *p,
const union g_addr *nexthop, ifindex_t ifindex,
enum nexthop_types_t nhtype, uint32_t metric,
u_char type, u_short instance,
uint8_t type, unsigned short instance,
route_tag_t tag);
extern void bgp_redistribute_delete(struct bgp *, struct prefix *, u_char,
u_short);
extern void bgp_redistribute_withdraw(struct bgp *, afi_t, int, u_short);
extern void bgp_redistribute_delete(struct bgp *, struct prefix *, uint8_t,
unsigned short);
extern void bgp_redistribute_withdraw(struct bgp *, afi_t, int, unsigned short);
extern void bgp_static_add(struct bgp *);
extern void bgp_static_delete(struct bgp *);
@ -384,13 +383,12 @@ extern int bgp_static_unset_safi(afi_t afi, safi_t safi, struct vty *,
const char *, const char *, const char *);
/* this is primarily for MPLS-VPN */
extern int bgp_update(struct peer *, struct prefix *, u_int32_t, struct attr *,
extern int bgp_update(struct peer *, struct prefix *, uint32_t, struct attr *,
afi_t, safi_t, int, int, struct prefix_rd *,
mpls_label_t *, u_int32_t, int, struct bgp_route_evpn *);
extern int bgp_withdraw(struct peer *, struct prefix *, u_int32_t,
struct attr *, afi_t, safi_t, int, int,
struct prefix_rd *, mpls_label_t *, u_int32_t,
struct bgp_route_evpn *);
mpls_label_t *, uint32_t, int, struct bgp_route_evpn *);
extern int bgp_withdraw(struct peer *, struct prefix *, uint32_t, struct attr *,
afi_t, safi_t, int, int, struct prefix_rd *,
mpls_label_t *, uint32_t, struct bgp_route_evpn *);
/* for bgp_nexthop and bgp_damp */
extern void bgp_process(struct bgp *, struct bgp_node *, afi_t, safi_t);
@ -411,22 +409,22 @@ extern void bgp_aggregate_increment(struct bgp *, struct prefix *,
extern void bgp_aggregate_decrement(struct bgp *, struct prefix *,
struct bgp_info *, afi_t, safi_t);
extern u_char bgp_distance_apply(struct prefix *, struct bgp_info *, afi_t,
safi_t, struct bgp *);
extern uint8_t bgp_distance_apply(struct prefix *, struct bgp_info *, afi_t,
safi_t, struct bgp *);
extern afi_t bgp_node_afi(struct vty *);
extern safi_t bgp_node_safi(struct vty *);
extern struct bgp_info *info_make(int type, int sub_type, u_short instance,
struct peer *peer, struct attr *attr,
struct bgp_node *rn);
extern struct bgp_info *info_make(int type, int sub_type,
unsigned short instance, struct peer *peer,
struct attr *attr, struct bgp_node *rn);
extern void route_vty_out(struct vty *, struct prefix *, struct bgp_info *, int,
safi_t, json_object *);
extern void route_vty_out_tag(struct vty *, struct prefix *, struct bgp_info *,
int, safi_t, json_object *);
extern void route_vty_out_tmp(struct vty *, struct prefix *, struct attr *,
safi_t, u_char, json_object *);
safi_t, uint8_t, json_object *);
extern void route_vty_out_overlay(struct vty *vty, struct prefix *p,
struct bgp_info *binfo, int display,
json_object *json);
@ -434,7 +432,7 @@ extern void route_vty_out_overlay(struct vty *vty, struct prefix *p,
extern int subgroup_process_announce_selected(struct update_subgroup *subgrp,
struct bgp_info *selected,
struct bgp_node *rn,
u_int32_t addpath_tx_id);
uint32_t addpath_tx_id);
extern int subgroup_announce_check(struct bgp_node *rn, struct bgp_info *ri,
struct update_subgroup *subgrp,
@ -474,5 +472,5 @@ extern void route_vty_out_detail(struct vty *vty, struct bgp *bgp,
extern int bgp_show_table_rd(struct vty *vty, struct bgp *bgp, safi_t safi,
struct bgp_table *table, struct prefix_rd *prd,
enum bgp_show_type type, void *output_arg,
u_char use_json);
uint8_t use_json);
#endif /* _QUAGGA_BGP_ROUTE_H */

48
bgpd/bgp_routemap.c
View file

@ -122,12 +122,12 @@ o Local extensions
#define RMAP_VALUE_SUB 2
struct rmap_value {
u_int8_t action;
u_int8_t variable;
u_int32_t value;
uint8_t action;
uint8_t variable;
uint32_t value;
};
static int route_value_match(struct rmap_value *rv, u_int32_t value)
static int route_value_match(struct rmap_value *rv, uint32_t value)
{
if (rv->variable == 0 && value == rv->value)
return RMAP_MATCH;
@ -135,10 +135,10 @@ static int route_value_match(struct rmap_value *rv, u_int32_t value)
return RMAP_NOMATCH;
}
static u_int32_t route_value_adjust(struct rmap_value *rv, u_int32_t current,
struct peer *peer)
static uint32_t route_value_adjust(struct rmap_value *rv, uint32_t current,
struct peer *peer)
{
u_int32_t value;
uint32_t value;
switch (rv->variable) {
case 1:
@ -165,7 +165,7 @@ static u_int32_t route_value_adjust(struct rmap_value *rv, u_int32_t current,
static void *route_value_compile(const char *arg)
{
u_int8_t action = RMAP_VALUE_SET, var = 0;
uint8_t action = RMAP_VALUE_SET, var = 0;
unsigned long larg = 0;
char *endptr = NULL;
struct rmap_value *rv;
@ -723,10 +723,10 @@ static route_map_result_t route_match_evpn_route_type(void *rule,
route_map_object_t type,
void *object)
{
u_char route_type = 0;
uint8_t route_type = 0;
if (type == RMAP_BGP) {
route_type = *((u_char *)rule);
route_type = *((uint8_t *)rule);
if (route_type == prefix->u.prefix_evpn.route_type)
return RMAP_MATCH;
@ -738,9 +738,9 @@ static route_map_result_t route_match_evpn_route_type(void *rule,
/* Route map `route-type' match statement. */
static void *route_match_evpn_route_type_compile(const char *arg)
{
u_char *route_type = NULL;
uint8_t *route_type = NULL;
route_type = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_char));
route_type = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
if (strncmp(arg, "ma", 2) == 0)
*route_type = BGP_EVPN_MAC_IP_ROUTE;
@ -771,7 +771,7 @@ static route_map_result_t route_match_local_pref(void *rule,
route_map_object_t type,
void *object)
{
u_int32_t *local_pref;
uint32_t *local_pref;
struct bgp_info *bgp_info;
if (type == RMAP_BGP) {
@ -790,7 +790,7 @@ static route_map_result_t route_match_local_pref(void *rule,
`arg' is local-pref value */
static void *route_match_local_pref_compile(const char *arg)
{
u_int32_t *local_pref;
uint32_t *local_pref;
char *endptr = NULL;
unsigned long tmpval;
@ -803,7 +803,7 @@ static void *route_match_local_pref_compile(const char *arg)
if (*endptr != '\0' || errno || tmpval > UINT32_MAX)
return NULL;
local_pref = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_int32_t));
local_pref = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
if (!local_pref)
return local_pref;
@ -1073,7 +1073,7 @@ static route_map_result_t route_match_origin(void *rule, struct prefix *prefix,
route_map_object_t type,
void *object)
{
u_char *origin;
uint8_t *origin;
struct bgp_info *bgp_info;
if (type == RMAP_BGP) {
@ -1089,9 +1089,9 @@ static route_map_result_t route_match_origin(void *rule, struct prefix *prefix,
static void *route_match_origin_compile(const char *arg)
{
u_char *origin;
uint8_t *origin;
origin = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_char));
origin = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
if (strcmp(arg, "igp") == 0)
*origin = 0;
@ -1362,7 +1362,7 @@ static route_map_result_t route_set_local_pref(void *rule,
{
struct rmap_value *rv;
struct bgp_info *bgp_info;
u_int32_t locpref = 0;
uint32_t locpref = 0;
if (type == RMAP_BGP) {
/* Fetch routemap's rule information. */
@ -1424,7 +1424,7 @@ static route_map_result_t route_set_metric(void *rule, struct prefix *prefix,
{
struct rmap_value *rv;
struct bgp_info *bgp_info;
u_int32_t med = 0;
uint32_t med = 0;
if (type == RMAP_BGP) {
/* Fetch routemap's rule information. */
@ -2035,7 +2035,7 @@ static route_map_result_t route_set_origin(void *rule, struct prefix *prefix,
route_map_object_t type,
void *object)
{
u_char *origin;
uint8_t *origin;
struct bgp_info *bgp_info;
if (type == RMAP_BGP) {
@ -2051,9 +2051,9 @@ static route_map_result_t route_set_origin(void *rule, struct prefix *prefix,
/* Compile function for origin set. */
static void *route_set_origin_compile(const char *arg)
{
u_char *origin;
uint8_t *origin;
origin = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_char));
origin = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
if (strcmp(arg, "igp") == 0)
*origin = 0;
@ -2205,7 +2205,7 @@ static route_map_result_t route_set_label_index(void *rule,
{
struct rmap_value *rv;
struct bgp_info *bgp_info;
u_int32_t label_index;
uint32_t label_index;
if (type == RMAP_BGP) {
/* Fetch routemap's rule information. */

2
bgpd/bgp_rpki.c
View file

@ -179,7 +179,7 @@ static void *route_match_compile(const char *arg)
{
int *rpki_status;
rpki_status = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_char));
rpki_status = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
if (strcmp(arg, "valid") == 0)
*rpki_status = RPKI_VALID;

74
bgpd/bgp_snmp.c
View file

@ -125,19 +125,19 @@ static oid bgp_trap_oid[] = {BGP4MIB, 0};
static struct in_addr bgp_empty_addr = {.s_addr = 0};
/* Hook functions. */
static u_char *bgpVersion(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
static u_char *bgpLocalAs(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
static u_char *bgpPeerTable(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
static u_char *bgpRcvdPathAttrTable(struct variable *, oid[], size_t *, int,
size_t *, WriteMethod **);
static u_char *bgpIdentifier(struct variable *, oid[], size_t *, int, size_t *,
static uint8_t *bgpVersion(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
static uint8_t *bgpLocalAs(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
static uint8_t *bgpPeerTable(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
static u_char *bgp4PathAttrTable(struct variable *, oid[], size_t *, int,
size_t *, WriteMethod **);
/* static u_char *bgpTraps (); */
static uint8_t *bgpRcvdPathAttrTable(struct variable *, oid[], size_t *, int,
size_t *, WriteMethod **);
static uint8_t *bgpIdentifier(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
static uint8_t *bgp4PathAttrTable(struct variable *, oid[], size_t *, int,
size_t *, WriteMethod **);
/* static uint8_t *bgpTraps (); */
static struct variable bgp_variables[] = {
/* BGP version. */
@ -315,11 +315,11 @@ static struct variable bgp_variables[] = {
};
static u_char *bgpVersion(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *bgpVersion(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
{
static u_char version;
static uint8_t version;
if (smux_header_generic(v, name, length, exact, var_len, write_method)
== MATCH_FAILED)
@ -330,12 +330,12 @@ static u_char *bgpVersion(struct variable *v, oid name[], size_t *length,
/* Return octet string length 1. */
*var_len = 1;
return (u_char *)&version;
return (uint8_t *)&version;
}
static u_char *bgpLocalAs(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *bgpLocalAs(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
{
struct bgp *bgp;
@ -443,9 +443,9 @@ static struct peer *bgpPeerTable_lookup(struct variable *v, oid name[],
}
/* BGP write methods. */
static int write_bgpPeerTable(int action, u_char *var_val, u_char var_val_type,
size_t var_val_len, u_char *statP, oid *name,
size_t length)
static int write_bgpPeerTable(int action, uint8_t *var_val,
uint8_t var_val_type, size_t var_val_len,
uint8_t *statP, oid *name, size_t length)
{
struct in_addr addr;
struct peer *peer;
@ -506,9 +506,9 @@ static int write_bgpPeerTable(int action, u_char *var_val, u_char var_val_type,
return SNMP_ERR_NOERROR;
}
static u_char *bgpPeerTable(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *bgpPeerTable(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
{
static struct in_addr addr;
struct peer *peer;
@ -588,11 +588,11 @@ static u_char *bgpPeerTable(struct variable *v, oid name[], size_t *length,
return SNMP_INTEGER(PEER_TOTAL_TX(peer));
break;
case BGPPEERLASTERROR: {
static u_char lasterror[2];
static uint8_t lasterror[2];
lasterror[0] = peer->notify.code;
lasterror[1] = peer->notify.subcode;
*var_len = 2;
return (u_char *)&lasterror;
return (uint8_t *)&lasterror;
} break;
case BGPPEERFSMESTABLISHEDTRANSITIONS:
return SNMP_INTEGER(peer->established);
@ -644,9 +644,9 @@ static u_char *bgpPeerTable(struct variable *v, oid name[], size_t *length,
return NULL;
}
static u_char *bgpIdentifier(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *bgpIdentifier(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
{
struct bgp *bgp;
@ -661,9 +661,9 @@ static u_char *bgpIdentifier(struct variable *v, oid name[], size_t *length,
return SNMP_IPADDRESS(bgp->router_id);
}
static u_char *bgpRcvdPathAttrTable(struct variable *v, oid name[],
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *bgpRcvdPathAttrTable(struct variable *v, oid name[],
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
{
/* Received Path Attribute Table. This table contains, one entry
per path to a network, path attributes received from all peers
@ -805,9 +805,9 @@ static struct bgp_info *bgp4PathAttrLookup(struct variable *v, oid name[],
return NULL;
}
static u_char *bgp4PathAttrTable(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *bgp4PathAttrTable(struct variable *v, oid name[],
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
{
struct bgp *bgp;
struct bgp_info *binfo;

2
bgpd/bgp_table.h
View file

@ -58,7 +58,7 @@ struct bgp_node {
mpls_label_t local_label;
uint64_t version;
u_char flags;
uint8_t flags;
#define BGP_NODE_PROCESS_SCHEDULED (1 << 0)
#define BGP_NODE_USER_CLEAR (1 << 1)
#define BGP_NODE_LABEL_CHANGED (1 << 2)

52
bgpd/bgp_updgrp.h
View file

@ -77,7 +77,7 @@
typedef enum { BGP_ATTR_VEC_NH = 0, BGP_ATTR_VEC_MAX } bpacket_attr_vec_type;
typedef struct {
u_int32_t flags;
uint32_t flags;
unsigned long offset;
} bpacket_attr_vec;
@ -139,19 +139,19 @@ struct update_group {
uint64_t id;
time_t uptime;
u_int32_t join_events;
u_int32_t prune_events;
u_int32_t merge_events;
u_int32_t updgrp_switch_events;
u_int32_t peer_refreshes_combined;
u_int32_t adj_count;
u_int32_t split_events;
u_int32_t merge_checks_triggered;
uint32_t join_events;
uint32_t prune_events;
uint32_t merge_events;
uint32_t updgrp_switch_events;
uint32_t peer_refreshes_combined;
uint32_t adj_count;
uint32_t split_events;
uint32_t merge_checks_triggered;
u_int32_t subgrps_created;
u_int32_t subgrps_deleted;
uint32_t subgrps_created;
uint32_t subgrps_deleted;
u_int32_t num_dbg_en_peers;
uint32_t num_dbg_en_peers;
};
/*
@ -214,7 +214,7 @@ struct update_subgroup {
struct hash *hash;
struct thread *t_coalesce;
u_int32_t v_coalesce;
uint32_t v_coalesce;
struct thread *t_merge_check;
@ -236,25 +236,25 @@ struct update_subgroup {
uint64_t subgroup_id;
} split_from;
u_int32_t join_events;
u_int32_t prune_events;
uint32_t join_events;
uint32_t prune_events;
/*
* This is bumped up when another subgroup merges into this one.
*/
u_int32_t merge_events;
u_int32_t updgrp_switch_events;
u_int32_t peer_refreshes_combined;
u_int32_t adj_count;
u_int32_t split_events;
u_int32_t merge_checks_triggered;
uint32_t merge_events;
uint32_t updgrp_switch_events;
uint32_t peer_refreshes_combined;
uint32_t adj_count;
uint32_t split_events;
uint32_t merge_checks_triggered;
uint64_t id;
u_int16_t sflags;
uint16_t sflags;
/* Subgroup flags, see below */
u_int16_t flags;
uint16_t flags;
};
/*
@ -302,7 +302,7 @@ struct updwalk_context {
int policy_route_update;
updgrp_walkcb cb;
void *context;
u_int8_t flags;
uint8_t flags;
#define UPDWALK_FLAGS_ADVQUEUE (1 << 0)
#define UPDWALK_FLAGS_ADVERTISED (1 << 1)
@ -449,7 +449,7 @@ extern void update_group_announce_rrclients(struct bgp *bgp);
extern void peer_af_announce_route(struct peer_af *paf, int combine);
extern struct bgp_adj_out *bgp_adj_out_alloc(struct update_subgroup *subgrp,
struct bgp_node *rn,
u_int32_t addpath_tx_id);
uint32_t addpath_tx_id);
extern void bgp_adj_out_remove_subgroup(struct bgp_node *rn,
struct bgp_adj_out *adj,
struct update_subgroup *subgrp);
@ -458,7 +458,7 @@ extern void bgp_adj_out_set_subgroup(struct bgp_node *rn,
struct attr *attr, struct bgp_info *binfo);
extern void bgp_adj_out_unset_subgroup(struct bgp_node *rn,
struct update_subgroup *subgrp,
char withdraw, u_int32_t addpath_tx_id);
char withdraw, uint32_t addpath_tx_id);
void subgroup_announce_table(struct update_subgroup *subgrp,
struct bgp_table *table);
extern void subgroup_trigger_write(struct update_subgroup *subgrp);

10
bgpd/bgp_updgrp_adv.c
View file

@ -57,7 +57,7 @@
static inline struct bgp_adj_out *adj_lookup(struct bgp_node *rn,
struct update_subgroup *subgrp,
u_int32_t addpath_tx_id)
uint32_t addpath_tx_id)
{
struct bgp_adj_out *adj;
struct peer *peer;
@ -207,7 +207,7 @@ static int group_announce_route_walkcb(struct update_group *updgrp, void *arg)
}
static void subgrp_show_adjq_vty(struct update_subgroup *subgrp,
struct vty *vty, u_int8_t flags)
struct vty *vty, uint8_t flags)
{
struct bgp_table *table;
struct bgp_adj_out *adj;
@ -280,7 +280,7 @@ static int updgrp_show_adj_walkcb(struct update_group *updgrp, void *arg)
}
static void updgrp_show_adj(struct bgp *bgp, afi_t afi, safi_t safi,
struct vty *vty, uint64_t id, u_int8_t flags)
struct vty *vty, uint64_t id, uint8_t flags)
{
struct updwalk_context ctx;
memset(&ctx, 0, sizeof(ctx));
@ -370,7 +370,7 @@ static int update_group_announce_rrc_walkcb(struct update_group *updgrp,
*/
struct bgp_adj_out *bgp_adj_out_alloc(struct update_subgroup *subgrp,
struct bgp_node *rn,
u_int32_t addpath_tx_id)
uint32_t addpath_tx_id)
{
struct bgp_adj_out *adj;
@ -487,7 +487,7 @@ void bgp_adj_out_set_subgroup(struct bgp_node *rn,
*/
void bgp_adj_out_unset_subgroup(struct bgp_node *rn,
struct update_subgroup *subgrp, char withdraw,
u_int32_t addpath_tx_id)
uint32_t addpath_tx_id)
{
struct bgp_adj_out *adj;
struct bgp_advertise *adv;

10
bgpd/bgp_updgrp_packet.c
View file

@ -396,7 +396,7 @@ struct stream *bpacket_reformat_for_peer(struct bpacket *pkt,
vec = &pkt->arr.entries[BGP_ATTR_VEC_NH];
if (CHECK_FLAG(vec->flags, BPKT_ATTRVEC_FLAGS_UPDATED)) {
u_int8_t nhlen;
uint8_t nhlen;
afi_t nhafi = AFI_MAX; /* NH AFI is based on nhlen! */
int route_map_sets_nh;
nhlen = stream_getc_from(s, vec->offset);
@ -699,10 +699,10 @@ struct bpacket *subgroup_update_packet(struct update_subgroup *subgrp)
int num_pfx = 0;
int addpath_encode = 0;
int addpath_overhead = 0;
u_int32_t addpath_tx_id = 0;
uint32_t addpath_tx_id = 0;
struct prefix_rd *prd = NULL;
mpls_label_t label = MPLS_INVALID_LABEL, *label_pnt = NULL;
u_int32_t num_labels = 0;
uint32_t num_labels = 0;
if (!subgrp)
return NULL;
@ -937,7 +937,7 @@ struct bpacket *subgroup_withdraw_packet(struct update_subgroup *subgrp)
size_t mp_start = 0;
size_t attrlen_pos = 0;
size_t mplen_pos = 0;
u_char first_time = 1;
uint8_t first_time = 1;
afi_t afi;
safi_t safi;
int space_remaining = 0;
@ -945,7 +945,7 @@ struct bpacket *subgroup_withdraw_packet(struct update_subgroup *subgrp)
int num_pfx = 0;
int addpath_encode = 0;
int addpath_overhead = 0;
u_int32_t addpath_tx_id = 0;
uint32_t addpath_tx_id = 0;
struct prefix_rd *prd = NULL;

6
bgpd/bgp_vpn.c
View file

@ -32,7 +32,7 @@
int show_adj_route_vpn(struct vty *vty, struct peer *peer,
struct prefix_rd *prd, afi_t afi, safi_t safi,
u_char use_json)
uint8_t use_json)
{
struct bgp *bgp;
struct bgp_table *table;
@ -124,14 +124,14 @@ int show_adj_route_vpn(struct vty *vty, struct peer *peer,
}
if (rd_header) {
u_int16_t type;
uint16_t type;
struct rd_as rd_as;
struct rd_ip rd_ip = {0};
#if ENABLE_BGP_VNC
struct rd_vnc_eth rd_vnc_eth = {
0};
#endif
u_char *pnt;
uint8_t *pnt;
pnt = rn->p.u.val;

2
bgpd/bgp_vpn.h
View file

@ -25,6 +25,6 @@
extern int show_adj_route_vpn(struct vty *vty, struct peer *peer,
struct prefix_rd *prd, afi_t afi, safi_t safi,
u_char use_json);
uint8_t use_json);
#endif /* _QUAGGA_BGP_VPN_H */

125
bgpd/bgp_vty.c
View file

@ -1111,11 +1111,11 @@ DEFUN (no_bgp_confederation_peers,
* @set: 1 for setting values, 0 for removing the max-paths config.
*/
static int bgp_maxpaths_config_vty(struct vty *vty, int peer_type,
const char *mpaths, u_int16_t options,
const char *mpaths, uint16_t options,
int set)
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
u_int16_t maxpaths = 0;
uint16_t maxpaths = 0;
int ret;
afi_t afi;
safi_t safi;
@ -1257,8 +1257,8 @@ static int bgp_update_delay_config_vty(struct vty *vty, const char *delay,
const char *wait)
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
u_int16_t update_delay;
u_int16_t establish_wait;
uint16_t update_delay;
uint16_t establish_wait;
update_delay = strtoul(delay, NULL, 10);
@ -1779,7 +1779,7 @@ DEFUN (bgp_graceful_restart_stalepath_time,
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3;
u_int32_t stalepath;
uint32_t stalepath;
stalepath = strtoul(argv[idx_number]->arg, NULL, 10);
bgp->stalepath_time = stalepath;
@ -1796,7 +1796,7 @@ DEFUN (bgp_graceful_restart_restart_time,
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3;
u_int32_t restart;
uint32_t restart;
restart = strtoul(argv[idx_number]->arg, NULL, 10);
bgp->restart_time = restart;
@ -2292,7 +2292,7 @@ DEFUN (bgp_default_local_preference,
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3;
u_int32_t local_pref;
uint32_t local_pref;
local_pref = strtoul(argv[idx_number]->arg, NULL, 10);
@ -2329,7 +2329,7 @@ DEFUN (bgp_default_subgroup_pkt_queue_max,
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3;
u_int32_t max_size;
uint32_t max_size;
max_size = strtoul(argv[idx_number]->arg, NULL, 10);
@ -3404,7 +3404,7 @@ ALIAS_HIDDEN(no_neighbor_set_peer_group, no_neighbor_set_peer_group_hidden_cmd,
"Peer-group name\n")
static int peer_flag_modify_vty(struct vty *vty, const char *ip_str,
u_int16_t flag, int set)
uint16_t flag, int set)
{
int ret;
struct peer *peer;
@ -3436,14 +3436,13 @@ static int peer_flag_modify_vty(struct vty *vty, const char *ip_str,
return bgp_vty_return(vty, ret);
}
static int peer_flag_set_vty(struct vty *vty, const char *ip_str,
u_int16_t flag)
static int peer_flag_set_vty(struct vty *vty, const char *ip_str, uint16_t flag)
{
return peer_flag_modify_vty(vty, ip_str, flag, 1);
}
static int peer_flag_unset_vty(struct vty *vty, const char *ip_str,
u_int16_t flag)
uint16_t flag)
{
return peer_flag_modify_vty(vty, ip_str, flag, 0);
}
@ -3608,7 +3607,7 @@ DEFUN (no_neighbor_capability_enhe,
}
static int peer_af_flag_modify_vty(struct vty *vty, const char *peer_str,
afi_t afi, safi_t safi, u_int32_t flag,
afi_t afi, safi_t safi, uint32_t flag,
int set)
{
int ret;
@ -3627,13 +3626,13 @@ static int peer_af_flag_modify_vty(struct vty *vty, const char *peer_str,
}
static int peer_af_flag_set_vty(struct vty *vty, const char *peer_str,
afi_t afi, safi_t safi, u_int32_t flag)
afi_t afi, safi_t safi, uint32_t flag)
{
return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 1);
}
static int peer_af_flag_unset_vty(struct vty *vty, const char *peer_str,
afi_t afi, safi_t safi, u_int32_t flag)
afi_t afi, safi_t safi, uint32_t flag)
{
return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 0);
}
@ -3653,7 +3652,7 @@ DEFUN (neighbor_capability_orf_prefix,
{
int idx_peer = 1;
int idx_send_recv = 5;
u_int16_t flag = 0;
uint16_t flag = 0;
if (strmatch(argv[idx_send_recv]->text, "send"))
flag = PEER_FLAG_ORF_PREFIX_SM;
@ -3697,7 +3696,7 @@ DEFUN (no_neighbor_capability_orf_prefix,
{
int idx_peer = 2;
int idx_send_recv = 6;
u_int16_t flag = 0;
uint16_t flag = 0;
if (strmatch(argv[idx_send_recv]->text, "send"))
flag = PEER_FLAG_ORF_PREFIX_SM;
@ -4072,7 +4071,7 @@ DEFUN (neighbor_send_community_type,
"Send Large Community attributes\n")
{
int idx = 0;
u_int32_t flag = 0;
uint32_t flag = 0;
char *peer = argv[1]->arg;
@ -4338,7 +4337,7 @@ DEFUN (neighbor_attr_unchanged,
int idx = 0;
char *peer_str = argv[1]->arg;
struct peer *peer;
u_int16_t flags = 0;
uint16_t flags = 0;
afi_t afi = bgp_node_afi(vty);
safi_t safi = bgp_node_safi(vty);
@ -4408,7 +4407,7 @@ DEFUN (no_neighbor_attr_unchanged,
{
int idx = 0;
char *peer = argv[2]->arg;
u_int16_t flags = 0;
uint16_t flags = 0;
if (argv_find(argv, argc, "as-path", &idx))
SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
@ -4747,7 +4746,7 @@ static int peer_port_vty(struct vty *vty, const char *ip_str, int afi,
const char *port_str)
{
struct peer *peer;
u_int16_t port;
uint16_t port;
struct servent *sp;
peer = peer_lookup_vty(vty, ip_str);
@ -4924,8 +4923,8 @@ static int peer_timers_set_vty(struct vty *vty, const char *ip_str,
{
int ret;
struct peer *peer;
u_int32_t keepalive;
u_int32_t holdtime;
uint32_t keepalive;
uint32_t holdtime;
peer = peer_and_group_lookup_vty(vty, ip_str);
if (!peer)
@ -4990,7 +4989,7 @@ static int peer_timers_connect_set_vty(struct vty *vty, const char *ip_str,
{
int ret;
struct peer *peer;
u_int32_t connect;
uint32_t connect;
peer = peer_and_group_lookup_vty(vty, ip_str);
if (!peer)
@ -5052,7 +5051,7 @@ static int peer_advertise_interval_vty(struct vty *vty, const char *ip_str,
{
int ret;
struct peer *peer;
u_int32_t routeadv = 0;
uint32_t routeadv = 0;
peer = peer_and_group_lookup_vty(vty, ip_str);
if (!peer)
@ -5107,7 +5106,7 @@ DEFUN (bgp_set_route_map_delay_timer,
"0 disables the timer, no route updates happen when route-maps change\n")
{
int idx_number = 3;
u_int32_t rmap_delay_timer;
uint32_t rmap_delay_timer;
if (argv[idx_number]->arg) {
rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
@ -5658,9 +5657,9 @@ static int peer_maximum_prefix_set_vty(struct vty *vty, const char *ip_str,
{
int ret;
struct peer *peer;
u_int32_t max;
u_char threshold;
u_int16_t restart;
uint32_t max;
uint8_t threshold;
uint16_t restart;
peer = peer_and_group_lookup_vty(vty, ip_str);
if (!peer)
@ -6969,7 +6968,7 @@ DEFUN (show_bgp_vrfs,
struct list *inst = bm->bgp;
struct listnode *node;
struct bgp *bgp;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
json_object *json_vrfs = NULL;
int count = 0;
@ -7290,7 +7289,7 @@ static void bgp_show_bestpath_json(struct bgp *bgp, json_object *json)
/* Show BGP peer's summary information. */
static int bgp_show_summary(struct vty *vty, struct bgp *bgp, int afi, int safi,
u_char use_json, json_object *json)
uint8_t use_json, json_object *json)
{
struct peer *peer;
struct listnode *node, *nnode;
@ -7705,7 +7704,7 @@ static int bgp_show_summary(struct vty *vty, struct bgp *bgp, int afi, int safi,
}
static void bgp_show_summary_afi_safi(struct vty *vty, struct bgp *bgp, int afi,
int safi, u_char use_json,
int safi, uint8_t use_json,
json_object *json)
{
int is_first = 1;
@ -7767,7 +7766,7 @@ static void bgp_show_summary_afi_safi(struct vty *vty, struct bgp *bgp, int afi,
}
static void bgp_show_all_instances_summary_vty(struct vty *vty, afi_t afi,
safi_t safi, u_char use_json)
safi_t safi, uint8_t use_json)
{
struct listnode *node, *nnode;
struct bgp *bgp;
@ -7804,7 +7803,7 @@ static void bgp_show_all_instances_summary_vty(struct vty *vty, afi_t afi,
}
int bgp_show_summary_vty(struct vty *vty, const char *name, afi_t afi,
safi_t safi, u_char use_json)
safi_t safi, uint8_t use_json)
{
struct bgp *bgp;
@ -7942,9 +7941,9 @@ enum show_type { show_all, show_peer };
static void bgp_show_peer_afi_orf_cap(struct vty *vty, struct peer *p,
afi_t afi, safi_t safi,
u_int16_t adv_smcap, u_int16_t adv_rmcap,
u_int16_t rcv_smcap, u_int16_t rcv_rmcap,
u_char use_json, json_object *json_pref)
uint16_t adv_smcap, uint16_t adv_rmcap,
uint16_t rcv_smcap, uint16_t rcv_rmcap,
uint8_t use_json, json_object *json_pref)
{
/* Send-Mode */
if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
@ -8004,7 +8003,7 @@ static void bgp_show_peer_afi_orf_cap(struct vty *vty, struct peer *p,
}
static void bgp_show_peer_afi(struct vty *vty, struct peer *p, afi_t afi,
safi_t safi, u_char use_json,
safi_t safi, uint8_t use_json,
json_object *json_neigh)
{
struct bgp_filter *filter;
@ -8579,7 +8578,7 @@ static void bgp_show_peer_afi(struct vty *vty, struct peer *p, afi_t afi,
}
}
static void bgp_show_peer(struct vty *vty, struct peer *p, u_char use_json,
static void bgp_show_peer(struct vty *vty, struct peer *p, uint8_t use_json,
json_object *json)
{
struct bgp *bgp;
@ -8590,8 +8589,8 @@ static void bgp_show_peer(struct vty *vty, struct peer *p, u_char use_json,
const char *code_str;
afi_t afi;
safi_t safi;
u_int16_t i;
u_char *msg;
uint16_t i;
uint8_t *msg;
json_object *json_neigh = NULL;
time_t epoch_tbuf;
@ -10026,7 +10025,7 @@ static void bgp_show_peer(struct vty *vty, struct peer *p, u_char use_json,
msg_str = bgp_notify_admin_message(
msgbuf, sizeof(msgbuf),
(u_char *)p->notify.data,
(uint8_t *)p->notify.data,
p->notify.length);
if (msg_str)
json_object_string_add(
@ -10062,7 +10061,7 @@ static void bgp_show_peer(struct vty *vty, struct peer *p, u_char use_json,
msg_str = bgp_notify_admin_message(
msgbuf, sizeof(msgbuf),
(u_char *)p->notify.data,
(uint8_t *)p->notify.data,
p->notify.length);
if (msg_str)
vty_out(vty,
@ -10316,7 +10315,7 @@ static void bgp_show_peer(struct vty *vty, struct peer *p, u_char use_json,
static int bgp_show_neighbor(struct vty *vty, struct bgp *bgp,
enum show_type type, union sockunion *su,
const char *conf_if, u_char use_json,
const char *conf_if, uint8_t use_json,
json_object *json)
{
struct listnode *node, *nnode;
@ -10373,7 +10372,7 @@ static int bgp_show_neighbor(struct vty *vty, struct bgp *bgp,
static void bgp_show_all_instances_neighbors_vty(struct vty *vty,
enum show_type type,
const char *ip_str,
u_char use_json)
uint8_t use_json)
{
struct listnode *node, *nnode;
struct bgp *bgp;
@ -10440,7 +10439,7 @@ static void bgp_show_all_instances_neighbors_vty(struct vty *vty,
static int bgp_show_neighbor_vty(struct vty *vty, const char *name,
enum show_type type, const char *ip_str,
u_char use_json)
uint8_t use_json)
{
int ret;
struct bgp *bgp;
@ -10515,7 +10514,7 @@ DEFUN (show_ip_bgp_neighbors,
char *sh_arg = NULL;
enum show_type sh_type;
u_char uj = use_json(argc, argv);
uint8_t uj = use_json(argc, argv);
int idx = 0;
@ -11027,7 +11026,7 @@ DEFUN (bgp_redistribute_ipv4_metric,
int idx_protocol = 1;
int idx_number = 3;
int type;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
@ -11064,7 +11063,7 @@ DEFUN (bgp_redistribute_ipv4_rmap_metric,
int idx_word = 3;
int idx_number = 5;
int type;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
@ -11106,7 +11105,7 @@ DEFUN (bgp_redistribute_ipv4_metric_rmap,
int idx_number = 3;
int idx_word = 5;
int type;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
@ -11144,8 +11143,8 @@ DEFUN (bgp_redistribute_ipv4_ospf,
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_ospf_table = 1;
int idx_number = 2;
u_short instance;
u_short protocol;
unsigned short instance;
unsigned short protocol;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
@ -11180,7 +11179,7 @@ DEFUN (bgp_redistribute_ipv4_ospf_rmap,
int idx_number = 2;
int idx_word = 4;
struct bgp_redist *red;
u_short instance;
unsigned short instance;
int protocol;
if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
@ -11218,9 +11217,9 @@ DEFUN (bgp_redistribute_ipv4_ospf_metric,
int idx_ospf_table = 1;
int idx_number = 2;
int idx_number_2 = 4;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
u_short instance;
unsigned short instance;
int protocol;
if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
@ -11263,9 +11262,9 @@ DEFUN (bgp_redistribute_ipv4_ospf_rmap_metric,
int idx_number = 2;
int idx_word = 4;
int idx_number_2 = 6;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
u_short instance;
unsigned short instance;
int protocol;
if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
@ -11312,9 +11311,9 @@ DEFUN (bgp_redistribute_ipv4_ospf_metric_rmap,
int idx_number = 2;
int idx_number_2 = 4;
int idx_word = 6;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
u_short instance;
unsigned short instance;
int protocol;
if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
@ -11360,7 +11359,7 @@ DEFUN (no_bgp_redistribute_ipv4_ospf,
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_ospf_table = 2;
int idx_number = 3;
u_short instance;
unsigned short instance;
int protocol;
if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
@ -11476,7 +11475,7 @@ DEFUN (bgp_redistribute_ipv6_metric,
int idx_protocol = 1;
int idx_number = 3;
int type;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
@ -11506,7 +11505,7 @@ DEFUN (bgp_redistribute_ipv6_rmap_metric,
int idx_word = 3;
int idx_number = 5;
int type;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
@ -11537,7 +11536,7 @@ DEFUN (bgp_redistribute_ipv6_metric_rmap,
int idx_number = 3;
int idx_word = 5;
int type;
u_int32_t metric;
uint32_t metric;
struct bgp_redist *red;
type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);

2
bgpd/bgp_vty.h
View file

@ -70,7 +70,7 @@ extern int bgp_vty_find_and_parse_afi_safi_bgp(struct vty *vty,
int argc, int *idx, afi_t *afi,
safi_t *safi, struct bgp **bgp);
extern int bgp_show_summary_vty(struct vty *vty, const char *name, afi_t afi,
safi_t safi, u_char use_json);
safi_t safi, uint8_t use_json);
extern void bgp_vpn_policy_config_write_afi(struct vty *vty, struct bgp *bgp,
afi_t afi);
#endif /* _QUAGGA_BGP_VTY_H */

29
bgpd/bgp_zebra.c
View file

@ -979,10 +979,10 @@ void bgp_zebra_announce(struct bgp_node *rn, struct prefix *p,
int nh_family;
unsigned int valid_nh_count = 0;
int has_valid_label = 0;
u_char distance;
uint8_t distance;
struct peer *peer;
struct bgp_info *mpinfo;
u_int32_t metric;
uint32_t metric;
struct attr local_attr;
struct bgp_info local_info;
struct bgp_info *mpinfo_cp = &local_info;
@ -1367,8 +1367,8 @@ void bgp_zebra_withdraw(struct prefix *p, struct bgp_info *info,
zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
}
struct bgp_redist *bgp_redist_lookup(struct bgp *bgp, afi_t afi, u_char type,
u_short instance)
struct bgp_redist *bgp_redist_lookup(struct bgp *bgp, afi_t afi, uint8_t type,
unsigned short instance)
{
struct list *red_list;
struct listnode *node;
@ -1385,8 +1385,8 @@ struct bgp_redist *bgp_redist_lookup(struct bgp *bgp, afi_t afi, u_char type,
return NULL;
}
struct bgp_redist *bgp_redist_add(struct bgp *bgp, afi_t afi, u_char type,
u_short instance)
struct bgp_redist *bgp_redist_add(struct bgp *bgp, afi_t afi, uint8_t type,
unsigned short instance)
{
struct list *red_list;
struct bgp_redist *red;
@ -1408,8 +1408,8 @@ struct bgp_redist *bgp_redist_add(struct bgp *bgp, afi_t afi, u_char type,
return red;
}
static void bgp_redist_del(struct bgp *bgp, afi_t afi, u_char type,
u_short instance)
static void bgp_redist_del(struct bgp *bgp, afi_t afi, uint8_t type,
unsigned short instance)
{
struct bgp_redist *red;
@ -1424,7 +1424,8 @@ static void bgp_redist_del(struct bgp *bgp, afi_t afi, u_char type,
}
/* Other routes redistribution into BGP. */
int bgp_redistribute_set(struct bgp *bgp, afi_t afi, int type, u_short instance)
int bgp_redistribute_set(struct bgp *bgp, afi_t afi, int type,
unsigned short instance)
{
/* Return if already redistribute flag is set. */
@ -1471,7 +1472,7 @@ int bgp_redistribute_set(struct bgp *bgp, afi_t afi, int type, u_short instance)
}
int bgp_redistribute_resend(struct bgp *bgp, afi_t afi, int type,
u_short instance)
unsigned short instance)
{
/* Don't try to send if we're not connected to Zebra or Zebra doesn't
* know of this instance.
@ -1509,7 +1510,7 @@ int bgp_redistribute_rmap_set(struct bgp_redist *red, const char *name)
/* Redistribute with metric specification. */
int bgp_redistribute_metric_set(struct bgp *bgp, struct bgp_redist *red,
afi_t afi, int type, u_int32_t metric)
afi_t afi, int type, uint32_t metric)
{
struct bgp_node *rn;
struct bgp_info *ri;
@ -1547,7 +1548,7 @@ int bgp_redistribute_metric_set(struct bgp *bgp, struct bgp_redist *red,
/* Unset redistribution. */
int bgp_redistribute_unreg(struct bgp *bgp, afi_t afi, int type,
u_short instance)
unsigned short instance)
{
struct bgp_redist *red;
@ -1586,7 +1587,7 @@ int bgp_redistribute_unreg(struct bgp *bgp, afi_t afi, int type,
/* Unset redistribution. */
int bgp_redistribute_unset(struct bgp *bgp, afi_t afi, int type,
u_short instance)
unsigned short instance)
{
struct bgp_redist *red;
@ -1893,7 +1894,7 @@ static int bgp_zebra_process_local_macip(int command, struct zclient *zclient,
int ipa_len;
char buf[ETHER_ADDR_STRLEN];
char buf1[INET6_ADDRSTRLEN];
u_char flags;
uint8_t flags;
memset(&ip, 0, sizeof(ip));
s = zclient->ibuf;

17
bgpd/bgp_zebra.h
View file

@ -42,16 +42,17 @@ extern void bgp_zebra_terminate_radv(struct bgp *bgp, struct peer *peer);
extern void bgp_zebra_instance_register(struct bgp *);
extern void bgp_zebra_instance_deregister(struct bgp *);
extern struct bgp_redist *bgp_redist_lookup(struct bgp *, afi_t, u_char,
u_short);
extern struct bgp_redist *bgp_redist_add(struct bgp *, afi_t, u_char, u_short);
extern int bgp_redistribute_set(struct bgp *, afi_t, int, u_short);
extern int bgp_redistribute_resend(struct bgp *, afi_t, int, u_short);
extern struct bgp_redist *bgp_redist_lookup(struct bgp *, afi_t, uint8_t,
unsigned short);
extern struct bgp_redist *bgp_redist_add(struct bgp *, afi_t, uint8_t,
unsigned short);
extern int bgp_redistribute_set(struct bgp *, afi_t, int, unsigned short);
extern int bgp_redistribute_resend(struct bgp *, afi_t, int, unsigned short);
extern int bgp_redistribute_rmap_set(struct bgp_redist *, const char *);
extern int bgp_redistribute_metric_set(struct bgp *, struct bgp_redist *, afi_t,
int, u_int32_t);
extern int bgp_redistribute_unset(struct bgp *, afi_t, int, u_short);
extern int bgp_redistribute_unreg(struct bgp *, afi_t, int, u_short);
int, uint32_t);
extern int bgp_redistribute_unset(struct bgp *, afi_t, int, unsigned short);
extern int bgp_redistribute_unreg(struct bgp *, afi_t, int, unsigned short);
extern struct interface *if_lookup_by_ipv4(struct in_addr *, vrf_id_t);
extern struct interface *if_lookup_by_ipv4_exact(struct in_addr *, vrf_id_t);

59
bgpd/bgpd.c
View file

@ -376,7 +376,7 @@ time_t bgp_clock(void)
}
/* BGP timer configuration. */
int bgp_timers_set(struct bgp *bgp, u_int32_t keepalive, u_int32_t holdtime)
int bgp_timers_set(struct bgp *bgp, uint32_t keepalive, uint32_t holdtime)
{
bgp->default_keepalive =
(keepalive < holdtime / 3 ? keepalive : holdtime / 3);
@ -589,7 +589,7 @@ int bgp_confederation_peers_remove(struct bgp *bgp, as_t as)
}
/* Local preference configuration. */
int bgp_default_local_preference_set(struct bgp *bgp, u_int32_t local_pref)
int bgp_default_local_preference_set(struct bgp *bgp, uint32_t local_pref)
{
if (!bgp)
return -1;
@ -610,8 +610,7 @@ int bgp_default_local_preference_unset(struct bgp *bgp)
}
/* Local preference configuration. */
int bgp_default_subgroup_pkt_queue_max_set(struct bgp *bgp,
u_int32_t queue_size)
int bgp_default_subgroup_pkt_queue_max_set(struct bgp *bgp, uint32_t queue_size)
{
if (!bgp)
return -1;
@ -796,15 +795,14 @@ static int peer_hash_same(const void *p1, const void *p2)
== CHECK_FLAG(peer2->flags, PEER_FLAG_CONFIG_NODE));
}
int peer_af_flag_check(struct peer *peer, afi_t afi, safi_t safi,
u_int32_t flag)
int peer_af_flag_check(struct peer *peer, afi_t afi, safi_t safi, uint32_t flag)
{
return CHECK_FLAG(peer->af_flags[afi][safi], flag);
}
/* Return true if flag is set for the peer but not the peer-group */
static int peergroup_af_flag_check(struct peer *peer, afi_t afi, safi_t safi,
u_int32_t flag)
uint32_t flag)
{
struct peer *g_peer = NULL;
@ -1302,7 +1300,7 @@ static int bgp_peer_conf_if_to_su_update_v4(struct peer *peer,
{
struct connected *ifc;
struct prefix p;
u_int32_t addr;
uint32_t addr;
struct listnode *node;
/* If our IPv4 address on the interface is /30 or /31, we can derive the
@ -3709,16 +3707,16 @@ static void peer_change_action(struct peer *peer, afi_t afi, safi_t safi,
struct peer_flag_action {
/* Peer's flag. */
u_int32_t flag;
uint32_t flag;
/* This flag can be set for peer-group member. */
u_char not_for_member;
uint8_t not_for_member;
/* Action when the flag is changed. */
enum peer_change_type type;
/* Peer down cause */
u_char peer_down;
uint8_t peer_down;
};
static const struct peer_flag_action peer_flag_action_list[] = {
@ -3765,7 +3763,7 @@ static const struct peer_flag_action peer_af_flag_action_list[] = {
/* Proper action set. */
static int peer_flag_action_set(const struct peer_flag_action *action_list,
int size, struct peer_flag_action *action,
u_int32_t flag)
uint32_t flag)
{
int i;
int found = 0;
@ -3809,7 +3807,7 @@ static int peer_flag_action_set(const struct peer_flag_action *action_list,
return found;
}
static void peer_flag_modify_action(struct peer *peer, u_int32_t flag)
static void peer_flag_modify_action(struct peer *peer, uint32_t flag)
{
if (flag == PEER_FLAG_SHUTDOWN) {
if (CHECK_FLAG(peer->flags, flag)) {
@ -3840,7 +3838,7 @@ static void peer_flag_modify_action(struct peer *peer, u_int32_t flag)
msglen = 128;
if (msglen) {
u_char msgbuf[129];
uint8_t msgbuf[129];
msgbuf[0] = msglen;
memcpy(msgbuf + 1, msg, msglen);
@ -3874,7 +3872,7 @@ static void peer_flag_modify_action(struct peer *peer, u_int32_t flag)
}
/* Change specified peer flag. */
static int peer_flag_modify(struct peer *peer, u_int32_t flag, int set)
static int peer_flag_modify(struct peer *peer, uint32_t flag, int set)
{
int found;
int size;
@ -3947,18 +3945,18 @@ static int peer_flag_modify(struct peer *peer, u_int32_t flag, int set)
return 0;
}
int peer_flag_set(struct peer *peer, u_int32_t flag)
int peer_flag_set(struct peer *peer, uint32_t flag)
{
return peer_flag_modify(peer, flag, 1);
}
int peer_flag_unset(struct peer *peer, u_int32_t flag)
int peer_flag_unset(struct peer *peer, uint32_t flag)
{
return peer_flag_modify(peer, flag, 0);
}
static int peer_af_flag_modify(struct peer *peer, afi_t afi, safi_t safi,
u_int32_t flag, int set)
uint32_t flag, int set)
{
int found;
int size;
@ -4114,13 +4112,12 @@ static int peer_af_flag_modify(struct peer *peer, afi_t afi, safi_t safi,
return 0;
}
int peer_af_flag_set(struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag)
int peer_af_flag_set(struct peer *peer, afi_t afi, safi_t safi, uint32_t flag)
{
return peer_af_flag_modify(peer, afi, safi, flag, 1);
}
int peer_af_flag_unset(struct peer *peer, afi_t afi, safi_t safi,
u_int32_t flag)
int peer_af_flag_unset(struct peer *peer, afi_t afi, safi_t safi, uint32_t flag)
{
return peer_af_flag_modify(peer, afi, safi, flag, 0);
}
@ -4552,7 +4549,7 @@ int peer_default_originate_unset(struct peer *peer, afi_t afi, safi_t safi)
return 0;
}
int peer_port_set(struct peer *peer, u_int16_t port)
int peer_port_set(struct peer *peer, uint16_t port)
{
peer->port = port;
return 0;
@ -4591,7 +4588,7 @@ static void peer_on_policy_change(struct peer *peer, afi_t afi, safi_t safi,
/* neighbor weight. */
int peer_weight_set(struct peer *peer, afi_t afi, safi_t safi, u_int16_t weight)
int peer_weight_set(struct peer *peer, afi_t afi, safi_t safi, uint16_t weight)
{
struct peer_group *group;
struct listnode *node, *nnode;
@ -4671,7 +4668,7 @@ int peer_weight_unset(struct peer *peer, afi_t afi, safi_t safi)
return 0;
}
int peer_timers_set(struct peer *peer, u_int32_t keepalive, u_int32_t holdtime)
int peer_timers_set(struct peer *peer, uint32_t keepalive, uint32_t holdtime)
{
struct peer_group *group;
struct listnode *node, *nnode;
@ -4752,7 +4749,7 @@ int peer_timers_unset(struct peer *peer)
return 0;
}
int peer_timers_connect_set(struct peer *peer, u_int32_t connect)
int peer_timers_connect_set(struct peer *peer, uint32_t connect)
{
struct peer_group *group;
struct listnode *node, *nnode;
@ -4805,7 +4802,7 @@ int peer_timers_connect_unset(struct peer *peer)
return 0;
}
int peer_advertise_interval_set(struct peer *peer, u_int32_t routeadv)
int peer_advertise_interval_set(struct peer *peer, uint32_t routeadv)
{
struct peer_group *group;
struct listnode *node, *nnode;
@ -5872,8 +5869,8 @@ int peer_unsuppress_map_unset(struct peer *peer, afi_t afi, safi_t safi)
}
int peer_maximum_prefix_set(struct peer *peer, afi_t afi, safi_t safi,
u_int32_t max, u_char threshold, int warning,
u_int16_t restart)
uint32_t max, uint8_t threshold, int warning,
uint16_t restart)
{
struct peer_group *group;
struct listnode *node, *nnode;
@ -6217,7 +6214,7 @@ int peer_clear_soft(struct peer *peer, afi_t afi, safi_t safi,
|| CHECK_FLAG(peer->af_cap[afi][safi],
PEER_CAP_ORF_PREFIX_RM_OLD_RCV))) {
struct bgp_filter *filter = &peer->filter[afi][safi];
u_char prefix_type;
uint8_t prefix_type;
if (CHECK_FLAG(peer->af_cap[afi][safi],
PEER_CAP_ORF_PREFIX_RM_RCV))
@ -6271,7 +6268,7 @@ int peer_clear_soft(struct peer *peer, afi_t afi, safi_t safi,
}
/* Display peer uptime.*/
char *peer_uptime(time_t uptime2, char *buf, size_t len, u_char use_json,
char *peer_uptime(time_t uptime2, char *buf, size_t len, uint8_t use_json,
json_object *json)
{
time_t uptime1, epoch_tbuf;
@ -6281,7 +6278,7 @@ char *peer_uptime(time_t uptime2, char *buf, size_t len, u_char use_json,
if (len < BGP_UPTIME_LEN) {
if (!use_json) {
zlog_warn("peer_uptime (): buffer shortage %lu",
(u_long)len);
(unsigned long)len);
/* XXX: should return status instead of buf... */
snprintf(buf, len, "<error> ");
}

195
bgpd/bgpd.h
View file

@ -60,9 +60,9 @@ enum { AS_UNSPECIFIED = 0,
};
/* Typedef BGP specific types. */
typedef u_int32_t as_t;
typedef u_int16_t as16_t; /* we may still encounter 16 Bit asnums */
typedef u_int16_t bgp_size_t;
typedef uint32_t as_t;
typedef uint16_t as16_t; /* we may still encounter 16 Bit asnums */
typedef uint16_t bgp_size_t;
#define max(a, b) \
({ \
@ -112,7 +112,7 @@ struct bgp_master {
struct list *listen_sockets;
/* BGP port number. */
u_int16_t port;
uint16_t port;
/* Listener address */
char *address;
@ -121,7 +121,7 @@ struct bgp_master {
time_t start_time;
/* Various BGP global configuration. */
u_char options;
uint8_t options;
#define BGP_OPT_NO_FIB (1 << 0)
#define BGP_OPT_MULTIPLE_INSTANCE (1 << 1)
#define BGP_OPT_CONFIG_CISCO (1 << 2)
@ -132,7 +132,7 @@ struct bgp_master {
/* timer to dampen route map changes */
struct thread *t_rmap_update; /* Handle route map updates */
u_int32_t rmap_update_timer; /* Route map update timer */
uint32_t rmap_update_timer; /* Route map update timer */
#define RMAP_DEFAULT_UPDATE_TIMER 5 /* disabled by default */
/* Id space for automatic RD derivation for an EVI/VRF */
@ -149,11 +149,11 @@ struct bgp_rmap {
};
struct bgp_redist {
u_short instance;
unsigned short instance;
/* BGP redistribute metric configuration. */
u_char redist_metric_flag;
u_int32_t redist_metric;
uint8_t redist_metric_flag;
uint32_t redist_metric;
/* BGP redistribute route-map. */
struct bgp_rmap rmap;
@ -216,23 +216,23 @@ struct bgp {
* Global statistics for update groups.
*/
struct {
u_int32_t join_events;
u_int32_t prune_events;
u_int32_t merge_events;
u_int32_t split_events;
u_int32_t updgrp_switch_events;
u_int32_t peer_refreshes_combined;
u_int32_t adj_count;
u_int32_t merge_checks_triggered;
uint32_t join_events;
uint32_t prune_events;
uint32_t merge_events;
uint32_t split_events;
uint32_t updgrp_switch_events;
uint32_t peer_refreshes_combined;
uint32_t adj_count;
uint32_t merge_checks_triggered;
u_int32_t updgrps_created;
u_int32_t updgrps_deleted;
u_int32_t subgrps_created;
u_int32_t subgrps_deleted;
uint32_t updgrps_created;
uint32_t updgrps_deleted;
uint32_t subgrps_created;
uint32_t subgrps_deleted;
} update_group_stats;
/* BGP configuration. */
u_int16_t config;
uint16_t config;
#define BGP_CONFIG_CLUSTER_ID (1 << 0)
#define BGP_CONFIG_CONFEDERATION (1 << 1)
@ -252,45 +252,45 @@ struct bgp {
struct thread
*t_startup; /* start-up timer on only once at the beginning */
u_int32_t v_maxmed_onstartup; /* Duration of max-med on start-up */
uint32_t v_maxmed_onstartup; /* Duration of max-med on start-up */
#define BGP_MAXMED_ONSTARTUP_UNCONFIGURED 0 /* 0 means off, its the default */
u_int32_t maxmed_onstartup_value; /* Max-med value when active on
start-up */
uint32_t maxmed_onstartup_value; /* Max-med value when active on
start-up */
struct thread
*t_maxmed_onstartup; /* non-null when max-med onstartup is on */
u_char maxmed_onstartup_over; /* Flag to make it effective only once */
uint8_t maxmed_onstartup_over; /* Flag to make it effective only once */
u_char v_maxmed_admin; /* 1/0 if max-med administrative is on/off */
uint8_t v_maxmed_admin; /* 1/0 if max-med administrative is on/off */
#define BGP_MAXMED_ADMIN_UNCONFIGURED 0 /* Off by default */
u_int32_t maxmed_admin_value; /* Max-med value when administrative in on
*/
uint32_t maxmed_admin_value; /* Max-med value when administrative in on
*/
#define BGP_MAXMED_VALUE_DEFAULT 4294967294 /* Maximum by default */
u_char maxmed_active; /* 1/0 if max-med is active or not */
u_int32_t maxmed_value; /* Max-med value when its active */
uint8_t maxmed_active; /* 1/0 if max-med is active or not */
uint32_t maxmed_value; /* Max-med value when its active */
/* BGP update delay on startup */
struct thread *t_update_delay;
struct thread *t_establish_wait;
u_char update_delay_over;
u_char main_zebra_update_hold;
u_char main_peers_update_hold;
u_int16_t v_update_delay;
u_int16_t v_establish_wait;
uint8_t update_delay_over;
uint8_t main_zebra_update_hold;
uint8_t main_peers_update_hold;
uint16_t v_update_delay;
uint16_t v_establish_wait;
char update_delay_begin_time[64];
char update_delay_end_time[64];
char update_delay_zebra_resume_time[64];
char update_delay_peers_resume_time[64];
u_int32_t established;
u_int32_t restarted_peers;
u_int32_t implicit_eors;
u_int32_t explicit_eors;
uint32_t established;
uint32_t restarted_peers;
uint32_t implicit_eors;
uint32_t explicit_eors;
#define BGP_UPDATE_DELAY_DEF 0
#define BGP_UPDATE_DELAY_MIN 0
#define BGP_UPDATE_DELAY_MAX 3600
/* BGP flags. */
u_int32_t flags;
uint32_t flags;
#define BGP_FLAG_ALWAYS_COMPARE_MED (1 << 0)
#define BGP_FLAG_DETERMINISTIC_MED (1 << 1)
#define BGP_FLAG_MED_MISSING_AS_WORST (1 << 2)
@ -315,7 +315,7 @@ struct bgp {
#define BGP_FLAG_GRACEFUL_SHUTDOWN (1 << 21)
/* BGP Per AF flags */
u_int16_t af_flags[AFI_MAX][SAFI_MAX];
uint16_t af_flags[AFI_MAX][SAFI_MAX];
#define BGP_CONFIG_DAMPENING (1 << 0)
#define BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT (1 << 1)
#define BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT (1 << 2)
@ -357,36 +357,36 @@ struct bgp {
struct list *redist[AFI_MAX][ZEBRA_ROUTE_MAX];
/* Allocate MPLS labels */
u_char allocate_mpls_labels[AFI_MAX][SAFI_MAX];
uint8_t allocate_mpls_labels[AFI_MAX][SAFI_MAX];
/* timer to re-evaluate neighbor default-originate route-maps */
struct thread *t_rmap_def_originate_eval;
#define RMAP_DEFAULT_ORIGINATE_EVAL_TIMER 5
/* BGP distance configuration. */
u_char distance_ebgp[AFI_MAX][SAFI_MAX];
u_char distance_ibgp[AFI_MAX][SAFI_MAX];
u_char distance_local[AFI_MAX][SAFI_MAX];
uint8_t distance_ebgp[AFI_MAX][SAFI_MAX];
uint8_t distance_ibgp[AFI_MAX][SAFI_MAX];
uint8_t distance_local[AFI_MAX][SAFI_MAX];
/* BGP default local-preference. */
u_int32_t default_local_pref;
uint32_t default_local_pref;
/* BGP default subgroup pkt queue max */
u_int32_t default_subgroup_pkt_queue_max;
uint32_t default_subgroup_pkt_queue_max;
/* BGP default timer. */
u_int32_t default_holdtime;
u_int32_t default_keepalive;
uint32_t default_holdtime;
uint32_t default_keepalive;
/* BGP graceful restart */
u_int32_t restart_time;
u_int32_t stalepath_time;
uint32_t restart_time;
uint32_t stalepath_time;
/* Maximum-paths configuration */
struct bgp_maxpaths_cfg {
u_int16_t maxpaths_ebgp;
u_int16_t maxpaths_ibgp;
u_int16_t ibgp_flags;
uint16_t maxpaths_ebgp;
uint16_t maxpaths_ibgp;
uint16_t ibgp_flags;
#define BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN (1 << 0)
} maxpaths[AFI_MAX][SAFI_MAX];
@ -401,7 +401,7 @@ struct bgp {
/* Auto-shutdown new peers */
bool autoshutdown;
u_int32_t addpath_tx_id;
uint32_t addpath_tx_id;
int addpath_tx_used[AFI_MAX][SAFI_MAX];
#if ENABLE_BGP_VNC
@ -509,11 +509,11 @@ struct peer_group {
/* BGP Notify message format. */
struct bgp_notify {
u_char code;
u_char subcode;
uint8_t code;
uint8_t subcode;
char *data;
bgp_size_t length;
u_char *raw_data;
uint8_t *raw_data;
};
/* Next hop self address. */
@ -535,7 +535,7 @@ struct bgp_nexthop {
#define BGP_RD_SIZE 8
struct bgp_rd {
u_char val[BGP_RD_SIZE];
uint8_t val[BGP_RD_SIZE];
};
#define RMAP_IN 0
@ -719,13 +719,13 @@ struct peer {
struct bgp_nexthop nexthop; /* Nexthop */
/* Peer address family configuration. */
u_char afc[AFI_MAX][SAFI_MAX];
u_char afc_nego[AFI_MAX][SAFI_MAX];
u_char afc_adv[AFI_MAX][SAFI_MAX];
u_char afc_recv[AFI_MAX][SAFI_MAX];
uint8_t afc[AFI_MAX][SAFI_MAX];
uint8_t afc_nego[AFI_MAX][SAFI_MAX];
uint8_t afc_adv[AFI_MAX][SAFI_MAX];
uint8_t afc_recv[AFI_MAX][SAFI_MAX];
/* Capability flags (reset in bgp_stop) */
u_int32_t cap;
uint32_t cap;
#define PEER_CAP_REFRESH_ADV (1 << 0) /* refresh advertised */
#define PEER_CAP_REFRESH_OLD_RCV (1 << 1) /* refresh old received */
#define PEER_CAP_REFRESH_NEW_RCV (1 << 2) /* refresh rfc received */
@ -745,7 +745,7 @@ struct peer {
#define PEER_CAP_HOSTNAME_RCV (1 << 16) /* hostname received */
/* Capability flags (reset in bgp_stop) */
u_int32_t af_cap[AFI_MAX][SAFI_MAX];
uint32_t af_cap[AFI_MAX][SAFI_MAX];
#define PEER_CAP_ORF_PREFIX_SM_ADV (1 << 0) /* send-mode advertised */
#define PEER_CAP_ORF_PREFIX_RM_ADV (1 << 1) /* receive-mode advertised */
#define PEER_CAP_ORF_PREFIX_SM_RCV (1 << 2) /* send-mode received */
@ -763,7 +763,7 @@ struct peer {
#define PEER_CAP_ENHE_AF_NEGO (1 << 14) /* Extended nexthop afi/safi negotiated */
/* Global configuration flags. */
u_int32_t flags;
uint32_t flags;
#define PEER_FLAG_PASSIVE (1 << 0) /* passive mode */
#define PEER_FLAG_SHUTDOWN (1 << 1) /* shutdown */
#define PEER_FLAG_DONT_CAPABILITY (1 << 2) /* dont-capability */
@ -785,10 +785,10 @@ struct peer {
char *tx_shutdown_message;
/* NSF mode (graceful restart) */
u_char nsf[AFI_MAX][SAFI_MAX];
uint8_t nsf[AFI_MAX][SAFI_MAX];
/* Per AF configuration flags. */
u_int32_t af_flags[AFI_MAX][SAFI_MAX];
uint32_t af_flags[AFI_MAX][SAFI_MAX];
#define PEER_FLAG_SEND_COMMUNITY (1 << 0) /* send-community */
#define PEER_FLAG_SEND_EXT_COMMUNITY (1 << 1) /* send-community ext. */
#define PEER_FLAG_NEXTHOP_SELF (1 << 2) /* next-hop-self */
@ -827,7 +827,7 @@ struct peer {
} default_rmap[AFI_MAX][SAFI_MAX];
/* Peer status flags. */
u_int16_t sflags;
uint16_t sflags;
#define PEER_STATUS_ACCEPT_PEER (1 << 0) /* accept peer */
#define PEER_STATUS_PREFIX_OVERFLOW (1 << 1) /* prefix-overflow */
#define PEER_STATUS_CAPABILITY_OPEN (1 << 2) /* capability open send */
@ -837,7 +837,7 @@ struct peer {
#define PEER_STATUS_NSF_WAIT (1 << 6) /* wait comeback peer */
/* Peer status af flags (reset in bgp_stop) */
u_int16_t af_sflags[AFI_MAX][SAFI_MAX];
uint16_t af_sflags[AFI_MAX][SAFI_MAX];
#define PEER_STATUS_ORF_PREFIX_SEND (1 << 0) /* prefix-list send peer */
#define PEER_STATUS_ORF_WAIT_REFRESH (1 << 1) /* wait refresh received peer */
#define PEER_STATUS_PREFIX_THRESHOLD (1 << 2) /* exceed prefix-threshold */
@ -846,7 +846,7 @@ struct peer {
#define PEER_STATUS_EOR_RECEIVED (1 << 5) /* end-of-rib received from peer */
/* Default attribute value for the peer. */
u_int32_t config;
uint32_t config;
#define PEER_CONFIG_TIMER (1 << 0) /* keepalive & holdtime */
#define PEER_CONFIG_CONNECT (1 << 1) /* connect */
#define PEER_CONFIG_ROUTEADV (1 << 2) /* route advertise */
@ -933,11 +933,11 @@ struct peer {
_Atomic uint32_t dynamic_cap_out; /* Dynamic Capability output count. */
/* BGP state count */
u_int32_t established; /* Established */
u_int32_t dropped; /* Dropped */
uint32_t established; /* Established */
uint32_t dropped; /* Dropped */
/* Update delay related fields */
u_char update_delay_over; /* When this is set, BGP is no more waiting
uint8_t update_delay_over; /* When this is set, BGP is no more waiting
for EOR */
/* Syncronization list and time. */
@ -971,8 +971,8 @@ struct peer {
/* Max prefix count. */
unsigned long pmax[AFI_MAX][SAFI_MAX];
u_char pmax_threshold[AFI_MAX][SAFI_MAX];
u_int16_t pmax_restart[AFI_MAX][SAFI_MAX];
uint8_t pmax_threshold[AFI_MAX][SAFI_MAX];
uint16_t pmax_restart[AFI_MAX][SAFI_MAX];
#define MAXIMUM_PREFIX_THRESHOLD_DEFAULT 75
/* allowas-in. */
@ -1010,10 +1010,10 @@ struct peer {
#define PEER_DOWN_IF_DOWN 25 /* Interface down */
#define PEER_DOWN_NBR_ADDR_DEL 26 /* Peer address lost */
unsigned long last_reset_cause_size;
u_char last_reset_cause[BGP_MAX_PACKET_SIZE];
uint8_t last_reset_cause[BGP_MAX_PACKET_SIZE];
/* The kind of route-map Flags.*/
u_char rmap_type;
uint8_t rmap_type;
#define PEER_RMAP_TYPE_IN (1 << 0) /* neighbor route-map in */
#define PEER_RMAP_TYPE_OUT (1 << 1) /* neighbor route-map out */
#define PEER_RMAP_TYPE_NETWORK (1 << 2) /* network route-map */
@ -1052,7 +1052,7 @@ struct bgp_nlri {
uint8_t safi; /* iana_safi_t */
/* Pointer to NLRI byte stream. */
u_char *nlri;
uint8_t *nlri;
/* Length of whole NLRI. */
bgp_size_t length;
@ -1353,7 +1353,7 @@ extern struct peer *peer_create(union sockunion *, const char *, struct bgp *,
struct peer_group *);
extern struct peer *peer_create_accept(struct bgp *);
extern void peer_xfer_config(struct peer *dst, struct peer *src);
extern char *peer_uptime(time_t, char *, size_t, u_char, json_object *);
extern char *peer_uptime(time_t, char *, size_t, uint8_t, json_object *);
extern int bgp_config_write(struct vty *);
@ -1394,14 +1394,13 @@ extern int bgp_confederation_peers_check(struct bgp *, as_t);
extern int bgp_confederation_peers_add(struct bgp *, as_t);
extern int bgp_confederation_peers_remove(struct bgp *, as_t);
extern int bgp_timers_set(struct bgp *, u_int32_t keepalive,
u_int32_t holdtime);
extern int bgp_timers_set(struct bgp *, uint32_t keepalive, uint32_t holdtime);
extern int bgp_timers_unset(struct bgp *);
extern int bgp_default_local_preference_set(struct bgp *, u_int32_t);
extern int bgp_default_local_preference_set(struct bgp *, uint32_t);
extern int bgp_default_local_preference_unset(struct bgp *);
extern int bgp_default_subgroup_pkt_queue_max_set(struct bgp *bgp, u_int32_t);
extern int bgp_default_subgroup_pkt_queue_max_set(struct bgp *bgp, uint32_t);
extern int bgp_default_subgroup_pkt_queue_max_unset(struct bgp *bgp);
extern int bgp_listen_limit_set(struct bgp *, int);
@ -1427,12 +1426,12 @@ extern int peer_group_bind(struct bgp *, union sockunion *, struct peer *,
struct peer_group *, as_t *);
extern int peer_group_unbind(struct bgp *, struct peer *, struct peer_group *);
extern int peer_flag_set(struct peer *, u_int32_t);
extern int peer_flag_unset(struct peer *, u_int32_t);
extern int peer_flag_set(struct peer *, uint32_t);
extern int peer_flag_unset(struct peer *, uint32_t);
extern int peer_af_flag_set(struct peer *, afi_t, safi_t, u_int32_t);
extern int peer_af_flag_unset(struct peer *, afi_t, safi_t, u_int32_t);
extern int peer_af_flag_check(struct peer *, afi_t, safi_t, u_int32_t);
extern int peer_af_flag_set(struct peer *, afi_t, safi_t, uint32_t);
extern int peer_af_flag_unset(struct peer *, afi_t, safi_t, uint32_t);
extern int peer_af_flag_check(struct peer *, afi_t, safi_t, uint32_t);
extern int peer_ebgp_multihop_set(struct peer *, int);
extern int peer_ebgp_multihop_unset(struct peer *);
@ -1449,20 +1448,20 @@ extern int peer_default_originate_set(struct peer *, afi_t, safi_t,
const char *);
extern int peer_default_originate_unset(struct peer *, afi_t, safi_t);
extern int peer_port_set(struct peer *, u_int16_t);
extern int peer_port_set(struct peer *, uint16_t);
extern int peer_port_unset(struct peer *);
extern int peer_weight_set(struct peer *, afi_t, safi_t, u_int16_t);
extern int peer_weight_set(struct peer *, afi_t, safi_t, uint16_t);
extern int peer_weight_unset(struct peer *, afi_t, safi_t);
extern int peer_timers_set(struct peer *, u_int32_t keepalive,
u_int32_t holdtime);
extern int peer_timers_set(struct peer *, uint32_t keepalive,
uint32_t holdtime);
extern int peer_timers_unset(struct peer *);
extern int peer_timers_connect_set(struct peer *, u_int32_t);
extern int peer_timers_connect_set(struct peer *, uint32_t);
extern int peer_timers_connect_unset(struct peer *);
extern int peer_advertise_interval_set(struct peer *, u_int32_t);
extern int peer_advertise_interval_set(struct peer *, uint32_t);
extern int peer_advertise_interval_unset(struct peer *);
extern void peer_interface_set(struct peer *, const char *);
@ -1494,8 +1493,8 @@ extern int peer_password_unset(struct peer *);
extern int peer_unsuppress_map_unset(struct peer *, afi_t, safi_t);
extern int peer_maximum_prefix_set(struct peer *, afi_t, safi_t, u_int32_t,
u_char, int, u_int16_t);
extern int peer_maximum_prefix_set(struct peer *, afi_t, safi_t, uint32_t,
uint8_t, int, uint16_t);
extern int peer_maximum_prefix_unset(struct peer *, afi_t, safi_t);
extern int peer_clear(struct peer *, struct listnode **);

7
bgpd/rfapi/rfapi_backend.h
View file

@ -37,13 +37,14 @@ void bgp_rfapi_destroy(struct bgp *bgp, struct rfapi *h);
extern void rfapiProcessUpdate(struct peer *peer, void *rfd, struct prefix *p,
struct prefix_rd *prd, struct attr *attr,
afi_t afi, safi_t safi, u_char type,
u_char sub_type, uint32_t *label);
afi_t afi, safi_t safi, uint8_t type,
uint8_t sub_type, uint32_t *label);
extern void rfapiProcessWithdraw(struct peer *peer, void *rfd, struct prefix *p,
struct prefix_rd *prd, struct attr *attr,
afi_t afi, safi_t safi, u_char type, int kill);
afi_t afi, safi_t safi, uint8_t type,
int kill);
extern void rfapiProcessPeerDown(struct peer *peer);

24
bgpd/rfapi/rfapi_import.c
View file

@ -503,7 +503,7 @@ int rfapiGetUnAddrOfVpnBi(struct bgp_info *bi, struct prefix *p)
*/
static struct bgp_info *rfapiBgpInfoCreate(struct attr *attr, struct peer *peer,
void *rfd, struct prefix_rd *prd,
u_char type, u_char sub_type,
uint8_t type, uint8_t sub_type,
uint32_t *label)
{
struct bgp_info *new;
@ -2879,7 +2879,7 @@ typedef void(rfapi_bi_filtered_import_f)(struct rfapi_import_table *, int,
struct peer *, void *, struct prefix *,
struct prefix *, afi_t,
struct prefix_rd *, struct attr *,
u_char, u_char, uint32_t *);
uint8_t, uint8_t, uint32_t *);
static void rfapiExpireEncapNow(struct rfapi_import_table *it,
@ -2932,8 +2932,8 @@ static void rfapiBgpInfoFilteredImportEncap(
struct prefix *aux_prefix, /* Unused for encap routes */
afi_t afi, struct prefix_rd *prd,
struct attr *attr, /* part of bgp_info */
u_char type, /* part of bgp_info */
u_char sub_type, /* part of bgp_info */
uint8_t type, /* part of bgp_info */
uint8_t sub_type, /* part of bgp_info */
uint32_t *label) /* part of bgp_info */
{
struct route_table *rt = NULL;
@ -3391,8 +3391,8 @@ void rfapiBgpInfoFilteredImportVPN(
struct prefix *aux_prefix, /* AFI_L2VPN: optional IP */
afi_t afi, struct prefix_rd *prd,
struct attr *attr, /* part of bgp_info */
u_char type, /* part of bgp_info */
u_char sub_type, /* part of bgp_info */
uint8_t type, /* part of bgp_info */
uint8_t sub_type, /* part of bgp_info */
uint32_t *label) /* part of bgp_info */
{
struct route_table *rt = NULL;
@ -3869,8 +3869,8 @@ static void rfapiBgpInfoFilteredImportBadSafi(
struct prefix *aux_prefix, /* AFI_L2VPN: optional IP */
afi_t afi, struct prefix_rd *prd,
struct attr *attr, /* part of bgp_info */
u_char type, /* part of bgp_info */
u_char sub_type, /* part of bgp_info */
uint8_t type, /* part of bgp_info */
uint8_t sub_type, /* part of bgp_info */
uint32_t *label) /* part of bgp_info */
{
vnc_zlog_debug_verbose("%s: Error, bad safi", __func__);
@ -3896,8 +3896,8 @@ rfapiBgpInfoFilteredImportFunction(safi_t safi)
void rfapiProcessUpdate(struct peer *peer,
void *rfd, /* set when looped from RFP/RFAPI */
struct prefix *p, struct prefix_rd *prd,
struct attr *attr, afi_t afi, safi_t safi, u_char type,
u_char sub_type, uint32_t *label)
struct attr *attr, afi_t afi, safi_t safi, uint8_t type,
uint8_t sub_type, uint32_t *label)
{
struct bgp *bgp;
struct rfapi *h;
@ -3981,7 +3981,7 @@ void rfapiProcessUpdate(struct peer *peer,
void rfapiProcessWithdraw(struct peer *peer, void *rfd, struct prefix *p,
struct prefix_rd *prd, struct attr *attr, afi_t afi,
safi_t safi, u_char type, int kill)
safi_t safi, uint8_t type, int kill)
{
struct bgp *bgp;
struct rfapi *h;
@ -4232,7 +4232,7 @@ static void rfapiBgpTableFilteredImport(struct bgp *bgp,
struct bgp_info *bi;
for (bi = rn2->info; bi; bi = bi->next) {
u_int32_t label = 0;
uint32_t label = 0;
if (CHECK_FLAG(bi->flags,
BGP_INFO_REMOVED))

4
bgpd/rfapi/rfapi_import.h
View file

@ -148,8 +148,8 @@ extern void rfapiBgpInfoFilteredImportVPN(
struct prefix *aux_prefix, /* AFI_ETHER: optional IP */
afi_t afi, struct prefix_rd *prd,
struct attr *attr, /* part of bgp_info */
u_char type, /* part of bgp_info */
u_char sub_type, /* part of bgp_info */
uint8_t type, /* part of bgp_info */
uint8_t sub_type, /* part of bgp_info */
uint32_t *label); /* part of bgp_info */
extern struct rfapi_next_hop_entry *rfapiEthRouteNode2NextHopList(

6
bgpd/rfapi/rfapi_vty.c
View file

@ -1068,7 +1068,7 @@ static int rfapiPrintRemoteRegBi(struct bgp *bgp, void *stream,
inet_ntop(pfx_vn.family, &pfx_vn.u.prefix, buf_ntop,
BUFSIZ));
if (bi->extra) {
u_int32_t l = decode_label(&bi->extra->label[0]);
uint32_t l = decode_label(&bi->extra->label[0]);
snprintf(buf_vn, BUFSIZ, "Label: %d", l);
} else /* should never happen */
{
@ -1180,7 +1180,7 @@ static int rfapiPrintRemoteRegBi(struct bgp *bgp, void *stream,
}
}
if (tun_type != BGP_ENCAP_TYPE_MPLS && bi->extra) {
u_int32_t l = decode_label(&bi->extra->label[0]);
uint32_t l = decode_label(&bi->extra->label[0]);
if (!MPLS_LABEL_IS_NULL(l)) {
fp(out, " Label: %d", l);
if (nlines == 1)
@ -1631,7 +1631,7 @@ void rfapiPrintDescriptor(struct vty *vty, struct rfapi_descriptor *rfd)
}
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
u_char family;
uint8_t family;
family = afi2family(afi);
if (!family)

4
bgpd/rfapi/vnc_export_table.h
View file

@ -39,8 +39,8 @@ struct vnc_export_info {
struct vnc_export_info *next;
struct route_node *node;
struct peer *peer;
u_char type;
u_char subtype;
uint8_t type;
uint8_t subtype;
uint32_t lifetime;
struct thread *timer;
};

24
bgpd/rfapi/vnc_import_bgp.c
View file

@ -124,14 +124,14 @@ struct prefix_bag {
struct bgp_info *ubi; /* unicast route */
};
static const u_char maskbit[] = {0x00, 0x80, 0xc0, 0xe0, 0xf0,
0xf8, 0xfc, 0xfe, 0xff};
static const uint8_t maskbit[] = {0x00, 0x80, 0xc0, 0xe0, 0xf0,
0xf8, 0xfc, 0xfe, 0xff};
int vnc_prefix_cmp(void *pfx1, void *pfx2)
{
int offset;
int shift;
u_char mask;
uint8_t mask;
struct prefix *p1 = pfx1;
struct prefix *p2 = pfx2;
@ -154,8 +154,8 @@ int vnc_prefix_cmp(void *pfx1, void *pfx2)
}
/* Set both prefix's head pointer. */
const u_char *pp1 = (const u_char *)&p1->u.prefix;
const u_char *pp2 = (const u_char *)&p2->u.prefix;
const uint8_t *pp1 = (const uint8_t *)&p1->u.prefix;
const uint8_t *pp2 = (const uint8_t *)&p2->u.prefix;
while (offset--) {
if (*pp1 < *pp2)
@ -1762,7 +1762,7 @@ static void vnc_import_bgp_exterior_add_route_it(
bi_interior = bi_interior->next) {
struct prefix_rd *prd;
struct attr new_attr;
u_int32_t label = 0;
uint32_t label = 0;
if (!is_usable_interior_route(bi_interior))
continue;
@ -1941,7 +1941,7 @@ void vnc_import_bgp_exterior_del_route(
for (bi_interior = rn->info; bi_interior;
bi_interior = bi_interior->next) {
struct prefix_rd *prd;
u_int32_t label = 0;
uint32_t label = 0;
if (!is_usable_interior_route(bi_interior))
continue;
@ -2102,7 +2102,7 @@ void vnc_import_bgp_exterior_add_route_interior(
struct prefix_rd *prd;
struct attr new_attr;
u_int32_t label = 0;
uint32_t label = 0;
++count; /* debugging */
@ -2194,7 +2194,7 @@ void vnc_import_bgp_exterior_add_route_interior(
struct bgp_info *bi;
struct prefix_rd *prd;
struct attr new_attr;
u_int32_t label = 0;
uint32_t label = 0;
/* do pull-down */
@ -2336,7 +2336,7 @@ void vnc_import_bgp_exterior_add_route_interior(
struct prefix_rd *prd;
struct attr new_attr;
u_int32_t label = 0;
uint32_t label = 0;
/* do pull-down */
@ -2476,7 +2476,7 @@ void vnc_import_bgp_exterior_del_route_interior(
&cursor)) {
struct prefix_rd *prd;
u_int32_t label = 0;
uint32_t label = 0;
if (bi_interior->extra) {
prd = &bi_interior->extra->vnc.import.rd;
@ -2549,7 +2549,7 @@ void vnc_import_bgp_exterior_del_route_interior(
struct prefix_rd *prd;
struct attr new_attr;
u_int32_t label = 0;
uint32_t label = 0;
if (bi->type == ZEBRA_ROUTE_BGP_DIRECT_EXT)
continue;

4
bgpd/rfapi/vnc_zebra.c
View file

@ -58,7 +58,7 @@ static struct zclient *zclient_vnc = NULL;
/*
* Routes coming from zebra get added to VNC here
*/
static void vnc_redistribute_add(struct prefix *p, u_int32_t metric,
static void vnc_redistribute_add(struct prefix *p, uint32_t metric,
uint8_t type)
{
struct bgp *bgp = bgp_get_default();
@ -436,7 +436,7 @@ static void vnc_zebra_route_msg(struct prefix *p, unsigned int nhp_count,
static void
nve_list_to_nh_array(u_char family, struct list *nve_list,
nve_list_to_nh_array(uint8_t family, struct list *nve_list,
unsigned int *nh_count_ret,
void **nh_ary_ret, /* returned address array */
void **nhp_ary_ret) /* returned pointer array */

2
doc/developer/cli.rst
View file

@ -650,7 +650,7 @@ struct cmd\_token
struct cmd_token
{
enum cmd_token_type type; // token type
u_char attr; // token attributes
uint8_t attr; // token attributes
bool allowrepeat; // matcher allowed to match token repetitively?
char *text; // token text

26
doc/developer/next-hop-tracking.rst
View file

@ -264,19 +264,19 @@ Zebra data structure
RNH table::
O
/ \
O O
/ \
O O
struct rnh
{
u_char flags;
struct route_entry *state;
struct list *client_list;
struct route_node *node;
};
. O
/ \
O O
/ \
O O
struct rnh
{
uint8_t flags;
struct route_entry *state;
struct list *client_list;
struct route_node *node;
};
User interface changes
~~~~~~~~~~~~~~~~~~~~~~

12
eigrpd/eigrp_dump.c
View file

@ -117,11 +117,11 @@ void eigrp_ip_header_dump(struct ip *iph)
zlog_debug("ip_hl %u", iph->ip_hl);
zlog_debug("ip_tos %u", iph->ip_tos);
zlog_debug("ip_len %u", iph->ip_len);
zlog_debug("ip_id %u", (u_int32_t)iph->ip_id);
zlog_debug("ip_off %u", (u_int32_t)iph->ip_off);
zlog_debug("ip_id %u", (uint32_t)iph->ip_id);
zlog_debug("ip_off %u", (uint32_t)iph->ip_off);
zlog_debug("ip_ttl %u", iph->ip_ttl);
zlog_debug("ip_p %u", iph->ip_p);
zlog_debug("ip_sum 0x%x", (u_int32_t)iph->ip_sum);
zlog_debug("ip_sum 0x%x", (uint32_t)iph->ip_sum);
zlog_debug("ip_src %s", inet_ntoa(iph->ip_src));
zlog_debug("ip_dst %s", inet_ntoa(iph->ip_dst));
}
@ -156,7 +156,7 @@ const char *eigrp_if_name_string(struct eigrp_interface *ei)
const char *eigrp_topology_ip_string(struct eigrp_prefix_entry *tn)
{
static char buf[EIGRP_IF_STRING_MAXLEN] = "";
u_int32_t ifaddr;
uint32_t ifaddr;
ifaddr = ntohl(tn->destination->u.prefix4.s_addr);
snprintf(buf, EIGRP_IF_STRING_MAXLEN, "%u.%u.%u.%u",
@ -169,7 +169,7 @@ const char *eigrp_topology_ip_string(struct eigrp_prefix_entry *tn)
const char *eigrp_if_ip_string(struct eigrp_interface *ei)
{
static char buf[EIGRP_IF_STRING_MAXLEN] = "";
u_int32_t ifaddr;
uint32_t ifaddr;
if (!ei)
return "inactive";
@ -185,7 +185,7 @@ const char *eigrp_if_ip_string(struct eigrp_interface *ei)
const char *eigrp_neigh_ip_string(struct eigrp_neighbor *nbr)
{
static char buf[EIGRP_IF_STRING_MAXLEN] = "";
u_int32_t ifaddr;
uint32_t ifaddr;
ifaddr = ntohl(nbr->src.s_addr);
snprintf(buf, EIGRP_IF_STRING_MAXLEN, "%u.%u.%u.%u",

4
eigrpd/eigrp_fsm.c
View file

@ -170,7 +170,7 @@ struct {
},
};
static const char *packet_type2str(u_char packet_type)
static const char *packet_type2str(uint8_t packet_type)
{
if (packet_type == EIGRP_OPC_UPDATE)
return "Update";
@ -264,7 +264,7 @@ eigrp_get_fsm_event(struct eigrp_fsm_action_message *msg)
// struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct eigrp_nexthop_entry *entry = msg->entry;
u_char actual_state = prefix->state;
uint8_t actual_state = prefix->state;
enum metric_change change;
if (entry == NULL) {

56
eigrpd/eigrp_hello.c
View file

@ -108,7 +108,7 @@ int eigrp_hello_timer(struct thread *thread)
* @param[in] nbr neighbor the ACK should be sent to
* @param[in] param pointer packet TLV is stored to
*
* @return u_int16_t number of bytes added to packet stream
* @return uint16_t number of bytes added to packet stream
*
* @par
* Encode Parameter TLV, used to convey metric weights and the hold time.
@ -183,7 +183,7 @@ eigrp_hello_parameter_decode(struct eigrp_neighbor *nbr,
return nbr;
}
static u_char
static uint8_t
eigrp_hello_authentication_decode(struct stream *s,
struct eigrp_tlv_hdr_type *tlv_header,
struct eigrp_neighbor *nbr)
@ -268,15 +268,15 @@ static void eigrp_peer_termination_decode(struct eigrp_neighbor *nbr,
* @param[in] nbr_addr pointer to neighbor address for Peer
* Termination TLV
*
* @return u_int16_t number of bytes added to packet stream
* @return uint16_t number of bytes added to packet stream
*
* @par
* Function used to encode Peer Termination TLV to Hello packet.
*/
static u_int16_t eigrp_peer_termination_encode(struct stream *s,
struct in_addr *nbr_addr)
static uint16_t eigrp_peer_termination_encode(struct stream *s,
struct in_addr *nbr_addr)
{
u_int16_t length = EIGRP_TLV_PEER_TERMINATION_LEN;
uint16_t length = EIGRP_TLV_PEER_TERMINATION_LEN;
/* fill in type and length */
stream_putw(s, EIGRP_TLV_PEER_TERMINATION);
@ -405,8 +405,8 @@ void eigrp_hello_receive(struct eigrp *eigrp, struct ip *iph,
inet_ntoa(nbr->src));
}
u_int32_t FRR_MAJOR;
u_int32_t FRR_MINOR;
uint32_t FRR_MAJOR;
uint32_t FRR_MINOR;
void eigrp_sw_version_initialize(void)
{
@ -428,16 +428,16 @@ void eigrp_sw_version_initialize(void)
*
* @param[in,out] s packet stream TLV is stored to
*
* @return u_int16_t number of bytes added to packet stream
* @return uint16_t number of bytes added to packet stream
*
* @par
* Store the software version in the specified location.
* This consists of two bytes of OS version, and two bytes of EIGRP
* revision number.
*/
static u_int16_t eigrp_sw_version_encode(struct stream *s)
static uint16_t eigrp_sw_version_encode(struct stream *s)
{
u_int16_t length = EIGRP_TLV_SW_VERSION_LEN;
uint16_t length = EIGRP_TLV_SW_VERSION_LEN;
// setup the tlv fields
stream_putw(s, EIGRP_TLV_SW_VERSION);
@ -464,9 +464,9 @@ static u_int16_t eigrp_sw_version_encode(struct stream *s)
* If doing mutli-topology, then store the supported TID list.
* This is currently a place holder function
*/
static u_int16_t eigrp_tidlist_encode(struct stream *s)
static uint16_t eigrp_tidlist_encode(struct stream *s)
{
// u_int16_t length = EIGRP_TLV_SW_VERSION_LEN;
// uint16_t length = EIGRP_TLV_SW_VERSION_LEN;
return 0;
}
@ -475,15 +475,15 @@ static u_int16_t eigrp_tidlist_encode(struct stream *s)
*
* @param[in,out] s packet stream TLV is stored to
*
* @return u_int16_t number of bytes added to packet stream
* @return uint16_t number of bytes added to packet stream
*
* @par
* Part of conditional receive process
*
*/
static u_int16_t eigrp_sequence_encode(struct stream *s)
static uint16_t eigrp_sequence_encode(struct stream *s)
{
u_int16_t length = EIGRP_TLV_SEQ_BASE_LEN;
uint16_t length = EIGRP_TLV_SEQ_BASE_LEN;
struct eigrp *eigrp;
struct eigrp_interface *ei;
struct listnode *node, *node2, *nnode2;
@ -507,7 +507,7 @@ static u_int16_t eigrp_sequence_encode(struct stream *s)
for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, node, ei)) {
for (ALL_LIST_ELEMENTS(ei->nbrs, node2, nnode2, nbr)) {
if (nbr->multicast_queue->count > 0) {
length += (u_int16_t)stream_put_ipv4(
length += (uint16_t)stream_put_ipv4(
s, nbr->src.s_addr);
found = 1;
}
@ -532,15 +532,15 @@ static u_int16_t eigrp_sequence_encode(struct stream *s)
*
* @param[in,out] s packet stream TLV is stored to
*
* @return u_int16_t number of bytes added to packet stream
* @return uint16_t number of bytes added to packet stream
*
* @par
* Part of conditional receive process
*
*/
static u_int16_t eigrp_next_sequence_encode(struct stream *s)
static uint16_t eigrp_next_sequence_encode(struct stream *s)
{
u_int16_t length = EIGRP_NEXT_SEQUENCE_TLV_SIZE;
uint16_t length = EIGRP_NEXT_SEQUENCE_TLV_SIZE;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
@ -562,7 +562,7 @@ static u_int16_t eigrp_next_sequence_encode(struct stream *s)
* @param[in] ei pointer to interface hello packet came in on
* @param[in,out] s packet stream TLV is stored to
*
* @return u_int16_t number of bytes added to packet stream
* @return uint16_t number of bytes added to packet stream
*
* @par
* Encode Parameter TLV, used to convey metric weights and the hold time.
@ -571,10 +571,10 @@ static u_int16_t eigrp_next_sequence_encode(struct stream *s)
* Note the addition of K6 for the new extended metrics, and does not apply to
* older TLV packet formats.
*/
static u_int16_t eigrp_hello_parameter_encode(struct eigrp_interface *ei,
struct stream *s, u_char flags)
static uint16_t eigrp_hello_parameter_encode(struct eigrp_interface *ei,
struct stream *s, uint8_t flags)
{
u_int16_t length = EIGRP_TLV_PARAMETER_LEN;
uint16_t length = EIGRP_TLV_PARAMETER_LEN;
// add in the parameters TLV
stream_putw(s, EIGRP_TLV_PARAMETER);
@ -622,12 +622,12 @@ static u_int16_t eigrp_hello_parameter_encode(struct eigrp_interface *ei,
*
*/
static struct eigrp_packet *eigrp_hello_encode(struct eigrp_interface *ei,
in_addr_t addr, u_int32_t ack,
u_char flags,
in_addr_t addr, uint32_t ack,
uint8_t flags,
struct in_addr *nbr_addr)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
// allocate a new packet to be sent
ep = eigrp_packet_new(ei->ifp->mtu, NULL);
@ -749,7 +749,7 @@ void eigrp_hello_send_ack(struct eigrp_neighbor *nbr)
* sending. If no packets are currently queues, the packet will be
* sent immadiatly
*/
void eigrp_hello_send(struct eigrp_interface *ei, u_char flags,
void eigrp_hello_send(struct eigrp_interface *ei, uint8_t flags,
struct in_addr *nbr_addr)
{
struct eigrp_packet *ep = NULL;

14
eigrpd/eigrp_interface.c
View file

@ -320,7 +320,7 @@ void eigrp_if_set_multicast(struct eigrp_interface *ei)
}
}
u_char eigrp_default_iftype(struct interface *ifp)
uint8_t eigrp_default_iftype(struct interface *ifp)
{
if (if_is_pointopoint(ifp))
return EIGRP_IFTYPE_POINTOPOINT;
@ -413,32 +413,32 @@ struct eigrp_interface *eigrp_if_lookup_by_name(struct eigrp *eigrp,
return NULL;
}
u_int32_t eigrp_bandwidth_to_scaled(u_int32_t bandwidth)
uint32_t eigrp_bandwidth_to_scaled(uint32_t bandwidth)
{
uint64_t temp_bandwidth = (256ull * 10000000) / bandwidth;
temp_bandwidth = temp_bandwidth < EIGRP_MAX_METRIC ? temp_bandwidth
: EIGRP_MAX_METRIC;
return (u_int32_t)temp_bandwidth;
return (uint32_t)temp_bandwidth;
}
u_int32_t eigrp_scaled_to_bandwidth(u_int32_t scaled)
uint32_t eigrp_scaled_to_bandwidth(uint32_t scaled)
{
uint64_t temp_scaled = scaled * (256ull * 10000000);
temp_scaled =
temp_scaled < EIGRP_MAX_METRIC ? temp_scaled : EIGRP_MAX_METRIC;
return (u_int32_t)temp_scaled;
return (uint32_t)temp_scaled;
}
u_int32_t eigrp_delay_to_scaled(u_int32_t delay)
uint32_t eigrp_delay_to_scaled(uint32_t delay)
{
return delay * 256;
}
u_int32_t eigrp_scaled_to_delay(u_int32_t scaled)
uint32_t eigrp_scaled_to_delay(uint32_t scaled)
{
return scaled / 256;
}

10
eigrpd/eigrp_interface.h
View file

@ -44,7 +44,7 @@ extern struct eigrp_interface *eigrp_if_new(struct eigrp *, struct interface *,
extern int eigrp_if_up(struct eigrp_interface *);
extern void eigrp_if_stream_set(struct eigrp_interface *);
extern void eigrp_if_set_multicast(struct eigrp_interface *);
extern u_char eigrp_default_iftype(struct interface *);
extern uint8_t eigrp_default_iftype(struct interface *);
extern void eigrp_if_free(struct eigrp_interface *, int);
extern int eigrp_if_down(struct eigrp_interface *);
extern void eigrp_if_stream_unset(struct eigrp_interface *);
@ -58,10 +58,10 @@ extern struct eigrp_interface *eigrp_if_lookup_by_name(struct eigrp *,
/* Simulate down/up on the interface. */
extern void eigrp_if_reset(struct interface *);
extern u_int32_t eigrp_bandwidth_to_scaled(u_int32_t);
extern u_int32_t eigrp_scaled_to_bandwidth(u_int32_t);
extern u_int32_t eigrp_delay_to_scaled(u_int32_t);
extern u_int32_t eigrp_scaled_to_delay(u_int32_t);
extern uint32_t eigrp_bandwidth_to_scaled(uint32_t);
extern uint32_t eigrp_scaled_to_bandwidth(uint32_t);
extern uint32_t eigrp_delay_to_scaled(uint32_t);
extern uint32_t eigrp_scaled_to_delay(uint32_t);
#endif /* ZEBRA_EIGRP_INTERFACE_H_ */

6
eigrpd/eigrp_neighbor.c
View file

@ -206,12 +206,12 @@ int holddown_timer_expired(struct thread *thread)
return 0;
}
u_char eigrp_nbr_state_get(struct eigrp_neighbor *nbr)
uint8_t eigrp_nbr_state_get(struct eigrp_neighbor *nbr)
{
return (nbr->state);
}
void eigrp_nbr_state_set(struct eigrp_neighbor *nbr, u_char state)
void eigrp_nbr_state_set(struct eigrp_neighbor *nbr, uint8_t state)
{
nbr->state = state;
@ -302,7 +302,7 @@ int eigrp_nbr_count_get(void)
struct listnode *node, *node2, *nnode2;
struct eigrp_neighbor *nbr;
struct eigrp *eigrp = eigrp_lookup();
u_int32_t counter;
uint32_t counter;
if (eigrp == NULL) {
zlog_debug("EIGRP Routing Process not enabled");

4
eigrpd/eigrp_neighbor.h
View file

@ -43,8 +43,8 @@ extern int holddown_timer_expired(struct thread *);
extern int eigrp_neighborship_check(struct eigrp_neighbor *,
struct TLV_Parameter_Type *);
extern void eigrp_nbr_state_update(struct eigrp_neighbor *);
extern void eigrp_nbr_state_set(struct eigrp_neighbor *, u_char state);
extern u_char eigrp_nbr_state_get(struct eigrp_neighbor *);
extern void eigrp_nbr_state_set(struct eigrp_neighbor *, uint8_t state);
extern uint8_t eigrp_nbr_state_get(struct eigrp_neighbor *);
extern int eigrp_nbr_count_get(void);
extern const char *eigrp_nbr_state_str(struct eigrp_neighbor *);
extern struct eigrp_neighbor *eigrp_nbr_lookup_by_addr(struct eigrp_interface *,

20
eigrpd/eigrp_network.c
View file

@ -150,7 +150,7 @@ void eigrp_adjust_sndbuflen(struct eigrp *eigrp, unsigned int buflen)
int eigrp_if_ipmulticast(struct eigrp *top, struct prefix *p,
unsigned int ifindex)
{
u_char val;
uint8_t val;
int ret, len;
val = 0;
@ -368,8 +368,8 @@ int eigrp_network_unset(struct eigrp *eigrp, struct prefix *p)
return 1;
}
u_int32_t eigrp_calculate_metrics(struct eigrp *eigrp,
struct eigrp_metrics metric)
uint32_t eigrp_calculate_metrics(struct eigrp *eigrp,
struct eigrp_metrics metric)
{
uint64_t temp_metric;
temp_metric = 0;
@ -396,13 +396,13 @@ u_int32_t eigrp_calculate_metrics(struct eigrp *eigrp,
+ eigrp->k_values[3]);
if (temp_metric <= EIGRP_MAX_METRIC)
return (u_int32_t)temp_metric;
return (uint32_t)temp_metric;
else
return EIGRP_MAX_METRIC;
}
u_int32_t eigrp_calculate_total_metrics(struct eigrp *eigrp,
struct eigrp_nexthop_entry *entry)
uint32_t eigrp_calculate_total_metrics(struct eigrp *eigrp,
struct eigrp_nexthop_entry *entry)
{
struct eigrp_interface *ei = entry->ei;
@ -412,9 +412,9 @@ u_int32_t eigrp_calculate_total_metrics(struct eigrp *eigrp,
+ (uint64_t)eigrp_delay_to_scaled(ei->params.delay);
entry->total_metric.delay = temp_delay > EIGRP_MAX_METRIC
? EIGRP_MAX_METRIC
: (u_int32_t)temp_delay;
: (uint32_t)temp_delay;
u_int32_t bw = eigrp_bandwidth_to_scaled(ei->params.bandwidth);
uint32_t bw = eigrp_bandwidth_to_scaled(ei->params.bandwidth);
entry->total_metric.bandwidth = entry->total_metric.bandwidth > bw
? bw
: entry->total_metric.bandwidth;
@ -422,8 +422,8 @@ u_int32_t eigrp_calculate_total_metrics(struct eigrp *eigrp,
return eigrp_calculate_metrics(eigrp, entry->total_metric);
}
u_char eigrp_metrics_is_same(struct eigrp_metrics metric1,
struct eigrp_metrics metric2)
uint8_t eigrp_metrics_is_same(struct eigrp_metrics metric1,
struct eigrp_metrics metric2)
{
if ((metric1.bandwidth == metric2.bandwidth)
&& (metric1.delay == metric2.delay)

9
eigrpd/eigrp_network.h
View file

@ -43,10 +43,11 @@ extern int eigrp_if_drop_allspfrouters(struct eigrp *top, struct prefix *p,
unsigned int ifindex);
extern void eigrp_adjust_sndbuflen(struct eigrp *, unsigned int);
extern u_int32_t eigrp_calculate_metrics(struct eigrp *, struct eigrp_metrics);
extern u_int32_t eigrp_calculate_total_metrics(struct eigrp *,
struct eigrp_nexthop_entry *);
extern u_char eigrp_metrics_is_same(struct eigrp_metrics, struct eigrp_metrics);
extern uint32_t eigrp_calculate_metrics(struct eigrp *, struct eigrp_metrics);
extern uint32_t eigrp_calculate_total_metrics(struct eigrp *,
struct eigrp_nexthop_entry *);
extern uint8_t eigrp_metrics_is_same(struct eigrp_metrics,
struct eigrp_metrics);
extern void eigrp_external_routes_refresh(struct eigrp *, int);
#endif /* EIGRP_NETWORK_H_ */

47
eigrpd/eigrp_packet.c
View file

@ -87,14 +87,14 @@ static int eigrp_retrans_count_exceeded(struct eigrp_packet *ep,
}
int eigrp_make_md5_digest(struct eigrp_interface *ei, struct stream *s,
u_char flags)
uint8_t flags)
{
struct key *key = NULL;
struct keychain *keychain;
unsigned char digest[EIGRP_AUTH_TYPE_MD5_LEN];
MD5_CTX ctx;
u_char *ibuf;
uint8_t *ibuf;
size_t backup_get, backup_end;
struct TLV_MD5_Authentication_Type *auth_TLV;
@ -157,14 +157,14 @@ int eigrp_make_md5_digest(struct eigrp_interface *ei, struct stream *s,
int eigrp_check_md5_digest(struct stream *s,
struct TLV_MD5_Authentication_Type *authTLV,
struct eigrp_neighbor *nbr, u_char flags)
struct eigrp_neighbor *nbr, uint8_t flags)
{
MD5_CTX ctx;
unsigned char digest[EIGRP_AUTH_TYPE_MD5_LEN];
unsigned char orig[EIGRP_AUTH_TYPE_MD5_LEN];
struct key *key = NULL;
struct keychain *keychain;
u_char *ibuf;
uint8_t *ibuf;
size_t backup_end;
struct TLV_MD5_Authentication_Type *auth_TLV;
struct eigrp_header *eigrph;
@ -242,7 +242,7 @@ int eigrp_check_md5_digest(struct stream *s,
}
int eigrp_make_sha256_digest(struct eigrp_interface *ei, struct stream *s,
u_char flags)
uint8_t flags)
{
struct key *key = NULL;
struct keychain *keychain;
@ -304,7 +304,7 @@ int eigrp_make_sha256_digest(struct eigrp_interface *ei, struct stream *s,
int eigrp_check_sha256_digest(struct stream *s,
struct TLV_SHA256_Authentication_Type *authTLV,
struct eigrp_neighbor *nbr, u_char flags)
struct eigrp_neighbor *nbr, uint8_t flags)
{
return 1;
}
@ -319,13 +319,13 @@ int eigrp_write(struct thread *thread)
struct ip iph;
struct msghdr msg;
struct iovec iov[2];
u_int32_t seqno, ack;
uint32_t seqno, ack;
int ret;
int flags = 0;
struct listnode *node;
#ifdef WANT_EIGRP_WRITE_FRAGMENT
static u_int16_t ipid = 0;
static uint16_t ipid = 0;
#endif /* WANT_EIGRP_WRITE_FRAGMENT */
#define EIGRP_WRITE_IPHL_SHIFT 2
@ -479,8 +479,8 @@ int eigrp_read(struct thread *thread)
struct interface *ifp;
struct eigrp_neighbor *nbr;
u_int16_t opcode = 0;
u_int16_t length = 0;
uint16_t opcode = 0;
uint16_t length = 0;
/* first of all get interface pointer. */
eigrp = THREAD_ARG(thread);
@ -706,7 +706,7 @@ static struct stream *eigrp_recv_packet(int fd, struct interface **ifp,
{
int ret;
struct ip *iph;
u_int16_t ip_len;
uint16_t ip_len;
unsigned int ifindex = 0;
struct iovec iov;
/* Header and data both require alignment. */
@ -729,7 +729,7 @@ static struct stream *eigrp_recv_packet(int fd, struct interface **ifp,
zlog_warn(
"eigrp_recv_packet: discarding runt packet of length %d "
"(ip header size is %u)",
ret, (u_int)sizeof(iph));
ret, (unsigned int)sizeof(iph));
return NULL;
}
@ -864,7 +864,7 @@ void eigrp_send_packet_reliably(struct eigrp_neighbor *nbr)
/* Calculate EIGRP checksum */
void eigrp_packet_checksum(struct eigrp_interface *ei, struct stream *s,
u_int16_t length)
uint16_t length)
{
struct eigrp_header *eigrph;
@ -876,16 +876,15 @@ void eigrp_packet_checksum(struct eigrp_interface *ei, struct stream *s,
/* Make EIGRP header. */
void eigrp_packet_header_init(int type, struct eigrp *eigrp, struct stream *s,
u_int32_t flags, u_int32_t sequence,
u_int32_t ack)
uint32_t flags, uint32_t sequence, uint32_t ack)
{
struct eigrp_header *eigrph;
stream_reset(s);
eigrph = (struct eigrp_header *)STREAM_DATA(s);
eigrph->version = (u_char)EIGRP_HEADER_VERSION;
eigrph->opcode = (u_char)type;
eigrph->version = (uint8_t)EIGRP_HEADER_VERSION;
eigrph->opcode = (uint8_t)type;
eigrph->checksum = 0;
eigrph->vrid = htons(eigrp->vrid);
@ -1159,10 +1158,10 @@ struct TLV_IPv4_Internal_type *eigrp_read_ipv4_tlv(struct stream *s)
return tlv;
}
u_int16_t eigrp_add_internalTLV_to_stream(struct stream *s,
struct eigrp_prefix_entry *pe)
uint16_t eigrp_add_internalTLV_to_stream(struct stream *s,
struct eigrp_prefix_entry *pe)
{
u_int16_t length;
uint16_t length;
stream_putw(s, EIGRP_TLV_IPv4_INT);
switch (pe->destination->prefixlen) {
@ -1245,8 +1244,8 @@ u_int16_t eigrp_add_internalTLV_to_stream(struct stream *s,
return length;
}
u_int16_t eigrp_add_authTLV_MD5_to_stream(struct stream *s,
struct eigrp_interface *ei)
uint16_t eigrp_add_authTLV_MD5_to_stream(struct stream *s,
struct eigrp_interface *ei)
{
struct key *key;
struct keychain *keychain;
@ -1285,8 +1284,8 @@ u_int16_t eigrp_add_authTLV_MD5_to_stream(struct stream *s,
return 0;
}
u_int16_t eigrp_add_authTLV_SHA256_to_stream(struct stream *s,
struct eigrp_interface *ei)
uint16_t eigrp_add_authTLV_SHA256_to_stream(struct stream *s,
struct eigrp_interface *ei)
{
struct key *key;
struct keychain *keychain;

28
eigrpd/eigrp_packet.h
View file

@ -42,9 +42,9 @@ extern struct eigrp_packet *eigrp_packet_duplicate(struct eigrp_packet *,
extern void eigrp_packet_free(struct eigrp_packet *);
extern void eigrp_packet_delete(struct eigrp_interface *);
extern void eigrp_packet_header_init(int, struct eigrp *, struct stream *,
u_int32_t, u_int32_t, u_int32_t);
uint32_t, uint32_t, uint32_t);
extern void eigrp_packet_checksum(struct eigrp_interface *, struct stream *,
u_int16_t);
uint16_t);
extern struct eigrp_fifo *eigrp_fifo_new(void);
extern struct eigrp_packet *eigrp_fifo_next(struct eigrp_fifo *);
@ -56,12 +56,12 @@ extern void eigrp_fifo_reset(struct eigrp_fifo *);
extern void eigrp_send_packet_reliably(struct eigrp_neighbor *);
extern struct TLV_IPv4_Internal_type *eigrp_read_ipv4_tlv(struct stream *);
extern u_int16_t eigrp_add_internalTLV_to_stream(struct stream *,
struct eigrp_prefix_entry *);
extern u_int16_t eigrp_add_authTLV_MD5_to_stream(struct stream *,
struct eigrp_interface *);
extern u_int16_t eigrp_add_authTLV_SHA256_to_stream(struct stream *,
struct eigrp_interface *);
extern uint16_t eigrp_add_internalTLV_to_stream(struct stream *,
struct eigrp_prefix_entry *);
extern uint16_t eigrp_add_authTLV_MD5_to_stream(struct stream *,
struct eigrp_interface *);
extern uint16_t eigrp_add_authTLV_SHA256_to_stream(struct stream *,
struct eigrp_interface *);
extern int eigrp_unack_packet_retrans(struct thread *);
extern int eigrp_unack_multicast_packet_retrans(struct thread *);
@ -71,7 +71,7 @@ extern int eigrp_unack_multicast_packet_retrans(struct thread *);
* eigrp_hello.c
*/
extern void eigrp_sw_version_initialize(void);
extern void eigrp_hello_send(struct eigrp_interface *, u_char,
extern void eigrp_hello_send(struct eigrp_interface *, uint8_t,
struct in_addr *);
extern void eigrp_hello_send_ack(struct eigrp_neighbor *);
extern void eigrp_hello_receive(struct eigrp *, struct ip *,
@ -108,7 +108,7 @@ extern void eigrp_send_query(struct eigrp_interface *);
extern void eigrp_query_receive(struct eigrp *, struct ip *,
struct eigrp_header *, struct stream *,
struct eigrp_interface *, int);
extern u_int32_t eigrp_query_send_all(struct eigrp *);
extern uint32_t eigrp_query_send_all(struct eigrp *);
/*
* These externs are found in eigrp_reply.c
@ -143,15 +143,15 @@ extern struct TLV_SHA256_Authentication_Type *eigrp_authTLV_SHA256_new(void);
extern void eigrp_authTLV_SHA256_free(struct TLV_SHA256_Authentication_Type *);
extern int eigrp_make_md5_digest(struct eigrp_interface *, struct stream *,
u_char);
uint8_t);
extern int eigrp_check_md5_digest(struct stream *,
struct TLV_MD5_Authentication_Type *,
struct eigrp_neighbor *, u_char);
struct eigrp_neighbor *, uint8_t);
extern int eigrp_make_sha256_digest(struct eigrp_interface *, struct stream *,
u_char);
uint8_t);
extern int eigrp_check_sha256_digest(struct stream *,
struct TLV_SHA256_Authentication_Type *,
struct eigrp_neighbor *, u_char);
struct eigrp_neighbor *, uint8_t);
extern void eigrp_IPv4_InternalTLV_free(struct TLV_IPv4_Internal_type *);

12
eigrpd/eigrp_query.c
View file

@ -54,12 +54,12 @@
#include "eigrpd/eigrp_fsm.h"
#include "eigrpd/eigrp_memory.h"
u_int32_t eigrp_query_send_all(struct eigrp *eigrp)
uint32_t eigrp_query_send_all(struct eigrp *eigrp)
{
struct eigrp_interface *iface;
struct listnode *node, *node2, *nnode2;
struct eigrp_prefix_entry *pe;
u_int32_t counter;
uint32_t counter;
if (eigrp == NULL) {
zlog_debug("EIGRP Routing Process not enabled");
@ -93,8 +93,8 @@ void eigrp_query_receive(struct eigrp *eigrp, struct ip *iph,
struct TLV_IPv4_Internal_type *tlv;
struct prefix dest_addr;
u_int16_t type;
u_int16_t length;
uint16_t type;
uint16_t length;
/* increment statistics. */
ei->query_in++;
@ -111,7 +111,7 @@ void eigrp_query_receive(struct eigrp *eigrp, struct ip *iph,
type = stream_getw(s);
switch (type) {
case EIGRP_TLV_IPv4_INT:
stream_set_getp(s, s->getp - sizeof(u_int16_t));
stream_set_getp(s, s->getp - sizeof(uint16_t));
tlv = eigrp_read_ipv4_tlv(s);
@ -161,7 +161,7 @@ void eigrp_query_receive(struct eigrp *eigrp, struct ip *iph,
void eigrp_send_query(struct eigrp_interface *ei)
{
struct eigrp_packet *ep = NULL;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
struct listnode *node, *nnode, *node2, *nnode2;
struct eigrp_neighbor *nbr;
struct eigrp_prefix_entry *pe;

6
eigrpd/eigrp_reply.c
View file

@ -63,7 +63,7 @@
void eigrp_send_reply(struct eigrp_neighbor *nbr, struct eigrp_prefix_entry *pe)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
struct eigrp_interface *ei = nbr->ei;
struct eigrp *eigrp = ei->eigrp;
struct eigrp_prefix_entry *pe2;
@ -132,7 +132,7 @@ void eigrp_reply_receive(struct eigrp *eigrp, struct ip *iph,
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
u_int16_t type;
uint16_t type;
/* increment statistics. */
ei->reply_in++;
@ -153,7 +153,7 @@ void eigrp_reply_receive(struct eigrp *eigrp, struct ip *iph,
struct prefix dest_addr;
stream_set_getp(s, s->getp - sizeof(u_int16_t));
stream_set_getp(s, s->getp - sizeof(uint16_t));
tlv = eigrp_read_ipv4_tlv(s);

22
eigrpd/eigrp_routemap.c
View file

@ -255,8 +255,8 @@ static route_map_result_t route_match_metric(void *rule, struct prefix *prefix,
route_map_object_t type,
void *object)
{
// u_int32_t *metric;
// u_int32_t check;
// uint32_t *metric;
// uint32_t check;
// struct rip_info *rinfo;
// struct eigrp_nexthop_entry *te;
// struct eigrp_prefix_entry *pe;
@ -286,9 +286,9 @@ static route_map_result_t route_match_metric(void *rule, struct prefix *prefix,
/* Route map `match metric' match statement. `arg' is METRIC value */
static void *route_match_metric_compile(const char *arg)
{
// u_int32_t *metric;
// uint32_t *metric;
//
// metric = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_int32_t));
// metric = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (uint32_t));
// *metric = atoi (arg);
//
// if(*metric > 0)
@ -529,7 +529,7 @@ static struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd = {
static route_map_result_t route_match_tag(void *rule, struct prefix *prefix,
route_map_object_t type, void *object)
{
// u_short *tag;
// unsigned short *tag;
// struct rip_info *rinfo;
//
// if (type == RMAP_EIGRP)
@ -549,9 +549,9 @@ static route_map_result_t route_match_tag(void *rule, struct prefix *prefix,
/* Route map `match tag' match statement. `arg' is TAG value */
static void *route_match_tag_compile(const char *arg)
{
// u_short *tag;
// unsigned short *tag;
//
// tag = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_short));
// tag = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (unsigned short));
// *tag = atoi (arg);
//
// return tag;
@ -721,7 +721,7 @@ static struct route_map_rule_cmd route_set_ip_nexthop_cmd = {
static route_map_result_t route_set_tag(void *rule, struct prefix *prefix,
route_map_object_t type, void *object)
{
// u_short *tag;
// unsigned short *tag;
// struct rip_info *rinfo;
//
// if(type == RMAP_RIP)
@ -738,12 +738,12 @@ static route_map_result_t route_set_tag(void *rule, struct prefix *prefix,
}
/* Route map `tag' compile function. Given string is converted
to u_short. */
to unsigned short. */
static void *route_set_tag_compile(const char *arg)
{
// u_short *tag;
// unsigned short *tag;
//
// tag = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_short));
// tag = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (unsigned short));
// *tag = atoi (arg);
//
// return tag;

6
eigrpd/eigrp_siaquery.c
View file

@ -62,7 +62,7 @@ void eigrp_siaquery_receive(struct eigrp *eigrp, struct ip *iph,
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
u_int16_t type;
uint16_t type;
/* increment statistics. */
ei->siaQuery_in++;
@ -80,7 +80,7 @@ void eigrp_siaquery_receive(struct eigrp *eigrp, struct ip *iph,
if (type == EIGRP_TLV_IPv4_INT) {
struct prefix dest_addr;
stream_set_getp(s, s->getp - sizeof(u_int16_t));
stream_set_getp(s, s->getp - sizeof(uint16_t));
tlv = eigrp_read_ipv4_tlv(s);
@ -117,7 +117,7 @@ void eigrp_send_siaquery(struct eigrp_neighbor *nbr,
struct eigrp_prefix_entry *pe)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
ep = eigrp_packet_new(nbr->ei->ifp->mtu, nbr);

6
eigrpd/eigrp_siareply.c
View file

@ -61,7 +61,7 @@ void eigrp_siareply_receive(struct eigrp *eigrp, struct ip *iph,
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
u_int16_t type;
uint16_t type;
/* increment statistics. */
ei->siaReply_in++;
@ -79,7 +79,7 @@ void eigrp_siareply_receive(struct eigrp *eigrp, struct ip *iph,
if (type == EIGRP_TLV_IPv4_INT) {
struct prefix dest_addr;
stream_set_getp(s, s->getp - sizeof(u_int16_t));
stream_set_getp(s, s->getp - sizeof(uint16_t));
tlv = eigrp_read_ipv4_tlv(s);
@ -116,7 +116,7 @@ void eigrp_send_siareply(struct eigrp_neighbor *nbr,
struct eigrp_prefix_entry *pe)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
ep = eigrp_packet_new(nbr->ei->ifp->mtu, nbr);

52
eigrpd/eigrp_snmp.c
View file

@ -167,16 +167,16 @@ oid eigrp_oid[] = {EIGRPMIB};
#define UINTEGER ASN_UNSIGNED
/* Hook functions. */
static u_char *eigrpVpnEntry(struct variable *, oid *, size_t *, int, size_t *,
WriteMethod **);
static u_char *eigrpTraffStatsEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
static u_char *eigrpTopologyEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
static u_char *eigrpPeerEntry(struct variable *, oid *, size_t *, int, size_t *,
static uint8_t *eigrpVpnEntry(struct variable *, oid *, size_t *, int, size_t *,
WriteMethod **);
static u_char *eigrpInterfaceEntry(struct variable *, oid *, size_t *, int,
static uint8_t *eigrpTraffStatsEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
static uint8_t *eigrpTopologyEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
static uint8_t *eigrpPeerEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
static uint8_t *eigrpInterfaceEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
struct variable eigrp_variables[] = {
@ -599,9 +599,9 @@ static struct eigrp_neighbor *eigrpNbrLookup(struct variable *v, oid *name,
}
static u_char *eigrpVpnEntry(struct variable *v, oid *name, size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *eigrpVpnEntry(struct variable *v, oid *name, size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
{
struct eigrp *eigrp;
@ -657,9 +657,9 @@ static uint32_t eigrp_neighbor_count(struct eigrp *eigrp)
}
static u_char *eigrpTraffStatsEntry(struct variable *v, oid *name,
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *eigrpTraffStatsEntry(struct variable *v, oid *name,
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
{
struct eigrp *eigrp;
struct eigrp_interface *ei;
@ -913,9 +913,9 @@ static u_char *eigrpTraffStatsEntry(struct variable *v, oid *name,
return NULL;
}
static u_char *eigrpTopologyEntry(struct variable *v, oid *name, size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *eigrpTopologyEntry(struct variable *v, oid *name,
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
{
struct eigrp *eigrp;
struct eigrp_interface *ei;
@ -1061,9 +1061,9 @@ static u_char *eigrpTopologyEntry(struct variable *v, oid *name, size_t *length,
return NULL;
}
static u_char *eigrpPeerEntry(struct variable *v, oid *name, size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *eigrpPeerEntry(struct variable *v, oid *name, size_t *length,
int exact, size_t *var_len,
WriteMethod **write_method)
{
struct eigrp *eigrp;
struct eigrp_interface *ei;
@ -1194,9 +1194,9 @@ static u_char *eigrpPeerEntry(struct variable *v, oid *name, size_t *length,
return NULL;
}
static u_char *eigrpInterfaceEntry(struct variable *v, oid *name,
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
static uint8_t *eigrpInterfaceEntry(struct variable *v, oid *name,
size_t *length, int exact, size_t *var_len,
WriteMethod **write_method)
{
struct eigrp *eigrp;
struct eigrp_interface *ei;
@ -1383,13 +1383,13 @@ static u_char *eigrpInterfaceEntry(struct variable *v, oid *name,
on this interface. */
keylist = keychain_list_get();
for (ALL_LIST_ELEMENTS(keylist, node, nnode, keychain)) {
return (u_char *)keychain->name;
return (uint8_t *)keychain->name;
}
if (eigrp && keychain) {
*var_len = str_len(keychain->name);
return (u_char *)keychain->name;
return (uint8_t *)keychain->name;
} else
return (u_char *)"TEST";
return (uint8_t *)"TEST";
break;
default:
return NULL;

276
eigrpd/eigrp_structs.h
View file

@ -52,43 +52,43 @@ struct eigrp_master {
time_t start_time;
/* Various EIGRP global configuration. */
u_char options;
uint8_t options;
#define EIGRP_MASTER_SHUTDOWN (1 << 0) /* deferred-shutdown */
};
struct eigrp_metrics {
u_int32_t delay;
u_int32_t bandwidth;
uint32_t delay;
uint32_t bandwidth;
unsigned char mtu[3];
u_char hop_count;
u_char reliability;
u_char load;
u_char tag;
u_char flags;
uint8_t hop_count;
uint8_t reliability;
uint8_t load;
uint8_t tag;
uint8_t flags;
};
struct eigrp {
u_int16_t AS; /* Autonomous system number */
u_int16_t vrid; /* Virtual Router ID */
u_char k_values[6]; /*Array for K values configuration*/
u_char variance; /*Metric variance multiplier*/
u_char max_paths; /*Maximum allowed paths for 1 prefix*/
uint16_t AS; /* Autonomous system number */
uint16_t vrid; /* Virtual Router ID */
uint8_t k_values[6]; /*Array for K values configuration*/
uint8_t variance; /*Metric variance multiplier*/
uint8_t max_paths; /*Maximum allowed paths for 1 prefix*/
/*Name of this EIGRP instance*/
char *name;
/* EIGRP Router ID. */
u_int32_t router_id; /* Configured automatically. */
u_int32_t router_id_static; /* Configured manually. */
uint32_t router_id; /* Configured automatically. */
uint32_t router_id_static; /* Configured manually. */
struct list *eiflist; /* eigrp interfaces */
u_char passive_interface_default; /* passive-interface default */
uint8_t passive_interface_default; /* passive-interface default */
unsigned int fd;
unsigned int maxsndbuflen;
u_int32_t sequence_number; /*Global EIGRP sequence number*/
uint32_t sequence_number; /*Global EIGRP sequence number*/
struct stream *ibuf;
struct list *oi_write_q;
@ -128,7 +128,7 @@ struct eigrp {
char *name;
struct route_map *map;
int metric_config;
u_int32_t metric;
uint32_t metric;
} route_map[ZEBRA_ROUTE_MAX];
QOBJ_FIELDS
@ -136,14 +136,14 @@ struct eigrp {
DECLARE_QOBJ_TYPE(eigrp)
struct eigrp_if_params {
u_char passive_interface;
u_int32_t v_hello;
u_int16_t v_wait;
u_char type; /* type of interface */
u_int32_t bandwidth;
u_int32_t delay;
u_char reliability;
u_char load;
uint8_t passive_interface;
uint32_t v_hello;
uint16_t v_wait;
uint8_t type; /* type of interface */
uint32_t bandwidth;
uint32_t delay;
uint8_t reliability;
uint8_t load;
char *auth_keychain; /* Associated keychain with interface*/
int auth_type; /* EIGRP authentication type */
@ -172,10 +172,10 @@ struct eigrp_interface {
/* To which multicast groups do we currently belong? */
u_char multicast_memberships;
uint8_t multicast_memberships;
/* EIGRP Network Type. */
u_char type;
uint8_t type;
struct prefix *address; /* Interface prefix */
struct connected *connected; /* Pointer to connected */
@ -190,22 +190,22 @@ struct eigrp_interface {
int on_write_q;
/* Statistics fields. */
u_int32_t hello_in; /* Hello message input count. */
u_int32_t update_in; /* Update message input count. */
u_int32_t query_in; /* Querry message input count. */
u_int32_t reply_in; /* Reply message input count. */
u_int32_t hello_out; /* Hello message output count. */
u_int32_t update_out; /* Update message output count. */
u_int32_t query_out; /* Query message output count. */
u_int32_t reply_out; /* Reply message output count. */
u_int32_t siaQuery_in;
u_int32_t siaQuery_out;
u_int32_t siaReply_in;
u_int32_t siaReply_out;
u_int32_t ack_out;
u_int32_t ack_in;
uint32_t hello_in; /* Hello message input count. */
uint32_t update_in; /* Update message input count. */
uint32_t query_in; /* Querry message input count. */
uint32_t reply_in; /* Reply message input count. */
uint32_t hello_out; /* Hello message output count. */
uint32_t update_out; /* Update message output count. */
uint32_t query_out; /* Query message output count. */
uint32_t reply_out; /* Reply message output count. */
uint32_t siaQuery_in;
uint32_t siaQuery_out;
uint32_t siaReply_in;
uint32_t siaReply_out;
uint32_t ack_out;
uint32_t ack_in;
u_int32_t crypt_seqnum; /* Cryptographic Sequence Number */
uint32_t crypt_seqnum; /* Cryptographic Sequence Number */
/* Access-list. */
struct access_list *list[EIGRP_FILTER_MAX];
@ -231,30 +231,32 @@ struct eigrp_neighbor {
struct eigrp_interface *ei;
/* EIGRP neighbor Information */
u_char state; /* neigbor status. */
uint8_t state; /* neigbor status. */
u_int32_t recv_sequence_number; /* Last received sequence Number. */
u_int32_t init_sequence_number;
uint32_t recv_sequence_number; /* Last received sequence Number. */
uint32_t init_sequence_number;
/*If packet is unacknowledged, we try to send it again 16 times*/
u_char retrans_counter;
uint8_t retrans_counter;
struct in_addr src; /* Neighbor Src address. */
u_char os_rel_major; // system version - just for show
u_char os_rel_minor; // system version - just for show
u_char tlv_rel_major; // eigrp version - tells us what TLV format to use
u_char tlv_rel_minor; // eigrp version - tells us what TLV format to use
uint8_t os_rel_major; // system version - just for show
uint8_t os_rel_minor; // system version - just for show
uint8_t tlv_rel_major; // eigrp version - tells us what TLV format to
// use
uint8_t tlv_rel_minor; // eigrp version - tells us what TLV format to
// use
u_char K1;
u_char K2;
u_char K3;
u_char K4;
u_char K5;
u_char K6;
uint8_t K1;
uint8_t K2;
uint8_t K3;
uint8_t K4;
uint8_t K5;
uint8_t K6;
/* Timer values. */
u_int16_t v_holddown;
uint16_t v_holddown;
/* Threads. */
struct thread *t_holddown;
@ -264,7 +266,7 @@ struct eigrp_neighbor {
struct eigrp_fifo *retrans_queue;
struct eigrp_fifo *multicast_queue;
u_int32_t crypt_seqnum; /* Cryptographic Sequence Number. */
uint32_t crypt_seqnum; /* Cryptographic Sequence Number. */
/* prefixes not received from neighbor during Graceful restart */
struct list *nbr_gr_prefixes;
@ -291,12 +293,12 @@ struct eigrp_packet {
struct thread *t_retrans_timer;
/*Packet retransmission counter*/
u_char retrans_counter;
uint8_t retrans_counter;
u_int32_t sequence_number;
uint32_t sequence_number;
/* EIGRP packet length. */
u_int16_t length;
uint16_t length;
struct eigrp_neighbor *nbr;
};
@ -309,14 +311,14 @@ struct eigrp_fifo {
};
struct eigrp_header {
u_char version;
u_char opcode;
u_int16_t checksum;
u_int32_t flags;
u_int32_t sequence;
u_int32_t ack;
u_int16_t vrid;
u_int16_t ASNumber;
uint8_t version;
uint8_t opcode;
uint16_t checksum;
uint32_t flags;
uint32_t sequence;
uint32_t ack;
uint16_t vrid;
uint16_t ASNumber;
char *tlv[0];
} __attribute__((packed));
@ -332,109 +334,109 @@ struct eigrp_header {
* +-----+------------------+
*/
struct eigrp_tlv_hdr_type {
u_int16_t type;
u_int16_t length;
uint16_t type;
uint16_t length;
uint8_t value[0];
} __attribute__((packed));
struct TLV_Parameter_Type {
u_int16_t type;
u_int16_t length;
u_char K1;
u_char K2;
u_char K3;
u_char K4;
u_char K5;
u_char K6;
u_int16_t hold_time;
uint16_t type;
uint16_t length;
uint8_t K1;
uint8_t K2;
uint8_t K3;
uint8_t K4;
uint8_t K5;
uint8_t K6;
uint16_t hold_time;
} __attribute__((packed));
struct TLV_MD5_Authentication_Type {
u_int16_t type;
u_int16_t length;
u_int16_t auth_type;
u_int16_t auth_length;
u_int32_t key_id;
u_int32_t key_sequence;
u_char Nullpad[8];
u_char digest[EIGRP_AUTH_TYPE_MD5_LEN];
uint16_t type;
uint16_t length;
uint16_t auth_type;
uint16_t auth_length;
uint32_t key_id;
uint32_t key_sequence;
uint8_t Nullpad[8];
uint8_t digest[EIGRP_AUTH_TYPE_MD5_LEN];
} __attribute__((packed));
struct TLV_SHA256_Authentication_Type {
u_int16_t type;
u_int16_t length;
u_int16_t auth_type;
u_int16_t auth_length;
u_int32_t key_id;
u_int32_t key_sequence;
u_char Nullpad[8];
u_char digest[EIGRP_AUTH_TYPE_SHA256_LEN];
uint16_t type;
uint16_t length;
uint16_t auth_type;
uint16_t auth_length;
uint32_t key_id;
uint32_t key_sequence;
uint8_t Nullpad[8];
uint8_t digest[EIGRP_AUTH_TYPE_SHA256_LEN];
} __attribute__((packed));
struct TLV_Sequence_Type {
u_int16_t type;
u_int16_t length;
u_char addr_length;
uint16_t type;
uint16_t length;
uint8_t addr_length;
struct in_addr *addresses;
} __attribute__((packed));
struct TLV_Next_Multicast_Sequence {
u_int16_t type;
u_int16_t length;
u_int32_t multicast_sequence;
uint16_t type;
uint16_t length;
uint32_t multicast_sequence;
} __attribute__((packed));
struct TLV_Software_Type {
u_int16_t type;
u_int16_t length;
u_char vender_major;
u_char vender_minor;
u_char eigrp_major;
u_char eigrp_minor;
uint16_t type;
uint16_t length;
uint8_t vender_major;
uint8_t vender_minor;
uint8_t eigrp_major;
uint8_t eigrp_minor;
} __attribute__((packed));
struct TLV_IPv4_Internal_type {
u_int16_t type;
u_int16_t length;
uint16_t type;
uint16_t length;
struct in_addr forward;
/*Metrics*/
struct eigrp_metrics metric;
u_char prefix_length;
uint8_t prefix_length;
unsigned char destination_part[4];
struct in_addr destination;
} __attribute__((packed));
struct TLV_IPv4_External_type {
u_int16_t type;
u_int16_t length;
uint16_t type;
uint16_t length;
struct in_addr next_hop;
struct in_addr originating_router;
u_int32_t originating_as;
u_int32_t administrative_tag;
u_int32_t external_metric;
u_int16_t reserved;
u_char external_protocol;
u_char external_flags;
uint32_t originating_as;
uint32_t administrative_tag;
uint32_t external_metric;
uint16_t reserved;
uint8_t external_protocol;
uint8_t external_flags;
/*Metrics*/
struct eigrp_metrics metric;
u_char prefix_length;
uint8_t prefix_length;
unsigned char destination_part[4];
struct in_addr destination;
} __attribute__((packed));
/* EIGRP Peer Termination TLV - used for hard restart */
struct TLV_Peer_Termination_type {
u_int16_t type;
u_int16_t length;
u_char unknown;
u_int32_t neighbor_ip;
uint16_t type;
uint16_t length;
uint8_t unknown;
uint32_t neighbor_ip;
} __attribute__((packed));
/* Who executed Graceful restart */
@ -445,15 +447,15 @@ enum GR_type { EIGRP_GR_MANUAL, EIGRP_GR_FILTER };
/* EIGRP Topology table node structure */
struct eigrp_prefix_entry {
struct list *entries, *rij;
u_int32_t fdistance; // FD
u_int32_t rdistance; // RD
u_int32_t distance; // D
uint32_t fdistance; // FD
uint32_t rdistance; // RD
uint32_t distance; // D
struct eigrp_metrics reported_metric; // RD for sending
u_char nt; // network type
u_char state; // route fsm state
u_char af; // address family
u_char req_action; // required action
uint8_t nt; // network type
uint8_t state; // route fsm state
uint8_t af; // address family
uint8_t req_action; // required action
struct prefix *destination;
@ -468,15 +470,15 @@ struct eigrp_prefix_entry {
/* EIGRP Topology table record structure */
struct eigrp_nexthop_entry {
struct eigrp_prefix_entry *prefix;
u_int32_t reported_distance; // distance reported by neighbor
u_int32_t distance; // sum of reported distance and link cost to
// advertised neighbor
uint32_t reported_distance; // distance reported by neighbor
uint32_t distance; // sum of reported distance and link cost to
// advertised neighbor
struct eigrp_metrics reported_metric;
struct eigrp_metrics total_metric;
struct eigrp_neighbor *adv_router; // ip address of advertising neighbor
u_char flags; // used for marking successor and FS
uint8_t flags; // used for marking successor and FS
struct eigrp_interface *ei; // pointer for case of connected entry
};
@ -491,7 +493,7 @@ typedef enum {
/* EIGRP Finite State Machine */
struct eigrp_fsm_action_message {
u_char packet_type; // UPDATE, QUERY, SIAQUERY, SIAREPLY
uint8_t packet_type; // UPDATE, QUERY, SIAQUERY, SIAREPLY
struct eigrp *eigrp; // which thread sent mesg
struct eigrp_neighbor *adv_router; // advertising neighbor
struct eigrp_nexthop_entry *entry;

2
eigrpd/eigrp_topology.c
View file

@ -362,7 +362,7 @@ eigrp_topology_update_distance(struct eigrp_fsm_action_message *msg)
struct eigrp_prefix_entry *prefix = msg->prefix;
struct eigrp_nexthop_entry *entry = msg->entry;
enum metric_change change = METRIC_SAME;
u_int32_t new_reported_distance;
uint32_t new_reported_distance;
assert(entry);

36
eigrpd/eigrp_update.c
View file

@ -176,13 +176,13 @@ void eigrp_update_receive(struct eigrp *eigrp, struct ip *iph,
struct TLV_IPv4_Internal_type *tlv;
struct eigrp_prefix_entry *pe;
struct eigrp_nexthop_entry *ne;
u_int32_t flags;
u_int16_t type;
u_int16_t length;
u_char same;
uint32_t flags;
uint16_t type;
uint16_t length;
uint8_t same;
struct prefix dest_addr;
u_char graceful_restart;
u_char graceful_restart_final;
uint8_t graceful_restart;
uint8_t graceful_restart_final;
struct list *nbr_prefixes = NULL;
/* increment statistics. */
@ -297,7 +297,7 @@ void eigrp_update_receive(struct eigrp *eigrp, struct ip *iph,
type = stream_getw(s);
switch (type) {
case EIGRP_TLV_IPv4_INT:
stream_set_getp(s, s->getp - sizeof(u_int16_t));
stream_set_getp(s, s->getp - sizeof(uint16_t));
tlv = eigrp_read_ipv4_tlv(s);
@ -418,7 +418,7 @@ void eigrp_update_receive(struct eigrp *eigrp, struct ip *iph,
void eigrp_update_send_init(struct eigrp_neighbor *nbr)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
ep = eigrp_packet_new(nbr->ei->ifp->mtu, nbr);
@ -463,7 +463,7 @@ void eigrp_update_send_init(struct eigrp_neighbor *nbr)
static void eigrp_update_place_on_nbr_queue(struct eigrp_neighbor *nbr,
struct eigrp_packet *ep,
u_int32_t seq_no, int length)
uint32_t seq_no, int length)
{
if ((nbr->ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
&& (nbr->ei->params.auth_keychain != NULL)) {
@ -525,15 +525,15 @@ static void eigrp_update_send_to_all_nbrs(struct eigrp_interface *ei,
void eigrp_update_send_EOT(struct eigrp_neighbor *nbr)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
struct eigrp_nexthop_entry *te;
struct eigrp_prefix_entry *pe;
struct listnode *node2, *nnode2;
struct eigrp_interface *ei = nbr->ei;
struct eigrp *eigrp = ei->eigrp;
struct prefix *dest_addr;
u_int32_t seq_no = eigrp->sequence_number;
u_int16_t mtu = ei->ifp->mtu;
uint32_t seq_no = eigrp->sequence_number;
uint16_t mtu = ei->ifp->mtu;
struct route_node *rn;
ep = eigrp_packet_new(mtu, nbr);
@ -600,15 +600,15 @@ void eigrp_update_send(struct eigrp_interface *ei)
struct eigrp_packet *ep;
struct listnode *node, *nnode;
struct eigrp_prefix_entry *pe;
u_char has_tlv;
uint8_t has_tlv;
struct eigrp *eigrp = ei->eigrp;
struct prefix *dest_addr;
u_int32_t seq_no = eigrp->sequence_number;
uint32_t seq_no = eigrp->sequence_number;
if (ei->nbrs->count == 0)
return;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
ep = eigrp_packet_new(ei->ifp->mtu, NULL);
@ -634,7 +634,7 @@ void eigrp_update_send(struct eigrp_interface *ei)
continue;
if ((length + EIGRP_TLV_MAX_IPV4_BYTE)
> (u_int16_t)ei->ifp->mtu) {
> (uint16_t)ei->ifp->mtu) {
if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
&& (ei->params.auth_keychain != NULL)) {
eigrp_make_md5_digest(ei, ep->s,
@ -743,13 +743,13 @@ void eigrp_update_send_all(struct eigrp *eigrp,
static void eigrp_update_send_GR_part(struct eigrp_neighbor *nbr)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
uint16_t length = EIGRP_HEADER_LEN;
struct eigrp_prefix_entry *pe;
struct prefix *dest_addr;
struct eigrp_interface *ei = nbr->ei;
struct eigrp *eigrp = ei->eigrp;
struct list *prefixes;
u_int32_t flags;
uint32_t flags;
unsigned int send_prefixes;
struct route_node *rn;

16
eigrpd/eigrp_vty.c
View file

@ -608,7 +608,7 @@ DEFUN (eigrp_if_delay,
VTY_DECLVAR_CONTEXT(interface, ifp);
struct eigrp_interface *ei = ifp->info;
struct eigrp *eigrp;
u_int32_t delay;
uint32_t delay;
eigrp = eigrp_lookup();
if (eigrp == NULL) {
@ -666,7 +666,7 @@ DEFUN (eigrp_if_bandwidth,
{
VTY_DECLVAR_CONTEXT(interface, ifp);
struct eigrp_interface *ei = ifp->info;
u_int32_t bandwidth;
uint32_t bandwidth;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
@ -727,7 +727,7 @@ DEFUN (eigrp_if_ip_hellointerval,
{
VTY_DECLVAR_CONTEXT(interface, ifp);
struct eigrp_interface *ei = ifp->info;
u_int32_t hello;
uint32_t hello;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
@ -790,7 +790,7 @@ DEFUN (eigrp_if_ip_holdinterval,
{
VTY_DECLVAR_CONTEXT(interface, ifp);
struct eigrp_interface *ei = ifp->info;
u_int32_t hold;
uint32_t hold;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
@ -821,7 +821,7 @@ DEFUN (eigrp_ip_summary_address,
"Summary <network>/<length>, e.g. 192.168.0.0/16\n")
{
// VTY_DECLVAR_CONTEXT(interface, ifp);
// u_int32_t AS;
// uint32_t AS;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
@ -848,7 +848,7 @@ DEFUN (no_eigrp_ip_summary_address,
"Summary <network>/<length>, e.g. 192.168.0.0/16\n")
{
// VTY_DECLVAR_CONTEXT(interface, ifp);
// u_int32_t AS;
// uint32_t AS;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
@ -1120,7 +1120,7 @@ DEFUN (eigrp_variance,
"Metric variance multiplier\n")
{
struct eigrp *eigrp;
u_char variance;
uint8_t variance;
eigrp = eigrp_lookup();
if (eigrp == NULL) {
@ -1164,7 +1164,7 @@ DEFUN (eigrp_maximum_paths,
"Number of paths\n")
{
struct eigrp *eigrp;
u_char max;
uint8_t max;
eigrp = eigrp_lookup();
if (eigrp == NULL) {

2
eigrpd/eigrpd.c
View file

@ -96,7 +96,7 @@ void eigrp_router_id_update(struct eigrp *eigrp)
{
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
struct interface *ifp;
u_int32_t router_id, router_id_old;
uint32_t router_id, router_id_old;
router_id_old = eigrp->router_id;

8
isisd/isis_adjacency.c
View file

@ -51,7 +51,7 @@
extern struct isis *isis;
static struct isis_adjacency *adj_alloc(const u_char *id)
static struct isis_adjacency *adj_alloc(const uint8_t *id)
{
struct isis_adjacency *adj;
@ -61,7 +61,7 @@ static struct isis_adjacency *adj_alloc(const u_char *id)
return adj;
}
struct isis_adjacency *isis_new_adj(const u_char *id, const u_char *snpa,
struct isis_adjacency *isis_new_adj(const uint8_t *id, const uint8_t *snpa,
int level, struct isis_circuit *circuit)
{
struct isis_adjacency *adj;
@ -96,7 +96,7 @@ struct isis_adjacency *isis_new_adj(const u_char *id, const u_char *snpa,
return adj;
}
struct isis_adjacency *isis_adj_lookup(const u_char *sysid, struct list *adjdb)
struct isis_adjacency *isis_adj_lookup(const uint8_t *sysid, struct list *adjdb)
{
struct isis_adjacency *adj;
struct listnode *node;
@ -108,7 +108,7 @@ struct isis_adjacency *isis_adj_lookup(const u_char *sysid, struct list *adjdb)
return NULL;
}
struct isis_adjacency *isis_adj_lookup_snpa(const u_char *ssnpa,
struct isis_adjacency *isis_adj_lookup_snpa(const uint8_t *ssnpa,
struct list *adjdb)
{
struct listnode *node;

21
isisd/isis_adjacency.h
View file

@ -69,9 +69,9 @@ struct isis_dis_record {
};
struct isis_adjacency {
u_char snpa[ETH_ALEN]; /* NeighbourSNPAAddress */
u_char sysid[ISIS_SYS_ID_LEN]; /* neighbourSystemIdentifier */
u_char lanid[ISIS_SYS_ID_LEN + 1]; /* LAN id on bcast circuits */
uint8_t snpa[ETH_ALEN]; /* NeighbourSNPAAddress */
uint8_t sysid[ISIS_SYS_ID_LEN]; /* neighbourSystemIdentifier */
uint8_t lanid[ISIS_SYS_ID_LEN + 1]; /* LAN id on bcast circuits */
int dischanges[ISIS_LEVELS]; /* how many DIS changes ? */
/* an array of N levels for M records */
struct isis_dis_record dis_record[DIS_RECORDS * ISIS_LEVELS];
@ -86,13 +86,13 @@ struct isis_adjacency {
struct in6_addr *ipv6_addresses;
unsigned int ipv6_address_count;
struct in6_addr router_address6;
u_char prio[ISIS_LEVELS]; /* priorityOfNeighbour for DIS */
uint8_t prio[ISIS_LEVELS]; /* priorityOfNeighbour for DIS */
int circuit_t; /* from hello PDU hdr */
int level; /* level (1 or 2) */
enum isis_system_type sys_type; /* neighbourSystemType */
u_int16_t hold_time; /* entryRemainingTime */
u_int32_t last_upd;
u_int32_t last_flap; /* last time the adj flapped */
uint16_t hold_time; /* entryRemainingTime */
uint32_t last_upd;
uint32_t last_flap; /* last time the adj flapped */
enum isis_threeway_state threeway_state;
uint32_t ext_circuit_id;
int flaps; /* number of adjacency flaps */
@ -104,10 +104,11 @@ struct isis_adjacency {
struct isis_threeway_adj;
struct isis_adjacency *isis_adj_lookup(const u_char *sysid, struct list *adjdb);
struct isis_adjacency *isis_adj_lookup_snpa(const u_char *ssnpa,
struct isis_adjacency *isis_adj_lookup(const uint8_t *sysid,
struct list *adjdb);
struct isis_adjacency *isis_adj_lookup_snpa(const uint8_t *ssnpa,
struct list *adjdb);
struct isis_adjacency *isis_new_adj(const u_char *id, const u_char *snpa,
struct isis_adjacency *isis_new_adj(const uint8_t *id, const uint8_t *snpa,
int level, struct isis_circuit *circuit);
void isis_delete_adj(void *adj);
void isis_adj_process_threeway(struct isis_adjacency *adj,

22
isisd/isis_bpf.c
View file

@ -54,20 +54,20 @@ struct bpf_insn llcfilter[] = {
3), /* check second byte */
BPF_STMT(BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 2),
BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x03, 0, 1), /* check third byte */
BPF_STMT(BPF_RET + BPF_K, (u_int)-1),
BPF_STMT(BPF_RET + BPF_K, (unsigned int)-1),
BPF_STMT(BPF_RET + BPF_K, 0)};
u_int readblen = 0;
u_char *readbuff = NULL;
unsigned int readblen = 0;
uint8_t *readbuff = NULL;
/*
* Table 9 - Architectural constants for use with ISO 8802 subnetworks
* ISO 10589 - 8.4.8
*/
u_char ALL_L1_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x14};
u_char ALL_L2_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x15};
u_char ALL_ISS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x05};
u_char ALL_ESS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x04};
uint8_t ALL_L1_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x14};
uint8_t ALL_L2_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x15};
uint8_t ALL_ISS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x05};
uint8_t ALL_ESS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x04};
static char sock_buff[8192];
@ -76,9 +76,9 @@ static int open_bpf_dev(struct isis_circuit *circuit)
int i = 0, fd;
char bpfdev[128];
struct ifreq ifr;
u_int blen, immediate;
unsigned int blen, immediate;
#ifdef BIOCSSEESENT
u_int seesent;
unsigned int seesent;
#endif
struct timeval timeout;
struct bpf_program bpf_prog;
@ -214,10 +214,10 @@ end:
return retval;
}
int isis_recv_pdu_bcast(struct isis_circuit *circuit, u_char *ssnpa)
int isis_recv_pdu_bcast(struct isis_circuit *circuit, uint8_t *ssnpa)
{
int bytesread = 0, bytestoread, offset, one = 1, err = ISIS_OK;
u_char *buff_ptr;
uint8_t *buff_ptr;
struct bpf_hdr *bpf_hdr;
assert(circuit->fd > 0);

4
isisd/isis_circuit.c
View file

@ -209,7 +209,7 @@ void isis_circuit_add_addr(struct isis_circuit *circuit,
struct prefix_ipv6 *ipv6;
if (connected->address->family == AF_INET) {
u_int32_t addr = connected->address->u.prefix4.s_addr;
uint32_t addr = connected->address->u.prefix4.s_addr;
addr = ntohl(addr);
if (IPV4_NET0(addr) || IPV4_NET127(addr) || IN_CLASSD(addr)
|| IPV4_LINKLOCAL(addr))
@ -1235,7 +1235,7 @@ ferr_r isis_circuit_passwd_unset(struct isis_circuit *circuit)
}
static int isis_circuit_passwd_set(struct isis_circuit *circuit,
u_char passwd_type, const char *passwd)
uint8_t passwd_type, const char *passwd)
{
int len;

50
isisd/isis_circuit.h
View file

@ -37,26 +37,26 @@ struct isis_lsp;
struct password {
struct password *next;
int len;
u_char *pass;
uint8_t *pass;
};
struct metric {
u_char metric_default;
u_char metric_error;
u_char metric_expense;
u_char metric_delay;
uint8_t metric_default;
uint8_t metric_error;
uint8_t metric_expense;
uint8_t metric_delay;
};
struct isis_bcast_info {
u_char snpa[ETH_ALEN]; /* SNPA of this circuit */
uint8_t snpa[ETH_ALEN]; /* SNPA of this circuit */
char run_dr_elect[2]; /* Should we run dr election ? */
struct thread *t_run_dr[2]; /* DR election thread */
struct thread *t_send_lan_hello[2]; /* send LAN IIHs in this thread */
struct list *adjdb[2]; /* adjacency dbs */
struct list *lan_neighs[2]; /* list of lx neigh snpa */
char is_dr[2]; /* Are we level x DR ? */
u_char l1_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-1 DR */
u_char l2_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-2 DR */
uint8_t l1_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-1 DR */
uint8_t l2_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-2 DR */
struct thread *t_refresh_pseudo_lsp[2]; /* refresh pseudo-node LSPs */
};
@ -67,7 +67,7 @@ struct isis_p2p_info {
struct isis_circuit {
int state;
u_char circuit_id; /* l1/l2 bcast CircuitID */
uint8_t circuit_id; /* l1/l2 bcast CircuitID */
struct isis_area *area; /* back pointer to the area */
struct interface *interface; /* interface info from z */
int fd; /* IS-IS l1/2 socket */
@ -89,7 +89,7 @@ struct isis_circuit {
* circuit
*/
/* there is no real point in two streams, just for programming kicker */
int (*rx)(struct isis_circuit *circuit, u_char *ssnpa);
int (*rx)(struct isis_circuit *circuit, uint8_t *ssnpa);
struct stream *rcv_stream; /* Stream for receiving */
int (*tx)(struct isis_circuit *circuit, int level);
struct stream *snd_stream; /* Stream for sending */
@ -104,7 +104,7 @@ struct isis_circuit {
struct isis_bcast_info bc;
struct isis_p2p_info p2p;
} u;
u_char priority[2]; /* l1/2 IS configured priority */
uint8_t priority[2]; /* l1/2 IS configured priority */
int pad_hellos; /* add padding to Hello PDUs ? */
char ext_domain; /* externalDomain (boolean) */
int lsp_regenerate_pending[ISIS_LEVELS];
@ -114,12 +114,12 @@ struct isis_circuit {
struct isis_passwd passwd; /* Circuit rx/tx password */
int is_type; /* circuit is type == level of circuit
* differentiated from circuit type (media) */
u_int32_t hello_interval[2]; /* l1HelloInterval in msecs */
u_int16_t hello_multiplier[2]; /* l1HelloMultiplier */
u_int16_t csnp_interval[2]; /* level-1 csnp-interval in seconds */
u_int16_t psnp_interval[2]; /* level-1 psnp-interval in seconds */
u_int8_t metric[2];
u_int32_t te_metric[2];
uint32_t hello_interval[2]; /* l1HelloInterval in msecs */
uint16_t hello_multiplier[2]; /* l1HelloMultiplier */
uint16_t csnp_interval[2]; /* level-1 csnp-interval in seconds */
uint16_t psnp_interval[2]; /* level-1 psnp-interval in seconds */
uint8_t metric[2];
uint32_t te_metric[2];
struct mpls_te_circuit
*mtc; /* Support for MPLS-TE parameters - see isis_te.[c,h] */
int ip_router; /* Route IP ? */
@ -129,20 +129,20 @@ struct isis_circuit {
int ipv6_router; /* Route IPv6 ? */
struct list *ipv6_link; /* our link local IPv6 addresses */
struct list *ipv6_non_link; /* our non-link local IPv6 addresses */
u_int16_t upadjcount[2];
uint16_t upadjcount[2];
#define ISIS_CIRCUIT_FLAPPED_AFTER_SPF 0x01
u_char flags;
uint8_t flags;
bool disable_threeway_adj;
/*
* Counters as in 10589--11.2.5.9
*/
u_int32_t adj_state_changes; /* changesInAdjacencyState */
u_int32_t init_failures; /* intialisationFailures */
u_int32_t ctrl_pdus_rxed; /* controlPDUsReceived */
u_int32_t ctrl_pdus_txed; /* controlPDUsSent */
u_int32_t
uint32_t adj_state_changes; /* changesInAdjacencyState */
uint32_t init_failures; /* intialisationFailures */
uint32_t ctrl_pdus_rxed; /* controlPDUsReceived */
uint32_t ctrl_pdus_txed; /* controlPDUsSent */
uint32_t
desig_changes[2]; /* lanLxDesignatedIntermediateSystemChanges */
u_int32_t rej_adjacencies; /* rejectedAdjacencies */
uint32_t rej_adjacencies; /* rejectedAdjacencies */
QOBJ_FIELDS
};

16
isisd/isis_common.h
View file

@ -28,30 +28,30 @@
* Area Address
*/
struct area_addr {
u_char addr_len;
u_char area_addr[20];
uint8_t addr_len;
uint8_t area_addr[20];
};
struct isis_passwd {
u_char len;
uint8_t len;
#define ISIS_PASSWD_TYPE_UNUSED 0
#define ISIS_PASSWD_TYPE_CLEARTXT 1
#define ISIS_PASSWD_TYPE_HMAC_MD5 54
#define ISIS_PASSWD_TYPE_PRIVATE 255
u_char type;
uint8_t type;
/* Authenticate SNPs? */
#define SNP_AUTH_SEND 0x01
#define SNP_AUTH_RECV 0x02
u_char snp_auth;
u_char passwd[255];
uint8_t snp_auth;
uint8_t passwd[255];
};
/*
* Supported Protocol IDs
*/
struct nlpids {
u_char count;
u_char nlpids[4]; /* FIXME: enough ? */
uint8_t count;
uint8_t nlpids[4]; /* FIXME: enough ? */
};
#endif

30
isisd/isis_dlpi.c
View file

@ -54,14 +54,14 @@ static t_uscalar_t dlpi_ctl[1024]; /* DLPI control messages */
* ISO 10589 - 8.4.8
*/
u_char ALL_L1_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x14};
u_char ALL_L2_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x15};
u_char ALL_ISS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x05};
u_char ALL_ESS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x04};
uint8_t ALL_L1_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x14};
uint8_t ALL_L2_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x15};
uint8_t ALL_ISS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x05};
uint8_t ALL_ESS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x04};
static u_char sock_buff[8192];
static uint8_t sock_buff[8192];
static u_short pf_filter[] = {
static unsigned short pf_filter[] = {
ENF_PUSHWORD + 0, /* Get the SSAP/DSAP values */
ENF_PUSHLIT | ENF_CAND, /* Check them */
ISO_SAP | (ISO_SAP << 8),
@ -248,23 +248,23 @@ static int dlpibind(int fd)
return 0;
}
static int dlpimcast(int fd, const u_char *mcaddr)
static int dlpimcast(int fd, const uint8_t *mcaddr)
{
struct {
dl_enabmulti_req_t der;
u_char addr[ETHERADDRL];
uint8_t addr[ETHERADDRL];
} dler;
memset(&dler, 0, sizeof(dler));
dler.der.dl_primitive = DL_ENABMULTI_REQ;
dler.der.dl_addr_length = sizeof(dler.addr);
dler.der.dl_addr_offset = dler.addr - (u_char *)&dler;
dler.der.dl_addr_offset = dler.addr - (uint8_t *)&dler;
memcpy(dler.addr, mcaddr, sizeof(dler.addr));
dlpisend(fd, &dler, sizeof(dler), NULL, 0, 0);
return dlpiok(fd, dler.der.dl_primitive);
}
static int dlpiaddr(int fd, u_char *addr)
static int dlpiaddr(int fd, uint8_t *addr)
{
dl_phys_addr_req_t dpar;
dl_phys_addr_ack_t *dpaa = (dl_phys_addr_ack_t *)dlpi_ctl;
@ -443,7 +443,7 @@ static int open_dlpi_dev(struct isis_circuit *circuit)
struct strioctl sioc;
pfil.Pf_Priority = 0;
pfil.Pf_FilterLen = sizeof(pf_filter) / sizeof(u_short);
pfil.Pf_FilterLen = sizeof(pf_filter) / sizeof(unsigned short);
memcpy(pfil.Pf_Filter, pf_filter, sizeof(pf_filter));
/* pfmod does not support transparent ioctls */
sioc.ic_cmd = PFIOCSETF;
@ -495,7 +495,7 @@ end:
return retval;
}
int isis_recv_pdu_bcast(struct isis_circuit *circuit, u_char *ssnpa)
int isis_recv_pdu_bcast(struct isis_circuit *circuit, uint8_t *ssnpa)
{
struct pollfd fds[1];
struct strbuf ctlbuf, databuf;
@ -561,7 +561,7 @@ int isis_send_pdu_bcast(struct isis_circuit *circuit, int level)
{
dl_unitdata_req_t *dur = (dl_unitdata_req_t *)dlpi_ctl;
char *dstaddr;
u_short *dstsap;
unsigned short *dstsap;
int buflen;
int rv;
@ -583,9 +583,9 @@ int isis_send_pdu_bcast(struct isis_circuit *circuit, int level)
dstaddr = (char *)(dur + 1);
if (circuit->sap_length < 0) {
dstsap = (u_short *)(dstaddr + ETHERADDRL);
dstsap = (unsigned short *)(dstaddr + ETHERADDRL);
} else {
dstsap = (u_short *)dstaddr;
dstsap = (unsigned short *)dstaddr;
dstaddr += circuit->sap_length;
}
if (level == 1)

Some files were not shown because too many files have changed in this diff Show more