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) {
}
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;
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;
}
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;
struct bgp_advertise_fifo {
struct bgp_advertise *next;
struct bgp_advertise *prev;
- u_int32_t count;
+ uint32_t count;
};
/* BGP advertise attribute. */
/* Prefix information. */
struct bgp_node *rn;
- u_int32_t addpath_tx_id;
+ uint32_t addpath_tx_id;
/* Advertised attribute. */
struct attr *attr;
struct attr *attr;
/* Addpath identifier */
- u_int32_t addpath_rx_id;
+ uint32_t addpath_rx_id;
};
/* BGP advertisement list. */
: (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 *);
* 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. */
* 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;
/* 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 {
}
}
-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);
* 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
/* 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;
/* 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;
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;
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. */
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 */
}
/* 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));
}
/* 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;
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
* 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) {
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;
/* 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)
}
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);
}
{
- u_char val;
+ uint8_t val;
if ((val = stream_getc(s)))
zlog_warn(
"%s sent non-zero value, %u, for defunct SNPA-length field",
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;
}
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);
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;
}
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);
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;
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);
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.
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))
/* 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. */
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 */
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) {
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;
*/
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);
}
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;
/* 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;
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;
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);
/* 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;
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;
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;
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
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 *);
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 *);
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);
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)
: 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;
}
char *esi2str(struct eth_segment_id *id)
{
char *ptr;
- u_char *val;
+ uint8_t *val;
if (!id)
return NULL;
/* 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++;
/* 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++;
* 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)
* 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++;
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;
#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 {
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 */
/*
* 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;
/*
* 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,
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);
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);
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;
switch (type) {
case BGP_ATTR_ORIGIN: {
- u_char origin;
+ uint8_t origin;
origin = stream_getc(s);
printf("ORIGIN: %d\n", origin);
} break;
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);
/* 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);
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) {
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);
/* 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);
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;
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)
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;
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;
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 {
}
/* 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)
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;
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)
/* 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);
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);
}
{
int i;
struct community *new;
- u_int32_t val;
+ uint32_t val;
if (!com)
return NULL;
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;
}
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;
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) {
/* 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)
}
/* 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;
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);
}
/* 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++;
}
/* 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;
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 == ':') {
{
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 {
int size;
/* Communities value. */
- u_int32_t *val;
+ uint32_t *val;
/* Communities as a json object */
json_object *json;
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);
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 */
}
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;
}
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;
int index;
/* Last time message type. */
- u_char lastrecord;
+ uint8_t lastrecord;
#define BGP_RECORD_UPDATE 1U
#define BGP_RECORD_WITHDRAW 2U
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);
}
/* 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;
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];
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);
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 */
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);
}
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);
}
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;
}
/* 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;
* 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);
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. */
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;
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
(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);
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. */
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) {
int size;
/* Extended Communities value. */
- u_int8_t *val;
+ uint8_t *val;
/* Human readable format string. */
char *str;
/*
* 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;
/*
* 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;
/*
* 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;
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 *);
/* 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;
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;
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;
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);
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 */
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);
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);
}
/*
* 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;
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;
}
}
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);
/* 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;
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,
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;
* 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);
* 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;
* 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;
* 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;
* 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 */
* 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
* 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),
* 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;
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];
/*
* 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;
buf1,
sizeof(buf1)));
} else {
- u_char family;
+ uint8_t family;
family = IS_EVPN_PREFIX_IPADDR_V4(p) ? AF_INET
: AF_INET6;
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;
*/
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;
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 */
* 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;
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;
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;
}
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,
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);
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. */
/* 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)
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));
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;
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)
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;
/* 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)
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;
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;
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;
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;
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);
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);
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);
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);
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);
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;
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;
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];
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;
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;
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);
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;
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))
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);
"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;
JSON_STR)
{
struct bgp *bgp;
- u_char uj = 0;
+ uint8_t uj = 0;
json_object *json = NULL;
bgp = bgp_get_default();
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();
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;
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;
/* 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);
*/
static uint16_t bgp_write(struct peer *peer)
{
- u_char type;
+ uint8_t type;
struct stream *s;
int num;
int update_last_write = 0;
struct bgp *bgp;
struct bgp_table *table;
struct prefix p;
- u_int32_t label;
+ uint32_t label;
afi_t afi;
safi_t safi;
struct stream *s;
struct prefix *p;
int command;
- u_int16_t flags = 0;
+ uint16_t flags = 0;
size_t flags_pos = 0;
/* Check socket. */
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);
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;
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 */
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);
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;
}
}
/* 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);
}
/* 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);
};
static int lcommunity_add_val(struct lcommunity *lcom,
struct lcommunity_val *lval)
{
- u_int8_t *p;
+ uint8_t *p;
int ret;
int c;
}
/* 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;
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 == ':') {
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);
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);
}
/* 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;
int size;
/* Large Communities value. */
- u_int8_t *val;
+ uint8_t *val;
/* Human readable format string. */
char *str;
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 *);
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 */
* 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;
*
* 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;
*
* 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)
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;
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;
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
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 */
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;
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;
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;
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;
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;
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;
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;
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;
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;
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);
/* 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)
#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)
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;
}
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(
{
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 */
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 */
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)) {
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(
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);
* 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);
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;
/* 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);
* 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)
*
* @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;
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) {
}
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;
/* 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. */
/* 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 */
};
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[];
};
#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 */
* @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;
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))
/* 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 */
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. */
* @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;
* @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);
}
* @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;
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;
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);
/* 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(
/* 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;
}
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;
}
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;
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");
}
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) {
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;
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;
* @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;
*/
int bgp_capability_receive(struct peer *peer, bgp_size_t size)
{
- u_char *pnt;
+ uint8_t *pnt;
/* Fetch pointer. */
pnt = stream_pnt(peer->curr);
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];
/* 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 *);
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 *);
#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];
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;
#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 *);
/* 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);
}
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);
/* 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;
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;
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;
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
}
-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;
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;
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;
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)
{
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;
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];
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)
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;
#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);
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);
*/
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;
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) {
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];
}
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;
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;
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;
/* 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;
json_object *json)
{
int len = 0;
- u_int32_t destination;
+ uint32_t destination;
char buf[BUFSIZ];
if (p->family == AF_INET) {
/* 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;
/* 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;
/* 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;
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)
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)
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;
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;
}
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;
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;
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();
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;
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;
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;
}
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;
}
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;
{
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)
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;
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;
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) {
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)
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;
afi_t afi;
safi_t safi;
struct prefix p;
- u_char distance;
+ uint8_t distance;
struct bgp_node *rn;
struct bgp_distance *bdistance;
}
/* 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;
/* "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);
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 {
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;
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)
#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
#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 */
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 {
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 *);
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 *);
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);
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);
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,
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 */
#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;
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:
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;
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;
/* 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;
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) {
`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;
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;
route_map_object_t type,
void *object)
{
- u_char *origin;
+ uint8_t *origin;
struct bgp_info *bgp_info;
if (type == RMAP_BGP) {
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;
{
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. */
{
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. */
route_map_object_t type,
void *object)
{
- u_char *origin;
+ uint8_t *origin;
struct bgp_info *bgp_info;
if (type == RMAP_BGP) {
/* 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;
{
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. */
{
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;
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. */
};
-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)
/* 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;
}
/* 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;
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;
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);
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;
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
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;
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)
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;
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;
};
/*
struct hash *hash;
struct thread *t_coalesce;
- u_int32_t v_coalesce;
+ uint32_t v_coalesce;
struct thread *t_merge_check;
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;
};
/*
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)
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);
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);
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;
}
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;
}
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));
*/
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;
*/
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;
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);
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;
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;
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;
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;
}
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;
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 */
* @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;
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);
{
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;
{
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;
{
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);
{
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);
"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;
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);
}
}
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;
}
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);
}
{
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;
{
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;
"Send Large Community attributes\n")
{
int idx = 0;
- u_int32_t flag = 0;
+ uint32_t flag = 0;
char *peer = argv[1]->arg;
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);
{
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);
const char *port_str)
{
struct peer *peer;
- u_int16_t port;
+ uint16_t port;
struct servent *sp;
peer = peer_lookup_vty(vty, 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)
{
int ret;
struct peer *peer;
- u_int32_t connect;
+ uint32_t connect;
peer = peer_and_group_lookup_vty(vty, ip_str);
if (!peer)
{
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)
"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);
{
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)
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;
/* 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;
}
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;
}
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;
}
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;
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)
}
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;
}
}
-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;
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;
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(
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,
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;
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;
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;
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;
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);
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);
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);
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);
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)
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)
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)
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)
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)
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);
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);
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);
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 */
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;
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;
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;
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;
}
/* 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. */
}
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.
/* 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;
/* Unset redistribution. */
int bgp_redistribute_unreg(struct bgp *bgp, afi_t afi, int type,
- u_short instance)
+ unsigned short instance)
{
struct bgp_redist *red;
/* Unset redistribution. */
int bgp_redistribute_unset(struct bgp *bgp, afi_t afi, int type,
- u_short instance)
+ unsigned short instance)
{
struct bgp_redist *red;
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;
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);
}
/* 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);
}
/* 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;
}
/* 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;
== 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;
{
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
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[] = {
/* 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;
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)) {
msglen = 128;
if (msglen) {
- u_char msgbuf[129];
+ uint8_t msgbuf[129];
msgbuf[0] = msglen;
memcpy(msgbuf + 1, msg, msglen);
}
/* 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;
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;
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);
}
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;
/* 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;
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;
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;
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;
}
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;
|| 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))
}
/* 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;
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> ");
}
};
/* 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) \
({ \
struct list *listen_sockets;
/* BGP port number. */
- u_int16_t port;
+ uint16_t port;
/* Listener address */
char *address;
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)
/* 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 */
};
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;
* 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;
-
- u_int32_t updgrps_created;
- u_int32_t updgrps_deleted;
- u_int32_t subgrps_created;
- u_int32_t subgrps_deleted;
+ 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;
+
+ 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)
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)
#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)
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];
/* 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
/* 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. */
#define BGP_RD_SIZE 8
struct bgp_rd {
- u_char val[BGP_RD_SIZE];
+ uint8_t val[BGP_RD_SIZE];
};
#define RMAP_IN 0
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 */
#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 */
#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 */
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 */
} 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 */
#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 */
#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 */
_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. */
/* 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. */
#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 */
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;
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 *);
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);
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 *);
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 *);
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 **);
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);
*/
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;
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,
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;
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;
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__);
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;
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;
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))
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(
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 */
{
}
}
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)
}
for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
- u_char family;
+ uint8_t family;
family = afi2family(afi);
if (!family)
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;
};
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;
}
/* 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)
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;
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;
struct prefix_rd *prd;
struct attr new_attr;
- u_int32_t label = 0;
+ uint32_t label = 0;
++count; /* debugging */
struct bgp_info *bi;
struct prefix_rd *prd;
struct attr new_attr;
- u_int32_t label = 0;
+ uint32_t label = 0;
/* do pull-down */
struct prefix_rd *prd;
struct attr new_attr;
- u_int32_t label = 0;
+ uint32_t label = 0;
/* do pull-down */
&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;
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;
/*
* 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();
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 */
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
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
~~~~~~~~~~~~~~~~~~~~~~
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));
}
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",
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";
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",
},
};
-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";
// 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) {
* @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.
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)
* @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);
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)
{
*
* @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);
* 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;
}
*
* @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;
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;
}
*
* @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();
* @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.
* 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);
*
*/
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);
* 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;
}
}
-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;
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;
}
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 *);
/* 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_ */
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;
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");
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 *,
int eigrp_if_ipmulticast(struct eigrp *top, struct prefix *p,
unsigned int ifindex)
{
- u_char val;
+ uint8_t val;
int ret, len;
val = 0;
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;
+ 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;
+ (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;
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)
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_ */
}
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;
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;
}
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;
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;
}
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
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);
{
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. */
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;
}
/* 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;
/* 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);
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) {
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;
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;
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 *);
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 *);
* 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 *,
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
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 *);
#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");
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++;
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);
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;
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;
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
- u_int16_t type;
+ uint16_t type;
/* increment statistics. */
ei->reply_in++;
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);
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;
/* 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)
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)
/* 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;
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)
}
/* 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;
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
- u_int16_t type;
+ uint16_t type;
/* increment statistics. */
ei->siaQuery_in++;
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);
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);
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
- u_int16_t type;
+ uint16_t type;
/* increment statistics. */
ei->siaReply_in++;
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);
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);
#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[] = {
}
-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;
}
-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;
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;
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;
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;
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;
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;
char *name;
struct route_map *map;
int metric_config;
- u_int32_t metric;
+ uint32_t metric;
} route_map[ZEBRA_ROUTE_MAX];
QOBJ_FIELDS
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 */
/* 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 */
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;
-
- u_int32_t crypt_seqnum; /* Cryptographic Sequence Number */
+ 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;
+
+ uint32_t crypt_seqnum; /* Cryptographic Sequence Number */
/* Access-list. */
struct access_list *list[EIGRP_FILTER_MAX];
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;
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;
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;
};
};
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));
* +-----+------------------+
*/
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 */
/* 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;
/* 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
};
/* 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;
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);
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. */
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);
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);
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)) {
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);
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);
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,
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;
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) {
{
VTY_DECLVAR_CONTEXT(interface, ifp);
struct eigrp_interface *ei = ifp->info;
- u_int32_t bandwidth;
+ uint32_t bandwidth;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
{
VTY_DECLVAR_CONTEXT(interface, ifp);
struct eigrp_interface *ei = ifp->info;
- u_int32_t hello;
+ uint32_t hello;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
{
VTY_DECLVAR_CONTEXT(interface, ifp);
struct eigrp_interface *ei = ifp->info;
- u_int32_t hold;
+ uint32_t hold;
struct eigrp *eigrp;
eigrp = eigrp_lookup();
"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();
"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();
"Metric variance multiplier\n")
{
struct eigrp *eigrp;
- u_char variance;
+ uint8_t variance;
eigrp = eigrp_lookup();
if (eigrp == NULL) {
"Number of paths\n")
{
struct eigrp *eigrp;
- u_char max;
+ uint8_t max;
eigrp = eigrp_lookup();
if (eigrp == NULL) {
{
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;
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;
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;
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;
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;
};
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];
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 */
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,
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];
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;
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);
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))
}
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;
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 */
};
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 */
* 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 */
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];
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 ? */
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
};
* 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
* 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),
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;
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;
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;
{
dl_unitdata_req_t *dur = (dl_unitdata_req_t *)dlpi_ctl;
char *dstaddr;
- u_short *dstsap;
+ unsigned short *dstsap;
int buflen;
int rv;
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)
struct listnode *node;
struct isis_adjacency *adj, *adj_dr = NULL;
struct list *list = list_new();
- u_char own_prio;
+ uint8_t own_prio;
int biggest_prio = -1;
int cmp_res, retval = ISIS_OK;
int isis_dr_resign(struct isis_circuit *circuit, int level)
{
- u_char id[ISIS_SYS_ID_LEN + 2];
+ uint8_t id[ISIS_SYS_ID_LEN + 2];
zlog_debug("isis_dr_resign l%d", level);
int isis_dr_commence(struct isis_circuit *circuit, int level)
{
- u_char old_dr[ISIS_SYS_ID_LEN + 2];
+ uint8_t old_dr[ISIS_SYS_ID_LEN + 2];
if (isis->debugs & DEBUG_EVENTS)
zlog_debug("isis_dr_commence l%d", level);
return ISIS_OK;
}
-struct isis_dynhn *dynhn_find_by_id(const u_char *id)
+struct isis_dynhn *dynhn_find_by_id(const uint8_t *id)
{
struct listnode *node = NULL;
struct isis_dynhn *dyn = NULL;
return NULL;
}
-void isis_dynhn_insert(const u_char *id, const char *hostname, int level)
+void isis_dynhn_insert(const uint8_t *id, const char *hostname, int level)
{
struct isis_dynhn *dyn;
dyn->refresh = time(NULL);
}
-void isis_dynhn_remove(const u_char *id)
+void isis_dynhn_remove(const uint8_t *id)
{
struct isis_dynhn *dyn;
#define _ZEBRA_ISIS_DYNHN_H
struct isis_dynhn {
- u_char id[ISIS_SYS_ID_LEN];
+ uint8_t id[ISIS_SYS_ID_LEN];
char hostname[256];
time_t refresh;
int level;
};
void dyn_cache_init(void);
-void isis_dynhn_insert(const u_char *id, const char *hostname, int level);
-void isis_dynhn_remove(const u_char *id);
-struct isis_dynhn *dynhn_find_by_id(const u_char *id);
+void isis_dynhn_insert(const uint8_t *id, const char *hostname, int level);
+void isis_dynhn_remove(const uint8_t *id);
+struct isis_dynhn *dynhn_find_by_id(const uint8_t *id);
struct isis_dynhn *dynhn_find_by_name(const char *hostname);
void dynhn_print_all(struct vty *vty);
}
void isis_event_auth_failure(char *area_tag, const char *error_string,
- u_char *sysid)
+ uint8_t *sysid)
{
if (isis->debugs & DEBUG_EVENTS)
zlog_debug("ISIS-Evt (%s) Authentication failure %s from %s",
#define AUTH_ERROR_TYPE_SNP 2
#define AUTH_ERROR_TYPE_HELLO 1
void isis_event_auth_failure(char *area_tag, const char *error_string,
- u_char *sysid);
+ uint8_t *sysid);
#endif /* _ZEBRA_ISIS_EVENTS_H */
return;
}
-int flags_any_set(u_int32_t *flags)
+int flags_any_set(uint32_t *flags)
{
- u_int32_t zero[ISIS_MAX_CIRCUITS];
+ uint32_t zero[ISIS_MAX_CIRCUITS];
memset(zero, 0x00, ISIS_MAX_CIRCUITS * 4);
return bcmp(flags, zero, ISIS_MAX_CIRCUITS * 4);
void flags_initialize(struct flags *flags);
long int flags_get_index(struct flags *flags);
void flags_free_index(struct flags *flags, long int index);
-int flags_any_set(u_int32_t *flags);
+int flags_any_set(uint32_t *flags);
#define _ISIS_SET_FLAG(F, C) \
{ \
static int lsp_l1_refresh_pseudo(struct thread *thread);
static int lsp_l2_refresh_pseudo(struct thread *thread);
-int lsp_id_cmp(u_char *id1, u_char *id2)
+int lsp_id_cmp(uint8_t *id1, uint8_t *id2)
{
return memcmp(id1, id2, ISIS_SYS_ID_LEN + 2);
}
return dict;
}
-struct isis_lsp *lsp_search(u_char *id, dict_t *lspdb)
+struct isis_lsp *lsp_search(uint8_t *id, dict_t *lspdb)
{
dnode_t *node;
zlog_debug("searching db");
for (dn = dict_first(lspdb); dn; dn = dict_next(lspdb, dn)) {
zlog_debug("%s\t%pX",
- rawlspid_print((u_char *)dnode_getkey(dn)),
+ rawlspid_print((uint8_t *)dnode_getkey(dn)),
dnode_get(dn));
}
#endif /* EXTREME DEBUG */
return;
}
-void lsp_search_and_destroy(u_char *id, dict_t *lspdb)
+void lsp_search_and_destroy(uint8_t *id, dict_t *lspdb)
{
dnode_t *node;
struct isis_lsp *lsp;
return;
}
-static u_int8_t lsp_bits_generate(int level, int overload_bit, int attached_bit)
+static uint8_t lsp_bits_generate(int level, int overload_bit, int attached_bit)
{
- u_int8_t lsp_bits = 0;
+ uint8_t lsp_bits = 0;
if (level == IS_LEVEL_1)
lsp_bits = IS_LEVEL_1;
else
return lsp;
}
-struct isis_lsp *lsp_new(struct isis_area *area, u_char *lsp_id,
+struct isis_lsp *lsp_new(struct isis_area *area, uint8_t *lsp_id,
uint16_t rem_lifetime, uint32_t seqno,
uint8_t lsp_bits, uint16_t checksum,
struct isis_lsp *lsp0, int level)
/*
* Build a list of LSPs with non-zero ht bounded by start and stop ids
*/
-void lsp_build_list_nonzero_ht(u_char *start_id, u_char *stop_id,
+void lsp_build_list_nonzero_ht(uint8_t *start_id, uint8_t *stop_id,
struct list *list, dict_t *lspdb)
{
dnode_t *first, *last, *curr;
stream_putw_at(lsp->pdu, 10, lsp->hdr.rem_lifetime);
}
-static void lspid_print(u_char *lsp_id, u_char *trg, char dynhost, char frag)
+static void lspid_print(uint8_t *lsp_id, uint8_t *trg, char dynhost, char frag)
{
struct isis_dynhn *dyn = NULL;
- u_char id[SYSID_STRLEN];
+ uint8_t id[SYSID_STRLEN];
if (dynhost)
dyn = dynhn_find_by_id(lsp_id);
/* this function prints the lsp on show isis database */
void lsp_print(struct isis_lsp *lsp, struct vty *vty, char dynhost)
{
- u_char LSPid[255];
+ uint8_t LSPid[255];
char age_out[8];
lspid_print(lsp->hdr.lsp_id, LSPid, dynhost, 1);
return lsp_count;
}
-static u_int16_t lsp_rem_lifetime(struct isis_area *area, int level)
+static uint16_t lsp_rem_lifetime(struct isis_area *area, int level)
{
- u_int16_t rem_lifetime;
+ uint16_t rem_lifetime;
/* Add jitter to configured LSP lifetime */
rem_lifetime =
return rem_lifetime;
}
-static u_int16_t lsp_refresh_time(struct isis_lsp *lsp, u_int16_t rem_lifetime)
+static uint16_t lsp_refresh_time(struct isis_lsp *lsp, uint16_t rem_lifetime)
{
struct isis_area *area = lsp->area;
int level = lsp->level;
- u_int16_t refresh_time;
+ uint16_t refresh_time;
/* Add jitter to LSP refresh time */
refresh_time =
int lsp_generate(struct isis_area *area, int level)
{
struct isis_lsp *oldlsp, *newlsp;
- u_int32_t seq_num = 0;
- u_char lspid[ISIS_SYS_ID_LEN + 2];
- u_int16_t rem_lifetime, refresh_time;
+ uint32_t seq_num = 0;
+ uint8_t lspid[ISIS_SYS_ID_LEN + 2];
+ uint16_t rem_lifetime, refresh_time;
if ((area == NULL) || (area->is_type & level) != level)
return ISIS_ERROR;
dict_t *lspdb;
struct isis_lsp *lsp, *frag;
struct listnode *node;
- u_char lspid[ISIS_SYS_ID_LEN + 2];
- u_int16_t rem_lifetime, refresh_time;
+ uint8_t lspid[ISIS_SYS_ID_LEN + 2];
+ uint16_t rem_lifetime, refresh_time;
if ((area == NULL) || (area->is_type & level) != level)
return ISIS_ERROR;
int lsp_regenerate_schedule(struct isis_area *area, int level, int all_pseudo)
{
struct isis_lsp *lsp;
- u_char id[ISIS_SYS_ID_LEN + 2];
+ uint8_t id[ISIS_SYS_ID_LEN + 2];
time_t now, diff;
long timeout;
struct listnode *cnode;
{
dict_t *lspdb = circuit->area->lspdb[level - 1];
struct isis_lsp *lsp;
- u_char lsp_id[ISIS_SYS_ID_LEN + 2];
- u_int16_t rem_lifetime, refresh_time;
+ uint8_t lsp_id[ISIS_SYS_ID_LEN + 2];
+ uint16_t rem_lifetime, refresh_time;
if ((circuit->is_type & level) != level
|| (circuit->state != C_STATE_UP)
{
dict_t *lspdb = circuit->area->lspdb[level - 1];
struct isis_lsp *lsp;
- u_char lsp_id[ISIS_SYS_ID_LEN + 2];
- u_int16_t rem_lifetime, refresh_time;
+ uint8_t lsp_id[ISIS_SYS_ID_LEN + 2];
+ uint16_t rem_lifetime, refresh_time;
if ((circuit->is_type & level) != level
|| (circuit->state != C_STATE_UP)
static int lsp_l1_refresh_pseudo(struct thread *thread)
{
struct isis_circuit *circuit;
- u_char id[ISIS_SYS_ID_LEN + 2];
+ uint8_t id[ISIS_SYS_ID_LEN + 2];
circuit = THREAD_ARG(thread);
static int lsp_l2_refresh_pseudo(struct thread *thread)
{
struct isis_circuit *circuit;
- u_char id[ISIS_SYS_ID_LEN + 2];
+ uint8_t id[ISIS_SYS_ID_LEN + 2];
circuit = THREAD_ARG(thread);
int lsp_regenerate_schedule_pseudo(struct isis_circuit *circuit, int level)
{
struct isis_lsp *lsp;
- u_char lsp_id[ISIS_SYS_ID_LEN + 2];
+ uint8_t lsp_id[ISIS_SYS_ID_LEN + 2];
time_t now, diff;
long timeout;
int lvl;
struct listnode *lspnode, *cnode;
dnode_t *dnode, *dnode_next;
int level;
- u_int16_t rem_lifetime;
+ uint16_t rem_lifetime;
time_t now = monotime(NULL);
lsp_list = list_new();
return ISIS_OK;
}
-void lsp_purge_pseudo(u_char *id, struct isis_circuit *circuit, int level)
+void lsp_purge_pseudo(uint8_t *id, struct isis_circuit *circuit, int level)
{
struct isis_lsp *lsp;
struct list *frags;
struct isis_lsp *zero_lsp;
} lspu;
- u_int32_t SRMflags[ISIS_MAX_CIRCUITS];
- u_int32_t SSNflags[ISIS_MAX_CIRCUITS];
+ uint32_t SRMflags[ISIS_MAX_CIRCUITS];
+ uint32_t SSNflags[ISIS_MAX_CIRCUITS];
int level; /* L1 or L2? */
int scheduled; /* scheduled for sending */
time_t installed;
struct stream *stream, struct isis_lsp *lsp0,
struct isis_area *area, int level);
void lsp_insert(struct isis_lsp *lsp, dict_t *lspdb);
-struct isis_lsp *lsp_search(u_char *id, dict_t *lspdb);
+struct isis_lsp *lsp_search(uint8_t *id, dict_t *lspdb);
-void lsp_build_list(u_char *start_id, u_char *stop_id, u_char num_lsps,
+void lsp_build_list(uint8_t *start_id, uint8_t *stop_id, uint8_t num_lsps,
struct list *list, dict_t *lspdb);
-void lsp_build_list_nonzero_ht(u_char *start_id, u_char *stop_id,
+void lsp_build_list_nonzero_ht(uint8_t *start_id, uint8_t *stop_id,
struct list *list, dict_t *lspdb);
-void lsp_search_and_destroy(u_char *id, dict_t *lspdb);
-void lsp_purge_pseudo(u_char *id, struct isis_circuit *circuit, int level);
+void lsp_search_and_destroy(uint8_t *id, dict_t *lspdb);
+void lsp_purge_pseudo(uint8_t *id, struct isis_circuit *circuit, int level);
void lsp_purge_non_exist(int level, struct isis_lsp_hdr *hdr,
struct isis_area *area);
memcpy((I), isis->sysid, ISIS_SYS_ID_LEN); \
(I)[ISIS_SYS_ID_LEN] = 0; \
(I)[ISIS_SYS_ID_LEN + 1] = 0
-int lsp_id_cmp(u_char *id1, u_char *id2);
+int lsp_id_cmp(uint8_t *id1, uint8_t *id2);
int lsp_compare(char *areatag, struct isis_lsp *lsp, uint32_t seqno,
uint16_t checksum, uint16_t rem_lifetime);
void lsp_update(struct isis_lsp *lsp, struct isis_lsp_hdr *hdr,
/*
* This converts the isonet to its printable format
*/
-const char *isonet_print(const u_char *from, int len)
+const char *isonet_print(const uint8_t *from, int len)
{
int i = 0;
char *pos = isonet;
* Returns 0 on error, length of buff on ok
* extract dot from the dotted str, and insert all the number in a buff
*/
-int dotformat2buff(u_char *buff, const char *dotted)
+int dotformat2buff(uint8_t *buff, const char *dotted)
{
int dotlen, len = 0;
const char *pos = dotted;
- u_char number[3];
+ uint8_t number[3];
int nextdotpos = 2;
number[2] = '\0';
/*
* conversion of XXXX.XXXX.XXXX to memory
*/
-int sysid2buff(u_char *buff, const char *dotted)
+int sysid2buff(uint8_t *buff, const char *dotted)
{
int len = 0;
const char *pos = dotted;
- u_char number[3];
+ uint8_t number[3];
number[2] = '\0';
// surely not a sysid_string if not 14 length
/*
* Print functions - we print to static vars
*/
-const char *snpa_print(const u_char *from)
+const char *snpa_print(const uint8_t *from)
{
return isis_format_id(from, ISIS_SYS_ID_LEN);
}
-const char *sysid_print(const u_char *from)
+const char *sysid_print(const uint8_t *from)
{
return isis_format_id(from, ISIS_SYS_ID_LEN);
}
-const char *rawlspid_print(const u_char *from)
+const char *rawlspid_print(const uint8_t *from)
{
return isis_format_id(from, 8);
}
return rv;
}
-const char *time2string(u_int32_t time)
+const char *time2string(uint32_t time)
{
char *pos = datestring;
- u_int32_t rest;
+ uint32_t rest;
if (time == 0)
return "-";
return timer;
}
-struct in_addr newprefix2inaddr(u_char *prefix_start, u_char prefix_masklen)
+struct in_addr newprefix2inaddr(uint8_t *prefix_start, uint8_t prefix_masklen)
{
memset(&new_prefix, 0, sizeof(new_prefix));
memcpy(&new_prefix, prefix_start,
* Returns the dynamic hostname associated with the passed system ID.
* If no dynamic hostname found then returns formatted system ID.
*/
-const char *print_sys_hostname(const u_char *sysid)
+const char *print_sys_hostname(const uint8_t *sysid)
{
struct isis_dynhn *dyn;
const char *circuit_state2string(int state);
const char *circuit_type2string(int type);
const char *syst2string(int);
-struct in_addr newprefix2inaddr(u_char *prefix_start, u_char prefix_masklen);
+struct in_addr newprefix2inaddr(uint8_t *prefix_start, uint8_t prefix_masklen);
/*
* Converting input to memory stored format
* return value of 0 indicates wrong input
*/
-int dotformat2buff(u_char *, const char *);
-int sysid2buff(u_char *, const char *);
+int dotformat2buff(uint8_t *, const char *);
+int sysid2buff(uint8_t *, const char *);
/*
* Printing functions
*/
-const char *isonet_print(const u_char *, int len);
-const char *sysid_print(const u_char *);
-const char *snpa_print(const u_char *);
-const char *rawlspid_print(const u_char *);
+const char *isonet_print(const uint8_t *, int len);
+const char *sysid_print(const uint8_t *);
+const char *snpa_print(const uint8_t *);
+const char *rawlspid_print(const uint8_t *);
const char *isis_format_id(const uint8_t *id, size_t len);
-const char *time2string(u_int32_t);
+const char *time2string(uint32_t);
const char *nlpid2str(uint8_t nlpid);
/* typedef struct nlpids nlpids; */
char *nlpid2string(struct nlpids *);
-const char *print_sys_hostname(const u_char *sysid);
+const char *print_sys_hostname(const uint8_t *sysid);
void zlog_dump_data(void *data, int len);
/*
#ifndef _ZEBRA_ISIS_NETWORK_H
#define _ZEBRA_ISIS_NETWORK_H
-extern u_char ALL_L1_ISYSTEMS[];
-extern u_char ALL_L2_ISYSTEMS[];
+extern uint8_t ALL_L1_ISYSTEMS[];
+extern uint8_t ALL_L2_ISYSTEMS[];
int isis_sock_init(struct isis_circuit *circuit);
-int isis_recv_pdu_bcast(struct isis_circuit *circuit, u_char *ssnpa);
-int isis_recv_pdu_p2p(struct isis_circuit *circuit, u_char *ssnpa);
+int isis_recv_pdu_bcast(struct isis_circuit *circuit, uint8_t *ssnpa);
+int isis_recv_pdu_p2p(struct isis_circuit *circuit, uint8_t *ssnpa);
int isis_send_pdu_bcast(struct isis_circuit *circuit, int level);
int isis_send_pdu_p2p(struct isis_circuit *circuit, int level);
{
unsigned long lenp;
int retval;
- u_int16_t length;
+ uint16_t length;
uint8_t pdu_type =
(level == IS_LEVEL_1) ? L1_PARTIAL_SEQ_NUM : L2_PARTIAL_SEQ_NUM;
stream_putl(circuit->snd_stream, hdr->seqno);
stream_putw(circuit->snd_stream, hdr->checksum);
- length = (u_int16_t)stream_get_endp(circuit->snd_stream);
+ length = (uint16_t)stream_get_endp(circuit->snd_stream);
/* Update PDU length */
stream_putw_at(circuit->snd_stream, lenp, length);
struct iih_info {
struct isis_circuit *circuit;
- u_char *ssnpa;
+ uint8_t *ssnpa;
int level;
uint8_t circ_type;
}
if (adj->dis_record[iih->level - 1].dis == ISIS_IS_DIS) {
- u_char *dis = (iih->level == 1)
- ? iih->circuit->u.bc.l1_desig_is
- : iih->circuit->u.bc.l2_desig_is;
+ uint8_t *dis = (iih->level == 1)
+ ? iih->circuit->u.bc.l1_desig_is
+ : iih->circuit->u.bc.l2_desig_is;
if (memcmp(dis, iih->dis, ISIS_SYS_ID_LEN + 1)) {
thread_add_event(master, isis_event_dis_status_change,
}
static int process_hello(uint8_t pdu_type, struct isis_circuit *circuit,
- u_char *ssnpa)
+ uint8_t *ssnpa)
{
bool p2p_hello = (pdu_type == P2P_HELLO);
int level = p2p_hello ? 0
* Section 7.3.15.1 - Action on receipt of a link state PDU
*/
static int process_lsp(uint8_t pdu_type, struct isis_circuit *circuit,
- const u_char *ssnpa)
+ const uint8_t *ssnpa)
{
int level = (pdu_type == L1_LINK_STATE) ? ISIS_LEVEL1 : ISIS_LEVEL2;
*/
static int process_snp(uint8_t pdu_type, struct isis_circuit *circuit,
- const u_char *ssnpa)
+ const uint8_t *ssnpa)
{
bool is_csnp = (pdu_type == L1_COMPLETE_SEQ_NUM
|| pdu_type == L2_COMPLETE_SEQ_NUM);
* PDU Dispatcher
*/
-int isis_handle_pdu(struct isis_circuit *circuit, u_char *ssnpa)
+int isis_handle_pdu(struct isis_circuit *circuit, uint8_t *ssnpa)
{
int retval = ISIS_OK;
int isis_receive(struct thread *thread)
{
struct isis_circuit *circuit;
- u_char ssnpa[ETH_ALEN];
+ uint8_t ssnpa[ETH_ALEN];
int retval;
/*
stream_putw(circuit->snd_stream, 0); /* length is filled in later */
if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- u_char *desig_is = (level == IS_LEVEL_1)
- ? circuit->u.bc.l1_desig_is
- : circuit->u.bc.l2_desig_is;
+ uint8_t *desig_is = (level == IS_LEVEL_1)
+ ? circuit->u.bc.l1_desig_is
+ : circuit->u.bc.l2_desig_is;
stream_putc(circuit->snd_stream, circuit->priority[level - 1]);
stream_put(circuit->snd_stream, desig_is, ISIS_SYS_ID_LEN + 1);
} else {
memcpy(start, stop, ISIS_SYS_ID_LEN + 2);
loop = 0;
for (int i = ISIS_SYS_ID_LEN + 1; i >= 0; --i) {
- if (start[i] < (u_char)0xff) {
+ if (start[i] < (uint8_t)0xff) {
start[i] += 1;
loop = 1;
break;
*/
struct esis_fixed_hdr {
- u_char idrp;
- u_char length;
- u_char version;
- u_char id_len;
- u_char pdu_type;
- u_int16_t holdtime;
- u_int16_t checksum;
+ uint8_t idrp;
+ uint8_t length;
+ uint8_t version;
+ uint8_t id_len;
+ uint8_t pdu_type;
+ uint16_t holdtime;
+ uint16_t checksum;
} __attribute__((packed));
#define ESIS_FIXED_HDR_LEN 9
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
struct isis_lan_hello_hdr {
- u_char circuit_t;
- u_char source_id[ISIS_SYS_ID_LEN];
- u_int16_t hold_time;
- u_int16_t pdu_len;
- u_char prio;
- u_char lan_id[ISIS_SYS_ID_LEN + 1];
+ uint8_t circuit_t;
+ uint8_t source_id[ISIS_SYS_ID_LEN];
+ uint16_t hold_time;
+ uint16_t pdu_len;
+ uint8_t prio;
+ uint8_t lan_id[ISIS_SYS_ID_LEN + 1];
} __attribute__((packed));
#define ISIS_LANHELLO_HDRLEN 19
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
struct isis_p2p_hello_hdr {
- u_char circuit_t;
- u_char source_id[ISIS_SYS_ID_LEN];
- u_int16_t hold_time;
- u_int16_t pdu_len;
- u_char local_id;
+ uint8_t circuit_t;
+ uint8_t source_id[ISIS_SYS_ID_LEN];
+ uint16_t hold_time;
+ uint16_t pdu_len;
+ uint8_t local_id;
} __attribute__((packed));
#define ISIS_P2PHELLO_HDRLEN 12
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
struct isis_complete_seqnum_hdr {
- u_int16_t pdu_len;
- u_char source_id[ISIS_SYS_ID_LEN + 1];
- u_char start_lsp_id[ISIS_SYS_ID_LEN + 2];
- u_char stop_lsp_id[ISIS_SYS_ID_LEN + 2];
+ uint16_t pdu_len;
+ uint8_t source_id[ISIS_SYS_ID_LEN + 1];
+ uint8_t start_lsp_id[ISIS_SYS_ID_LEN + 2];
+ uint8_t stop_lsp_id[ISIS_SYS_ID_LEN + 2];
};
#define ISIS_CSNP_HDRLEN 25
* +---------------------------------------------------------------+
*/
struct isis_partial_seqnum_hdr {
- u_int16_t pdu_len;
- u_char source_id[ISIS_SYS_ID_LEN + 1];
+ uint16_t pdu_len;
+ uint8_t source_id[ISIS_SYS_ID_LEN + 1];
};
#define ISIS_PSNP_HDRLEN 9
int send_lsp(struct thread *thread);
void fill_fixed_hdr(uint8_t pdu_type, struct stream *stream);
int send_hello(struct isis_circuit *circuit, int level);
-int isis_handle_pdu(struct isis_circuit *circuit, u_char *ssnpa);
+int isis_handle_pdu(struct isis_circuit *circuit, uint8_t *ssnpa);
#endif /* _ZEBRA_ISIS_PDU_H */
* 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 uint8_t discard_buff[8192];
static uint8_t sock_buff[8192];
return retval;
}
-static inline int llc_check(u_char *llc)
+static inline int llc_check(uint8_t *llc)
{
if (*llc != ISO_SAP || *(llc + 1) != ISO_SAP || *(llc + 2) != 3)
return 0;
return 1;
}
-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, addr_len;
struct sockaddr_ll s_addr;
- u_char llc[LLC_LEN];
+ uint8_t llc[LLC_LEN];
addr_len = sizeof(s_addr);
return ISIS_OK;
}
-int isis_recv_pdu_p2p(struct isis_circuit *circuit, u_char *ssnpa)
+int isis_recv_pdu_p2p(struct isis_circuit *circuit, uint8_t *ssnpa)
{
int bytesread, addr_len;
struct sockaddr_ll s_addr;
}
/* Handle notification about route being added */
-void isis_redist_add(int type, struct prefix *p, u_char distance,
+void isis_redist_add(int type, struct prefix *p, uint8_t distance,
uint32_t metric)
{
int family = p->family;
struct isis_ext_info {
int origin;
uint32_t metric;
- u_char distance;
+ uint8_t distance;
};
struct isis_redist {
struct route_table *get_ext_reach(struct isis_area *area, int family,
int level);
-void isis_redist_add(int type, struct prefix *p, u_char distance,
+void isis_redist_add(int type, struct prefix *p, uint8_t distance,
uint32_t metric);
void isis_redist_delete(int type, struct prefix *p);
int isis_redist_config_write(struct vty *vty, struct isis_area *area,
}
static int isis_route_info_same(struct isis_route_info *new,
- struct isis_route_info *old, u_char family)
+ struct isis_route_info *old, uint8_t family)
{
struct listnode *node;
struct isis_nexthop *nexthop;
return 1;
}
-struct isis_route_info *isis_route_create(struct prefix *prefix, u_int32_t cost,
- u_int32_t depth,
+struct isis_route_info *isis_route_create(struct prefix *prefix, uint32_t cost,
+ uint32_t depth,
struct list *adjacencies,
struct isis_area *area, int level)
{
struct route_node *route_node;
struct isis_route_info *rinfo_new, *rinfo_old, *route_info = NULL;
char buff[PREFIX2STR_BUFFER];
- u_char family;
+ uint8_t family;
family = prefix->family;
/* for debugs */
#define ISIS_ROUTE_FLAG_ACTIVE 0x01 /* active route for the prefix */
#define ISIS_ROUTE_FLAG_ZEBRA_SYNCED 0x02 /* set when route synced to zebra */
#define ISIS_ROUTE_FLAG_ZEBRA_RESYNC 0x04 /* set when route needs to sync */
- u_char flag;
- u_int32_t cost;
- u_int32_t depth;
+ uint8_t flag;
+ uint32_t cost;
+ uint32_t depth;
struct list *nexthops;
struct list *nexthops6;
};
-struct isis_route_info *isis_route_create(struct prefix *prefix, u_int32_t cost,
- u_int32_t depth,
+struct isis_route_info *isis_route_create(struct prefix *prefix, uint32_t cost,
+ uint32_t depth,
struct list *adjacencies,
struct isis_area *area, int level);
enum vertextype type;
union {
- u_char id[ISIS_SYS_ID_LEN + 1];
+ uint8_t id[ISIS_SYS_ID_LEN + 1];
struct prefix prefix;
} N;
- u_int32_t d_N; /* d(N) Distance from this IS */
- u_int16_t depth; /* The depth in the imaginary tree */
+ uint32_t d_N; /* d(N) Distance from this IS */
+ uint16_t depth; /* The depth in the imaginary tree */
struct list *Adj_N; /* {Adj(N)} next hop or neighbor list */
struct list *parents; /* list of parents for ECMP */
uint64_t insert_counter;
vertex->type = vtype;
if (VTYPE_IS(vtype) || VTYPE_ES(vtype)) {
- memcpy(vertex->N.id, (u_char *)id, ISIS_SYS_ID_LEN + 1);
+ memcpy(vertex->N.id, (uint8_t *)id, ISIS_SYS_ID_LEN + 1);
} else if (VTYPE_IP(vtype)) {
memcpy(&vertex->N.prefix, (struct prefix *)id,
sizeof(struct prefix));
* associated with the given system ID.
*/
static struct isis_lsp *isis_root_system_lsp(struct isis_area *area, int level,
- u_char *sysid)
+ uint8_t *sysid)
{
struct isis_lsp *lsp;
- u_char lspid[ISIS_SYS_ID_LEN + 2];
+ uint8_t lspid[ISIS_SYS_ID_LEN + 2];
memcpy(lspid, sysid, ISIS_SYS_ID_LEN);
LSP_PSEUDO_ID(lspid) = 0;
* Add this IS to the root of SPT
*/
static struct isis_vertex *isis_spf_add_root(struct isis_spftree *spftree,
- u_char *sysid)
+ uint8_t *sysid)
{
struct isis_vertex *vertex;
struct isis_lsp *lsp;
#ifdef EXTREME_DEBUG
char buff[PREFIX2STR_BUFFER];
#endif /* EXTREME_DEBUG */
- u_char id[ISIS_SYS_ID_LEN + 1];
+ uint8_t id[ISIS_SYS_ID_LEN + 1];
memcpy(id, sysid, ISIS_SYS_ID_LEN);
LSP_PSEUDO_ID(id) = 0;
*/
static int isis_spf_process_lsp(struct isis_spftree *spftree,
struct isis_lsp *lsp, uint32_t cost,
- uint16_t depth, u_char *root_sysid,
+ uint16_t depth, uint8_t *root_sysid,
struct isis_vertex *parent)
{
bool pseudo_lsp = LSP_PSEUDO_ID(lsp->hdr.lsp_id);
struct listnode *fragnode = NULL;
uint32_t dist;
enum vertextype vtype;
- static const u_char null_sysid[ISIS_SYS_ID_LEN];
+ static const uint8_t null_sysid[ISIS_SYS_ID_LEN];
struct isis_mt_router_info *mt_router_info = NULL;
if (!lsp->tlvs)
}
static int isis_spf_preload_tent(struct isis_spftree *spftree,
- u_char *root_sysid, struct isis_vertex *parent)
+ uint8_t *root_sysid,
+ struct isis_vertex *parent)
{
struct isis_circuit *circuit;
struct listnode *cnode, *anode, *ipnode;
struct prefix_ipv4 *ipv4;
struct prefix prefix;
int retval = ISIS_OK;
- u_char lsp_id[ISIS_SYS_ID_LEN + 2];
- static u_char null_lsp_id[ISIS_SYS_ID_LEN + 2];
+ uint8_t lsp_id[ISIS_SYS_ID_LEN + 2];
+ static uint8_t null_lsp_id[ISIS_SYS_ID_LEN + 2];
struct prefix_ipv6 *ipv6;
struct isis_circuit_mt_setting *circuit_mt;
}
static int isis_run_spf(struct isis_area *area, int level, int family,
- u_char *sysid, struct timeval *nowtv)
+ uint8_t *sysid, struct timeval *nowtv)
{
int retval = ISIS_OK;
struct isis_vertex *vertex;
struct isis_vertex *root_vertex;
struct isis_spftree *spftree = NULL;
- u_char lsp_id[ISIS_SYS_ID_LEN + 2];
+ uint8_t lsp_id[ISIS_SYS_ID_LEN + 2];
struct isis_lsp *lsp;
struct route_table *table = NULL;
struct timeval time_now;
}
static void isis_print_paths(struct vty *vty, struct isis_vertex_queue *queue,
- u_char *root_sysid)
+ uint8_t *root_sysid)
{
struct listnode *node;
struct isis_vertex *vertex;
vty_out(vty, "\n");
vty_out(vty, " last run duration : %u usec\n",
- (u_int32_t)spftree->last_run_duration);
+ (uint32_t)spftree->last_run_duration);
vty_out(vty, " run count : %u\n", spftree->runcount);
}
/* Following are various functions to set MPLS TE parameters */
static void set_circuitparams_admin_grp(struct mpls_te_circuit *mtc,
- u_int32_t admingrp)
+ uint32_t admingrp)
{
SUBTLV_TYPE(mtc->admin_grp) = TE_SUBTLV_ADMIN_GRP;
SUBTLV_LEN(mtc->admin_grp) = SUBTLV_DEF_SIZE;
}
static void __attribute__((unused))
-set_circuitparams_llri(struct mpls_te_circuit *mtc, u_int32_t local,
- u_int32_t remote)
+set_circuitparams_llri(struct mpls_te_circuit *mtc, uint32_t local,
+ uint32_t remote)
{
SUBTLV_TYPE(mtc->llri) = TE_SUBTLV_LLRI;
SUBTLV_LEN(mtc->llri) = TE_SUBTLV_LLRI_SIZE;
}
static void set_circuitparams_te_metric(struct mpls_te_circuit *mtc,
- u_int32_t te_metric)
+ uint32_t te_metric)
{
SUBTLV_TYPE(mtc->te_metric) = TE_SUBTLV_TE_METRIC;
SUBTLV_LEN(mtc->te_metric) = TE_SUBTLV_TE_METRIC_SIZE;
}
static void set_circuitparams_inter_as(struct mpls_te_circuit *mtc,
- struct in_addr addr, u_int32_t as)
+ struct in_addr addr, uint32_t as)
{
/* Set the Remote ASBR IP address and then the associated AS number */
}
static void set_circuitparams_av_delay(struct mpls_te_circuit *mtc,
- u_int32_t delay, u_char anormal)
+ uint32_t delay, uint8_t anormal)
{
- u_int32_t tmp;
+ uint32_t tmp;
/* Note that TLV-length field is the size of array. */
SUBTLV_TYPE(mtc->av_delay) = TE_SUBTLV_AV_DELAY;
SUBTLV_LEN(mtc->av_delay) = SUBTLV_DEF_SIZE;
}
static void set_circuitparams_mm_delay(struct mpls_te_circuit *mtc,
- u_int32_t low, u_int32_t high,
- u_char anormal)
+ uint32_t low, uint32_t high,
+ uint8_t anormal)
{
- u_int32_t tmp;
+ uint32_t tmp;
/* Note that TLV-length field is the size of array. */
SUBTLV_TYPE(mtc->mm_delay) = TE_SUBTLV_MM_DELAY;
SUBTLV_LEN(mtc->mm_delay) = TE_SUBTLV_MM_DELAY_SIZE;
}
static void set_circuitparams_delay_var(struct mpls_te_circuit *mtc,
- u_int32_t jitter)
+ uint32_t jitter)
{
/* Note that TLV-length field is the size of array. */
SUBTLV_TYPE(mtc->delay_var) = TE_SUBTLV_DELAY_VAR;
}
static void set_circuitparams_pkt_loss(struct mpls_te_circuit *mtc,
- u_int32_t loss, u_char anormal)
+ uint32_t loss, uint8_t anormal)
{
- u_int32_t tmp;
+ uint32_t tmp;
/* Note that TLV-length field is the size of array. */
SUBTLV_TYPE(mtc->pkt_loss) = TE_SUBTLV_PKT_LOSS;
SUBTLV_LEN(mtc->pkt_loss) = SUBTLV_DEF_SIZE;
* Followings are vty session control functions.
*------------------------------------------------------------------------*/
-static u_char print_subtlv_admin_grp(struct sbuf *buf, int indent,
- struct te_subtlv_admin_grp *tlv)
+static uint8_t print_subtlv_admin_grp(struct sbuf *buf, int indent,
+ struct te_subtlv_admin_grp *tlv)
{
sbuf_push(buf, indent, "Administrative Group: 0x%" PRIx32 "\n",
ntohl(tlv->value));
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_llri(struct sbuf *buf, int indent,
- struct te_subtlv_llri *tlv)
+static uint8_t print_subtlv_llri(struct sbuf *buf, int indent,
+ struct te_subtlv_llri *tlv)
{
sbuf_push(buf, indent, "Link Local ID: %" PRIu32 "\n",
ntohl(tlv->local));
return (SUBTLV_HDR_SIZE + TE_SUBTLV_LLRI_SIZE);
}
-static u_char print_subtlv_local_ipaddr(struct sbuf *buf, int indent,
- struct te_subtlv_local_ipaddr *tlv)
+static uint8_t print_subtlv_local_ipaddr(struct sbuf *buf, int indent,
+ struct te_subtlv_local_ipaddr *tlv)
{
sbuf_push(buf, indent, "Local Interface IP Address(es): %s\n",
inet_ntoa(tlv->value));
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_rmt_ipaddr(struct sbuf *buf, int indent,
- struct te_subtlv_rmt_ipaddr *tlv)
+static uint8_t print_subtlv_rmt_ipaddr(struct sbuf *buf, int indent,
+ struct te_subtlv_rmt_ipaddr *tlv)
{
sbuf_push(buf, indent, "Remote Interface IP Address(es): %s\n",
inet_ntoa(tlv->value));
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_max_bw(struct sbuf *buf, int indent,
- struct te_subtlv_max_bw *tlv)
+static uint8_t print_subtlv_max_bw(struct sbuf *buf, int indent,
+ struct te_subtlv_max_bw *tlv)
{
float fval;
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_max_rsv_bw(struct sbuf *buf, int indent,
- struct te_subtlv_max_rsv_bw *tlv)
+static uint8_t print_subtlv_max_rsv_bw(struct sbuf *buf, int indent,
+ struct te_subtlv_max_rsv_bw *tlv)
{
float fval;
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_unrsv_bw(struct sbuf *buf, int indent,
- struct te_subtlv_unrsv_bw *tlv)
+static uint8_t print_subtlv_unrsv_bw(struct sbuf *buf, int indent,
+ struct te_subtlv_unrsv_bw *tlv)
{
float fval1, fval2;
int i;
return (SUBTLV_HDR_SIZE + TE_SUBTLV_UNRSV_SIZE);
}
-static u_char print_subtlv_te_metric(struct sbuf *buf, int indent,
- struct te_subtlv_te_metric *tlv)
+static uint8_t print_subtlv_te_metric(struct sbuf *buf, int indent,
+ struct te_subtlv_te_metric *tlv)
{
- u_int32_t te_metric;
+ uint32_t te_metric;
te_metric = tlv->value[2] | tlv->value[1] << 8 | tlv->value[0] << 16;
sbuf_push(buf, indent, "Traffic Engineering Metric: %u\n", te_metric);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_ras(struct sbuf *buf, int indent,
- struct te_subtlv_ras *tlv)
+static uint8_t print_subtlv_ras(struct sbuf *buf, int indent,
+ struct te_subtlv_ras *tlv)
{
sbuf_push(buf, indent, "Inter-AS TE Remote AS number: %" PRIu32 "\n",
ntohl(tlv->value));
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_rip(struct sbuf *buf, int indent,
- struct te_subtlv_rip *tlv)
+static uint8_t print_subtlv_rip(struct sbuf *buf, int indent,
+ struct te_subtlv_rip *tlv)
{
sbuf_push(buf, indent, "Inter-AS TE Remote ASBR IP address: %s\n",
inet_ntoa(tlv->value));
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_av_delay(struct sbuf *buf, int indent,
- struct te_subtlv_av_delay *tlv)
+static uint8_t print_subtlv_av_delay(struct sbuf *buf, int indent,
+ struct te_subtlv_av_delay *tlv)
{
- u_int32_t delay;
- u_int32_t A;
+ uint32_t delay;
+ uint32_t A;
- delay = (u_int32_t)ntohl(tlv->value) & TE_EXT_MASK;
- A = (u_int32_t)ntohl(tlv->value) & TE_EXT_ANORMAL;
+ delay = (uint32_t)ntohl(tlv->value) & TE_EXT_MASK;
+ A = (uint32_t)ntohl(tlv->value) & TE_EXT_ANORMAL;
sbuf_push(buf, indent,
"%s Average Link Delay: %" PRIu32 " (micro-sec)\n",
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_mm_delay(struct sbuf *buf, int indent,
- struct te_subtlv_mm_delay *tlv)
+static uint8_t print_subtlv_mm_delay(struct sbuf *buf, int indent,
+ struct te_subtlv_mm_delay *tlv)
{
- u_int32_t low, high;
- u_int32_t A;
+ uint32_t low, high;
+ uint32_t A;
- low = (u_int32_t)ntohl(tlv->low) & TE_EXT_MASK;
- A = (u_int32_t)ntohl(tlv->low) & TE_EXT_ANORMAL;
- high = (u_int32_t)ntohl(tlv->high) & TE_EXT_MASK;
+ low = (uint32_t)ntohl(tlv->low) & TE_EXT_MASK;
+ A = (uint32_t)ntohl(tlv->low) & TE_EXT_ANORMAL;
+ high = (uint32_t)ntohl(tlv->high) & TE_EXT_MASK;
sbuf_push(buf, indent, "%s Min/Max Link Delay: %" PRIu32 " / %" PRIu32 " (micro-sec)\n",
A ? "Anomalous" : "Normal", low, high);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_delay_var(struct sbuf *buf, int indent,
- struct te_subtlv_delay_var *tlv)
+static uint8_t print_subtlv_delay_var(struct sbuf *buf, int indent,
+ struct te_subtlv_delay_var *tlv)
{
- u_int32_t jitter;
+ uint32_t jitter;
- jitter = (u_int32_t)ntohl(tlv->value) & TE_EXT_MASK;
+ jitter = (uint32_t)ntohl(tlv->value) & TE_EXT_MASK;
sbuf_push(buf, indent, "Delay Variation: %" PRIu32 " (micro-sec)\n",
jitter);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_pkt_loss(struct sbuf *buf, int indent,
- struct te_subtlv_pkt_loss *tlv)
+static uint8_t print_subtlv_pkt_loss(struct sbuf *buf, int indent,
+ struct te_subtlv_pkt_loss *tlv)
{
- u_int32_t loss;
- u_int32_t A;
+ uint32_t loss;
+ uint32_t A;
float fval;
- loss = (u_int32_t)ntohl(tlv->value) & TE_EXT_MASK;
+ loss = (uint32_t)ntohl(tlv->value) & TE_EXT_MASK;
fval = (float)(loss * LOSS_PRECISION);
- A = (u_int32_t)ntohl(tlv->value) & TE_EXT_ANORMAL;
+ A = (uint32_t)ntohl(tlv->value) & TE_EXT_ANORMAL;
sbuf_push(buf, indent, "%s Link Packet Loss: %g (%%)\n",
A ? "Anomalous" : "Normal", fval);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_res_bw(struct sbuf *buf, int indent,
- struct te_subtlv_res_bw *tlv)
+static uint8_t print_subtlv_res_bw(struct sbuf *buf, int indent,
+ struct te_subtlv_res_bw *tlv)
{
float fval;
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_ava_bw(struct sbuf *buf, int indent,
- struct te_subtlv_ava_bw *tlv)
+static uint8_t print_subtlv_ava_bw(struct sbuf *buf, int indent,
+ struct te_subtlv_ava_bw *tlv)
{
float fval;
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_subtlv_use_bw(struct sbuf *buf, int indent,
- struct te_subtlv_use_bw *tlv)
+static uint8_t print_subtlv_use_bw(struct sbuf *buf, int indent,
+ struct te_subtlv_use_bw *tlv)
{
float fval;
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
-static u_char print_unknown_tlv(struct sbuf *buf, int indent,
- struct subtlv_header *tlvh)
+static uint8_t print_unknown_tlv(struct sbuf *buf, int indent,
+ struct subtlv_header *tlvh)
{
int i, rtn = 1;
- u_char *v = (u_char *)tlvh;
+ uint8_t *v = (uint8_t *)tlvh;
if (tlvh->length != 0) {
sbuf_push(buf, indent,
* used for Traffic Engineering.
*/
struct subtlv_header {
- u_char type; /* sub_TLV_XXX type (see above) */
- u_char length; /* Value portion only, in byte */
+ uint8_t type; /* sub_TLV_XXX type (see above) */
+ uint8_t length; /* Value portion only, in byte */
};
#define MAX_SUBTLV_SIZE 256
#define TE_SUBTLV_ADMIN_GRP 3
struct te_subtlv_admin_grp {
struct subtlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Admin. group membership. */
+ uint32_t value; /* Admin. group membership. */
} __attribute__((__packed__));
/* Link Local/Remote Identifiers - RFC 5307 */
#define TE_SUBTLV_LLRI_SIZE 8
struct te_subtlv_llri {
struct subtlv_header header; /* Value length is 8 octets. */
- u_int32_t local; /* Link Local Identifier */
- u_int32_t remote; /* Link Remote Identifier */
+ uint32_t local; /* Link Local Identifier */
+ uint32_t remote; /* Link Remote Identifier */
} __attribute__((__packed__));
/* Link Sub-TLV: Local Interface IP Address - RFC 5305 */
#define TE_SUBTLV_TE_METRIC_SIZE 3
struct te_subtlv_te_metric {
struct subtlv_header header; /* Value length is 4 octets. */
- u_char value[3]; /* Link metric for TE purpose. */
+ uint8_t value[3]; /* Link metric for TE purpose. */
} __attribute__((__packed__));
/* Remote AS Number sub-TLV - RFC5316 */
#define TE_SUBTLV_RAS 24
struct te_subtlv_ras {
struct subtlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Remote AS number */
+ uint32_t value; /* Remote AS number */
} __attribute__((__packed__));
/* IPv4 Remote ASBR ID Sub-TLV - RFC5316 */
#define TE_SUBTLV_AV_DELAY 33
struct te_subtlv_av_delay {
struct subtlv_header header; /* Value length is 4 bytes. */
- u_int32_t value; /* Average delay in micro-seconds only 24 bits => 0 ...
+ uint32_t value; /* Average delay in micro-seconds only 24 bits => 0 ...
16777215
with Anomalous Bit (A) as Upper most bit */
} __attribute__((__packed__));
#define TE_SUBTLV_MM_DELAY_SIZE 8
struct te_subtlv_mm_delay {
struct subtlv_header header; /* Value length is 8 bytes. */
- u_int32_t low; /* low delay in micro-seconds only 24 bits => 0 ...
+ uint32_t low; /* low delay in micro-seconds only 24 bits => 0 ...
16777215
with Anomalous Bit (A) as Upper most bit */
- u_int32_t high; /* high delay in micro-seconds only 24 bits => 0 ...
+ uint32_t high; /* high delay in micro-seconds only 24 bits => 0 ...
16777215 */
} __attribute__((__packed__));
#define TE_SUBTLV_DELAY_VAR 35
struct te_subtlv_delay_var {
struct subtlv_header header; /* Value length is 4 bytes. */
- u_int32_t value; /* interval in micro-seconds only 24 bits => 0 ...
+ uint32_t value; /* interval in micro-seconds only 24 bits => 0 ...
16777215 */
} __attribute__((__packed__));
#define TE_SUBTLV_PKT_LOSS 36
struct te_subtlv_pkt_loss {
struct subtlv_header header; /* Value length is 4 bytes. */
- u_int32_t
+ uint32_t
value; /* in percentage of total traffic only 24 bits (2^24 - 2)
with Anomalous Bit (A) as Upper most bit */
} __attribute__((__packed__));
status_t status;
/* L1, L1-L2, L2-Only */
- u_int8_t level;
+ uint8_t level;
/* RFC5316 */
interas_mode_t inter_as;
/* Type of MPLS-TE circuit: STD_TE(RFC5305), INTER_AS(RFC5316),
* INTER_AS_EMU(RFC5316 emulated) */
- u_int8_t type;
+ uint8_t type;
/* Total size of sub_tlvs */
- u_char length;
+ uint8_t length;
/* Store subTLV in network byte order. */
/* RFC5305 */
void isis_tlvs_add_lan_neighbors(struct isis_tlvs *tlvs, struct list *neighbors)
{
struct listnode *node;
- u_char *snpa;
+ uint8_t *snpa;
for (ALL_LIST_ELEMENTS_RO(neighbors, node, snpa)) {
struct isis_lan_neighbor *n =
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->hello_interval[0] = (u_int16_t)interval;
- circuit->hello_interval[1] = (u_int16_t)interval;
+ circuit->hello_interval[0] = (uint16_t)interval;
+ circuit->hello_interval[1] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->hello_interval[0] = (u_int16_t)interval;
+ circuit->hello_interval[0] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->hello_interval[1] = (u_int16_t)interval;
+ circuit->hello_interval[1] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->hello_multiplier[0] = (u_int16_t)mult;
- circuit->hello_multiplier[1] = (u_int16_t)mult;
+ circuit->hello_multiplier[0] = (uint16_t)mult;
+ circuit->hello_multiplier[1] = (uint16_t)mult;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->hello_multiplier[0] = (u_int16_t)mult;
+ circuit->hello_multiplier[0] = (uint16_t)mult;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->hello_multiplier[1] = (u_int16_t)mult;
+ circuit->hello_multiplier[1] = (uint16_t)mult;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->csnp_interval[0] = (u_int16_t)interval;
- circuit->csnp_interval[1] = (u_int16_t)interval;
+ circuit->csnp_interval[0] = (uint16_t)interval;
+ circuit->csnp_interval[1] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->csnp_interval[0] = (u_int16_t)interval;
+ circuit->csnp_interval[0] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->csnp_interval[1] = (u_int16_t)interval;
+ circuit->csnp_interval[1] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->psnp_interval[0] = (u_int16_t)interval;
- circuit->psnp_interval[1] = (u_int16_t)interval;
+ circuit->psnp_interval[0] = (uint16_t)interval;
+ circuit->psnp_interval[1] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->psnp_interval[0] = (u_int16_t)interval;
+ circuit->psnp_interval[0] = (uint16_t)interval;
return CMD_SUCCESS;
}
return CMD_WARNING_CONFIG_FAILED;
}
- circuit->psnp_interval[1] = (u_int16_t)interval;
+ circuit->psnp_interval[1] = (uint16_t)interval;
return CMD_SUCCESS;
}
{
int idx_number = 1;
VTY_DECLVAR_CONTEXT(isis_area, area);
- u_int16_t interval;
+ uint16_t interval;
interval = atoi(argv[idx_number]->arg);
area->min_spf_interval[0] = interval;
{
int idx_number = 2;
VTY_DECLVAR_CONTEXT(isis_area, area);
- u_int16_t interval;
+ uint16_t interval;
interval = atoi(argv[idx_number]->arg);
area->min_spf_interval[0] = interval;
{
int idx_number = 2;
VTY_DECLVAR_CONTEXT(isis_area, area);
- u_int16_t interval;
+ uint16_t interval;
interval = atoi(argv[idx_number]->arg);
area->min_spf_interval[1] = interval;
static int area_passwd_set(struct vty *vty, int level,
int (*type_set)(struct isis_area *area, int level,
- const char *passwd, u_char snp_auth),
- const char *passwd, u_char snp_auth)
+ const char *passwd,
+ uint8_t snp_auth),
+ const char *passwd, uint8_t snp_auth)
{
VTY_DECLVAR_CONTEXT(isis_area, area);
int idx_password = 0;
int idx_word = 2;
int idx_type = 5;
- u_char snp_auth = 0;
+ uint8_t snp_auth = 0;
int level = strmatch(argv[idx_password]->text, "domain-password")
? IS_LEVEL_2
: IS_LEVEL_1;
int idx_password = 0;
int idx_word = 2;
int idx_type = 5;
- u_char snp_auth = 0;
+ uint8_t snp_auth = 0;
int level = strmatch(argv[idx_password]->text, "domain-password")
? IS_LEVEL_2
: IS_LEVEL_1;
struct area_addr *addrp;
struct listnode *node;
- u_char buff[255];
+ uint8_t buff[255];
/* We check that we are not over the maximal number of addresses */
if (listcount(area->area_addrs) >= isis->max_area_addrs) {
VTY_DECLVAR_CONTEXT(isis_area, area);
struct area_addr addr, *addrp = NULL;
struct listnode *node;
- u_char buff[255];
+ uint8_t buff[255];
addr.addr_len = dotformat2buff(buff, net_title);
if (addr.addr_len < 8 || addr.addr_len > 20) {
struct list *adjdb;
struct isis_adjacency *adj;
struct isis_dynhn *dynhn;
- u_char sysid[ISIS_SYS_ID_LEN];
+ uint8_t sysid[ISIS_SYS_ID_LEN];
int i;
if (!isis) {
struct list *adjdb;
struct isis_adjacency *adj;
struct isis_dynhn *dynhn;
- u_char sysid[ISIS_SYS_ID_LEN];
+ uint8_t sysid[ISIS_SYS_ID_LEN];
int i;
if (!isis) {
struct isis_lsp *lsp;
struct isis_dynhn *dynhn;
const char *pos = argv;
- u_char lspid[ISIS_SYS_ID_LEN + 2];
+ uint8_t lspid[ISIS_SYS_ID_LEN + 2];
char sysid[255];
- u_char number[3];
+ uint8_t number[3];
int level, lsp_count;
if (isis->area_list->count == 0)
if (strncmp(pos, "-", 1) == 0) {
memcpy(number, ++pos, 2);
lspid[ISIS_SYS_ID_LEN + 1] =
- (u_char)strtol((char *)number, NULL, 16);
+ (uint8_t)strtol((char *)number, NULL, 16);
pos -= 4;
if (strncmp(pos, ".", 1) != 0)
return CMD_WARNING;
if (strncmp(pos, ".", 1) == 0) {
memcpy(number, ++pos, 2);
lspid[ISIS_SYS_ID_LEN] =
- (u_char)strtol((char *)number, NULL, 16);
+ (uint8_t)strtol((char *)number, NULL, 16);
sysid[pos - argv - 1] = '\0';
}
}
}
static int isis_area_passwd_set(struct isis_area *area, int level,
- u_char passwd_type, const char *passwd,
- u_char snp_auth)
+ uint8_t passwd_type, const char *passwd,
+ uint8_t snp_auth)
{
struct isis_passwd *dest;
struct isis_passwd modified;
}
int isis_area_passwd_cleartext_set(struct isis_area *area, int level,
- const char *passwd, u_char snp_auth)
+ const char *passwd, uint8_t snp_auth)
{
return isis_area_passwd_set(area, level, ISIS_PASSWD_TYPE_CLEARTXT,
passwd, snp_auth);
}
int isis_area_passwd_hmac_md5_set(struct isis_area *area, int level,
- const char *passwd, u_char snp_auth)
+ const char *passwd, uint8_t snp_auth)
{
return isis_area_passwd_set(area, level, ISIS_PASSWD_TYPE_HMAC_MD5,
passwd, snp_auth);
/* #define EXTREME_DICT_DEBUG */
struct isis {
- u_long process_id;
+ unsigned long process_id;
int sysid_set;
- u_char sysid[ISIS_SYS_ID_LEN]; /* SystemID for this IS */
- u_int32_t router_id; /* Router ID from zebra */
+ uint8_t sysid[ISIS_SYS_ID_LEN]; /* SystemID for this IS */
+ uint32_t router_id; /* Router ID from zebra */
struct list *area_list; /* list of IS-IS areas */
struct list *init_circ_list;
struct list *nexthops; /* IPv4 next hops from this IS */
struct list *nexthops6; /* IPv6 next hops from this IS */
- u_char max_area_addrs; /* maximumAreaAdresses */
+ uint8_t max_area_addrs; /* maximumAreaAdresses */
struct area_addr *man_area_addrs; /* manualAreaAddresses */
- u_int32_t debugs; /* bitmap for debug */
+ uint32_t debugs; /* bitmap for debug */
time_t uptime; /* when did we start */
struct thread *t_dync_clean; /* dynamic hostname cache cleanup thread */
uint32_t circuit_ids_used[8]; /* 256 bits to track circuit ids 1 through 255 */
char *area_tag;
/* area addresses for this area */
struct list *area_addrs;
- u_int16_t max_lsp_lifetime[ISIS_LEVELS];
+ uint16_t max_lsp_lifetime[ISIS_LEVELS];
char is_type; /* level-1 level-1-2 or level-2-only */
/* are we overloaded? */
char overload_bit;
/* L1/L2 router identifier for inter-area traffic */
char attached_bit;
- u_int16_t lsp_refresh[ISIS_LEVELS];
+ uint16_t lsp_refresh[ISIS_LEVELS];
/* minimum time allowed before lsp retransmission */
- u_int16_t lsp_gen_interval[ISIS_LEVELS];
+ uint16_t lsp_gen_interval[ISIS_LEVELS];
/* min interval between between consequtive SPFs */
- u_int16_t min_spf_interval[ISIS_LEVELS];
+ uint16_t min_spf_interval[ISIS_LEVELS];
/* the percentage of LSP mtu size used, before generating a new frag */
int lsp_frag_threshold;
int ip_circuits;
/* logging adjacency changes? */
- u_char log_adj_changes;
+ uint8_t log_adj_changes;
/* multi topology settings */
struct list *mt_settings;
int ipv6_circuits;
/* Counters */
- u_int32_t circuit_state_changes;
+ uint32_t circuit_state_changes;
struct isis_redist redist_settings[REDIST_PROTOCOL_COUNT]
[ZEBRA_ROUTE_MAX + 1][ISIS_LEVELS];
struct route_table *ext_reach[REDIST_PROTOCOL_COUNT][ISIS_LEVELS];
/* IS_LEVEL_1 sets area_passwd, IS_LEVEL_2 domain_passwd */
int isis_area_passwd_unset(struct isis_area *area, int level);
int isis_area_passwd_cleartext_set(struct isis_area *area, int level,
- const char *passwd, u_char snp_auth);
+ const char *passwd, uint8_t snp_auth);
int isis_area_passwd_hmac_md5_set(struct isis_area *area, int level,
- const char *passwd, u_char snp_auth);
+ const char *passwd, uint8_t snp_auth);
void isis_vty_init(void);
/* Master of threads. */
* Based on Annex C.4 of ISO/IEC 8473
*/
-int iso_csum_verify(u_char *buffer, int len, uint16_t csum, int offset)
+int iso_csum_verify(uint8_t *buffer, int len, uint16_t csum, int offset)
{
- u_int16_t checksum;
- u_int32_t c0;
- u_int32_t c1;
+ uint16_t checksum;
+ uint32_t c0;
+ uint32_t c1;
c0 = csum & 0xff00;
c1 = csum & 0x00ff;
#ifndef _ZEBRA_ISO_CSUM_H
#define _ZEBRA_ISO_CSUM_H
-int iso_csum_verify(u_char *buffer, int len, uint16_t csum, int offset);
+int iso_csum_verify(uint8_t *buffer, int len, uint16_t csum, int offset);
#endif /* _ZEBRA_ISO_CSUM_H */
static int lde_address_add(struct lde_nbr *, struct lde_addr *);
static int lde_address_del(struct lde_nbr *, struct lde_addr *);
static void lde_address_list_free(struct lde_nbr *);
-static void zclient_sync_init(u_short instance);
+static void zclient_sync_init(unsigned short instance);
static void lde_label_list_init(void);
static int lde_get_label_chunk(void);
static void on_get_label_chunk_response(uint32_t start, uint32_t end);
}
}
-static void
-zclient_sync_init(u_short instance)
+static void zclient_sync_init(unsigned short instance)
{
/* Initialize special zclient for synchronous message exchanges. */
zclient_sync = zclient_new_notify(master, &zclient_options_default);
stream_put_in_addr(s, &kr->nexthop.v4);
break;
case AF_INET6:
- stream_write(s, (u_char *)&kr->prefix.v6, 16);
+ stream_write(s, (uint8_t *)&kr->prefix.v6, 16);
stream_putc(s, kr->prefixlen);
- stream_write(s, (u_char *)&kr->nexthop.v6, 16);
+ stream_write(s, (uint8_t *)&kr->nexthop.v6, 16);
break;
default:
fatalx("kr_change: unknown af");
char group[256];
char ctl_sock_path[MAXPATHLEN];
char zclient_serv_path[MAXPATHLEN];
- u_short instance;
+ unsigned short instance;
};
union ldpd_addr {
size_t enamelen, const oid *name, size_t namelen,
const oid *iname, size_t inamelen,
const struct trap_object *trapobj, size_t trapobjlen,
- u_char sptrap)
+ uint8_t sptrap)
{
oid objid_snmptrap[] = {1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0};
size_t objid_snmptrap_len = sizeof objid_snmptrap / sizeof(oid);
notification_oid_len = enamelen + 1;
snmp_varlist_add_variable(¬ification_vars, objid_snmptrap,
objid_snmptrap_len, ASN_OBJECT_ID,
- (u_char *)notification_oid,
+ (uint8_t *)notification_oid,
notification_oid_len * sizeof(oid));
/* Provided bindings */
unsigned int j;
oid oid[MAX_OID_LEN];
size_t oid_len, onamelen;
- u_char *val;
+ uint8_t *val;
size_t val_len;
WriteMethod *wm = NULL;
struct variable cvp;
* bfd_validate_param - Validate the BFD paramter information.
*/
int bfd_validate_param(struct vty *vty, const char *dm_str, const char *rx_str,
- const char *tx_str, u_int8_t *dm_val, u_int32_t *rx_val,
- u_int32_t *tx_val)
+ const char *tx_str, uint8_t *dm_val, uint32_t *rx_val,
+ uint32_t *tx_val)
{
*dm_val = strtoul(dm_str, NULL, 10);
*rx_val = strtoul(rx_str, NULL, 10);
/*
* bfd_set_param - Set the configured BFD paramter values
*/
-void bfd_set_param(struct bfd_info **bfd_info, u_int32_t min_rx,
- u_int32_t min_tx, u_int8_t detect_mult, int defaults,
- int *command)
+void bfd_set_param(struct bfd_info **bfd_info, uint32_t min_rx, uint32_t min_tx,
+ uint8_t detect_mult, int defaults, int *command)
{
if (!*bfd_info) {
*bfd_info = bfd_info_create();
* bfd_show_param - Show the BFD parameter information.
*/
void bfd_show_param(struct vty *vty, struct bfd_info *bfd_info, int bfd_tag,
- int extra_space, u_char use_json, json_object *json_obj)
+ int extra_space, uint8_t use_json, json_object *json_obj)
{
json_object *json_bfd = NULL;
* bfd_show_status - Show the BFD status information.
*/
static void bfd_show_status(struct vty *vty, struct bfd_info *bfd_info,
- int bfd_tag, int extra_space, u_char use_json,
+ int bfd_tag, int extra_space, uint8_t use_json,
json_object *json_bfd)
{
char time_buf[32];
* bfd_show_info - Show the BFD information.
*/
void bfd_show_info(struct vty *vty, struct bfd_info *bfd_info, int multihop,
- int extra_space, u_char use_json, json_object *json_obj)
+ int extra_space, uint8_t use_json, json_object *json_obj)
{
json_object *json_bfd = NULL;
#define BFD_GBL_FLAG_IN_SHUTDOWN (1 << 0) /* The daemon in shutdown */
struct bfd_gbl {
- u_int16_t flags;
+ uint16_t flags;
};
#define BFD_FLAG_PARAM_CFG (1 << 0) /* parameters have been configured */
};
struct bfd_info {
- u_int16_t flags;
- u_int8_t detect_mult;
- u_int32_t desired_min_tx;
- u_int32_t required_min_rx;
+ uint16_t flags;
+ uint8_t detect_mult;
+ uint32_t desired_min_tx;
+ uint32_t required_min_rx;
time_t last_update;
- u_int8_t status;
+ uint8_t status;
enum bfd_sess_type type;
};
extern int bfd_validate_param(struct vty *vty, const char *dm_str,
const char *rx_str, const char *tx_str,
- u_int8_t *dm_val, u_int32_t *rx_val,
- u_int32_t *tx_val);
+ uint8_t *dm_val, uint32_t *rx_val,
+ uint32_t *tx_val);
-extern void bfd_set_param(struct bfd_info **bfd_info, u_int32_t min_rx,
- u_int32_t min_tx, u_int8_t detect_mult, int defaults,
+extern void bfd_set_param(struct bfd_info **bfd_info, uint32_t min_rx,
+ uint32_t min_tx, uint8_t detect_mult, int defaults,
int *command);
extern void bfd_peer_sendmsg(struct zclient *zclient, struct bfd_info *bfd_info,
int family, void *dst_ip, void *src_ip,
const char *bfd_get_status_str(int status);
extern void bfd_show_param(struct vty *vty, struct bfd_info *bfd_info,
- int bfd_tag, int extra_space, u_char use_json,
+ int bfd_tag, int extra_space, uint8_t use_json,
json_object *json_obj);
extern void bfd_show_info(struct vty *vty, struct bfd_info *bfd_info,
- int multihop, int extra_space, u_char use_json,
+ int multihop, int extra_space, uint8_t use_json,
json_object *json_obj);
extern void bfd_client_sendmsg(struct zclient *zclient, int command);
}
/* Insert character into the buffer. */
-void buffer_putc(struct buffer *b, u_char c)
+void buffer_putc(struct buffer *b, uint8_t c)
{
buffer_put(b, &c, 1);
}
"%s: growing iov array to %d; "
"width %d, height %d, size %lu",
__func__, iov_alloc, width, height,
- (u_long)b->size);
+ (unsigned long)b->size);
iov = XREALLOC(MTYPE_TMP, iov,
iov_alloc * sizeof(*iov));
} else {
zlog_err(
"%s: corruption detected: buffer queue empty, "
"but written is %lu",
- __func__, (u_long)written);
+ __func__, (unsigned long)written);
break;
}
if (written < d->cp - d->sp) {
/* Add the given data to the end of the buffer. */
extern void buffer_put(struct buffer *, const void *, size_t);
/* Add a single character to the end of the buffer. */
-extern void buffer_putc(struct buffer *, u_char);
+extern void buffer_putc(struct buffer *, uint8_t);
/* Add a NUL-terminated string to the end of the buffer. */
extern void buffer_putstr(struct buffer *, const char *);
/* Add given data, inline-expanding \n to \r\n */
int /* return checksum in low-order 16 bits */
in_cksum(void *parg, int nbytes)
{
- u_short *ptr = parg;
+ unsigned short *ptr = parg;
register long sum; /* assumes long == 32 bits */
- u_short oddbyte;
- register u_short answer; /* assumes u_short == 16 bits */
+ unsigned short oddbyte;
+ register unsigned short answer; /* assumes unsigned short == 16 bits */
/*
* Our algorithm is simple, using a 32-bit accumulator (sum),
/* mop up an odd byte, if necessary */
if (nbytes == 1) {
oddbyte = 0; /* make sure top half is zero */
- *((u_char *)&oddbyte) = *(u_char *)ptr; /* one byte only */
+ *((uint8_t *)&oddbyte) = *(uint8_t *)ptr; /* one byte only */
sum += oddbyte;
}
index required in the specification ISO 8473, Annex C.1 */
/* calling with offset == FLETCHER_CHECKSUM_VALIDATE will validate the checksum
without modifying the buffer; a valid checksum returns 0 */
-u_int16_t fletcher_checksum(u_char *buffer, const size_t len,
- const uint16_t offset)
+uint16_t fletcher_checksum(uint8_t *buffer, const size_t len,
+ const uint16_t offset)
{
- u_int8_t *p;
+ uint8_t *p;
int x, y, c0, c1;
- u_int16_t checksum = 0;
- u_int16_t *csum;
+ uint16_t checksum = 0;
+ uint16_t *csum;
size_t partial_len, i, left = len;
if (offset != FLETCHER_CHECKSUM_VALIDATE)
{
assert(offset
< (len - 1)); /* account for two bytes of checksum */
- csum = (u_int16_t *)(buffer + offset);
+ csum = (uint16_t *)(buffer + offset);
*(csum) = 0;
}
extern int in_cksum(void *, int);
#define FLETCHER_CHECKSUM_VALIDATE 0xffff
-extern u_int16_t fletcher_checksum(u_char *, const size_t len,
- const uint16_t offset);
+extern uint16_t fletcher_checksum(uint8_t *, const size_t len,
+ const uint16_t offset);
DEFINE_MTYPE(LIB, CMD_ARG, "Command Argument")
DEFINE_MTYPE_STATIC(LIB, CMD_VAR, "Command Argument Name")
-struct cmd_token *cmd_token_new(enum cmd_token_type type, u_char attr,
+struct cmd_token *cmd_token_new(enum cmd_token_type type, uint8_t attr,
const char *text, const char *desc)
{
struct cmd_token *token =
}
static void cmd_fork_bump_attr(struct graph_node *gn, struct graph_node *join,
- u_char attr)
+ uint8_t attr)
{
size_t i;
struct cmd_token *tok = gn->data;
{
struct filter_cisco *filter;
struct in_addr mask;
- u_int32_t check_addr;
- u_int32_t check_mask;
+ uint32_t check_addr;
+ uint32_t check_mask;
filter = &mfilter->u.cfilter;
check_addr = p->u.prefix4.s_addr & ~filter->addr_mask.s_addr;
/* Link Parameters for Traffic Engineering */
struct if_link_params {
- u_int32_t lp_status; /* Status of Link Parameters: */
- u_int32_t te_metric; /* Traffic Engineering metric */
+ uint32_t lp_status; /* Status of Link Parameters: */
+ uint32_t te_metric; /* Traffic Engineering metric */
float default_bw;
float max_bw; /* Maximum Bandwidth */
float max_rsv_bw; /* Maximum Reservable Bandwidth */
float unrsv_bw[MAX_CLASS_TYPE]; /* Unreserved Bandwidth per Class Type
(8) */
- u_int32_t admin_grp; /* Administrative group */
- u_int32_t rmt_as; /* Remote AS number */
+ uint32_t admin_grp; /* Administrative group */
+ uint32_t rmt_as; /* Remote AS number */
struct in_addr rmt_ip; /* Remote IP address */
- u_int32_t av_delay; /* Link Average Delay */
- u_int32_t min_delay; /* Link Min Delay */
- u_int32_t max_delay; /* Link Max Delay */
- u_int32_t delay_var; /* Link Delay Variation */
+ uint32_t av_delay; /* Link Average Delay */
+ uint32_t min_delay; /* Link Min Delay */
+ uint32_t max_delay; /* Link Max Delay */
+ uint32_t delay_var; /* Link Delay Variation */
float pkt_loss; /* Link Packet Loss */
float res_bw; /* Residual Bandwidth */
float ava_bw; /* Available Bandwidth */
#define IFINDEX_INTERNAL 0
/* Zebra internal interface status */
- u_char status;
+ uint8_t status;
#define ZEBRA_INTERFACE_ACTIVE (1 << 0)
#define ZEBRA_INTERFACE_SUB (1 << 1)
#define ZEBRA_INTERFACE_LINKDETECTION (1 << 2)
/* Link-layer information and hardware address */
enum zebra_link_type ll_type;
- u_char hw_addr[INTERFACE_HWADDR_MAX];
+ uint8_t hw_addr[INTERFACE_HWADDR_MAX];
int hw_addr_len;
/* interface bandwidth, kbits */
struct interface *ifp;
/* Flags for configuration. */
- u_char conf;
+ uint8_t conf;
#define ZEBRA_IFC_REAL (1 << 0)
#define ZEBRA_IFC_CONFIGURED (1 << 1)
#define ZEBRA_IFC_QUEUED (1 << 2)
*/
/* Flags for connected address. */
- u_char flags;
+ uint8_t flags;
#define ZEBRA_IFA_SECONDARY (1 << 0)
#define ZEBRA_IFA_PEER (1 << 1)
#define ZEBRA_IFA_UNNUMBERED (1 << 2)
int ibuf_realloc(struct ibuf *buf, size_t len)
{
- u_char *b;
+ uint8_t *b;
/* on static buffers max is eq size and so the following fails */
if (buf->wpos + len > buf->max) {
return (datalen + IMSG_HEADER_SIZE);
}
-int imsg_compose(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
- pid_t pid, int fd, const void *data, u_int16_t datalen)
+int imsg_compose(struct imsgbuf *ibuf, uint32_t type, uint32_t peerid,
+ pid_t pid, int fd, const void *data, uint16_t datalen)
{
struct ibuf *wbuf;
return (1);
}
-int imsg_composev(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
+int imsg_composev(struct imsgbuf *ibuf, uint32_t type, uint32_t peerid,
pid_t pid, int fd, const struct iovec *iov, int iovcnt)
{
struct ibuf *wbuf;
}
/* ARGSUSED */
-struct ibuf *imsg_create(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
- pid_t pid, u_int16_t datalen)
+struct ibuf *imsg_create(struct imsgbuf *ibuf, uint32_t type, uint32_t peerid,
+ pid_t pid, uint16_t datalen)
{
struct ibuf *wbuf;
struct imsg_hdr hdr;
return (wbuf);
}
-int imsg_add(struct ibuf *msg, const void *data, u_int16_t datalen)
+int imsg_add(struct ibuf *msg, const void *data, uint16_t datalen)
{
if (datalen)
if (ibuf_add(msg, data, datalen) == -1) {
if (msg->fd != -1)
hdr->flags |= IMSGF_HASFD;
- hdr->len = (u_int16_t)msg->wpos;
+ hdr->len = (uint16_t)msg->wpos;
ibuf_close(&ibuf->w, msg);
}
struct ibuf {
TAILQ_ENTRY(ibuf) entry;
- u_char *buf;
+ uint8_t *buf;
size_t size;
size_t max;
size_t wpos;
struct msgbuf {
TAILQ_HEAD(, ibuf) bufs;
- u_int32_t queued;
+ uint32_t queued;
int fd;
};
struct ibuf_read {
- u_char buf[IBUF_READ_SIZE];
- u_char *rptr;
+ uint8_t buf[IBUF_READ_SIZE];
+ uint8_t *rptr;
size_t wpos;
};
#define IMSGF_HASFD 1
struct imsg_hdr {
- u_int32_t type;
- u_int16_t len;
- u_int16_t flags;
- u_int32_t peerid;
- u_int32_t pid;
+ uint32_t type;
+ uint16_t len;
+ uint16_t flags;
+ uint32_t peerid;
+ uint32_t pid;
};
struct imsg {
void imsg_init(struct imsgbuf *, int);
ssize_t imsg_read(struct imsgbuf *);
ssize_t imsg_get(struct imsgbuf *, struct imsg *);
-int imsg_compose(struct imsgbuf *, u_int32_t, u_int32_t, pid_t, int,
- const void *, u_int16_t);
-int imsg_composev(struct imsgbuf *, u_int32_t, u_int32_t, pid_t, int,
+int imsg_compose(struct imsgbuf *, uint32_t, uint32_t, pid_t, int, const void *,
+ uint16_t);
+int imsg_composev(struct imsgbuf *, uint32_t, uint32_t, pid_t, int,
const struct iovec *, int);
-struct ibuf *imsg_create(struct imsgbuf *, u_int32_t, u_int32_t, pid_t,
- u_int16_t);
-int imsg_add(struct ibuf *, const void *, u_int16_t);
+struct ibuf *imsg_create(struct imsgbuf *, uint32_t, uint32_t, pid_t, uint16_t);
+int imsg_add(struct ibuf *, const void *, uint16_t);
void imsg_close(struct imsgbuf *, struct ibuf *);
void imsg_free(struct imsg *);
int imsg_flush(struct imsgbuf *);
struct ipaddr {
enum ipaddr_type_t ipa_type;
union {
- u_char addr;
+ uint8_t addr;
struct in_addr _v4_addr;
struct in6_addr _v6_addr;
} ip;
static inline void ipv4_to_ipv4_mapped_ipv6(struct in6_addr *in6,
struct in_addr in)
{
- u_int32_t addr_type = htonl(0xFFFF);
+ uint32_t addr_type = htonl(0xFFFF);
memset(in6, 0, sizeof(struct in6_addr));
memcpy((char *)in6 + 8, &addr_type, sizeof(addr_type));
* of bytes. No alignment or length assumptions are made about
* the input key.
*/
-u_int32_t jhash(const void *key, u_int32_t length, u_int32_t initval)
+uint32_t jhash(const void *key, uint32_t length, uint32_t initval)
{
- u_int32_t a, b, c, len;
- const u_int8_t *k = key;
+ uint32_t a, b, c, len;
+ const uint8_t *k = key;
len = length;
a = b = JHASH_GOLDEN_RATIO;
c = initval;
while (len >= 12) {
- a += (k[0] + ((u_int32_t)k[1] << 8) + ((u_int32_t)k[2] << 16)
- + ((u_int32_t)k[3] << 24));
- b += (k[4] + ((u_int32_t)k[5] << 8) + ((u_int32_t)k[6] << 16)
- + ((u_int32_t)k[7] << 24));
- c += (k[8] + ((u_int32_t)k[9] << 8) + ((u_int32_t)k[10] << 16)
- + ((u_int32_t)k[11] << 24));
+ a += (k[0] + ((uint32_t)k[1] << 8) + ((uint32_t)k[2] << 16)
+ + ((uint32_t)k[3] << 24));
+ b += (k[4] + ((uint32_t)k[5] << 8) + ((uint32_t)k[6] << 16)
+ + ((uint32_t)k[7] << 24));
+ c += (k[8] + ((uint32_t)k[9] << 8) + ((uint32_t)k[10] << 16)
+ + ((uint32_t)k[11] << 24));
__jhash_mix(a, b, c);
c += length;
switch (len) {
case 11:
- c += ((u_int32_t)k[10] << 24);
+ c += ((uint32_t)k[10] << 24);
/* fallthru */
case 10:
- c += ((u_int32_t)k[9] << 16);
+ c += ((uint32_t)k[9] << 16);
/* fallthru */
case 9:
- c += ((u_int32_t)k[8] << 8);
+ c += ((uint32_t)k[8] << 8);
/* fallthru */
case 8:
- b += ((u_int32_t)k[7] << 24);
+ b += ((uint32_t)k[7] << 24);
/* fallthru */
case 7:
- b += ((u_int32_t)k[6] << 16);
+ b += ((uint32_t)k[6] << 16);
/* fallthru */
case 6:
- b += ((u_int32_t)k[5] << 8);
+ b += ((uint32_t)k[5] << 8);
/* fallthru */
case 5:
b += k[4];
/* fallthru */
case 4:
- a += ((u_int32_t)k[3] << 24);
+ a += ((uint32_t)k[3] << 24);
/* fallthru */
case 3:
- a += ((u_int32_t)k[2] << 16);
+ a += ((uint32_t)k[2] << 16);
/* fallthru */
case 2:
- a += ((u_int32_t)k[1] << 8);
+ a += ((uint32_t)k[1] << 8);
/* fallthru */
case 1:
a += k[0];
return c;
}
-/* A special optimized version that handles 1 or more of u_int32_ts.
- * The length parameter here is the number of u_int32_ts in the key.
+/* A special optimized version that handles 1 or more of uint32_ts.
+ * The length parameter here is the number of uint32_ts in the key.
*/
-u_int32_t jhash2(const u_int32_t *k, u_int32_t length, u_int32_t initval)
+uint32_t jhash2(const uint32_t *k, uint32_t length, uint32_t initval)
{
- u_int32_t a, b, c, len;
+ uint32_t a, b, c, len;
a = b = JHASH_GOLDEN_RATIO;
c = initval;
* NOTE: In partilar the "c += length; __jhash_mix(a,b,c);" normally
* done at the end is not done here.
*/
-u_int32_t jhash_3words(u_int32_t a, u_int32_t b, u_int32_t c, u_int32_t initval)
+uint32_t jhash_3words(uint32_t a, uint32_t b, uint32_t c, uint32_t initval)
{
a += JHASH_GOLDEN_RATIO;
b += JHASH_GOLDEN_RATIO;
return c;
}
-u_int32_t jhash_2words(u_int32_t a, u_int32_t b, u_int32_t initval)
+uint32_t jhash_2words(uint32_t a, uint32_t b, uint32_t initval)
{
return jhash_3words(a, b, 0, initval);
}
-u_int32_t jhash_1word(u_int32_t a, u_int32_t initval)
+uint32_t jhash_1word(uint32_t a, uint32_t initval)
{
return jhash_3words(a, 0, 0, initval);
}
* of bytes. No alignment or length assumptions are made about
* the input key.
*/
-extern u_int32_t jhash(const void *key, u_int32_t length, u_int32_t initval);
+extern uint32_t jhash(const void *key, uint32_t length, uint32_t initval);
-/* A special optimized version that handles 1 or more of u_int32_ts.
- * The length parameter here is the number of u_int32_ts in the key.
+/* A special optimized version that handles 1 or more of uint32_ts.
+ * The length parameter here is the number of uint32_ts in the key.
*/
-extern u_int32_t jhash2(const u_int32_t *k, u_int32_t length,
- u_int32_t initval);
+extern uint32_t jhash2(const uint32_t *k, uint32_t length, uint32_t initval);
/* A special ultra-optimized versions that knows they are hashing exactly
* 3, 2 or 1 word(s).
* NOTE: In partilar the "c += length; __jhash_mix(a,b,c);" normally
* done at the end is not done here.
*/
-extern u_int32_t jhash_3words(u_int32_t a, u_int32_t b, u_int32_t c,
- u_int32_t initval);
-extern u_int32_t jhash_2words(u_int32_t a, u_int32_t b, u_int32_t initval);
-extern u_int32_t jhash_1word(u_int32_t a, u_int32_t initval);
+extern uint32_t jhash_3words(uint32_t a, uint32_t b, uint32_t c,
+ uint32_t initval);
+extern uint32_t jhash_2words(uint32_t a, uint32_t b, uint32_t initval);
+extern uint32_t jhash_1word(uint32_t a, uint32_t initval);
#endif /* _QUAGGA_JHASH_H */
keychain_free(keychain);
}
-static struct key *key_lookup(const struct keychain *keychain, u_int32_t index)
+static struct key *key_lookup(const struct keychain *keychain, uint32_t index)
{
struct listnode *node;
struct key *key;
}
struct key *key_lookup_for_accept(const struct keychain *keychain,
- u_int32_t index)
+ uint32_t index)
{
struct listnode *node;
struct key *key;
return NULL;
}
-static struct key *key_get(const struct keychain *keychain, u_int32_t index)
+static struct key *key_get(const struct keychain *keychain, uint32_t index)
{
struct key *key;
int idx_number = 1;
VTY_DECLVAR_CONTEXT(keychain, keychain);
struct key *key;
- u_int32_t index;
+ uint32_t index;
index = strtoul(argv[idx_number]->arg, NULL, 10);
key = key_get(keychain, index);
int idx_number = 2;
VTY_DECLVAR_CONTEXT(keychain, keychain);
struct key *key;
- u_int32_t index;
+ uint32_t index;
index = strtoul(argv[idx_number]->arg, NULL, 10);
key = key_lookup(keychain, index);
const char *duration_str)
{
time_t time_start;
- u_int32_t duration;
+ uint32_t duration;
time_start = key_str2time(stime_str, sday_str, smonth_str, syear_str);
if (time_start < 0) {
time_t start;
time_t end;
- u_char duration;
+ uint8_t duration;
};
struct key {
- u_int32_t index;
+ uint32_t index;
char *string;
extern void keychain_init(void);
extern struct keychain *keychain_lookup(const char *);
-extern struct key *key_lookup_for_accept(const struct keychain *, u_int32_t);
+extern struct key *key_lookup_for_accept(const struct keychain *, uint32_t);
extern struct key *key_match_for_accept(const struct keychain *, const char *);
extern struct key *key_lookup_for_send(const struct keychain *);
return dst;
}
-static char *num_append(char *s, int len, u_long x)
+static char *num_append(char *s, int len, unsigned long x)
{
char buf[30];
char *t;
}
#if defined(SA_SIGINFO) || defined(HAVE_STACK_TRACE)
-static char *hex_append(char *s, int len, u_long x)
+static char *hex_append(char *s, int len, unsigned long x)
{
char buf[30];
char *t;
return str_append(s, len, "0");
*(t = &buf[sizeof(buf) - 1]) = '\0';
while (x && (t > buf)) {
- u_int cc = (x % 16);
+ unsigned int cc = (x % 16);
*--t = ((cc < 10) ? ('0' + cc) : ('a' + cc - 10));
x /= 16;
}
s = num_append(LOC, now);
#ifdef SA_SIGINFO
s = str_append(LOC, " (si_addr 0x");
- s = hex_append(LOC, (u_long)(siginfo->si_addr));
+ s = hex_append(LOC, (unsigned long)(siginfo->si_addr));
if (program_counter) {
s = str_append(LOC, ", PC 0x");
- s = hex_append(LOC, (u_long)program_counter);
+ s = hex_append(LOC, (unsigned long)program_counter);
}
s = str_append(LOC, "); ");
#else /* SA_SIGINFO */
s = str_append(LOC, "[bt ");
s = num_append(LOC, i);
s = str_append(LOC, "] 0x");
- s = hex_append(LOC, (u_long)(array[i]));
+ s = hex_append(
+ LOC, (unsigned long)(array[i]));
}
*s = '\0';
if (priority
}
/* Open log stream */
-void openzlog(const char *progname, const char *protoname, u_short instance,
- int syslog_flags, int syslog_facility)
+void openzlog(const char *progname, const char *protoname,
+ unsigned short instance, int syslog_flags, int syslog_facility)
{
struct zlog *zl;
- u_int i;
+ unsigned int i;
zl = XCALLOC(MTYPE_ZLOG, sizeof(struct zlog));
static const struct zebra_desc_table unknown = {0, "unknown", '?'};
-static const struct zebra_desc_table *zroute_lookup(u_int zroute)
+static const struct zebra_desc_table *zroute_lookup(unsigned int zroute)
{
- u_int i;
+ unsigned int i;
if (zroute >= array_size(route_types)) {
zlog_err("unknown zebra route type: %u", zroute);
return &unknown;
}
-const char *zebra_route_string(u_int zroute)
+const char *zebra_route_string(unsigned int zroute)
{
return zroute_lookup(zroute)->string;
}
-char zebra_route_char(u_int zroute)
+char zebra_route_char(unsigned int zroute)
{
return zroute_lookup(zroute)->chr;
}
struct zlog {
const char *ident; /* daemon name (first arg to openlog) */
const char *protoname;
- u_short instance;
+ unsigned short instance;
int maxlvl[ZLOG_NUM_DESTS]; /* maximum priority to send to associated
logging destination */
int default_lvl; /* maxlvl to use if none is specified */
} md5_ctxt;
extern void md5_init(md5_ctxt *);
-extern void md5_loop(md5_ctxt *, const void *, u_int);
+extern void md5_loop(md5_ctxt *, const void *, unsigned int);
extern void md5_pad(md5_ctxt *);
extern void md5_result(uint8_t *, md5_ctxt *);
/* Encode a label stack entry from fields; convert to network byte-order as
* the Netlink interface expects MPLS labels to be in this format.
*/
-static inline mpls_lse_t mpls_lse_encode(mpls_label_t label, u_int32_t ttl,
- u_int32_t exp, u_int32_t bos)
+static inline mpls_lse_t mpls_lse_encode(mpls_label_t label, uint32_t ttl,
+ uint32_t exp, uint32_t bos)
{
mpls_lse_t lse;
lse = htonl((label << MPLS_LS_LABEL_SHIFT) | (exp << MPLS_LS_EXP_SHIFT)
* Netlink interface.
*/
static inline void mpls_lse_decode(mpls_lse_t lse, mpls_label_t *label,
- u_int32_t *ttl, u_int32_t *exp,
- u_int32_t *bos)
+ uint32_t *ttl, uint32_t *exp, uint32_t *bos)
{
mpls_lse_t local_lse;
#include "network.h"
/* Read nbytes from fd and store into ptr. */
-int readn(int fd, u_char *ptr, int nbytes)
+int readn(int fd, uint8_t *ptr, int nbytes)
{
int nleft;
int nread;
}
/* Write nbytes from ptr to fd. */
-int writen(int fd, const u_char *ptr, int nbytes)
+int writen(int fd, const uint8_t *ptr, int nbytes)
{
int nleft;
int nwritten;
float htonf(float host)
{
- u_int32_t lu1, lu2;
+ uint32_t lu1, lu2;
float convert;
- memcpy(&lu1, &host, sizeof(u_int32_t));
+ memcpy(&lu1, &host, sizeof(uint32_t));
lu2 = htonl(lu1);
- memcpy(&convert, &lu2, sizeof(u_int32_t));
+ memcpy(&convert, &lu2, sizeof(uint32_t));
return convert;
}
/* Both readn and writen are deprecated and will be removed. They are not
suitable for use with non-blocking file descriptors.
*/
-extern int readn(int, u_char *, int);
-extern int writen(int, const u_char *, int);
+extern int readn(int, uint8_t *, int);
+extern int writen(int, const uint8_t *, int);
/* Set the file descriptor to use non-blocking I/O. Returns 0 for success,
-1 on error. */
/* Update nexthop with label information. */
void nexthop_add_labels(struct nexthop *nexthop, enum lsp_types_t type,
- u_int8_t num_labels, mpls_label_t *label)
+ uint8_t num_labels, mpls_label_t *label)
{
struct mpls_label_stack *nh_label;
int i;
enum nexthop_types_t type;
- u_char flags;
+ uint8_t flags;
#define NEXTHOP_FLAG_ACTIVE (1 << 0) /* This nexthop is alive. */
#define NEXTHOP_FLAG_FIB (1 << 1) /* FIB nexthop. */
#define NEXTHOP_FLAG_RECURSIVE (1 << 2) /* Recursive nexthop. */
void nexthop_free(struct nexthop *nexthop);
void nexthops_free(struct nexthop *nexthop);
-void nexthop_add_labels(struct nexthop *, enum lsp_types_t, u_int8_t,
+void nexthop_add_labels(struct nexthop *, enum lsp_types_t, uint8_t,
mpls_label_t *);
void nexthop_del_labels(struct nexthop *);
#include "linklist.h"
#include "vty.h"
-typedef u_int32_t ns_id_t;
+typedef uint32_t ns_id_t;
/* the default NS ID */
#define NS_UNKNOWN UINT32_MAX
else if (ftruncate(fd, pidsize) < 0)
zlog_err(
"Could not truncate pid_file %s to %u bytes: %s",
- path, (u_int)pidsize, safe_strerror(errno));
+ path, (unsigned int)pidsize,
+ safe_strerror(errno));
}
return pid;
}
}
struct stream *prefix_bgp_orf_entry(struct stream *s, struct prefix_list *plist,
- u_char init_flag, u_char permit_flag,
- u_char deny_flag)
+ uint8_t init_flag, uint8_t permit_flag,
+ uint8_t deny_flag)
{
struct prefix_list_entry *pentry;
return s;
for (pentry = plist->head; pentry; pentry = pentry->next) {
- u_char flag = init_flag;
+ uint8_t flag = init_flag;
struct prefix *p = &pentry->prefix;
flag |= (pentry->type == PREFIX_PERMIT ? permit_flag
: deny_flag);
stream_putc(s, flag);
- stream_putl(s, (u_int32_t)pentry->seq);
- stream_putc(s, (u_char)pentry->ge);
- stream_putc(s, (u_char)pentry->le);
+ stream_putl(s, (uint32_t)pentry->seq);
+ stream_putc(s, (uint8_t)pentry->ge);
+ stream_putc(s, (uint8_t)pentry->le);
stream_put_prefix(s, p);
}
/* return prefix count */
int prefix_bgp_show_prefix_list(struct vty *vty, afi_t afi, char *name,
- u_char use_json)
+ uint8_t use_json)
{
struct prefix_list *plist;
struct prefix_list_entry *pentry;
struct prefix_list;
struct orf_prefix {
- u_int32_t seq;
- u_char ge;
- u_char le;
+ uint32_t seq;
+ uint8_t ge;
+ uint8_t le;
struct prefix p;
};
extern struct prefix_list *prefix_bgp_orf_lookup(afi_t, const char *);
extern struct stream *prefix_bgp_orf_entry(struct stream *,
- struct prefix_list *, u_char, u_char,
- u_char);
+ struct prefix_list *, uint8_t,
+ uint8_t, uint8_t);
extern int prefix_bgp_orf_set(char *, afi_t, struct orf_prefix *, int, int);
extern void prefix_bgp_orf_remove_all(afi_t, char *);
-extern int prefix_bgp_show_prefix_list(struct vty *, afi_t, char *, u_char);
+extern int prefix_bgp_show_prefix_list(struct vty *, afi_t, char *, uint8_t);
#endif /* _QUAGGA_PLIST_H */
DEFINE_MTYPE_STATIC(LIB, PREFIX, "Prefix")
/* Maskbit. */
-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};
static const struct in6_addr maskbytes6[] = {
/* /0 */ {{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
return 1;
}
-unsigned int prefix_bit(const u_char *prefix, const u_char prefixlen)
+unsigned int prefix_bit(const uint8_t *prefix, const uint8_t prefixlen)
{
unsigned int offset = prefixlen / 8;
unsigned int shift = 7 - (prefixlen % 8);
return (prefix[offset] >> shift) & 1;
}
-unsigned int prefix6_bit(const struct in6_addr *prefix, const u_char prefixlen)
+unsigned int prefix6_bit(const struct in6_addr *prefix, const uint8_t prefixlen)
{
- return prefix_bit((const u_char *)&prefix->s6_addr, prefixlen);
+ return prefix_bit((const uint8_t *)&prefix->s6_addr, prefixlen);
}
int str2family(const char *string)
{
int offset;
int shift;
- const u_char *np, *pp;
+ const uint8_t *np, *pp;
/* If n's prefix is longer than p's one return 0. */
if (n->prefixlen > p->prefixlen)
return 0;
/* Set both prefix's head pointer. */
- np = (const u_char *)&n->u.prefix;
- pp = (const u_char *)&p->u.prefix;
+ np = (const uint8_t *)&n->u.prefix;
+ pp = (const uint8_t *)&p->u.prefix;
offset = n->prefixlen / PNBBY;
shift = n->prefixlen % PNBBY;
{
int offset;
int shift;
- const u_char *np, *pp;
+ const uint8_t *np, *pp;
/* Set both prefix's head pointer. */
- np = (const u_char *)&n->u.prefix;
- pp = (const u_char *)&p->u.prefix;
+ np = (const uint8_t *)&n->u.prefix;
+ pp = (const uint8_t *)&p->u.prefix;
offset = n->prefixlen / PNBBY;
shift = n->prefixlen % PNBBY;
int shift;
/* 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;
if (p1->family != p2->family || p1->prefixlen != p2->prefixlen)
return 1;
{
int pos, bit;
int length = 0;
- u_char xor ;
+ uint8_t xor ;
/* 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;
if (p1->family == AF_INET)
length = IPV4_MAX_BYTELEN;
XFREE(MTYPE_TMP, cp);
/* Get prefix length. */
- plen = (u_char)atoi(++pnt);
+ plen = (uint8_t)atoi(++pnt);
if (plen > IPV4_MAX_PREFIXLEN)
return 0;
if (pnt) {
/* Get prefix length. */
- plen = (u_char)atoi(++pnt);
+ plen = (uint8_t)atoi(++pnt);
if (plen > 48) {
ret = 0;
goto done;
/* Convert IP address's netmask into integer. We assume netmask is
sequential one. Argument netmask should be network byte order. */
-u_char ip_masklen(struct in_addr netmask)
+uint8_t ip_masklen(struct in_addr netmask)
{
uint32_t tmp = ~ntohl(netmask.s_addr);
if (tmp)
XFREE(MTYPE_TMP, cp);
if (ret == 0)
return 0;
- plen = (u_char)atoi(++pnt);
+ plen = (uint8_t)atoi(++pnt);
if (plen > IPV6_MAX_BITLEN)
return 0;
p->prefixlen = plen;
}
/* Convert struct in6_addr netmask into integer.
- * FIXME return u_char as ip_maskleni() does. */
+ * FIXME return uint8_t as ip_maskleni() does. */
int ip6_masklen(struct in6_addr netmask)
{
int len = 0;
void apply_mask_ipv6(struct prefix_ipv6 *p)
{
- u_char *pnt;
+ uint8_t *pnt;
int index;
int offset;
index = p->prefixlen / 8;
if (index < 16) {
- pnt = (u_char *)&p->prefix;
+ pnt = (uint8_t *)&p->prefix;
offset = p->prefixlen % 8;
pnt[index] &= maskbit[offset];
static const char *prefixevpn2str(const struct prefix *p, char *str, int size)
{
- u_char family;
+ uint8_t family;
char buf[PREFIX2STR_BUFFER];
char buf2[ETHER_ADDR_STRLEN];
void apply_classful_mask_ipv4(struct prefix_ipv4 *p)
{
- u_int32_t destination;
+ uint32_t destination;
destination = ntohl(p->prefix.s_addr);
{
struct in_addr network;
struct in_addr mask;
- u_char prefixlen;
- u_int32_t destination;
+ uint8_t prefixlen;
+ uint32_t destination;
int ret;
ret = inet_aton(net_str, &network);
* own to simplify internal handling
*/
struct ethaddr {
- u_char octet[ETH_ALEN];
+ uint8_t octet[ETH_ALEN];
} __attribute__((packed));
/* EVPN address (RFC 7432) */
struct evpn_addr {
- u_char route_type;
- u_char ip_prefix_length;
+ uint8_t route_type;
+ uint8_t ip_prefix_length;
struct ethaddr mac;
uint32_t eth_tag;
struct ipaddr ip;
#if 0
union
{
- u_char addr;
+ uint8_t addr;
struct in_addr v4_addr;
struct in6_addr v6_addr;
} ip;
/* FRR generic prefix structure. */
struct prefix {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
union {
- u_char prefix;
+ uint8_t prefix;
struct in_addr prefix4;
struct in6_addr prefix6;
struct {
struct in_addr adv_router;
} lp;
struct ethaddr prefix_eth; /* AF_ETHERNET */
- u_char val[16];
+ uint8_t val[16];
uintptr_t ptr;
struct evpn_addr prefix_evpn; /* AF_EVPN */
} u __attribute__((aligned(8)));
/* IPv4 prefix structure. */
struct prefix_ipv4 {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
struct in_addr prefix __attribute__((aligned(8)));
};
/* IPv6 prefix structure. */
struct prefix_ipv6 {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
struct in6_addr prefix __attribute__((aligned(8)));
};
struct prefix_ls {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
struct in_addr id __attribute__((aligned(8)));
struct in_addr adv_router;
};
/* Prefix for routing distinguisher. */
struct prefix_rd {
- u_char family;
- u_char prefixlen;
- u_char val[8] __attribute__((aligned(8)));
+ uint8_t family;
+ uint8_t prefixlen;
+ uint8_t val[8] __attribute__((aligned(8)));
};
/* Prefix for ethernet. */
struct prefix_eth {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
struct ethaddr eth_addr __attribute__((aligned(8))); /* AF_ETHERNET */
};
/* EVPN prefix structure. */
struct prefix_evpn {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
struct evpn_addr prefix __attribute__((aligned(8)));
};
/* Prefix for a generic pointer */
struct prefix_ptr {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
uintptr_t prefix __attribute__((aligned(8)));
};
struct prefix_sg {
- u_char family;
- u_char prefixlen;
+ uint8_t family;
+ uint8_t prefixlen;
struct in_addr src __attribute__((aligned(8)));
struct in_addr grp;
};
}
#define IPV4_ADDR_COPY(D,S) ipv4_addr_copy((D), (S))
-#define IPV4_NET0(a) ((((u_int32_t) (a)) & 0xff000000) == 0x00000000)
-#define IPV4_NET127(a) ((((u_int32_t) (a)) & 0xff000000) == 0x7f000000)
-#define IPV4_LINKLOCAL(a) ((((u_int32_t) (a)) & 0xffff0000) == 0xa9fe0000)
-#define IPV4_CLASS_DE(a) ((((u_int32_t) (a)) & 0xe0000000) == 0xe0000000)
-#define IPV4_MC_LINKLOCAL(a) ((((u_int32_t) (a)) & 0xffffff00) == 0xe0000000)
+#define IPV4_NET0(a) ((((uint32_t)(a)) & 0xff000000) == 0x00000000)
+#define IPV4_NET127(a) ((((uint32_t)(a)) & 0xff000000) == 0x7f000000)
+#define IPV4_LINKLOCAL(a) ((((uint32_t)(a)) & 0xffff0000) == 0xa9fe0000)
+#define IPV4_CLASS_DE(a) ((((uint32_t)(a)) & 0xe0000000) == 0xe0000000)
+#define IPV4_MC_LINKLOCAL(a) ((((uint32_t)(a)) & 0xffffff00) == 0xe0000000)
/* Max bit/byte length of IPv6 address. */
#define IPV6_MAX_BYTELEN 16
extern const char *afi2str(afi_t afi);
/* Check bit of the prefix. */
-extern unsigned int prefix_bit(const u_char *prefix, const u_char prefixlen);
+extern unsigned int prefix_bit(const uint8_t *prefix, const uint8_t prefixlen);
extern unsigned int prefix6_bit(const struct in6_addr *prefix,
- const u_char prefixlen);
+ const uint8_t prefixlen);
extern struct prefix *prefix_new(void);
extern void prefix_free(struct prefix *);
extern int prefix_ipv4_any(const struct prefix_ipv4 *);
extern void apply_classful_mask_ipv4(struct prefix_ipv4 *);
-extern u_char ip_masklen(struct in_addr);
+extern uint8_t ip_masklen(struct in_addr);
extern void masklen2ip(const int, struct in_addr *);
/* returns the network portion of the host address */
extern in_addr_t ipv4_network_addr(in_addr_t hostaddr, int masklen);
};
static const struct {
const int *sigs;
- u_int nsigs;
+ unsigned int nsigs;
void (*handler)(int signo
#ifdef SA_SIGINFO
,
{exit_signals, array_size(exit_signals), exit_handler},
{ignore_signals, array_size(ignore_signals), NULL},
};
- u_int i;
+ unsigned int i;
for (i = 0; i < array_size(sigmap); i++) {
- u_int j;
+ unsigned int j;
for (j = 0; j < sigmap[i].nsigs; j++) {
struct sigaction oact;
struct subtree {
/* Tree's oid. */
oid name[MAX_OID_LEN];
- u_char name_len;
+ uint8_t name_len;
/* List of the variables. */
struct variable *variables;
}
static void smux_getresp_send(oid objid[], size_t objid_len, long reqid,
- long errstat, long errindex, u_char val_type,
+ long errstat, long errindex, uint8_t val_type,
void *arg, size_t arg_len)
{
- u_char buf[BUFSIZ];
- u_char *ptr, *h1, *h1e, *h2, *h2e;
+ uint8_t buf[BUFSIZ];
+ uint8_t *ptr, *h1, *h1e, *h2, *h2e;
size_t len, length;
ptr = buf;
h1 = ptr;
/* Place holder h1 for complete sequence */
- ptr = asn_build_sequence(ptr, &len, (u_char)SMUX_GETRSP, 0);
+ ptr = asn_build_sequence(ptr, &len, (uint8_t)SMUX_GETRSP, 0);
h1e = ptr;
- ptr = asn_build_int(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_INTEGER),
- &reqid, sizeof(reqid));
+ ptr = asn_build_int(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER), &reqid,
+ sizeof(reqid));
if (debug_smux)
zlog_debug("SMUX GETRSP errstat: %ld", errstat);
- ptr = asn_build_int(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_INTEGER),
- &errstat, sizeof(errstat));
+ ptr = asn_build_int(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
+ &errstat, sizeof(errstat));
if (debug_smux)
zlog_debug("SMUX GETRSP errindex: %ld", errindex);
- ptr = asn_build_int(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_INTEGER),
- &errindex, sizeof(errindex));
+ ptr = asn_build_int(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
+ &errindex, sizeof(errindex));
h2 = ptr;
/* Place holder h2 for one variable */
ptr = asn_build_sequence(ptr, &len,
- (u_char)(ASN_SEQUENCE | ASN_CONSTRUCTOR), 0);
+ (uint8_t)(ASN_SEQUENCE | ASN_CONSTRUCTOR), 0);
h2e = ptr;
ptr = snmp_build_var_op(ptr, objid, &objid_len, val_type, arg_len, arg,
/* Now variable size is known, fill in size */
asn_build_sequence(h2, &length,
- (u_char)(ASN_SEQUENCE | ASN_CONSTRUCTOR), ptr - h2e);
+ (uint8_t)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
+ ptr - h2e);
/* Fill in size of whole sequence */
- asn_build_sequence(h1, &length, (u_char)SMUX_GETRSP, ptr - h1e);
+ asn_build_sequence(h1, &length, (uint8_t)SMUX_GETRSP, ptr - h1e);
if (debug_smux)
zlog_debug("SMUX getresp send: %td", (ptr - buf));
send(smux_sock, buf, (ptr - buf), 0);
}
-static u_char *smux_var(u_char *ptr, size_t len, oid objid[], size_t *objid_len,
- size_t *var_val_len, u_char *var_val_type,
- void **var_value)
+static uint8_t *smux_var(uint8_t *ptr, size_t len, oid objid[],
+ size_t *objid_len, size_t *var_val_len,
+ uint8_t *var_val_type, void **var_value)
{
- u_char type;
- u_char val_type;
+ uint8_t type;
+ uint8_t val_type;
size_t val_len;
- u_char *val;
+ uint8_t *val;
if (debug_smux)
zlog_debug("SMUX var parse: len %zd", len);
ucd-snmp smux and as such suppose, that the peer receives in the message
only one variable. Fortunately, IBM seems to do the same in AIX. */
-static int smux_set(oid *reqid, size_t *reqid_len, u_char val_type, void *val,
+static int smux_set(oid *reqid, size_t *reqid_len, uint8_t val_type, void *val,
size_t val_len, int action)
{
int j;
oid *suffix;
size_t suffix_len;
int result;
- u_char *statP = NULL;
+ uint8_t *statP = NULL;
WriteMethod *write_method = NULL;
struct listnode *node, *nnode;
return SNMP_ERR_NOSUCHNAME;
}
-static int smux_get(oid *reqid, size_t *reqid_len, int exact, u_char *val_type,
+static int smux_get(oid *reqid, size_t *reqid_len, int exact, uint8_t *val_type,
void **val, size_t *val_len)
{
int j;
}
static int smux_getnext(oid *reqid, size_t *reqid_len, int exact,
- u_char *val_type, void **val, size_t *val_len)
+ uint8_t *val_type, void **val, size_t *val_len)
{
int j;
oid save[MAX_OID_LEN];
}
/* GET message header. */
-static u_char *smux_parse_get_header(u_char *ptr, size_t *len, long *reqid)
+static uint8_t *smux_parse_get_header(uint8_t *ptr, size_t *len, long *reqid)
{
- u_char type;
+ uint8_t type;
long errstat;
long errindex;
return ptr;
}
-static void smux_parse_set(u_char *ptr, size_t len, int action)
+static void smux_parse_set(uint8_t *ptr, size_t len, int action)
{
long reqid;
oid oid[MAX_OID_LEN];
size_t oid_len;
- u_char val_type;
+ uint8_t val_type;
void *val;
size_t val_len;
int ret;
0);
}
-static void smux_parse_get(u_char *ptr, size_t len, int exact)
+static void smux_parse_get(uint8_t *ptr, size_t len, int exact)
{
long reqid;
oid oid[MAX_OID_LEN];
size_t oid_len;
- u_char val_type;
+ uint8_t val_type;
void *val;
size_t val_len;
int ret;
}
/* Parse SMUX_CLOSE message. */
-static void smux_parse_close(u_char *ptr, int len)
+static void smux_parse_close(uint8_t *ptr, int len)
{
long reason = 0;
}
/* SMUX_RRSP message. */
-static void smux_parse_rrsp(u_char *ptr, size_t len)
+static void smux_parse_rrsp(uint8_t *ptr, size_t len)
{
- u_char val;
+ uint8_t val;
long errstat;
ptr = asn_parse_int(ptr, &len, &val, &errstat, sizeof(errstat));
}
/* Parse SMUX message. */
-static int smux_parse(u_char *ptr, size_t len)
+static int smux_parse(uint8_t *ptr, size_t len)
{
/* This buffer we'll use for SOUT message. We could allocate it with
malloc and save only static pointer/lenght, but IMHO static
buffer is a faster solusion. */
- static u_char sout_save_buff[SMUXMAXPKTSIZE];
+ static uint8_t sout_save_buff[SMUXMAXPKTSIZE];
static int sout_save_len = 0;
int len_income = len; /* see note below: YYY */
- u_char type;
- u_char rollback;
+ uint8_t type;
+ uint8_t rollback;
rollback = ptr[2]; /* important only for SMUX_SOUT */
{
int sock;
int len;
- u_char buf[SMUXMAXPKTSIZE];
+ uint8_t buf[SMUXMAXPKTSIZE];
int ret;
/* Clear thread. */
static int smux_open(int sock)
{
- u_char buf[BUFSIZ];
- u_char *ptr;
+ uint8_t buf[BUFSIZ];
+ uint8_t *ptr;
size_t len;
long version;
const char progname[] = FRR_SMUX_NAME "-" FRR_VERSION;
len = BUFSIZ;
/* SMUX Header. As placeholder. */
- ptr = asn_build_header(ptr, &len, (u_char)SMUX_OPEN, 0);
+ ptr = asn_build_header(ptr, &len, (uint8_t)SMUX_OPEN, 0);
/* SMUX Open. */
version = 0;
- ptr = asn_build_int(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_INTEGER),
- &version, sizeof(version));
+ ptr = asn_build_int(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
+ &version, sizeof(version));
/* SMUX connection oid. */
- ptr = asn_build_objid(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_OBJECT_ID),
- smux_oid, smux_oid_len);
+ ptr = asn_build_objid(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
+ smux_oid, smux_oid_len);
/* SMUX connection description. */
- ptr = asn_build_string(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_OCTET_STR),
- (const u_char *)progname, strlen(progname));
+ ptr = asn_build_string(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR),
+ (const uint8_t *)progname, strlen(progname));
/* SMUX connection password. */
- ptr = asn_build_string(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_OCTET_STR),
- (u_char *)smux_passwd, strlen(smux_passwd));
+ ptr = asn_build_string(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR),
+ (uint8_t *)smux_passwd, strlen(smux_passwd));
/* Fill in real SMUX header. We exclude ASN header size (2). */
len = BUFSIZ;
- asn_build_header(buf, &len, (u_char)SMUX_OPEN, (ptr - buf) - 2);
+ asn_build_header(buf, &len, (uint8_t)SMUX_OPEN, (ptr - buf) - 2);
return send(sock, buf, (ptr - buf), 0);
}
size_t enamelen, const oid *name, size_t namelen,
const oid *iname, size_t inamelen,
const struct trap_object *trapobj, size_t trapobjlen,
- u_char sptrap)
+ uint8_t sptrap)
{
unsigned int i;
- u_char buf[BUFSIZ];
- u_char *ptr;
+ uint8_t buf[BUFSIZ];
+ uint8_t *ptr;
size_t len, length;
struct in_addr addr;
unsigned long val;
- u_char *h1, *h1e;
+ uint8_t *h1, *h1e;
ptr = buf;
len = BUFSIZ;
return 0;
/* SMUX header. */
- ptr = asn_build_header(ptr, &len, (u_char)SMUX_TRAP, 0);
+ ptr = asn_build_header(ptr, &len, (uint8_t)SMUX_TRAP, 0);
/* Sub agent enterprise oid. */
- ptr = asn_build_objid(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_OBJECT_ID),
- smux_oid, smux_oid_len);
+ ptr = asn_build_objid(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
+ smux_oid, smux_oid_len);
/* IP address. */
addr.s_addr = 0;
- ptr = asn_build_string(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_IPADDRESS),
- (u_char *)&addr, sizeof(addr));
+ ptr = asn_build_string(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_IPADDRESS),
+ (uint8_t *)&addr, sizeof(addr));
/* Generic trap integer. */
val = SNMP_TRAP_ENTERPRISESPECIFIC;
- ptr = asn_build_int(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_INTEGER),
- (long *)&val, sizeof(val));
+ ptr = asn_build_int(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
+ (long *)&val, sizeof(val));
/* Specific trap integer. */
val = sptrap;
- ptr = asn_build_int(ptr, &len, (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE
- | ASN_INTEGER),
- (long *)&val, sizeof(val));
+ ptr = asn_build_int(
+ ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
+ (long *)&val, sizeof(val));
/* Timeticks timestamp. */
val = 0;
ptr = asn_build_unsigned_int(
ptr, &len,
- (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_TIMETICKS), &val,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_TIMETICKS), &val,
sizeof(val));
/* Variables. */
h1 = ptr;
ptr = asn_build_sequence(ptr, &len,
- (u_char)(ASN_SEQUENCE | ASN_CONSTRUCTOR), 0);
+ (uint8_t)(ASN_SEQUENCE | ASN_CONSTRUCTOR), 0);
/* Iteration for each objects. */
size_t oid_len;
void *val;
size_t val_len;
- u_char val_type;
+ uint8_t val_type;
/* Make OID. */
if (trapobj[i].namelen > 0) {
}
smux_oid_dump("Trap", oid, oid_len);
zlog_info("BUFSIZ: %d // oid_len: %lu", BUFSIZ,
- (u_long)oid_len);
+ (unsigned long)oid_len);
}
ret = smux_get(oid, &oid_len, 1, &val_type, &val, &val_len);
/* Now variable size is known, fill in size */
asn_build_sequence(h1, &length,
- (u_char)(ASN_SEQUENCE | ASN_CONSTRUCTOR), ptr - h1e);
+ (uint8_t)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
+ ptr - h1e);
/* Fill in size of whole sequence */
len = BUFSIZ;
- asn_build_header(buf, &len, (u_char)SMUX_TRAP, (ptr - buf) - 2);
+ asn_build_header(buf, &len, (uint8_t)SMUX_TRAP, (ptr - buf) - 2);
return send(smux_sock, buf, (ptr - buf), 0);
}
static int smux_register(int sock)
{
- u_char buf[BUFSIZ];
- u_char *ptr;
+ uint8_t buf[BUFSIZ];
+ uint8_t *ptr;
int ret;
size_t len;
long priority;
len = BUFSIZ;
/* SMUX RReq Header. */
- ptr = asn_build_header(ptr, &len, (u_char)SMUX_RREQ, 0);
+ ptr = asn_build_header(ptr, &len, (uint8_t)SMUX_RREQ, 0);
/* Register MIB tree. */
- ptr = asn_build_objid(
- ptr, &len,
- (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
- subtree->name, subtree->name_len);
+ ptr = asn_build_objid(ptr, &len,
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE
+ | ASN_OBJECT_ID),
+ subtree->name, subtree->name_len);
/* Priority. */
priority = -1;
ptr = asn_build_int(
ptr, &len,
- (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&priority, sizeof(priority));
/* Operation. */
operation = 2; /* Register R/W */
ptr = asn_build_int(
ptr, &len,
- (u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
+ (uint8_t)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&operation, sizeof(operation));
if (debug_smux) {
}
len = BUFSIZ;
- asn_build_header(buf, &len, (u_char)SMUX_RREQ, (ptr - buf) - 2);
+ asn_build_header(buf, &len, (uint8_t)SMUX_RREQ,
+ (ptr - buf) - 2);
ret = send(sock, buf, (ptr - buf), 0);
if (ret < 0)
return ret;
#define SNMP_INTEGER(V) \
(*var_len = sizeof(snmp_int_val), snmp_int_val = V, \
- (u_char *)&snmp_int_val)
+ (uint8_t *)&snmp_int_val)
#define SNMP_IPADDRESS(V) \
(*var_len = sizeof(struct in_addr), snmp_in_addr_val = V, \
- (u_char *)&snmp_in_addr_val)
+ (uint8_t *)&snmp_in_addr_val)
extern void smux_init(struct thread_master *tm);
extern void smux_register_mib(const char *, struct variable *, size_t, int,
*/
extern int smux_trap(struct variable *, size_t, const oid *, size_t,
const oid *, size_t, const oid *, size_t,
- const struct trap_object *, size_t, u_char);
+ const struct trap_object *, size_t, uint8_t);
extern int oid_compare(const oid *, int, const oid *, int);
extern void oid2in_addr(oid[], int, struct in_addr *);
void oid2in_addr(oid oid[], int len, struct in_addr *addr)
{
int i;
- u_char *pnt;
+ uint8_t *pnt;
if (len == 0)
return;
- pnt = (u_char *)addr;
+ pnt = (uint8_t *)addr;
for (i = 0; i < len; i++)
*pnt++ = oid[i];
void oid_copy_addr(oid oid[], struct in_addr *addr, int len)
{
int i;
- u_char *pnt;
+ uint8_t *pnt;
if (len == 0)
return;
- pnt = (u_char *)addr;
+ pnt = (uint8_t *)addr;
for (i = 0; i < len; i++)
oid[i] = *pnt++;
int getsockopt_so_sendbuf(const int sock)
{
- u_int32_t optval;
+ uint32_t optval;
socklen_t optlen = sizeof(optval);
int ret = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&optval,
&optlen);
#endif
}
-int setsockopt_ipv4_multicast_loop(int sock, u_char val)
+int setsockopt_ipv4_multicast_loop(int sock, uint8_t val)
{
int ret;
#define TCP_MD5_AUTH_ADD 1
#define TCP_MD5_AUTH_DEL 2
struct tcp_rfc2385_cmd {
- u_int8_t command; /* Command - Add/Delete */
- u_int32_t address; /* IPV4 address associated */
- u_int8_t keylen; /* MD5 Key len (do NOT assume 0 terminated
+ uint8_t command; /* Command - Add/Delete */
+ uint32_t address; /* IPV4 address associated */
+ uint8_t keylen; /* MD5 Key len (do NOT assume 0 terminated
ascii) */
void *key; /* MD5 Key */
} cmd;
struct in_addr if_addr,
unsigned int mcast_addr,
ifindex_t ifindex);
-extern int setsockopt_ipv4_multicast_loop(int sock, u_char val);
+extern int setsockopt_ipv4_multicast_loop(int sock, uint8_t val);
extern int setsockopt_ipv4_tos(int sock, int tos);
return family2addrsize(sockunion_family(su));
}
-const u_char *sockunion_get_addr(const union sockunion *su)
+const uint8_t *sockunion_get_addr(const union sockunion *su)
{
switch (sockunion_family(su)) {
case AF_INET:
- return (const u_char *)&su->sin.sin_addr.s_addr;
+ return (const uint8_t *)&su->sin.sin_addr.s_addr;
case AF_INET6:
- return (const u_char *)&su->sin6.sin6_addr;
+ return (const uint8_t *)&su->sin6.sin6_addr;
}
return NULL;
}
-void sockunion_set(union sockunion *su, int family, const u_char *addr,
+void sockunion_set(union sockunion *su, int family, const uint8_t *addr,
size_t bytes)
{
if (family2addrsize(family) != bytes)
const struct in6_addr *addr2)
{
unsigned int i;
- const u_char *p1, *p2;
+ const uint8_t *p1, *p2;
- p1 = (const u_char *)addr1;
- p2 = (const u_char *)addr2;
+ p1 = (const uint8_t *)addr1;
+ p2 = (const uint8_t *)addr2;
for (i = 0; i < sizeof(struct in6_addr); i++) {
if (p1[i] > p2[i])
extern size_t family2addrsize(int family);
extern size_t sockunion_get_addrlen(const union sockunion *);
-extern const u_char *sockunion_get_addr(const union sockunion *);
-extern void sockunion_set(union sockunion *, int family, const u_char *addr,
+extern const uint8_t *sockunion_get_addr(const union sockunion *);
+extern void sockunion_set(union sockunion *, int family, const uint8_t *addr,
size_t bytes);
extern union sockunion *sockunion_str2su(const char *str);
size_t stream_resize(struct stream *s, size_t newsize)
{
- u_char *newdata;
+ uint8_t *newdata;
STREAM_VERIFY_SANE(s);
newdata = XREALLOC(MTYPE_STREAM_DATA, s->data, newsize);
}
/* Get next character from the stream. */
-inline bool stream_getc2(struct stream *s, u_char *byte)
+inline bool stream_getc2(struct stream *s, uint8_t *byte)
{
STREAM_VERIFY_SANE(s);
- if (STREAM_READABLE(s) < sizeof(u_char)) {
+ if (STREAM_READABLE(s) < sizeof(uint8_t)) {
STREAM_BOUND_WARN2(s, "get char");
return false;
}
return true;
}
-u_char stream_getc(struct stream *s)
+uint8_t stream_getc(struct stream *s)
{
- u_char c;
+ uint8_t c;
STREAM_VERIFY_SANE(s);
- if (STREAM_READABLE(s) < sizeof(u_char)) {
+ if (STREAM_READABLE(s) < sizeof(uint8_t)) {
STREAM_BOUND_WARN(s, "get char");
return 0;
}
}
/* Get next character from the stream. */
-u_char stream_getc_from(struct stream *s, size_t from)
+uint8_t stream_getc_from(struct stream *s, size_t from)
{
- u_char c;
+ uint8_t c;
STREAM_VERIFY_SANE(s);
- if (!GETP_VALID(s, from + sizeof(u_char))) {
+ if (!GETP_VALID(s, from + sizeof(uint8_t))) {
STREAM_BOUND_WARN(s, "get char");
return 0;
}
}
/* Get next word from the stream. */
-u_int16_t stream_getw(struct stream *s)
+uint16_t stream_getw(struct stream *s)
{
- u_int16_t w;
+ uint16_t w;
STREAM_VERIFY_SANE(s);
- if (STREAM_READABLE(s) < sizeof(u_int16_t)) {
+ if (STREAM_READABLE(s) < sizeof(uint16_t)) {
STREAM_BOUND_WARN(s, "get ");
return 0;
}
}
/* Get next word from the stream. */
-u_int16_t stream_getw_from(struct stream *s, size_t from)
+uint16_t stream_getw_from(struct stream *s, size_t from)
{
- u_int16_t w;
+ uint16_t w;
STREAM_VERIFY_SANE(s);
- if (!GETP_VALID(s, from + sizeof(u_int16_t))) {
+ if (!GETP_VALID(s, from + sizeof(uint16_t))) {
STREAM_BOUND_WARN(s, "get ");
return 0;
}
}
/* Get next 3-byte from the stream. */
-u_int32_t stream_get3_from(struct stream *s, size_t from)
+uint32_t stream_get3_from(struct stream *s, size_t from)
{
- u_int32_t l;
+ uint32_t l;
STREAM_VERIFY_SANE(s);
return l;
}
-u_int32_t stream_get3(struct stream *s)
+uint32_t stream_get3(struct stream *s)
{
- u_int32_t l;
+ uint32_t l;
STREAM_VERIFY_SANE(s);
}
/* Get next long word from the stream. */
-u_int32_t stream_getl_from(struct stream *s, size_t from)
+uint32_t stream_getl_from(struct stream *s, size_t from)
{
- u_int32_t l;
+ uint32_t l;
STREAM_VERIFY_SANE(s);
- if (!GETP_VALID(s, from + sizeof(u_int32_t))) {
+ if (!GETP_VALID(s, from + sizeof(uint32_t))) {
STREAM_BOUND_WARN(s, "get long");
return 0;
}
return true;
}
-u_int32_t stream_getl(struct stream *s)
+uint32_t stream_getl(struct stream *s)
{
- u_int32_t l;
+ uint32_t l;
STREAM_VERIFY_SANE(s);
- if (STREAM_READABLE(s) < sizeof(u_int32_t)) {
+ if (STREAM_READABLE(s) < sizeof(uint32_t)) {
STREAM_BOUND_WARN(s, "get long");
return 0;
}
}
/* Get next long word from the stream. */
-u_int32_t stream_get_ipv4(struct stream *s)
+uint32_t stream_get_ipv4(struct stream *s)
{
- u_int32_t l;
+ uint32_t l;
STREAM_VERIFY_SANE(s);
- if (STREAM_READABLE(s) < sizeof(u_int32_t)) {
+ if (STREAM_READABLE(s) < sizeof(uint32_t)) {
STREAM_BOUND_WARN(s, "get ipv4");
return 0;
}
- memcpy(&l, s->data + s->getp, sizeof(u_int32_t));
- s->getp += sizeof(u_int32_t);
+ memcpy(&l, s->data + s->getp, sizeof(uint32_t));
+ s->getp += sizeof(uint32_t);
return l;
}
}
/* Put character to the stream. */
-int stream_putc(struct stream *s, u_char c)
+int stream_putc(struct stream *s, uint8_t c)
{
STREAM_VERIFY_SANE(s);
- if (STREAM_WRITEABLE(s) < sizeof(u_char)) {
+ if (STREAM_WRITEABLE(s) < sizeof(uint8_t)) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
s->data[s->endp++] = c;
- return sizeof(u_char);
+ return sizeof(uint8_t);
}
/* Put word to the stream. */
-int stream_putw(struct stream *s, u_int16_t w)
+int stream_putw(struct stream *s, uint16_t w)
{
STREAM_VERIFY_SANE(s);
- if (STREAM_WRITEABLE(s) < sizeof(u_int16_t)) {
+ if (STREAM_WRITEABLE(s) < sizeof(uint16_t)) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
- s->data[s->endp++] = (u_char)(w >> 8);
- s->data[s->endp++] = (u_char)w;
+ s->data[s->endp++] = (uint8_t)(w >> 8);
+ s->data[s->endp++] = (uint8_t)w;
return 2;
}
/* Put long word to the stream. */
-int stream_put3(struct stream *s, u_int32_t l)
+int stream_put3(struct stream *s, uint32_t l)
{
STREAM_VERIFY_SANE(s);
return 0;
}
- s->data[s->endp++] = (u_char)(l >> 16);
- s->data[s->endp++] = (u_char)(l >> 8);
- s->data[s->endp++] = (u_char)l;
+ s->data[s->endp++] = (uint8_t)(l >> 16);
+ s->data[s->endp++] = (uint8_t)(l >> 8);
+ s->data[s->endp++] = (uint8_t)l;
return 3;
}
/* Put long word to the stream. */
-int stream_putl(struct stream *s, u_int32_t l)
+int stream_putl(struct stream *s, uint32_t l)
{
STREAM_VERIFY_SANE(s);
- if (STREAM_WRITEABLE(s) < sizeof(u_int32_t)) {
+ if (STREAM_WRITEABLE(s) < sizeof(uint32_t)) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
- s->data[s->endp++] = (u_char)(l >> 24);
- s->data[s->endp++] = (u_char)(l >> 16);
- s->data[s->endp++] = (u_char)(l >> 8);
- s->data[s->endp++] = (u_char)l;
+ s->data[s->endp++] = (uint8_t)(l >> 24);
+ s->data[s->endp++] = (uint8_t)(l >> 16);
+ s->data[s->endp++] = (uint8_t)(l >> 8);
+ s->data[s->endp++] = (uint8_t)l;
return 4;
}
return 0;
}
- s->data[s->endp++] = (u_char)(q >> 56);
- s->data[s->endp++] = (u_char)(q >> 48);
- s->data[s->endp++] = (u_char)(q >> 40);
- s->data[s->endp++] = (u_char)(q >> 32);
- s->data[s->endp++] = (u_char)(q >> 24);
- s->data[s->endp++] = (u_char)(q >> 16);
- s->data[s->endp++] = (u_char)(q >> 8);
- s->data[s->endp++] = (u_char)q;
+ s->data[s->endp++] = (uint8_t)(q >> 56);
+ s->data[s->endp++] = (uint8_t)(q >> 48);
+ s->data[s->endp++] = (uint8_t)(q >> 40);
+ s->data[s->endp++] = (uint8_t)(q >> 32);
+ s->data[s->endp++] = (uint8_t)(q >> 24);
+ s->data[s->endp++] = (uint8_t)(q >> 16);
+ s->data[s->endp++] = (uint8_t)(q >> 8);
+ s->data[s->endp++] = (uint8_t)q;
return 8;
}
return stream_putq(s, u.o);
}
-int stream_putc_at(struct stream *s, size_t putp, u_char c)
+int stream_putc_at(struct stream *s, size_t putp, uint8_t c)
{
STREAM_VERIFY_SANE(s);
- if (!PUT_AT_VALID(s, putp + sizeof(u_char))) {
+ if (!PUT_AT_VALID(s, putp + sizeof(uint8_t))) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
return 1;
}
-int stream_putw_at(struct stream *s, size_t putp, u_int16_t w)
+int stream_putw_at(struct stream *s, size_t putp, uint16_t w)
{
STREAM_VERIFY_SANE(s);
- if (!PUT_AT_VALID(s, putp + sizeof(u_int16_t))) {
+ if (!PUT_AT_VALID(s, putp + sizeof(uint16_t))) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
- s->data[putp] = (u_char)(w >> 8);
- s->data[putp + 1] = (u_char)w;
+ s->data[putp] = (uint8_t)(w >> 8);
+ s->data[putp + 1] = (uint8_t)w;
return 2;
}
-int stream_put3_at(struct stream *s, size_t putp, u_int32_t l)
+int stream_put3_at(struct stream *s, size_t putp, uint32_t l)
{
STREAM_VERIFY_SANE(s);
STREAM_BOUND_WARN(s, "put");
return 0;
}
- s->data[putp] = (u_char)(l >> 16);
- s->data[putp + 1] = (u_char)(l >> 8);
- s->data[putp + 2] = (u_char)l;
+ s->data[putp] = (uint8_t)(l >> 16);
+ s->data[putp + 1] = (uint8_t)(l >> 8);
+ s->data[putp + 2] = (uint8_t)l;
return 3;
}
-int stream_putl_at(struct stream *s, size_t putp, u_int32_t l)
+int stream_putl_at(struct stream *s, size_t putp, uint32_t l)
{
STREAM_VERIFY_SANE(s);
- if (!PUT_AT_VALID(s, putp + sizeof(u_int32_t))) {
+ if (!PUT_AT_VALID(s, putp + sizeof(uint32_t))) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
- s->data[putp] = (u_char)(l >> 24);
- s->data[putp + 1] = (u_char)(l >> 16);
- s->data[putp + 2] = (u_char)(l >> 8);
- s->data[putp + 3] = (u_char)l;
+ s->data[putp] = (uint8_t)(l >> 24);
+ s->data[putp + 1] = (uint8_t)(l >> 16);
+ s->data[putp + 2] = (uint8_t)(l >> 8);
+ s->data[putp + 3] = (uint8_t)l;
return 4;
}
STREAM_BOUND_WARN(s, "put");
return 0;
}
- s->data[putp] = (u_char)(q >> 56);
- s->data[putp + 1] = (u_char)(q >> 48);
- s->data[putp + 2] = (u_char)(q >> 40);
- s->data[putp + 3] = (u_char)(q >> 32);
- s->data[putp + 4] = (u_char)(q >> 24);
- s->data[putp + 5] = (u_char)(q >> 16);
- s->data[putp + 6] = (u_char)(q >> 8);
- s->data[putp + 7] = (u_char)q;
+ s->data[putp] = (uint8_t)(q >> 56);
+ s->data[putp + 1] = (uint8_t)(q >> 48);
+ s->data[putp + 2] = (uint8_t)(q >> 40);
+ s->data[putp + 3] = (uint8_t)(q >> 32);
+ s->data[putp + 4] = (uint8_t)(q >> 24);
+ s->data[putp + 5] = (uint8_t)(q >> 16);
+ s->data[putp + 6] = (uint8_t)(q >> 8);
+ s->data[putp + 7] = (uint8_t)q;
return 8;
}
/* Put long word to the stream. */
-int stream_put_ipv4(struct stream *s, u_int32_t l)
+int stream_put_ipv4(struct stream *s, uint32_t l)
{
STREAM_VERIFY_SANE(s);
- if (STREAM_WRITEABLE(s) < sizeof(u_int32_t)) {
+ if (STREAM_WRITEABLE(s) < sizeof(uint32_t)) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
- memcpy(s->data + s->endp, &l, sizeof(u_int32_t));
- s->endp += sizeof(u_int32_t);
+ memcpy(s->data + s->endp, &l, sizeof(uint32_t));
+ s->endp += sizeof(uint32_t);
- return sizeof(u_int32_t);
+ return sizeof(uint32_t);
}
/* Put long word to the stream. */
{
STREAM_VERIFY_SANE(s);
- if (STREAM_WRITEABLE(s) < sizeof(u_int32_t)) {
+ if (STREAM_WRITEABLE(s) < sizeof(uint32_t)) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
- memcpy(s->data + s->endp, addr, sizeof(u_int32_t));
- s->endp += sizeof(u_int32_t);
+ memcpy(s->data + s->endp, addr, sizeof(uint32_t));
+ s->endp += sizeof(uint32_t);
- return sizeof(u_int32_t);
+ return sizeof(uint32_t);
}
/* Put in_addr at location in the stream. */
/* Put prefix by nlri type format. */
int stream_put_prefix_addpath(struct stream *s, struct prefix *p,
- int addpath_encode, u_int32_t addpath_tx_id)
+ int addpath_encode, uint32_t addpath_tx_id)
{
size_t psize;
size_t psize_with_addpath;
else
psize_with_addpath = psize;
- if (STREAM_WRITEABLE(s) < (psize_with_addpath + sizeof(u_char))) {
+ if (STREAM_WRITEABLE(s) < (psize_with_addpath + sizeof(uint8_t))) {
STREAM_BOUND_WARN(s, "put");
return 0;
}
if (addpath_encode) {
- s->data[s->endp++] = (u_char)(addpath_tx_id >> 24);
- s->data[s->endp++] = (u_char)(addpath_tx_id >> 16);
- s->data[s->endp++] = (u_char)(addpath_tx_id >> 8);
- s->data[s->endp++] = (u_char)addpath_tx_id;
+ s->data[s->endp++] = (uint8_t)(addpath_tx_id >> 24);
+ s->data[s->endp++] = (uint8_t)(addpath_tx_id >> 16);
+ s->data[s->endp++] = (uint8_t)(addpath_tx_id >> 8);
+ s->data[s->endp++] = (uint8_t)addpath_tx_id;
}
s->data[s->endp++] = p->prefixlen;
mpls_label_t *label)
{
size_t psize;
- u_char *label_pnt = (u_char *)label;
+ uint8_t *label_pnt = (uint8_t *)label;
STREAM_VERIFY_SANE(s);
* Use stream_get_pnt_to if you must, but decoding streams properly
* is preferred
*/
-u_char *stream_pnt(struct stream *s)
+uint8_t *stream_pnt(struct stream *s)
{
STREAM_VERIFY_SANE(s);
return s->data + s->getp;
extern size_t stream_get_getp(struct stream *);
extern size_t stream_get_endp(struct stream *);
extern size_t stream_get_size(struct stream *);
-extern u_char *stream_get_data(struct stream *);
+extern uint8_t *stream_get_data(struct stream *);
/**
* Create a new stream structure; copy offset bytes from s1 to the new
/* steam_put: NULL source zeroes out size_t bytes of stream */
extern void stream_put(struct stream *, const void *, size_t);
-extern int stream_putc(struct stream *, u_char);
-extern int stream_putc_at(struct stream *, size_t, u_char);
-extern int stream_putw(struct stream *, u_int16_t);
-extern int stream_putw_at(struct stream *, size_t, u_int16_t);
-extern int stream_put3(struct stream *, u_int32_t);
-extern int stream_put3_at(struct stream *, size_t, u_int32_t);
-extern int stream_putl(struct stream *, u_int32_t);
-extern int stream_putl_at(struct stream *, size_t, u_int32_t);
+extern int stream_putc(struct stream *, uint8_t);
+extern int stream_putc_at(struct stream *, size_t, uint8_t);
+extern int stream_putw(struct stream *, uint16_t);
+extern int stream_putw_at(struct stream *, size_t, uint16_t);
+extern int stream_put3(struct stream *, uint32_t);
+extern int stream_put3_at(struct stream *, size_t, uint32_t);
+extern int stream_putl(struct stream *, uint32_t);
+extern int stream_putl_at(struct stream *, size_t, uint32_t);
extern int stream_putq(struct stream *, uint64_t);
extern int stream_putq_at(struct stream *, size_t, uint64_t);
-extern int stream_put_ipv4(struct stream *, u_int32_t);
+extern int stream_put_ipv4(struct stream *, uint32_t);
extern int stream_put_in_addr(struct stream *, struct in_addr *);
extern int stream_put_in_addr_at(struct stream *, size_t, struct in_addr *);
extern int stream_put_in6_addr_at(struct stream *, size_t, struct in6_addr *);
extern int stream_put_prefix_addpath(struct stream *, struct prefix *,
int addpath_encode,
- u_int32_t addpath_tx_id);
+ uint32_t addpath_tx_id);
extern int stream_put_prefix(struct stream *, struct prefix *);
extern int stream_put_labeled_prefix(struct stream *, struct prefix *,
mpls_label_t *);
extern void stream_get(void *, struct stream *, size_t);
extern bool stream_get2(void *data, struct stream *s, size_t size);
extern void stream_get_from(void *, struct stream *, size_t, size_t);
-extern u_char stream_getc(struct stream *);
-extern bool stream_getc2(struct stream *s, u_char *byte);
-extern u_char stream_getc_from(struct stream *, size_t);
-extern u_int16_t stream_getw(struct stream *);
+extern uint8_t stream_getc(struct stream *);
+extern bool stream_getc2(struct stream *s, uint8_t *byte);
+extern uint8_t stream_getc_from(struct stream *, size_t);
+extern uint16_t stream_getw(struct stream *);
extern bool stream_getw2(struct stream *s, uint16_t *word);
-extern u_int16_t stream_getw_from(struct stream *, size_t);
-extern u_int32_t stream_get3(struct stream *);
-extern u_int32_t stream_get3_from(struct stream *, size_t);
-extern u_int32_t stream_getl(struct stream *);
+extern uint16_t stream_getw_from(struct stream *, size_t);
+extern uint32_t stream_get3(struct stream *);
+extern uint32_t stream_get3_from(struct stream *, size_t);
+extern uint32_t stream_getl(struct stream *);
extern bool stream_getl2(struct stream *s, uint32_t *l);
-extern u_int32_t stream_getl_from(struct stream *, size_t);
+extern uint32_t stream_getl_from(struct stream *, size_t);
extern uint64_t stream_getq(struct stream *);
extern uint64_t stream_getq_from(struct stream *, size_t);
-extern u_int32_t stream_get_ipv4(struct stream *);
+extern uint32_t stream_get_ipv4(struct stream *);
/* IEEE-754 floats */
extern float stream_getf(struct stream *);
extern int stream_empty(struct stream *); /* is the stream empty? */
/* deprecated */
-extern u_char *stream_pnt(struct stream *);
+extern uint8_t *stream_pnt(struct stream *);
/* Stream fifo. */
extern struct stream_fifo *stream_fifo_new(void);
}
/* Utility mask array. */
-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};
/* Common prefix route genaration. */
static void route_common(const struct prefix *n, const struct prefix *p,
struct prefix *new)
{
int i;
- u_char diff;
- u_char mask;
+ uint8_t diff;
+ uint8_t mask;
- const u_char *np = (const u_char *)&n->u.prefix;
- const u_char *pp = (const u_char *)&p->u.prefix;
- u_char *newp = (u_char *)&new->u.prefix;
+ const uint8_t *np = (const uint8_t *)&n->u.prefix;
+ const uint8_t *pp = (const uint8_t *)&p->u.prefix;
+ uint8_t *newp = (uint8_t *)&new->u.prefix;
for (i = 0; i < p->prefixlen / 8; i++) {
if (np[i] == pp[i])
struct route_node *node;
struct route_node *match;
struct route_node *inserted;
- u_char prefixlen = p->prefixlen;
- const u_char *prefix = &p->u.prefix;
+ uint8_t prefixlen = p->prefixlen;
+ const uint8_t *prefix = &p->u.prefix;
apply_mask((struct prefix *)p);
node = hash_get(table->hash, (void *)p, NULL);
}
/* Get new thread. */
-static struct thread *thread_get(struct thread_master *m, u_char type,
+static struct thread *thread_get(struct thread_master *m, uint8_t type,
int (*func)(struct thread *), void *arg,
debugargdef)
{
#define __VLAN_H__
/* VLAN Identifier */
-typedef u_int16_t vlanid_t;
+typedef uint16_t vlanid_t;
#define VLANID_MAX 4095
#endif /* __VLAN_H__ */
#define VRF_BITMAP_BIT_OFFSET(_id) ((_id) % VRF_BITMAP_NUM_OF_BITS_IN_GROUP)
#define VRF_BITMAP_INDEX_IN_GROUP(_bit_offset) ((_bit_offset) / CHAR_BIT)
-#define VRF_BITMAP_FLAG(_bit_offset) (((u_char)1) << ((_bit_offset) % CHAR_BIT))
+#define VRF_BITMAP_FLAG(_bit_offset) \
+ (((uint8_t)1) << ((_bit_offset) % CHAR_BIT))
struct vrf_bitmap {
- u_char *groups[VRF_BITMAP_NUM_OF_GROUPS];
+ uint8_t *groups[VRF_BITMAP_NUM_OF_GROUPS];
};
vrf_bitmap_t vrf_bitmap_init(void)
void vrf_bitmap_set(vrf_bitmap_t bmap, vrf_id_t vrf_id)
{
struct vrf_bitmap *bm = (struct vrf_bitmap *)bmap;
- u_char group = VRF_BITMAP_GROUP(vrf_id);
- u_char offset = VRF_BITMAP_BIT_OFFSET(vrf_id);
+ uint8_t group = VRF_BITMAP_GROUP(vrf_id);
+ uint8_t offset = VRF_BITMAP_BIT_OFFSET(vrf_id);
if (bmap == VRF_BITMAP_NULL || vrf_id == VRF_UNKNOWN)
return;
void vrf_bitmap_unset(vrf_bitmap_t bmap, vrf_id_t vrf_id)
{
struct vrf_bitmap *bm = (struct vrf_bitmap *)bmap;
- u_char group = VRF_BITMAP_GROUP(vrf_id);
- u_char offset = VRF_BITMAP_BIT_OFFSET(vrf_id);
+ uint8_t group = VRF_BITMAP_GROUP(vrf_id);
+ uint8_t offset = VRF_BITMAP_BIT_OFFSET(vrf_id);
if (bmap == VRF_BITMAP_NULL || vrf_id == VRF_UNKNOWN
|| bm->groups[group] == NULL)
int vrf_bitmap_check(vrf_bitmap_t bmap, vrf_id_t vrf_id)
{
struct vrf_bitmap *bm = (struct vrf_bitmap *)bmap;
- u_char group = VRF_BITMAP_GROUP(vrf_id);
- u_char offset = VRF_BITMAP_BIT_OFFSET(vrf_id);
+ uint8_t group = VRF_BITMAP_GROUP(vrf_id);
+ uint8_t offset = VRF_BITMAP_BIT_OFFSET(vrf_id);
if (bmap == VRF_BITMAP_NULL || vrf_id == VRF_UNKNOWN
|| bm->groups[group] == NULL)
char name[VRF_NAMSIZ + 1];
/* Zebra internal VRF status */
- u_char status;
+ uint8_t status;
#define VRF_ACTIVE (1 << 0) /* VRF is up in kernel */
#define VRF_CONFIGURED (1 << 1) /* VRF has some FRR configuration */
/* Pointer p must point out buffer. */
if (vty->type != VTY_TERM)
- buffer_put(vty->obuf, (u_char *)p, len);
+ buffer_put(vty->obuf, (uint8_t *)p, len);
else
- buffer_put_crlf(vty->obuf, (u_char *)p, len);
+ buffer_put_crlf(vty->obuf, (uint8_t *)p, len);
/* If p is not different with buf, it is allocated buffer. */
if (p != buf)
"RFC 1073 violation detected: telnet NAWS option "
"should send %d characters, but we received %lu",
TELNET_NAWS_SB_LEN,
- (u_long)vty->sb_len);
+ (unsigned long)vty->sb_len);
else if (sizeof(vty->sb_buf) < TELNET_NAWS_SB_LEN)
zlog_err(
"Bug detected: sizeof(vty->sb_buf) %lu < %d, "
"too small to handle the telnet NAWS option",
- (u_long)sizeof(vty->sb_buf),
+ (unsigned long)sizeof(vty->sb_buf),
TELNET_NAWS_SB_LEN);
else {
vty->width = ((vty->sb_buf[1] << 8)
struct vty *vty;
unsigned char buf[VTY_READ_BUFSIZ];
unsigned char *p;
- u_char header[4] = {0, 0, 0, 0};
+ uint8_t header[4] = {0, 0, 0, 0};
sock = THREAD_FD(thread);
vty = THREAD_ARG(thread);
#define __VXLAN_H__
/* VxLAN Network Identifier - 24-bit (RFC 7348) */
-typedef u_int32_t vni_t;
+typedef uint32_t vni_t;
#define VNI_MAX 16777215 /* (2^24 - 1) */
#endif /* __VXLAN_H__ */
} cycles; /* cycle counts */
/* private state */
- u_int16_t flags; /* user set flag */
+ uint16_t flags; /* user set flag */
};
/* User API */
XFREE(MTYPE_ZCLIENT, zclient);
}
-u_short *redist_check_instance(struct redist_proto *red, u_short instance)
+unsigned short *redist_check_instance(struct redist_proto *red,
+ unsigned short instance)
{
struct listnode *node;
- u_short *id;
+ unsigned short *id;
if (!red->instances)
return NULL;
return NULL;
}
-void redist_add_instance(struct redist_proto *red, u_short instance)
+void redist_add_instance(struct redist_proto *red, unsigned short instance)
{
- u_short *in;
+ unsigned short *in;
red->enabled = 1;
if (!red->instances)
red->instances = list_new();
- in = XMALLOC(MTYPE_REDIST_INST, sizeof(u_short));
+ in = XMALLOC(MTYPE_REDIST_INST, sizeof(unsigned short));
*in = instance;
listnode_add(red->instances, in);
}
-void redist_del_instance(struct redist_proto *red, u_short instance)
+void redist_del_instance(struct redist_proto *red, unsigned short instance)
{
- u_short *id;
+ unsigned short *id;
id = redist_check_instance(red, instance);
if (!id)
stream_putw(s, command);
}
-int zclient_read_header(struct stream *s, int sock, u_int16_t *size,
- u_char *marker, u_char *version, vrf_id_t *vrf_id,
- u_int16_t *cmd)
+int zclient_read_header(struct stream *s, int sock, uint16_t *size,
+ uint8_t *marker, uint8_t *version, vrf_id_t *vrf_id,
+ uint16_t *cmd)
{
if (stream_read(s, sock, ZEBRA_HEADER_SIZE) != ZEBRA_HEADER_SIZE)
return -1;
continue;
struct listnode *node;
- u_short *id;
+ unsigned short *id;
for (ALL_LIST_ELEMENTS_RO(
zclient->mi_redist[afi][i]
continue;
struct listnode *node;
- u_short *id;
+ unsigned short *id;
for (ALL_LIST_ELEMENTS_RO(
zclient->mi_redist[afi][i]
/* Initialize zebra client. Argument redist_default is unwanted
redistribute route type. */
-void zclient_init(struct zclient *zclient, int redist_default, u_short instance,
- struct zebra_privs_t *privs)
+void zclient_init(struct zclient *zclient, int redist_default,
+ unsigned short instance, struct zebra_privs_t *privs)
{
int afi, i;
*
* XXX: No attention paid to alignment.
*/
-int zapi_ipv4_route(u_char cmd, struct zclient *zclient, struct prefix_ipv4 *p,
+int zapi_ipv4_route(uint8_t cmd, struct zclient *zclient, struct prefix_ipv4 *p,
struct zapi_ipv4 *api)
{
int i;
/* Put prefix information. */
psize = PSIZE(p->prefixlen);
stream_putc(s, p->prefixlen);
- stream_write(s, (u_char *)&p->prefix, psize);
+ stream_write(s, (uint8_t *)&p->prefix, psize);
/* Nexthop, ifindex, distance and metric information. */
if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
return zclient_send_message(zclient);
}
-int zapi_ipv4_route_ipv6_nexthop(u_char cmd, struct zclient *zclient,
+int zapi_ipv4_route_ipv6_nexthop(uint8_t cmd, struct zclient *zclient,
struct prefix_ipv4 *p, struct zapi_ipv6 *api)
{
int i;
/* Put prefix information. */
psize = PSIZE(p->prefixlen);
stream_putc(s, p->prefixlen);
- stream_write(s, (u_char *)&p->prefix, psize);
+ stream_write(s, (uint8_t *)&p->prefix, psize);
/* Nexthop, ifindex, distance and metric information. */
if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
for (i = 0; i < api->nexthop_num; i++) {
stream_putc(s, NEXTHOP_TYPE_IPV6);
- stream_write(s, (u_char *)api->nexthop[i], 16);
+ stream_write(s, (uint8_t *)api->nexthop[i], 16);
/* For labeled-unicast, each nexthop is followed by
* label. */
if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL))
return zclient_send_message(zclient);
}
-int zapi_ipv6_route(u_char cmd, struct zclient *zclient, struct prefix_ipv6 *p,
+int zapi_ipv6_route(uint8_t cmd, struct zclient *zclient, struct prefix_ipv6 *p,
struct prefix_ipv6 *src_p, struct zapi_ipv6 *api)
{
int i;
/* Put prefix information. */
psize = PSIZE(p->prefixlen);
stream_putc(s, p->prefixlen);
- stream_write(s, (u_char *)&p->prefix, psize);
+ stream_write(s, (uint8_t *)&p->prefix, psize);
if (CHECK_FLAG(api->message, ZAPI_MESSAGE_SRCPFX)) {
psize = PSIZE(src_p->prefixlen);
stream_putc(s, src_p->prefixlen);
- stream_write(s, (u_char *)&src_p->prefix, psize);
+ stream_write(s, (uint8_t *)&src_p->prefix, psize);
}
/* Nexthop, ifindex, distance and metric information. */
for (i = 0; i < api->nexthop_num; i++) {
stream_putc(s, NEXTHOP_TYPE_IPV6);
- stream_write(s, (u_char *)api->nexthop[i], 16);
+ stream_write(s, (uint8_t *)api->nexthop[i], 16);
/* For labeled-unicast, each nexthop is followed by
* label. */
if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL))
return zclient_send_message(zclient);
}
-int zclient_route_send(u_char cmd, struct zclient *zclient,
+int zclient_route_send(uint8_t cmd, struct zclient *zclient,
struct zapi_route *api)
{
if (zapi_route_encode(cmd, zclient->obuf, api) < 0)
return zclient_send_message(zclient);
}
-int zapi_route_encode(u_char cmd, struct stream *s, struct zapi_route *api)
+int zapi_route_encode(uint8_t cmd, struct stream *s, struct zapi_route *api)
{
struct zapi_nexthop *api_nh;
int i;
stream_putc(s, api->prefix.family);
psize = PSIZE(api->prefix.prefixlen);
stream_putc(s, api->prefix.prefixlen);
- stream_write(s, (u_char *)&api->prefix.u.prefix, psize);
+ stream_write(s, (uint8_t *)&api->prefix.u.prefix, psize);
if (CHECK_FLAG(api->message, ZAPI_MESSAGE_SRCPFX)) {
psize = PSIZE(api->src_prefix.prefixlen);
stream_putc(s, api->src_prefix.prefixlen);
- stream_write(s, (u_char *)&api->src_prefix.prefix, psize);
+ stream_write(s, (uint8_t *)&api->src_prefix.prefix, psize);
}
/* Nexthops. */
stream_putl(s, api_nh->ifindex);
break;
case NEXTHOP_TYPE_IPV6:
- stream_write(s, (u_char *)&api_nh->gate.ipv6,
+ stream_write(s, (uint8_t *)&api_nh->gate.ipv6,
16);
break;
case NEXTHOP_TYPE_IPV6_IFINDEX:
- stream_write(s, (u_char *)&api_nh->gate.ipv6,
+ stream_write(s, (uint8_t *)&api_nh->gate.ipv6,
16);
stream_putl(s, api_nh->ifindex);
break;
* sending client
*/
int zebra_redistribute_send(int command, struct zclient *zclient, afi_t afi,
- int type, u_short instance, vrf_id_t vrf_id)
+ int type, unsigned short instance, vrf_id_t vrf_id)
{
struct stream *s;
static void zclient_stream_get_prefix(struct stream *s, struct prefix *p)
{
size_t plen = prefix_blen(p);
- u_char c;
+ uint8_t c;
p->prefixlen = 0;
if (plen == 0)
void zebra_interface_if_set_value(struct stream *s, struct interface *ifp)
{
- u_char link_params_status = 0;
+ uint8_t link_params_status = 0;
/* Read interface's index. */
if_set_index(ifp, stream_getl(s));
static int memconstant(const void *s, int c, size_t n)
{
- const u_char *p = s;
+ const uint8_t *p = s;
while (n-- > 0)
if (*p++ != c)
struct connected *ifc;
struct prefix p, d, *dp;
int plen;
- u_char ifc_flags;
+ uint8_t ifc_flags;
memset(&p, 0, sizeof(p));
memset(&d, 0, sizeof(d));
/* filter unwanted messages until the expected one arrives */
static int zclient_read_sync_response(struct zclient *zclient,
- u_int16_t expected_cmd)
+ uint16_t expected_cmd)
{
struct stream *s;
- u_int16_t size = -1;
- u_char marker;
- u_char version;
+ uint16_t size = -1;
+ uint8_t marker;
+ uint8_t version;
vrf_id_t vrf_id;
- u_int16_t cmd;
+ uint16_t cmd;
fd_set readfds;
int ret;
{
int ret;
struct stream *s;
- u_char result;
+ uint8_t result;
if (zclient_debug)
zlog_debug("Connecting to Label Manager");
* @param end To write last assigned chunk label to
* @result 0 on success, -1 otherwise
*/
-int lm_get_label_chunk(struct zclient *zclient, u_char keep,
+int lm_get_label_chunk(struct zclient *zclient, uint8_t keep,
uint32_t chunk_size, uint32_t *start, uint32_t *end)
{
int ret;
struct stream *s;
- u_char response_keep;
+ uint8_t response_keep;
if (zclient_debug)
zlog_debug("Getting Label Chunk");
stream_put_in_addr(s, &pw->nexthop.ipv4);
break;
case AF_INET6:
- stream_write(s, (u_char *)&pw->nexthop.ipv6, 16);
+ stream_write(s, (uint8_t *)&pw->nexthop.ipv6, 16);
break;
default:
zlog_err("%s: unknown af", __func__);
struct stream *ns;
zlog_warn(
"%s: message size %u exceeds buffer size %lu, expanding...",
- __func__, length, (u_long)STREAM_SIZE(zclient->ibuf));
+ __func__, length,
+ (unsigned long)STREAM_SIZE(zclient->ibuf));
ns = stream_new(length);
stream_copy(ns, zclient->ibuf);
stream_free(zclient->ibuf);
}
void zclient_redistribute(int command, struct zclient *zclient, afi_t afi,
- int type, u_short instance, vrf_id_t vrf_id)
+ int type, unsigned short instance, vrf_id_t vrf_id)
{
if (instance) {
} zebra_message_types_t;
struct redist_proto {
- u_char enabled;
+ uint8_t enabled;
struct list *instances;
};
struct thread *t_write;
/* Redistribute information. */
- u_char redist_default; /* clients protocol */
- u_short instance;
+ uint8_t redist_default; /* clients protocol */
+ unsigned short instance;
struct redist_proto mi_redist[AFI_MAX][ZEBRA_ROUTE_MAX];
vrf_bitmap_t redist[AFI_MAX][ZEBRA_ROUTE_MAX];
* to encode/decode.
*/
struct zapi_route {
- u_char type;
- u_short instance;
+ uint8_t type;
+ unsigned short instance;
- u_int32_t flags;
+ uint32_t flags;
- u_char message;
+ uint8_t message;
/*
* This is an enum but we are going to treat it as a uint8_t
struct prefix prefix;
struct prefix_ipv6 src_prefix;
- u_int16_t nexthop_num;
+ uint16_t nexthop_num;
struct zapi_nexthop nexthops[MULTIPATH_NUM];
- u_char distance;
+ uint8_t distance;
- u_int32_t metric;
+ uint32_t metric;
route_tag_t tag;
- u_int32_t mtu;
+ uint32_t mtu;
vrf_id_t vrf_id;
/* Zebra IPv4 route message API. */
struct zapi_ipv4 {
- u_char type;
- u_short instance;
+ uint8_t type;
+ unsigned short instance;
- u_int32_t flags;
+ uint32_t flags;
- u_char message;
+ uint8_t message;
safi_t safi;
- u_char nexthop_num;
+ uint8_t nexthop_num;
struct in_addr **nexthop;
- u_char ifindex_num;
+ uint8_t ifindex_num;
ifindex_t *ifindex;
- u_char label_num;
+ uint8_t label_num;
unsigned int *label;
- u_char distance;
+ uint8_t distance;
- u_int32_t metric;
+ uint32_t metric;
route_tag_t tag;
- u_int32_t mtu;
+ uint32_t mtu;
vrf_id_t vrf_id;
};
zclient_new_notify((A), &zclient_options_default); \
CPP_WARN("Please transition to using zclient_new_notify");
-extern void zclient_init(struct zclient *, int, u_short,
+extern void zclient_init(struct zclient *, int, unsigned short,
struct zebra_privs_t *privs);
extern int zclient_start(struct zclient *);
extern void zclient_stop(struct zclient *);
extern int zclient_socket_connect(struct zclient *);
-extern u_short *redist_check_instance(struct redist_proto *, u_short);
-extern void redist_add_instance(struct redist_proto *, u_short);
-extern void redist_del_instance(struct redist_proto *, u_short);
+extern unsigned short *redist_check_instance(struct redist_proto *,
+ unsigned short);
+extern void redist_add_instance(struct redist_proto *, unsigned short);
+extern void redist_del_instance(struct redist_proto *, unsigned short);
/*
* Send to zebra that the specified vrf is using label to resolve
/* Send redistribute command to zebra daemon. Do not update zclient state. */
extern int zebra_redistribute_send(int command, struct zclient *, afi_t,
- int type, u_short instance, vrf_id_t vrf_id);
+ int type, unsigned short instance,
+ vrf_id_t vrf_id);
/* If state has changed, update state and call zebra_redistribute_send. */
extern void zclient_redistribute(int command, struct zclient *, afi_t, int type,
- u_short instance, vrf_id_t vrf_id);
+ unsigned short instance, vrf_id_t vrf_id);
/* If state has changed, update state and send the command to zebra. */
extern void zclient_redistribute_default(int command, struct zclient *,
* - a marker mismatch was detected
* - header size field specified more data than could be read
*/
-extern int zclient_read_header(struct stream *s, int sock, u_int16_t *size,
- u_char *marker, u_char *version,
- vrf_id_t *vrf_id, u_int16_t *cmd);
+extern int zclient_read_header(struct stream *s, int sock, uint16_t *size,
+ uint8_t *marker, uint8_t *version,
+ vrf_id_t *vrf_id, uint16_t *cmd);
/*
* Parse header from ZAPI message stream into struct zmsghdr.
* This function assumes the stream getp points at the first byte of the header.
#endif
/* clang-format on */
-extern int zapi_ipv4_route(u_char, struct zclient *, struct prefix_ipv4 *,
+extern int zapi_ipv4_route(uint8_t, struct zclient *, struct prefix_ipv4 *,
struct zapi_ipv4 *) __attribute__((deprecated));
extern struct interface *zebra_interface_link_params_read(struct stream *);
extern size_t zebra_interface_link_params_write(struct stream *,
struct interface *);
extern int lm_label_manager_connect(struct zclient *zclient);
-extern int lm_get_label_chunk(struct zclient *zclient, u_char keep,
+extern int lm_get_label_chunk(struct zclient *zclient, uint8_t keep,
uint32_t chunk_size, uint32_t *start,
uint32_t *end);
extern int lm_release_label_chunk(struct zclient *zclient, uint32_t start,
/* IPv6 prefix add and delete function prototype. */
struct zapi_ipv6 {
- u_char type;
- u_short instance;
+ uint8_t type;
+ unsigned short instance;
- u_int32_t flags;
+ uint32_t flags;
- u_char message;
+ uint8_t message;
safi_t safi;
- u_char nexthop_num;
+ uint8_t nexthop_num;
struct in6_addr **nexthop;
- u_char ifindex_num;
+ uint8_t ifindex_num;
ifindex_t *ifindex;
- u_char label_num;
+ uint8_t label_num;
unsigned int *label;
- u_char distance;
+ uint8_t distance;
- u_int32_t metric;
+ uint32_t metric;
route_tag_t tag;
- u_int32_t mtu;
+ uint32_t mtu;
vrf_id_t vrf_id;
};
-extern int zapi_ipv6_route(u_char cmd, struct zclient *zclient,
+extern int zapi_ipv6_route(uint8_t cmd, struct zclient *zclient,
struct prefix_ipv6 *p, struct prefix_ipv6 *src_p,
struct zapi_ipv6 *api) __attribute__((deprecated));
-extern int zapi_ipv4_route_ipv6_nexthop(u_char, struct zclient *,
+extern int zapi_ipv4_route_ipv6_nexthop(uint8_t, struct zclient *,
struct prefix_ipv4 *,
struct zapi_ipv6 *)
__attribute__((deprecated));
-extern int zclient_route_send(u_char, struct zclient *, struct zapi_route *);
+extern int zclient_route_send(uint8_t, struct zclient *, struct zapi_route *);
extern int zclient_send_rnh(struct zclient *zclient, int command,
struct prefix *p, bool exact_match,
vrf_id_t vrf_id);
-extern int zapi_route_encode(u_char, struct stream *, struct zapi_route *);
+extern int zapi_route_encode(uint8_t, struct stream *, struct zapi_route *);
extern int zapi_route_decode(struct stream *, struct zapi_route *);
bool zapi_route_notify_decode(struct stream *s, struct prefix *p,
uint32_t *tableid,
#ifdef SUNOS_5
#define _XPG4_2
-typedef unsigned int u_int32_t;
-typedef unsigned short u_int16_t;
-typedef unsigned char u_int8_t;
+typedef unsigned int uint32_t;
+typedef unsigned short uint16_t;
+typedef unsigned char uint8_t;
#endif /* SUNOS_5 */
#include <unistd.h>
((atomic_store_explicit(PV, 0, memory_order_seq_cst)))
/* Zebra types. Used in Zserv message header. */
-typedef u_int16_t zebra_size_t;
-typedef u_int16_t zebra_command_t;
+typedef uint16_t zebra_size_t;
+typedef uint16_t zebra_command_t;
/* VRF ID type. */
typedef uint32_t vrf_id_t;
debugf(NHRP_DEBUG_IF, "%s: GRE: %x %x %x", ifp->name,
nifp->grekey, nifp->linkidx, saddr.s_addr);
if (saddr.s_addr)
- sockunion_set(&nbma, AF_INET, (u_char *)&saddr.s_addr,
+ sockunion_set(&nbma, AF_INET, (uint8_t *)&saddr.s_addr,
sizeof(saddr.s_addr));
else if (!nbmaifp && nifp->linkidx != IFINDEX_INTERNAL)
nbmaifp =
struct ospf6_inter_prefix_lsa *prefix_lsa;
struct ospf6_inter_router_lsa *router_lsa;
struct ospf6_route_table *summary_table = NULL;
- u_int16_t type;
+ uint16_t type;
char buf[PREFIX2STR_BUFFER];
int is_debug = 0;
OSPF6_ABR_RANGE_CLEAR_COST(range);
}
-static inline u_int32_t ospf6_abr_range_compute_cost(struct ospf6_route *range,
- struct ospf6 *o)
+static inline uint32_t ospf6_abr_range_compute_cost(struct ospf6_route *range,
+ struct ospf6 *o)
{
struct ospf6_route *ro;
- u_int32_t cost = 0;
+ uint32_t cost = 0;
for (ro = ospf6_route_match_head(&range->prefix, o->route_table); ro;
ro = ospf6_route_match_next(&range->prefix, ro)) {
}
static inline int
-ospf6_abr_range_summary_needs_update(struct ospf6_route *range, u_int32_t cost)
+ospf6_abr_range_summary_needs_update(struct ospf6_route *range, uint32_t cost)
{
int redo_summary = 0;
static void ospf6_abr_range_update(struct ospf6_route *range)
{
- u_int32_t cost = 0;
+ uint32_t cost = 0;
struct listnode *node, *nnode;
struct ospf6_area *oa;
int summary_orig = 0;
struct ospf6_route_table *table = NULL;
struct ospf6_route *range, *route, *old = NULL;
struct ospf6_route *abr_entry;
- u_char type = 0;
+ uint8_t type = 0;
char options[3] = {0, 0, 0};
- u_int8_t prefix_options = 0;
- u_int32_t cost = 0;
- u_char router_bits = 0;
+ uint8_t prefix_options = 0;
+ uint32_t cost = 0;
+ uint8_t router_bits = 0;
char buf[PREFIX2STR_BUFFER];
int is_debug = 0;
struct ospf6_inter_prefix_lsa *prefix_lsa = NULL;
}
}
-void ospf6_abr_examin_brouter(u_int32_t router_id)
+void ospf6_abr_examin_brouter(uint32_t router_id)
{
struct ospf6_lsa *lsa;
struct ospf6_area *oa;
- u_int16_t type;
+ uint16_t type;
if (ospf6_is_router_abr(ospf6))
oa = ospf6->backbone;
void ospf6_abr_reimport(struct ospf6_area *oa)
{
struct ospf6_lsa *lsa;
- u_int16_t type;
+ uint16_t type;
type = htons(OSPF6_LSTYPE_INTER_ROUTER);
for (ALL_LSDB_TYPED(oa->lsdb, type, lsa))
lsa->header);
vty_out(vty, " Metric: %lu\n",
- (u_long)OSPF6_ABR_SUMMARY_METRIC(prefix_lsa));
+ (unsigned long)OSPF6_ABR_SUMMARY_METRIC(prefix_lsa));
ospf6_prefix_options_printbuf(prefix_lsa->prefix.prefix_options, buf,
sizeof(buf));
ospf6_options_printbuf(router_lsa->options, buf, sizeof(buf));
vty_out(vty, " Options: %s\n", buf);
vty_out(vty, " Metric: %lu\n",
- (u_long)OSPF6_ABR_SUMMARY_METRIC(router_lsa));
+ (unsigned long)OSPF6_ABR_SUMMARY_METRIC(router_lsa));
inet_ntop(AF_INET, &router_lsa->router_id, buf, sizeof(buf));
vty_out(vty, " Destination Router ID: %s\n", buf);
/* Inter-Area-Prefix-LSA */
#define OSPF6_INTER_PREFIX_LSA_MIN_SIZE 4U /* w/o IPv6 prefix */
struct ospf6_inter_prefix_lsa {
- u_int32_t metric;
+ uint32_t metric;
struct ospf6_prefix prefix;
};
/* Inter-Area-Router-LSA */
#define OSPF6_INTER_ROUTER_LSA_FIX_SIZE 12U
struct ospf6_inter_router_lsa {
- u_char mbz;
- u_char options[3];
- u_int32_t metric;
- u_int32_t router_id;
+ uint8_t mbz;
+ uint8_t options[3];
+ uint32_t metric;
+ uint32_t router_id;
};
#define OSPF6_ABR_SUMMARY_METRIC(E) (ntohl ((E)->metric & htonl (0x00ffffff)))
extern void ospf6_abr_examin_summary(struct ospf6_lsa *lsa,
struct ospf6_area *oa);
extern void ospf6_abr_defaults_to_stub(struct ospf6 *);
-extern void ospf6_abr_examin_brouter(u_int32_t router_id);
+extern void ospf6_abr_examin_brouter(uint32_t router_id);
extern void ospf6_abr_reimport(struct ospf6_area *oa);
extern void ospf6_abr_range_reset_cost(struct ospf6 *ospf6);
extern void ospf6_abr_prefix_resummarize(struct ospf6 *ospf6);
* @param o - ospf6 instance
* @param df - display format for area ID
*/
-struct ospf6_area *ospf6_area_create(u_int32_t area_id, struct ospf6 *o, int df)
+struct ospf6_area *ospf6_area_create(uint32_t area_id, struct ospf6 *o, int df)
{
struct ospf6_area *oa;
XFREE(MTYPE_OSPF6_AREA, oa);
}
-struct ospf6_area *ospf6_area_lookup(u_int32_t area_id, struct ospf6 *ospf6)
+struct ospf6_area *ospf6_area_lookup(uint32_t area_id, struct ospf6 *ospf6)
{
struct ospf6_area *oa;
struct listnode *n;
#define OSPF6_CMD_AREA_GET(str, oa) \
{ \
char *ep; \
- u_int32_t area_id = htonl(strtoul(str, &ep, 10)); \
+ uint32_t area_id = htonl(strtoul(str, &ep, 10)); \
if (*ep && inet_pton(AF_INET, str, &area_id) != 1) { \
vty_out(vty, "Malformed Area-ID: %s\n", str); \
return CMD_SUCCESS; \
struct ospf6_area *oa;
struct prefix prefix;
struct ospf6_route *range;
- u_int32_t cost = OSPF_AREA_RANGE_COST_UNSPEC;
+ uint32_t cost = OSPF_AREA_RANGE_COST_UNSPEC;
OSPF6_CMD_AREA_GET(argv[idx_ipv4]->arg, oa);
"Show SPF tree\n")
{
int idx_ipv4 = 4;
- u_int32_t area_id;
+ uint32_t area_id;
struct ospf6_area *oa;
struct ospf6_vertex *root;
struct ospf6_route *route;
{
int idx_ipv4 = 5;
int idx_ipv4_2 = 7;
- u_int32_t area_id;
+ uint32_t area_id;
struct ospf6_area *oa;
struct ospf6_vertex *root;
struct ospf6_route *route;
struct prefix prefix;
- u_int32_t router_id;
+ uint32_t router_id;
struct ospf6_route_table *spf_table;
unsigned char tmp_debug_ospf6_spf = 0;
struct ospf6 *ospf6;
/* Area-ID */
- u_int32_t area_id;
+ uint32_t area_id;
#define OSPF6_AREA_FMT_DOTTEDQUAD 1
#define OSPF6_AREA_FMT_DECIMAL 2
char name[16];
/* flag */
- u_char flag;
+ uint8_t flag;
/* OSPF Option */
- u_char options[3];
+ uint8_t options[3];
/* Summary routes to be originated (includes Configured Address Ranges)
*/
struct ospf6_route_table *spf_table;
struct ospf6_route_table *route_table;
- u_int32_t spf_calculation; /* SPF calculation count */
+ uint32_t spf_calculation; /* SPF calculation count */
struct thread *thread_router_lsa;
struct thread *thread_intra_prefix_lsa;
- u_int32_t router_lsa_size_limit;
+ uint32_t router_lsa_size_limit;
/* Area announce list */
struct {
/* prototypes */
extern int ospf6_area_cmp(void *va, void *vb);
-extern struct ospf6_area *ospf6_area_create(u_int32_t, struct ospf6 *, int);
+extern struct ospf6_area *ospf6_area_create(uint32_t, struct ospf6 *, int);
extern void ospf6_area_delete(struct ospf6_area *);
-extern struct ospf6_area *ospf6_area_lookup(u_int32_t, struct ospf6 *);
+extern struct ospf6_area *ospf6_area_lookup(uint32_t, struct ospf6 *);
extern void ospf6_area_enable(struct ospf6_area *);
extern void ospf6_area_disable(struct ospf6_area *);
void ospf6_asbr_lsentry_add(struct ospf6_route *asbr_entry)
{
struct ospf6_lsa *lsa;
- u_int16_t type;
- u_int32_t router;
+ uint16_t type;
+ uint32_t router;
if (!CHECK_FLAG(asbr_entry->flag, OSPF6_ROUTE_BEST)) {
char buf[16];
void ospf6_asbr_lsentry_remove(struct ospf6_route *asbr_entry)
{
struct ospf6_lsa *lsa;
- u_int16_t type;
- u_int32_t router;
+ uint16_t type;
+ uint32_t router;
type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
router = ospf6_linkstate_prefix_adv_router(&asbr_entry->prefix);
}
void ospf6_asbr_redistribute_add(int type, ifindex_t ifindex,
- struct prefix *prefix, u_int nexthop_num,
+ struct prefix *prefix,
+ unsigned int nexthop_num,
struct in6_addr *nexthop, route_tag_t tag)
{
int ret;
static void *ospf6_routemap_rule_set_metric_compile(const char *arg)
{
- u_int32_t metric;
+ uint32_t metric;
char *endp;
metric = strtoul(arg, &endp, 0);
if (metric > OSPF_LS_INFINITY || *endp != '\0')
vty_out(vty, " Bits: %s\n", buf);
vty_out(vty, " Metric: %5lu\n",
- (u_long)OSPF6_ASBR_METRIC(external));
+ (unsigned long)OSPF6_ASBR_METRIC(external));
ospf6_prefix_options_printbuf(external->prefix.prefix_options, buf,
sizeof(buf));
{
struct ospf6_external_info *info = route->route_option;
char prefix[PREFIX2STR_BUFFER], id[16], forwarding[64];
- u_int32_t tmp_id;
+ uint32_t tmp_id;
prefix2str(&route->prefix, prefix, sizeof(prefix));
tmp_id = ntohl(info->id);
vty_out(vty, "%c %-32s %-15s type-%d %5lu %s\n",
zebra_route_char(info->type), prefix, id,
route->path.metric_type,
- (u_long)(route->path.metric_type == 2 ? route->path.u.cost_e2
- : route->path.cost),
+ (unsigned long)(route->path.metric_type == 2
+ ? route->path.u.cost_e2
+ : route->path.cost),
forwarding);
}
int type;
/* Originating Link State ID */
- u_int32_t id;
+ uint32_t id;
struct in6_addr forwarding;
/* AS-External-LSA */
#define OSPF6_AS_EXTERNAL_LSA_MIN_SIZE 4U /* w/o IPv6 prefix */
struct ospf6_as_external_lsa {
- u_int32_t bits_metric;
+ uint32_t bits_metric;
struct ospf6_prefix prefix;
/* followed by none or one forwarding address */
extern int ospf6_asbr_is_asbr(struct ospf6 *o);
extern void ospf6_asbr_redistribute_add(int type, ifindex_t ifindex,
struct prefix *prefix,
- u_int nexthop_num,
+ unsigned int nexthop_num,
struct in6_addr *nexthop,
route_tag_t tag);
extern void ospf6_asbr_redistribute_remove(int type, ifindex_t ifindex,
* ospf6_bfd_if_param_set - Set the configured BFD paramter values for
* interface.
*/
-static void ospf6_bfd_if_param_set(struct ospf6_interface *oi, u_int32_t min_rx,
- u_int32_t min_tx, u_int8_t detect_mult,
+static void ospf6_bfd_if_param_set(struct ospf6_interface *oi, uint32_t min_rx,
+ uint32_t min_tx, uint8_t detect_mult,
int defaults)
{
int command = 0;
int idx_number_2 = 4;
int idx_number_3 = 5;
struct ospf6_interface *oi;
- 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;
assert(ifp);
ospf6_interface_lsdb_hook(lsa, ospf6_lsremove_to_spf_reason(lsa));
}
-static u_char ospf6_default_iftype(struct interface *ifp)
+static uint8_t ospf6_default_iftype(struct interface *ifp)
{
if (if_is_pointopoint(ifp))
return OSPF_IFTYPE_POINTOPOINT;
return OSPF_IFTYPE_BROADCAST;
}
-static u_int32_t ospf6_interface_get_cost(struct ospf6_interface *oi)
+static uint32_t ospf6_interface_get_cost(struct ospf6_interface *oi)
{
/* If all else fails, use default OSPF cost */
- u_int32_t cost;
- u_int32_t bw, refbw;
+ uint32_t cost;
+ uint32_t bw, refbw;
/* interface speed and bw can be 0 in some platforms,
* use ospf default bw. If bw is configured then it would
if (CHECK_FLAG(oi->flag, OSPF6_INTERFACE_NOAUTOCOST))
cost = oi->cost;
else {
- cost = (u_int32_t)((double)refbw / (double)bw + (double)0.5);
+ cost = (uint32_t)((double)refbw / (double)bw + (double)0.5);
if (cost < 1)
cost = 1;
else if (cost > UINT32_MAX)
static void ospf6_interface_recalculate_cost(struct ospf6_interface *oi)
{
- u_int32_t newcost;
+ uint32_t newcost;
newcost = ospf6_interface_get_cost(oi);
if (newcost == oi->cost)
OSPF6_INTRA_PREFIX_LSA_SCHEDULE_STUB(oi->area);
}
-static void ospf6_interface_state_change(u_char next_state,
+static void ospf6_interface_state_change(uint8_t next_state,
struct ospf6_interface *oi)
{
- u_char prev_state;
+ uint8_t prev_state;
prev_state = oi->state;
oi->state = next_state;
return a;
}
-static u_char dr_election(struct ospf6_interface *oi)
+static uint8_t dr_election(struct ospf6_interface *oi)
{
struct listnode *node, *nnode;
struct ospf6_neighbor *on, *drouter, *bdrouter, myself;
struct ospf6_neighbor *best_drouter, *best_bdrouter;
- u_char next_state = 0;
+ uint8_t next_state = 0;
drouter = bdrouter = NULL;
best_drouter = best_bdrouter = NULL;
struct ospf6_area *oa;
struct ospf6_interface *oi;
struct listnode *i, *j;
- u_int32_t refbw;
+ uint32_t refbw;
refbw = strtol(argv[idx_number]->arg, NULL, 10);
if (refbw < 1 || refbw > 4294967) {
/* Interface ID; use interface->ifindex */
/* ospf6 instance id */
- u_char instance_id;
+ uint8_t instance_id;
/* I/F transmission delay */
- u_int32_t transdelay;
+ uint32_t transdelay;
/* Network Type */
- u_char type;
+ uint8_t type;
/* Router Priority */
- u_char priority;
+ uint8_t priority;
/* Time Interval */
- u_int16_t hello_interval;
- u_int16_t dead_interval;
- u_int32_t rxmt_interval;
+ uint16_t hello_interval;
+ uint16_t dead_interval;
+ uint32_t rxmt_interval;
- u_int32_t state_change;
+ uint32_t state_change;
/* Cost */
- u_int32_t cost;
+ uint32_t cost;
/* I/F MTU */
- u_int32_t ifmtu;
+ uint32_t ifmtu;
/* Configured MTU */
- u_int32_t c_ifmtu;
+ uint32_t c_ifmtu;
/* Interface State */
- u_char state;
+ uint8_t state;
/* Interface socket setting trial counter, resets on success */
- u_char sso_try_cnt;
+ uint8_t sso_try_cnt;
/* OSPF6 Interface flag */
char flag;
/* MTU mismatch check */
- u_char mtu_ignore;
+ uint8_t mtu_ignore;
/* Decision of DR Election */
- u_int32_t drouter;
- u_int32_t bdrouter;
- u_int32_t prev_drouter;
- u_int32_t prev_bdrouter;
+ uint32_t drouter;
+ uint32_t bdrouter;
+ uint32_t prev_drouter;
+ uint32_t prev_bdrouter;
/* Linklocal LSA Database: includes Link-LSA */
struct ospf6_lsdb *lsdb;
void *bfd_info;
/* Statistics Fields */
- u_int32_t hello_in;
- u_int32_t hello_out;
- u_int32_t db_desc_in;
- u_int32_t db_desc_out;
- u_int32_t ls_req_in;
- u_int32_t ls_req_out;
- u_int32_t ls_upd_in;
- u_int32_t ls_upd_out;
- u_int32_t ls_ack_in;
- u_int32_t ls_ack_out;
- u_int32_t discarded;
+ uint32_t hello_in;
+ uint32_t hello_out;
+ uint32_t db_desc_in;
+ uint32_t db_desc_out;
+ uint32_t ls_req_in;
+ uint32_t ls_req_out;
+ uint32_t ls_upd_in;
+ uint32_t ls_upd_out;
+ uint32_t ls_ack_in;
+ uint32_t ls_ack_out;
+ uint32_t discarded;
QOBJ_FIELDS
};
#include "ospf6_spf.h"
unsigned char conf_debug_ospf6_brouter = 0;
-u_int32_t conf_debug_ospf6_brouter_specific_router_id;
-u_int32_t conf_debug_ospf6_brouter_specific_area_id;
+uint32_t conf_debug_ospf6_brouter_specific_router_id;
+uint32_t conf_debug_ospf6_brouter_specific_area_id;
#define MAX_LSA_PAYLOAD (1024 + 256)
/******************************/
struct ospf6_lsa_header *lsa_header;
struct ospf6_lsa *lsa;
- u_int32_t link_state_id = 0;
+ uint32_t link_state_id = 0;
struct listnode *node, *nnode;
struct listnode *j;
struct ospf6_interface *oi;
struct ospf6_neighbor *on, *drouter = NULL;
struct ospf6_router_lsa *router_lsa;
struct ospf6_router_lsdesc *lsdesc;
- u_int16_t type;
- u_int32_t router;
+ uint16_t type;
+ uint32_t router;
int count;
oa = (struct ospf6_area *)THREAD_ARG(thread);
struct ospf6_neighbor *on;
struct ospf6_link_lsa *link_lsa;
struct listnode *i;
- u_int16_t type;
+ uint16_t type;
oi = (struct ospf6_interface *)THREAD_ARG(thread);
oi->thread_network_lsa = NULL;
struct ospf6_route_table *route_advertise;
struct ospf6_link_lsa *link_lsa;
char *start, *end, *current;
- u_int16_t type;
+ uint16_t type;
char buf[PREFIX2STR_BUFFER];
oi = (struct ospf6_interface *)THREAD_ARG(thread);
void ospf6_intra_route_calculation(struct ospf6_area *oa)
{
struct ospf6_route *route, *nroute;
- u_int16_t type;
+ uint16_t type;
struct ospf6_lsa *lsa;
void (*hook_add)(struct ospf6_route *) = NULL;
void (*hook_remove)(struct ospf6_route *) = NULL;
static void ospf6_brouter_debug_print(struct ospf6_route *brouter)
{
- u_int32_t brouter_id;
+ uint32_t brouter_id;
char brouter_name[16];
char area_name[16];
char destination[64];
struct ospf6_route *brouter, *nbrouter, *copy;
void (*hook_add)(struct ospf6_route *) = NULL;
void (*hook_remove)(struct ospf6_route *) = NULL;
- u_int32_t brouter_id;
+ uint32_t brouter_id;
char brouter_name[16];
if (IS_OSPF6_DEBUG_BROUTER_SPECIFIC_AREA_ID(oa->area_id))
)
{
int idx_ipv4 = 4;
- u_int32_t router_id;
+ uint32_t router_id;
inet_pton(AF_INET, argv[idx_ipv4]->arg, &router_id);
OSPF6_DEBUG_BROUTER_SPECIFIC_ROUTER_ON(router_id);
return CMD_SUCCESS;
)
{
int idx_ipv4 = 4;
- u_int32_t area_id;
+ uint32_t area_id;
inet_pton(AF_INET, argv[idx_ipv4]->arg, &area_id);
OSPF6_DEBUG_BROUTER_SPECIFIC_AREA_ON(area_id);
return CMD_SUCCESS;
/* Debug option */
extern unsigned char conf_debug_ospf6_brouter;
-extern u_int32_t conf_debug_ospf6_brouter_specific_router_id;
-extern u_int32_t conf_debug_ospf6_brouter_specific_area_id;
+extern uint32_t conf_debug_ospf6_brouter_specific_router_id;
+extern uint32_t conf_debug_ospf6_brouter_specific_area_id;
#define OSPF6_DEBUG_BROUTER_SUMMARY 0x01
#define OSPF6_DEBUG_BROUTER_SPECIFIC_ROUTER 0x02
#define OSPF6_DEBUG_BROUTER_SPECIFIC_AREA 0x04
/* Router-LSA */
#define OSPF6_ROUTER_LSA_MIN_SIZE 4U
struct ospf6_router_lsa {
- u_char bits;
- u_char options[3];
+ uint8_t bits;
+ uint8_t options[3];
/* followed by ospf6_router_lsdesc(s) */
};
/* Link State Description in Router-LSA */
#define OSPF6_ROUTER_LSDESC_FIX_SIZE 16U
struct ospf6_router_lsdesc {
- u_char type;
- u_char reserved;
- u_int16_t metric; /* output cost */
- u_int32_t interface_id;
- u_int32_t neighbor_interface_id;
- u_int32_t neighbor_router_id;
+ uint8_t type;
+ uint8_t reserved;
+ uint16_t metric; /* output cost */
+ uint32_t interface_id;
+ uint32_t neighbor_interface_id;
+ uint32_t neighbor_router_id;
};
#define OSPF6_ROUTER_LSDESC_POINTTOPOINT 1
/* Network-LSA */
#define OSPF6_NETWORK_LSA_MIN_SIZE 4U
struct ospf6_network_lsa {
- u_char reserved;
- u_char options[3];
+ uint8_t reserved;
+ uint8_t options[3];
/* followed by ospf6_netowrk_lsd(s) */
};
/* Link State Description in Router-LSA */
#define OSPF6_NETWORK_LSDESC_FIX_SIZE 4U
struct ospf6_network_lsdesc {
- u_int32_t router_id;
+ uint32_t router_id;
};
#define NETWORK_LSDESC_GET_NBR_ROUTERID(x) \
(((struct ospf6_network_lsdesc *)(x))->router_id)
/* Link-LSA */
#define OSPF6_LINK_LSA_MIN_SIZE 24U /* w/o 1st IPv6 prefix */
struct ospf6_link_lsa {
- u_char priority;
- u_char options[3];
+ uint8_t priority;
+ uint8_t options[3];
struct in6_addr linklocal_addr;
- u_int32_t prefix_num;
+ uint32_t prefix_num;
/* followed by ospf6 prefix(es) */
};
/* Intra-Area-Prefix-LSA */
#define OSPF6_INTRA_PREFIX_LSA_MIN_SIZE 12U /* w/o 1st IPv6 prefix */
struct ospf6_intra_prefix_lsa {
- u_int16_t prefix_num;
- u_int16_t ref_type;
- u_int32_t ref_id;
- u_int32_t ref_adv_router;
+ uint16_t prefix_num;
+ uint16_t ref_type;
+ uint32_t ref_id;
+ uint32_t ref_adv_router;
/* followed by ospf6 prefix(es) */
};
} while (0)
/* Function Prototypes */
-extern char *ospf6_router_lsdesc_lookup(u_char type, u_int32_t interface_id,
- u_int32_t neighbor_interface_id,
- u_int32_t neighbor_router_id,
+extern char *ospf6_router_lsdesc_lookup(uint8_t type, uint32_t interface_id,
+ uint32_t neighbor_interface_id,
+ uint32_t neighbor_router_id,
struct ospf6_lsa *lsa);
-extern char *ospf6_network_lsdesc_lookup(u_int32_t router_id,
+extern char *ospf6_network_lsdesc_lookup(uint32_t router_id,
struct ospf6_lsa *lsa);
extern int ospf6_router_is_stub_router(struct ospf6_lsa *lsa);
static int ospf6_unknown_lsa_show(struct vty *vty, struct ospf6_lsa *lsa)
{
- u_char *start, *end, *current;
+ uint8_t *start, *end, *current;
char byte[4];
- start = (u_char *)lsa->header + sizeof(struct ospf6_lsa_header);
- end = (u_char *)lsa->header + ntohs(lsa->header->length);
+ start = (uint8_t *)lsa->header + sizeof(struct ospf6_lsa_header);
+ end = (uint8_t *)lsa->header + ntohs(lsa->header->length);
vty_out(vty, " Unknown contents:\n");
for (current = start; current < end; current++) {
vector_set_index(ospf6_lsa_handler_vector, index, (void *)handler);
}
-const struct ospf6_lsa_handler *ospf6_get_lsa_handler(u_int16_t type)
+const struct ospf6_lsa_handler *ospf6_get_lsa_handler(uint16_t type)
{
const struct ospf6_lsa_handler *handler = NULL;
unsigned int index = ntohs(type) & OSPF6_LSTYPE_FCODE_MASK;
return handler;
}
-const char *ospf6_lstype_name(u_int16_t type)
+const char *ospf6_lstype_name(uint16_t type)
{
static char buf[8];
const struct ospf6_lsa_handler *handler;
return buf;
}
-const char *ospf6_lstype_short_name(u_int16_t type)
+const char *ospf6_lstype_short_name(uint16_t type)
{
static char buf[8];
const struct ospf6_lsa_handler *handler;
return buf;
}
-u_char ospf6_lstype_debug(u_int16_t type)
+uint8_t ospf6_lstype_debug(uint16_t type)
{
const struct ospf6_lsa_handler *handler;
handler = ospf6_get_lsa_handler(type);
/* this function calculates current age from its birth,
then update age field of LSA header. return value is current age */
-u_int16_t ospf6_lsa_age_current(struct ospf6_lsa *lsa)
+uint16_t ospf6_lsa_age_current(struct ospf6_lsa *lsa)
{
struct timeval now;
- u_int32_t ulage;
- u_int16_t age;
+ uint32_t ulage;
+ uint16_t age;
assert(lsa);
assert(lsa->header);
}
/* update age field of LSA header with adding InfTransDelay */
-void ospf6_lsa_age_update_to_send(struct ospf6_lsa *lsa, u_int32_t transdelay)
+void ospf6_lsa_age_update_to_send(struct ospf6_lsa *lsa, uint32_t transdelay)
{
unsigned short age;
int ospf6_lsa_compare(struct ospf6_lsa *a, struct ospf6_lsa *b)
{
int32_t seqnuma, seqnumb;
- u_int16_t cksuma, cksumb;
- u_int16_t agea, ageb;
+ uint16_t cksuma, cksumb;
+ uint16_t agea, ageb;
assert(a && a->header);
assert(b && b->header);
zlog_debug(" [%s Id:%s Adv:%s]", ospf6_lstype_name(header->type), id,
adv_router);
zlog_debug(" Age: %4hu SeqNum: %#08lx Cksum: %04hx Len: %d",
- ntohs(header->age), (u_long)ntohl(header->seqnum),
+ ntohs(header->age), (unsigned long)ntohl(header->seqnum),
ntohs(header->checksum), ntohs(header->length));
}
vty_out(vty, "%-4s %-15s%-15s%4hu %8lx %30s\n",
ospf6_lstype_short_name(lsa->header->type), id,
adv_router, ospf6_lsa_age_current(lsa),
- (u_long)ntohl(lsa->header->seqnum),
+ (unsigned long)ntohl(lsa->header->seqnum),
handler->lh_get_prefix_str(lsa, buf, sizeof(buf), 0));
} else if (type != OSPF6_LSTYPE_UNKNOWN) {
sprintf(tmpbuf, "%-4s %-15s%-15s%4hu %8lx",
ospf6_lstype_short_name(lsa->header->type), id,
adv_router, ospf6_lsa_age_current(lsa),
- (u_long)ntohl(lsa->header->seqnum));
+ (unsigned long)ntohl(lsa->header->seqnum));
while (handler->lh_get_prefix_str(lsa, buf, sizeof(buf), cnt)
!= NULL) {
vty_out(vty, "%-4s %-15s%-15s%4hu %8lx\n",
ospf6_lstype_short_name(lsa->header->type), id,
adv_router, ospf6_lsa_age_current(lsa),
- (u_long)ntohl(lsa->header->seqnum));
+ (unsigned long)ntohl(lsa->header->seqnum));
}
}
void ospf6_lsa_show_dump(struct vty *vty, struct ospf6_lsa *lsa)
{
- u_char *start, *end, *current;
+ uint8_t *start, *end, *current;
char byte[4];
- start = (u_char *)lsa->header;
- end = (u_char *)lsa->header + ntohs(lsa->header->length);
+ start = (uint8_t *)lsa->header;
+ end = (uint8_t *)lsa->header + ntohs(lsa->header->length);
vty_out(vty, "\n");
vty_out(vty, "%s:\n", lsa->name);
vty_out(vty, "Link State ID: %s\n", id);
vty_out(vty, "Advertising Router: %s\n", adv_router);
vty_out(vty, "LS Sequence Number: %#010lx\n",
- (u_long)ntohl(lsa->header->seqnum));
+ (unsigned long)ntohl(lsa->header->seqnum));
vty_out(vty, "CheckSum: %#06hx Length: %hu\n",
ntohs(lsa->header->checksum), ntohs(lsa->header->length));
vty_out(vty, "Flag: %x \n", lsa->flag);
vty_out(vty, "Link State ID: %s\n", id);
vty_out(vty, "Advertising Router: %s\n", adv_router);
vty_out(vty, "LS Sequence Number: %#010lx\n",
- (u_long)ntohl(lsa->header->seqnum));
+ (unsigned long)ntohl(lsa->header->seqnum));
vty_out(vty, "CheckSum: %#06hx Length: %hu\n",
ntohs(lsa->header->checksum), ntohs(lsa->header->length));
vty_out(vty, "Duration: %s\n", duration);
{
struct ospf6_lsa *lsa = NULL;
struct ospf6_lsa_header *new_header = NULL;
- u_int16_t lsa_size = 0;
+ uint16_t lsa_size = 0;
/* size of the entire LSA */
lsa_size = ntohs(header->length); /* XXX vulnerable */
one-based. */
unsigned short ospf6_lsa_checksum(struct ospf6_lsa_header *lsa_header)
{
- u_char *buffer = (u_char *)&lsa_header->type;
- int type_offset = buffer - (u_char *)&lsa_header->age; /* should be 2 */
+ uint8_t *buffer = (uint8_t *)&lsa_header->type;
+ int type_offset =
+ buffer - (uint8_t *)&lsa_header->age; /* should be 2 */
/* Skip the AGE field */
- u_int16_t len = ntohs(lsa_header->length) - type_offset;
+ uint16_t len = ntohs(lsa_header->length) - type_offset;
/* Checksum offset starts from "type" field, not the beginning of the
lsa_header struct. The offset is 14, rather than 16. */
- int checksum_offset = (u_char *)&lsa_header->checksum - buffer;
+ int checksum_offset = (uint8_t *)&lsa_header->checksum - buffer;
return (unsigned short)fletcher_checksum(buffer, len, checksum_offset);
}
int ospf6_lsa_checksum_valid(struct ospf6_lsa_header *lsa_header)
{
- u_char *buffer = (u_char *)&lsa_header->type;
- int type_offset = buffer - (u_char *)&lsa_header->age; /* should be 2 */
+ uint8_t *buffer = (uint8_t *)&lsa_header->type;
+ int type_offset =
+ buffer - (uint8_t *)&lsa_header->age; /* should be 2 */
/* Skip the AGE field */
- u_int16_t len = ntohs(lsa_header->length) - type_offset;
+ uint16_t len = ntohs(lsa_header->length) - type_offset;
return (fletcher_checksum(buffer, len, FLETCHER_CHECKSUM_VALIDATE)
== 0);
{
int idx_lsa = 4;
int idx_type = 5;
- u_int i;
+ unsigned int i;
struct ospf6_lsa_handler *handler = NULL;
for (i = 0; i < vector_active(ospf6_lsa_handler_vector); i++) {
int config_write_ospf6_debug_lsa(struct vty *vty)
{
- u_int i;
+ unsigned int i;
const struct ospf6_lsa_handler *handler;
for (i = 0; i < vector_active(ospf6_lsa_handler_vector); i++) {
/* LSA Header */
#define OSPF6_LSA_HEADER_SIZE 20U
struct ospf6_lsa_header {
- u_int16_t age; /* LS age */
- u_int16_t type; /* LS type */
- u_int32_t id; /* Link State ID */
- u_int32_t adv_router; /* Advertising Router */
- u_int32_t seqnum; /* LS sequence number */
- u_int16_t checksum; /* LS checksum */
- u_int16_t length; /* LSA length */
+ uint16_t age; /* LS age */
+ uint16_t type; /* LS type */
+ uint32_t id; /* Link State ID */
+ uint32_t adv_router; /* Advertising Router */
+ uint32_t seqnum; /* LS sequence number */
+ uint16_t checksum; /* LS checksum */
+ uint16_t length; /* LSA length */
};
#define OSPF6_LSA_HEADER_END(h) ((caddr_t)(h) + sizeof(struct ospf6_lsa_header))
struct ospf6_lsa_handler {
const struct {
- u_int16_t type; /* host byte order */
+ uint16_t type; /* host byte order */
const char *name;
const char *short_name;
int (*show)(struct vty *, struct ospf6_lsa *);
#define lh_short_name s.short_name
#define lh_show s.show
#define lh_get_prefix_str s.get_prefix_str
- u_char debug;
+ uint8_t debug;
#define lh_debug debug
};
/* Function Prototypes */
-extern const char *ospf6_lstype_name(u_int16_t type);
-extern const char *ospf6_lstype_short_name(u_int16_t type);
-extern u_char ospf6_lstype_debug(u_int16_t type);
+extern const char *ospf6_lstype_name(uint16_t type);
+extern const char *ospf6_lstype_short_name(uint16_t type);
+extern uint8_t ospf6_lstype_debug(uint16_t type);
extern int ospf6_lsa_is_differ(struct ospf6_lsa *lsa1, struct ospf6_lsa *lsa2);
extern int ospf6_lsa_is_changed(struct ospf6_lsa *lsa1, struct ospf6_lsa *lsa2);
-extern u_int16_t ospf6_lsa_age_current(struct ospf6_lsa *);
-extern void ospf6_lsa_age_update_to_send(struct ospf6_lsa *, u_int32_t);
+extern uint16_t ospf6_lsa_age_current(struct ospf6_lsa *);
+extern void ospf6_lsa_age_update_to_send(struct ospf6_lsa *, uint32_t);
extern void ospf6_lsa_premature_aging(struct ospf6_lsa *);
extern int ospf6_lsa_compare(struct ospf6_lsa *, struct ospf6_lsa *);
extern unsigned short ospf6_lsa_checksum(struct ospf6_lsa_header *);
extern int ospf6_lsa_checksum_valid(struct ospf6_lsa_header *);
-extern int ospf6_lsa_prohibited_duration(u_int16_t type, u_int32_t id,
- u_int32_t adv_router, void *scope);
+extern int ospf6_lsa_prohibited_duration(uint16_t type, uint32_t id,
+ uint32_t adv_router, void *scope);
extern void ospf6_install_lsa_handler(const struct ospf6_lsa_handler *handler);
-extern const struct ospf6_lsa_handler *ospf6_get_lsa_handler(u_int16_t type);
+extern const struct ospf6_lsa_handler *ospf6_get_lsa_handler(uint16_t type);
extern void ospf6_lsa_init(void);
extern void ospf6_lsa_terminate(void);
ospf6_lsdb_count_assert(lsdb);
}
-struct ospf6_lsa *ospf6_lsdb_lookup(u_int16_t type, u_int32_t id,
- u_int32_t adv_router,
+struct ospf6_lsa *ospf6_lsdb_lookup(uint16_t type, uint32_t id,
+ uint32_t adv_router,
struct ospf6_lsdb *lsdb)
{
struct route_node *node;
return (struct ospf6_lsa *)node->info;
}
-struct ospf6_lsa *ospf6_lsdb_lookup_next(u_int16_t type, u_int32_t id,
- u_int32_t adv_router,
+struct ospf6_lsa *ospf6_lsdb_lookup_next(uint16_t type, uint32_t id,
+ uint32_t adv_router,
struct ospf6_lsdb *lsdb)
{
struct route_node *node;
}
void ospf6_lsdb_show(struct vty *vty, enum ospf_lsdb_show_level level,
- u_int16_t *type, u_int32_t *id, u_int32_t *adv_router,
+ uint16_t *type, uint32_t *id, uint32_t *adv_router,
struct ospf6_lsdb *lsdb)
{
struct ospf6_lsa *lsa;
}
}
-u_int32_t ospf6_new_ls_id(u_int16_t type, u_int32_t adv_router,
- struct ospf6_lsdb *lsdb)
+uint32_t ospf6_new_ls_id(uint16_t type, uint32_t adv_router,
+ struct ospf6_lsdb *lsdb)
{
struct ospf6_lsa *lsa;
- u_int32_t id = 1, tmp_id;
+ uint32_t id = 1, tmp_id;
/* This routine is curently invoked only for Inter-Prefix LSAs for
* non-summarized routes (no area/range).
id++;
}
- return ((u_int32_t)htonl(id));
+ return ((uint32_t)htonl(id));
}
/* Decide new LS sequence number to originate.
note return value is network byte order */
-u_int32_t ospf6_new_ls_seqnum(u_int16_t type, u_int32_t id,
- u_int32_t adv_router, struct ospf6_lsdb *lsdb)
+uint32_t ospf6_new_ls_seqnum(uint16_t type, uint32_t id, uint32_t adv_router,
+ struct ospf6_lsdb *lsdb)
{
struct ospf6_lsa *lsa;
signed long seqnum = 0;
else
seqnum = (signed long)ntohl(lsa->header->seqnum) + 1;
- return ((u_int32_t)htonl(seqnum));
+ return ((uint32_t)htonl(seqnum));
}
struct ospf6_lsdb {
void *data; /* data structure that holds this lsdb */
struct route_table *table;
- u_int32_t count;
+ uint32_t count;
void (*hook_add)(struct ospf6_lsa *);
void (*hook_remove)(struct ospf6_lsa *);
};
extern struct ospf6_lsdb *ospf6_lsdb_create(void *data);
extern void ospf6_lsdb_delete(struct ospf6_lsdb *lsdb);
-extern struct ospf6_lsa *ospf6_lsdb_lookup(u_int16_t type, u_int32_t id,
- u_int32_t adv_router,
+extern struct ospf6_lsa *ospf6_lsdb_lookup(uint16_t type, uint32_t id,
+ uint32_t adv_router,
struct ospf6_lsdb *lsdb);
-extern struct ospf6_lsa *ospf6_lsdb_lookup_next(u_int16_t type, u_int32_t id,
- u_int32_t adv_router,
+extern struct ospf6_lsa *ospf6_lsdb_lookup_next(uint16_t type, uint32_t id,
+ uint32_t adv_router,
struct ospf6_lsdb *lsdb);
extern void ospf6_lsdb_add(struct ospf6_lsa *lsa, struct ospf6_lsdb *lsdb);
};
extern void ospf6_lsdb_show(struct vty *vty, enum ospf_lsdb_show_level level,
- u_int16_t *type, u_int32_t *id,
- u_int32_t *adv_router, struct ospf6_lsdb *lsdb);
+ uint16_t *type, uint32_t *id, uint32_t *adv_router,
+ struct ospf6_lsdb *lsdb);
-extern u_int32_t ospf6_new_ls_id(u_int16_t type, u_int32_t adv_router,
- struct ospf6_lsdb *lsdb);
-extern u_int32_t ospf6_new_ls_seqnum(u_int16_t type, u_int32_t id,
- u_int32_t adv_router,
- struct ospf6_lsdb *lsdb);
+extern uint32_t ospf6_new_ls_id(uint16_t type, uint32_t adv_router,
+ struct ospf6_lsdb *lsdb);
+extern uint32_t ospf6_new_ls_seqnum(uint16_t type, uint32_t id,
+ uint32_t adv_router,
+ struct ospf6_lsdb *lsdb);
extern int ospf6_lsdb_maxage_remover(struct ospf6_lsdb *lsdb);
#endif /* OSPF6_LSDB_H */
/* Minimum (besides the standard OSPF packet header) lengths for OSPF
packets of particular types, offset is the "type" field. */
-const u_int16_t ospf6_packet_minlen[OSPF6_MESSAGE_TYPE_ALL] = {
+const uint16_t ospf6_packet_minlen[OSPF6_MESSAGE_TYPE_ALL] = {
0,
OSPF6_HELLO_MIN_SIZE,
OSPF6_DB_DESC_MIN_SIZE,
/* Minimum (besides the standard LSA header) lengths for LSAs of particular
types, offset is the "LSA function code" portion of "LSA type" field. */
-const u_int16_t ospf6_lsa_minlen[OSPF6_LSTYPE_SIZE] = {
+const uint16_t ospf6_lsa_minlen[OSPF6_LSTYPE_SIZE] = {
0,
/* 0x2001 */ OSPF6_ROUTER_LSA_MIN_SIZE,
/* 0x2002 */ OSPF6_NETWORK_LSA_MIN_SIZE,
ospf6_options_printbuf(hello->options, options, sizeof(options));
zlog_debug(" I/F-Id:%ld Priority:%d Option:%s",
- (u_long)ntohl(hello->interface_id), hello->priority,
+ (unsigned long)ntohl(hello->interface_id), hello->priority,
options);
zlog_debug(" HelloInterval:%hu DeadInterval:%hu",
ntohs(hello->hello_interval), ntohs(hello->dead_interval));
zlog_debug(" DR:%s BDR:%s", drouter, bdrouter);
for (p = (char *)((caddr_t)hello + sizeof(struct ospf6_hello));
- p + sizeof(u_int32_t) <= OSPF6_MESSAGE_END(oh);
- p += sizeof(u_int32_t)) {
+ p + sizeof(uint32_t) <= OSPF6_MESSAGE_END(oh);
+ p += sizeof(uint32_t)) {
inet_ntop(AF_INET, (void *)p, neighbor, sizeof(neighbor));
zlog_debug(" Neighbor: %s", neighbor);
}
(CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_IBIT) ? "I" : "-"),
(CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MBIT) ? "M" : "-"),
(CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MSBIT) ? "m" : "s"),
- (u_long)ntohl(dbdesc->seqnum));
+ (unsigned long)ntohl(dbdesc->seqnum));
for (p = (char *)((caddr_t)dbdesc + sizeof(struct ospf6_dbdesc));
p + sizeof(struct ospf6_lsa_header) <= OSPF6_MESSAGE_END(oh);
void ospf6_lsupdate_print(struct ospf6_header *oh)
{
struct ospf6_lsupdate *lsupdate;
- u_long num;
+ unsigned long num;
char *p;
ospf6_header_print(oh);
/* TwoWay check */
for (p = (char *)((caddr_t)hello + sizeof(struct ospf6_hello));
- p + sizeof(u_int32_t) <= OSPF6_MESSAGE_END(oh);
- p += sizeof(u_int32_t)) {
- u_int32_t *router_id = (u_int32_t *)p;
+ p + sizeof(uint32_t) <= OSPF6_MESSAGE_END(oh);
+ p += sizeof(uint32_t)) {
+ uint32_t *router_id = (uint32_t *)p;
if (*router_id == oi->area->ospf6->router_id)
twoway++;
if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
zlog_debug(
"Sequence number mismatch (%#lx expected)",
- (u_long)on->dbdesc_seqnum);
+ (unsigned long)on->dbdesc_seqnum);
thread_add_event(master, seqnumber_mismatch, on, 0,
NULL);
return;
if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
zlog_debug(
"Sequence number mismatch (%#lx expected)",
- (u_long)on->dbdesc_seqnum + 1);
+ (unsigned long)on->dbdesc_seqnum + 1);
thread_add_event(master, seqnumber_mismatch, on, 0,
NULL);
return;
static unsigned ospf6_prefixes_examin(
struct ospf6_prefix *current, /* start of buffer */
unsigned length,
- const u_int32_t req_num_pfxs /* always compared with the actual number
+ const uint32_t req_num_pfxs /* always compared with the actual number
of prefixes */
- )
+)
{
- u_char requested_pfx_bytes;
- u_int32_t real_num_pfxs = 0;
+ uint8_t requested_pfx_bytes;
+ uint32_t real_num_pfxs = 0;
while (length) {
if (length < OSPF6_PREFIX_MIN_SIZE) {
LSA type in network byte order, uses in host byte order and passes to
ospf6_lstype_name() in network byte order again. */
static unsigned ospf6_lsa_examin(struct ospf6_lsa_header *lsah,
- const u_int16_t lsalen,
- const u_char headeronly)
+ const uint16_t lsalen,
+ const uint8_t headeronly)
{
struct ospf6_intra_prefix_lsa *intra_prefix_lsa;
struct ospf6_as_external_lsa *as_external_lsa;
struct ospf6_link_lsa *link_lsa;
unsigned exp_length;
- u_int8_t ltindex;
- u_int16_t lsatype;
+ uint8_t ltindex;
+ uint16_t lsatype;
/* In case an additional minimum length constraint is defined for
current
of deeper-level checks. */
static unsigned
ospf6_lsaseq_examin(struct ospf6_lsa_header *lsah, /* start of buffered data */
- size_t length, const u_char headeronly,
+ size_t length, const uint8_t headeronly,
/* When declared_num_lsas is not 0, compare it to the real
number of LSAs
and treat the difference as an error. */
- const u_int32_t declared_num_lsas)
+ const uint32_t declared_num_lsas)
{
- u_int32_t counted_lsas = 0;
+ uint32_t counted_lsas = 0;
while (length) {
- u_int16_t lsalen;
+ uint16_t lsalen;
if (length < OSPF6_LSA_HEADER_SIZE) {
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
RECV))
assert(p == OSPF6_MESSAGE_END(oh));
}
-static u_char *recvbuf = NULL;
-static u_char *sendbuf = NULL;
+static uint8_t *recvbuf = NULL;
+static uint8_t *sendbuf = NULL;
static unsigned int iobuflen = 0;
int ospf6_iobuf_size(unsigned int size)
{
- u_char *recvnew, *sendnew;
+ uint8_t *recvnew, *sendnew;
if (size <= iobuflen)
return iobuflen;
struct ospf6_interface *oi;
struct ospf6_header *oh;
struct ospf6_hello *hello;
- u_char *p;
+ uint8_t *p;
struct listnode *node, *nnode;
struct ospf6_neighbor *on;
hello->drouter = oi->drouter;
hello->bdrouter = oi->bdrouter;
- p = (u_char *)((caddr_t)hello + sizeof(struct ospf6_hello));
+ p = (uint8_t *)((caddr_t)hello + sizeof(struct ospf6_hello));
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
if (on->state < OSPF6_NEIGHBOR_INIT)
continue;
- if (p - sendbuf + sizeof(u_int32_t) > ospf6_packet_max(oi)) {
+ if (p - sendbuf + sizeof(uint32_t) > ospf6_packet_max(oi)) {
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_HELLO,
SEND))
zlog_debug(
break;
}
- memcpy(p, &on->router_id, sizeof(u_int32_t));
- p += sizeof(u_int32_t);
+ memcpy(p, &on->router_id, sizeof(uint32_t));
+ p += sizeof(uint32_t);
}
oh->type = OSPF6_MESSAGE_TYPE_HELLO;
struct ospf6_neighbor *on;
struct ospf6_header *oh;
struct ospf6_dbdesc *dbdesc;
- u_char *p;
+ uint8_t *p;
struct ospf6_lsa *lsa;
struct in6_addr *dst;
dbdesc->seqnum = htonl(on->dbdesc_seqnum);
/* if this is not initial one, set LSA headers in dbdesc */
- p = (u_char *)((caddr_t)dbdesc + sizeof(struct ospf6_dbdesc));
+ p = (uint8_t *)((caddr_t)dbdesc + sizeof(struct ospf6_dbdesc));
if (!CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT)) {
for (ALL_LSDB(on->dbdesc_list, lsa)) {
ospf6_lsa_age_update_to_send(lsa,
struct ospf6_neighbor *on;
struct ospf6_header *oh;
struct ospf6_lsreq_entry *e;
- u_char *p;
+ uint8_t *p;
struct ospf6_lsa *lsa, *last_req;
on = (struct ospf6_neighbor *)THREAD_ARG(thread);
last_req = NULL;
/* set Request entries in lsreq */
- p = (u_char *)((caddr_t)oh + sizeof(struct ospf6_header));
+ p = (uint8_t *)((caddr_t)oh + sizeof(struct ospf6_header));
for (ALL_LSDB(on->request_list, lsa)) {
/* MTU check */
if (p - sendbuf + sizeof(struct ospf6_lsreq_entry)
struct ospf6_neighbor *on;
struct ospf6_header *oh;
struct ospf6_lsupdate *lsupdate;
- u_char *p;
+ uint8_t *p;
int lsa_cnt;
struct ospf6_lsa *lsa;
lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
+ sizeof(struct ospf6_header));
- p = (u_char *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
+ p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
lsa_cnt = 0;
/* lsupdate_list lists those LSA which doesn't need to be
+ sizeof(struct
ospf6_header));
- p = (u_char *)((caddr_t)lsupdate
- + sizeof(struct ospf6_lsupdate));
+ p = (uint8_t *)((caddr_t)lsupdate
+ + sizeof(struct
+ ospf6_lsupdate));
lsa_cnt = 0;
}
}
oh = (struct ospf6_header *)sendbuf;
lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
+ sizeof(struct ospf6_header));
- p = (u_char *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
+ p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
lsa_cnt = 0;
for (ALL_LSDB(on->retrans_list, lsa)) {
*)((caddr_t)oh
+ sizeof(struct
ospf6_header));
- p = (u_char *)((caddr_t)lsupdate
- + sizeof(struct ospf6_lsupdate));
+ p = (uint8_t *)((caddr_t)lsupdate
+ + sizeof(struct
+ ospf6_lsupdate));
lsa_cnt = 0;
}
}
{
struct ospf6_header *oh;
struct ospf6_lsupdate *lsupdate;
- u_char *p;
+ uint8_t *p;
int lsa_cnt = 0;
memset(sendbuf, 0, iobuflen);
lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
+ sizeof(struct ospf6_header));
- p = (u_char *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
+ p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
ospf6_lsa_age_update_to_send(lsa, on->ospf6_if->transdelay);
memcpy(p, lsa->header, OSPF6_LSA_SIZE(lsa->header));
p += OSPF6_LSA_SIZE(lsa->header);
struct ospf6_interface *oi;
struct ospf6_header *oh;
struct ospf6_lsupdate *lsupdate;
- u_char *p;
+ uint8_t *p;
int lsa_cnt;
struct ospf6_lsa *lsa;
lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
+ sizeof(struct ospf6_header));
- p = (u_char *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
+ p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
lsa_cnt = 0;
for (ALL_LSDB(oi->lsupdate_list, lsa)) {
+ sizeof(struct
ospf6_header));
- p = (u_char *)((caddr_t)lsupdate
- + sizeof(struct ospf6_lsupdate));
+ p = (uint8_t *)((caddr_t)lsupdate
+ + sizeof(struct
+ ospf6_lsupdate));
lsa_cnt = 0;
}
}
{
struct ospf6_neighbor *on;
struct ospf6_header *oh;
- u_char *p;
+ uint8_t *p;
struct ospf6_lsa *lsa;
int lsa_cnt = 0;
memset(sendbuf, 0, iobuflen);
oh = (struct ospf6_header *)sendbuf;
- p = (u_char *)((caddr_t)oh + sizeof(struct ospf6_header));
+ p = (uint8_t *)((caddr_t)oh + sizeof(struct ospf6_header));
for (ALL_LSDB(on->lsack_list, lsa)) {
/* MTU check */
memset(sendbuf, 0, iobuflen);
oh = (struct ospf6_header *)sendbuf;
- p = (u_char *)((caddr_t)oh
- + sizeof(struct ospf6_header));
+ p = (uint8_t *)((caddr_t)oh
+ + sizeof(struct ospf6_header));
lsa_cnt = 0;
}
}
{
struct ospf6_interface *oi;
struct ospf6_header *oh;
- u_char *p;
+ uint8_t *p;
struct ospf6_lsa *lsa;
int lsa_cnt = 0;
memset(sendbuf, 0, iobuflen);
oh = (struct ospf6_header *)sendbuf;
- p = (u_char *)((caddr_t)oh + sizeof(struct ospf6_header));
+ p = (uint8_t *)((caddr_t)oh + sizeof(struct ospf6_header));
for (ALL_LSDB(oi->lsack_list, lsa)) {
/* MTU check */
/* OSPFv3 packet header */
#define OSPF6_HEADER_SIZE 16U
struct ospf6_header {
- u_char version;
- u_char type;
- u_int16_t length;
- u_int32_t router_id;
- u_int32_t area_id;
- u_int16_t checksum;
- u_char instance_id;
- u_char reserved;
+ uint8_t version;
+ uint8_t type;
+ uint16_t length;
+ uint32_t router_id;
+ uint32_t area_id;
+ uint16_t checksum;
+ uint8_t instance_id;
+ uint8_t reserved;
};
#define OSPF6_MESSAGE_END(H) ((caddr_t) (H) + ntohs ((H)->length))
#define OSPF6_HELLO_MIN_SIZE 20U
struct ospf6_hello {
ifindex_t interface_id;
- u_char priority;
- u_char options[3];
- u_int16_t hello_interval;
- u_int16_t dead_interval;
- u_int32_t drouter;
- u_int32_t bdrouter;
+ uint8_t priority;
+ uint8_t options[3];
+ uint16_t hello_interval;
+ uint16_t dead_interval;
+ uint32_t drouter;
+ uint32_t bdrouter;
/* Followed by Router-IDs */
};
/* Database Description */
#define OSPF6_DB_DESC_MIN_SIZE 12U
struct ospf6_dbdesc {
- u_char reserved1;
- u_char options[3];
- u_int16_t ifmtu;
- u_char reserved2;
- u_char bits;
- u_int32_t seqnum;
+ uint8_t reserved1;
+ uint8_t options[3];
+ uint16_t ifmtu;
+ uint8_t reserved2;
+ uint8_t bits;
+ uint32_t seqnum;
/* Followed by LSA Headers */
};
/* It is just a sequence of entries below */
#define OSPF6_LSREQ_LSDESC_FIX_SIZE 12U
struct ospf6_lsreq_entry {
- u_int16_t reserved; /* Must Be Zero */
- u_int16_t type; /* LS type */
- u_int32_t id; /* Link State ID */
- u_int32_t adv_router; /* Advertising Router */
+ uint16_t reserved; /* Must Be Zero */
+ uint16_t type; /* LS type */
+ uint32_t id; /* Link State ID */
+ uint32_t adv_router; /* Advertising Router */
};
/* Link State Update */
#define OSPF6_LS_UPD_MIN_SIZE 4U
struct ospf6_lsupdate {
- u_int32_t lsa_number;
+ uint32_t lsa_number;
/* Followed by LSAs */
};
return (ntohl(ona->router_id) < ntohl(onb->router_id) ? -1 : 1);
}
-struct ospf6_neighbor *ospf6_neighbor_lookup(u_int32_t router_id,
+struct ospf6_neighbor *ospf6_neighbor_lookup(uint32_t router_id,
struct ospf6_interface *oi)
{
struct listnode *n;
}
/* create ospf6_neighbor */
-struct ospf6_neighbor *ospf6_neighbor_create(u_int32_t router_id,
+struct ospf6_neighbor *ospf6_neighbor_create(uint32_t router_id,
struct ospf6_interface *oi)
{
struct ospf6_neighbor *on;
XFREE(MTYPE_OSPF6_NEIGHBOR, on);
}
-static void ospf6_neighbor_state_change(u_char next_state,
+static void ospf6_neighbor_state_change(uint8_t next_state,
struct ospf6_neighbor *on, int event)
{
- u_char prev_state;
+ uint8_t prev_state;
prev_state = on->state;
on->state = next_state;
(CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT) ? "More " : ""),
(CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT) ? "Master"
: "Slave"),
- (u_long)ntohl(on->dbdesc_seqnum));
+ (unsigned long)ntohl(on->dbdesc_seqnum));
vty_out(vty, " Summary-List: %d LSAs\n", on->summary_list->count);
for (ALL_LSDB(on->summary_list, lsa))
struct ospf6_area *oa;
struct listnode *i, *j, *k;
void (*showfunc)(struct vty *, struct ospf6_neighbor *);
- u_int32_t router_id;
+ uint32_t router_id;
OSPF6_CMD_CHECK_RUNNING();
showfunc = ospf6_neighbor_show_detail;
DEBUG_STR
OSPF6_STR)
{
- u_int i;
+ unsigned int i;
struct ospf6_lsa_handler *handler = NULL;
OSPF6_DEBUG_ABR_OFF();
struct ospf6_interface *ospf6_if;
/* Neighbor state */
- u_char state;
+ uint8_t state;
/* timestamp of last changing state */
- u_int32_t state_change;
+ uint32_t state_change;
struct timeval last_changed;
/* Neighbor Router ID */
- u_int32_t router_id;
+ uint32_t router_id;
/* Neighbor Interface ID */
ifindex_t ifindex;
/* Router Priority of this neighbor */
- u_char priority;
+ uint8_t priority;
- u_int32_t drouter;
- u_int32_t bdrouter;
- u_int32_t prev_drouter;
- u_int32_t prev_bdrouter;
+ uint32_t drouter;
+ uint32_t bdrouter;
+ uint32_t prev_drouter;
+ uint32_t prev_bdrouter;
/* Options field (Capability) */
char options[3];
struct in6_addr linklocal_addr;
/* For Database Exchange */
- u_char dbdesc_bits;
- u_int32_t dbdesc_seqnum;
+ uint8_t dbdesc_bits;
+ uint32_t dbdesc_seqnum;
/* Last received Database Description packet */
struct ospf6_dbdesc dbdesc_last;
int ospf6_neighbor_cmp(void *va, void *vb);
void ospf6_neighbor_dbex_init(struct ospf6_neighbor *on);
-struct ospf6_neighbor *ospf6_neighbor_lookup(u_int32_t,
+struct ospf6_neighbor *ospf6_neighbor_lookup(uint32_t,
struct ospf6_interface *);
-struct ospf6_neighbor *ospf6_neighbor_create(u_int32_t,
+struct ospf6_neighbor *ospf6_neighbor_create(uint32_t,
struct ospf6_interface *);
void ospf6_neighbor_delete(struct ospf6_neighbor *);
/* setsockopt MulticastLoop to off */
static void ospf6_reset_mcastloop(void)
{
- u_int off = 0;
+ unsigned int off = 0;
if (setsockopt(ospf6_sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &off,
- sizeof(u_int))
+ sizeof(unsigned int))
< 0)
zlog_warn("Network: reset IPV6_MULTICAST_LOOP failed: %s",
safe_strerror(errno));
struct cmsghdr *scmsgp;
union {
struct cmsghdr hdr;
- u_char buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
+ uint8_t buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
} cmsgbuf;
struct in6_pktinfo *pktinfo;
struct sockaddr_in6 dst_sin6;
int retval;
struct msghdr rmsghdr;
struct cmsghdr *rcmsgp;
- u_char cmsgbuf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
+ uint8_t cmsgbuf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
struct in6_pktinfo *pktinfo;
struct sockaddr_in6 src_sin6;
void ospf6_prefix_apply_mask(struct ospf6_prefix *op)
{
- u_char *pnt, mask;
+ uint8_t *pnt, mask;
int index, offset;
- pnt = (u_char *)((caddr_t)op + sizeof(struct ospf6_prefix));
+ pnt = (uint8_t *)((caddr_t)op + sizeof(struct ospf6_prefix));
index = op->prefix_length / 8;
offset = op->prefix_length % 8;
mask = 0xff << (8 - offset);
pnt[index++] = 0;
}
-void ospf6_prefix_options_printbuf(u_int8_t prefix_options, char *buf, int size)
+void ospf6_prefix_options_printbuf(uint8_t prefix_options, char *buf, int size)
{
snprintf(buf, size, "xxx");
}
snprintf(buf, size, "----%c%c%c%c", w, v, e, b);
}
-void ospf6_options_printbuf(u_char *options, char *buf, int size)
+void ospf6_options_printbuf(uint8_t *options, char *buf, int size)
{
const char *dc, *r, *n, *mc, *e, *v6;
dc = (OSPF6_OPT_ISSET(options, OSPF6_OPT_DC) ? "DC" : "--");
/* OSPF6 Prefix */
#define OSPF6_PREFIX_MIN_SIZE 4U /* .length == 0 */
struct ospf6_prefix {
- u_int8_t prefix_length;
- u_int8_t prefix_options;
+ uint8_t prefix_length;
+ uint8_t prefix_options;
union {
- u_int16_t _prefix_metric;
- u_int16_t _prefix_referenced_lstype;
+ uint16_t _prefix_metric;
+ uint16_t _prefix_referenced_lstype;
} u;
#define prefix_metric u._prefix_metric
#define prefix_refer_lstype u._prefix_referenced_lstype
} while (0)
extern void ospf6_prefix_apply_mask(struct ospf6_prefix *op);
-extern void ospf6_prefix_options_printbuf(u_int8_t prefix_options, char *buf,
+extern void ospf6_prefix_options_printbuf(uint8_t prefix_options, char *buf,
int size);
extern void ospf6_capability_printbuf(char capability, char *buf, int size);
-extern void ospf6_options_printbuf(u_char *options, char *buf, int size);
+extern void ospf6_options_printbuf(uint8_t *options, char *buf, int size);
#endif /* OSPF6_PROTO_H */
return name;
}
-void ospf6_linkstate_prefix(u_int32_t adv_router, u_int32_t id,
+void ospf6_linkstate_prefix(uint32_t adv_router, uint32_t id,
struct prefix *prefix)
{
memset(prefix, 0, sizeof(struct prefix));
void ospf6_linkstate_prefix2str(struct prefix *prefix, char *buf, int size)
{
- u_int32_t adv_router, id;
+ uint32_t adv_router, id;
char adv_router_str[16], id_str[16];
memcpy(&adv_router, &prefix->u.prefix6.s6_addr[0], 4);
memcpy(&id, &prefix->u.prefix6.s6_addr[4], 4);
}
static void ospf6_route_show_table_type(struct vty *vty, int detail,
- u_char type,
+ uint8_t type,
struct ospf6_route_table *table)
{
struct ospf6_route *route;
int isprefix = 0;
int i, ret;
struct prefix prefix;
- u_char type = 0;
+ uint8_t type = 0;
memset(&prefix, 0, sizeof(struct prefix));
static void ospf6_linkstate_show(struct vty *vty, struct ospf6_route *route)
{
- u_int32_t router, id;
+ uint32_t router, id;
char routername[16], idname[16], rbits[16], options[16];
router = ospf6_linkstate_prefix_adv_router(&route->prefix);
void ospf6_brouter_show(struct vty *vty, struct ospf6_route *route)
{
- u_int32_t adv_router;
+ uint32_t adv_router;
char adv[16], rbits[16], options[16], area[16];
adv_router = ospf6_linkstate_prefix_adv_router(&route->prefix);
/* Path */
struct ospf6_ls_origin {
- u_int16_t type;
- u_int32_t id;
- u_int32_t adv_router;
+ uint16_t type;
+ uint32_t id;
+ uint32_t adv_router;
};
struct ospf6_path {
struct ospf6_ls_origin origin;
/* Router bits */
- u_char router_bits;
+ uint8_t router_bits;
/* Optional Capabilities */
- u_char options[3];
+ uint8_t options[3];
/* Prefix Options */
- u_char prefix_options;
+ uint8_t prefix_options;
/* Associated Area */
- u_int32_t area_id;
+ uint32_t area_id;
/* Path-type */
- u_char type;
- u_char subtype; /* only used for redistribute i.e ZEBRA_ROUTE_XXX */
+ uint8_t type;
+ uint8_t subtype; /* only used for redistribute i.e ZEBRA_ROUTE_XXX */
/* Cost */
- u_int8_t metric_type;
- u_int32_t cost;
+ uint8_t metric_type;
+ uint32_t cost;
union {
- u_int32_t cost_e2;
- u_int32_t cost_config;
+ uint32_t cost_e2;
+ uint32_t cost_config;
} u;
- u_int32_t tag;
+ uint32_t tag;
/* nh list for this path */
struct list *nh_list;
unsigned int lock;
/* Destination Type */
- u_char type;
+ uint8_t type;
/* XXX: It would likely be better to use separate struct in_addr's
* for the advertising router-ID and prefix IDs, instead of stuffing
struct timeval changed;
/* flag */
- u_char flag;
+ uint8_t flag;
/* route option */
void *route_option;
/* link state id for advertising */
- u_int32_t linkstate_id;
+ uint32_t linkstate_id;
/* path */
struct ospf6_path path;
/* patricia tree */
struct route_table *table;
- u_int32_t count;
+ uint32_t count;
bitfield_t idspace;
#define ADV_ROUTER_IN_PREFIX(x) ((x)->u.lp.id.s_addr)
/* Function prototype */
-extern void ospf6_linkstate_prefix(u_int32_t adv_router, u_int32_t id,
+extern void ospf6_linkstate_prefix(uint32_t adv_router, uint32_t id,
struct prefix *prefix);
extern void ospf6_linkstate_prefix2str(struct prefix *prefix, char *buf,
int size);
static oid ospfv3_trap_oid[] = {OSPFv3MIB, 0};
/* Hook functions. */
-static u_char *ospfv3GeneralGroup(struct variable *, oid *, size_t *, int,
+static uint8_t *ospfv3GeneralGroup(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *ospfv3AreaEntry(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *ospfv3WwLsdbEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
-static u_char *ospfv3AreaEntry(struct variable *, oid *, size_t *, int,
+static uint8_t *ospfv3NbrEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
-static u_char *ospfv3WwLsdbEntry(struct variable *, oid *, size_t *, int,
- size_t *, WriteMethod **);
-static u_char *ospfv3NbrEntry(struct variable *, oid *, size_t *, int, size_t *,
+static uint8_t *ospfv3IfEntry(struct variable *, oid *, size_t *, int, size_t *,
WriteMethod **);
-static u_char *ospfv3IfEntry(struct variable *, oid *, size_t *, int, size_t *,
- WriteMethod **);
static struct variable ospfv3_variables[] = {
/* OSPF general variables */
{1, 9, 1, 15}},
};
-static u_char *ospfv3GeneralGroup(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfv3GeneralGroup(struct variable *v, oid *name,
+ size_t *length, int exact, size_t *var_len,
+ WriteMethod **write_method)
{
- u_int16_t sum;
- u_int32_t count;
+ uint16_t sum;
+ uint32_t count;
struct ospf6_lsa *lsa = NULL;
/* Check whether the instance identifier is valid */
return NULL;
}
-static u_char *ospfv3AreaEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfv3AreaEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf6_area *oa, *area = NULL;
struct ospf6_lsa *lsa = NULL;
- u_int32_t area_id = 0;
- u_int32_t count;
- u_int16_t sum;
+ uint32_t area_id = 0;
+ uint32_t count;
+ uint16_t sum;
struct listnode *node;
unsigned int len;
char a[16];
inet_ntop(AF_INET, &area_id, a, sizeof(a));
zlog_debug("SNMP access by area: %s, exact=%d len=%d length=%lu", a,
- exact, len, (u_long)*length);
+ exact, len, (unsigned long)*length);
for (ALL_LIST_ELEMENTS_RO(ospf6->area_list, node, oa)) {
if (area == NULL) {
inet_ntop(AF_INET, &area->area_id, a, sizeof(a));
zlog_debug("SNMP found area: %s, exact=%d len=%d length=%lu", a, exact,
- len, (u_long)*length);
+ len, (unsigned long)*length);
switch (v->magic) {
case OSPFv3IMPORTASEXTERN:
return (ifp1->ifindex - ifp2->ifindex);
}
-static u_char *ospfv3WwLsdbEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfv3WwLsdbEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
struct ospf6_lsa *lsa = NULL;
ifindex_t ifindex;
uint32_t area_id, id, instid, adv_router;
- u_int16_t type;
+ uint16_t type;
int len;
oid *offset;
int offsetlen;
break;
case OSPFv3WWLSDBADVERTISEMENT:
*var_len = ntohs(lsa->header->length);
- return (u_char *)lsa->header;
+ return (uint8_t *)lsa->header;
break;
case OSPFv3WWLSDBTYPEKNOWN:
return SNMP_INTEGER(OSPF6_LSA_IS_KNOWN(lsa->header->type)
return NULL;
}
-static u_char *ospfv3IfEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfv3IfEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
ifindex_t ifindex = 0;
struct list *ifslist;
oid *offset;
int offsetlen, len;
- u_int32_t sum;
+ uint32_t sum;
if (smux_header_table(v, name, length, exact, var_len, write_method)
== MATCH_FAILED)
return NULL;
}
-static u_char *ospfv3NbrEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfv3NbrEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
ifindex_t ifindex = 0;
return SNMP_INTEGER(2); /* IPv6 only */
case OSPFv3NBRADDRESS:
*var_len = sizeof(struct in6_addr);
- return (u_char *)&on->linklocal_addr;
+ return (uint8_t *)&on->linklocal_addr;
case OSPFv3NBROPTIONS:
return SNMP_INTEGER(on->options[2]);
case OSPFv3NBRPRIORITY:
v->lsa = lsa;
/* capability bits + options */
- v->capability = *(u_char *)(OSPF6_LSA_HEADER_END(lsa->header));
- v->options[0] = *(u_char *)(OSPF6_LSA_HEADER_END(lsa->header) + 1);
- v->options[1] = *(u_char *)(OSPF6_LSA_HEADER_END(lsa->header) + 2);
- v->options[2] = *(u_char *)(OSPF6_LSA_HEADER_END(lsa->header) + 3);
+ v->capability = *(uint8_t *)(OSPF6_LSA_HEADER_END(lsa->header));
+ v->options[0] = *(uint8_t *)(OSPF6_LSA_HEADER_END(lsa->header) + 1);
+ v->options[1] = *(uint8_t *)(OSPF6_LSA_HEADER_END(lsa->header) + 2);
+ v->options[2] = *(uint8_t *)(OSPF6_LSA_HEADER_END(lsa->header) + 3);
v->nh_list = list_new();
v->nh_list->cmp = (int (*)(void *, void *))ospf6_nexthop_cmp;
struct ospf6_vertex *v)
{
struct ospf6_lsa *lsa = NULL;
- u_int16_t type = 0;
- u_int32_t id = 0, adv_router = 0;
+ uint16_t type = 0;
+ uint32_t id = 0, adv_router = 0;
if (VERTEX_IS_TYPE(NETWORK, v)) {
type = htons(OSPF6_LSTYPE_ROUTER);
int i;
ifindex_t ifindex;
struct ospf6_interface *oi;
- u_int16_t type;
- u_int32_t adv_router;
+ uint16_t type;
+ uint32_t adv_router;
struct ospf6_lsa *lsa;
struct ospf6_link_lsa *link_lsa;
char buf[64];
/* RFC2328 16.1. Calculating the shortest-path tree for an area */
/* RFC2740 3.8.1. Calculating the shortest path tree for an area */
-void ospf6_spf_calculation(u_int32_t router_id,
+void ospf6_spf_calculation(uint32_t router_id,
struct ospf6_route_table *result_table,
struct ospf6_area *oa)
{
uint8_t *new_header = NULL;
const struct route_node *end = NULL;
uint16_t lsa_length, total_lsa_length = 0, num_lsa = 0;
- u_int16_t type = 0;
+ uint16_t type = 0;
char ifbuf[16];
uint32_t interface_id;
caddr_t lsd;
/* Transit Vertex */
struct ospf6_vertex {
/* type of this vertex */
- u_int8_t type;
+ uint8_t type;
/* Vertex Identifier */
struct prefix vertex_id;
struct ospf6_lsa *lsa;
/* Distance from Root (i.e. Cost) */
- u_int32_t cost;
+ uint32_t cost;
/* Router hops to this node */
- u_char hops;
+ uint8_t hops;
/* capability bits */
- u_char capability;
+ uint8_t capability;
/* Optional capabilities */
- u_char options[3];
+ uint8_t options[3];
/* For tree display */
struct ospf6_vertex *parent;
}
extern void ospf6_spf_table_finish(struct ospf6_route_table *result_table);
-extern void ospf6_spf_calculation(u_int32_t router_id,
+extern void ospf6_spf_calculation(uint32_t router_id,
struct ospf6_route_table *result_table,
struct ospf6_area *oa);
extern void ospf6_spf_schedule(struct ospf6 *ospf, unsigned int reason);
int idx = 0;
int ret;
const char *router_id_str;
- u_int32_t router_id;
+ uint32_t router_id;
struct ospf6_area *oa;
struct listnode *node;
struct ospf6_area *oa;
struct ospf6_interface *oi;
struct interface *ifp;
- u_int32_t area_id;
+ uint32_t area_id;
/* find/create ospf6 interface */
ifp = if_get_by_name(argv[idx_ifname]->arg, VRF_DEFAULT, 0);
struct ospf6_interface *oi;
struct ospf6_area *oa;
struct interface *ifp;
- u_int32_t area_id;
+ uint32_t area_id;
ifp = if_lookup_by_name(argv[idx_ifname]->arg, VRF_DEFAULT);
if (ifp == NULL) {
/* OSPFv3 top level data structure */
struct ospf6 {
/* my router id */
- u_int32_t router_id;
+ uint32_t router_id;
/* static router id */
- u_int32_t router_id_static;
+ uint32_t router_id_static;
struct in_addr router_id_zebra;
struct ospf6_route_table *external_table;
struct route_table *external_id_table;
- u_int32_t external_id;
+ uint32_t external_id;
/* redistribute route-map */
struct {
struct route_map *map;
} rmap[ZEBRA_ROUTE_MAX];
- u_char flag;
+ uint8_t flag;
/* Configured flags */
- u_char config_flags;
+ uint8_t config_flags;
#define OSPF6_LOG_ADJACENCY_CHANGES (1 << 0)
#define OSPF6_LOG_ADJACENCY_DETAIL (1 << 1)
struct thread *maxage_remover;
struct thread *t_distribute_update; /* Distirbute update timer. */
- u_int32_t ref_bandwidth;
+ uint32_t ref_bandwidth;
/* Distance parameters */
- u_char distance_all;
- u_char distance_intra;
- u_char distance_inter;
- u_char distance_external;
+ uint8_t distance_all;
+ uint8_t distance_intra;
+ uint8_t distance_inter;
+ uint8_t distance_external;
struct route_table *distance_table;
{
int ret;
struct prefix_ipv6 p;
- u_char distance;
+ uint8_t distance;
struct route_node *rn;
struct ospf6_distance *odistance;
}
}
-u_char ospf6_distance_apply(struct prefix_ipv6 *p, struct ospf6_route * or)
+uint8_t ospf6_distance_apply(struct prefix_ipv6 *p, struct ospf6_route * or)
{
struct ospf6 *o;
/* OSPF6 distance */
struct ospf6_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;
struct ospf6;
extern void ospf6_distance_reset(struct ospf6 *);
-extern u_char ospf6_distance_apply(struct prefix_ipv6 *, struct ospf6_route *);
+extern uint8_t ospf6_distance_apply(struct prefix_ipv6 *, struct ospf6_route *);
extern int ospf6_distance_set(struct vty *, struct ospf6 *, const char *,
const char *, const char *);
return level;
}
-static u_int16_t parse_type_spec(int idx_lsa, int argc, struct cmd_token **argv)
+static uint16_t parse_type_spec(int idx_lsa, int argc, struct cmd_token **argv)
{
- u_int16_t type = 0;
+ uint16_t type = 0;
if (argc > idx_lsa) {
if (strmatch(argv[idx_lsa]->text, "router"))
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
+ uint16_t type = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int32_t id = 0;
+ uint32_t id = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int32_t adv_router = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
inet_pton(AF_INET, argv[idx_ipv4]->arg, &adv_router);
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
- u_int32_t id = 0;
+ uint16_t type = 0;
+ uint32_t id = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
- u_int32_t adv_router = 0;
+ uint16_t type = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int32_t id = 0;
- u_int32_t adv_router = 0;
+ uint32_t id = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
inet_pton(AF_INET, argv[idx_ls_id]->arg, &id);
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int32_t id = 0;
- u_int32_t adv_router = 0;
+ uint32_t id = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
inet_pton(AF_INET, argv[idx_adv_rtr]->arg, &adv_router);
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
- u_int32_t id = 0;
- u_int32_t adv_router = 0;
+ uint16_t type = 0;
+ uint32_t id = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
- u_int32_t id = 0;
- u_int32_t adv_router = 0;
+ uint16_t type = 0;
+ uint32_t id = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int32_t adv_router = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
level = parse_show_level(idx_level, argc, argv);
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
- u_int32_t adv_router = 0;
+ uint16_t type = 0;
+ uint32_t adv_router = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
- u_int32_t adv_router = 0;
- u_int32_t id = 0;
+ uint16_t type = 0;
+ uint32_t adv_router = 0;
+ uint32_t id = 0;
OSPF6_CMD_CHECK_RUNNING();
struct ospf6 *o = ospf6;
struct ospf6_area *oa;
struct ospf6_interface *oi;
- u_int16_t type = 0;
- u_int32_t adv_router = 0;
- u_int32_t id = 0;
+ uint16_t type = 0;
+ uint32_t adv_router = 0;
+ uint32_t id = 0;
OSPF6_CMD_CHECK_RUNNING();
"Show detailed output\n")
{
int idx_ipv4 = 4;
- u_int32_t adv_router;
+ uint32_t adv_router;
struct ospf6_route *ro;
struct prefix prefix;
static int ospf_apiclient_send_request(struct ospf_apiclient *oclient,
struct msg *msg)
{
- u_int32_t reqseq;
+ uint32_t reqseq;
struct msg_reply *msgreply;
int rc;
* -----------------------------------------------------------
*/
-static u_int32_t ospf_apiclient_get_seqnr(void)
+static uint32_t ospf_apiclient_get_seqnr(void)
{
- static u_int32_t seqnr = MIN_SEQ;
- u_int32_t tmp;
+ static uint32_t seqnr = MIN_SEQ;
+ uint32_t tmp;
tmp = seqnr;
/* Increment sequence number */
/*
* Synchronous request to register opaque type.
*/
-int ospf_apiclient_register_opaque_type(struct ospf_apiclient *cl, u_char ltype,
- u_char otype)
+int ospf_apiclient_register_opaque_type(struct ospf_apiclient *cl,
+ uint8_t ltype, uint8_t otype)
{
struct msg *msg;
int rc;
int ospf_apiclient_lsa_originate(struct ospf_apiclient *oclient,
struct in_addr ifaddr, struct in_addr area_id,
- u_char lsa_type, u_char opaque_type,
- u_int32_t opaque_id, void *opaquedata,
+ uint8_t lsa_type, uint8_t opaque_type,
+ uint32_t opaque_id, void *opaquedata,
int opaquelen)
{
struct msg *msg;
int rc;
- u_char buf[OSPF_MAX_LSA_SIZE];
+ uint8_t buf[OSPF_MAX_LSA_SIZE];
struct lsa_header *lsah;
- u_int32_t tmp;
+ uint32_t tmp;
/* We can only originate opaque LSAs */
lsah->checksum = 0;
lsah->length = htons(sizeof(struct lsa_header) + opaquelen);
- memcpy(((u_char *)lsah) + sizeof(struct lsa_header), opaquedata,
+ memcpy(((uint8_t *)lsah) + sizeof(struct lsa_header), opaquedata,
opaquelen);
msg = new_msg_originate_request(ospf_apiclient_get_seqnr(), ifaddr,
}
int ospf_apiclient_lsa_delete(struct ospf_apiclient *oclient,
- struct in_addr area_id, u_char lsa_type,
- u_char opaque_type, u_int32_t opaque_id)
+ struct in_addr area_id, uint8_t lsa_type,
+ uint8_t opaque_type, uint32_t opaque_id)
{
struct msg *msg;
int rc;
void ospf_apiclient_register_callback(
struct ospf_apiclient *oclient,
- void (*ready_notify)(u_char lsa_type, u_char opaque_type,
+ void (*ready_notify)(uint8_t lsa_type, uint8_t opaque_type,
struct in_addr addr),
void (*new_if)(struct in_addr ifaddr, struct in_addr area_id),
void (*del_if)(struct in_addr ifaddr),
void (*ism_change)(struct in_addr ifaddr, struct in_addr area_id,
- u_char status),
+ uint8_t status),
void (*nsm_change)(struct in_addr ifaddr, struct in_addr nbraddr,
- struct in_addr router_id, u_char status),
+ struct in_addr router_id, uint8_t status),
void (*update_notify)(struct in_addr ifaddr, struct in_addr area_id,
- u_char self_origin, struct lsa_header *lsa),
+ uint8_t self_origin, struct lsa_header *lsa),
void (*delete_notify)(struct in_addr ifaddr, struct in_addr area_id,
- u_char self_origin, struct lsa_header *lsa))
+ uint8_t self_origin, struct lsa_header *lsa))
{
assert(oclient);
assert(update_notify);
int fd_async;
/* Pointer to callback functions */
- void (*ready_notify)(u_char lsa_type, u_char opaque_type,
+ void (*ready_notify)(uint8_t lsa_type, uint8_t opaque_type,
struct in_addr addr);
void (*new_if)(struct in_addr ifaddr, struct in_addr area_id);
void (*del_if)(struct in_addr ifaddr);
void (*ism_change)(struct in_addr ifaddr, struct in_addr area_id,
- u_char status);
+ uint8_t status);
void (*nsm_change)(struct in_addr ifaddr, struct in_addr nbraddr,
- struct in_addr router_id, u_char status);
+ struct in_addr router_id, uint8_t status);
void (*update_notify)(struct in_addr ifaddr, struct in_addr area_id,
- u_char self_origin, struct lsa_header *lsa);
+ uint8_t self_origin, struct lsa_header *lsa);
void (*delete_notify)(struct in_addr ifaddr, struct in_addr area_id,
- u_char self_origin, struct lsa_header *lsa);
+ uint8_t self_origin, struct lsa_header *lsa);
};
/* Synchronous request to register opaque type. */
int ospf_apiclient_register_opaque_type(struct ospf_apiclient *oclient,
- u_char ltype, u_char otype);
+ uint8_t ltype, uint8_t otype);
/* Synchronous request to register event mask. */
int ospf_apiclient_register_events(struct ospf_apiclient *oclient,
- u_int32_t mask);
+ uint32_t mask);
/* Register callback functions.*/
void ospf_apiclient_register_callback(
struct ospf_apiclient *oclient,
- void (*ready_notify)(u_char lsa_type, u_char opaque_type,
+ void (*ready_notify)(uint8_t lsa_type, uint8_t opaque_type,
struct in_addr addr),
void (*new_if)(struct in_addr ifaddr, struct in_addr area_id),
void (*del_if)(struct in_addr ifaddr),
void (*ism_change)(struct in_addr ifaddr, struct in_addr area_id,
- u_char status),
+ uint8_t status),
void (*nsm_change)(struct in_addr ifaddr, struct in_addr nbraddr,
- struct in_addr router_id, u_char status),
+ struct in_addr router_id, uint8_t status),
void (*update_notify)(struct in_addr ifaddr, struct in_addr area_id,
- u_char selforig, struct lsa_header *lsa),
+ uint8_t selforig, struct lsa_header *lsa),
void (*delete_notify)(struct in_addr ifaddr, struct in_addr area_id,
- u_char selforig, struct lsa_header *lsa));
+ uint8_t selforig, struct lsa_header *lsa));
/* Synchronous request to synchronize LSDB. */
int ospf_apiclient_sync_lsdb(struct ospf_apiclient *oclient);
/* Synchronous request to originate or update opaque LSA. */
int ospf_apiclient_lsa_originate(struct ospf_apiclient *oclient,
struct in_addr ifaddr, struct in_addr area_id,
- u_char lsa_type, u_char opaque_type,
- u_int32_t opaque_id, void *opaquedata,
+ uint8_t lsa_type, uint8_t opaque_type,
+ uint32_t opaque_id, void *opaquedata,
int opaquelen);
/* Synchronous request to delete opaque LSA. Parameter opaque_id is in
host byte order */
int ospf_apiclient_lsa_delete(struct ospf_apiclient *oclient,
- struct in_addr area_id, u_char lsa_type,
- u_char opaque_type, u_int32_t opaque_id);
+ struct in_addr area_id, uint8_t lsa_type,
+ uint8_t opaque_type, uint32_t opaque_id);
/* Fetch async message and handle it */
int ospf_apiclient_handle_async(struct ospf_apiclient *oclient);
/* Our opaque LSAs have the following format. */
struct my_opaque_lsa {
struct lsa_header hdr; /* include common LSA header */
- u_char data[4]; /* our own data format then follows here */
+ uint8_t data[4]; /* our own data format then follows here */
};
struct ospf_apiclient *cl;
struct in_addr ifaddr;
struct in_addr area_id;
- u_char lsa_type;
- u_char opaque_type;
- u_int32_t opaque_id;
+ uint8_t lsa_type;
+ uint8_t opaque_type;
+ uint32_t opaque_id;
void *opaquedata;
int opaquelen;
- static u_int32_t counter = 1; /* Incremented each time invoked */
+ static uint32_t counter = 1; /* Incremented each time invoked */
int rc;
cl = THREAD_ARG(t);
opaque_type = atoi(args[3]);
opaque_id = atoi(args[4]);
opaquedata = &counter;
- opaquelen = sizeof(u_int32_t);
+ opaquelen = sizeof(uint32_t);
printf("Originating/updating LSA with counter=%d... ", counter);
rc = ospf_apiclient_lsa_originate(cl, ifaddr, area_id, lsa_type,
*/
static void lsa_update_callback(struct in_addr ifaddr, struct in_addr area_id,
- u_char is_self_originated,
+ uint8_t is_self_originated,
struct lsa_header *lsa)
{
printf("lsa_update_callback: ");
if (lsa->type == OSPF_ROUTER_LSA) {
struct router_lsa *rl = (struct router_lsa) lsa;
...
- u_int16_t links = rl->links;
+ uint16_t links = rl->links;
...
}
*/
}
static void lsa_delete_callback(struct in_addr ifaddr, struct in_addr area_id,
- u_char is_self_originated,
+ uint8_t is_self_originated,
struct lsa_header *lsa)
{
printf("lsa_delete_callback: ");
ospf_lsa_header_dump(lsa);
}
-static void ready_callback(u_char lsa_type, u_char opaque_type,
+static void ready_callback(uint8_t lsa_type, uint8_t opaque_type,
struct in_addr addr)
{
printf("ready_callback: lsa_type: %d opaque_type: %d addr=%s\n",
}
static void ism_change_callback(struct in_addr ifaddr, struct in_addr area_id,
- u_char state)
+ uint8_t state)
{
printf("ism_change: ifaddr: %s ", inet_ntoa(ifaddr));
printf("area_id: %s\n", inet_ntoa(area_id));
}
static void nsm_change_callback(struct in_addr ifaddr, struct in_addr nbraddr,
- struct in_addr router_id, u_char state)
+ struct in_addr router_id, uint8_t state)
{
printf("nsm_change: ifaddr: %s ", inet_ntoa(ifaddr));
printf("nbraddr: %s\n", inet_ntoa(nbraddr));
}
int ospf_area_range_cost_set(struct ospf *ospf, struct in_addr area_id,
- struct prefix_ipv4 *p, u_int32_t cost)
+ struct prefix_ipv4 *p, uint32_t cost)
{
struct ospf_area *area;
struct ospf_area_range *range;
struct listnode *lnode, *nnode;
for (ALL_LIST_ELEMENTS(ospf->areas, lnode, nnode, area)) {
- u_char old_state = area->NSSATranslatorState;
+ uint8_t old_state = area->NSSATranslatorState;
if (area->external_routing != OSPF_AREA_NSSA)
continue;
int bb_act_attached = 0;
int areas_configured = 0;
int areas_act_attached = 0;
- u_char new_flags = ospf->flags;
+ uint8_t new_flags = ospf->flags;
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("ospf_check_abr_status(): Start");
range->specifics++;
}
-static void set_metric(struct ospf_lsa *lsa, u_int32_t metric)
+static void set_metric(struct ospf_lsa *lsa, uint32_t metric)
{
struct summary_lsa *header;
- u_char *mp;
+ uint8_t *mp;
metric = htonl(metric);
- mp = (u_char *)&metric;
+ mp = (uint8_t *)&metric;
mp++;
header = (struct summary_lsa *)lsa->data;
memcpy(header->metric, mp, 3);
return 0;
}
-static void ospf_abr_translate_nssa_range(struct prefix_ipv4 *p, u_int32_t cost)
+static void ospf_abr_translate_nssa_range(struct prefix_ipv4 *p, uint32_t cost)
{
/* The Type-7 is created from the aggregated prefix and forwarded
for lsa installation and flooding... to be added... */
}
-void ospf_abr_announce_network_to_area(struct prefix_ipv4 *p, u_int32_t cost,
+void ospf_abr_announce_network_to_area(struct prefix_ipv4 *p, uint32_t cost,
struct ospf_area *area)
{
struct ospf_lsa *lsa, *old = NULL;
struct summary_lsa *sl = NULL;
- u_int32_t full_cost;
+ uint32_t full_cost;
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("ospf_abr_announce_network_to_area(): Start");
zlog_debug("ospf_abr_process_network_rt(): Stop");
}
-static void ospf_abr_announce_rtr_to_area(struct prefix_ipv4 *p, u_int32_t cost,
+static void ospf_abr_announce_rtr_to_area(struct prefix_ipv4 *p, uint32_t cost,
struct ospf_area *area)
{
struct ospf_lsa *lsa, *old = NULL;
struct in_addr addr;
/* Area range masklen. */
- u_char masklen;
+ uint8_t masklen;
/* Flags. */
- u_char flags;
+ uint8_t flags;
/* Number of more specific prefixes. */
int specifics;
/* Addr and masklen to substitute. */
struct in_addr subst_addr;
- u_char subst_masklen;
+ uint8_t subst_masklen;
/* Range cost. */
- u_int32_t cost;
+ uint32_t cost;
/* Configured range cost. */
- u_int32_t cost_config;
+ uint32_t cost_config;
};
/* Prototypes. */
extern int ospf_area_range_set(struct ospf *, struct in_addr,
struct prefix_ipv4 *, int);
extern int ospf_area_range_cost_set(struct ospf *, struct in_addr,
- struct prefix_ipv4 *, u_int32_t);
+ struct prefix_ipv4 *, uint32_t);
extern int ospf_area_range_unset(struct ospf *, struct in_addr,
struct prefix_ipv4 *);
extern int ospf_area_range_substitute_set(struct ospf *, struct in_addr,
extern void ospf_abr_task(struct ospf *);
extern void ospf_schedule_abr_task(struct ospf *);
-extern void ospf_abr_announce_network_to_area(struct prefix_ipv4 *, u_int32_t,
+extern void ospf_abr_announce_network_to_area(struct prefix_ipv4 *, uint32_t,
struct ospf_area *);
#endif /* _ZEBRA_OSPF_ABR_H */
{
struct opaque_lsa {
struct lsa_header header;
- u_char mydata[];
+ uint8_t mydata[];
};
struct opaque_lsa *olsa;
* -----------------------------------------------------------
*/
-struct msg *msg_new(u_char msgtype, void *msgbody, u_int32_t seqnum,
- u_int16_t msglen)
+struct msg *msg_new(uint8_t msgtype, void *msgbody, uint32_t seqnum,
+ uint16_t msglen)
{
struct msg *new;
/* Set sequence number of message */
-void msg_set_seq(struct msg *msg, u_int32_t seqnr)
+void msg_set_seq(struct msg *msg, uint32_t seqnr)
{
assert(msg);
msg->hdr.msgseq = htonl(seqnr);
}
/* Get sequence number of message */
-u_int32_t msg_get_seq(struct msg *msg)
+uint32_t msg_get_seq(struct msg *msg)
{
assert(msg);
return ntohl(msg->hdr.msgseq);
{
struct msg *msg;
struct apimsghdr hdr;
- u_char buf[OSPF_API_MAX_MSG_SIZE];
+ uint8_t buf[OSPF_API_MAX_MSG_SIZE];
int bodylen;
int rlen;
/* Read message header */
- rlen = readn(fd, (u_char *)&hdr, sizeof(struct apimsghdr));
+ rlen = readn(fd, (uint8_t *)&hdr, sizeof(struct apimsghdr));
if (rlen < 0) {
zlog_warn("msg_read: readn %s", safe_strerror(errno));
int msg_write(int fd, struct msg *msg)
{
- u_char buf[OSPF_API_MAX_MSG_SIZE];
+ uint8_t buf[OSPF_API_MAX_MSG_SIZE];
int l;
int wlen;
* -----------------------------------------------------------
*/
-struct msg *new_msg_register_opaque_type(u_int32_t seqnum, u_char ltype,
- u_char otype)
+struct msg *new_msg_register_opaque_type(uint32_t seqnum, uint8_t ltype,
+ uint8_t otype)
{
struct msg_register_opaque_type rmsg;
sizeof(struct msg_register_opaque_type));
}
-struct msg *new_msg_register_event(u_int32_t seqnum,
+struct msg *new_msg_register_event(uint32_t seqnum,
struct lsa_filter_type *filter)
{
- u_char buf[OSPF_API_MAX_MSG_SIZE];
+ uint8_t buf[OSPF_API_MAX_MSG_SIZE];
struct msg_register_event *emsg;
unsigned int len;
return msg_new(MSG_REGISTER_EVENT, emsg, seqnum, len);
}
-struct msg *new_msg_sync_lsdb(u_int32_t seqnum, struct lsa_filter_type *filter)
+struct msg *new_msg_sync_lsdb(uint32_t seqnum, struct lsa_filter_type *filter)
{
- u_char buf[OSPF_API_MAX_MSG_SIZE];
+ uint8_t buf[OSPF_API_MAX_MSG_SIZE];
struct msg_sync_lsdb *smsg;
unsigned int len;
}
-struct msg *new_msg_originate_request(u_int32_t seqnum, struct in_addr ifaddr,
+struct msg *new_msg_originate_request(uint32_t seqnum, struct in_addr ifaddr,
struct in_addr area_id,
struct lsa_header *data)
{
return msg_new(MSG_ORIGINATE_REQUEST, omsg, seqnum, omsglen);
}
-struct msg *new_msg_delete_request(u_int32_t seqnum, struct in_addr area_id,
- u_char lsa_type, u_char opaque_type,
- u_int32_t opaque_id)
+struct msg *new_msg_delete_request(uint32_t seqnum, struct in_addr area_id,
+ uint8_t lsa_type, uint8_t opaque_type,
+ uint32_t opaque_id)
{
struct msg_delete_request dmsg;
dmsg.area_id = area_id;
}
-struct msg *new_msg_reply(u_int32_t seqnr, u_char rc)
+struct msg *new_msg_reply(uint32_t seqnr, uint8_t rc)
{
struct msg *msg;
struct msg_reply rmsg;
return msg;
}
-struct msg *new_msg_ready_notify(u_int32_t seqnr, u_char lsa_type,
- u_char opaque_type, struct in_addr addr)
+struct msg *new_msg_ready_notify(uint32_t seqnr, uint8_t lsa_type,
+ uint8_t opaque_type, struct in_addr addr)
{
struct msg_ready_notify rmsg;
sizeof(struct msg_ready_notify));
}
-struct msg *new_msg_new_if(u_int32_t seqnr, struct in_addr ifaddr,
+struct msg *new_msg_new_if(uint32_t seqnr, struct in_addr ifaddr,
struct in_addr area_id)
{
struct msg_new_if nmsg;
return msg_new(MSG_NEW_IF, &nmsg, seqnr, sizeof(struct msg_new_if));
}
-struct msg *new_msg_del_if(u_int32_t seqnr, struct in_addr ifaddr)
+struct msg *new_msg_del_if(uint32_t seqnr, struct in_addr ifaddr)
{
struct msg_del_if dmsg;
return msg_new(MSG_DEL_IF, &dmsg, seqnr, sizeof(struct msg_del_if));
}
-struct msg *new_msg_ism_change(u_int32_t seqnr, struct in_addr ifaddr,
- struct in_addr area_id, u_char status)
+struct msg *new_msg_ism_change(uint32_t seqnr, struct in_addr ifaddr,
+ struct in_addr area_id, uint8_t status)
{
struct msg_ism_change imsg;
sizeof(struct msg_ism_change));
}
-struct msg *new_msg_nsm_change(u_int32_t seqnr, struct in_addr ifaddr,
+struct msg *new_msg_nsm_change(uint32_t seqnr, struct in_addr ifaddr,
struct in_addr nbraddr, struct in_addr router_id,
- u_char status)
+ uint8_t status)
{
struct msg_nsm_change nmsg;
sizeof(struct msg_nsm_change));
}
-struct msg *new_msg_lsa_change_notify(u_char msgtype, u_int32_t seqnum,
+struct msg *new_msg_lsa_change_notify(uint8_t msgtype, uint32_t seqnum,
struct in_addr ifaddr,
struct in_addr area_id,
- u_char is_self_originated,
+ uint8_t is_self_originated,
struct lsa_header *data)
{
- u_char buf[OSPF_API_MAX_MSG_SIZE];
+ uint8_t buf[OSPF_API_MAX_MSG_SIZE];
struct msg_lsa_change_notify *nmsg;
unsigned int len;
/* Message header structure, fields are in network byte order and
aligned to four octets. */
struct apimsghdr {
- u_char version; /* OSPF API protocol version */
- u_char msgtype; /* Type of message */
- u_int16_t msglen; /* Length of message w/o header */
- u_int32_t msgseq; /* Sequence number */
+ uint8_t version; /* OSPF API protocol version */
+ uint8_t msgtype; /* Type of message */
+ uint16_t msglen; /* Length of message w/o header */
+ uint32_t msgseq; /* Sequence number */
};
/* Message representation with header and body */
};
/* Prototypes for generic messages. */
-extern struct msg *msg_new(u_char msgtype, void *msgbody, u_int32_t seqnum,
- u_int16_t msglen);
+extern struct msg *msg_new(uint8_t msgtype, void *msgbody, uint32_t seqnum,
+ uint16_t msglen);
extern struct msg *msg_dup(struct msg *msg);
extern void msg_print(struct msg *msg); /* XXX debug only */
extern void msg_free(struct msg *msg);
#define MIN_SEQ 1
#define MAX_SEQ 2147483647
-extern void msg_set_seq(struct msg *msg, u_int32_t seqnr);
-extern u_int32_t msg_get_seq(struct msg *msg);
+extern void msg_set_seq(struct msg *msg, uint32_t seqnr);
+extern uint32_t msg_get_seq(struct msg *msg);
/* -----------------------------------------------------------
* Message fifo queues
#define MSG_NSM_CHANGE 17
struct msg_register_opaque_type {
- u_char lsatype;
- u_char opaquetype;
- u_char pad[2]; /* padding */
+ uint8_t lsatype;
+ uint8_t opaquetype;
+ uint8_t pad[2]; /* padding */
};
struct msg_unregister_opaque_type {
- u_char lsatype;
- u_char opaquetype;
- u_char pad[2]; /* padding */
+ uint8_t lsatype;
+ uint8_t opaquetype;
+ uint8_t pad[2]; /* padding */
};
/* Power2 is needed to convert LSA types into bit positions,
#ifdef ORIGINAL_CODING
-static const u_int16_t Power2[] = {0x0, 0x1, 0x2, 0x4, 0x8, 0x10,
- 0x20, 0x40, 0x80, 0x100, 0x200, 0x400,
- 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
+static const uint16_t Power2[] = {0x0, 0x1, 0x2, 0x4, 0x8, 0x10,
+ 0x20, 0x40, 0x80, 0x100, 0x200, 0x400,
+ 0x800, 0x1000, 0x2000, 0x4000, 0x8000};
#else
-static const u_int16_t Power2[] = {
+static const uint16_t Power2[] = {
0, (1 << 0), (1 << 1), (1 << 2), (1 << 3), (1 << 4),
(1 << 5), (1 << 6), (1 << 7), (1 << 8), (1 << 9), (1 << 10),
(1 << 11), (1 << 12), (1 << 13), (1 << 14), (1 << 15)};
#endif /* ORIGINAL_CODING */
struct lsa_filter_type {
- u_int16_t typemask; /* bitmask for selecting LSA types (1..16) */
- u_char origin; /* selects according to origin. */
+ uint16_t typemask; /* bitmask for selecting LSA types (1..16) */
+ uint8_t origin; /* selects according to origin. */
#define NON_SELF_ORIGINATED 0
#define SELF_ORIGINATED (OSPF_LSA_SELF)
#define ANY_ORIGIN 2
- u_char num_areas; /* number of areas in the filter. */
- /* areas, if any, go here. */
+ uint8_t num_areas; /* number of areas in the filter. */
+ /* areas, if any, go here. */
};
struct msg_register_event {
struct msg_delete_request {
struct in_addr area_id; /* "0.0.0.0" for AS-external opaque LSAs */
- u_char lsa_type;
- u_char opaque_type;
- u_char pad[2]; /* padding */
- u_int32_t opaque_id;
+ uint8_t lsa_type;
+ uint8_t opaque_type;
+ uint8_t pad[2]; /* padding */
+ uint32_t opaque_id;
};
struct msg_reply {
#define OSPF_API_NOMEMORY (-8)
#define OSPF_API_ERROR (-9)
#define OSPF_API_UNDEF (-10)
- u_char pad[3]; /* padding to four byte alignment */
+ uint8_t pad[3]; /* padding to four byte alignment */
};
/* Message to tell client application that it ospf daemon is
* ready to accept opaque LSAs for a given interface or area. */
struct msg_ready_notify {
- u_char lsa_type;
- u_char opaque_type;
- u_char pad[2]; /* padding */
+ uint8_t lsa_type;
+ uint8_t opaque_type;
+ uint8_t pad[2]; /* padding */
struct in_addr addr; /* interface address or area address */
};
struct in_addr ifaddr;
/* Area ID. Not valid for AS-External and Opaque11 LSAs. */
struct in_addr area_id;
- u_char is_self_originated; /* 1 if self originated. */
- u_char pad[3];
+ uint8_t is_self_originated; /* 1 if self originated. */
+ uint8_t pad[3];
struct lsa_header data;
};
struct msg_ism_change {
struct in_addr ifaddr; /* interface IP address */
struct in_addr area_id; /* area this interface belongs to */
- u_char status; /* interface status (up/down) */
- u_char pad[3]; /* not used */
+ uint8_t status; /* interface status (up/down) */
+ uint8_t pad[3]; /* not used */
};
struct msg_nsm_change {
struct in_addr ifaddr; /* attached interface */
struct in_addr nbraddr; /* Neighbor interface address */
struct in_addr router_id; /* Router ID of neighbor */
- u_char status; /* NSM status */
- u_char pad[3];
+ uint8_t status; /* NSM status */
+ uint8_t pad[3];
};
/* We make use of a union to define a structure that covers all
extern void api_opaque_lsa_print(struct lsa_header *data);
/* Messages sent by client */
-extern struct msg *new_msg_register_opaque_type(u_int32_t seqnum, u_char ltype,
- u_char otype);
-extern struct msg *new_msg_register_event(u_int32_t seqnum,
+extern struct msg *new_msg_register_opaque_type(uint32_t seqnum, uint8_t ltype,
+ uint8_t otype);
+extern struct msg *new_msg_register_event(uint32_t seqnum,
struct lsa_filter_type *filter);
-extern struct msg *new_msg_sync_lsdb(u_int32_t seqnum,
+extern struct msg *new_msg_sync_lsdb(uint32_t seqnum,
struct lsa_filter_type *filter);
-extern struct msg *new_msg_originate_request(u_int32_t seqnum,
+extern struct msg *new_msg_originate_request(uint32_t seqnum,
struct in_addr ifaddr,
struct in_addr area_id,
struct lsa_header *data);
-extern struct msg *new_msg_delete_request(u_int32_t seqnum,
+extern struct msg *new_msg_delete_request(uint32_t seqnum,
struct in_addr area_id,
- u_char lsa_type, u_char opaque_type,
- u_int32_t opaque_id);
+ uint8_t lsa_type, uint8_t opaque_type,
+ uint32_t opaque_id);
/* Messages sent by OSPF daemon */
-extern struct msg *new_msg_reply(u_int32_t seqnum, u_char rc);
+extern struct msg *new_msg_reply(uint32_t seqnum, uint8_t rc);
-extern struct msg *new_msg_ready_notify(u_int32_t seqnr, u_char lsa_type,
- u_char opaque_type,
+extern struct msg *new_msg_ready_notify(uint32_t seqnr, uint8_t lsa_type,
+ uint8_t opaque_type,
struct in_addr addr);
-extern struct msg *new_msg_new_if(u_int32_t seqnr, struct in_addr ifaddr,
+extern struct msg *new_msg_new_if(uint32_t seqnr, struct in_addr ifaddr,
struct in_addr area);
-extern struct msg *new_msg_del_if(u_int32_t seqnr, struct in_addr ifaddr);
+extern struct msg *new_msg_del_if(uint32_t seqnr, struct in_addr ifaddr);
-extern struct msg *new_msg_ism_change(u_int32_t seqnr, struct in_addr ifaddr,
- struct in_addr area, u_char status);
+extern struct msg *new_msg_ism_change(uint32_t seqnr, struct in_addr ifaddr,
+ struct in_addr area, uint8_t status);
-extern struct msg *new_msg_nsm_change(u_int32_t seqnr, struct in_addr ifaddr,
+extern struct msg *new_msg_nsm_change(uint32_t seqnr, struct in_addr ifaddr,
struct in_addr nbraddr,
- struct in_addr router_id, u_char status);
+ struct in_addr router_id, uint8_t status);
/* msgtype is MSG_LSA_UPDATE_NOTIFY or MSG_LSA_DELETE_NOTIFY */
-extern struct msg *new_msg_lsa_change_notify(u_char msgtype, u_int32_t seqnum,
+extern struct msg *new_msg_lsa_change_notify(uint8_t msgtype, uint32_t seqnum,
struct in_addr ifaddr,
struct in_addr area_id,
- u_char is_self_originated,
+ uint8_t is_self_originated,
struct lsa_header *data);
/* string printing functions */
/* XXX */
}
-static struct ospf_apiserver *lookup_apiserver(u_char lsa_type,
- u_char opaque_type)
+static struct ospf_apiserver *lookup_apiserver(uint8_t lsa_type,
+ uint8_t opaque_type)
{
struct listnode *n1, *n2;
struct registered_opaque_type *r;
return 0;
}
-int ospf_apiserver_send_reply(struct ospf_apiserver *apiserv, u_int32_t seqnr,
- u_char rc)
+int ospf_apiserver_send_reply(struct ospf_apiserver *apiserv, uint32_t seqnr,
+ uint8_t rc)
{
struct msg *msg = new_msg_reply(seqnr, rc);
int ret;
*/
int ospf_apiserver_register_opaque_type(struct ospf_apiserver *apiserv,
- u_char lsa_type, u_char opaque_type)
+ uint8_t lsa_type, uint8_t opaque_type)
{
struct registered_opaque_type *regtype;
int (*originator_func)(void *arg);
}
int ospf_apiserver_unregister_opaque_type(struct ospf_apiserver *apiserv,
- u_char lsa_type, u_char opaque_type)
+ uint8_t lsa_type, uint8_t opaque_type)
{
struct listnode *node, *nnode;
struct registered_opaque_type *regtype;
static int apiserver_is_opaque_type_registered(struct ospf_apiserver *apiserv,
- u_char lsa_type,
- u_char opaque_type)
+ uint8_t lsa_type,
+ uint8_t opaque_type)
{
struct listnode *node, *nnode;
struct registered_opaque_type *regtype;
struct msg *msg)
{
struct msg_register_opaque_type *rmsg;
- u_char lsa_type;
- u_char opaque_type;
+ uint8_t lsa_type;
+ uint8_t opaque_type;
int rc = 0;
/* Extract parameters from register opaque type message */
struct msg *msg)
{
struct msg_unregister_opaque_type *umsg;
- u_char ltype;
- u_char otype;
+ uint8_t ltype;
+ uint8_t otype;
int rc = 0;
/* Extract parameters from unregister opaque type message */
{
struct msg_register_event *rmsg;
int rc;
- u_int32_t seqnum;
+ uint32_t seqnum;
rmsg = (struct msg_register_event *)STREAM_DATA(msg->s);
param = (struct param_t *)p_arg;
apiserv = param->apiserv;
- seqnum = (u_int32_t)int_arg;
+ seqnum = (uint32_t)int_arg;
/* Check origin in filter. */
if ((param->filter->origin == ANY_ORIGIN)
struct msg *msg)
{
struct listnode *node, *nnode;
- u_int32_t seqnum;
+ uint32_t seqnum;
int rc = 0;
struct msg_sync_lsdb *smsg;
struct ospf_apiserver_param_t {
struct ospf_apiserver *apiserv;
struct lsa_filter_type *filter;
} param;
- u_int16_t mask;
+ uint16_t mask;
struct route_node *rn;
struct ospf_lsa *lsa;
struct ospf *ospf;
/* Iterate over all areas. */
for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area)) {
int i;
- u_int32_t *area_id = NULL;
+ uint32_t *area_id = NULL;
/* Compare area_id with area_ids in sync request. */
if ((i = smsg->filter.num_areas) > 0) {
/* Let area_id point to the list of area IDs,
* which is at the end of smsg->filter. */
- area_id = (u_int32_t *)(&smsg->filter + 1);
+ area_id = (uint32_t *)(&smsg->filter + 1);
while (i) {
if (*area_id == area->area_id.s_addr) {
break;
struct stream *s;
struct lsa_header *newlsa;
struct ospf_lsa *new = NULL;
- u_char options = 0x0;
- u_int16_t length;
+ uint8_t options = 0x0;
+ uint16_t length;
struct ospf *ospf;
ospf->router_id);
/* Set opaque-LSA body fields. */
- stream_put(s, ((u_char *)protolsa) + sizeof(struct lsa_header),
+ stream_put(s, ((uint8_t *)protolsa) + sizeof(struct lsa_header),
ntohs(protolsa->length) - sizeof(struct lsa_header));
/* Determine length of LSA. */
{
struct param_t {
struct ospf_apiserver *apiserv;
- u_char lsa_type;
- u_char opaque_type;
+ uint8_t lsa_type;
+ uint8_t opaque_type;
} * param;
/* Sanity check */
type or a connection to an application closes and all those opaque
LSAs need to be flushed the LSDB. */
void ospf_apiserver_flush_opaque_lsa(struct ospf_apiserver *apiserv,
- u_char lsa_type, u_char opaque_type)
+ uint8_t lsa_type, uint8_t opaque_type)
{
struct param_t {
struct ospf_apiserver *apiserv;
- u_char lsa_type;
- u_char opaque_type;
+ uint8_t lsa_type;
+ uint8_t opaque_type;
} param;
struct listnode *node, *nnode;
struct ospf *ospf;
{
struct opaque_lsa {
struct lsa_header header;
- u_char data[1]; /* opaque data have variable length. This is
+ uint8_t data[1]; /* opaque data have variable length. This is
start
address */
};
msg_free(msg);
}
-static void apiserver_clients_lsa_change_notify(u_char msgtype,
+static void apiserver_clients_lsa_change_notify(uint8_t msgtype,
struct ospf_lsa *lsa)
{
struct msg *msg;
/* Now send message to all clients with a matching filter */
for (ALL_LIST_ELEMENTS(apiserver_list, node, nnode, apiserv)) {
struct lsa_filter_type *filter;
- u_int16_t mask;
- u_int32_t *area;
+ uint16_t mask;
+ uint32_t *area;
int i;
/* Check filter for this client. */
}
if (i > 0) {
- area = (u_int32_t *)(filter + 1);
+ area = (uint32_t *)(filter + 1);
while (i) {
if (*area == area_id.s_addr) {
break;
*/
-static int apiserver_notify_clients_lsa(u_char msgtype, struct ospf_lsa *lsa)
+static int apiserver_notify_clients_lsa(uint8_t msgtype, struct ospf_lsa *lsa)
{
struct msg *msg;
/* default area for AS-External and Opaque11 LSAs */
/* List of opaque types that application registered */
struct registered_opaque_type {
- u_char lsa_type;
- u_char opaque_type;
+ uint8_t lsa_type;
+ uint8_t opaque_type;
};
extern int ospf_apiserver_sync_write(struct thread *thread);
extern int ospf_apiserver_async_write(struct thread *thread);
extern int ospf_apiserver_send_reply(struct ospf_apiserver *apiserv,
- u_int32_t seqnr, u_char rc);
+ uint32_t seqnr, uint8_t rc);
/* -----------------------------------------------------------
* Followings are message handler functions
*/
extern int ospf_apiserver_register_opaque_type(struct ospf_apiserver *apiserver,
- u_char lsa_type,
- u_char opaque_type);
+ uint8_t lsa_type,
+ uint8_t opaque_type);
extern int
ospf_apiserver_unregister_opaque_type(struct ospf_apiserver *apiserver,
- u_char lsa_type, u_char opaque_type);
+ uint8_t lsa_type, uint8_t opaque_type);
extern struct ospf_lsa *
ospf_apiserver_opaque_lsa_new(struct ospf_area *area, struct ospf_interface *oi,
struct lsa_header *protolsa);
extern int ospf_ospf_apiserver_lsa_originator(void *arg);
extern struct ospf_lsa *ospf_apiserver_lsa_refresher(struct ospf_lsa *lsa);
extern void ospf_apiserver_flush_opaque_lsa(struct ospf_apiserver *apiserv,
- u_char lsa_type,
- u_char opaque_type);
+ uint8_t lsa_type,
+ uint8_t opaque_type);
/* -----------------------------------------------------------
* Followings are hooks when LSAs are updated or deleted
extern int ospf_apiserver_lsa_update(struct ospf_lsa *lsa);
extern int ospf_apiserver_lsa_delete(struct ospf_lsa *lsa);
-extern void ospf_apiserver_clients_lsa_change_notify(u_char msgtype,
+extern void ospf_apiserver_clients_lsa_change_notify(uint8_t msgtype,
struct ospf_lsa *lsa);
#endif /* _OSPF_APISERVER_H */
/* Add an External info for AS-external-LSA. */
-struct external_info *ospf_external_info_new(u_char type, u_short instance)
+struct external_info *ospf_external_info_new(uint8_t type,
+ unsigned short instance)
{
struct external_info *new;
/* Add an External info for AS-external-LSA. */
struct external_info *
-ospf_external_info_add(struct ospf *ospf, u_char type, u_short instance,
+ospf_external_info_add(struct ospf *ospf, uint8_t type, unsigned short instance,
struct prefix_ipv4 p, ifindex_t ifindex,
struct in_addr nexthop, route_tag_t tag)
{
return new;
}
-void ospf_external_info_delete(struct ospf *ospf, u_char type, u_short instance,
- struct prefix_ipv4 p)
+void ospf_external_info_delete(struct ospf *ospf, uint8_t type,
+ unsigned short instance, struct prefix_ipv4 p)
{
struct route_node *rn;
struct ospf_external *ext;
}
}
-struct external_info *ospf_external_info_lookup(struct ospf *ospf, u_char type,
- u_short instance,
+struct external_info *ospf_external_info_lookup(struct ospf *ospf, uint8_t type,
+ unsigned short instance,
struct prefix_ipv4 *p)
{
struct route_node *rn;
/* Update ASBR status. */
-void ospf_asbr_status_update(struct ospf *ospf, u_char status)
+void ospf_asbr_status_update(struct ospf *ospf, uint8_t status)
{
zlog_info("ASBR[Status:%d]: Update", status);
ospf_router_lsa_update(ospf);
}
-void ospf_redistribute_withdraw(struct ospf *ospf, u_char type,
- u_short instance)
+void ospf_redistribute_withdraw(struct ospf *ospf, uint8_t type,
+ unsigned short instance)
{
struct route_node *rn;
struct external_info *ei;
/* Redistributed external information. */
struct external_info {
/* Type of source protocol. */
- u_char type;
+ uint8_t type;
- u_short instance;
+ unsigned short instance;
/* Prefix. */
struct prefix_ipv4 p;
#define OSPF_ASBR_CHECK_DELAY 30
extern void ospf_external_route_remove(struct ospf *, struct prefix_ipv4 *);
-extern struct external_info *ospf_external_info_new(u_char, u_short);
+extern struct external_info *ospf_external_info_new(uint8_t, unsigned short);
extern void ospf_reset_route_map_set_values(struct route_map_set_values *);
extern int ospf_route_map_set_compare(struct route_map_set_values *,
struct route_map_set_values *);
-extern struct external_info *ospf_external_info_add(struct ospf *, u_char,
- u_short, struct prefix_ipv4,
+extern struct external_info *ospf_external_info_add(struct ospf *, uint8_t,
+ unsigned short,
+ struct prefix_ipv4,
ifindex_t, struct in_addr,
route_tag_t);
-extern void ospf_external_info_delete(struct ospf *, u_char, u_short,
+extern void ospf_external_info_delete(struct ospf *, uint8_t, unsigned short,
struct prefix_ipv4);
-extern struct external_info *
-ospf_external_info_lookup(struct ospf *, u_char, u_short, struct prefix_ipv4 *);
+extern struct external_info *ospf_external_info_lookup(struct ospf *, uint8_t,
+ unsigned short,
+ struct prefix_ipv4 *);
extern struct ospf_route *ospf_external_route_lookup(struct ospf *,
struct prefix_ipv4 *);
-extern void ospf_asbr_status_update(struct ospf *, u_char);
+extern void ospf_asbr_status_update(struct ospf *, uint8_t);
-extern void ospf_redistribute_withdraw(struct ospf *, u_char, u_short);
+extern void ospf_redistribute_withdraw(struct ospf *, uint8_t, unsigned short);
extern void ospf_asbr_check(void);
extern void ospf_schedule_asbr_check(void);
extern void ospf_asbr_route_install_lsa(struct ospf_lsa *);
static struct ospf_route *
ospf_ase_calculate_new_route(struct ospf_lsa *lsa,
- struct ospf_route *asbr_route, u_int32_t metric)
+ struct ospf_route *asbr_route, uint32_t metric)
{
struct as_external_lsa *al;
struct ospf_route *new;
int ospf_ase_calculate_route(struct ospf *ospf, struct ospf_lsa *lsa)
{
- u_int32_t metric;
+ uint32_t metric;
struct as_external_lsa *al;
struct ospf_route *asbr_route;
struct prefix_ipv4 asbr, p;
* ospf_bfd_show_info - Show BFD info structure
*/
void ospf_bfd_show_info(struct vty *vty, void *bfd_info, json_object *json_obj,
- u_char use_json, int param_only)
+ uint8_t use_json, int param_only)
{
if (param_only)
bfd_show_param(vty, (struct bfd_info *)bfd_info, 1, 0, use_json,
* ospf_bfd_interface_show - Show the interface BFD configuration.
*/
void ospf_bfd_interface_show(struct vty *vty, struct interface *ifp,
- json_object *json_interface_sub, u_char use_json)
+ json_object *json_interface_sub, uint8_t use_json)
{
struct ospf_if_params *params;
* ospf_bfd_if_param_set - Set the configured BFD paramter values for
* interface.
*/
-static void ospf_bfd_if_param_set(struct interface *ifp, u_int32_t min_rx,
- u_int32_t min_tx, u_int8_t detect_mult,
+static void ospf_bfd_if_param_set(struct interface *ifp, uint32_t min_rx,
+ uint32_t min_tx, uint8_t detect_mult,
int defaults)
{
struct ospf_if_params *params;
int idx_number = 3;
int idx_number_2 = 4;
int idx_number_3 = 5;
- 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;
assert(ifp);
extern void ospf_bfd_interface_show(struct vty *vty, struct interface *ifp,
json_object *json_interface_sub,
- u_char use_json);
+ uint8_t use_json);
extern void ospf_bfd_info_nbr_create(struct ospf_interface *oi,
struct ospf_neighbor *nbr);
extern void ospf_bfd_show_info(struct vty *vty, void *bfd_info,
- json_object *json_obj, u_char use_json,
+ json_object *json_obj, uint8_t use_json,
int param_only);
extern void ospf_bfd_info_free(void **bfd_info);
unsigned long term_debug_ospf_ext = 0;
unsigned long term_debug_ospf_sr = 0;
-const char *ospf_redist_string(u_int route_type)
+const char *ospf_redist_string(unsigned int route_type)
{
return (route_type == ZEBRA_ROUTE_MAX) ? "Default"
: zebra_route_string(route_type);
const char *ospf_area_name_string(struct ospf_area *area)
{
static char buf[OSPF_AREA_STRING_MAXLEN] = "";
- u_int32_t area_id;
+ uint32_t area_id;
if (!area)
return "-";
const char *ospf_area_desc_string(struct ospf_area *area)
{
static char buf[OSPF_AREA_DESC_STRING_MAXLEN] = "";
- u_char type;
+ uint8_t type;
if (!area)
return "(incomplete)";
const char *ospf_if_name_string(struct ospf_interface *oi)
{
static char buf[OSPF_IF_STRING_MAXLEN] = "";
- u_int32_t ifaddr;
+ uint32_t ifaddr;
if (!oi || !oi->address)
return "inactive";
return ospf_timeval_dump(&result, buf, size);
}
-static void ospf_packet_hello_dump(struct stream *s, u_int16_t length)
+static void ospf_packet_hello_dump(struct stream *s, uint16_t length)
{
struct ospf_hello *hello;
int i;
ospf_options_dump(hello->options));
zlog_debug(" RtrPriority %d", hello->priority);
zlog_debug(" RtrDeadInterval %ld",
- (u_long)ntohl(hello->dead_interval));
+ (unsigned long)ntohl(hello->dead_interval));
zlog_debug(" DRouter %s", inet_ntoa(hello->d_router));
zlog_debug(" BDRouter %s", inet_ntoa(hello->bd_router));
zlog_debug(" Neighbor %s", inet_ntoa(hello->neighbors[i]));
}
-static char *ospf_dd_flags_dump(u_char flags, char *buf, size_t size)
+static char *ospf_dd_flags_dump(uint8_t flags, char *buf, size_t size)
{
memset(buf, 0, size);
return buf;
}
-static char *ospf_router_lsa_flags_dump(u_char flags, char *buf, size_t size)
+static char *ospf_router_lsa_flags_dump(uint8_t flags, char *buf, size_t size)
{
memset(buf, 0, size);
return buf;
}
-static void ospf_router_lsa_dump(struct stream *s, u_int16_t length)
+static void ospf_router_lsa_dump(struct stream *s, uint16_t length)
{
char buf[BUFSIZ];
struct router_lsa *rl;
zlog_debug(" Link ID %s", inet_ntoa(rl->link[i].link_id));
zlog_debug(" Link Data %s",
inet_ntoa(rl->link[i].link_data));
- zlog_debug(" Type %d", (u_char)rl->link[i].type);
- zlog_debug(" TOS %d", (u_char)rl->link[i].tos);
+ zlog_debug(" Type %d", (uint8_t)rl->link[i].type);
+ zlog_debug(" TOS %d", (uint8_t)rl->link[i].tos);
zlog_debug(" metric %d", ntohs(rl->link[i].metric));
len -= 12;
}
}
-static void ospf_network_lsa_dump(struct stream *s, u_int16_t length)
+static void ospf_network_lsa_dump(struct stream *s, uint16_t length)
{
struct network_lsa *nl;
int i, cnt;
inet_ntoa(nl->routers[i]));
}
-static void ospf_summary_lsa_dump(struct stream *s, u_int16_t length)
+static void ospf_summary_lsa_dump(struct stream *s, uint16_t length)
{
struct summary_lsa *sl;
int size;
GET_METRIC(sl->metric));
}
-static void ospf_as_external_lsa_dump(struct stream *s, u_int16_t length)
+static void ospf_as_external_lsa_dump(struct stream *s, uint16_t length)
{
struct as_external_lsa *al;
int size;
}
}
-static void ospf_lsa_header_list_dump(struct stream *s, u_int16_t length)
+static void ospf_lsa_header_list_dump(struct stream *s, uint16_t length)
{
struct lsa_header *lsa;
}
}
-static void ospf_packet_db_desc_dump(struct stream *s, u_int16_t length)
+static void ospf_packet_db_desc_dump(struct stream *s, uint16_t length)
{
struct ospf_db_desc *dd;
char dd_flags[8];
- u_int32_t gp;
+ uint32_t gp;
gp = stream_get_getp(s);
dd = (struct ospf_db_desc *)stream_pnt(s);
ospf_options_dump(dd->options));
zlog_debug(" Flags %d (%s)", dd->flags,
ospf_dd_flags_dump(dd->flags, dd_flags, sizeof dd_flags));
- zlog_debug(" Sequence Number 0x%08lx", (u_long)ntohl(dd->dd_seqnum));
+ zlog_debug(" Sequence Number 0x%08lx",
+ (unsigned long)ntohl(dd->dd_seqnum));
length -= OSPF_HEADER_SIZE + OSPF_DB_DESC_MIN_SIZE;
stream_set_getp(s, gp);
}
-static void ospf_packet_ls_req_dump(struct stream *s, u_int16_t length)
+static void ospf_packet_ls_req_dump(struct stream *s, uint16_t length)
{
- u_int32_t sp;
- u_int32_t ls_type;
+ uint32_t sp;
+ uint32_t ls_type;
struct in_addr ls_id;
struct in_addr adv_router;
stream_set_getp(s, sp);
}
-static void ospf_packet_ls_upd_dump(struct stream *s, u_int16_t length)
+static void ospf_packet_ls_upd_dump(struct stream *s, uint16_t length)
{
- u_int32_t sp;
+ uint32_t sp;
struct lsa_header *lsa;
int lsa_len;
- u_int32_t count;
+ uint32_t count;
length -= OSPF_HEADER_SIZE;
stream_set_getp(s, sp);
}
-static void ospf_packet_ls_ack_dump(struct stream *s, u_int16_t length)
+static void ospf_packet_ls_ack_dump(struct stream *s, uint16_t length)
{
- u_int32_t sp;
+ uint32_t sp;
length -= OSPF_HEADER_SIZE;
sp = stream_get_getp(s);
zlog_debug("ip_hl %d", iph->ip_hl);
zlog_debug("ip_tos %d", iph->ip_tos);
zlog_debug("ip_len %d", 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 %d", iph->ip_ttl);
zlog_debug("ip_p %d", 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));
}
static void ospf_header_dump(struct ospf_header *ospfh)
{
char buf[9];
- u_int16_t auth_type = ntohs(ospfh->auth_type);
+ uint16_t auth_type = ntohs(ospfh->auth_type);
zlog_debug("Header");
zlog_debug(" Version %d", ospfh->version);
zlog_debug(" Key ID %d", ospfh->u.crypt.key_id);
zlog_debug(" Auth Data Len %d", ospfh->u.crypt.auth_data_len);
zlog_debug(" Sequence number %ld",
- (u_long)ntohl(ospfh->u.crypt.crypt_seqnum));
+ (unsigned long)ntohl(ospfh->u.crypt.crypt_seqnum));
break;
default:
zlog_debug("* This is not supported authentication type");
"NSM Timer Information\n")
{
int idx_number = 2;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"NSM Timer Information\n")
{
int idx_number = 3;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"LSA Refresh\n")
{
int idx_number = 2;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"LSA Refres\n")
{
int idx_number = 3;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"Zebra redistribute\n")
{
int idx_number = 2;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"Zebra redistribute\n")
{
int idx_number = 3;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"OSPF event information\n")
{
int idx_number = 2;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"OSPF event information\n")
{
int idx_number = 3;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"OSPF nssa information\n")
{
int idx_number = 2;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
"OSPF nssa information\n")
{
int idx_number = 3;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if (!ospf_lookup_instance(instance))
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
if ((ospf = ospf_lookup_instance(instance)) == NULL)
#define OSPF_OPTION_STR_MAXLEN 24
-char *ospf_options_dump(u_char options)
+char *ospf_options_dump(uint8_t options)
{
static char buf[OSPF_OPTION_STR_MAXLEN];
zlog_debug(" Link State ID %s", inet_ntoa(lsah->id));
zlog_debug(" Advertising Router %s", inet_ntoa(lsah->adv_router));
zlog_debug(" LS sequence number 0x%lx",
- (u_long)ntohl(lsah->ls_seqnum));
+ (unsigned long)ntohl(lsah->ls_seqnum));
zlog_debug(" LS checksum 0x%x", ntohs(lsah->checksum));
zlog_debug(" length %d", ntohs(lsah->length));
}
extern const int ospf_network_type_msg_max;
extern const size_t ospf_auth_type_str_max;
-extern char *ospf_options_dump(u_char);
+extern char *ospf_options_dump(uint8_t);
extern void ospf_lsa_header_dump(struct lsa_header *);
#endif /* _ZEBRA_OSPF_DUMP_API_H */
struct lsa_header *lsah;
struct ospf_lsa *new = NULL;
struct ospf *top;
- u_char options, lsa_type;
+ uint8_t options, lsa_type;
struct in_addr lsa_id;
struct in_addr router_id;
uint32_t tmp;
struct stream *s;
struct lsa_header *lsah;
struct ospf_lsa *new = NULL;
- u_char options, lsa_type;
+ uint8_t options, lsa_type;
struct in_addr lsa_id;
uint32_t tmp;
uint16_t length;
struct ospf_route *abr_or, *new_or;
struct summary_lsa *sl;
struct prefix_ipv4 p, abr;
- u_int32_t metric;
+ uint32_t metric;
if (lsa == NULL)
return 0;
struct route_node *rn;
struct ospf_route * or, *abr_or, *new_or;
struct prefix_ipv4 abr;
- u_int32_t cost;
+ uint32_t cost;
abr.family = AF_INET;
abr.prefix = lsa->header.adv_router;
{
struct ospf_route * or, *abr_or, *new_or;
struct prefix_ipv4 abr;
- u_int32_t cost;
+ uint32_t cost;
abr.family = AF_INET;
abr.prefix = lsa->header.adv_router;
struct ospf *ospf = area->ospf;
struct summary_lsa *sl;
struct prefix_ipv4 p;
- u_int32_t metric;
+ uint32_t metric;
if (lsa == NULL)
return 0;
int ospf_if_get_output_cost(struct ospf_interface *oi)
{
/* If all else fails, use default OSPF cost */
- u_int32_t cost;
- u_int32_t bw, refbw;
+ uint32_t cost;
+ uint32_t bw, refbw;
/* ifp speed and bw can be 0 in some platforms, use ospf default bw
if bw is configured under interface it would be used.
/* See if a cost can be calculated from the zebra processes
interface bandwidth field. */
else {
- cost = (u_int32_t)((double)refbw / (double)bw + (double)0.5);
+ cost = (uint32_t)((double)refbw / (double)bw + (double)0.5);
if (cost < 1)
cost = 1;
else if (cost > 65535)
void ospf_if_recalculate_output_cost(struct interface *ifp)
{
- u_int32_t newcost;
+ uint32_t newcost;
struct route_node *rn;
for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
XFREE(MTYPE_OSPF_VL_DATA, vl_data);
}
-u_int vlink_count = 0;
+unsigned int vlink_count = 0;
struct ospf_interface *ospf_vl_new(struct ospf *ospf,
struct ospf_vl_data *vl_data)
listnode_add(crypt, ck);
}
-struct crypt_key *ospf_crypt_key_lookup(struct list *auth_crypt, u_char key_id)
+struct crypt_key *ospf_crypt_key_lookup(struct list *auth_crypt, uint8_t key_id)
{
struct listnode *node;
struct crypt_key *ck;
return NULL;
}
-int ospf_crypt_key_delete(struct list *auth_crypt, u_char key_id)
+int ospf_crypt_key_delete(struct list *auth_crypt, uint8_t key_id)
{
struct listnode *node, *nnode;
struct crypt_key *ck;
return 0;
}
-u_char ospf_default_iftype(struct interface *ifp)
+uint8_t ospf_default_iftype(struct interface *ifp)
{
if (if_is_pointopoint(ifp))
return OSPF_IFTYPE_POINTOPOINT;
? (O)->params->P \
: IF_DEF_PARAMS((O)->ifp)->P)
-#define DECLARE_IF_PARAM(T, P) T P; u_char P##__config:1
+#define DECLARE_IF_PARAM(T, P) \
+ T P; \
+ uint8_t P##__config : 1
#define UNSET_IF_PARAM(S, P) ((S)->P##__config) = 0
#define SET_IF_PARAM(S, P) ((S)->P##__config) = 1
struct ospf_if_params {
- DECLARE_IF_PARAM(u_int32_t,
+ DECLARE_IF_PARAM(uint32_t,
transmit_delay); /* Interface Transmisson Delay */
- DECLARE_IF_PARAM(u_int32_t,
+ DECLARE_IF_PARAM(uint32_t,
output_cost_cmd); /* Command Interface Output Cost */
- DECLARE_IF_PARAM(u_int32_t,
+ DECLARE_IF_PARAM(uint32_t,
retransmit_interval); /* Retransmission Interval */
- DECLARE_IF_PARAM(u_char, passive_interface); /* OSPF Interface is
+ DECLARE_IF_PARAM(uint8_t, passive_interface); /* OSPF Interface is
passive: no sending or
receiving (no need to
join multicast groups)
*/
- DECLARE_IF_PARAM(u_char, priority); /* OSPF Interface priority */
+ DECLARE_IF_PARAM(uint8_t, priority); /* OSPF Interface priority */
/* Enable OSPF on this interface with area if_area */
DECLARE_IF_PARAM(struct in_addr, if_area);
- u_int32_t if_area_id_fmt;
+ uint32_t if_area_id_fmt;
- DECLARE_IF_PARAM(u_char, type); /* type of interface */
+ DECLARE_IF_PARAM(uint8_t, type); /* type of interface */
#define OSPF_IF_ACTIVE 0
#define OSPF_IF_PASSIVE 1
? IF_DEF_PARAMS((O)->ifp)->passive_interface \
: (O)->ospf->passive_interface_default))
- DECLARE_IF_PARAM(u_int32_t, v_hello); /* Hello Interval */
- DECLARE_IF_PARAM(u_int32_t, v_wait); /* Router Dead Interval */
+ DECLARE_IF_PARAM(uint32_t, v_hello); /* Hello Interval */
+ DECLARE_IF_PARAM(uint32_t, v_wait); /* Router Dead Interval */
/* MTU mismatch check (see RFC2328, chap 10.6) */
- DECLARE_IF_PARAM(u_char, mtu_ignore);
+ DECLARE_IF_PARAM(uint8_t, mtu_ignore);
/* Fast-Hellos */
- DECLARE_IF_PARAM(u_char, fast_hello);
+ DECLARE_IF_PARAM(uint8_t, fast_hello);
/* Authentication data. */
- u_char auth_simple[OSPF_AUTH_SIMPLE_SIZE + 1]; /* Simple password. */
- u_char auth_simple__config : 1;
+ uint8_t auth_simple[OSPF_AUTH_SIMPLE_SIZE + 1]; /* Simple password. */
+ uint8_t auth_simple__config : 1;
DECLARE_IF_PARAM(struct list *,
auth_crypt); /* List of Auth cryptographic data. */
DECLARE_IF_PARAM(int, auth_type); /* OSPF authentication type */
/* Other, non-configuration state */
- u_int32_t network_lsa_seqnum; /* Network LSA seqnum */
+ uint32_t network_lsa_seqnum; /* Network LSA seqnum */
/* BFD configuration */
struct bfd_info *bfd_info;
struct ospf_interface *vl_oi; /* Interface data structure */
struct vertex_nexthop nexthop; /* Nexthop router and oi to use */
struct in_addr peer_addr; /* Address used to reach the peer */
- u_char flags;
+ uint8_t flags;
};
#define OSPF_VL_FLAG_APPROVED 0x01
struct crypt_key {
- u_char key_id;
- u_char auth_key[OSPF_AUTH_MD5_SIZE + 1];
+ uint8_t key_id;
+ uint8_t auth_key[OSPF_AUTH_MD5_SIZE + 1];
};
/* OSPF interface structure. */
struct ospf_fifo *obuf; /* Output queue */
/* OSPF Network Type. */
- u_char type;
+ uint8_t type;
/* State of Interface State Machine. */
- u_char state;
+ uint8_t state;
/* To which multicast groups do we currently belong? */
- u_char multicast_memberships;
+ uint8_t multicast_memberships;
#define OI_MEMBER_FLAG(M) (1 << (M))
#define OI_MEMBER_COUNT(O,M) (IF_OSPF_IF_INFO(oi->ifp)->membership_counts[(M)])
#define OI_MEMBER_CHECK(O, M) \
/* Configured varables. */
struct ospf_if_params *params;
- u_int32_t crypt_seqnum; /* Cryptographic Sequence Number */
- u_int32_t output_cost; /* Acutual Interface Output Cost */
+ uint32_t crypt_seqnum; /* Cryptographic Sequence Number */
+ uint32_t output_cost; /* Acutual Interface Output Cost */
/* Neighbor information. */
struct route_table *nbrs; /* OSPF Neighbor List */
} ls_ack_direct;
/* Timer values. */
- u_int32_t v_ls_ack; /* Delayed Link State Acknowledgment */
+ uint32_t v_ls_ack; /* Delayed Link State Acknowledgment */
/* Threads. */
struct thread *t_hello; /* timer */
int on_write_q;
/* Statistics fields. */
- u_int32_t hello_in; /* Hello message input count. */
- u_int32_t hello_out; /* Hello message output count. */
- u_int32_t db_desc_in; /* database desc. message input count. */
- u_int32_t db_desc_out; /* database desc. message output count. */
- u_int32_t ls_req_in; /* LS request message input count. */
- u_int32_t ls_req_out; /* LS request message output count. */
- u_int32_t ls_upd_in; /* LS update message input count. */
- u_int32_t ls_upd_out; /* LS update message output count. */
- u_int32_t ls_ack_in; /* LS Ack message input count. */
- u_int32_t ls_ack_out; /* LS Ack message output count. */
- u_int32_t discarded; /* discarded input count by error. */
- u_int32_t state_change; /* Number of status change. */
-
- u_int32_t full_nbrs;
+ uint32_t hello_in; /* Hello message input count. */
+ uint32_t hello_out; /* Hello message output count. */
+ uint32_t db_desc_in; /* database desc. message input count. */
+ uint32_t db_desc_out; /* database desc. message output count. */
+ uint32_t ls_req_in; /* LS request message input count. */
+ uint32_t ls_req_out; /* LS request message output count. */
+ uint32_t ls_upd_in; /* LS update message input count. */
+ uint32_t ls_upd_out; /* LS update message output count. */
+ uint32_t ls_ack_in; /* LS Ack message input count. */
+ uint32_t ls_ack_out; /* LS Ack message output count. */
+ uint32_t discarded; /* discarded input count by error. */
+ uint32_t state_change; /* Number of status change. */
+
+ uint32_t full_nbrs;
QOBJ_FIELDS
};
extern int ospf_full_virtual_nbrs(struct ospf_area *);
extern int ospf_vls_in_area(struct ospf_area *);
-extern struct crypt_key *ospf_crypt_key_lookup(struct list *, u_char);
+extern struct crypt_key *ospf_crypt_key_lookup(struct list *, uint8_t);
extern struct crypt_key *ospf_crypt_key_new(void);
extern void ospf_crypt_key_add(struct list *, struct crypt_key *);
-extern int ospf_crypt_key_delete(struct list *, u_char);
-extern u_char ospf_default_iftype(struct interface *ifp);
+extern int ospf_crypt_key_delete(struct list *, uint8_t);
+extern uint8_t ospf_default_iftype(struct interface *ifp);
extern int ospf_interface_neighbor_count(struct ospf_interface *oi);
/* Set all multicast memberships appropriately based on the type and
#include "ospfd/ospf_abr.h"
-u_int32_t get_metric(u_char *metric)
+uint32_t get_metric(uint8_t *metric)
{
- u_int32_t m;
+ uint32_t m;
m = metric[0];
m = (m << 8) + metric[1];
m = (m << 8) + metric[2];
/* All the offsets are zero-based. The offsets in the RFC1008 are
one-based. */
-u_int16_t ospf_lsa_checksum(struct lsa_header *lsa)
+uint16_t ospf_lsa_checksum(struct lsa_header *lsa)
{
- u_char *buffer = (u_char *)&lsa->options;
- int options_offset = buffer - (u_char *)&lsa->ls_age; /* should be 2 */
+ uint8_t *buffer = (uint8_t *)&lsa->options;
+ int options_offset = buffer - (uint8_t *)&lsa->ls_age; /* should be 2 */
/* Skip the AGE field */
- u_int16_t len = ntohs(lsa->length) - options_offset;
+ uint16_t len = ntohs(lsa->length) - options_offset;
/* Checksum offset starts from "options" field, not the beginning of the
lsa_header struct. The offset is 14, rather than 16. */
- int checksum_offset = (u_char *)&lsa->checksum - buffer;
+ int checksum_offset = (uint8_t *)&lsa->checksum - buffer;
return fletcher_checksum(buffer, len, checksum_offset);
}
int ospf_lsa_checksum_valid(struct lsa_header *lsa)
{
- u_char *buffer = (u_char *)&lsa->options;
- int options_offset = buffer - (u_char *)&lsa->ls_age; /* should be 2 */
+ uint8_t *buffer = (uint8_t *)&lsa->options;
+ int options_offset = buffer - (uint8_t *)&lsa->ls_age; /* should be 2 */
/* Skip the AGE field */
- u_int16_t len = ntohs(lsa->length) - options_offset;
+ uint16_t len = ntohs(lsa->length) - options_offset;
return (fletcher_checksum(buffer, len, FLETCHER_CHECKSUM_VALIDATE)
== 0);
return buf;
}
-u_int32_t lsa_seqnum_increment(struct ospf_lsa *lsa)
+uint32_t lsa_seqnum_increment(struct ospf_lsa *lsa)
{
- u_int32_t seqnum;
+ uint32_t seqnum;
seqnum = ntohl(lsa->data->ls_seqnum) + 1;
return htonl(seqnum);
}
-void lsa_header_set(struct stream *s, u_char options, u_char type,
+void lsa_header_set(struct stream *s, uint8_t options, uint8_t type,
struct in_addr id, struct in_addr router_id)
{
struct lsa_header *lsah;
/* router-LSA related functions. */
/* Get router-LSA flags. */
-static u_char router_lsa_flags(struct ospf_area *area)
+static uint8_t router_lsa_flags(struct ospf_area *area)
{
- u_char flags;
+ uint8_t flags;
flags = area->ospf->flags;
/* Determine cost of link, taking RFC3137 stub-router support into
* consideration
*/
-static u_int16_t ospf_link_cost(struct ospf_interface *oi)
+static uint16_t ospf_link_cost(struct ospf_interface *oi)
{
/* RFC3137 stub router support */
if (!CHECK_FLAG(oi->area->stub_router_state, OSPF_AREA_IS_STUB_ROUTED))
/* Set a link information. */
static char link_info_set(struct stream *s, struct in_addr id,
- struct in_addr data, u_char type, u_char tos,
- u_int16_t cost)
+ struct in_addr data, uint8_t type, uint8_t tos,
+ uint16_t cost)
{
/* LSA stream is initially allocated to OSPF_MAX_LSA_SIZE, suits
* vast majority of cases. Some rare routers with lots of links need
int links = 0;
struct ospf_neighbor *nbr;
struct in_addr id, mask, data;
- u_int16_t cost = ospf_link_cost(oi);
+ uint16_t cost = ospf_link_cost(oi);
if (IS_DEBUG_OSPF(lsa, LSA_GENERATE))
zlog_debug("LSA[Type1]: Set link Point-to-Point");
{
struct ospf_neighbor *dr;
struct in_addr id, mask;
- u_int16_t cost = ospf_link_cost(oi);
+ uint16_t cost = ospf_link_cost(oi);
/* Describe Type 3 Link. */
if (oi->state == ISM_Waiting) {
static int lsa_link_virtuallink_set(struct stream *s, struct ospf_interface *oi)
{
struct ospf_neighbor *nbr;
- u_int16_t cost = ospf_link_cost(oi);
+ uint16_t cost = ospf_link_cost(oi);
if (oi->state == ISM_PointToPoint)
if ((nbr = ospf_nbr_lookup_ptop(oi)))
struct route_node *rn;
struct ospf_neighbor *nbr = NULL;
struct in_addr id, mask;
- u_int16_t cost = ospf_link_cost(oi);
+ uint16_t cost = ospf_link_cost(oi);
mask.s_addr = 0xffffffff;
id.s_addr = oi->address->u.prefix4.s_addr;
static void ospf_router_lsa_body_set(struct stream *s, struct ospf_area *area)
{
unsigned long putp;
- u_int16_t cnt;
+ uint16_t cnt;
/* Set flags. */
stream_putc(s, router_lsa_flags(area));
return new;
}
-static void stream_put_ospf_metric(struct stream *s, u_int32_t metric_value)
+static void stream_put_ospf_metric(struct stream *s, uint32_t metric_value)
{
- u_int32_t metric;
+ uint32_t metric;
char *mp;
/* Put 0 metric. TOS metric is not supported. */
/* summary-LSA related functions. */
static void ospf_summary_lsa_body_set(struct stream *s, struct prefix *p,
- u_int32_t metric)
+ uint32_t metric)
{
struct in_addr mask;
stream_put_ipv4(s, mask.s_addr);
/* Set # TOS. */
- stream_putc(s, (u_char)0);
+ stream_putc(s, (uint8_t)0);
/* Set metric. */
stream_put_ospf_metric(s, metric);
}
static struct ospf_lsa *ospf_summary_lsa_new(struct ospf_area *area,
- struct prefix *p, u_int32_t metric,
+ struct prefix *p, uint32_t metric,
struct in_addr id)
{
struct stream *s;
/* Originate Summary-LSA. */
struct ospf_lsa *ospf_summary_lsa_originate(struct prefix_ipv4 *p,
- u_int32_t metric,
+ uint32_t metric,
struct ospf_area *area)
{
struct ospf_lsa *new;
/* summary-ASBR-LSA related functions. */
static void ospf_summary_asbr_lsa_body_set(struct stream *s, struct prefix *p,
- u_int32_t metric)
+ uint32_t metric)
{
/* Put Network Mask. */
- stream_put_ipv4(s, (u_int32_t)0);
+ stream_put_ipv4(s, (uint32_t)0);
/* Set # TOS. */
- stream_putc(s, (u_char)0);
+ stream_putc(s, (uint8_t)0);
/* Set metric. */
stream_put_ospf_metric(s, metric);
static struct ospf_lsa *ospf_summary_asbr_lsa_new(struct ospf_area *area,
struct prefix *p,
- u_int32_t metric,
+ uint32_t metric,
struct in_addr id)
{
struct stream *s;
/* Originate summary-ASBR-LSA. */
struct ospf_lsa *ospf_summary_asbr_lsa_originate(struct prefix_ipv4 *p,
- u_int32_t metric,
+ uint32_t metric,
struct ospf_area *area)
{
struct ospf_lsa *new;
#define DEFAULT_METRIC_TYPE EXTERNAL_METRIC_TYPE_2
-int metric_type(struct ospf *ospf, u_char src, u_short instance)
+int metric_type(struct ospf *ospf, uint8_t src, unsigned short instance)
{
struct ospf_redist *red;
: red->dmetric.type);
}
-int metric_value(struct ospf *ospf, u_char src, u_short instance)
+int metric_value(struct ospf *ospf, uint8_t src, unsigned short instance)
{
struct ospf_redist *red;
{
struct prefix_ipv4 *p = &ei->p;
struct in_addr mask, fwd_addr;
- u_int32_t mvalue;
+ uint32_t mvalue;
int mtype;
int type;
- u_short instance;
+ unsigned short instance;
/* Put Network Mask. */
masklen2ip(p->prefixlen, &mask);
}
/* Flush an AS-external-LSA from LSDB and routing domain. */
-void ospf_external_lsa_flush(struct ospf *ospf, u_char type,
+void ospf_external_lsa_flush(struct ospf *ospf, uint8_t type,
struct prefix_ipv4 *p,
ifindex_t ifindex /*, struct in_addr nexthop */)
{
}
}
-void ospf_external_lsa_refresh_type(struct ospf *ospf, u_char type,
- u_short instance, int force)
+void ospf_external_lsa_refresh_type(struct ospf *ospf, uint8_t type,
+ unsigned short instance, int force)
{
struct route_node *rn;
struct external_info *ei;
"LSA[Type%d:%s]: LSA 0x%lx is self-originated: ",
lsa->data->type,
inet_ntoa(lsa->data->id),
- (u_long)lsa);
+ (unsigned long)lsa);
if (IS_DEBUG_OSPF(lsa, LSA_FLOODING))
zlog_debug(
return 0;
}
-struct ospf_lsa *ospf_lsa_lookup_by_prefix(struct ospf_lsdb *lsdb, u_char type,
+struct ospf_lsa *ospf_lsa_lookup_by_prefix(struct ospf_lsdb *lsdb, uint8_t type,
struct prefix_ipv4 *p,
struct in_addr router_id)
{
}
struct ospf_lsa *ospf_lsa_lookup(struct ospf *ospf, struct ospf_area *area,
- u_int32_t type, struct in_addr id,
+ uint32_t type, struct in_addr id,
struct in_addr adv_router)
{
if (!ospf)
return NULL;
}
-struct ospf_lsa *ospf_lsa_lookup_by_id(struct ospf_area *area, u_int32_t type,
+struct ospf_lsa *ospf_lsa_lookup_by_id(struct ospf_area *area, uint32_t type,
struct in_addr id)
{
struct ospf_lsa *lsa;
void ospf_lsa_flush_self_originated(struct ospf_neighbor *nbr,
struct ospf_lsa *self, struct ospf_lsa *new)
{
- u_int32_t seqnum;
+ uint32_t seqnum;
/* Adjust LS Sequence Number. */
seqnum = ntohl(new->data->ls_seqnum) + 1;
/* Get unique Link State ID. */
struct in_addr ospf_lsa_unique_id(struct ospf *ospf, struct ospf_lsdb *lsdb,
- u_char type, struct prefix_ipv4 *p)
+ uint8_t type, struct prefix_ipv4 *p)
{
struct ospf_lsa *lsa;
struct in_addr mask, id;
#define LSA_ACTION_FLUSH_AREA 2
struct lsa_action {
- u_char action;
+ uint8_t action;
struct ospf_area *area;
struct ospf_lsa *lsa;
};
void ospf_refresher_register_lsa(struct ospf *ospf, struct ospf_lsa *lsa)
{
- u_int16_t index, current_index;
+ uint16_t index, current_index;
assert(lsa->lock > 0);
assert(IS_LSA_SELF(lsa));
/* OSPF LSA header. */
struct lsa_header {
- u_int16_t ls_age;
- u_char options;
- u_char type;
+ uint16_t ls_age;
+ uint8_t options;
+ uint8_t type;
struct in_addr id;
struct in_addr adv_router;
- u_int32_t ls_seqnum;
- u_int16_t checksum;
- u_int16_t length;
+ uint32_t ls_seqnum;
+ uint16_t checksum;
+ uint16_t length;
};
/* OSPF LSA. */
struct ospf_lsa {
/* LSA origination flag. */
- u_char flags;
+ uint8_t flags;
#define OSPF_LSA_SELF 0x01
#define OSPF_LSA_SELF_CHECKED 0x02
#define OSPF_LSA_RECEIVED 0x04
struct in_addr link_id;
struct in_addr link_data;
struct {
- u_char type;
- u_char tos_count;
- u_int16_t metric;
+ uint8_t type;
+ uint8_t tos_count;
+ uint16_t metric;
} m[1];
};
be replaced with the next revision having 1 descriptor block. */
struct router_lsa {
struct lsa_header header;
- u_char flags;
- u_char zero;
- u_int16_t links;
+ uint8_t flags;
+ uint8_t zero;
+ uint16_t links;
struct {
struct in_addr link_id;
struct in_addr link_data;
- u_char type;
- u_char tos;
- u_int16_t metric;
+ uint8_t type;
+ uint8_t tos;
+ uint16_t metric;
} link[1];
};
struct summary_lsa {
struct lsa_header header;
struct in_addr mask;
- u_char tos;
- u_char metric[3];
+ uint8_t tos;
+ uint8_t metric[3];
};
/* OSPF AS-external-LSAs structure. */
struct lsa_header header;
struct in_addr mask;
struct {
- u_char tos;
- u_char metric[3];
+ uint8_t tos;
+ uint8_t metric[3];
struct in_addr fwd_addr;
- u_int32_t route_tag;
+ uint32_t route_tag;
} e[1];
};
extern struct timeval msec2tv(int);
extern int get_age(struct ospf_lsa *);
-extern u_int16_t ospf_lsa_checksum(struct lsa_header *);
+extern uint16_t ospf_lsa_checksum(struct lsa_header *);
extern int ospf_lsa_checksum_valid(struct lsa_header *);
extern int ospf_lsa_refresh_delay(struct ospf_lsa *);
extern const char *dump_lsa_key(struct ospf_lsa *);
-extern u_int32_t lsa_seqnum_increment(struct ospf_lsa *);
-extern void lsa_header_set(struct stream *, u_char, u_char, struct in_addr,
+extern uint32_t lsa_seqnum_increment(struct ospf_lsa *);
+extern void lsa_header_set(struct stream *, uint8_t, uint8_t, struct in_addr,
struct in_addr);
extern struct ospf_neighbor *ospf_nbr_lookup_ptop(struct ospf_interface *);
extern int ospf_check_nbr_status(struct ospf *);
extern void ospf_network_lsa_update(struct ospf_interface *);
extern struct ospf_lsa *
-ospf_summary_lsa_originate(struct prefix_ipv4 *, u_int32_t, struct ospf_area *);
+ospf_summary_lsa_originate(struct prefix_ipv4 *, uint32_t, struct ospf_area *);
extern struct ospf_lsa *ospf_summary_asbr_lsa_originate(struct prefix_ipv4 *,
- u_int32_t,
+ uint32_t,
struct ospf_area *);
extern struct ospf_lsa *ospf_lsa_install(struct ospf *, struct ospf_interface *,
struct ospf_lsa *);
extern void ospf_nssa_lsa_flush(struct ospf *ospf, struct prefix_ipv4 *p);
-extern void ospf_external_lsa_flush(struct ospf *, u_char, struct prefix_ipv4 *,
+extern void ospf_external_lsa_flush(struct ospf *, uint8_t,
+ struct prefix_ipv4 *,
ifindex_t /* , struct in_addr nexthop */);
extern struct in_addr ospf_get_ip_from_ifp(struct ospf_interface *);
extern int ospf_external_lsa_originate_timer(struct thread *);
extern int ospf_default_originate_timer(struct thread *);
extern struct ospf_lsa *ospf_lsa_lookup(struct ospf *ospf, struct ospf_area *,
- u_int32_t, struct in_addr,
+ uint32_t, struct in_addr,
struct in_addr);
-extern struct ospf_lsa *ospf_lsa_lookup_by_id(struct ospf_area *, u_int32_t,
+extern struct ospf_lsa *ospf_lsa_lookup_by_id(struct ospf_area *, uint32_t,
struct in_addr);
extern struct ospf_lsa *ospf_lsa_lookup_by_header(struct ospf_area *,
struct lsa_header *);
extern int ospf_lsa_is_self_originated(struct ospf *, struct ospf_lsa *);
-extern struct ospf_lsa *ospf_lsa_lookup_by_prefix(struct ospf_lsdb *, u_char,
+extern struct ospf_lsa *ospf_lsa_lookup_by_prefix(struct ospf_lsdb *, uint8_t,
struct prefix_ipv4 *,
struct in_addr);
extern void ospf_lsa_maxage(struct ospf *, struct ospf_lsa *);
-extern u_int32_t get_metric(u_char *);
+extern uint32_t get_metric(uint8_t *);
extern int ospf_lsa_maxage_walker(struct thread *);
extern struct ospf_lsa *ospf_lsa_refresh(struct ospf *, struct ospf_lsa *);
extern void ospf_external_lsa_refresh_default(struct ospf *);
-extern void ospf_external_lsa_refresh_type(struct ospf *, u_char, u_short, int);
+extern void ospf_external_lsa_refresh_type(struct ospf *, uint8_t,
+ unsigned short, int);
extern struct ospf_lsa *ospf_external_lsa_refresh(struct ospf *,
struct ospf_lsa *,
struct external_info *, int);
extern struct in_addr ospf_lsa_unique_id(struct ospf *, struct ospf_lsdb *,
- u_char, struct prefix_ipv4 *);
+ uint8_t, struct prefix_ipv4 *);
extern void ospf_schedule_lsa_flood_area(struct ospf_area *, struct ospf_lsa *);
extern void ospf_schedule_lsa_flush_area(struct ospf_area *, struct ospf_lsa *);
struct ospf_lsa *);
extern int is_prefix_default(struct prefix_ipv4 *);
-extern int metric_type(struct ospf *, u_char, u_short);
-extern int metric_value(struct ospf *, u_char, u_short);
+extern int metric_type(struct ospf *, uint8_t, unsigned short);
+extern int metric_value(struct ospf *, uint8_t, unsigned short);
extern struct in_addr ospf_get_nssa_ip(struct ospf_area *);
extern int ospf_translated_nssa_compare(struct ospf_lsa *, struct ospf_lsa *);
return NULL;
}
-struct ospf_lsa *ospf_lsdb_lookup_by_id(struct ospf_lsdb *lsdb, u_char type,
+struct ospf_lsa *ospf_lsdb_lookup_by_id(struct ospf_lsdb *lsdb, uint8_t type,
struct in_addr id,
struct in_addr adv_router)
{
}
struct ospf_lsa *ospf_lsdb_lookup_by_id_next(struct ospf_lsdb *lsdb,
- u_char type, struct in_addr id,
+ uint8_t type, struct in_addr id,
struct in_addr adv_router,
int first)
{
/* Set all stats to -1 (LSA_SPF_NOT_EXPLORED). */
extern void ospf_lsdb_clean_stat(struct ospf_lsdb *lsdb);
extern struct ospf_lsa *ospf_lsdb_lookup(struct ospf_lsdb *, struct ospf_lsa *);
-extern struct ospf_lsa *ospf_lsdb_lookup_by_id(struct ospf_lsdb *, u_char,
+extern struct ospf_lsa *ospf_lsdb_lookup_by_id(struct ospf_lsdb *, uint8_t,
struct in_addr, struct in_addr);
-extern struct ospf_lsa *ospf_lsdb_lookup_by_id_next(struct ospf_lsdb *, u_char,
+extern struct ospf_lsa *ospf_lsdb_lookup_by_id_next(struct ospf_lsdb *, uint8_t,
struct in_addr,
struct in_addr, int);
extern unsigned long ospf_lsdb_count_all(struct ospf_lsdb *);
/* OSPFd main routine. */
int main(int argc, char **argv)
{
- u_short instance = 0;
+ unsigned short instance = 0;
#ifdef SUPPORT_OSPF_API
/* OSPF apiserver is disabled by default. */
struct ospf_interface *oi;
/* OSPF neighbor Information */
- u_char state; /* NSM status. */
- u_char dd_flags; /* DD bit flags. */
- u_int32_t dd_seqnum; /* DD Sequence Number. */
+ uint8_t state; /* NSM status. */
+ uint8_t dd_flags; /* DD bit flags. */
+ uint32_t dd_seqnum; /* DD Sequence Number. */
/* Neighbor Information from Hello. */
struct prefix address; /* Neighbor Interface Address. */
struct in_addr src; /* Src address. */
struct in_addr router_id; /* Router ID. */
- u_char options; /* Options. */
+ uint8_t options; /* Options. */
int priority; /* Router Priority. */
struct in_addr d_router; /* Designated Router. */
struct in_addr bd_router; /* Backup Designated Router. */
/* Last received Databse Description packet. */
struct {
- u_char options;
- u_char flags;
- u_int32_t dd_seqnum;
+ uint8_t options;
+ uint8_t flags;
+ uint32_t dd_seqnum;
} last_recv;
/* LSA data. */
struct ospf_lsdb ls_req;
struct ospf_lsa *ls_req_last;
- u_int32_t crypt_seqnum; /* Cryptographic Sequence Number. */
+ uint32_t crypt_seqnum; /* Cryptographic Sequence Number. */
/* Timer values. */
- u_int32_t v_inactivity;
- u_int32_t v_db_desc;
- u_int32_t v_ls_req;
- u_int32_t v_ls_upd;
+ uint32_t v_inactivity;
+ uint32_t v_db_desc;
+ uint32_t v_ls_req;
+ uint32_t v_ls_upd;
/* Threads. */
struct thread *t_inactivity;
struct timeval ts_last_progress; /* last advance of NSM */
struct timeval ts_last_regress; /* last regressive NSM change */
const char *last_regress_str; /* Event which last regressed NSM */
- u_int32_t state_change; /* NSM state change counter */
+ uint32_t state_change; /* NSM state change counter */
/* BFD information */
void *bfd_info;
int ospf_if_ipmulticast(struct ospf *top, struct prefix *p, ifindex_t ifindex)
{
- u_char val;
+ uint8_t val;
int ret, len;
/* Prevent receiving self-origined multicast packets. */
{
struct ospf_interface *oi = nbr->oi;
struct ospf_area *vl_area = NULL;
- u_char old_state;
+ uint8_t old_state;
int x;
int force = 1;
return;
}
-static const char *ospf_opaque_type_name(u_char opaque_type)
+static const char *ospf_opaque_type_name(uint8_t opaque_type)
{
const char *name = "Unknown";
if (OPAQUE_TYPE_RANGE_UNASSIGNED(opaque_type))
name = "Unassigned";
else {
- u_int32_t bigger_range = opaque_type;
+ uint32_t bigger_range = opaque_type;
/*
* Get around type-limits warning: comparison is always
* true due to limited range of data type
struct opaque_info_per_type; /* Forward declaration. */
struct ospf_opaque_functab {
- u_char opaque_type;
+ uint8_t opaque_type;
struct opaque_info_per_type *oipt;
int (*new_if_hook)(struct interface *ifp);
return;
}
-static struct list *ospf_get_opaque_funclist(u_char lsa_type)
+static struct list *ospf_get_opaque_funclist(uint8_t lsa_type)
{
struct list *funclist = NULL;
/* XXX: such a huge argument list can /not/ be healthy... */
int ospf_register_opaque_functab(
- u_char lsa_type, u_char opaque_type,
+ uint8_t lsa_type, uint8_t opaque_type,
int (*new_if_hook)(struct interface *ifp),
int (*del_if_hook)(struct interface *ifp),
void (*ism_change_hook)(struct ospf_interface *oi, int old_status),
return rc;
}
-void ospf_delete_opaque_functab(u_char lsa_type, u_char opaque_type)
+void ospf_delete_opaque_functab(uint8_t lsa_type, uint8_t opaque_type)
{
struct list *funclist;
struct listnode *node, *nnode;
struct list *funclist;
struct listnode *node;
struct ospf_opaque_functab *functab;
- u_char key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
+ uint8_t key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
if ((funclist = ospf_get_opaque_funclist(lsa->data->type)) != NULL)
for (ALL_LIST_ELEMENTS_RO(funclist, node, functab))
* identified by their opaque-id.
*/
struct opaque_info_per_type {
- u_char lsa_type;
- u_char opaque_type;
+ uint8_t lsa_type;
+ uint8_t opaque_type;
enum { PROC_NORMAL, PROC_SUSPEND } status;
/* Opaque-LSA control information per opaque-id. */
struct opaque_info_per_id {
- u_int32_t opaque_id;
+ uint32_t opaque_id;
/* Thread for refresh/flush scheduling for this opaque-type/id. */
struct thread *t_opaque_lsa_self;
struct list *listtop = NULL;
struct listnode *node, *nnode;
struct opaque_info_per_type *oipt = NULL;
- u_char key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
+ uint8_t key = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));
switch (lsa->data->type) {
case OSPF_OPAQUE_LINK_LSA:
{
struct listnode *node, *nnode;
struct opaque_info_per_id *oipi;
- u_int32_t key = GET_OPAQUE_ID(ntohl(lsa->data->id.s_addr));
+ uint32_t key = GET_OPAQUE_ID(ntohl(lsa->data->id.s_addr));
for (ALL_LIST_ELEMENTS(oipt->id_list, node, nnode, oipi))
if (oipi->opaque_id == key)
void show_opaque_info_detail(struct vty *vty, struct ospf_lsa *lsa)
{
struct lsa_header *lsah = (struct lsa_header *)lsa->data;
- u_int32_t lsid = ntohl(lsah->id.s_addr);
- u_char opaque_type = GET_OPAQUE_TYPE(lsid);
- u_int32_t opaque_id = GET_OPAQUE_ID(lsid);
+ uint32_t lsid = ntohl(lsah->id.s_addr);
+ uint8_t opaque_type = GET_OPAQUE_TYPE(lsid);
+ uint32_t opaque_id = GET_OPAQUE_ID(lsid);
struct ospf_opaque_functab *functab;
/* Switch output functionality by vty address. */
return;
}
-void ospf_opaque_lsa_dump(struct stream *s, u_int16_t length)
+void ospf_opaque_lsa_dump(struct stream *s, uint16_t length)
{
struct ospf_lsa lsa;
#define OSPF_OPAQUE_TIMER_ON(T,F,L,V) thread_add_timer_msec (master, (F), (L), (V), &(T))
static struct ospf_lsa *pseudo_lsa(struct ospf_interface *oi,
- struct ospf_area *area, u_char lsa_type,
- u_char opaque_type);
+ struct ospf_area *area, uint8_t lsa_type,
+ uint8_t opaque_type);
static int ospf_opaque_type9_lsa_reoriginate_timer(struct thread *t);
static int ospf_opaque_type10_lsa_reoriginate_timer(struct thread *t);
static int ospf_opaque_type11_lsa_reoriginate_timer(struct thread *t);
static int ospf_opaque_lsa_refresh_timer(struct thread *t);
void ospf_opaque_lsa_reoriginate_schedule(void *lsa_type_dependent,
- u_char lsa_type, u_char opaque_type)
+ uint8_t lsa_type, uint8_t opaque_type)
{
struct ospf *top = NULL;
struct ospf_area dummy, *area = NULL;
}
static struct ospf_lsa *pseudo_lsa(struct ospf_interface *oi,
- struct ospf_area *area, u_char lsa_type,
- u_char opaque_type)
+ struct ospf_area *area, uint8_t lsa_type,
+ uint8_t opaque_type)
{
static struct ospf_lsa lsa = {0};
static struct lsa_header lsah = {0};
- u_int32_t tmp;
+ uint32_t tmp;
lsa.oi = oi;
lsa.area = area;
#define LSID_OPAQUE_TYPE_MASK 0xff000000 /* 8 bits */
#define LSID_OPAQUE_ID_MASK 0x00ffffff /* 24 bits */
-#define GET_OPAQUE_TYPE(lsid) (((u_int32_t)(lsid)&LSID_OPAQUE_TYPE_MASK) >> 24)
+#define GET_OPAQUE_TYPE(lsid) (((uint32_t)(lsid)&LSID_OPAQUE_TYPE_MASK) >> 24)
-#define GET_OPAQUE_ID(lsid) ((u_int32_t)(lsid)&LSID_OPAQUE_ID_MASK)
+#define GET_OPAQUE_ID(lsid) ((uint32_t)(lsid)&LSID_OPAQUE_ID_MASK)
#define SET_OPAQUE_LSID(type, id) \
((((unsigned)(type) << 24) & LSID_OPAQUE_TYPE_MASK) \
#define VALID_OPAQUE_INFO_LEN(lsahdr) \
((ntohs((lsahdr)->length) >= sizeof(struct lsa_header)) \
- && ((ntohs((lsahdr)->length) % sizeof(u_int32_t)) == 0))
+ && ((ntohs((lsahdr)->length) % sizeof(uint32_t)) == 0))
/*
* Following section defines generic TLV (type, length, value) macros,
* used for various LSA opaque usage e.g. Traffic Engineering.
*/
struct tlv_header {
- u_int16_t type; /* Type of Value */
- u_int16_t length; /* Length of Value portion only, in bytes */
+ uint16_t type; /* Type of Value */
+ uint16_t length; /* Length of Value portion only, in bytes */
};
#define TLV_HDR_SIZE (sizeof(struct tlv_header))
-#define TLV_BODY_SIZE(tlvh) (ROUNDUP(ntohs((tlvh)->length), sizeof(u_int32_t)))
+#define TLV_BODY_SIZE(tlvh) (ROUNDUP(ntohs((tlvh)->length), sizeof(uint32_t)))
#define TLV_SIZE(tlvh) (TLV_HDR_SIZE + TLV_BODY_SIZE(tlvh))
extern void ospf_opaque_type11_lsa_term(struct ospf *ospf);
extern int ospf_register_opaque_functab(
- u_char lsa_type, u_char opaque_type,
+ uint8_t lsa_type, uint8_t opaque_type,
int (*new_if_hook)(struct interface *ifp),
int (*del_if_hook)(struct interface *ifp),
void (*ism_change_hook)(struct ospf_interface *oi, int old_status),
struct ospf_lsa *(*lsa_refresher)(struct ospf_lsa *lsa),
int (*new_lsa_hook)(struct ospf_lsa *lsa),
int (*del_lsa_hook)(struct ospf_lsa *lsa));
-extern void ospf_delete_opaque_functab(u_char lsa_type, u_char opaque_type);
+extern void ospf_delete_opaque_functab(uint8_t lsa_type, uint8_t opaque_type);
extern int ospf_opaque_new_if(struct interface *ifp);
extern int ospf_opaque_del_if(struct interface *ifp);
extern void ospf_opaque_config_write_if(struct vty *vty, struct interface *ifp);
extern void ospf_opaque_config_write_debug(struct vty *vty);
extern void show_opaque_info_detail(struct vty *vty, struct ospf_lsa *lsa);
-extern void ospf_opaque_lsa_dump(struct stream *s, u_int16_t length);
+extern void ospf_opaque_lsa_dump(struct stream *s, uint16_t length);
extern void ospf_opaque_lsa_originate_schedule(struct ospf_interface *oi,
int *init_delay);
extern struct ospf_lsa *ospf_opaque_lsa_refresh(struct ospf_lsa *lsa);
extern void ospf_opaque_lsa_reoriginate_schedule(void *lsa_type_dependent,
- u_char lsa_type,
- u_char opaque_type);
+ uint8_t lsa_type,
+ uint8_t opaque_type);
extern void ospf_opaque_lsa_refresh_schedule(struct ospf_lsa *lsa);
extern void ospf_opaque_lsa_flush_schedule(struct ospf_lsa *lsa);
/* Minimum (besides OSPF_HEADER_SIZE) lengths for OSPF packets of
particular types, offset is the "type" field of a packet. */
-static const u_int16_t ospf_packet_minlen[] = {
+static const uint16_t ospf_packet_minlen[] = {
0,
OSPF_HELLO_MIN_SIZE,
OSPF_DB_DESC_MIN_SIZE,
/* Minimum (besides OSPF_LSA_HEADER_SIZE) lengths for LSAs of particular
types, offset is the "LSA type" field. */
-static const u_int16_t ospf_lsa_minlen[] = {
+static const uint16_t ospf_lsa_minlen[] = {
0,
OSPF_ROUTER_LSA_MIN_SIZE,
OSPF_NETWORK_LSA_MIN_SIZE,
/* XXX size_t */
zlog_warn(
"ospf_packet_dup stream %lu ospf_packet %u size mismatch",
- (u_long)STREAM_SIZE(op->s), op->length);
+ (unsigned long)STREAM_SIZE(op->s), op->length);
/* Reserve space for MD5 authentication that may be added later. */
new = ospf_packet_new(stream_get_endp(op->s) + OSPF_AUTH_MD5_SIZE);
unsigned char digest[OSPF_AUTH_MD5_SIZE];
struct crypt_key *ck;
struct ospf_neighbor *nbr;
- u_int16_t length = ntohs(ospfh->length);
+ uint16_t length = ntohs(ospfh->length);
/* Get secret key. */
ck = ospf_crypt_key_lookup(OSPF_IF_PARAM(oi, auth_crypt),
unsigned char digest[OSPF_AUTH_MD5_SIZE] = {0};
MD5_CTX ctx;
void *ibuf;
- u_int32_t t;
+ uint32_t t;
struct crypt_key *ck;
- const u_int8_t *auth_key;
+ const uint8_t *auth_key;
ibuf = STREAM_DATA(op->s);
ospfh = (struct ospf_header *)ibuf;
/* Get MD5 Authentication key from auth_key list. */
if (list_isempty(OSPF_IF_PARAM(oi, auth_crypt)))
- auth_key = (const u_int8_t *)digest;
+ auth_key = (const uint8_t *)digest;
else {
ck = listgetdata(listtail(OSPF_IF_PARAM(oi, auth_crypt)));
auth_key = ck->auth_key;
/* XXX size_t */
zlog_warn(
"ospf_make_md5_digest: length mismatch stream %lu ospf_packet %u",
- (u_long)stream_get_endp(op->s), op->length);
+ (unsigned long)stream_get_endp(op->s), op->length);
return OSPF_AUTH_MD5_SIZE;
}
#ifdef WANT_OSPF_WRITE_FRAGMENT
static void ospf_write_frags(int fd, struct ospf_packet *op, struct ip *iph,
struct msghdr *msg, unsigned int maxdatasize,
- unsigned int mtu, int flags, u_char type)
+ unsigned int mtu, int flags, uint8_t type)
{
#define OSPF_WRITE_FRAG_SHIFT 3
- u_int16_t offset;
+ uint16_t offset;
struct iovec *iovp;
int ret;
struct ip iph;
struct msghdr msg;
struct iovec iov[2];
- u_char type;
+ uint8_t type;
int ret;
int flags = 0;
struct listnode *node;
#ifdef WANT_OSPF_WRITE_FRAGMENT
- static u_int16_t ipid = 0;
- u_int16_t maxdatasize;
+ static uint16_t ipid = 0;
+ uint16_t maxdatasize;
#endif /* WANT_OSPF_WRITE_FRAGMENT */
#define OSPF_WRITE_IPHL_SHIFT 2
int pkt_count = 0;
/* Process rest of DD packet. */
static void ospf_db_desc_proc(struct stream *s, struct ospf_interface *oi,
struct ospf_neighbor *nbr,
- struct ospf_db_desc *dd, u_int16_t size)
+ struct ospf_db_desc *dd, uint16_t size)
{
struct ospf_lsa *new, *find;
struct lsa_header *lsah;
/* OSPF Database Description message read -- RFC2328 Section 10.6. */
static void ospf_db_desc(struct ip *iph, struct ospf_header *ospfh,
struct stream *s, struct ospf_interface *oi,
- u_int16_t size)
+ uint16_t size)
{
struct ospf_db_desc *dd;
struct ospf_neighbor *nbr;
/* OSPF Link State Request Read -- RFC2328 Section 10.7. */
static void ospf_ls_req(struct ip *iph, struct ospf_header *ospfh,
struct stream *s, struct ospf_interface *oi,
- u_int16_t size)
+ uint16_t size)
{
struct ospf_neighbor *nbr;
- u_int32_t ls_type;
+ uint32_t ls_type;
struct in_addr ls_id;
struct in_addr adv_router;
struct ospf_lsa *find;
struct stream *s,
struct ospf_interface *oi, size_t size)
{
- u_int16_t count, sum;
- u_int32_t length;
+ uint16_t count, sum;
+ uint32_t length;
struct lsa_header *lsah;
struct ospf_lsa *lsa;
struct list *lsas;
/* OSPF Link State Update message read -- RFC2328 Section 13. */
static void ospf_ls_upd(struct ospf *ospf, struct ip *iph,
struct ospf_header *ospfh, struct stream *s,
- struct ospf_interface *oi, u_int16_t size)
+ struct ospf_interface *oi, uint16_t size)
{
struct ospf_neighbor *nbr;
struct list *lsas;
/* OSPF Link State Acknowledgment message read -- RFC2328 Section 13.7. */
static void ospf_ls_ack(struct ip *iph, struct ospf_header *ospfh,
struct stream *s, struct ospf_interface *oi,
- u_int16_t size)
+ uint16_t size)
{
struct ospf_neighbor *nbr;
{
int ret;
struct ip *iph;
- u_int16_t ip_len;
+ uint16_t ip_len;
ifindex_t ifindex = 0;
struct iovec iov;
/* Header and data both require alignment. */
zlog_warn(
"ospf_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;
}
static int ospf_check_auth(struct ospf_interface *oi, struct ospf_header *ospfh)
{
struct crypt_key *ck;
- u_int16_t iface_auth_type;
- u_int16_t pkt_auth_type = ntohs(ospfh->auth_type);
+ uint16_t iface_auth_type;
+ uint16_t pkt_auth_type = ntohs(ospfh->auth_type);
switch (pkt_auth_type) {
case OSPF_AUTH_NULL: /* RFC2328 D.5.1 */
static int ospf_check_sum(struct ospf_header *ospfh)
{
- u_int32_t ret;
- u_int16_t sum;
+ uint32_t ret;
+ uint16_t sum;
/* clear auth_data for checksum. */
memset(ospfh->u.auth_data, 0, OSPF_AUTH_SIMPLE_SIZE);
/* keep checksum and clear. */
sum = ospfh->checksum;
- memset(&ospfh->checksum, 0, sizeof(u_int16_t));
+ memset(&ospfh->checksum, 0, sizeof(uint16_t));
/* calculate checksum. */
ret = in_cksum(ospfh, ntohs(ospfh->length));
/* Verify, that given link/TOS records are properly sized/aligned and match
Router-LSA "# links" and "# TOS" fields as specified in RFC2328 A.4.2. */
static unsigned ospf_router_lsa_links_examin(struct router_lsa_link *link,
- u_int16_t linkbytes,
- const u_int16_t num_links)
+ uint16_t linkbytes,
+ const uint16_t num_links)
{
unsigned counted_links = 0, thislinklen;
/* Verify, that the given LSA is properly sized/aligned (including type-specific
minimum length constraint). */
-static unsigned ospf_lsa_examin(struct lsa_header *lsah, const u_int16_t lsalen,
- const u_char headeronly)
+static unsigned ospf_lsa_examin(struct lsa_header *lsah, const uint16_t lsalen,
+ const uint8_t headeronly)
{
unsigned ret;
struct router_lsa *rlsa;
of deeper-level checks. */
static unsigned
ospf_lsaseq_examin(struct lsa_header *lsah, /* start of buffered data */
- size_t length, const u_char headeronly,
+ size_t length, const uint8_t headeronly,
/* When declared_num_lsas is not 0, compare it to the real
number of LSAs
and treat the difference as an error. */
- const u_int32_t declared_num_lsas)
+ const uint32_t declared_num_lsas)
{
- u_int32_t counted_lsas = 0;
+ uint32_t counted_lsas = 0;
while (length) {
- u_int16_t lsalen;
+ uint16_t lsalen;
if (length < OSPF_LSA_HEADER_SIZE) {
if (IS_DEBUG_OSPF_PACKET(0, RECV))
zlog_debug(
static unsigned ospf_packet_examin(struct ospf_header *oh,
const unsigned bytesonwire)
{
- u_int16_t bytesdeclared, bytesauth;
+ uint16_t bytesdeclared, bytesauth;
unsigned ret;
struct ospf_ls_update *lsupd;
struct ospf_interface *oi;
struct ip *iph;
struct ospf_header *ospfh;
- u_int16_t length;
+ uint16_t length;
struct interface *ifp = NULL;
struct connected *c;
ospfh = (struct ospf_header *)STREAM_DATA(s);
- ospfh->version = (u_char)OSPF_VERSION;
- ospfh->type = (u_char)type;
+ ospfh->version = (uint8_t)OSPF_VERSION;
+ ospfh->type = (uint8_t)type;
ospfh->router_id = oi->ospf->router_id;
/* Fill rest of OSPF header. */
static void ospf_fill_header(struct ospf_interface *oi, struct stream *s,
- u_int16_t length)
+ uint16_t length)
{
struct ospf_header *ospfh;
{
struct ospf_neighbor *nbr;
struct route_node *rn;
- u_int16_t length = OSPF_HELLO_MIN_SIZE;
+ uint16_t length = OSPF_HELLO_MIN_SIZE;
struct in_addr mask;
unsigned long p;
int flag = 0;
struct ospf_neighbor *nbr, struct stream *s)
{
struct ospf_lsa *lsa;
- u_int16_t length = OSPF_DB_DESC_MIN_SIZE;
- u_char options;
+ uint16_t length = OSPF_DB_DESC_MIN_SIZE;
+ uint8_t options;
unsigned long pp;
int i;
struct ospf_lsdb *lsdb;
if (!CHECK_FLAG(lsa->flags, OSPF_LSA_DISCARD)) {
struct lsa_header *lsah;
- u_int16_t ls_age;
+ uint16_t ls_age;
/* DD packet overflows interface MTU. */
if (length + OSPF_LSA_HEADER_SIZE
return length;
}
-static int ospf_make_ls_req_func(struct stream *s, u_int16_t *length,
+static int ospf_make_ls_req_func(struct stream *s, uint16_t *length,
unsigned long delta, struct ospf_neighbor *nbr,
struct ospf_lsa *lsa)
{
static int ospf_make_ls_req(struct ospf_neighbor *nbr, struct stream *s)
{
struct ospf_lsa *lsa;
- u_int16_t length = OSPF_LS_REQ_MIN_SIZE;
+ uint16_t length = OSPF_LS_REQ_MIN_SIZE;
unsigned long delta = stream_get_endp(s) + 12;
struct route_table *table;
struct route_node *rn;
{
struct ospf_lsa *lsa;
struct listnode *node;
- u_int16_t length = 0;
+ uint16_t length = 0;
unsigned int size_noauth;
unsigned long delta = stream_get_endp(s);
unsigned long pp;
while ((node = listhead(update)) != NULL) {
struct lsa_header *lsah;
- u_int16_t ls_age;
+ uint16_t ls_age;
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("ospf_make_ls_upd: List Iteration %d",
struct stream *s)
{
struct listnode *node, *nnode;
- u_int16_t length = OSPF_LS_ACK_MIN_SIZE;
+ uint16_t length = OSPF_LS_ACK_MIN_SIZE;
unsigned long delta = stream_get_endp(s) + 24;
struct ospf_lsa *lsa;
static void ospf_hello_send_sub(struct ospf_interface *oi, in_addr_t addr)
{
struct ospf_packet *op;
- u_int16_t length = OSPF_HEADER_SIZE;
+ uint16_t length = OSPF_HEADER_SIZE;
op = ospf_packet_new(oi->ifp->mtu);
{
struct ospf_interface *oi;
struct ospf_packet *op;
- u_int16_t length = OSPF_HEADER_SIZE;
+ uint16_t length = OSPF_HEADER_SIZE;
oi = nbr->oi;
op = ospf_packet_new(oi->ifp->mtu);
{
struct ospf_interface *oi;
struct ospf_packet *op;
- u_int16_t length = OSPF_HEADER_SIZE;
+ uint16_t length = OSPF_HEADER_SIZE;
oi = nbr->oi;
op = ospf_packet_new(oi->ifp->mtu);
int send_lsupd_now)
{
struct ospf_packet *op;
- u_int16_t length = OSPF_HEADER_SIZE;
+ uint16_t length = OSPF_HEADER_SIZE;
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("listcount = %d, [%s]dst %s", listcount(update),
struct in_addr dst)
{
struct ospf_packet *op;
- u_int16_t length = OSPF_HEADER_SIZE;
+ uint16_t length = OSPF_HEADER_SIZE;
op = ospf_packet_new(oi->ifp->mtu);
struct in_addr dst;
/* OSPF packet length. */
- u_int16_t length;
+ uint16_t length;
};
/* OSPF packet queue structure. */
/* OSPF packet header structure. */
struct ospf_header {
- u_char version; /* OSPF Version. */
- u_char type; /* Packet Type. */
- u_int16_t length; /* Packet Length. */
+ uint8_t version; /* OSPF Version. */
+ uint8_t type; /* Packet Type. */
+ uint16_t length; /* Packet Length. */
struct in_addr router_id; /* Router ID. */
struct in_addr area_id; /* Area ID. */
- u_int16_t checksum; /* Check Sum. */
- u_int16_t auth_type; /* Authentication Type. */
+ uint16_t checksum; /* Check Sum. */
+ uint16_t auth_type; /* Authentication Type. */
/* Authentication Data. */
union {
/* Simple Authentication. */
- u_char auth_data[OSPF_AUTH_SIMPLE_SIZE];
+ uint8_t auth_data[OSPF_AUTH_SIMPLE_SIZE];
/* Cryptographic Authentication. */
struct {
- u_int16_t zero; /* Should be 0. */
- u_char key_id; /* Key ID. */
- u_char auth_data_len; /* Auth Data Length. */
- u_int32_t crypt_seqnum; /* Cryptographic Sequence
+ uint16_t zero; /* Should be 0. */
+ uint8_t key_id; /* Key ID. */
+ uint8_t auth_data_len; /* Auth Data Length. */
+ uint32_t crypt_seqnum; /* Cryptographic Sequence
Number. */
} crypt;
} u;
/* OSPF Hello body format. */
struct ospf_hello {
struct in_addr network_mask;
- u_int16_t hello_interval;
- u_char options;
- u_char priority;
- u_int32_t dead_interval;
+ uint16_t hello_interval;
+ uint8_t options;
+ uint8_t priority;
+ uint32_t dead_interval;
struct in_addr d_router;
struct in_addr bd_router;
struct in_addr neighbors[1];
/* OSPF Database Description body format. */
struct ospf_db_desc {
- u_int16_t mtu;
- u_char options;
- u_char flags;
- u_int32_t dd_seqnum;
+ uint16_t mtu;
+ uint8_t options;
+ uint8_t flags;
+ uint32_t dd_seqnum;
};
struct ospf_ls_update {
- u_int32_t num_lsas;
+ uint32_t num_lsas;
};
/* Macros. */
struct ospf_router_info {
bool enabled;
- u_int8_t registered;
- u_int8_t scope;
+ uint8_t registered;
+ uint8_t scope;
/* Flags to manage this router information. */
#define RIFLG_LSA_ENGAGED 0x1
#define RIFLG_LSA_FORCED_REFRESH 0x2
- u_int32_t flags;
+ uint32_t flags;
/* area pointer if flooding is Type 10 Null if flooding is AS scope */
struct ospf_area *area;
return 0;
}
-static int ospf_router_info_register(u_int8_t scope)
+static int ospf_router_info_register(uint8_t scope)
{
int rc = 0;
*------------------------------------------------------------------------*/
static void set_router_info_capabilities(struct ri_tlv_router_cap *ric,
- u_int32_t cap)
+ uint32_t cap)
{
ric->header.type = htons(RI_TLV_CAPABILITIES);
ric->header.length = htons(RI_TLV_LENGTH);
static int set_pce_header(struct ospf_pce_info *pce)
{
- u_int16_t length = 0;
+ uint16_t length = 0;
struct listnode *node;
struct ri_pce_subtlv_domain *domain;
struct ri_pce_subtlv_neighbor *neighbor;
return;
}
-static void set_pce_path_scope(u_int32_t scope, struct ospf_pce_info *pce)
+static void set_pce_path_scope(uint32_t scope, struct ospf_pce_info *pce)
{
/* Set PCE Scope */
return;
}
-static void set_pce_domain(u_int16_t type, u_int32_t domain,
+static void set_pce_domain(uint16_t type, uint32_t domain,
struct ospf_pce_info *pce)
{
return;
}
-static void unset_pce_domain(u_int16_t type, u_int32_t domain,
+static void unset_pce_domain(uint16_t type, uint32_t domain,
struct ospf_pce_info *pce)
{
struct listnode *node;
}
}
-static void set_pce_neighbor(u_int16_t type, u_int32_t domain,
+static void set_pce_neighbor(uint16_t type, uint32_t domain,
struct ospf_pce_info *pce)
{
return;
}
-static void unset_pce_neighbor(u_int16_t type, u_int32_t domain,
+static void unset_pce_neighbor(uint16_t type, uint32_t domain,
struct ospf_pce_info *pce)
{
struct listnode *node;
}
}
-static void set_pce_cap_flag(u_int32_t cap, struct ospf_pce_info *pce)
+static void set_pce_cap_flag(uint32_t cap, struct ospf_pce_info *pce)
{
/* Set PCE Capabilities flag */
static void initialize_params(struct ospf_router_info *ori)
{
- u_int32_t cap = 0;
+ uint32_t cap = 0;
struct ospf *top;
/*
struct stream *s;
struct lsa_header *lsah;
struct ospf_lsa *new = NULL;
- u_char options, lsa_type;
+ uint8_t options, lsa_type;
struct in_addr lsa_id;
- u_int32_t tmp;
- u_int16_t length;
+ uint32_t tmp;
+ uint16_t length;
/* Create a stream for LSA. */
if ((s = stream_new(OSPF_MAX_LSA_SIZE)) == NULL) {
struct ospf_lsa lsa;
struct lsa_header lsah;
struct ospf *top;
- u_int32_t tmp;
+ uint32_t tmp;
memset(&lsa, 0, sizeof(lsa));
memset(&lsah, 0, sizeof(lsah));
* Followings are vty session control functions.
*------------------------------------------------------------------------*/
-static u_int16_t show_vty_router_cap(struct vty *vty, struct tlv_header *tlvh)
+static uint16_t show_vty_router_cap(struct vty *vty, struct tlv_header *tlvh)
{
struct ri_tlv_router_cap *top = (struct ri_tlv_router_cap *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_pce_subtlv_address(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_pce_subtlv_address(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct ri_pce_subtlv_address *top =
(struct ri_pce_subtlv_address *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_pce_subtlv_path_scope(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_pce_subtlv_path_scope(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct ri_pce_subtlv_path_scope *top =
(struct ri_pce_subtlv_path_scope *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_pce_subtlv_domain(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_pce_subtlv_domain(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct ri_pce_subtlv_domain *top = (struct ri_pce_subtlv_domain *)tlvh;
struct in_addr tmp;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_pce_subtlv_neighbor(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_pce_subtlv_neighbor(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct ri_pce_subtlv_neighbor *top =
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_pce_subtlv_cap_flag(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_pce_subtlv_cap_flag(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct ri_pce_subtlv_cap_flag *top =
(struct ri_pce_subtlv_cap_flag *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_unknown_tlv(struct vty *vty, struct tlv_header *tlvh)
+static uint16_t show_vty_unknown_tlv(struct vty *vty, struct tlv_header *tlvh)
{
if (vty != NULL)
vty_out(vty, " Unknown TLV: [type(0x%x), length(0x%x)]\n",
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_pce_info(struct vty *vty, struct tlv_header *ri,
- uint32_t total)
+static uint16_t show_vty_pce_info(struct vty *vty, struct tlv_header *ri,
+ uint32_t total)
{
struct tlv_header *tlvh;
- u_int16_t sum = 0;
+ uint16_t sum = 0;
for (tlvh = ri; sum < total; tlvh = TLV_HDR_NEXT(tlvh)) {
switch (ntohs(tlvh->type)) {
{
struct lsa_header *lsah = (struct lsa_header *)lsa->data;
struct tlv_header *tlvh;
- u_int16_t length = 0, sum = 0;
+ uint16_t length = 0, sum = 0;
/* Initialize TLV browsing */
length = ntohs(lsah->length) - OSPF_LSA_HEADER_SIZE;
int idx_ipv4 = 2;
char *area = (argc == 3) ? argv[idx_ipv4]->arg : NULL;
- u_int8_t scope;
+ uint8_t scope;
if (OspfRI.enabled)
return CMD_SUCCESS;
struct ri_tlv_router_cap {
struct tlv_header header; /* Value length is 4 bytes. */
- u_int32_t value;
+ uint32_t value;
};
/* Capabilities bits are left align */
#define PCE_ADDRESS_LENGTH_IPV4 8
#define PCE_ADDRESS_LENGTH_IPV6 20
struct {
- u_int16_t type; /* Address type: 1 = IPv4, 2 = IPv6 */
+ uint16_t type; /* Address type: 1 = IPv4, 2 = IPv6 */
#define PCE_ADDRESS_TYPE_IPV4 1
#define PCE_ADDRESS_TYPE_IPV6 2
- u_int16_t reserved;
+ uint16_t reserved;
struct in_addr value; /* PCE address */
} address;
};
* L, R, Rd, S, Sd, Y, PrefL, PrefR, PrefS and PrefY bits:
* see RFC5088 page 9
*/
- u_int32_t value;
+ uint32_t value;
};
/* PCE Domain Sub-TLV */ /* Optional */
struct ri_pce_subtlv_domain {
struct tlv_header header; /* Type = 3; Length = 8 bytes. */
- u_int16_t type; /* Domain type: 1 = OSPF Area ID, 2 = AS Number */
- u_int16_t reserved;
- u_int32_t value;
+ uint16_t type; /* Domain type: 1 = OSPF Area ID, 2 = AS Number */
+ uint16_t reserved;
+ uint32_t value;
};
/* PCE Neighbor Sub-TLV */ /* Mandatory if R or S bit is set */
#define RI_PCE_SUBTLV_NEIGHBOR 4
struct ri_pce_subtlv_neighbor {
struct tlv_header header; /* Type = 4; Length = 8 bytes. */
- u_int16_t type; /* Domain type: 1 = OSPF Area ID, 2 = AS Number */
- u_int16_t reserved;
- u_int32_t value;
+ uint16_t type; /* Domain type: 1 = OSPF Area ID, 2 = AS Number */
+ uint16_t reserved;
+ uint32_t value;
};
/* PCE Capabilities Flags Sub-TLV */ /* Optional */
struct ri_pce_subtlv_cap_flag {
struct tlv_header header; /* Type = 5; Length = n x 4 bytes. */
- u_int32_t value;
+ uint32_t value;
};
/* Structure to share flooding scope info for Segment Routing */
struct vertex *v, struct ospf_area *area,
int parent_is_root, int lsa_pos)
{
- u_int32_t cost;
+ uint32_t cost;
struct route_node *rn;
struct ospf_route * or ;
struct prefix_ipv4 p;
static int ospf_asbr_route_cmp(struct ospf *ospf, struct ospf_route *r1,
struct ospf_route *r2)
{
- u_char r1_type, r2_type;
+ uint8_t r1_type, r2_type;
r1_type = r1->path_type;
r2_type = r2->path_type;
int external_routing;
/* Optional Capability. */
- u_char options; /* Get from LSA header. */
+ uint8_t options; /* Get from LSA header. */
/* */
- u_char flags; /* From router-LSA */
+ uint8_t flags; /* From router-LSA */
};
struct route_external {
struct ospf_lsa *origin;
/* Link State Cost Type2. */
- u_int32_t type2_cost;
+ uint32_t type2_cost;
/* Tag value. */
- u_int32_t tag;
+ uint32_t tag;
/* ASBR route. */
struct ospf_route *asbr;
struct ospf_route {
/* Destination Type. */
- u_char type;
+ uint8_t type;
/* Destination ID. */ /* i.e. Link State ID. */
struct in_addr id;
struct in_addr mask; /* Only valid for networks. */
/* Path Type. */
- u_char path_type;
+ uint8_t path_type;
/* List of Paths. */
struct list *paths;
/* Link State Cost. */
- u_int32_t cost; /* i.e. metric. */
+ uint32_t cost; /* i.e. metric. */
/* Route specific info. */
union {
struct ospf_metric {
enum { metric_increment, metric_decrement, metric_absolute } type;
bool used;
- u_int32_t metric;
+ uint32_t metric;
};
/* `set metric METRIC' */
{
struct ospf_metric *metric;
- metric = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_int32_t));
+ metric = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
metric->used = false;
if (all_digit(arg))
route_map_object_t type,
void *object)
{
- u_int32_t *metric_type;
+ uint32_t *metric_type;
struct external_info *ei;
if (type == RMAP_OSPF) {
/* set metric-type compilation. */
static void *route_set_metric_type_compile(const char *arg)
{
- u_int32_t *metric_type;
+ uint32_t *metric_type;
- metric_type = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_int32_t));
+ metric_type = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
if (strcmp(arg, "type-1") == 0)
*metric_type = EXTERNAL_METRIC_TYPE_1;
else if (strcmp(arg, "type-2") == 0)
static struct in_addr ospf_empty_addr = {.s_addr = 0};
/* Hook functions. */
-static u_char *ospfGeneralGroup(struct variable *, oid *, size_t *, int,
- size_t *, WriteMethod **);
-static u_char *ospfAreaEntry(struct variable *, oid *, size_t *, int, size_t *,
- WriteMethod **);
-static u_char *ospfStubAreaEntry(struct variable *, oid *, size_t *, int,
+static uint8_t *ospfGeneralGroup(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
-static u_char *ospfLsdbEntry(struct variable *, oid *, size_t *, int, size_t *,
- WriteMethod **);
-static u_char *ospfAreaRangeEntry(struct variable *, oid *, size_t *, int,
+static uint8_t *ospfAreaEntry(struct variable *, oid *, size_t *, int, size_t *,
+ WriteMethod **);
+static uint8_t *ospfStubAreaEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
-static u_char *ospfHostEntry(struct variable *, oid *, size_t *, int, size_t *,
- WriteMethod **);
-static u_char *ospfIfEntry(struct variable *, oid *, size_t *, int, size_t *,
- WriteMethod **);
-static u_char *ospfIfMetricEntry(struct variable *, oid *, size_t *, int,
- size_t *, WriteMethod **);
-static u_char *ospfVirtIfEntry(struct variable *, oid *, size_t *, int,
- size_t *, WriteMethod **);
-static u_char *ospfNbrEntry(struct variable *, oid *, size_t *, int, size_t *,
+static uint8_t *ospfLsdbEntry(struct variable *, oid *, size_t *, int, size_t *,
+ WriteMethod **);
+static uint8_t *ospfAreaRangeEntry(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *ospfHostEntry(struct variable *, oid *, size_t *, int, size_t *,
+ WriteMethod **);
+static uint8_t *ospfIfEntry(struct variable *, oid *, size_t *, int, size_t *,
WriteMethod **);
-static u_char *ospfVirtNbrEntry(struct variable *, oid *, size_t *, int,
- size_t *, WriteMethod **);
-static u_char *ospfExtLsdbEntry(struct variable *, oid *, size_t *, int,
+static uint8_t *ospfIfMetricEntry(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *ospfVirtIfEntry(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
-static u_char *ospfAreaAggregateEntry(struct variable *, oid *, size_t *, int,
- size_t *, WriteMethod **);
+static uint8_t *ospfNbrEntry(struct variable *, oid *, size_t *, int, size_t *,
+ WriteMethod **);
+static uint8_t *ospfVirtNbrEntry(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *ospfExtLsdbEntry(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *ospfAreaAggregateEntry(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
static struct variable ospf_variables[] = {
/* OSPF general variables */
return 0;
}
-static u_char *ospfGeneralGroup(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfGeneralGroup(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf *ospf;
return NULL;
}
-static u_char *ospfAreaEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfAreaEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_area *area;
struct in_addr addr;
return NULL;
}
-static u_char *ospfStubAreaEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfStubAreaEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_area *area;
struct in_addr addr;
return NULL;
}
-static struct ospf_lsa *lsdb_lookup_next(struct ospf_area *area, u_char *type,
+static struct ospf_lsa *lsdb_lookup_next(struct ospf_area *area, uint8_t *type,
int type_next, struct in_addr *ls_id,
int ls_id_next,
struct in_addr *router_id,
static struct ospf_lsa *ospfLsdbLookup(struct variable *v, oid *name,
size_t *length, struct in_addr *area_id,
- u_char *type, struct in_addr *ls_id,
+ uint8_t *type, struct in_addr *ls_id,
struct in_addr *router_id, int exact)
{
struct ospf *ospf;
return NULL;
}
-static u_char *ospfLsdbEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfLsdbEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_lsa *lsa;
struct lsa_header *lsah;
struct in_addr area_id;
- u_char type;
+ uint8_t type;
struct in_addr ls_id;
struct in_addr router_id;
struct ospf *ospf;
break;
case OSPFLSDBADVERTISEMENT: /* 8 */
*var_len = ntohs(lsah->length);
- return (u_char *)lsah;
+ return (uint8_t *)lsah;
break;
default:
return NULL;
return NULL;
}
-static u_char *ospfAreaRangeEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfAreaRangeEntry(struct variable *v, oid *name,
+ size_t *length, int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_area_range *range;
struct in_addr area_id;
return NULL;
}
-static u_char *ospfHostEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfHostEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_nbr_nbma *nbr_nbma;
struct ospf_interface *oi;
return NULL;
}
-static u_char *ospfIfEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfIfEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
ifindex_t ifindex;
struct in_addr ifaddr;
break;
case OSPFIFAUTHKEY: /* 16 */
*var_len = 0;
- return (u_char *)OSPF_IF_PARAM(oi, auth_simple);
+ return (uint8_t *)OSPF_IF_PARAM(oi, auth_simple);
break;
case OSPFIFSTATUS: /* 17 */
return SNMP_INTEGER(SNMP_VALID);
return NULL;
}
-static u_char *ospfIfMetricEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfIfMetricEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
/* Currently we support metric 1 only. */
ifindex_t ifindex;
return NULL;
}
-static u_char *ospfVirtIfEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfVirtIfEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_vl_data *vl_data;
struct ospf_interface *oi;
break;
case OSPFVIRTIFAUTHKEY:
*var_len = 0;
- return (u_char *)OSPF_IF_PARAM(oi, auth_simple);
+ return (uint8_t *)OSPF_IF_PARAM(oi, auth_simple);
break;
case OSPFVIRTIFSTATUS:
return SNMP_INTEGER(SNMP_VALID);
full (8)
}
*/
-static int32_t ospf_snmp_neighbor_state(u_char nst)
+static int32_t ospf_snmp_neighbor_state(uint8_t nst)
{
switch (nst) {
case NSM_Attempt:
}
}
-static u_char *ospfNbrEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfNbrEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct in_addr nbr_addr;
ifindex_t ifindex;
return NULL;
}
-static u_char *ospfVirtNbrEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfVirtNbrEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_vl_data *vl_data;
struct in_addr area_id;
/* Return the current value of the variable */
switch (v->magic) {
case OSPFVIRTNBRAREA:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFVIRTNBRRTRID:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFVIRTNBRIPADDR:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFVIRTNBROPTIONS:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFVIRTNBRSTATE:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFVIRTNBREVENTS:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFVIRTNBRLSRETRANSQLEN:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFVIRTNBRHELLOSUPPRESSED:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
default:
return NULL;
}
static struct ospf_lsa *ospfExtLsdbLookup(struct variable *v, oid *name,
- size_t *length, u_char *type,
+ size_t *length, uint8_t *type,
struct in_addr *ls_id,
struct in_addr *router_id, int exact)
{
int first;
oid *offset;
int offsetlen;
- u_char lsa_type;
+ uint8_t lsa_type;
unsigned int len;
struct ospf_lsa *lsa;
struct ospf *ospf;
return NULL;
}
-static u_char *ospfExtLsdbEntry(struct variable *v, oid *name, size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfExtLsdbEntry(struct variable *v, oid *name, size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct ospf_lsa *lsa;
struct lsa_header *lsah;
- u_char type;
+ uint8_t type;
struct in_addr ls_id;
struct in_addr router_id;
struct ospf *ospf;
break;
case OSPFEXTLSDBADVERTISEMENT:
*var_len = ntohs(lsah->length);
- return (u_char *)lsah;
+ return (uint8_t *)lsah;
break;
default:
return NULL;
return NULL;
}
-static u_char *ospfAreaAggregateEntry(struct variable *v, oid *name,
- size_t *length, int exact,
- size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *ospfAreaAggregateEntry(struct variable *v, oid *name,
+ size_t *length, int exact,
+ size_t *var_len,
+ WriteMethod **write_method)
{
if (smux_header_table(v, name, length, exact, var_len, write_method)
== MATCH_FAILED)
/* Return the current value of the variable */
switch (v->magic) {
case OSPFAREAAGGREGATEAREAID:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFAREAAGGREGATELSDBTYPE:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFAREAAGGREGATENET:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFAREAAGGREGATEMASK:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFAREAAGGREGATESTATUS:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
case OSPFAREAAGGREGATEEFFECT:
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
break;
default:
return NULL;
ospf_get_next_link(struct vertex *v, struct vertex *w,
struct router_lsa_link *prev_link)
{
- u_char *p;
- u_char *lim;
- u_char lsa_type = LSA_LINK_TYPE_TRANSIT;
+ uint8_t *p;
+ uint8_t *lim;
+ uint8_t lsa_type = LSA_LINK_TYPE_TRANSIT;
struct router_lsa_link *l;
if (w->type == OSPF_VERTEX_ROUTER)
lsa_type = LSA_LINK_TYPE_POINTOPOINT;
if (prev_link == NULL)
- p = ((u_char *)v->lsa) + OSPF_LSA_HEADER_SIZE + 4;
+ p = ((uint8_t *)v->lsa) + OSPF_LSA_HEADER_SIZE + 4;
else {
- p = (u_char *)prev_link;
+ p = (uint8_t *)prev_link;
p += (OSPF_ROUTER_LSA_LINK_SIZE
+ (prev_link->m[0].tos_count * OSPF_ROUTER_LSA_TOS_SIZE));
}
- lim = ((u_char *)v->lsa) + ntohs(v->lsa->length);
+ lim = ((uint8_t *)v->lsa) + ntohs(v->lsa->length);
while (p < lim) {
l = (struct router_lsa_link *)p;
struct ospf_area *area, struct pqueue *candidate)
{
struct ospf_lsa *w_lsa = NULL;
- u_char *p;
- u_char *lim;
+ uint8_t *p;
+ uint8_t *lim;
struct router_lsa_link *l = NULL;
struct in_addr *r;
int type = 0, lsa_pos = -1, lsa_pos_next = 0;
v->type == OSPF_VERTEX_ROUTER ? "Router" : "Network",
inet_ntoa(v->lsa->id));
- p = ((u_char *)v->lsa) + OSPF_LSA_HEADER_SIZE + 4;
- lim = ((u_char *)v->lsa) + ntohs(v->lsa->length);
+ p = ((uint8_t *)v->lsa) + OSPF_LSA_HEADER_SIZE + 4;
+ lim = ((uint8_t *)v->lsa) + ntohs(v->lsa->length);
while (p < lim) {
struct vertex *w;
zlog_debug("ospf_process_stub():processing stubs for area %s",
inet_ntoa(area->area_id));
if (v->type == OSPF_VERTEX_ROUTER) {
- u_char *p;
- u_char *lim;
+ uint8_t *p;
+ uint8_t *lim;
struct router_lsa_link *l;
struct router_lsa *rlsa;
int lsa_pos = 0;
zlog_debug(
"ospf_process_stubs(): we have %d links to process",
ntohs(rlsa->links));
- p = ((u_char *)v->lsa) + OSPF_LSA_HEADER_SIZE + 4;
- lim = ((u_char *)v->lsa) + ntohs(v->lsa->length);
+ p = ((uint8_t *)v->lsa) + OSPF_LSA_HEADER_SIZE + 4;
+ lim = ((uint8_t *)v->lsa) + ntohs(v->lsa->length);
while (p < lim) {
l = (struct router_lsa_link *)p;
/* A router or network in an area */
struct vertex {
- u_char flags;
- u_char type; /* copied from LSA header */
+ uint8_t flags;
+ uint8_t type; /* copied from LSA header */
struct in_addr id; /* copied from LSA header */
struct lsa_header *lsa; /* Router or Network LSA */
int *stat; /* Link to LSA status. */
- u_int32_t distance; /* from root to this vertex */
+ uint32_t distance; /* from root to this vertex */
struct list *parents; /* list of parents in SPF tree */
struct list *children; /* list of children in SPF tree*/
};
/* Update Segment Link of given Segment Routing Node */
static void update_ext_link_sid(struct sr_node *srn, struct sr_link *srl,
- u_char lsa_flags)
+ uint8_t lsa_flags)
{
struct listnode *node;
struct sr_link *lk;
int idx = 0;
struct in_addr rid;
struct sr_node *srn;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL, *json_node_array = NULL;
if (!OspfSR.enabled) {
static int ospf_mpls_te_register(enum inter_as_mode mode)
{
int rc = 0;
- u_int8_t scope;
+ uint8_t scope;
if (OspfMplsTE.inter_as != Off)
return rc;
static int ospf_mpls_te_unregister()
{
- u_int8_t scope;
+ uint8_t scope;
if (OspfMplsTE.inter_as == Off)
return 0;
return;
}
-static u_int32_t get_mpls_te_instance_value(void)
+static uint32_t get_mpls_te_instance_value(void)
{
- static u_int32_t seqno = 0;
+ static uint32_t seqno = 0;
if (seqno < MAX_LEGAL_TE_INSTANCE_NUM)
seqno += 1;
static void set_linkparams_link_header(struct mpls_te_link *lp)
{
- u_int16_t length = 0;
+ uint16_t length = 0;
/* TE_LINK_SUBTLV_LINK_TYPE */
if (ntohs(lp->link_type.header.type) != 0)
}
static void set_linkparams_te_metric(struct mpls_te_link *lp,
- u_int32_t te_metric)
+ uint32_t te_metric)
{
lp->te_metric.header.type = htons(TE_LINK_SUBTLV_TE_METRIC);
lp->te_metric.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
}
static void set_linkparams_rsc_clsclr(struct mpls_te_link *lp,
- u_int32_t classcolor)
+ uint32_t classcolor)
{
lp->rsc_clsclr.header.type = htons(TE_LINK_SUBTLV_RSC_CLSCLR);
lp->rsc_clsclr.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
}
static void set_linkparams_inter_as(struct mpls_te_link *lp,
- struct in_addr addr, u_int32_t as)
+ struct in_addr addr, uint32_t as)
{
/* Set the Remote ASBR IP address and then the associated AS number */
lp->ras.value = htonl(0);
}
-void set_linkparams_llri(struct mpls_te_link *lp, u_int32_t local,
- u_int32_t remote)
+void set_linkparams_llri(struct mpls_te_link *lp, uint32_t local,
+ uint32_t remote)
{
lp->llri.header.type = htons(TE_LINK_SUBTLV_LLRI);
lp->lrrid.remote.s_addr = remote.s_addr;
}
-static void set_linkparams_av_delay(struct mpls_te_link *lp, u_int32_t delay,
- u_char anormal)
+static void set_linkparams_av_delay(struct mpls_te_link *lp, uint32_t delay,
+ uint8_t anormal)
{
- u_int32_t tmp;
+ uint32_t tmp;
/* Note that TLV-length field is the size of array. */
lp->av_delay.header.type = htons(TE_LINK_SUBTLV_AV_DELAY);
lp->av_delay.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
return;
}
-static void set_linkparams_mm_delay(struct mpls_te_link *lp, u_int32_t low,
- u_int32_t high, u_char anormal)
+static void set_linkparams_mm_delay(struct mpls_te_link *lp, uint32_t low,
+ uint32_t high, uint8_t anormal)
{
- u_int32_t tmp;
+ uint32_t tmp;
/* Note that TLV-length field is the size of array. */
lp->mm_delay.header.type = htons(TE_LINK_SUBTLV_MM_DELAY);
lp->mm_delay.header.length = htons(TE_LINK_SUBTLV_MM_DELAY_SIZE);
return;
}
-static void set_linkparams_delay_var(struct mpls_te_link *lp, u_int32_t jitter)
+static void set_linkparams_delay_var(struct mpls_te_link *lp, uint32_t jitter)
{
/* Note that TLV-length field is the size of array. */
lp->delay_var.header.type = htons(TE_LINK_SUBTLV_DELAY_VAR);
return;
}
-static void set_linkparams_pkt_loss(struct mpls_te_link *lp, u_int32_t loss,
- u_char anormal)
+static void set_linkparams_pkt_loss(struct mpls_te_link *lp, uint32_t loss,
+ uint8_t anormal)
{
- u_int32_t tmp;
+ uint32_t tmp;
/* Note that TLV-length field is the size of array. */
lp->pkt_loss.header.type = htons(TE_LINK_SUBTLV_PKT_LOSS);
lp->pkt_loss.header.length = htons(TE_LINK_SUBTLV_DEF_SIZE);
struct stream *s;
struct lsa_header *lsah;
struct ospf_lsa *new = NULL;
- u_char options, lsa_type = 0;
+ uint8_t options, lsa_type = 0;
struct in_addr lsa_id;
- u_int32_t tmp;
- u_int16_t length;
+ uint32_t tmp;
+ uint16_t length;
/* Create a stream for LSA. */
if ((s = stream_new(OSPF_MAX_LSA_SIZE)) == NULL) {
struct ospf_lsa lsa;
struct lsa_header lsah;
struct ospf *top;
- u_int32_t tmp;
+ uint32_t tmp;
memset(&lsa, 0, sizeof(lsa));
memset(&lsah, 0, sizeof(lsah));
* Followings are vty session control functions.
*------------------------------------------------------------------------*/
-static u_int16_t show_vty_router_addr(struct vty *vty, struct tlv_header *tlvh)
+static uint16_t show_vty_router_addr(struct vty *vty, struct tlv_header *tlvh)
{
struct te_tlv_router_addr *top = (struct te_tlv_router_addr *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_header(struct vty *vty, struct tlv_header *tlvh)
+static uint16_t show_vty_link_header(struct vty *vty, struct tlv_header *tlvh)
{
struct te_tlv_link *top = (struct te_tlv_link *)tlvh;
return TLV_HDR_SIZE; /* Here is special, not "TLV_SIZE". */
}
-static u_int16_t show_vty_link_subtlv_link_type(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_link_type(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_link_type *top;
const char *cp = "Unknown";
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_link_id(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_link_id(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_link_id *top;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_lclif_ipaddr(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_lclif_ipaddr(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_lclif_ipaddr *top;
int i, n;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_rmtif_ipaddr(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_rmtif_ipaddr(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_rmtif_ipaddr *top;
int i, n;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_te_metric(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_te_metric(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_te_metric *top;
top = (struct te_link_subtlv_te_metric *)tlvh;
if (vty != NULL)
vty_out(vty, " Traffic Engineering Metric: %u\n",
- (u_int32_t)ntohl(top->value));
+ (uint32_t)ntohl(top->value));
else
zlog_debug(" Traffic Engineering Metric: %u",
- (u_int32_t)ntohl(top->value));
+ (uint32_t)ntohl(top->value));
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_max_bw(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_max_bw(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_max_bw *top;
float fval;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_max_rsv_bw(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_max_rsv_bw(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_max_rsv_bw *top;
float fval;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_unrsv_bw(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_unrsv_bw(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_unrsv_bw *top;
float fval1, fval2;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_rsc_clsclr(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_rsc_clsclr(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_rsc_clsclr *top;
top = (struct te_link_subtlv_rsc_clsclr *)tlvh;
if (vty != NULL)
vty_out(vty, " Resource class/color: 0x%x\n",
- (u_int32_t)ntohl(top->value));
+ (uint32_t)ntohl(top->value));
else
zlog_debug(" Resource Class/Color: 0x%x",
- (u_int32_t)ntohl(top->value));
+ (uint32_t)ntohl(top->value));
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_lrrid(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_lrrid(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_lrrid *top;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_llri(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_llri(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_llri *top;
if (vty != NULL) {
vty_out(vty, " Link Local ID: %d\n",
- (u_int32_t)ntohl(top->local));
+ (uint32_t)ntohl(top->local));
vty_out(vty, " Link Remote ID: %d\n",
- (u_int32_t)ntohl(top->remote));
+ (uint32_t)ntohl(top->remote));
} else {
zlog_debug(" Link Local ID: %d",
- (u_int32_t)ntohl(top->local));
+ (uint32_t)ntohl(top->local));
zlog_debug(" Link Remote ID: %d",
- (u_int32_t)ntohl(top->remote));
+ (uint32_t)ntohl(top->remote));
}
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_rip(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_rip(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_rip *top;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_ras(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_ras(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_ras *top;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_av_delay(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_av_delay(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_av_delay *top;
- u_int32_t delay;
- u_int32_t anomalous;
+ uint32_t delay;
+ uint32_t anomalous;
top = (struct te_link_subtlv_av_delay *)tlvh;
- delay = (u_int32_t)ntohl(top->value) & TE_EXT_MASK;
- anomalous = (u_int32_t)ntohl(top->value) & TE_EXT_ANORMAL;
+ delay = (uint32_t)ntohl(top->value) & TE_EXT_MASK;
+ anomalous = (uint32_t)ntohl(top->value) & TE_EXT_ANORMAL;
if (vty != NULL)
vty_out(vty, " %s Average Link Delay: %d (micro-sec)\n",
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_mm_delay(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_mm_delay(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_mm_delay *top;
- u_int32_t low, high;
- u_int32_t anomalous;
+ uint32_t low, high;
+ uint32_t anomalous;
top = (struct te_link_subtlv_mm_delay *)tlvh;
- low = (u_int32_t)ntohl(top->low) & TE_EXT_MASK;
- anomalous = (u_int32_t)ntohl(top->low) & TE_EXT_ANORMAL;
- high = (u_int32_t)ntohl(top->high);
+ low = (uint32_t)ntohl(top->low) & TE_EXT_MASK;
+ anomalous = (uint32_t)ntohl(top->low) & TE_EXT_ANORMAL;
+ high = (uint32_t)ntohl(top->high);
if (vty != NULL)
vty_out(vty, " %s Min/Max Link Delay: %d/%d (micro-sec)\n",
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_delay_var(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_delay_var(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_delay_var *top;
- u_int32_t jitter;
+ uint32_t jitter;
top = (struct te_link_subtlv_delay_var *)tlvh;
- jitter = (u_int32_t)ntohl(top->value) & TE_EXT_MASK;
+ jitter = (uint32_t)ntohl(top->value) & TE_EXT_MASK;
if (vty != NULL)
vty_out(vty, " Delay Variation: %d (micro-sec)\n", jitter);
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_pkt_loss(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_pkt_loss(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_pkt_loss *top;
- u_int32_t loss;
- u_int32_t anomalous;
+ uint32_t loss;
+ uint32_t anomalous;
float fval;
top = (struct te_link_subtlv_pkt_loss *)tlvh;
- loss = (u_int32_t)ntohl(top->value) & TE_EXT_MASK;
+ loss = (uint32_t)ntohl(top->value) & TE_EXT_MASK;
fval = (float)(loss * LOSS_PRECISION);
- anomalous = (u_int32_t)ntohl(top->value) & TE_EXT_ANORMAL;
+ anomalous = (uint32_t)ntohl(top->value) & TE_EXT_ANORMAL;
if (vty != NULL)
vty_out(vty, " %s Link Loss: %g (%%)\n",
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_res_bw(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_res_bw(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_res_bw *top;
float fval;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_ava_bw(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_ava_bw(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_ava_bw *top;
float fval;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_subtlv_use_bw(struct vty *vty,
- struct tlv_header *tlvh)
+static uint16_t show_vty_link_subtlv_use_bw(struct vty *vty,
+ struct tlv_header *tlvh)
{
struct te_link_subtlv_use_bw *top;
float fval;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_unknown_tlv(struct vty *vty, struct tlv_header *tlvh)
+static uint16_t show_vty_unknown_tlv(struct vty *vty, struct tlv_header *tlvh)
{
if (vty != NULL)
vty_out(vty, " Unknown TLV: [type(0x%x), length(0x%x)]\n",
return TLV_SIZE(tlvh);
}
-static u_int16_t ospf_mpls_te_show_link_subtlv(struct vty *vty,
- struct tlv_header *tlvh0,
- u_int16_t subtotal,
- u_int16_t total)
+static uint16_t ospf_mpls_te_show_link_subtlv(struct vty *vty,
+ struct tlv_header *tlvh0,
+ uint16_t subtotal, uint16_t total)
{
struct tlv_header *tlvh, *next;
- u_int16_t sum = subtotal;
+ uint16_t sum = subtotal;
for (tlvh = tlvh0; sum < total;
tlvh = (next ? next : TLV_HDR_NEXT(tlvh))) {
{
struct lsa_header *lsah = (struct lsa_header *)lsa->data;
struct tlv_header *tlvh, *next;
- u_int16_t sum, total;
- u_int16_t (*subfunc)(struct vty * vty, struct tlv_header * tlvh,
- u_int16_t subtotal, u_int16_t total) = NULL;
+ uint16_t sum, total;
+ uint16_t (*subfunc)(struct vty * vty, struct tlv_header * tlvh,
+ uint16_t subtotal, uint16_t total) = NULL;
sum = 0;
total = ntohs(lsah->length) - OSPF_LSA_HEADER_SIZE;
struct {
#define LINK_TYPE_SUBTLV_VALUE_PTP 1
#define LINK_TYPE_SUBTLV_VALUE_MA 2
- u_char value;
- u_char padding[3];
+ uint8_t value;
+ uint8_t padding[3];
} link_type;
};
#define TE_LINK_SUBTLV_TE_METRIC 5
struct te_link_subtlv_te_metric {
struct tlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Link metric for TE purpose. */
+ uint32_t value; /* Link metric for TE purpose. */
};
/* Link Sub-TLV: Maximum Bandwidth */ /* Optional */
#define TE_LINK_SUBTLV_RSC_CLSCLR 9
struct te_link_subtlv_rsc_clsclr {
struct tlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Admin. group membership. */
+ uint32_t value; /* Admin. group membership. */
};
/* For RFC6827 */
#define TE_LINK_SUBTLV_LLRI_SIZE 8
struct te_link_subtlv_llri {
struct tlv_header header; /* Value length is 8 octets. */
- u_int32_t local; /* Link Local Identifier */
- u_int32_t remote; /* Link Remote Identifier */
+ uint32_t local; /* Link Local Identifier */
+ uint32_t remote; /* Link Remote Identifier */
};
/* Inter-RA Export Upward sub-TLV (12) and Inter-RA Export Downward sub-TLV (13)
#define TE_LINK_SUBTLV_RAS 21
struct te_link_subtlv_ras {
struct tlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Remote AS number */
+ uint32_t value; /* Remote AS number */
};
/* IPv4 Remote ASBR ID Sub-TLV */
* delay in micro-seconds only 24 bits => 0 ... 16777215
* with Anomalous Bit as Upper most bit
*/
- u_int32_t value;
+ uint32_t value;
};
/* Link Sub-TLV: Low/High Link Delay */
* low delay in micro-seconds only 24 bits => 0 ... 16777215
* with Anomalous Bit (A) as Upper most bit
*/
- u_int32_t low;
+ uint32_t low;
/* high delay in micro-seconds only 24 bits => 0 ... 16777215 */
- u_int32_t high;
+ uint32_t high;
};
/* Link Sub-TLV: Link Delay Variation i.e. Jitter */
struct te_link_subtlv_delay_var {
struct tlv_header header; /* Value length is 4 bytes. */
/* interval in micro-seconds only 24 bits => 0 ... 16777215 */
- u_int32_t value;
+ uint32_t value;
};
/* Link Sub-TLV: Routine Unidirectional Link Packet Loss */
* in percentage of total traffic only 24 bits (2^24 - 2)
* with Anomalous Bit as Upper most bit
*/
- u_int32_t value;
+ uint32_t value;
};
/* Link Sub-TLV: Unidirectional Residual Bandwidth */ /* Optional */
struct te_link_subtlv {
struct tlv_header header;
union {
- u_int32_t link_type;
+ uint32_t link_type;
struct in_addr link_id;
struct in_addr lclif;
struct in_addr rmtif;
- u_int32_t te_metric;
+ uint32_t te_metric;
float max_bw;
float max_rsv_bw;
float unrsv[8];
- u_int32_t rsc_clsclr;
- u_int32_t llri[2];
- u_int32_t ras;
+ uint32_t rsc_clsclr;
+ uint32_t llri[2];
+ uint32_t ras;
struct in_addr rip;
struct in_addr lrrid[2];
- u_int32_t av_delay;
- u_int32_t mm_delay;
- u_int32_t delay_var;
- u_int32_t pkt_loss;
+ uint32_t av_delay;
+ uint32_t mm_delay;
+ uint32_t delay_var;
+ uint32_t pkt_loss;
float res_bw;
float ava_bw;
float use_bw;
* is subdivided into 8-bit "unused" field and 16-bit "instance" field.
* In this implementation, each Link-TLV has its own instance.
*/
- u_int32_t instance;
+ uint32_t instance;
/* Reference pointer to a Zebra-interface. */
struct interface *ifp;
struct ospf_area *area;
/* Flags to manage this link parameters. */
- u_int32_t flags;
+ uint32_t flags;
/* Type of MPLS-TE link: RFC3630, RFC5392, RFC5392 emulated, RFC6827 */
- u_int8_t type;
+ uint8_t type;
/* Store Link-TLV in network byte order. */
/* RFC3630 & RFC6827 / RFC 6827 */
extern struct ospf_mpls_te *get_ospf_mpls_te(void);
extern void ospf_mpls_te_update_if(struct interface *);
extern void ospf_mpls_te_lsa_schedule(struct mpls_te_link *, enum lsa_opcode);
-extern void set_linkparams_llri(struct mpls_te_link *, u_int32_t, u_int32_t);
+extern void set_linkparams_llri(struct mpls_te_link *, uint32_t, uint32_t);
extern void set_linkparams_lrrid(struct mpls_te_link *, struct in_addr,
struct in_addr);
static struct ospf *ospf_cmd_lookup_ospf(struct vty *vty,
struct cmd_token *argv[],
const int argc, uint32_t enable,
- u_short *instance)
+ unsigned short *instance)
{
struct ospf *ospf = NULL;
int idx_vrf = 0, idx_inst = 0;
}
static void ospf_show_vrf_name(struct ospf *ospf, struct vty *vty,
- json_object *json, u_char use_vrf)
+ json_object *json, uint8_t use_vrf)
{
if (use_vrf) {
if (json) {
{
struct ospf *ospf = NULL;
int ret = CMD_SUCCESS;
- u_short instance = 0;
+ unsigned short instance = 0;
struct vrf *vrf = NULL;
struct route_node *rn;
struct interface *ifp;
VRF_CMD_HELP_STR)
{
struct ospf *ospf;
- u_short instance = 0;
+ unsigned short instance = 0;
ospf = ospf_cmd_lookup_ospf(vty, argv, argc, 0, &instance);
if (ospf == NULL) {
}
-static void ospf_passive_interface_default(struct ospf *ospf, u_char newval)
+static void ospf_passive_interface_default(struct ospf *ospf, uint8_t newval)
{
struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
struct listnode *ln;
static void ospf_passive_interface_update_addr(struct ospf *ospf,
struct interface *ifp,
struct ospf_if_params *params,
- u_char value,
+ uint8_t value,
struct in_addr addr)
{
- u_char dflt;
+ uint8_t dflt;
params->passive_interface = value;
if (params != IF_DEF_PARAMS(ifp)) {
static void ospf_passive_interface_update(struct ospf *ospf,
struct interface *ifp,
struct ospf_if_params *params,
- u_char value)
+ uint8_t value)
{
params->passive_interface = value;
if (params == IF_DEF_PARAMS(ifp)) {
struct prefix_ipv4 p;
struct in_addr area_id;
int format;
- u_int32_t cost;
+ uint32_t cost;
VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
struct prefix_ipv4 p;
struct in_addr area_id;
int format;
- u_int32_t cost;
+ uint32_t cost;
VTY_GET_OSPF_AREA_ID(area_id, format, argv[idx_ipv4_number]->arg);
str2prefix_ipv4(argv[idx_ipv4_prefixlen]->arg, &p);
: "stub");
else
vty_out(vty, "Area %ld is %s\n",
- (u_long)ntohl(area_id.s_addr),
+ (unsigned long)ntohl(area_id.s_addr),
area->external_routing == OSPF_AREA_NSSA
? "nssa"
: "stub");
int idx_number = 3;
struct ospf_area *area;
struct in_addr area_id;
- u_int32_t cost;
+ uint32_t cost;
int format;
struct prefix_ipv4 p;
{
VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
int idx_vendor = 2;
- u_char abr_type = OSPF_ABR_UNKNOWN;
+ uint8_t abr_type = OSPF_ABR_UNKNOWN;
if (strncmp(argv[idx_vendor]->arg, "c", 1) == 0)
abr_type = OSPF_ABR_CISCO;
{
VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
int idx_vendor = 3;
- u_char abr_type = OSPF_ABR_UNKNOWN;
+ uint8_t abr_type = OSPF_ABR_UNKNOWN;
if (strncmp(argv[idx_vendor]->arg, "c", 1) == 0)
abr_type = OSPF_ABR_CISCO;
VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
int idx_number = 2;
- u_int32_t refbw;
+ uint32_t refbw;
struct interface *ifp;
refbw = strtol(argv[idx_number]->arg, NULL, 10);
{
VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
int idx_number;
- u_int32_t write_oi_count;
+ uint32_t write_oi_count;
if (argc == 3)
idx_number = 2;
const char *ospf_shortcut_mode_descr_str[] = {"Default", "Enabled", "Disabled"};
static void show_ip_ospf_area(struct vty *vty, struct ospf_area *area,
- json_object *json_areas, u_char use_json)
+ json_object *json_areas, uint8_t use_json)
{
json_object *json_area = NULL;
}
static int show_ip_ospf_common(struct vty *vty, struct ospf *ospf,
- json_object *json, u_char use_vrf)
+ json_object *json, uint8_t use_vrf)
{
struct listnode *node, *nnode;
struct ospf_area *area;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
char *vrf_name = NULL;
bool all_vrf = FALSE;
int inst = 0;
int idx_vrf = 0;
json_object *json = NULL;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
if (listcount(om->ospf) == 0)
return CMD_SUCCESS;
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
int ret = CMD_SUCCESS;
json_object *json = NULL;
static void show_ip_ospf_interface_sub(struct vty *vty, struct ospf *ospf,
struct interface *ifp,
json_object *json_interface_sub,
- u_char use_json)
+ uint8_t use_json)
{
int is_up;
struct ospf_neighbor *nbr;
}
static int show_ip_ospf_interface_common(struct vty *vty, struct ospf *ospf,
- char *intf_name, u_char use_vrf,
- json_object *json, u_char use_json)
+ char *intf_name, uint8_t use_vrf,
+ json_object *json, uint8_t use_json)
{
struct interface *ifp;
struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
static void show_ip_ospf_interface_traffic_sub(struct vty *vty,
struct ospf_interface *oi,
json_object *json_interface_sub,
- u_char use_json)
+ uint8_t use_json)
{
if (use_json) {
json_object_int_add(json_interface_sub, "ifIndex",
/* OSPFv2 Packet Counters */
static int show_ip_ospf_interface_traffic_common(
struct vty *vty, struct ospf *ospf, char *intf_name, json_object *json,
- int display_once, u_char use_vrf, u_char use_json)
+ int display_once, uint8_t use_vrf, uint8_t use_json)
{
struct vrf *vrf = NULL;
struct interface *ifp = NULL;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
char *vrf_name = NULL, *intf_name = NULL;
bool all_vrf = FALSE;
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0, idx_intf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
json_object *json = NULL;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
int idx_number = 3;
int idx_intf = 0;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
char *intf_name = NULL;
int ret = CMD_SUCCESS;
json_object *json = NULL;
bool all_vrf = FALSE;
int inst = 0;
int idx_vrf = 0, idx_intf = 0;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
int ret = CMD_SUCCESS;
int display_once = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
static void show_ip_ospf_neighbor_sub(struct vty *vty,
struct ospf_interface *oi,
- json_object *json, u_char use_json)
+ json_object *json, uint8_t use_json)
{
struct route_node *rn;
struct ospf_neighbor *nbr, *prev_nbr = NULL;
}
static int show_ip_ospf_neighbor_common(struct vty *vty, struct ospf *ospf,
- json_object *json, u_char use_json,
- u_char use_vrf)
+ json_object *json, uint8_t use_json,
+ uint8_t use_vrf)
{
struct ospf_interface *oi;
struct listnode *node;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
char *vrf_name = NULL;
bool all_vrf = FALSE;
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
json_object *json = NULL;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
int ret = CMD_SUCCESS;
}
static int show_ip_ospf_neighbor_all_common(struct vty *vty, struct ospf *ospf,
- json_object *json, u_char use_json,
- u_char use_vrf)
+ json_object *json, uint8_t use_json,
+ uint8_t use_vrf)
{
struct listnode *node;
struct ospf_interface *oi;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
char *vrf_name = NULL;
bool all_vrf = FALSE;
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
json_object *json = NULL;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
int ret = CMD_SUCCESS;
static int show_ip_ospf_neighbor_int_common(struct vty *vty, struct ospf *ospf,
int arg_base,
struct cmd_token **argv,
- u_char use_json, u_char use_vrf)
+ uint8_t use_json, uint8_t use_vrf)
{
struct interface *ifp;
struct route_node *rn;
{
struct ospf *ospf;
int idx_ifname = 4;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
int ret = CMD_SUCCESS;
struct interface *ifp = NULL;
int idx_number = 3;
int idx_ifname = 5;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
if (!uj)
show_ip_ospf_neighbour_header(vty);
static void show_ip_ospf_nbr_nbma_detail_sub(struct vty *vty,
struct ospf_interface *oi,
struct ospf_nbr_nbma *nbr_nbma,
- u_char use_json, json_object *json)
+ uint8_t use_json,
+ json_object *json)
{
char timebuf[OSPF_TIME_DUMP_SIZE];
json_object *json_sub = NULL;
static void show_ip_ospf_neighbor_detail_sub(struct vty *vty,
struct ospf_interface *oi,
struct ospf_neighbor *nbr,
- json_object *json, u_char use_json)
+ json_object *json,
+ uint8_t use_json)
{
char timebuf[OSPF_TIME_DUMP_SIZE];
json_object *json_sub = NULL;
static int show_ip_ospf_neighbor_id_common(struct vty *vty, struct ospf *ospf,
int arg_base,
struct cmd_token **argv,
- u_char use_json, u_char use_vrf)
+ uint8_t use_json, uint8_t use_vrf)
{
struct listnode *node;
struct ospf_neighbor *nbr;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
int ret = CMD_SUCCESS;
int idx_number = 3;
int idx_router_id = 5;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
instance = strtoul(argv[idx_number]->arg, NULL, 10);
ospf = ospf_lookup_instance(instance);
static int show_ip_ospf_neighbor_detail_common(struct vty *vty,
struct ospf *ospf,
json_object *json,
- u_char use_json, u_char use_vrf)
+ uint8_t use_json,
+ uint8_t use_vrf)
{
struct ospf_interface *oi;
struct listnode *node;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
char *vrf_name = NULL;
bool all_vrf = FALSE;
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
json_object *json = NULL;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
int ret = CMD_SUCCESS;
static int show_ip_ospf_neighbor_detail_all_common(struct vty *vty,
struct ospf *ospf,
json_object *json,
- u_char use_json,
- u_char use_vrf)
+ uint8_t use_json,
+ uint8_t use_vrf)
{
struct listnode *node;
struct ospf_interface *oi;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
char *vrf_name = NULL;
bool all_vrf = FALSE;
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
json_object *json = NULL;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
int ret = CMD_SUCCESS;
struct ospf *ospf,
int arg_base,
struct cmd_token **argv,
- u_char use_json)
+ uint8_t use_json)
{
struct ospf_interface *oi;
struct interface *ifp;
JSON_STR)
{
struct ospf *ospf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct listnode *node = NULL;
int ret = CMD_SUCCESS;
int idx_number = 3;
int idx_ifname = 5;
struct ospf *ospf;
- u_short instance = 0;
- u_char uj = use_json(argc, argv);
+ unsigned short instance = 0;
+ uint8_t uj = use_json(argc, argv);
instance = strtoul(argv[idx_number]->arg, NULL, 10);
ospf = ospf_lookup_instance(instance);
vty_out(vty, "%-15s ", inet_ntoa(lsa->data->id));
vty_out(vty, "%-15s %4d 0x%08lx 0x%04x",
inet_ntoa(lsa->data->adv_router), LS_AGE(lsa),
- (u_long)ntohl(lsa->data->ls_seqnum),
+ (unsigned long)ntohl(lsa->data->ls_seqnum),
ntohs(lsa->data->checksum));
/* LSA specific part show. */
switch (lsa->data->type) {
? "E2"
: "E1",
inet_ntoa(p.prefix), p.prefixlen,
- (u_long)ntohl(asel->e[0].route_tag));
+ (unsigned long)ntohl(
+ asel->e[0].route_tag));
break;
case OSPF_NETWORK_LSA:
case OSPF_ASBR_SUMMARY_LSA:
vty_out(vty, " Advertising Router: %s\n",
inet_ntoa(lsa->data->adv_router));
vty_out(vty, " LS Seq Number: %08lx\n",
- (u_long)ntohl(lsa->data->ls_seqnum));
+ (unsigned long)ntohl(lsa->data->ls_seqnum));
vty_out(vty, " Checksum: 0x%04x\n", ntohs(lsa->data->checksum));
vty_out(vty, " Length: %d\n\n", ntohs(lsa->data->length));
}
static int show_ip_ospf_database_common(struct vty *vty, struct ospf *ospf,
int arg_base, int argc,
- struct cmd_token **argv, u_char use_vrf)
+ struct cmd_token **argv,
+ uint8_t use_vrf)
{
int idx_type = 4;
int type, ret;
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
"Advertising Router (as an IP address)\n")
{
struct ospf *ospf;
- u_short instance = 0;
+ unsigned short instance = 0;
struct listnode *node = NULL;
char *vrf_name = NULL;
bool all_vrf = FALSE;
int ret = CMD_SUCCESS;
int inst = 0;
int idx = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
if (argv_find(argv, argc, "(1-65535)", &idx)) {
instance = strtoul(argv[idx]->arg, NULL, 10);
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
struct ospf *ospf,
int arg_base, int argc,
struct cmd_token **argv,
- u_char use_vrf)
+ uint8_t use_vrf)
{
int idx_type = 4;
int type, ret;
"Self-originated link states\n")
{
struct ospf *ospf = NULL;
- u_short instance = 0;
+ unsigned short instance = 0;
struct listnode *node = NULL;
char *vrf_name = NULL;
bool all_vrf = FALSE;
int ret = CMD_SUCCESS;
int inst = 0;
int idx = 0, idx_vrf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
if (argv_find(argv, argc, "(1-65535)", &idx)) {
instance = strtoul(argv[idx]->arg, NULL, 10);
{
VTY_DECLVAR_CONTEXT(interface, ifp);
struct crypt_key *ck;
- u_char key_id;
+ uint8_t key_id;
struct in_addr addr;
struct ospf_if_params *params;
}
ck = ospf_crypt_key_new();
- ck->key_id = (u_char)key_id;
+ ck->key_id = (uint8_t)key_id;
memset(ck->auth_key, 0, OSPF_AUTH_MD5_SIZE + 1);
strncpy((char *)ck->auth_key, cryptkey, OSPF_AUTH_MD5_SIZE);
{
VTY_DECLVAR_CONTEXT(interface, ifp);
int idx = 0;
- u_int32_t cost = OSPF_OUTPUT_COST_DEFAULT;
+ uint32_t cost = OSPF_OUTPUT_COST_DEFAULT;
struct in_addr addr;
struct ospf_if_params *params;
params = IF_DEF_PARAMS(ifp);
const char *fast_hello_str)
{
VTY_DECLVAR_CONTEXT(interface, ifp);
- u_int32_t seconds;
- u_char hellomult;
+ uint32_t seconds;
+ uint8_t hellomult;
struct in_addr addr;
int ret;
struct ospf_if_params *params;
struct in_addr addr;
struct ospf_if_params *params;
params = IF_DEF_PARAMS(ifp);
- u_int32_t seconds = 0;
+ uint32_t seconds = 0;
argv_find(argv, argc, "(1-65535)", &idx);
seconds = strtol(argv[idx]->arg, NULL, 10);
{
VTY_DECLVAR_CONTEXT(interface, ifp);
int idx = 0;
- u_int32_t seconds;
+ uint32_t seconds;
struct in_addr addr;
struct ospf_if_params *params;
params = IF_DEF_PARAMS(ifp);
{
VTY_DECLVAR_CONTEXT(interface, ifp);
int idx = 0;
- u_int32_t seconds;
+ uint32_t seconds;
struct in_addr addr;
struct ospf_if_params *params;
struct ospf_if_params *params = NULL;
struct route_node *rn;
struct ospf *ospf = NULL;
- u_short instance = 0;
+ unsigned short instance = 0;
char *areaid;
if (argv_find(argv, argc, "(1-65535)", &idx))
int idx = 0;
struct ospf *ospf;
struct ospf_if_params *params;
- u_short instance = 0;
+ unsigned short instance = 0;
struct in_addr addr;
if (argv_find(argv, argc, "(1-65535)", &idx))
int source;
int type = -1;
int metric = -1;
- u_short instance;
+ unsigned short instance;
struct ospf_redist *red;
if (!ospf)
VTY_DECLVAR_INSTANCE_CONTEXT(ospf, ospf);
int idx_ospf_table = 2;
int idx_number = 3;
- u_int instance;
+ unsigned int instance;
struct ospf_redist *red;
int source;
}
static int show_ip_ospf_border_routers_common(struct vty *vty,
- struct ospf *ospf, u_char use_vrf)
+ struct ospf *ospf,
+ uint8_t use_vrf)
{
if (ospf->instance)
vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0;
- u_char use_vrf = 0;
+ uint8_t use_vrf = 0;
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
ospf = ospf_lookup_instance(instance);
}
static int show_ip_ospf_route_common(struct vty *vty, struct ospf *ospf,
- json_object *json, u_char use_vrf)
+ json_object *json, uint8_t use_vrf)
{
json_object *json_vrf = NULL;
int ret = CMD_SUCCESS;
int inst = 0;
int idx_vrf = 0;
- u_char use_vrf = 0;
- u_char uj = use_json(argc, argv);
+ uint8_t use_vrf = 0;
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
if (uj)
{
int idx_number = 3;
struct ospf *ospf;
- u_short instance = 0;
+ unsigned short instance = 0;
instance = strtoul(argv[idx_number]->arg, NULL, 10);
ospf = ospf_lookup_instance(instance);
"Show OSPF VRFs \n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
json_object *json = NULL;
json_object *json_vrfs = NULL;
struct ospf *ospf = NULL;
static int config_write_network_area(struct vty *vty, struct ospf *ospf)
{
struct route_node *rn;
- u_char buf[INET_ADDRSTRLEN];
+ uint8_t buf[INET_ADDRSTRLEN];
/* `network area' print. */
for (rn = route_top(ospf->networks); rn; rn = route_next(rn))
{
struct listnode *node;
struct ospf_area *area;
- u_char buf[INET_ADDRSTRLEN];
+ uint8_t buf[INET_ADDRSTRLEN];
/* Area configuration print. */
for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area)) {
{
struct zapi_route api;
struct zapi_nexthop *api_nh;
- u_char distance;
+ uint8_t distance;
struct ospf_path *path;
struct listnode *node;
int count = 0;
inet_ntoa(p->prefix), p->prefixlen);
}
-struct ospf_external *ospf_external_lookup(struct ospf *ospf, u_char type,
- u_short instance)
+struct ospf_external *ospf_external_lookup(struct ospf *ospf, uint8_t type,
+ unsigned short instance)
{
struct list *ext_list;
struct listnode *node;
return NULL;
}
-struct ospf_external *ospf_external_add(struct ospf *ospf, u_char type,
- u_short instance)
+struct ospf_external *ospf_external_add(struct ospf *ospf, uint8_t type,
+ unsigned short instance)
{
struct list *ext_list;
struct ospf_external *ext;
return ext;
}
-void ospf_external_del(struct ospf *ospf, u_char type, u_short instance)
+void ospf_external_del(struct ospf *ospf, uint8_t type, unsigned short instance)
{
struct ospf_external *ext;
}
}
-struct ospf_redist *ospf_redist_lookup(struct ospf *ospf, u_char type,
- u_short instance)
+struct ospf_redist *ospf_redist_lookup(struct ospf *ospf, uint8_t type,
+ unsigned short instance)
{
struct list *red_list;
struct listnode *node;
return NULL;
}
-struct ospf_redist *ospf_redist_add(struct ospf *ospf, u_char type,
- u_short instance)
+struct ospf_redist *ospf_redist_add(struct ospf *ospf, uint8_t type,
+ unsigned short instance)
{
struct list *red_list;
struct ospf_redist *red;
return red;
}
-void ospf_redist_del(struct ospf *ospf, u_char type, u_short instance)
+void ospf_redist_del(struct ospf *ospf, uint8_t type, unsigned short instance)
{
struct ospf_redist *red;
}
-int ospf_is_type_redistributed(struct ospf *ospf, int type, u_short instance)
+int ospf_is_type_redistributed(struct ospf *ospf, int type,
+ unsigned short instance)
{
return (DEFAULT_ROUTE_TYPE(type)
? vrf_bitmap_check(zclient->default_information,
ospf->vrf_id))));
}
-int ospf_redistribute_set(struct ospf *ospf, int type, u_short instance,
+int ospf_redistribute_set(struct ospf *ospf, int type, unsigned short instance,
int mtype, int mvalue)
{
int force = 0;
return CMD_SUCCESS;
}
-int ospf_redistribute_unset(struct ospf *ospf, int type, u_short instance)
+int ospf_redistribute_unset(struct ospf *ospf, int type,
+ unsigned short instance)
{
if (type == zclient->redist_default && instance == zclient->instance)
return CMD_SUCCESS;
struct route_map_set_values save_values;
struct prefix_ipv4 *p = &ei->p;
struct ospf_redist *red;
- u_char type = is_prefix_default(&ei->p) ? DEFAULT_ROUTE : ei->type;
- u_short instance = is_prefix_default(&ei->p) ? 0 : ei->instance;
+ uint8_t type = is_prefix_default(&ei->p) ? DEFAULT_ROUTE : ei->type;
+ unsigned short instance = is_prefix_default(&ei->p) ? 0 : ei->instance;
if (changed)
*changed = 0;
}
/* Update distribute-list and set timer to apply access-list. */
-void ospf_distribute_list_update(struct ospf *ospf, int type, u_short instance)
+void ospf_distribute_list_update(struct ospf *ospf, int type,
+ unsigned short instance)
{
struct route_table *rt;
struct ospf_external *ext;
{
int ret;
struct prefix_ipv4 p;
- u_char distance;
+ uint8_t distance;
struct route_node *rn;
struct ospf_distance *odistance;
}
}
-u_char ospf_distance_apply(struct ospf *ospf, struct prefix_ipv4 *p,
- struct ospf_route * or)
+uint8_t ospf_distance_apply(struct ospf *ospf, struct prefix_ipv4 *p,
+ struct ospf_route * or)
{
if (ospf == NULL)
zclient_send_reg_requests(zclient, VRF_DEFAULT);
}
-void ospf_zebra_init(struct thread_master *master, u_short instance)
+void ospf_zebra_init(struct thread_master *master, unsigned short instance)
{
/* Allocate zebra structure. */
zclient = zclient_new_notify(master, &zclient_options_default);
/* OSPF distance. */
struct ospf_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;
int *);
extern int ospf_distribute_check_connected(struct ospf *,
struct external_info *);
-extern void ospf_distribute_list_update(struct ospf *, int, u_short);
+extern void ospf_distribute_list_update(struct ospf *, int, unsigned short);
-extern int ospf_is_type_redistributed(struct ospf *, int, u_short);
+extern int ospf_is_type_redistributed(struct ospf *, int, unsigned short);
extern void ospf_distance_reset(struct ospf *);
-extern u_char ospf_distance_apply(struct ospf *ospf, struct prefix_ipv4 *,
- struct ospf_route *);
-extern struct ospf_external *ospf_external_lookup(struct ospf *, u_char,
- u_short);
-extern struct ospf_external *ospf_external_add(struct ospf *, u_char, u_short);
-extern void ospf_external_del(struct ospf *, u_char, u_short);
-extern struct ospf_redist *ospf_redist_lookup(struct ospf *, u_char, u_short);
-extern struct ospf_redist *ospf_redist_add(struct ospf *, u_char, u_short);
-extern void ospf_redist_del(struct ospf *, u_char, u_short);
+extern uint8_t ospf_distance_apply(struct ospf *ospf, struct prefix_ipv4 *,
+ struct ospf_route *);
+extern struct ospf_external *ospf_external_lookup(struct ospf *, uint8_t,
+ unsigned short);
+extern struct ospf_external *ospf_external_add(struct ospf *, uint8_t,
+ unsigned short);
+extern void ospf_external_del(struct ospf *, uint8_t, unsigned short);
+extern struct ospf_redist *ospf_redist_lookup(struct ospf *, uint8_t,
+ unsigned short);
+extern struct ospf_redist *ospf_redist_add(struct ospf *, uint8_t,
+ unsigned short);
+extern void ospf_redist_del(struct ospf *, uint8_t, unsigned short);
-extern int ospf_redistribute_set(struct ospf *, int, u_short, int, int);
-extern int ospf_redistribute_unset(struct ospf *, int, u_short);
+extern int ospf_redistribute_set(struct ospf *, int, unsigned short, int, int);
+extern int ospf_redistribute_unset(struct ospf *, int, unsigned short);
extern int ospf_redistribute_default_set(struct ospf *, int, int, int);
extern int ospf_redistribute_default_unset(struct ospf *);
extern int ospf_distribute_list_out_set(struct ospf *, int, const char *);
const char *, const char *);
extern int ospf_distance_unset(struct vty *, struct ospf *, const char *,
const char *, const char *);
-extern void ospf_zebra_init(struct thread_master *, u_short);
+extern void ospf_zebra_init(struct thread_master *, unsigned short);
extern void ospf_zebra_vrf_register(struct ospf *ospf);
extern void ospf_zebra_vrf_deregister(struct ospf *ospf);
}
/* Allocate new ospf structure. */
-static struct ospf *ospf_new(u_short instance, const char *name)
+static struct ospf *ospf_new(unsigned short instance, const char *name)
{
int i;
struct vrf *vrf = NULL;
return new;
}
-struct ospf *ospf_lookup_instance(u_short instance)
+struct ospf *ospf_lookup_instance(unsigned short instance)
{
struct ospf *ospf;
struct listnode *node, *nnode;
listnode_delete(om->ospf, ospf);
}
-struct ospf *ospf_lookup_by_inst_name(u_short instance, const char *name)
+struct ospf *ospf_lookup_by_inst_name(unsigned short instance, const char *name)
{
struct ospf *ospf = NULL;
struct listnode *node, *nnode;
return NULL;
}
-struct ospf *ospf_get(u_short instance, const char *name)
+struct ospf *ospf_get(unsigned short instance, const char *name)
{
struct ospf *ospf;
return ospf;
}
-struct ospf *ospf_get_instance(u_short instance)
+struct ospf *ospf_get_instance(unsigned short instance)
{
struct ospf *ospf;
struct ospf_vl_data *vl_data;
struct listnode *node, *nnode;
int i;
- u_short instance = 0;
+ unsigned short instance = 0;
QOBJ_UNREG(ospf);
}
int ospf_nbr_nbma_priority_set(struct ospf *ospf, struct in_addr nbr_addr,
- u_char priority)
+ uint8_t priority)
{
struct ospf_nbr_nbma *nbr_nbma;
#define OSPF_LS_REFRESH_JITTER 60
struct ospf_external {
- u_short instance;
+ unsigned short instance;
struct route_table *external_info;
};
struct thread_master *master;
/* Various OSPF global configuration. */
- u_char options;
+ uint8_t options;
#define OSPF_MASTER_SHUTDOWN (1 << 0) /* deferred-shutdown */
};
struct ospf_redist {
- u_short instance;
+ unsigned short instance;
/* Redistribute metric info. */
struct {
struct ospf {
/* OSPF's running state based on the '[no] router ospf [<instance>]'
* config. */
- u_char oi_running;
+ uint8_t oi_running;
/* OSPF instance ID */
- u_short instance;
+ unsigned short instance;
/* OSPF Router ID. */
struct in_addr router_id; /* Configured automatically. */
char *name; /* VRF name */
/* ABR/ASBR internal flags. */
- u_char flags;
+ uint8_t flags;
#define OSPF_FLAG_ABR 0x0001
#define OSPF_FLAG_ASBR 0x0002
/* ABR type. */
- u_char abr_type;
+ uint8_t abr_type;
#define OSPF_ABR_UNKNOWN 0
#define OSPF_ABR_STAND 1
#define OSPF_ABR_IBM 2
#define OSPF_ABR_DEFAULT OSPF_ABR_CISCO
/* NSSA ABR */
- u_char anyNSSA; /* Bump for every NSSA attached. */
+ uint8_t anyNSSA; /* Bump for every NSSA attached. */
/* Configured variables. */
- u_char config;
+ uint8_t config;
#define OSPF_RFC1583_COMPATIBLE (1 << 0)
#define OSPF_OPAQUE_CAPABLE (1 << 2)
#define OSPF_LOG_ADJACENCY_CHANGES (1 << 3)
#define OSPF_LOG_ADJACENCY_DETAIL (1 << 4)
/* Opaque-LSA administrative flags. */
- u_char opaque;
+ uint8_t opaque;
#define OPAQUE_OPERATION_READY_BIT (1 << 0)
/* RFC3137 stub router. Configured time to stay stub / max-metric */
unsigned int stub_router_startup_time; /* seconds */
unsigned int stub_router_shutdown_time; /* seconds */
#define OSPF_STUB_ROUTER_UNCONFIGURED 0
- u_char stub_router_admin_set;
+ uint8_t stub_router_admin_set;
#define OSPF_STUB_ROUTER_ADMINISTRATIVE_SET 1
#define OSPF_STUB_ROUTER_ADMINISTRATIVE_UNSET 0
#define DEFAULT_ORIGINATE_NONE 0
#define DEFAULT_ORIGINATE_ZEBRA 1
#define DEFAULT_ORIGINATE_ALWAYS 2
- u_int32_t ref_bandwidth; /* Reference Bandwidth (Kbps). */
+ uint32_t ref_bandwidth; /* Reference Bandwidth (Kbps). */
struct route_table *networks; /* OSPF config networks. */
struct list *vlinks; /* Configured Virtual-Links. */
struct list *areas; /* OSPF areas. */
struct ospf_area *backbone; /* Pointer to the Backbone Area. */
struct list *oiflist; /* ospf interfaces */
- u_char passive_interface_default; /* passive-interface default */
+ uint8_t passive_interface_default; /* passive-interface default */
/* LSDB of AS-external-LSAs. */
struct ospf_lsdb *lsdb;
/ OSPF_LSA_REFRESHER_GRANULARITY \
+ 1)
struct {
- u_int16_t index;
+ uint16_t index;
struct list *qs[OSPF_LSA_REFRESHER_SLOTS];
} lsa_refresh_queue;
struct thread *t_lsa_refresher;
time_t lsa_refresher_started;
#define OSPF_LSA_REFRESH_INTERVAL_DEFAULT 10
- u_int16_t lsa_refresh_interval;
+ uint16_t lsa_refresh_interval;
/* Distance parameter. */
- u_char distance_all;
- u_char distance_intra;
- u_char distance_inter;
- u_char distance_external;
+ uint8_t distance_all;
+ uint8_t distance_intra;
+ uint8_t distance_inter;
+ uint8_t distance_external;
/* Statistics for LSA origination. */
- u_int32_t lsa_originate_count;
+ uint32_t lsa_originate_count;
/* Statistics for LSA used for new instantiation. */
- u_int32_t rx_lsa_count;
+ uint32_t rx_lsa_count;
/* Counter of "ip ospf area x.x.x.x" used
* for multual exclusion of network command under
* router ospf or ip ospf area x under interface. */
- u_int32_t if_ospf_cli_count;
+ uint32_t if_ospf_cli_count;
struct route_table *distance_table;
#define OSPF_SHORTCUT_ENABLE 1
#define OSPF_SHORTCUT_DISABLE 2
int shortcut_capability; /* Other ABRs agree on S-bit */
- u_int32_t default_cost; /* StubDefaultCost. */
+ uint32_t default_cost; /* StubDefaultCost. */
int auth_type; /* Authentication type. */
- u_char NSSATranslatorRole; /* NSSA configured role */
+ uint8_t NSSATranslatorRole; /* NSSA configured role */
#define OSPF_NSSA_ROLE_NEVER 0
#define OSPF_NSSA_ROLE_CANDIDATE 1
#define OSPF_NSSA_ROLE_ALWAYS 2
- u_char NSSATranslatorState; /* NSSA operational role */
+ uint8_t NSSATranslatorState; /* NSSA operational role */
#define OSPF_NSSA_TRANSLATE_DISABLED 0
#define OSPF_NSSA_TRANSLATE_ENABLED 1
int NSSATranslatorStabilityInterval;
- u_char transit; /* TransitCapability. */
+ uint8_t transit; /* TransitCapability. */
#define OSPF_TRANSIT_FALSE 0
#define OSPF_TRANSIT_TRUE 1
struct route_table *ranges; /* Configured Area Ranges. */
/* RFC3137 stub router state flags for area */
- u_char stub_router_state;
+ uint8_t stub_router_state;
#define OSPF_AREA_ADMIN_STUB_ROUTED (1 << 0) /* admin stub-router set */
#define OSPF_AREA_IS_STUB_ROUTED (1 << 1) /* stub-router active */
#define OSPF_AREA_WAS_START_STUB_ROUTED (1 << 2) /* startup SR was done */
struct thread *t_opaque_lsa_self; /* Type-10 Opaque-LSAs origin. */
/* Statistics field. */
- u_int32_t spf_calculation; /* SPF Calculation Count. */
+ uint32_t spf_calculation; /* SPF Calculation Count. */
/* Time stamps. */
struct timeval ts_spf; /* SPF calculation time stamp. */
/* Router count. */
- u_int32_t abr_count; /* ABR router in this area. */
- u_int32_t asbr_count; /* ASBR router in this area. */
+ uint32_t abr_count; /* ABR router in this area. */
+ uint32_t asbr_count; /* ASBR router in this area. */
/* Counters. */
- u_int32_t act_ints; /* Active interfaces. */
- u_int32_t full_nbrs; /* Fully adjacent neighbors. */
- u_int32_t full_vls; /* Fully adjacent virtual neighbors. */
+ uint32_t act_ints; /* Active interfaces. */
+ uint32_t full_nbrs; /* Fully adjacent neighbors. */
+ uint32_t full_vls; /* Fully adjacent virtual neighbors. */
};
/* OSPF config network structure. */
struct ospf_neighbor *nbr;
/* Neighbor priority. */
- u_char priority;
+ uint8_t priority;
/* Poll timer value. */
- u_int32_t v_poll;
+ uint32_t v_poll;
/* Poll timer thread. */
struct thread *t_poll;
/* State change. */
- u_int32_t state_change;
+ uint32_t state_change;
};
/* Macro. */
extern struct zebra_privs_t ospfd_privs;
/* Prototypes. */
-extern const char *ospf_redist_string(u_int route_type);
-extern struct ospf *ospf_lookup_instance(u_short);
-extern struct ospf *ospf_get(u_short instance, const char *name);
-extern struct ospf *ospf_get_instance(u_short);
-extern struct ospf *ospf_lookup_by_inst_name(u_short instance,
+extern const char *ospf_redist_string(unsigned int route_type);
+extern struct ospf *ospf_lookup_instance(unsigned short);
+extern struct ospf *ospf_get(unsigned short instance, const char *name);
+extern struct ospf *ospf_get_instance(unsigned short);
+extern struct ospf *ospf_lookup_by_inst_name(unsigned short instance,
const char *name);
extern struct ospf *ospf_lookup_by_vrf_id(vrf_id_t vrf_id);
extern void ospf_finish(struct ospf *);
extern int ospf_timers_refresh_unset(struct ospf *);
extern int ospf_nbr_nbma_set(struct ospf *, struct in_addr);
extern int ospf_nbr_nbma_unset(struct ospf *, struct in_addr);
-extern int ospf_nbr_nbma_priority_set(struct ospf *, struct in_addr, u_char);
+extern int ospf_nbr_nbma_priority_set(struct ospf *, struct in_addr, uint8_t);
extern int ospf_nbr_nbma_priority_unset(struct ospf *, struct in_addr);
extern int ospf_nbr_nbma_poll_interval_set(struct ospf *, struct in_addr,
unsigned int);
struct igmp_mtrace *mtrace;
int mtrace_len;
int responses;
- u_short sum;
+ unsigned short sum;
recvd = recvfrom(fd, mtrace_buf, IP_AND_MTRACE_BUF_LEN, 0, NULL, 0);
* pim_bfd_show_info - Show BFD info structure
*/
void pim_bfd_show_info(struct vty *vty, void *bfd_info, json_object *json_obj,
- u_char use_json, int param_only)
+ uint8_t use_json, int param_only)
{
if (param_only)
bfd_show_param(vty, (struct bfd_info *)bfd_info, 1, 0, use_json,
* pim_bfd_if_param_set - Set the configured BFD paramter values for
* interface.
*/
-void pim_bfd_if_param_set(struct interface *ifp, u_int32_t min_rx,
- u_int32_t min_tx, u_int8_t detect_mult, int defaults)
+void pim_bfd_if_param_set(struct interface *ifp, uint32_t min_rx,
+ uint32_t min_tx, uint8_t detect_mult, int defaults)
{
struct pim_interface *pim_ifp = ifp->info;
int command = 0;
void pim_bfd_init(void);
void pim_bfd_write_config(struct vty *vty, struct interface *ifp);
void pim_bfd_show_info(struct vty *vty, void *bfd_info, json_object *json_obj,
- u_char use_json, int param_only);
-void pim_bfd_if_param_set(struct interface *ifp, u_int32_t min_rx,
- u_int32_t min_tx, u_int8_t detect_mult, int defaults);
+ uint8_t use_json, int param_only);
+void pim_bfd_if_param_set(struct interface *ifp, uint32_t min_rx,
+ uint32_t min_tx, uint8_t detect_mult, int defaults);
int pim_bfd_reg_dereg_all_nbr(struct interface *ifp, int command);
void pim_bfd_trigger_event(struct pim_interface *pim_ifp,
struct pim_neighbor *nbr, uint8_t nbr_up);
json_object_object_add(json_iface, ch_grp_str, json_row);
}
static void pim_show_membership(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct pim_interface *pim_ifp;
struct pim_ifchannel *ch;
}
static void igmp_show_interfaces(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct interface *ifp;
time_t now;
static void igmp_show_interfaces_single(struct pim_instance *pim,
struct vty *vty, const char *ifname,
- u_char uj)
+ uint8_t uj)
{
struct igmp_sock *igmp;
struct interface *ifp;
static void pim_show_interfaces_single(struct pim_instance *pim,
struct vty *vty, const char *ifname,
- u_char uj)
+ uint8_t uj)
{
struct in_addr ifaddr;
struct interface *ifp;
}
static void pim_show_interfaces(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct interface *ifp;
struct listnode *upnode;
}
static void pim_show_interface_traffic(struct pim_instance *pim,
- struct vty *vty, u_char uj)
+ struct vty *vty, uint8_t uj)
{
struct interface *ifp = NULL;
struct pim_interface *pim_ifp = NULL;
static void pim_show_interface_traffic_single(struct pim_instance *pim,
struct vty *vty,
- const char *ifname, u_char uj)
+ const char *ifname, uint8_t uj)
{
struct interface *ifp = NULL;
struct pim_interface *pim_ifp = NULL;
static void pim_show_join_helper(struct vty *vty, struct pim_interface *pim_ifp,
struct pim_ifchannel *ch, json_object *json,
- time_t now, u_char uj)
+ time_t now, uint8_t uj)
{
char ch_src_str[INET_ADDRSTRLEN];
char ch_grp_str[INET_ADDRSTRLEN];
}
}
-static void pim_show_join(struct pim_instance *pim, struct vty *vty, u_char uj)
+static void pim_show_join(struct pim_instance *pim, struct vty *vty, uint8_t uj)
{
struct pim_interface *pim_ifp;
struct pim_ifchannel *ch;
}
static void pim_show_neighbors_single(struct pim_instance *pim, struct vty *vty,
- const char *neighbor, u_char uj)
+ const char *neighbor, uint8_t uj)
{
struct listnode *neighnode;
struct interface *ifp;
static void pim_show_state(struct pim_instance *pim, struct vty *vty,
const char *src_or_group, const char *group,
- u_char uj)
+ uint8_t uj)
{
struct channel_oil *c_oil;
struct listnode *node;
}
static void pim_show_neighbors(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct listnode *neighnode;
struct interface *ifp;
}
static void pim_show_upstream(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct listnode *upnode;
struct pim_upstream *up;
struct vty *vty,
struct pim_interface *pim_ifp,
struct pim_ifchannel *ch,
- json_object *json, u_char uj)
+ json_object *json, uint8_t uj)
{
struct pim_upstream *up = ch->upstream;
json_object *json_group = NULL;
}
static void pim_show_join_desired(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct pim_interface *pim_ifp;
struct pim_ifchannel *ch;
}
static void pim_show_upstream_rpf(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct listnode *upnode;
struct pim_upstream *up;
uptime_mroute_del, (long long)pim->mroute_del_events);
}
-static void pim_show_rpf(struct pim_instance *pim, struct vty *vty, u_char uj)
+static void pim_show_rpf(struct pim_instance *pim, struct vty *vty, uint8_t uj)
{
struct listnode *up_node;
struct pim_upstream *up;
}
static void igmp_show_groups(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct interface *ifp;
time_t now;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
JSON_STR)
{
int idx = 2;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
VRF_CMD_HELP_STR
"IGMP static join information\n")
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
IGMP_GROUP_STR
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
JSON_STR)
{
int idx = 6;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
"PIM interface join information\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
JSON_STR)
{
int idx = 2;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
const char *group = NULL;
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
const char *src_or_group = NULL;
const char *group = NULL;
int idx = 2;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
"PIM upstream information\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
"PIM RP information\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
"PIM cached source rpf information\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
VRF_CMD_HELP_STR
"Multicast global information\n")
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
}
static void show_mroute(struct pim_instance *pim, struct vty *vty, bool fill,
- u_char uj)
+ uint8_t uj)
{
struct listnode *node;
struct channel_oil *c_oil;
"Fill in Assumed data\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
bool fill = false;
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
"Fill in Assumed data\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
int idx = 4;
struct vrf *vrf;
bool first = true;
VRF_CMD_HELP_STR
"Route and packet count data\n")
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
}
static void ip_pim_ssm_show_group_range(struct pim_instance *pim,
- struct vty *vty, u_char uj)
+ struct vty *vty, uint8_t uj)
{
struct pim_ssm *ssm = pim->ssm_info;
const char *range_str =
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
}
static void ip_pim_ssm_show_group_type(struct pim_instance *pim,
- struct vty *vty, u_char uj,
+ struct vty *vty, uint8_t uj,
const char *group)
{
struct in_addr group_addr;
{
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!vrf)
return CMD_WARNING;
int idx_number = 3;
int idx_number_2 = 4;
int idx_number_3 = 5;
- 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;
struct pim_interface *pim_ifp = ifp->info;
}
static void ip_msdp_show_mesh_group(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct listnode *mbrnode;
struct pim_msdp_mg_mbr *mbr;
"MSDP mesh-group information\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
"MSDP mesh-group information\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
}
static void ip_msdp_show_peers(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct listnode *mpnode;
struct pim_msdp_peer *mp;
}
static void ip_msdp_show_peers_detail(struct pim_instance *pim, struct vty *vty,
- const char *peer, u_char uj)
+ const char *peer, uint8_t uj)
{
struct listnode *mpnode;
struct pim_msdp_peer *mp;
"peer ip address\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
JSON_STR)
{
int idx = 2;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
}
static void ip_msdp_show_sa(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct listnode *sanode;
struct pim_msdp_sa *sa;
static void ip_msdp_show_sa_entry_detail(struct pim_msdp_sa *sa,
const char *src_str,
const char *grp_str, struct vty *vty,
- u_char uj, json_object *json)
+ uint8_t uj, json_object *json)
{
char rp_str[INET_ADDRSTRLEN];
char peer_str[INET_ADDRSTRLEN];
}
static void ip_msdp_show_sa_detail(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct listnode *sanode;
struct pim_msdp_sa *sa;
"Detailed output\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
int idx = 2;
struct vrf *vrf = pim_cmd_lookup_vrf(vty, argv, argc, &idx);
"Detailed output\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
}
static void ip_msdp_show_sa_addr(struct pim_instance *pim, struct vty *vty,
- const char *addr, u_char uj)
+ const char *addr, uint8_t uj)
{
struct listnode *sanode;
struct pim_msdp_sa *sa;
}
static void ip_msdp_show_sa_sg(struct pim_instance *pim, struct vty *vty,
- const char *src, const char *grp, u_char uj)
+ const char *src, const char *grp, uint8_t uj)
{
struct listnode *sanode;
struct pim_msdp_sa *sa;
"group ip\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
int idx = 2;
"group ip\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
struct vrf *vrf;
bool first = true;
int idx = 2;
int fd;
char if_str[INET_ADDRSTRLEN];
char rsp_str[INET_ADDRSTRLEN];
- u_char ttl;
+ uint8_t ttl;
memset(&to, 0, sizeof(to));
to.sin_family = AF_INET;
struct pim_nexthop_cache {
struct pim_rpf rpf;
/* IGP route's metric. */
- u_int32_t metric;
+ uint32_t metric;
uint32_t distance;
/* Nexthop number and nexthop linked list. */
- u_char nexthop_num;
+ uint8_t nexthop_num;
struct nexthop *nexthop;
int64_t last_update;
- u_int16_t flags;
+ uint16_t flags;
#define PIM_NEXTHOP_VALID (1 << 0)
struct list *rp_list;
}
void pim_rp_show_information(struct pim_instance *pim, struct vty *vty,
- u_char uj)
+ uint8_t uj)
{
struct rp_info *rp_info;
struct rp_info *prev_rp_info = NULL;
#define RP(P, G) pim_rp_g ((P), (G))
void pim_rp_show_information(struct pim_instance *pim, struct vty *vty,
- u_char uj);
+ uint8_t uj);
void pim_resolve_rp_nh(struct pim_instance *pim);
int pim_rp_list_cmp(void *v1, void *v2);
#endif
}
int pim_socket_mcast(int protocol, struct in_addr ifaddr, struct interface *ifp,
- u_char loop)
+ uint8_t loop)
{
int rcvbuf = 1024 * 1024 * 8;
#ifdef HAVE_STRUCT_IP_MREQN_IMR_IFINDEX
void pim_socket_ip_hdr(int fd);
int pim_socket_raw(int protocol);
int pim_socket_mcast(int protocol, struct in_addr ifaddr, struct interface *ifp,
- u_char loop);
+ uint8_t loop);
int pim_socket_join(int fd, struct in_addr group, struct in_addr ifaddr,
ifindex_t ifindex);
int pim_socket_join_source(int fd, ifindex_t ifindex, struct in_addr group_addr,
int num_ifindex = 0;
struct stream *s;
uint16_t length;
- u_char marker;
- u_char version;
+ uint8_t marker;
+ uint8_t version;
vrf_id_t vrf_id;
uint16_t command = 0;
struct in_addr raddr;
int err;
uint16_t length = 0;
vrf_id_t vrf_id;
- u_char marker;
- u_char version;
+ uint8_t marker;
+ uint8_t version;
stream_reset(s);
err = zclient_read_header(s, zlookup->sock, &length, &marker,
*/
#define qpb_address_family_set qpb__address_family__set
static inline int qpb__address_family__set(Qpb__AddressFamily *pb_family,
- u_char family)
+ uint8_t family)
{
switch (family) {
case AF_INET:
*/
#define qpb_address_family_get qpb__address_family__get
static inline int qpb__address_family__get(Qpb__AddressFamily pb_family,
- u_char *family)
+ uint8_t *family)
{
switch (pb_family) {
*/
#define qpb_l3_prefix_get qpb__l3_prefix__get
static inline int qpb__l3_prefix__get(const Qpb__L3Prefix *pb_prefix,
- u_char family, struct prefix *prefix)
+ uint8_t family, struct prefix *prefix)
{
switch (family) {
#define qpb_l3_address_create qpb__l3_address__create
static inline Qpb__L3Address *
qpb__l3_address__create(qpb_allocator_t *allocator, union g_addr *addr,
- u_char family)
+ uint8_t family)
{
Qpb__L3Address *l3_addr;
*/
#define qpb_l3_address_get qpb__l3_address__get
static inline int qpb__l3_address__get(const Qpb__L3Address *l3_addr,
- u_char *family, union g_addr *addr)
+ uint8_t *family, union g_addr *addr)
{
if (l3_addr->v4) {
qpb__ipv4_address__get(l3_addr->v4, &addr->ipv4);
}
/* Send RIP request packet to specified interface. */
-static void rip_request_interface_send(struct interface *ifp, u_char version)
+static void rip_request_interface_send(struct interface *ifp, uint8_t version)
{
struct sockaddr_in to;
/* If metric is modifed return 1. */
int rip_offset_list_apply_in(struct prefix_ipv4 *p, struct interface *ifp,
- u_int32_t *metric)
+ uint32_t *metric)
{
struct rip_offset_list *offset;
struct access_list *alist;
/* If metric is modifed return 1. */
int rip_offset_list_apply_out(struct prefix_ipv4 *p, struct interface *ifp,
- u_int32_t *metric)
+ uint32_t *metric)
{
struct rip_offset_list *offset;
struct access_list *alist;
return peer;
}
-void rip_peer_update(struct sockaddr_in *from, u_char version)
+void rip_peer_update(struct sockaddr_in *from, uint8_t version)
{
struct rip_peer *peer;
peer = rip_peer_get(&from->sin_addr);
struct rip_metric_modifier {
enum { metric_increment, metric_decrement, metric_absolute } type;
bool used;
- u_int8_t metric;
+ uint8_t metric;
};
/* Hook function for updating route_map assignment. */
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;
if (type == RMAP_RIP) {
/* 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)
static struct route_table *rip_ifaddr_table;
/* Hook functions. */
-static u_char *rip2Globals(struct variable *, oid[], size_t *, int, size_t *,
- WriteMethod **);
-static u_char *rip2IfStatEntry(struct variable *, oid[], size_t *, int,
- size_t *, WriteMethod **);
-static u_char *rip2IfConfAddress(struct variable *, oid[], size_t *, int,
- size_t *, WriteMethod **);
-static u_char *rip2PeerTable(struct variable *, oid[], size_t *, int, size_t *,
- WriteMethod **);
+static uint8_t *rip2Globals(struct variable *, oid[], size_t *, int, size_t *,
+ WriteMethod **);
+static uint8_t *rip2IfStatEntry(struct variable *, oid[], size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *rip2IfConfAddress(struct variable *, oid[], size_t *, int,
+ size_t *, WriteMethod **);
+static uint8_t *rip2PeerTable(struct variable *, oid[], size_t *, int, size_t *,
+ WriteMethod **);
static struct variable rip_variables[] = {
/* RIP Global Counters. */
extern struct thread_master *master;
-static u_char *rip2Globals(struct variable *v, oid name[], size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *rip2Globals(struct variable *v, oid name[], size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
if (smux_header_generic(v, name, length, exact, var_len, write_method)
== MATCH_FAILED)
return NULL;
}
-static u_char *rip2IfStatEntry(struct variable *v, oid name[], size_t *length,
- int exact, size_t *var_len,
- WriteMethod **write_method)
+static uint8_t *rip2IfStatEntry(struct variable *v, oid name[], size_t *length,
+ int exact, size_t *var_len,
+ WriteMethod **write_method)
{
struct interface *ifp;
struct rip_interface *ri;
break;
case RIP2IFSTATRCVBADPACKETS:
*var_len = sizeof(long);
- return (u_char *)&ri->recv_badpackets;
+ return (uint8_t *)&ri->recv_badpackets;
case RIP2IFSTATRCVBADROUTES:
*var_len = sizeof(long);
- return (u_char *)&ri->recv_badroutes;
+ return (uint8_t *)&ri->recv_badroutes;
case RIP2IFSTATSENTUPDATES:
*var_len = sizeof(long);
- return (u_char *)&ri->sent_updates;
+ return (uint8_t *)&ri->sent_updates;
case RIP2IFSTATSTATUS:
*var_len = sizeof(long);
v->type = ASN_INTEGER;
- return (u_char *)&valid;
+ return (uint8_t *)&valid;
default:
return NULL;
return doNotReceive;
}
-static u_char *rip2IfConfAddress(struct variable *v, oid name[], size_t *length,
- int exact, size_t *val_len,
- WriteMethod **write_method)
+static uint8_t *rip2IfConfAddress(struct variable *v, oid name[],
+ size_t *length, int exact, size_t *val_len,
+ WriteMethod **write_method)
{
static struct in_addr addr;
static long valid = SNMP_INVALID;
static long domain = 0;
static long config = 0;
- static u_int auth = 0;
+ static unsigned int auth = 0;
struct interface *ifp;
struct rip_interface *ri;
switch (v->magic) {
case RIP2IFCONFADDRESS:
*val_len = sizeof(struct in_addr);
- return (u_char *)&addr;
+ return (uint8_t *)&addr;
case RIP2IFCONFDOMAIN:
*val_len = 2;
- return (u_char *)&domain;
+ return (uint8_t *)&domain;
case RIP2IFCONFAUTHTYPE:
auth = ri->auth_type;
*val_len = sizeof(long);
v->type = ASN_INTEGER;
- return (u_char *)&auth;
+ return (uint8_t *)&auth;
case RIP2IFCONFAUTHKEY:
*val_len = 0;
- return (u_char *)&domain;
+ return (uint8_t *)&domain;
case RIP2IFCONFSEND:
config = rip2IfConfSend(ri);
*val_len = sizeof(long);
v->type = ASN_INTEGER;
- return (u_char *)&config;
+ return (uint8_t *)&config;
case RIP2IFCONFRECEIVE:
config = rip2IfConfReceive(ri);
*val_len = sizeof(long);
v->type = ASN_INTEGER;
- return (u_char *)&config;
+ return (uint8_t *)&config;
case RIP2IFCONFDEFAULTMETRIC:
*val_len = sizeof(long);
v->type = ASN_INTEGER;
- return (u_char *)&ifp->metric;
+ return (uint8_t *)&ifp->metric;
case RIP2IFCONFSTATUS:
*val_len = sizeof(long);
v->type = ASN_INTEGER;
- return (u_char *)&valid;
+ return (uint8_t *)&valid;
case RIP2IFCONFSRCADDRESS:
*val_len = sizeof(struct in_addr);
- return (u_char *)&addr;
+ return (uint8_t *)&addr;
default:
return NULL;
return NULL;
}
-static u_char *rip2PeerTable(struct variable *v, oid name[], size_t *length,
- int exact, size_t *val_len,
- WriteMethod **write_method)
+static uint8_t *rip2PeerTable(struct variable *v, oid name[], size_t *length,
+ int exact, size_t *val_len,
+ WriteMethod **write_method)
{
static struct in_addr addr;
static int domain = 0;
switch (v->magic) {
case RIP2PEERADDRESS:
*val_len = sizeof(struct in_addr);
- return (u_char *)&peer->addr;
+ return (uint8_t *)&peer->addr;
case RIP2PEERDOMAIN:
*val_len = 2;
- return (u_char *)&domain;
+ return (uint8_t *)&domain;
case RIP2PEERLASTUPDATE:
#if 0
*/
*val_len = sizeof (time_t);
uptime = peer->uptime; /* now - snmp_agent_startup - peer->uptime */
- return (u_char *) &uptime;
+ return (uint8_t *) &uptime;
#else
- return (u_char *)NULL;
+ return (uint8_t *)NULL;
#endif
case RIP2PEERVERSION:
*val_len = sizeof(int);
version = peer->version;
- return (u_char *)&version;
+ return (uint8_t *)&version;
case RIP2PEERRCVBADPACKETS:
*val_len = sizeof(int);
- return (u_char *)&peer->recv_badpackets;
+ return (uint8_t *)&peer->recv_badpackets;
case RIP2PEERRCVBADROUTES:
*val_len = sizeof(int);
- return (u_char *)&peer->recv_badroutes;
+ return (uint8_t *)&peer->recv_badroutes;
default:
return NULL;
struct zclient *zclient = NULL;
/* Send ECMP routes to zebra. */
-static void rip_zebra_ipv4_send(struct route_node *rp, u_char cmd)
+static void rip_zebra_ipv4_send(struct route_node *rp, uint8_t cmd)
{
struct list *list = (struct list *)rp->info;
struct zapi_route api;
/* Prototypes. */
static void rip_event(enum rip_event, int);
static void rip_output_process(struct connected *, struct sockaddr_in *, int,
- u_char);
+ uint8_t);
static int rip_triggered_update(struct thread *);
static int rip_update_jitter(unsigned long);
struct rte *rte;
const char *command_str;
char pbuf[BUFSIZ], nbuf[BUFSIZ];
- u_char netmask = 0;
- u_char *p;
+ uint8_t netmask = 0;
+ uint8_t *p;
/* Set command string. */
if (packet->command > 0 && packet->command < RIP_COMMAND_MAX)
if (rte->family == htons(RIP_FAMILY_AUTH)) {
if (rte->tag
== htons(RIP_AUTH_SIMPLE_PASSWORD)) {
- p = (u_char *)&rte->prefix;
+ p = (uint8_t *)&rte->prefix;
zlog_debug(
" family 0x%X type %d auth string: %s",
" Auth Data len %d",
ntohs(md5->packet_len),
md5->keyid, md5->auth_len);
- zlog_debug(
- " Sequence Number %ld",
- (u_long)ntohl(md5->sequence));
+ zlog_debug(" Sequence Number %ld",
+ (unsigned long)ntohl(
+ md5->sequence));
} else if (rte->tag == htons(RIP_AUTH_DATA)) {
- p = (u_char *)&rte->prefix;
+ p = (uint8_t *)&rte->prefix;
zlog_debug(
" family 0x%X type %d (MD5 data)",
BUFSIZ),
ntohs(rte->family),
(route_tag_t)ntohs(rte->tag),
- (u_long)ntohl(rte->metric));
+ (unsigned long)ntohl(rte->metric));
} else {
zlog_debug(
" %s family %d tag %" ROUTE_TAG_PRI
inet_ntop(AF_INET, &rte->prefix, pbuf, BUFSIZ),
ntohs(rte->family),
(route_tag_t)ntohs(rte->tag),
- (u_long)ntohl(rte->metric));
+ (unsigned long)ntohl(rte->metric));
}
}
}
check net 0 because we accept default route. */
static int rip_destination_check(struct in_addr addr)
{
- u_int32_t destination;
+ uint32_t destination;
/* Convert to host byte order. */
destination = ntohl(addr.s_addr);
struct keychain *keychain;
struct key *key;
MD5_CTX ctx;
- u_char digest[RIP_AUTH_MD5_SIZE];
- u_int16_t packet_len;
+ uint8_t digest[RIP_AUTH_MD5_SIZE];
+ uint16_t packet_len;
char auth_str[RIP_AUTH_MD5_SIZE];
if (IS_RIP_DEBUG_EVENT)
}
/* retrieve authentication data */
- md5data = (struct rip_md5_data *)(((u_char *)packet) + packet_len);
+ md5data = (struct rip_md5_data *)(((uint8_t *)packet) + packet_len);
memset(auth_str, 0, RIP_AUTH_MD5_SIZE);
the received Next Hop is not directly reachable, it should be
treated as 0.0.0.0. */
if (packet->version == RIPv2 && rte->nexthop.s_addr != 0) {
- u_int32_t addrval;
+ uint32_t addrval;
/* Multicast address check. */
addrval = ntohl(rte->nexthop.s_addr);
|| (packet->version == RIPv2
&& (rte->prefix.s_addr != 0
&& rte->mask.s_addr == 0))) {
- u_int32_t destination;
+ uint32_t destination;
if (subnetted == -1) {
memcpy(&ifaddr, ifc->address,
* by connected argument. NULL to argument denotes destination should be
* should be RIP multicast group
*/
-static int rip_send_packet(u_char *buf, int size, struct sockaddr_in *to,
+static int rip_send_packet(uint8_t *buf, int size, struct sockaddr_in *to,
struct connected *ifc)
{
int ret;
}
packet->command = RIP_RESPONSE;
- rip_send_packet((u_char *)packet, size, from, ifc);
+ rip_send_packet((uint8_t *)packet, size, from, ifc);
}
rip_global_queries++;
}
}
/* Read RIP packet by recvmsg function. */
-int rip_recvmsg(int sock, u_char *buf, int size, struct sockaddr_in *from,
+int rip_recvmsg(int sock, uint8_t *buf, int size, struct sockaddr_in *from,
ifindex_t *ifindex)
{
int ret;
/* Write routing table entry to the stream and return next index of
the routing table entry in the stream. */
static int rip_write_rte(int num, struct stream *s, struct prefix_ipv4 *p,
- u_char version, struct rip_info *rinfo)
+ uint8_t version, struct rip_info *rinfo)
{
struct in_addr mask;
/* Send update to the ifp or spcified neighbor. */
void rip_output_process(struct connected *ifc, struct sockaddr_in *to,
- int route_type, u_char version)
+ int route_type, uint8_t version)
{
int ret;
struct stream *s;
}
/* Send RIP packet to the interface. */
-static void rip_update_interface(struct connected *ifc, u_char version,
+static void rip_update_interface(struct connected *ifc, uint8_t version,
int route_type)
{
struct interface *ifp = ifc->ifp;
/* Sned RIP request to the destination. */
int rip_request_send(struct sockaddr_in *to, struct interface *ifp,
- u_char version, struct connected *connected)
+ uint8_t version, struct connected *connected)
{
struct rte *rte;
struct rip_packet rip_packet;
* interface does not support multicast. Caller loops
* over each connected address for this case.
*/
- if (rip_send_packet((u_char *)&rip_packet, sizeof(rip_packet),
+ if (rip_send_packet((uint8_t *)&rip_packet, sizeof(rip_packet),
to, connected)
!= sizeof(rip_packet))
return -1;
if (p->family != AF_INET)
continue;
- if (rip_send_packet((u_char *)&rip_packet, sizeof(rip_packet),
+ if (rip_send_packet((uint8_t *)&rip_packet, sizeof(rip_packet),
to, connected)
!= sizeof(rip_packet))
return -1;
struct rip_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;
{
int ret;
struct prefix_ipv4 p;
- u_char distance;
+ uint8_t distance;
struct route_node *rn;
struct rip_distance *rdistance;
}
/* Apply RIP information to distance method. */
-u_char rip_distance_apply(struct rip_info *rinfo)
+uint8_t rip_distance_apply(struct rip_info *rinfo)
{
struct route_node *rn;
struct prefix_ipv4 p;
int default_metric;
/* RIP default-information originate. */
- u_char default_information;
+ uint8_t default_information;
char *default_information_route_map;
/* RIP default distance. */
- u_char distance;
+ uint8_t distance;
struct route_table *distance_table;
/* RIP ECMP flag */
char *name;
struct route_map *map;
int metric_config;
- u_int32_t metric;
+ uint32_t metric;
} route_map[ZEBRA_ROUTE_MAX];
QOBJ_FIELDS
/* RIP routing table entry which belong to rip_packet. */
struct rte {
- u_int16_t family; /* Address family of this route. */
- u_int16_t tag; /* Route Tag which included in RIP2 packet. */
+ uint16_t family; /* Address family of this route. */
+ uint16_t tag; /* Route Tag which included in RIP2 packet. */
struct in_addr prefix; /* Prefix of rip route. */
struct in_addr mask; /* Netmask of rip route. */
struct in_addr nexthop; /* Next hop of rip route. */
- u_int32_t metric; /* Metric value of rip route. */
+ uint32_t metric; /* Metric value of rip route. */
};
/* RIP packet structure. */
struct in_addr from;
/* Metric of this route. */
- u_int32_t metric;
+ uint32_t metric;
/* External metric of this route.
if learnt from an externalm proto */
- u_int32_t external_metric;
+ uint32_t external_metric;
/* Tag information of this route. */
- u_int16_t tag;
+ uint16_t tag;
/* Flags of RIP route. */
#define RIP_RTF_FIB 1
#define RIP_RTF_CHANGED 2
- u_char flags;
+ uint8_t flags;
/* Garbage collect timer. */
struct thread *t_timeout;
/* Route-map futures - this variables can be changed. */
struct in_addr nexthop_out;
- u_char metric_set;
- u_int32_t metric_out;
- u_int16_t tag_out;
+ uint8_t metric_set;
+ uint32_t metric_out;
+ uint16_t tag_out;
ifindex_t ifindex_out;
struct route_node *rp;
- u_char distance;
+ uint8_t distance;
#ifdef NEW_RIP_TABLE
struct rip_info *next;
char *key_chain;
/* value to use for md5->auth_len */
- u_int8_t md5_auth_len;
+ uint8_t md5_auth_len;
/* Split horizon flag. */
split_horizon_policy_t split_horizon;
time_t uptime;
/* Peer RIP version. */
- u_char version;
+ uint8_t version;
/* Statistics. */
int recv_badpackets;
};
struct rip_md5_info {
- u_int16_t family;
- u_int16_t type;
- u_int16_t packet_len;
- u_char keyid;
- u_char auth_len;
- u_int32_t sequence;
- u_int32_t reserv1;
- u_int32_t reserv2;
+ uint16_t family;
+ uint16_t type;
+ uint16_t packet_len;
+ uint8_t keyid;
+ uint8_t auth_len;
+ uint32_t sequence;
+ uint32_t reserv1;
+ uint32_t reserv2;
};
struct rip_md5_data {
- u_int16_t family;
- u_int16_t type;
- u_char digest[16];
+ uint16_t family;
+ uint16_t type;
+ uint8_t digest[16];
};
/* RIP accepet/announce methods. */
extern void rip_offset_init(void);
extern int if_check_address(struct in_addr addr);
-extern int rip_request_send(struct sockaddr_in *, struct interface *, u_char,
+extern int rip_request_send(struct sockaddr_in *, struct interface *, uint8_t,
struct connected *);
extern int rip_neighbor_lookup(struct sockaddr_in *);
extern int config_write_rip_redistribute(struct vty *, int);
extern void rip_peer_init(void);
-extern void rip_peer_update(struct sockaddr_in *, u_char);
+extern void rip_peer_update(struct sockaddr_in *, uint8_t);
extern void rip_peer_bad_route(struct sockaddr_in *);
extern void rip_peer_bad_packet(struct sockaddr_in *);
extern void rip_peer_display(struct vty *);
extern struct rip_peer *rip_peer_lookup_next(struct in_addr *);
extern int rip_offset_list_apply_in(struct prefix_ipv4 *, struct interface *,
- u_int32_t *);
+ uint32_t *);
extern int rip_offset_list_apply_out(struct prefix_ipv4 *, struct interface *,
- u_int32_t *);
+ uint32_t *);
extern void rip_offset_clean(void);
extern void rip_info_free(struct rip_info *);
-extern u_char rip_distance_apply(struct rip_info *);
+extern uint8_t rip_distance_apply(struct rip_info *);
extern void rip_redistribute_clean(void);
extern struct rip_info *rip_ecmp_add(struct rip_info *);
/* If metric is modifed return 1. */
int ripng_offset_list_apply_in(struct prefix_ipv6 *p, struct interface *ifp,
- u_char *metric)
+ uint8_t *metric)
{
struct ripng_offset_list *offset;
struct access_list *alist;
/* If metric is modifed return 1. */
int ripng_offset_list_apply_out(struct prefix_ipv6 *p, struct interface *ifp,
- u_char *metric)
+ uint8_t *metric)
{
struct ripng_offset_list *offset;
struct access_list *alist;
return peer;
}
-void ripng_peer_update(struct sockaddr_in6 *from, u_char version)
+void ripng_peer_update(struct sockaddr_in6 *from, uint8_t version)
{
struct ripng_peer *peer;
peer = ripng_peer_get(&from->sin6_addr);
unsigned int suppress;
/* Metric of this route. */
- u_char metric;
+ uint8_t metric;
/* Tag field of RIPng packet.*/
- u_int16_t tag;
+ uint16_t tag;
/* Route-map futures - this variables can be changed. */
struct in6_addr nexthop_out;
- u_char metric_set;
- u_char metric_out;
- u_int16_t tag_out;
+ uint8_t metric_set;
+ uint8_t metric_out;
+ uint16_t tag_out;
};
extern void ripng_aggregate_increment(struct route_node *rp,
struct rip_metric_modifier {
enum { metric_increment, metric_decrement, metric_absolute } type;
bool used;
- u_int8_t metric;
+ uint8_t metric;
};
/* `match metric METRIC' */
route_map_object_t type,
void *object)
{
- u_int32_t *metric;
+ uint32_t *metric;
struct ripng_info *rinfo;
if (type == RMAP_RIPNG) {
/* 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)
struct zclient *zclient = NULL;
/* Send ECMP routes to zebra. */
-static void ripng_zebra_ipv6_send(struct route_node *rp, u_char cmd)
+static void ripng_zebra_ipv6_send(struct route_node *rp, uint8_t cmd)
{
struct list *list = (struct list *)rp->info;
struct zapi_route api;
}
/* Receive UDP RIPng packet from socket. */
-static int ripng_recv_packet(int sock, u_char *buf, int bufsize,
+static int ripng_recv_packet(int sock, uint8_t *buf, int bufsize,
struct sockaddr_in6 *from, ifindex_t *ifindex,
int *hoplimit)
{
/* Write routing table entry to the stream and return next index of
the routing table entry in the stream. */
int ripng_write_rte(int num, struct stream *s, struct prefix_ipv6 *p,
- struct in6_addr *nexthop, u_int16_t tag, u_char metric)
+ struct in6_addr *nexthop, uint16_t tag, uint8_t metric)
{
/* RIPng packet header. */
if (num == 0) {
/* Write routing table entry. */
if (!nexthop)
- stream_write(s, (u_char *)&p->prefix, sizeof(struct in6_addr));
+ stream_write(s, (uint8_t *)&p->prefix, sizeof(struct in6_addr));
else
- stream_write(s, (u_char *)nexthop, sizeof(struct in6_addr));
+ stream_write(s, (uint8_t *)nexthop, sizeof(struct in6_addr));
stream_putw(s, tag);
if (p)
stream_putc(s, p->prefixlen);
int sock;
/* RIPng Parameters.*/
- u_char command;
- u_char version;
+ uint8_t command;
+ uint8_t version;
unsigned long update_time;
unsigned long timeout_time;
unsigned long garbage_time;
char *name;
struct route_map *map;
int metric_config;
- u_int32_t metric;
+ uint32_t metric;
} route_map[ZEBRA_ROUTE_MAX];
};
/* Routing table entry. */
struct rte {
struct in6_addr addr; /* RIPng destination prefix */
- u_int16_t tag; /* RIPng tag */
- u_char prefixlen; /* Length of the RIPng prefix */
- u_char metric; /* Metric of the RIPng route */
+ uint16_t tag; /* RIPng tag */
+ uint8_t prefixlen; /* Length of the RIPng prefix */
+ uint8_t metric; /* Metric of the RIPng route */
/* The nexthop is stored by the structure
* ripng_nexthop within ripngd.c */
};
/* RIPNG send packet. */
struct ripng_packet {
- u_char command;
- u_char version;
- u_int16_t zero;
+ uint8_t command;
+ uint8_t version;
+ uint16_t zero;
struct rte rte[1];
};
/* Each route's information. */
struct ripng_info {
/* This route's type. Static, ripng or aggregate. */
- u_char type;
+ uint8_t type;
/* Sub type for static route. */
- u_char sub_type;
+ uint8_t sub_type;
/* RIPng specific information */
struct in6_addr nexthop;
ifindex_t ifindex;
/* Metric of this route. */
- u_char metric;
+ uint8_t metric;
/* Tag field of RIPng packet.*/
- u_int16_t tag;
+ uint16_t tag;
/* For aggregation. */
unsigned int suppress;
/* Flags of RIPng route. */
#define RIPNG_RTF_FIB 1
#define RIPNG_RTF_CHANGED 2
- u_char flags;
+ uint8_t flags;
/* Garbage collect timer. */
struct thread *t_timeout;
/* Route-map features - this variables can be changed. */
struct in6_addr nexthop_out;
- u_char metric_set;
- u_char metric_out;
- u_int16_t tag_out;
+ uint8_t metric_set;
+ uint8_t metric_out;
+ uint16_t tag_out;
struct route_node *rp;
};
struct ripng_tag
{
/* Tag value. */
- u_int16_t tag;
+ uint16_t tag;
/* Port. */
- u_int16_t port;
+ uint16_t port;
/* Multicast group. */
struct in6_addr maddr;
int distance;
/* Split horizon. */
- u_char split_horizon;
+ uint8_t split_horizon;
/* Poison reverse. */
- u_char poison_reverse;
+ uint8_t poison_reverse;
};
#endif /* 0 */
#endif /* not yet */
#endif /* notyet */
/* Default information originate. */
- u_char default_originate;
+ uint8_t default_originate;
/* Default information only. */
- u_char default_only;
+ uint8_t default_only;
/* Wake up thread. */
struct thread *t_wakeup;
time_t uptime;
/* Peer RIP version. */
- u_char version;
+ uint8_t version;
/* Statistics. */
int recv_badpackets;
extern int config_write_ripng_offset_list(struct vty *);
extern void ripng_peer_init(void);
-extern void ripng_peer_update(struct sockaddr_in6 *, u_char);
+extern void ripng_peer_update(struct sockaddr_in6 *, uint8_t);
extern void ripng_peer_bad_route(struct sockaddr_in6 *);
extern void ripng_peer_bad_packet(struct sockaddr_in6 *);
extern void ripng_peer_display(struct vty *);
extern struct ripng_peer *ripng_peer_lookup_next(struct in6_addr *);
extern int ripng_offset_list_apply_in(struct prefix_ipv6 *, struct interface *,
- u_char *);
+ uint8_t *);
extern int ripng_offset_list_apply_out(struct prefix_ipv6 *, struct interface *,
- u_char *);
+ uint8_t *);
extern void ripng_offset_clean(void);
extern struct ripng_info *ripng_info_new(void);
extern void ripng_redistribute_write(struct vty *, int);
extern int ripng_write_rte(int num, struct stream *s, struct prefix_ipv6 *p,
- struct in6_addr *nexthop, u_int16_t tag,
- u_char metric);
+ struct in6_addr *nexthop, uint16_t tag,
+ uint8_t metric);
extern int ripng_send_packet(caddr_t buf, int bufsize, struct sockaddr_in6 *to,
struct interface *ifp);
static struct test_segment {
const char *name;
const char *desc;
- const u_char asdata[1024];
+ const uint8_t asdata[1024];
int len;
struct test_spec sp;
} test_segments[] = {
};
/* make an aspath from a data stream */
-static struct aspath *make_aspath(const u_char *data, size_t len, int use32bit)
+static struct aspath *make_aspath(const uint8_t *data, size_t len, int use32bit)
{
struct stream *s = NULL;
struct aspath *as;
return as;
}
-static void printbytes(const u_char *bytes, int len)
+static void printbytes(const uint8_t *bytes, int len)
{
int i = 0;
while (i < len) {
{
size_t bytes, bytes4;
int fails = 0;
- const u_char *out;
+ const uint8_t *out;
static struct stream *s;
struct aspath *asinout, *asconfeddel, *asstr, *as4;
static struct test_segment {
const char *name;
const char *desc;
- const u_char data[1024];
+ const uint8_t data[1024];
int len;
#define SHOULD_PARSE 0
#define SHOULD_ERR -1
static struct test_segment {
const char *name;
const char *desc;
- const u_int8_t data[1024];
+ const uint8_t data[1024];
int len;
struct test_spec sp;
} test_segments[] = {{/* 0 */
printf("%s: %s\n", t->name, t->desc);
- ecom = ecommunity_parse((u_int8_t *)t->data, t->len);
+ ecom = ecommunity_parse((uint8_t *)t->data, t->len);
printf("ecom: %s\nvalidating...:\n", ecommunity_str(ecom));
static struct test_segment {
const char *name;
const char *desc;
- const u_char data[1024];
+ const uint8_t data[1024];
int len;
#define SHOULD_PARSE 0
#define SHOULD_ERR -1
/* The final reduction phase.
* This one should be the original ospfd version
*/
-static u_int16_t reduce_ospfd(struct csum_vals *vals, testsz_t len,
- testoff_t off)
+static uint16_t reduce_ospfd(struct csum_vals *vals, testsz_t len,
+ testoff_t off)
{
#define x vals->x
#define y vals->y
}
/* slightly different concatenation */
-static u_int16_t reduce_ospfd1(struct csum_vals *vals, testsz_t len,
- testoff_t off)
+static uint16_t reduce_ospfd1(struct csum_vals *vals, testsz_t len,
+ testoff_t off)
{
#define x vals->x
#define y vals->y
}
/* original isisd version */
-static u_int16_t reduce_isisd(struct csum_vals *vals, testsz_t len,
- testoff_t off)
+static uint16_t reduce_isisd(struct csum_vals *vals, testsz_t len,
+ testoff_t off)
{
#define x vals->x
#define y vals->y
#define c0 vals->a.c0
#define c1 vals->a.c1
- u_int32_t mul;
+ uint32_t mul;
mul = (len - off) * (c0);
x = mul - c0 - c1;
}
/* Is the -1 in y wrong perhaps? */
-static u_int16_t reduce_isisd_yfix(struct csum_vals *vals, testsz_t len,
- testoff_t off)
+static uint16_t reduce_isisd_yfix(struct csum_vals *vals, testsz_t len,
+ testoff_t off)
{
#define x vals->x
#define y vals->y
#define c0 vals->a.c0
#define c1 vals->a.c1
- u_int32_t mul;
+ uint32_t mul;
mul = (len - off) * (c0);
x = mul - c0 - c1;
}
/* Move the mods yp */
-static u_int16_t reduce_isisd_mod(struct csum_vals *vals, testsz_t len,
- testoff_t off)
+static uint16_t reduce_isisd_mod(struct csum_vals *vals, testsz_t len,
+ testoff_t off)
{
#define x vals->x
#define y vals->y
#define c0 vals->a.c0
#define c1 vals->a.c1
- u_int32_t mul;
+ uint32_t mul;
mul = (len - off) * (c0);
x = mul - c1 - c0;
}
/* Move the mods up + fix y */
-static u_int16_t reduce_isisd_mody(struct csum_vals *vals, testsz_t len,
- testoff_t off)
+static uint16_t reduce_isisd_mody(struct csum_vals *vals, testsz_t len,
+ testoff_t off)
{
#define x vals->x
#define y vals->y
#define c0 vals->a.c0
#define c1 vals->a.c1
- u_int32_t mul;
+ uint32_t mul;
mul = (len - off) * (c0);
x = mul - c0 - c1;
struct reductions_t {
const char *name;
- u_int16_t (*f)(struct csum_vals *, testsz_t, testoff_t);
+ uint16_t (*f)(struct csum_vals *, testsz_t, testoff_t);
} reducts[] = {
{.name = "ospfd", .f = reduce_ospfd},
{.name = "ospfd-1", .f = reduce_ospfd1},
};
/* The original ospfd checksum */
-static u_int16_t ospfd_checksum(u_char *buffer, testsz_t len, testoff_t off)
+static uint16_t ospfd_checksum(uint8_t *buffer, testsz_t len, testoff_t off)
{
- u_char *sp, *ep, *p, *q;
+ uint8_t *sp, *ep, *p, *q;
int c0 = 0, c1 = 0;
int x, y;
- u_int16_t checksum, *csum;
+ uint16_t checksum, *csum;
- csum = (u_int16_t *)(buffer + off);
+ csum = (uint16_t *)(buffer + off);
*(csum) = 0;
sp = buffer;
}
/* the original, broken isisd checksum */
-static u_int16_t iso_csum_create(u_char *buffer, testsz_t len, testoff_t off)
+static uint16_t iso_csum_create(uint8_t *buffer, testsz_t len, testoff_t off)
{
- u_int8_t *p;
+ uint8_t *p;
int x;
int y;
- u_int32_t mul;
- u_int32_t c0;
- u_int32_t c1;
- u_int16_t checksum, *csum;
+ uint32_t mul;
+ uint32_t c0;
+ uint32_t c1;
+ uint16_t checksum, *csum;
int i, init_len, partial_len;
checksum = 0;
- csum = (u_int16_t *)(buffer + off);
+ csum = (uint16_t *)(buffer + off);
*(csum) = checksum;
p = buffer;
return checksum;
}
-static int verify(u_char *buffer, testsz_t len)
+static int verify(uint8_t *buffer, testsz_t len)
{
- u_int8_t *p;
- u_int32_t c0;
- u_int32_t c1;
+ uint8_t *p;
+ uint32_t c0;
+ uint32_t c1;
int i, partial_len;
p = buffer;
static int /* return checksum in low-order 16 bits */
in_cksum_optimized(void *parg, int nbytes)
{
- u_short *ptr = parg;
+ unsigned short *ptr = parg;
register long sum; /* assumes long == 32 bits */
- register u_short answer; /* assumes u_short == 16 bits */
+ register unsigned short answer; /* assumes unsigned short == 16 bits */
register int count;
/*
* Our algorithm is simple, using a 32-bit accumulator (sum),
sum += *++ptr;
if (nbytes & 1) /* Odd */
- sum += *(u_char *)(++ptr); /* one byte only */
+ sum += *(uint8_t *)(++ptr); /* one byte only */
/*
* Add back carry outs from top 16 bits to low 16 bits.
in_cksum_rfc(void *parg, int count)
/* from RFC 1071 */
{
- u_short *addr = parg;
+ unsigned short *addr = parg;
/* Compute Internet Checksum for "count" bytes
* beginning at location "addr".
*/
}
/* Add left-over byte, if any */
if (count > 0) {
- sum += *(u_char *)addr;
+ sum += *(uint8_t *)addr;
}
/* Fold 32-bit sum to 16 bits */
{
/* 60017 65629 702179 */
#define MAXDATALEN 60017
-#define BUFSIZE MAXDATALEN + sizeof(u_int16_t)
- u_char buffer[BUFSIZE];
+#define BUFSIZE MAXDATALEN + sizeof(uint16_t)
+ uint8_t buffer[BUFSIZE];
int exercise = 0;
#define EXERCISESTEP 257
srandom(time(NULL));
while (1) {
- u_int16_t ospfd, isisd, lib, in_csum, in_csum_res, in_csum_rfc;
+ uint16_t ospfd, isisd, lib, in_csum, in_csum_res, in_csum_rfc;
int i, j;
exercise += EXERCISESTEP;
"in_csum_rfc %x, len:%d\n",
in_csum, in_csum_res, in_csum_rfc, exercise);
- ospfd = ospfd_checksum(buffer, exercise + sizeof(u_int16_t),
+ ospfd = ospfd_checksum(buffer, exercise + sizeof(uint16_t),
exercise);
- if (verify(buffer, exercise + sizeof(u_int16_t)))
+ if (verify(buffer, exercise + sizeof(uint16_t)))
printf("verify: ospfd failed\n");
- isisd = iso_csum_create(buffer, exercise + sizeof(u_int16_t),
+ isisd = iso_csum_create(buffer, exercise + sizeof(uint16_t),
exercise);
- if (verify(buffer, exercise + sizeof(u_int16_t)))
+ if (verify(buffer, exercise + sizeof(uint16_t)))
printf("verify: isisd failed\n");
- lib = fletcher_checksum(buffer, exercise + sizeof(u_int16_t),
+ lib = fletcher_checksum(buffer, exercise + sizeof(uint16_t),
exercise);
- if (verify(buffer, exercise + sizeof(u_int16_t)))
+ if (verify(buffer, exercise + sizeof(uint16_t)))
printf("verify: lib failed\n");
if (ospfd != lib) {
for (i = 0; reducts[i].name != NULL; i++) {
ospfd = reducts[i].f(
&ospfd_vals,
- exercise + sizeof(u_int16_t),
+ exercise + sizeof(uint16_t),
exercise);
printf("%20s: x: %02x, y %02x, checksum 0x%04x\n",
reducts[i].name,
}
}
- printf("\n u_char testdata [] = {\n ");
+ printf("\n uint8_t testdata [] = {\n ");
for (i = 0; i < exercise; i++) {
printf("0x%02x,%s", buffer[i],
(i + 1) % 8 ? " " : "\n ");
#define CHUNK_SIZE 32
struct zclient *zclient;
-u_short instance = 1;
+unsigned short instance = 1;
const char *sequence = "GGRGGGRRG";
static int vtysh_execute_func(const char *line, int pager)
{
int ret, cmd_stat;
- u_int i;
+ unsigned int i;
vector vline;
const struct cmd_element *cmd;
FILE *fp = NULL;
fprintf(stdout, "%s", vty->buf);
break;
case CMD_SUCCESS_DAEMON: {
- u_int i;
+ unsigned int i;
int cmd_stat = CMD_SUCCESS;
fprintf(outputfile, "%s", vty->buf);
that */
break;
case CMD_SUCCESS_DAEMON: {
- u_int i;
+ unsigned int i;
int cmd_stat = CMD_SUCCESS;
for (i = 0; i < array_size(vtysh_client); i++) {
"For the isis daemon\n"
"For the pim daemon\n")
{
- u_int i;
+ unsigned int i;
char line[] = "do write terminal\n";
FILE *fp = outputfile;
int vtysh_write_config_integrated(void)
{
- u_int i;
+ unsigned int i;
char line[] = "do write terminal\n";
FILE *fp;
int fd;
{
int ret = CMD_SUCCESS;
char line[] = "do write memory\n";
- u_int i;
+ unsigned int i;
fprintf(outputfile,
"Note: this version of vtysh never writes vtysh.conf\n");
SHOW_STR
"Show list of running daemons\n")
{
- u_int i;
+ unsigned int i;
for (i = 0; i < array_size(vtysh_client); i++)
if (vtysh_client[i].fd >= 0)
int vtysh_connect_all(const char *daemon_name)
{
- u_int i;
+ unsigned int i;
int rc = 0;
int matches = 0;
struct config *config;
/* Index of this config. */
- u_int32_t index;
+ uint32_t index;
};
struct list *config_top;
struct vtysh_user {
char *name;
- u_char nopassword;
+ uint8_t nopassword;
};
struct list *userlist;
daemon_state_t state;
int fd;
struct timeval echo_sent;
- u_int connect_tries;
+ unsigned int connect_tries;
struct thread *t_wakeup;
struct thread *t_read;
struct thread *t_write;
snprintf(why, sizeof(why),
"read returned bad echo response of %d bytes "
"(expecting %u): %.*s",
- (int)rc, (u_int)sizeof(resp), (int)rc, buf);
+ (int)rc, (unsigned int)sizeof(resp), (int)rc, buf);
daemon_down(dmn, why);
return 0;
}
char why[100 + sizeof(echocmd)];
snprintf(why, sizeof(why),
"write '%s' returned %d instead of %u", echocmd,
- (int)rc, (u_int)sizeof(echocmd));
+ (int)rc, (unsigned int)sizeof(echocmd));
daemon_down(dmn, why);
} else {
gettimeofday(&dmn->echo_sent, NULL);
if (!(dmn = (struct daemon *)calloc(1, sizeof(*dmn)))) {
fprintf(stderr, "calloc(1,%u) failed: %s\n",
- (u_int)sizeof(*dmn),
+ (unsigned int)sizeof(*dmn),
safe_strerror(errno));
return 1;
}
/* IPv4 route add and delete test. */
void zebra_test_ipv4(int command, int type, char *prefix, char *gateway,
- u_char distance)
+ uint8_t distance)
{
struct zapi_ipv4 api;
struct prefix_ipv4 p;
{
char buf[BUFSIZ];
char distance_str[BUFSIZ];
- u_char distance;
+ uint8_t distance;
while (fgets(buf, sizeof buf, fp)) {
int i;
/* Add connected IPv4 route to the interface. */
void connected_add_ipv4(struct interface *ifp, int flags, struct in_addr *addr,
- u_char prefixlen, struct in_addr *broad,
+ uint8_t prefixlen, struct in_addr *broad,
const char *label)
{
struct prefix_ipv4 *p;
/* Delete connected IPv4 route to the interface. */
void connected_delete_ipv4(struct interface *ifp, int flags,
- struct in_addr *addr, u_char prefixlen,
+ struct in_addr *addr, uint8_t prefixlen,
struct in_addr *broad)
{
struct prefix p, d;
/* Add connected IPv6 route to the interface. */
void connected_add_ipv6(struct interface *ifp, int flags, struct in6_addr *addr,
- u_char prefixlen, const char *label)
+ uint8_t prefixlen, const char *label)
{
struct prefix_ipv6 *p;
struct connected *ifc;
}
void connected_delete_ipv6(struct interface *ifp, struct in6_addr *address,
- u_char prefixlen)
+ uint8_t prefixlen)
{
struct prefix p;
struct connected *ifc;
union prefixconstptr d);
extern void connected_add_ipv4(struct interface *ifp, int flags,
- struct in_addr *addr, u_char prefixlen,
+ struct in_addr *addr, uint8_t prefixlen,
struct in_addr *broad, const char *label);
extern void connected_delete_ipv4(struct interface *ifp, int flags,
- struct in_addr *addr, u_char prefixlen,
+ struct in_addr *addr, uint8_t prefixlen,
struct in_addr *broad);
extern void connected_delete_ipv4_unnumbered(struct connected *ifc);
extern void connected_down(struct interface *ifp, struct connected *ifc);
extern void connected_add_ipv6(struct interface *ifp, int flags,
- struct in6_addr *address, u_char prefixlen,
+ struct in6_addr *address, uint8_t prefixlen,
const char *label);
extern void connected_delete_ipv6(struct interface *ifp,
- struct in6_addr *address, u_char prefixlen);
+ struct in6_addr *address, uint8_t prefixlen);
extern int connected_is_unnumbered(struct interface *);
#if defined(KAME)
if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
addr->sin6_scope_id =
- ntohs(*(u_int16_t *)&addr->sin6_addr
+ ntohs(*(uint16_t *)&addr->sin6_addr
.s6_addr[2]);
addr->sin6_addr.s6_addr[2] =
addr->sin6_addr.s6_addr[3] = 0;
struct lifreq lifreq;
struct sockaddr_storage mask, dest;
char *dest_pnt = NULL;
- u_char prefixlen = 0;
+ uint8_t prefixlen = 0;
afi_t af;
int flags = 0;
struct rtattr *attr[IFLA_VRF_MAX + 1];
struct vrf *vrf;
struct zebra_vrf *zvrf;
- u_int32_t nl_table_id;
+ uint32_t nl_table_id;
ifi = NLMSG_DATA(h);
return;
}
- nl_table_id = *(u_int32_t *)RTA_DATA(attr[IFLA_VRF_TABLE]);
+ nl_table_id = *(uint32_t *)RTA_DATA(attr[IFLA_VRF_TABLE]);
if (h->nlmsg_type == RTM_NEWLINK) {
if (IS_ZEBRA_DEBUG_KERNEL)
parse_rtattr_nested(attr, IFLA_BR_MAX, link_data);
if (attr[IFLA_BR_VLAN_FILTERING])
bridge_info->vlan_aware =
- *(u_char *)RTA_DATA(attr[IFLA_BR_VLAN_FILTERING]);
+ *(uint8_t *)RTA_DATA(attr[IFLA_BR_VLAN_FILTERING]);
return 0;
}
struct interface *ifp;
struct rtattr *aftb[IFLA_BRIDGE_MAX + 1];
struct {
- u_int16_t flags;
- u_int16_t vid;
+ uint16_t flags;
+ uint16_t vid;
} * vinfo;
vlanid_t access_vlan;
if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
&& !vrf_is_backend_netns()) {
zif_slave_type = ZEBRA_IF_SLAVE_VRF;
- vrf_id = *(u_int32_t *)RTA_DATA(tb[IFLA_MASTER]);
+ vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
} else if (slave_kind && (strcmp(slave_kind, "bridge") == 0)) {
zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
bridge_ifindex =
/* Request for specific interface or address information from the kernel */
static int netlink_request_intf_addr(struct zebra_ns *zns, int family, int type,
- u_int32_t filter_mask)
+ uint32_t filter_mask)
{
struct {
struct nlmsghdr n;
struct interface *ifp;
void *addr;
void *broad;
- u_char flags = 0;
+ uint8_t flags = 0;
char *label = NULL;
struct zebra_ns *zns;
if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
&& !vrf_is_backend_netns()) {
zif_slave_type = ZEBRA_IF_SLAVE_VRF;
- vrf_id =
- *(u_int32_t *)RTA_DATA(tb[IFLA_MASTER]);
+ vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
} else if (slave_kind
&& (strcmp(slave_kind, "bridge") == 0)) {
zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
}
/* Build the table key */
-static void if_build_key(u_int32_t ifindex, struct prefix *p)
+static void if_build_key(uint32_t ifindex, struct prefix *p)
{
p->family = AF_INET;
p->prefixlen = IPV4_MAX_BITLEN;
/* Look up an interface by identifier within a NS */
struct interface *if_lookup_by_index_per_ns(struct zebra_ns *ns,
- u_int32_t ifindex)
+ uint32_t ifindex)
{
struct prefix p;
struct route_node *rn;
rib_update(ifp->vrf_id, RIB_UPDATE_IF_CHANGE);
}
-static void ipv6_ll_address_to_mac(struct in6_addr *address, u_char *mac)
+static void ipv6_ll_address_to_mac(struct in6_addr *address, uint8_t *mac)
{
mac[0] = address->s6_addr[8] ^ 0x02;
mac[1] = address->s6_addr[9];
inet_pton(AF_INET, buf, &ipv4_ll);
- ipv6_ll_address_to_mac(address, (u_char *)mac);
+ ipv6_ll_address_to_mac(address, (uint8_t *)mac);
ns_id = zvrf->zns->ns_id;
/*
int idx_number = 1;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
- u_int32_t metric;
+ uint32_t metric;
metric = strtoul(argv[idx_number]->arg, NULL, 10);
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
struct in_addr addr;
- u_int32_t as;
+ uint32_t as;
if (!inet_aton(argv[idx_ipv4]->arg, &addr)) {
vty_out(vty, "Please specify Router-Addr by A.B.C.D\n");
"Maximum delay in micro-second as decimal (0...16777215)\n")
{
/* Get and Check new delay values */
- u_int32_t delay = 0, low = 0, high = 0;
+ uint32_t delay = 0, low = 0, high = 0;
delay = strtoul(argv[1]->arg, NULL, 10);
if (argc == 6) {
low = strtoul(argv[3]->arg, NULL, 10);
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
- u_int8_t update = 0;
+ uint8_t update = 0;
if (argc == 2) {
/* Check new delay value against old Min and Max delays if set
int idx_number = 1;
VTY_DECLVAR_CONTEXT(interface, ifp);
struct if_link_params *iflp = if_link_params_get(ifp);
- u_int32_t value;
+ uint32_t value;
value = strtoul(argv[idx_number]->arg, NULL, 10);
milliseconds (1 hour).
Default: 0 */
- u_int32_t AdvReachableTime;
+ uint32_t AdvReachableTime;
#define RTADV_MAX_REACHABLE_TIME 3600000
/* The value to be placed in the Retrans Timer field in the Router
int DefaultPreference;
#define RTADV_PREF_MEDIUM 0x0 /* Per RFC4191. */
- u_char inFastRexmit; /* True if we're rexmits faster than usual */
+ uint8_t inFastRexmit; /* True if we're rexmits faster than usual */
/* Track if RA was configured by BGP or by the Operator or both */
- u_char ra_configured; /* Was RA configured? */
+ uint8_t ra_configured; /* Was RA configured? */
#define BGP_RA_CONFIGURED (1<<0) /* BGP configured RA? */
#define VTY_RA_CONFIGURED (1<<1) /* Operator configured RA? */
#define VTY_RA_INTERVAL_CONFIGURED (1<<2) /* Operator configured RA interval */
/* `zebra' daemon local interface structure. */
struct zebra_if {
/* Shutdown configuration. */
- u_char shutdown;
+ uint8_t shutdown;
/* Multicast configuration. */
- u_char multicast;
+ uint8_t multicast;
/* Router advertise configuration. */
- u_char rtadv_enable;
+ uint8_t rtadv_enable;
/* Installed addresses chains tree. */
struct route_table *ipv4_subnets;
* down (but primary still plumbed) and primary having gone
* ~IFF_UP, and all addresses gone.
*/
- u_char primary_state;
+ uint8_t primary_state;
#endif /* SUNOS_5 */
/* ptm enable configuration */
- u_char ptm_enable;
+ uint8_t ptm_enable;
/* Zebra interface and "slave" interface type */
zebra_iftype_t zif_type;
extern void zebra_if_init(void);
-extern struct interface *if_lookup_by_index_per_ns(struct zebra_ns *,
- u_int32_t);
+extern struct interface *if_lookup_by_index_per_ns(struct zebra_ns *, uint32_t);
extern struct interface *if_lookup_by_name_per_ns(struct zebra_ns *,
const char *);
extern struct interface *if_link_per_ns(struct zebra_ns *, struct interface *);
}
/* call ioctl system call */
-int if_ioctl(u_long request, caddr_t buffer)
+int if_ioctl(unsigned long request, caddr_t buffer)
{
int sock;
int ret;
}
/* call ioctl system call */
-int vrf_if_ioctl(u_long request, caddr_t buffer, vrf_id_t vrf_id)
+int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
{
int sock;
int ret;
}
#ifndef HAVE_NETLINK
-static int if_ioctl_ipv6(u_long request, caddr_t buffer)
+static int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
{
int sock;
int ret;
/* linux/include/net/ipv6.h */
struct in6_ifreq {
struct in6_addr ifr6_addr;
- u_int32_t ifr6_prefixlen;
+ uint32_t ifr6_prefixlen;
int ifr6_ifindex;
};
#endif /* _LINUX_IN6_H */
/* Prototypes. */
extern void ifreq_set_name(struct ifreq *, struct interface *);
-extern int if_ioctl(u_long, caddr_t);
-extern int vrf_if_ioctl(u_long request, caddr_t buffer, vrf_id_t vrf_id);
+extern int if_ioctl(unsigned long, caddr_t);
+extern int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id);
extern int if_set_flags(struct interface *, uint64_t);
extern int if_unset_flags(struct interface *, uint64_t);
extern int if_prefix_delete_ipv6(struct interface *, struct connected *);
#ifdef SOLARIS_IPV6
-extern int if_ioctl_ipv6(u_long, caddr_t);
+extern int if_ioctl_ipv6(unsigned long, caddr_t);
extern struct connected *if_lookup_linklocal(struct interface *);
#define AF_IOCTL(af, request, buffer) \
strncpy(lifreq->lifr_name, ifname, IFNAMSIZ);
}
-int vrf_if_ioctl(u_long request, caddr_t buffer, vrf_id_t vrf_id)
+int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
{
return if_ioctl(request, buffer);
}
/* call ioctl system call */
-int if_ioctl(u_long request, caddr_t buffer)
+int if_ioctl(unsigned long request, caddr_t buffer)
{
int sock;
int ret;
}
-int if_ioctl_ipv6(u_long request, caddr_t buffer)
+int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
{
int sock;
int ret;
{
struct lifreq lifreq;
int ret;
- u_char changed = 0;
+ uint8_t changed = 0;
if (ifp->flags & IFF_IPV4) {
lifreq_set_name(&lifreq, ifp->name);
unsigned long MinAdvertInterval;
unsigned long Preference;
- u_int32_t flags;
+ uint32_t flags;
#define IF_ACTIVE (1<<0) /* ICMP Active */
#define IF_BROADCAST (1<<1) /* 255.255.255.255 */
struct interface *ifp;
struct thread *t_advertise;
unsigned long irdp_sent;
- u_int16_t Lifetime;
+ uint16_t Lifetime;
struct list *AdvPrefList;
};
extern void irdp_advert_off(struct interface *ifp);
extern void process_solicit(struct interface *ifp);
extern int irdp_read_raw(struct thread *r);
-extern void send_packet(struct interface *ifp, struct stream *s, u_int32_t dst,
- struct prefix *p, u_int32_t ttl);
+extern void send_packet(struct interface *ifp, struct stream *s, uint32_t dst,
+ struct prefix *p, uint32_t ttl);
#endif /* _IRDP_H */
return 0;
}
-static const char *inet_2a(u_int32_t a, char *b)
+static const char *inet_2a(uint32_t a, char *b)
{
sprintf(b, "%u.%u.%u.%u", (a)&0xFF, (a >> 8) & 0xFF, (a >> 16) & 0xFF,
(a >> 24) & 0xFF);
}
/* Join to the add/leave multicast group. */
-static int if_group(struct interface *ifp, int sock, u_int32_t group,
+static int if_group(struct interface *ifp, int sock, uint32_t group,
int add_leave)
{
struct ip_mreq m;
struct irdp_interface *irdp = zi->irdp;
struct listnode *node;
struct connected *ifc;
- u_int32_t timer, seed;
+ uint32_t timer, seed;
assert(irdp);
struct irdp_interface *irdp = zi->irdp;
int size;
int pref;
- u_int16_t checksum;
+ uint16_t checksum;
pref = get_pref(irdp, p);
struct zebra_if *zi = ifp->info;
struct irdp_interface *irdp = zi->irdp;
char buf[PREFIX_STRLEN];
- u_int32_t dst;
- u_int32_t ttl = 1;
+ uint32_t dst;
+ uint32_t ttl = 1;
if (!irdp)
return;
int irdp_send_thread(struct thread *t_advert)
{
- u_int32_t timer, tmp;
+ uint32_t timer, tmp;
struct interface *ifp = THREAD_ARG(t_advert);
struct zebra_if *zi = ifp->info;
struct irdp_interface *irdp = zi->irdp;
{
struct zebra_if *zi = ifp->info;
struct irdp_interface *irdp = zi->irdp;
- u_int32_t timer;
+ uint32_t timer;
if (!irdp)
return;
}
}
-static int irdp_recvmsg(int sock, u_char *buf, int size, int *ifindex)
+static int irdp_recvmsg(int sock, uint8_t *buf, int size, int *ifindex)
{
struct msghdr msg;
struct iovec iov;
thread_add_read(zebrad.master, irdp_read_raw, NULL, irdp_sock,
&t_irdp_raw);
- ret = irdp_recvmsg(irdp_sock, (u_char *)buf, IRDP_RX_BUF, &ifindex);
+ ret = irdp_recvmsg(irdp_sock, (uint8_t *)buf, IRDP_RX_BUF, &ifindex);
if (ret < 0)
zlog_warn("IRDP: RX Error length = %d", ret);
return ret;
}
-void send_packet(struct interface *ifp, struct stream *s, u_int32_t dst,
- struct prefix *p, u_int32_t ttl)
+void send_packet(struct interface *ifp, struct stream *s, uint32_t dst,
+ struct prefix *p, uint32_t ttl)
{
static struct sockaddr_in sockdst = {AF_INET};
struct ip *ip;
char msgbuf[256];
char buf[256];
struct in_pktinfo *pktinfo;
- u_long src;
- u_char on;
+ unsigned long src;
+ uint8_t on;
if (!(ifp->flags & IFF_UP))
return;
#ifndef NLMSG_TAIL
#define NLMSG_TAIL(nmsg) \
- ((struct rtattr *)(((u_char *)(nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
+ ((struct rtattr *)(((uint8_t *)(nmsg)) \
+ + NLMSG_ALIGN((nmsg)->nlmsg_len)))
#endif
#ifndef RTA_TAIL
#define RTA_TAIL(rta) \
- ((struct rtattr *)(((u_char *)(rta)) + RTA_ALIGN((rta)->rta_len)))
+ ((struct rtattr *)(((uint8_t *)(rta)) + RTA_ALIGN((rta)->rta_len)))
#endif
#ifndef RTNL_FAMILY_IP6MR
{0}};
extern struct thread_master *master;
-extern u_int32_t nl_rcvbufsize;
+extern uint32_t nl_rcvbufsize;
extern struct zebra_privs_t zserv_privs;
static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
{
- u_int32_t oldsize;
+ uint32_t oldsize;
socklen_t newlen = sizeof(newsize);
socklen_t oldlen = sizeof(oldsize);
int ret;
return 0;
}
-int addattr16(struct nlmsghdr *n, unsigned int maxlen, int type, u_int16_t data)
+int addattr16(struct nlmsghdr *n, unsigned int maxlen, int type, uint16_t data)
{
- return addattr_l(n, maxlen, type, &data, sizeof(u_int16_t));
+ return addattr_l(n, maxlen, type, &data, sizeof(uint16_t));
}
int addattr32(struct nlmsghdr *n, unsigned int maxlen, int type, int data)
{
- return addattr_l(n, maxlen, type, &data, sizeof(u_int32_t));
+ return addattr_l(n, maxlen, type, &data, sizeof(uint32_t));
}
struct rtattr *addattr_nest(struct nlmsghdr *n, int maxlen, int type)
int addattr_nest_end(struct nlmsghdr *n, struct rtattr *nest)
{
- nest->rta_len = (u_char *)NLMSG_TAIL(n) - (u_char *)nest;
+ nest->rta_len = (uint8_t *)NLMSG_TAIL(n) - (uint8_t *)nest;
return n->nlmsg_len;
}
int rta_nest_end(struct rtattr *rta, struct rtattr *nest)
{
- nest->rta_len = (u_char *)RTA_TAIL(rta) - (u_char *)nest;
+ nest->rta_len = (uint8_t *)RTA_TAIL(rta) - (uint8_t *)nest;
return rta->rta_len;
}
return lookup_msg(nlmsg_str, msg_type, "");
}
-const char *nl_rtproto_to_str(u_char rtproto)
+const char *nl_rtproto_to_str(uint8_t rtproto)
{
return lookup_msg(rtproto_str, rtproto, "");
}
-const char *nl_family_to_str(u_char family)
+const char *nl_family_to_str(uint8_t family)
{
return lookup_msg(family_str, family, "");
}
-const char *nl_rttype_to_str(u_char rttype)
+const char *nl_rttype_to_str(uint8_t rttype)
{
return lookup_msg(rttype_str, rttype, "");
}
extern int rta_addattr_l(struct rtattr *rta, unsigned int maxlen, int type,
void *data, unsigned int alen);
extern int addattr16(struct nlmsghdr *n, unsigned int maxlen, int type,
- u_int16_t data);
+ uint16_t data);
extern int addattr32(struct nlmsghdr *n, unsigned int maxlen, int type,
int data);
extern struct rtattr *addattr_nest(struct nlmsghdr *n, int maxlen, int type);
extern struct rtattr *rta_nest(struct rtattr *rta, int maxlen, int type);
extern int rta_nest_end(struct rtattr *rta, struct rtattr *nest);
extern const char *nl_msg_type_to_str(uint16_t msg_type);
-extern const char *nl_rtproto_to_str(u_char rtproto);
-extern const char *nl_family_to_str(u_char family);
-extern const char *nl_rttype_to_str(u_char rttype);
+extern const char *nl_rtproto_to_str(uint8_t rtproto);
+extern const char *nl_family_to_str(uint8_t family);
+extern const char *nl_rttype_to_str(uint8_t rttype);
extern int netlink_parse_info(int (*filter)(struct sockaddr_nl *,
struct nlmsghdr *, ns_id_t, int),
#define RTA_NAME_GET(DEST, RTA, RTMADDRS, PNT, LEN) \
if ((RTMADDRS) & (RTA)) { \
- u_char *pdest = (u_char *)(DEST); \
+ uint8_t *pdest = (uint8_t *)(DEST); \
int len = SAROUNDUP((PNT)); \
struct sockaddr_dl *sdl = (struct sockaddr_dl *)(PNT); \
if (IS_ZEBRA_DEBUG_KERNEL) \
void rtm_read(struct rt_msghdr *rtm)
{
int flags;
- u_char zebra_flags;
+ uint8_t zebra_flags;
union sockunion dest, mask, gate;
char ifname[INTERFACE_NAMSIZ + 1];
short ifnlen = 0;
{
int ret = 0;
struct stream *src, *dst;
- u_int16_t size = 0;
- u_char marker;
- u_char version;
+ uint16_t size = 0;
+ uint8_t marker;
+ uint8_t version;
vrf_id_t vrf_id;
- u_int16_t resp_cmd;
+ uint16_t resp_cmd;
src = zclient->ibuf;
dst = obuf;
* @para size Size of the label chunk
* @return Pointer to the assigned label chunk
*/
-struct label_manager_chunk *assign_label_chunk(u_char proto, u_short instance,
- u_char keep, uint32_t size)
+struct label_manager_chunk *assign_label_chunk(uint8_t proto,
+ unsigned short instance,
+ uint8_t keep, uint32_t size)
{
struct label_manager_chunk *lmc;
struct listnode *node;
* @param end Last label of the chunk
* @return 0 on success, -1 otherwise
*/
-int release_label_chunk(u_char proto, u_short instance, uint32_t start,
+int release_label_chunk(uint8_t proto, unsigned short instance, uint32_t start,
uint32_t end)
{
struct listnode *node;
* @param instance Instance, to identify the owner
* @return Number of chunks released
*/
-int release_daemon_chunks(u_char proto, u_short instance)
+int release_daemon_chunks(uint8_t proto, unsigned short instance)
{
struct listnode *node;
struct label_manager_chunk *lmc;
* the same proto and instance values)
*/
struct label_manager_chunk {
- u_char proto;
- u_short instance;
- u_char keep;
+ uint8_t proto;
+ unsigned short instance;
+ uint8_t keep;
uint32_t start; /* First label of the chunk */
uint32_t end; /* Last label of the chunk */
};
int zread_relay_label_manager_request(int cmd, struct zserv *zserv,
vrf_id_t vrf_id);
void label_manager_init(char *lm_zserv_path);
-struct label_manager_chunk *assign_label_chunk(u_char proto, u_short instance,
- u_char keep, uint32_t size);
-int release_label_chunk(u_char proto, u_short instance, uint32_t start,
+struct label_manager_chunk *assign_label_chunk(uint8_t proto,
+ unsigned short instance,
+ uint8_t keep, uint32_t size);
+int release_label_chunk(uint8_t proto, unsigned short instance, uint32_t start,
uint32_t end);
-int release_daemon_chunks(u_char proto, u_short instance);
+int release_daemon_chunks(uint8_t proto, unsigned short instance);
void label_manager_close(void);
#endif /* _LABEL_MANAGER_H */
#ifdef HAVE_NETLINK
/* Receive buffer size for netlink socket */
-u_int32_t nl_rcvbufsize = 4194304;
+uint32_t nl_rcvbufsize = 4194304;
#endif /* HAVE_NETLINK */
/* Command line options. */
/* array holding redistribute info about table redistribution */
/* bit AFI is set if that AFI is redistributing routes from this table */
static int zebra_import_table_used[AFI_MAX][ZEBRA_KERNEL_TABLE_MAX];
-static u_int32_t zebra_import_table_distance[AFI_MAX][ZEBRA_KERNEL_TABLE_MAX];
+static uint32_t zebra_import_table_distance[AFI_MAX][ZEBRA_KERNEL_TABLE_MAX];
-int is_zebra_import_table_enabled(afi_t afi, u_int32_t table_id)
+int is_zebra_import_table_enabled(afi_t afi, uint32_t table_id)
{
/*
* Make sure that what we are called with actualy makes sense
}
/* Redistribute routes. */
-static void zebra_redistribute(struct zserv *client, int type, u_short instance,
- vrf_id_t vrf_id, int afi)
+static void zebra_redistribute(struct zserv *client, int type,
+ unsigned short instance, vrf_id_t vrf_id,
+ int afi)
{
struct route_entry *newre;
struct route_table *table;
{
afi_t afi = 0;
int type = 0;
- u_short instance;
+ unsigned short instance;
STREAM_GETC(msg, afi);
STREAM_GETC(msg, type);
{
afi_t afi = 0;
int type = 0;
- u_short instance;
+ unsigned short instance;
STREAM_GETC(msg, afi);
STREAM_GETC(msg, type);
}
/* Assuming no one calls this with the main routing table */
-int zebra_import_table(afi_t afi, u_int32_t table_id, u_int32_t distance,
+int zebra_import_table(afi_t afi, uint32_t table_id, uint32_t distance,
const char *rmap_name, int add)
{
struct route_table *table;
extern void zebra_interface_vrf_update_add(struct interface *,
vrf_id_t old_vrf_id);
-extern int zebra_import_table(afi_t afi, u_int32_t table_id, u_int32_t distance,
+extern int zebra_import_table(afi_t afi, uint32_t table_id, uint32_t distance,
const char *rmap_name, int add);
extern int zebra_add_import_table_entry(struct route_node *rn,
const char *rmap_name);
extern int zebra_del_import_table_entry(struct route_node *rn,
struct route_entry *re);
-extern int is_zebra_import_table_enabled(afi_t, u_int32_t table_id);
+extern int is_zebra_import_table_enabled(afi_t, uint32_t table_id);
extern int zebra_import_table_config(struct vty *);
int type;
/* Source protocol instance */
- u_short instance;
+ unsigned short instance;
/* VRF identifier. */
vrf_id_t vrf_id;
uint32_t table;
/* Metric */
- u_int32_t metric;
+ uint32_t metric;
/* MTU */
- u_int32_t mtu;
- u_int32_t nexthop_mtu;
+ uint32_t mtu;
+ uint32_t nexthop_mtu;
/* Distance. */
uint8_t distance;
* This flag's definition is in lib/zebra.h ZEBRA_FLAG_* and is exposed
* to clients via Zserv
*/
- u_int32_t flags;
+ uint32_t flags;
/* RIB internal status */
- u_char status;
+ uint8_t status;
#define ROUTE_ENTRY_REMOVED 0x1
/* to simplify NHT logic when NHs change, instead of doing a NH by NH cmp */
#define ROUTE_ENTRY_NEXTHOPS_CHANGED 0x2
#define ROUTE_ENTRY_LABELS_CHANGED 0x8
/* Nexthop information. */
- u_char nexthop_num;
- u_char nexthop_active_num;
+ uint8_t nexthop_num;
+ uint8_t nexthop_active_num;
};
/* meta-queue structure:
#define MQ_SIZE 5
struct meta_queue {
struct list *subq[MQ_SIZE];
- u_int32_t size; /* sum of lengths of all subqueues */
+ uint32_t size; /* sum of lengths of all subqueues */
};
/*
/*
* Flags, see below.
*/
- u_int32_t flags;
+ uint32_t flags;
/*
* Linkage to put dest on the FPM processing queue.
#define ZEBRA_RIB_FOUND_CONNECTED 2
#define ZEBRA_RIB_NOTFOUND 3
-extern int is_zebra_valid_kernel_table(u_int32_t table_id);
-extern int is_zebra_main_routing_table(u_int32_t table_id);
+extern int is_zebra_valid_kernel_table(uint32_t table_id);
+extern int is_zebra_main_routing_table(uint32_t table_id);
extern int zebra_check_addr(struct prefix *p);
extern void rib_addnode(struct route_node *rn, struct route_entry *re,
* All rib_add function will not just add prefix into RIB, but
* also implicitly withdraw equal prefix of same type. */
extern int rib_add(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
- u_short instance, int flags, struct prefix *p,
+ unsigned short instance, int flags, struct prefix *p,
struct prefix_ipv6 *src_p, const struct nexthop *nh,
- u_int32_t table_id, u_int32_t metric, u_int32_t mtu,
+ uint32_t table_id, uint32_t metric, uint32_t mtu,
uint8_t distance, route_tag_t tag);
extern int rib_add_multipath(afi_t afi, safi_t safi, struct prefix *p,
struct prefix_ipv6 *src_p, struct route_entry *re);
extern void rib_delete(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
- u_short instance, int flags, struct prefix *p,
+ unsigned short instance, int flags, struct prefix *p,
struct prefix_ipv6 *src_p, const struct nexthop *nh,
- u_int32_t table_id, u_int32_t metric, bool fromkernel,
+ uint32_t table_id, uint32_t metric, bool fromkernel,
struct ethaddr *rmac);
extern struct route_entry *rib_match(afi_t afi, safi_t safi, vrf_id_t vrf_id,
extern void rib_sweep_table(struct route_table *table);
extern void rib_close_table(struct route_table *table);
extern void rib_init(void);
-extern unsigned long rib_score_proto(u_char proto, u_short instance);
-extern unsigned long rib_score_proto_table(u_char proto, u_short instance,
+extern unsigned long rib_score_proto(uint8_t proto, unsigned short instance);
+extern unsigned long rib_score_proto_table(uint8_t proto,
+ unsigned short instance,
struct route_table *table);
extern void rib_queue_add(struct route_node *rn);
extern void meta_queue_free(struct meta_queue *mq);
*
* Returns the address family that the destination is for.
*/
-static inline u_char rib_dest_af(rib_dest_t *dest)
+static inline uint8_t rib_dest_af(rib_dest_t *dest)
{
return dest->rnode->p.family;
}
struct in_addr *vtep_ip);
extern int kernel_add_mac(struct interface *ifp, vlanid_t vid,
struct ethaddr *mac, struct in_addr vtep_ip,
- u_char sticky);
+ uint8_t sticky);
extern int kernel_del_mac(struct interface *ifp, vlanid_t vid,
struct ethaddr *mac, struct in_addr vtep_ip,
int local);
static vlanid_t filter_vlan = 0;
struct gw_family_t {
- u_int16_t filler;
- u_int16_t family;
+ uint16_t filler;
+ uint16_t family;
union g_addr gate;
};
/*
Pending: create an efficient table_id (in a tree/hash) based lookup)
*/
-static vrf_id_t vrf_lookup_by_table(u_int32_t table_id, ns_id_t ns_id)
+static vrf_id_t vrf_lookup_by_table(uint32_t table_id, ns_id_t ns_id)
{
struct vrf *vrf;
struct zebra_vrf *zvrf;
int len;
struct rtmsg *rtm;
struct rtattr *tb[RTA_MAX + 1];
- u_char flags = 0;
+ uint8_t flags = 0;
struct prefix p;
struct prefix_ipv6 src_p = {};
vrf_id_t vrf_id;
int index = 0;
int table;
int metric = 0;
- u_int32_t mtu = 0;
+ uint32_t mtu = 0;
uint8_t distance = 0;
route_tag_t tag = 0;
RTA_PAYLOAD(tb[RTA_METRICS]));
if (mxrta[RTAX_MTU])
- mtu = *(u_int32_t *)RTA_DATA(mxrta[RTAX_MTU]);
+ mtu = *(uint32_t *)RTA_DATA(mxrta[RTAX_MTU]);
}
if (rtm->rtm_family == AF_INET) {
return 0;
}
-static void _netlink_route_nl_add_gateway_info(u_char route_family,
- u_char gw_family,
+static void _netlink_route_nl_add_gateway_info(uint8_t route_family,
+ uint8_t gw_family,
struct nlmsghdr *nlmsg,
size_t req_size, int bytelen,
struct nexthop *nexthop)
}
}
-static void _netlink_route_rta_add_gateway_info(u_char route_family,
- u_char gw_family,
+static void _netlink_route_rta_add_gateway_info(uint8_t route_family,
+ uint8_t gw_family,
struct rtattr *rta,
struct rtnexthop *rtnh,
size_t req_size, int bytelen,
num_labels * sizeof(mpls_lse_t));
else {
struct rtattr *nest;
- u_int16_t encap = LWTUNNEL_ENCAP_MPLS;
+ uint16_t encap = LWTUNNEL_ENCAP_MPLS;
addattr_l(nlmsg, req_size, RTA_ENCAP_TYPE, &encap,
- sizeof(u_int16_t));
+ sizeof(uint16_t));
nest = addattr_nest(nlmsg, req_size, RTA_ENCAP);
addattr_l(nlmsg, req_size, MPLS_IPTUNNEL_DST, &out_lse,
num_labels * sizeof(mpls_lse_t));
RTA_LENGTH(num_labels * sizeof(mpls_lse_t));
} else {
struct rtattr *nest;
- u_int16_t encap = LWTUNNEL_ENCAP_MPLS;
+ uint16_t encap = LWTUNNEL_ENCAP_MPLS;
int len = rta->rta_len;
rta_addattr_l(rta, NL_PKT_BUF_SIZE, RTA_ENCAP_TYPE,
- &encap, sizeof(u_int16_t));
+ &encap, sizeof(uint16_t));
nest = rta_nest(rta, NL_PKT_BUF_SIZE, RTA_ENCAP);
rta_addattr_l(rta, NL_PKT_BUF_SIZE, MPLS_IPTUNNEL_DST,
&out_lse,
size_t req_size, int cmd)
{
int bytelen;
- u_char family;
+ uint8_t family;
family = NHLFE_FAMILY(nhlfe);
bytelen = (family == AF_INET ? 4 : 16);
struct rtmsg *rtmsg, union g_addr **src)
{
int bytelen;
- u_char family;
+ uint8_t family;
family = NHLFE_FAMILY(nhlfe);
bytelen = (family == AF_INET ? 4 : 16);
}
}
-static void _netlink_mpls_debug(int cmd, u_int32_t label, const char *routedesc)
+static void _netlink_mpls_debug(int cmd, uint32_t label, const char *routedesc)
{
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("netlink_mpls_multipath() (%s): %s %u/20", routedesc,
if (re->mtu || re->nexthop_mtu) {
char buf[NL_PKT_BUF_SIZE];
struct rtattr *rta = (void *)buf;
- u_int32_t mtu = re->mtu;
+ uint32_t mtu = re->mtu;
if (!mtu || (re->nexthop_mtu && re->nexthop_mtu < mtu))
mtu = re->nexthop_mtu;
rta->rta_type = RTA_METRICS;
struct ndmsg ndm;
char buf[256];
} req;
- u_char dst_mac[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ uint8_t dst_mac[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
struct zebra_vrf *zvrf = zebra_vrf_lookup_by_id(ifp->vrf_id);
zns = zvrf->zns;
char buf[ETHER_ADDR_STRLEN];
char vid_buf[20];
char dst_buf[30];
- u_char sticky = 0;
+ uint8_t sticky = 0;
ndm = NLMSG_DATA(h);
if ((NDA_VLAN <= NDA_MAX) && tb[NDA_VLAN]) {
vid_present = 1;
- vid = *(u_int16_t *)RTA_DATA(tb[NDA_VLAN]);
+ vid = *(uint16_t *)RTA_DATA(tb[NDA_VLAN]);
sprintf(vid_buf, " VLAN %u", vid);
}
static int netlink_macfdb_update(struct interface *ifp, vlanid_t vid,
struct ethaddr *mac, struct in_addr vtep_ip,
- int local, int cmd, u_char sticky)
+ int local, int cmd, uint8_t sticky)
{
struct zebra_ns *zns;
struct {
char buf[ETHER_ADDR_STRLEN];
char buf2[INET6_ADDRSTRLEN];
int mac_present = 0;
- u_char ext_learned;
+ uint8_t ext_learned;
ndm = NLMSG_DATA(h);
}
static int netlink_neigh_update2(struct interface *ifp, struct ipaddr *ip,
- struct ethaddr *mac, u_int32_t flags, int cmd)
+ struct ethaddr *mac, uint32_t flags, int cmd)
{
struct {
struct nlmsghdr n;
}
int kernel_add_mac(struct interface *ifp, vlanid_t vid, struct ethaddr *mac,
- struct in_addr vtep_ip, u_char sticky)
+ struct in_addr vtep_ip, uint8_t sticky)
{
return netlink_macfdb_update(ifp, vid, mac, vtep_ip, 0, RTM_NEWNEIGH,
sticky);
}
int kernel_add_mac(struct interface *ifp, vlanid_t vid, struct ethaddr *mac,
- struct in_addr vtep_ip, u_char sticky)
+ struct in_addr vtep_ip, uint8_t sticky)
{
return 0;
}
return ret;
}
-static int rtadv_recv_packet(struct zebra_ns *zns, int sock, u_char *buf,
+static int rtadv_recv_packet(struct zebra_ns *zns, int sock, uint8_t *buf,
int buflen, struct sockaddr_in6 *from,
ifindex_t *ifindex, int *hoplimit)
{
int len = 0;
struct zebra_if *zif;
struct rtadv_prefix *rprefix;
- u_char all_nodes_addr[] = {0xff, 0x02, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 1};
+ uint8_t all_nodes_addr[] = {0xff, 0x02, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 1};
struct listnode *node;
- u_int16_t pkt_RouterLifetime;
+ uint16_t pkt_RouterLifetime;
/*
* Allocate control message bufffer. This is dynamic because
#ifdef DEBUG
{
- u_char buf[INET6_ADDRSTRLEN];
+ uint8_t buf[INET6_ADDRSTRLEN];
zlog_debug("DEBUG %s",
inet_ntop(AF_INET6, &pinfo->nd_opt_pi_prefix,
rtadv_send_packet(zns->rtadv.sock, ifp);
}
-static void rtadv_process_advert(u_char *msg, unsigned int len,
+static void rtadv_process_advert(uint8_t *msg, unsigned int len,
struct interface *ifp,
struct sockaddr_in6 *addr)
{
}
-static void rtadv_process_packet(u_char *buf, unsigned int len,
+static void rtadv_process_packet(uint8_t *buf, unsigned int len,
ifindex_t ifindex, int hoplimit,
struct sockaddr_in6 *from,
struct zebra_ns *zns)
{
int sock;
int len;
- u_char buf[RTADV_MSG_SIZE];
+ uint8_t buf[RTADV_MSG_SIZE];
struct sockaddr_in6 from;
ifindex_t ifindex = 0;
int hoplimit = -1;
struct prefix_ipv6 prefix;
/* The value to be placed in the Valid Lifetime in the Prefix */
- u_int32_t AdvValidLifetime;
+ uint32_t AdvValidLifetime;
#define RTADV_VALID_LIFETIME 2592000
/* The value to be placed in the on-link flag */
/* The value to be placed in the Preferred Lifetime in the Prefix
Information option, in seconds.*/
- u_int32_t AdvPreferredLifetime;
+ uint32_t AdvPreferredLifetime;
#define RTADV_PREFERRED_LIFETIME 604800
/* The value to be placed in the Autonomous Flag. */
#ifndef HAVE_STRUCT_ND_OPT_HOMEAGENT_INFO
struct nd_opt_homeagent_info { /* Home Agent info */
- u_int8_t nd_opt_hai_type;
- u_int8_t nd_opt_hai_len;
- u_int16_t nd_opt_hai_reserved;
- u_int16_t nd_opt_hai_preference;
- u_int16_t nd_opt_hai_lifetime;
+ uint8_t nd_opt_hai_type;
+ uint8_t nd_opt_hai_len;
+ uint16_t nd_opt_hai_reserved;
+ uint16_t nd_opt_hai_preference;
+ uint16_t nd_opt_hai_lifetime;
} __attribute__((__packed__));
#endif
struct prefix prefix;
struct in_addr tmpaddr;
struct nexthop nh;
- u_char zebra_flags = 0;
+ uint8_t zebra_flags = 0;
if (routeEntry->ipRouteInfo.re_ire_type & IRE_CACHETABLE)
return;
Fpm__AddRoute *add_route;
Fpm__Nexthop *nexthop;
struct prefix prefix;
- u_char family, nh_family;
+ uint8_t family, nh_family;
uint if_index;
char *if_name;
size_t i;
*
* Returns string representation of an address of the given AF.
*/
-static inline const char *addr_to_a(u_char af, void *addr)
+static inline const char *addr_to_a(uint8_t af, void *addr)
{
if (!addr)
return "<No address>";
*
* The size of an address in a given address family.
*/
-static size_t af_addr_size(u_char af)
+static size_t af_addr_size(uint8_t af)
{
switch (af) {
*/
typedef struct netlink_route_info_t_ {
uint16_t nlmsg_type;
- u_char rtm_type;
+ uint8_t rtm_type;
uint32_t rtm_table;
- u_char rtm_protocol;
- u_char af;
+ uint8_t rtm_protocol;
+ uint8_t af;
struct prefix *prefix;
uint32_t *metric;
unsigned int num_nhs;
/*
* netlink_proto_from_route_type
*/
-static u_char netlink_proto_from_route_type(int type)
+static uint8_t netlink_proto_from_route_type(int type)
{
switch (type) {
case ZEBRA_ROUTE_KERNEL:
/* zebra L2 interface information - bridge interface */
struct zebra_l2info_bridge {
- u_char vlan_aware; /* VLAN-aware bridge? */
+ uint8_t vlan_aware; /* VLAN-aware bridge? */
};
/* zebra L2 interface information - VLAN interface */
/* static function declarations */
static void fec_evaluate(struct zebra_vrf *zvrf);
-static u_int32_t fec_derive_label_from_index(struct zebra_vrf *vrf,
- zebra_fec_t *fec);
+static uint32_t fec_derive_label_from_index(struct zebra_vrf *vrf,
+ zebra_fec_t *fec);
static int lsp_install(struct zebra_vrf *zvrf, mpls_label_t label,
struct route_node *rn, struct route_entry *re);
static int lsp_uninstall(struct zebra_vrf *zvrf, mpls_label_t label);
static void fec_print(zebra_fec_t *fec, struct vty *vty);
static zebra_fec_t *fec_find(struct route_table *table, struct prefix *p);
static zebra_fec_t *fec_add(struct route_table *table, struct prefix *p,
- mpls_label_t label, u_int32_t flags,
- u_int32_t label_index);
+ mpls_label_t label, uint32_t flags,
+ uint32_t label_index);
static int fec_del(zebra_fec_t *fec);
static unsigned int label_hash(void *p);
{
struct route_node *rn;
zebra_fec_t *fec;
- u_int32_t old_label, new_label;
+ uint32_t old_label, new_label;
int af;
char buf[BUFSIZ];
* its label index. The index is "acceptable" if it falls within the
* globally configured label block (SRGB).
*/
-static u_int32_t fec_derive_label_from_index(struct zebra_vrf *zvrf,
- zebra_fec_t *fec)
+static uint32_t fec_derive_label_from_index(struct zebra_vrf *zvrf,
+ zebra_fec_t *fec)
{
- u_int32_t label;
+ uint32_t label;
if (fec->label_index != MPLS_INVALID_LABEL_INDEX
&& zvrf->mpls_srgb.start_label
* or when a binding is configured.
*/
static zebra_fec_t *fec_add(struct route_table *table, struct prefix *p,
- mpls_label_t label, u_int32_t flags,
- u_int32_t label_index)
+ mpls_label_t label, uint32_t flags,
+ uint32_t label_index)
{
struct route_node *rn;
zebra_fec_t *fec;
* -2 if a label was inside the reserved range (0-15)
* -3 if the number of labels given exceeds MPLS_MAX_LABELS
*/
-int mpls_str2label(const char *label_str, u_int8_t *num_labels,
+int mpls_str2label(const char *label_str, uint8_t *num_labels,
mpls_label_t *labels)
{
char *ostr; // copy of label string (start)
/*
* Label to string conversion, labels in string separated by '/'.
*/
-char *mpls_label2str(u_int8_t num_labels, mpls_label_t *labels, char *buf,
+char *mpls_label2str(uint8_t num_labels, mpls_label_t *labels, char *buf,
int len, int pretty)
{
char label_buf[BUFSIZ];
* is acceptable.
*/
int zebra_mpls_fec_register(struct zebra_vrf *zvrf, struct prefix *p,
- u_int32_t label_index, struct zserv *client)
+ uint32_t label_index, struct zserv *client)
{
struct route_table *table;
zebra_fec_t *fec;
char buf[BUFSIZ];
int new_client;
int label_change = 0;
- u_int32_t old_label;
+ uint32_t old_label;
table = zvrf->fec_table[family2afi(PREFIX_FAMILY(p))];
if (!table)
*/
int mpls_ftn_update(int add, struct zebra_vrf *zvrf, enum lsp_types_t type,
struct prefix *prefix, enum nexthop_types_t gtype,
- union g_addr *gate, ifindex_t ifindex, u_int8_t distance,
+ union g_addr *gate, ifindex_t ifindex, uint8_t distance,
mpls_label_t out_label)
{
struct route_table *table;
* (VTY command handler).
*/
void zebra_mpls_print_lsp(struct vty *vty, struct zebra_vrf *zvrf,
- mpls_label_t label, u_char use_json)
+ mpls_label_t label, uint8_t use_json)
{
struct hash *lsp_table;
zebra_lsp_t *lsp;
* Display MPLS label forwarding table (VTY command handler).
*/
void zebra_mpls_print_lsp_table(struct vty *vty, struct zebra_vrf *zvrf,
- u_char use_json)
+ uint8_t use_json)
{
char buf[BUFSIZ];
json_object *json = NULL;
/*
* Add/update global label block.
*/
-int zebra_mpls_label_block_add(struct zebra_vrf *zvrf, u_int32_t start_label,
- u_int32_t end_label)
+int zebra_mpls_label_block_add(struct zebra_vrf *zvrf, uint32_t start_label,
+ uint32_t end_label)
{
zvrf->mpls_srgb.start_label = start_label;
zvrf->mpls_srgb.end_label = end_label;
zebra_lsp_t *lsp;
/* Runtime info - flags, pointers etc. */
- u_int32_t flags;
+ uint32_t flags;
#define NHLFE_FLAG_CHANGED (1 << 0)
#define NHLFE_FLAG_SELECTED (1 << 1)
#define NHLFE_FLAG_MULTIPATH (1 << 2)
zebra_nhlfe_t *next;
zebra_nhlfe_t *prev;
- u_char distance;
+ uint8_t distance;
};
/*
/* List of NHLFE, pointer to best and num equal-cost. */
zebra_nhlfe_t *nhlfe_list;
zebra_nhlfe_t *best_nhlfe;
- u_int32_t num_ecmp;
+ uint32_t num_ecmp;
/* Flags */
- u_int32_t flags;
+ uint32_t flags;
#define LSP_FLAG_SCHEDULED (1 << 0)
#define LSP_FLAG_INSTALLED (1 << 1)
#define LSP_FLAG_CHANGED (1 << 2)
/* Address-family of NHLFE - saved here for delete. All NHLFEs */
/* have to be of the same AF */
- u_char addr_family;
+ uint8_t addr_family;
};
/*
mpls_label_t label;
/* Label index (into global label block), if valid */
- u_int32_t label_index;
+ uint32_t label_index;
/* Flags. */
- u_int32_t flags;
+ uint32_t flags;
#define FEC_FLAG_CONFIGURED (1 << 0)
/* Clients interested in this FEC. */
/*
* String to label conversion, labels separated by '/'.
*/
-int mpls_str2label(const char *label_str, u_int8_t *num_labels,
+int mpls_str2label(const char *label_str, uint8_t *num_labels,
mpls_label_t *labels);
/*
* Label to string conversion, labels in string separated by '/'.
*/
-char *mpls_label2str(u_int8_t num_labels, mpls_label_t *labels, char *buf,
+char *mpls_label2str(uint8_t num_labels, mpls_label_t *labels, char *buf,
int len, int pretty);
/*
* Add/update global label block.
*/
-int zebra_mpls_label_block_add(struct zebra_vrf *zvrf, u_int32_t start_label,
- u_int32_t end_label);
+int zebra_mpls_label_block_add(struct zebra_vrf *zvrf, uint32_t start_label,
+ uint32_t end_label);
/*
* Delete global label block.
* is acceptable.
*/
int zebra_mpls_fec_register(struct zebra_vrf *zvrf, struct prefix *p,
- u_int32_t label_index, struct zserv *client);
+ uint32_t label_index, struct zserv *client);
/*
* Deregistration from a client for the label binding for a FEC. The FEC
*/
int mpls_ftn_update(int add, struct zebra_vrf *zvrf, enum lsp_types_t type,
struct prefix *prefix, enum nexthop_types_t gtype,
- union g_addr *gate, ifindex_t ifindex, u_int8_t distance,
+ union g_addr *gate, ifindex_t ifindex, uint8_t distance,
mpls_label_t out_label);
/*
* (VTY command handler).
*/
void zebra_mpls_print_lsp(struct vty *vty, struct zebra_vrf *zvrf,
- mpls_label_t label, u_char use_json);
+ mpls_label_t label, uint8_t use_json);
/*
* Display MPLS label forwarding table (VTY command handler).
*/
void zebra_mpls_print_lsp_table(struct vty *vty, struct zebra_vrf *zvrf,
- u_char use_json);
+ uint8_t use_json);
/*
* Display MPLS LSP configuration of all static LSPs (VTY command handler).
/*
* Distance (priority) definition for LSP NHLFE.
*/
-static inline u_char lsp_distance(enum lsp_types_t type)
+static inline uint8_t lsp_distance(enum lsp_types_t type)
{
switch (type) {
case ZEBRA_LSP_STATIC:
extern struct zebra_privs_t zserv_privs;
struct {
- u_int32_t rtseq;
+ uint32_t rtseq;
int fd;
int ioctl_fd;
} kr_state;
{
struct zebra_vrf *zvrf;
struct prefix p;
- u_int32_t label;
+ uint32_t label;
int ret;
zvrf = vrf_info_lookup(VRF_DEFAULT);
JSON_STR)
{
struct zebra_vrf *zvrf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zvrf = vrf_info_lookup(VRF_DEFAULT);
zebra_mpls_print_lsp_table(vty, zvrf, uj);
"LSP to display information about\n"
JSON_STR)
{
- u_int32_t label;
+ uint32_t label;
struct zebra_vrf *zvrf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zvrf = vrf_info_lookup(VRF_DEFAULT);
label = atoi(argv[3]->arg);
const char *end_label_str)
{
int ret;
- u_int32_t start_label;
- u_int32_t end_label;
+ uint32_t start_label;
+ uint32_t end_label;
struct zebra_vrf *zvrf;
zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT);
attr += NETLINK_ALIGN(attr->nla_len)) {
curr_length += attr->nla_len;
if ((attr->nla_type & NLA_TYPE_MASK) == NETNSA_NSID) {
- u_int32_t *ptr = (u_int32_t *)(attr);
+ uint32_t *ptr = (uint32_t *)(attr);
ns_id = ptr[1];
break;
return NULL;
}
-unsigned long zebra_ns_score_proto(u_char proto, u_short instance)
+unsigned long zebra_ns_score_proto(uint8_t proto, unsigned short instance)
{
struct zebra_ns *zns;
struct zebra_ns_table *znst;
uint32_t tableid, afi_t afi);
int zebra_ns_config_write(struct vty *vty, struct ns *ns);
-unsigned long zebra_ns_score_proto(u_char proto, u_short instance);
+unsigned long zebra_ns_score_proto(uint8_t proto, unsigned short instance);
void zebra_ns_sweep_route(void);
#endif
struct stream *s;
struct prefix src_p;
struct prefix dst_p;
- u_char multi_hop;
- u_char multi_hop_cnt;
- u_char detect_mul;
+ uint8_t multi_hop;
+ uint8_t multi_hop_cnt;
+ uint8_t detect_mul;
unsigned int min_rx_timer;
unsigned int min_tx_timer;
char if_name[INTERFACE_NAMSIZ];
- u_char len;
+ uint8_t len;
void *out_ctxt;
char buf[INET6_ADDRSTRLEN];
char tmp_buf[64];
struct stream *s;
struct prefix src_p;
struct prefix dst_p;
- u_char multi_hop;
+ uint8_t multi_hop;
char if_name[INTERFACE_NAMSIZ];
- u_char len;
+ uint8_t len;
char buf[INET6_ADDRSTRLEN];
char tmp_buf[64];
int data_len = ZEBRA_PTM_SEND_MAX_SOCKBUF;
int ptm_enable;
int pid;
- u_int8_t client_flags[ZEBRA_ROUTE_MAX];
+ uint8_t client_flags[ZEBRA_ROUTE_MAX];
};
#define ZEBRA_PTM_STATUS_DOWN 0
return distance;
}
-int is_zebra_valid_kernel_table(u_int32_t table_id)
+int is_zebra_valid_kernel_table(uint32_t table_id)
{
#ifdef linux
if ((table_id == RT_TABLE_UNSPEC) || (table_id == RT_TABLE_LOCAL)
return 1;
}
-int is_zebra_main_routing_table(u_int32_t table_id)
+int is_zebra_main_routing_table(uint32_t table_id)
{
if ((table_id == RT_TABLE_MAIN)
|| (table_id == zebrad.rtm_table_default))
int zebra_check_addr(struct prefix *p)
{
if (p->family == AF_INET) {
- u_int32_t addr;
+ uint32_t addr;
addr = p->u.prefix4.s_addr;
addr = ntohl(addr);
* picked from it and processed by rib_process(). Don't process more,
* than one RN record; operate only in the specified sub-queue.
*/
-static unsigned int process_subq(struct list *subq, u_char qindex)
+static unsigned int process_subq(struct list *subq, uint8_t qindex)
{
struct listnode *lnode = listhead(subq);
struct route_node *rnode;
/*
* Map from rib types to queue type (priority) in meta queue
*/
-static const u_char meta_queue_map[ZEBRA_ROUTE_MAX] = {
- [ZEBRA_ROUTE_SYSTEM] = 4,
- [ZEBRA_ROUTE_KERNEL] = 0,
- [ZEBRA_ROUTE_CONNECT] = 0,
- [ZEBRA_ROUTE_STATIC] = 1,
- [ZEBRA_ROUTE_RIP] = 2,
- [ZEBRA_ROUTE_RIPNG] = 2,
- [ZEBRA_ROUTE_OSPF] = 2,
- [ZEBRA_ROUTE_OSPF6] = 2,
- [ZEBRA_ROUTE_ISIS] = 2,
- [ZEBRA_ROUTE_BGP] = 3,
- [ZEBRA_ROUTE_PIM] = 4, // Shouldn't happen but for safety
- [ZEBRA_ROUTE_EIGRP] = 2,
- [ZEBRA_ROUTE_NHRP] = 2,
- [ZEBRA_ROUTE_HSLS] = 4,
- [ZEBRA_ROUTE_OLSR] = 4,
- [ZEBRA_ROUTE_TABLE] = 1,
- [ZEBRA_ROUTE_LDP] = 4,
- [ZEBRA_ROUTE_VNC] = 3,
- [ZEBRA_ROUTE_VNC_DIRECT] = 3,
- [ZEBRA_ROUTE_VNC_DIRECT_RH] = 3,
- [ZEBRA_ROUTE_BGP_DIRECT] = 3,
- [ZEBRA_ROUTE_BGP_DIRECT_EXT] = 3,
- [ZEBRA_ROUTE_BABEL] = 2,
- [ZEBRA_ROUTE_ALL] = 4, // Shouldn't happen but for safety
+static const uint8_t meta_queue_map[ZEBRA_ROUTE_MAX] = {
+ [ZEBRA_ROUTE_SYSTEM] = 4,
+ [ZEBRA_ROUTE_KERNEL] = 0,
+ [ZEBRA_ROUTE_CONNECT] = 0,
+ [ZEBRA_ROUTE_STATIC] = 1,
+ [ZEBRA_ROUTE_RIP] = 2,
+ [ZEBRA_ROUTE_RIPNG] = 2,
+ [ZEBRA_ROUTE_OSPF] = 2,
+ [ZEBRA_ROUTE_OSPF6] = 2,
+ [ZEBRA_ROUTE_ISIS] = 2,
+ [ZEBRA_ROUTE_BGP] = 3,
+ [ZEBRA_ROUTE_PIM] = 4, // Shouldn't happen but for safety
+ [ZEBRA_ROUTE_EIGRP] = 2,
+ [ZEBRA_ROUTE_NHRP] = 2,
+ [ZEBRA_ROUTE_HSLS] = 4,
+ [ZEBRA_ROUTE_OLSR] = 4,
+ [ZEBRA_ROUTE_TABLE] = 1,
+ [ZEBRA_ROUTE_LDP] = 4,
+ [ZEBRA_ROUTE_VNC] = 3,
+ [ZEBRA_ROUTE_VNC_DIRECT] = 3,
+ [ZEBRA_ROUTE_VNC_DIRECT_RH] = 3,
+ [ZEBRA_ROUTE_BGP_DIRECT] = 3,
+ [ZEBRA_ROUTE_BGP_DIRECT_EXT] = 3,
+ [ZEBRA_ROUTE_BABEL] = 2,
+ [ZEBRA_ROUTE_ALL] = 4, // Shouldn't happen but for safety
};
/* Look into the RN and queue it into one or more priority queues,
struct route_entry *re;
RNODE_FOREACH_RE (rn, re) {
- u_char qindex = meta_queue_map[re->type];
+ uint8_t qindex = meta_queue_map[re->type];
struct zebra_vrf *zvrf;
/* Invariant: at this point we always have rn->info set. */
}
void rib_delete(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
- u_short instance, int flags, struct prefix *p,
+ unsigned short instance, int flags, struct prefix *p,
struct prefix_ipv6 *src_p, const struct nexthop *nh,
- u_int32_t table_id, u_int32_t metric, bool fromkernel,
+ uint32_t table_id, uint32_t metric, bool fromkernel,
struct ethaddr *rmac)
{
struct route_table *table;
}
-int rib_add(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type, u_short instance,
- int flags, struct prefix *p, struct prefix_ipv6 *src_p,
- const struct nexthop *nh, u_int32_t table_id, u_int32_t metric,
- u_int32_t mtu, uint8_t distance, route_tag_t tag)
+int rib_add(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
+ unsigned short instance, int flags, struct prefix *p,
+ struct prefix_ipv6 *src_p, const struct nexthop *nh,
+ uint32_t table_id, uint32_t metric, uint32_t mtu, uint8_t distance,
+ route_tag_t tag)
{
struct route_entry *re;
struct nexthop *nexthop;
}
/* Remove specific by protocol routes from 'table'. */
-unsigned long rib_score_proto_table(u_char proto, u_short instance,
+unsigned long rib_score_proto_table(uint8_t proto, unsigned short instance,
struct route_table *table)
{
struct route_node *rn;
}
/* Remove specific by protocol routes. */
-unsigned long rib_score_proto(u_char proto, u_short instance)
+unsigned long rib_score_proto(uint8_t proto, unsigned short instance)
{
struct vrf *vrf;
struct zebra_vrf *zvrf;
struct stream *s;
struct route_entry *re;
unsigned long nump;
- u_char num;
+ uint8_t num;
struct nexthop *nh;
struct route_node *rn;
int cmd = (type == RNH_IMPORT_CHECK_TYPE) ? ZEBRA_IMPORT_CHECK_UPDATE
/* Nexthop structure. */
struct rnh {
- u_char flags;
+ uint8_t flags;
#define ZEBRA_NHT_CONNECTED 0x1
#define ZEBRA_NHT_DELETED 0x2
#include "zebra/zebra_rnh.h"
#include "zebra/zebra_routemap.h"
-static u_int32_t zebra_rmap_update_timer = ZEBRA_RMAP_DEFAULT_UPDATE_TIMER;
+static uint32_t zebra_rmap_update_timer = ZEBRA_RMAP_DEFAULT_UPDATE_TIMER;
static struct thread *zebra_t_rmap_update = NULL;
char *proto_rm[AFI_MAX][ZEBRA_ROUTE_MAX + 1]; /* "any" == ZEBRA_ROUTE_MAX */
/* NH Tracking route map */
struct nh_rmap_obj {
struct nexthop *nexthop;
vrf_id_t vrf_id;
- u_int32_t source_protocol;
+ uint32_t source_protocol;
int metric;
route_tag_t tag;
};
-static void zebra_route_map_set_delay_timer(u_int32_t value);
+static void zebra_route_map_set_delay_timer(uint32_t value);
/* Add zebra route map rule */
"0 means event-driven updates are disabled\n")
{
int idx_number = 3;
- u_int32_t rmap_delay_timer;
+ uint32_t rmap_delay_timer;
rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
zebra_route_map_set_delay_timer(rmap_delay_timer);
route_match_address_prefix_len(void *rule, struct prefix *prefix,
route_map_object_t type, void *object)
{
- u_int32_t *prefixlen = (u_int32_t *)rule;
+ uint32_t *prefixlen = (uint32_t *)rule;
if (type == RMAP_ZEBRA) {
return ((prefix->prefixlen == *prefixlen) ? RMAP_MATCH
static void *route_match_address_prefix_len_compile(const char *arg)
{
- u_int32_t *prefix_len;
+ uint32_t *prefix_len;
char *endptr = NULL;
unsigned long tmpval;
if (*endptr != '\0' || errno || tmpval > UINT32_MAX)
return NULL;
- prefix_len = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_int32_t));
+ prefix_len = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
if (!prefix_len)
return prefix_len;
route_match_ip_nexthop_prefix_len(void *rule, struct prefix *prefix,
route_map_object_t type, void *object)
{
- u_int32_t *prefixlen = (u_int32_t *)rule;
+ uint32_t *prefixlen = (uint32_t *)rule;
struct nh_rmap_obj *nh_data;
struct prefix_ipv4 p;
route_map_object_t type,
void *object)
{
- u_int32_t *rib_type = (u_int32_t *)rule;
+ uint32_t *rib_type = (uint32_t *)rule;
struct nh_rmap_obj *nh_data;
if (type == RMAP_ZEBRA) {
static void *route_match_source_protocol_compile(const char *arg)
{
- u_int32_t *rib_type;
+ uint32_t *rib_type;
int i;
i = proto_name2num(arg);
- rib_type = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(u_int32_t));
+ rib_type = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
*rib_type = i;
return (0);
}
-static void zebra_route_map_set_delay_timer(u_int32_t value)
+static void zebra_route_map_set_delay_timer(uint32_t value)
{
zebra_rmap_update_timer = value;
if (!value && zebra_t_rmap_update) {
static oid ipfw_oid[] = {IPFWMIB};
/* Hook functions. */
-static u_char *ipFwNumber(struct variable *, oid[], size_t *, int, size_t *,
+static uint8_t *ipFwNumber(struct variable *, oid[], size_t *, int, size_t *,
+ WriteMethod **);
+static uint8_t *ipFwTable(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
-static u_char *ipFwTable(struct variable *, oid[], size_t *, int, size_t *,
- WriteMethod **);
-static u_char *ipCidrNumber(struct variable *, oid[], size_t *, int, size_t *,
+static uint8_t *ipCidrNumber(struct variable *, oid[], size_t *, int, size_t *,
+ WriteMethod **);
+static uint8_t *ipCidrTable(struct variable *, oid[], size_t *, int, size_t *,
WriteMethod **);
-static u_char *ipCidrTable(struct variable *, oid[], size_t *, int, size_t *,
- WriteMethod **);
static struct variable zebra_variables[] = {
{0, GAUGE32, RONLY, ipFwNumber, 1, {1}},
{IPCIDRROUTESTATUS, ROWSTATUS, RONLY, ipCidrTable, 3, {4, 1, 16}}};
-static u_char *ipFwNumber(struct variable *v, oid objid[], size_t *objid_len,
- int exact, size_t *val_len,
- WriteMethod **write_method)
+static uint8_t *ipFwNumber(struct variable *v, oid objid[], size_t *objid_len,
+ int exact, size_t *val_len,
+ WriteMethod **write_method)
{
static int result;
struct route_table *table;
result++;
}
- return (u_char *)&result;
+ return (uint8_t *)&result;
}
-static u_char *ipCidrNumber(struct variable *v, oid objid[], size_t *objid_len,
- int exact, size_t *val_len,
- WriteMethod **write_method)
+static uint8_t *ipCidrNumber(struct variable *v, oid objid[], size_t *objid_len,
+ int exact, size_t *val_len,
+ WriteMethod **write_method)
{
static int result;
struct route_table *table;
result++;
}
- return (u_char *)&result;
+ return (uint8_t *)&result;
}
-static int in_addr_cmp(u_char *p1, u_char *p2)
+static int in_addr_cmp(uint8_t *p1, uint8_t *p2)
{
int i;
return 0;
}
-static int in_addr_add(u_char *p, int num)
+static int in_addr_add(uint8_t *p, int num)
{
int i, ip0;
return;
}
- if (in_addr_cmp((u_char *)&(*re)->ng.nexthop->gate.ipv4,
- (u_char *)&re2->ng.nexthop->gate.ipv4)
+ if (in_addr_cmp((uint8_t *)&(*re)->ng.nexthop->gate.ipv4,
+ (uint8_t *)&re2->ng.nexthop->gate.ipv4)
<= 0)
return;
int proto;
int policy;
struct in_addr nexthop;
- u_char *pnt;
+ uint8_t *pnt;
int i;
/* Init index variables */
- pnt = (u_char *)&dest;
+ pnt = (uint8_t *)&dest;
for (i = 0; i < 4; i++)
*pnt++ = 0;
- pnt = (u_char *)&nexthop;
+ pnt = (uint8_t *)&nexthop;
for (i = 0; i < 4; i++)
*pnt++ = 0;
/* Apply GETNEXT on not exact search */
if (!exact && (*objid_len >= (unsigned)v->namelen + 10)) {
- if (!in_addr_add((u_char *)&nexthop, 1))
+ if (!in_addr_add((uint8_t *)&nexthop, 1))
return;
}
if (policy) /* Not supported (yet?) */
return;
for (*np = route_top(table); *np; *np = route_next(*np)) {
- if (!in_addr_cmp(&(*np)->p.u.prefix, (u_char *)&dest)) {
+ if (!in_addr_cmp(&(*np)->p.u.prefix,
+ (uint8_t *)&dest)) {
RNODE_FOREACH_RE (*np, *re) {
- if (!in_addr_cmp(
- (u_char *)&(*re)
- ->ng.nexthop->gate.ipv4,
- (u_char *)&nexthop))
+ if (!in_addr_cmp((uint8_t *)&(*re)
+ ->ng.nexthop
+ ->gate.ipv4,
+ (uint8_t *)&nexthop))
if (proto
== proto_trans((*re)->type))
return;
for (np2 = route_top(table); np2; np2 = route_next(np2)) {
/* Check destination first */
- if (in_addr_cmp(&np2->p.u.prefix, (u_char *)&dest) > 0)
+ if (in_addr_cmp(&np2->p.u.prefix, (uint8_t *)&dest) > 0)
RNODE_FOREACH_RE (np2, re2) {
check_replace(np2, re2, np, re);
}
- if (in_addr_cmp(&np2->p.u.prefix, (u_char *)&dest)
+ if (in_addr_cmp(&np2->p.u.prefix, (uint8_t *)&dest)
== 0) { /* have to look at each re individually */
RNODE_FOREACH_RE (np2, re2) {
int proto2, policy2;
|| ((policy == policy2) && (proto < proto2))
|| ((policy == policy2) && (proto == proto2)
&& (in_addr_cmp(
- (u_char *)&re2->ng.nexthop
- ->gate.ipv4,
- (u_char *)&nexthop)
+ (uint8_t *)&re2->ng.nexthop
+ ->gate.ipv4,
+ (uint8_t *)&nexthop)
>= 0)))
check_replace(np2, re2, np, re);
}
proto = proto_trans((*re)->type);
*objid_len = v->namelen + 10;
- pnt = (u_char *)&(*np)->p.u.prefix;
+ pnt = (uint8_t *)&(*np)->p.u.prefix;
for (i = 0; i < 4; i++)
objid[v->namelen + i] = *pnt++;
nexthop = (*re)->ng.nexthop;
if (nexthop) {
- pnt = (u_char *)&nexthop->gate.ipv4;
+ pnt = (uint8_t *)&nexthop->gate.ipv4;
for (i = 0; i < 4; i++)
objid[i + v->namelen + 6] = *pnt++;
}
return;
}
-static u_char *ipFwTable(struct variable *v, oid objid[], size_t *objid_len,
- int exact, size_t *val_len, WriteMethod **write_method)
+static uint8_t *ipFwTable(struct variable *v, oid objid[], size_t *objid_len,
+ int exact, size_t *val_len,
+ WriteMethod **write_method)
{
struct route_node *np;
struct route_entry *re;
case IPFORWARDMASK:
masklen2ip(np->p.prefixlen, &netmask);
*val_len = 4;
- return (u_char *)&netmask;
+ return (uint8_t *)&netmask;
break;
case IPFORWARDPOLICY:
result = 0;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDNEXTHOP:
*val_len = 4;
- return (u_char *)&nexthop->gate.ipv4;
+ return (uint8_t *)&nexthop->gate.ipv4;
break;
case IPFORWARDIFINDEX:
*val_len = sizeof(int);
- return (u_char *)&nexthop->ifindex;
+ return (uint8_t *)&nexthop->ifindex;
break;
case IPFORWARDTYPE:
if (nexthop->type == NEXTHOP_TYPE_IFINDEX)
else
result = 4;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDPROTO:
result = proto_trans(re->type);
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDAGE:
result = 0;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDINFO:
resarr[0] = 0;
resarr[1] = 0;
*val_len = 2 * sizeof(int);
- return (u_char *)resarr;
+ return (uint8_t *)resarr;
break;
case IPFORWARDNEXTHOPAS:
result = -1;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDMETRIC1:
result = 0;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDMETRIC2:
result = 0;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDMETRIC3:
result = 0;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDMETRIC4:
result = 0;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
case IPFORWARDMETRIC5:
result = 0;
*val_len = sizeof(int);
- return (u_char *)&result;
+ return (uint8_t *)&result;
break;
default:
return NULL;
return NULL;
}
-static u_char *ipCidrTable(struct variable *v, oid objid[], size_t *objid_len,
- int exact, size_t *val_len,
- WriteMethod **write_method)
+static uint8_t *ipCidrTable(struct variable *v, oid objid[], size_t *objid_len,
+ int exact, size_t *val_len,
+ WriteMethod **write_method)
{
if (smux_header_table(v, objid, objid_len, exact, val_len, write_method)
== MATCH_FAILED)
route_unlock_node(rn);
}
-int static_add_route(afi_t afi, safi_t safi, u_char type, struct prefix *p,
+int static_add_route(afi_t afi, safi_t safi, uint8_t type, struct prefix *p,
struct prefix_ipv6 *src_p, union g_addr *gate,
const char *ifname, enum static_blackhole_type bh_type,
- route_tag_t tag, u_char distance, struct zebra_vrf *zvrf,
+ route_tag_t tag, uint8_t distance, struct zebra_vrf *zvrf,
struct zebra_vrf *nh_zvrf,
struct static_nh_label *snh_label)
{
return 1;
}
-int static_delete_route(afi_t afi, safi_t safi, u_char type, struct prefix *p,
+int static_delete_route(afi_t afi, safi_t safi, uint8_t type, struct prefix *p,
struct prefix_ipv6 *src_p, union g_addr *gate,
- const char *ifname, route_tag_t tag, u_char distance,
+ const char *ifname, route_tag_t tag, uint8_t distance,
struct zebra_vrf *zvrf,
struct static_nh_label *snh_label)
{
/* Static route label information */
struct static_nh_label {
- u_int8_t num_labels;
- u_int8_t reserved[3];
+ uint8_t num_labels;
+ uint8_t reserved[3];
mpls_label_t label[MPLS_MAX_LABELS];
};
vrf_id_t nh_vrf_id;
/* Administrative distance. */
- u_char distance;
+ uint8_t distance;
/* Tag */
route_tag_t tag;
struct prefix_ipv6 *src_p,
struct static_route *si);
-extern int static_add_route(afi_t, safi_t safi, u_char type, struct prefix *p,
+extern int static_add_route(afi_t, safi_t safi, uint8_t type, struct prefix *p,
struct prefix_ipv6 *src_p, union g_addr *gate,
const char *ifname,
enum static_blackhole_type bh_type, route_tag_t tag,
- u_char distance, struct zebra_vrf *zvrf,
+ uint8_t distance, struct zebra_vrf *zvrf,
struct zebra_vrf *nh_zvrf,
struct static_nh_label *snh_label);
-extern int static_delete_route(afi_t, safi_t safi, u_char type,
+extern int static_delete_route(afi_t, safi_t safi, uint8_t type,
struct prefix *p, struct prefix_ipv6 *src_p,
union g_addr *gate, const char *ifname,
- route_tag_t tag, u_char distance,
+ route_tag_t tag, uint8_t distance,
struct zebra_vrf *zvrf,
struct static_nh_label *snh_label);
*/
struct route_table *zebra_vrf_table_with_table_id(afi_t afi, safi_t safi,
vrf_id_t vrf_id,
- u_int32_t table_id)
+ uint32_t table_id)
{
struct route_table *table = NULL;
return zvrf->stable[afi][safi];
}
-struct route_table *zebra_vrf_other_route_table(afi_t afi, u_int32_t table_id,
+struct route_table *zebra_vrf_other_route_table(afi_t afi, uint32_t table_id,
vrf_id_t vrf_id)
{
struct zebra_vrf *zvrf;
/* MPLS (Segment Routing) global block */
typedef struct mpls_srgb_t_ {
- u_int32_t start_label;
- u_int32_t end_label;
+ uint32_t start_label;
+ uint32_t end_label;
} mpls_srgb_t;
/* Routing table instance. */
char *desc;
/* FIB identifier. */
- u_char fib_id;
+ uint8_t fib_id;
/* Flags. */
- u_int16_t flags;
+ uint16_t flags;
#define ZEBRA_VRF_RIB_SCHEDULED (1 << 0)
#define ZEBRA_VRF_RETAIN (2 << 0)
- u_int32_t table_id;
+ uint32_t table_id;
/* Routing table. */
struct route_table *table[AFI_MAX][SAFI_MAX];
struct zebra_static_pw_head static_pseudowires;
/* MPLS processing flags */
- u_int16_t mpls_flags;
+ uint16_t mpls_flags;
#define MPLS_FLAG_SCHEDULE_LSPS (1 << 0)
/*
struct route_table *zebra_vrf_table_with_table_id(afi_t afi, safi_t safi,
vrf_id_t vrf_id,
- u_int32_t table_id);
+ uint32_t table_id);
extern void zebra_vrf_update_all(struct zserv *client);
extern struct zebra_vrf *zebra_vrf_lookup_by_id(vrf_id_t vrf_id);
extern struct route_table *zebra_vrf_static_table(afi_t, safi_t,
struct zebra_vrf *zvrf);
extern struct route_table *
-zebra_vrf_other_route_table(afi_t afi, u_int32_t table_id, vrf_id_t vrf_id);
+zebra_vrf_other_route_table(afi_t afi, uint32_t table_id, vrf_id_t vrf_id);
extern int zebra_vrf_has_config(struct zebra_vrf *zvrf);
extern void zebra_vrf_init(void);
extern int allow_delete;
static int do_show_ip_route(struct vty *vty, const char *vrf_name, afi_t afi,
- safi_t safi, bool use_fib, u_char use_json,
+ safi_t safi, bool use_fib, uint8_t use_json,
route_tag_t tag,
const struct prefix *longer_prefix_p,
bool supernets_only, int type,
- u_short ospf_instance_id);
+ unsigned short ospf_instance_id);
static void vty_show_ip_route_detail(struct vty *vty, struct route_node *rn,
int mcast);
static void vty_show_ip_route_summary(struct vty *vty,
const char *distance_str, const char *label_str)
{
int ret;
- u_char distance;
+ uint8_t distance;
struct prefix p, src;
struct prefix_ipv6 *src_p = NULL;
union g_addr gate;
struct in_addr mask;
enum static_blackhole_type bh_type = 0;
route_tag_t tag = 0;
- u_char type;
+ uint8_t type;
struct static_nh_label snh_label;
ret = str2prefix(dest_str, &p);
bool use_fib, route_tag_t tag,
const struct prefix *longer_prefix_p,
bool supernets_only, int type,
- u_short ospf_instance_id, u_char use_json)
+ unsigned short ospf_instance_id,
+ uint8_t use_json)
{
struct route_node *rn;
struct route_entry *re;
}
static int do_show_ip_route(struct vty *vty, const char *vrf_name, afi_t afi,
- safi_t safi, bool use_fib, u_char use_json,
+ safi_t safi, bool use_fib, uint8_t use_json,
route_tag_t tag,
const struct prefix *longer_prefix_p,
bool supernets_only, int type,
- u_short ospf_instance_id)
+ unsigned short ospf_instance_id)
{
struct route_table *table;
struct zebra_vrf *zvrf = NULL;
struct route_entry *re;
#define ZEBRA_ROUTE_IBGP ZEBRA_ROUTE_MAX
#define ZEBRA_ROUTE_TOTAL (ZEBRA_ROUTE_IBGP + 1)
- u_int32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
- u_int32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
- u_int32_t i;
- u_int32_t is_ibgp;
+ uint32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t i;
+ uint32_t is_ibgp;
memset(&rib_cnt, 0, sizeof(rib_cnt));
memset(&fib_cnt, 0, sizeof(fib_cnt));
struct nexthop *nexthop;
#define ZEBRA_ROUTE_IBGP ZEBRA_ROUTE_MAX
#define ZEBRA_ROUTE_TOTAL (ZEBRA_ROUTE_IBGP + 1)
- u_int32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
- u_int32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
- u_int32_t i;
+ uint32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t i;
int cnt;
memset(&rib_cnt, 0, sizeof(rib_cnt));
struct zebra_vrf *zvrf;
json_object *json = NULL;
json_object *json_vrfs = NULL;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (uj) {
json = json_object_new_object();
"EVPN\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zebra_vxlan_print_evpn(vty, uj);
return CMD_SUCCESS;
JSON_STR)
{
struct zebra_vrf *zvrf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zvrf = vrf_info_lookup(VRF_DEFAULT);
zebra_vxlan_print_vnis(vty, zvrf, uj);
{
struct zebra_vrf *zvrf;
vni_t vni;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
vni = strtoul(argv[3]->arg, NULL, 10);
zvrf = vrf_info_lookup(VRF_DEFAULT);
{
vni_t l3vni = 0;
struct ethaddr mac;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
l3vni = strtoul(argv[4]->arg, NULL, 10);
if (!prefix_str2mac(argv[6]->arg, &mac)) {
JSON_STR)
{
vni_t l3vni = 0;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
l3vni = strtoul(argv[4]->arg, NULL, 10);
zebra_vxlan_print_rmacs_l3vni(vty, l3vni, uj);
"All VNIs\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zebra_vxlan_print_rmacs_all_l3vni(vty, uj);
{
vni_t l3vni;
struct ipaddr ip;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
l3vni = strtoul(argv[4]->arg, NULL, 10);
if (str2ipaddr(argv[6]->arg, &ip) != 0) {
JSON_STR)
{
vni_t l3vni;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
l3vni = strtoul(argv[4]->arg, NULL, 10);
zebra_vxlan_print_nh_l3vni(vty, l3vni, uj);
"All VNIs\n"
JSON_STR)
{
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zebra_vxlan_print_nh_all_l3vni(vty, uj);
{
struct zebra_vrf *zvrf;
vni_t vni;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
vni = strtoul(argv[4]->arg, NULL, 10);
zvrf = vrf_info_lookup(VRF_DEFAULT);
JSON_STR)
{
struct zebra_vrf *zvrf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zvrf = vrf_info_lookup(VRF_DEFAULT);
zebra_vxlan_print_macs_all_vni(vty, zvrf, uj);
{
struct zebra_vrf *zvrf;
struct in_addr vtep_ip;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
if (!inet_aton(argv[6]->arg, &vtep_ip)) {
if (!uj)
struct zebra_vrf *zvrf;
vni_t vni;
struct in_addr vtep_ip;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
vni = strtoul(argv[4]->arg, NULL, 10);
if (!inet_aton(argv[6]->arg, &vtep_ip)) {
{
struct zebra_vrf *zvrf;
vni_t vni;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
vni = strtoul(argv[4]->arg, NULL, 10);
zvrf = vrf_info_lookup(VRF_DEFAULT);
JSON_STR)
{
struct zebra_vrf *zvrf;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
zvrf = vrf_info_lookup(VRF_DEFAULT);
zebra_vxlan_print_neigh_all_vni(vty, zvrf, uj);
struct zebra_vrf *zvrf;
vni_t vni;
struct ipaddr ip;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
vni = strtoul(argv[4]->arg, NULL, 10);
if (str2ipaddr(argv[6]->arg, &ip) != 0) {
struct zebra_vrf *zvrf;
vni_t vni;
struct in_addr vtep_ip;
- u_char uj = use_json(argc, argv);
+ uint8_t uj = use_json(argc, argv);
vni = strtoul(argv[4]->arg, NULL, 10);
if (!inet_aton(argv[6]->arg, &vtep_ip)) {
"route-map for filtering\n"
"route-map name\n")
{
- u_int32_t table_id = 0;
+ uint32_t table_id = 0;
table_id = strtoul(argv[2]->arg, NULL, 10);
int distance = ZEBRA_TABLE_DISTANCE_DEFAULT;
"route-map for filtering\n"
"route-map name\n")
{
- u_int32_t table_id = 0;
+ uint32_t table_id = 0;
table_id = strtoul(argv[3]->arg, NULL, 10);
if (!is_zebra_valid_kernel_table(table_id)) {
static void zvni_print_hash(struct hash_backet *backet, void *ctxt[]);
static int zvni_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
- struct ipaddr *ip, u_char flags,
- u_int16_t cmd);
+ struct ipaddr *ip, uint8_t flags,
+ uint16_t cmd);
static unsigned int neigh_hash_keymake(void *p);
static int neigh_cmp(const void *p1, const void *p2);
static void *zvni_neigh_alloc(void *p);
static void zvni_neigh_del_from_vtep(zebra_vni_t *zvni, int uninstall,
struct in_addr *r_vtep_ip);
static void zvni_neigh_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
- u_int32_t flags);
+ uint32_t flags);
static zebra_neigh_t *zvni_neigh_lookup(zebra_vni_t *zvni, struct ipaddr *ip);
static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
- struct ethaddr *macaddr, u_char flags);
+ struct ethaddr *macaddr,
+ uint8_t flags);
static int zvni_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
- struct ethaddr *macaddr, u_char flags);
+ struct ethaddr *macaddr,
+ uint8_t flags);
static int zvni_neigh_install(zebra_vni_t *zvni, zebra_neigh_t *n);
static int zvni_neigh_uninstall(zebra_vni_t *zvni, zebra_neigh_t *n);
static zebra_vni_t *zvni_from_svi(struct interface *ifp,
static void zvni_mac_del_from_vtep(zebra_vni_t *zvni, int uninstall,
struct in_addr *r_vtep_ip);
static void zvni_mac_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
- u_int32_t flags);
+ uint32_t flags);
static zebra_mac_t *zvni_mac_lookup(zebra_vni_t *zvni, struct ethaddr *macaddr);
static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
- u_char flags);
+ uint8_t flags);
static int zvni_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
- u_char flags);
+ uint8_t flags);
static zebra_vni_t *zvni_map_vlan(struct interface *ifp,
struct interface *br_if, vlanid_t vid);
static int zvni_mac_install(zebra_vni_t *zvni, zebra_mac_t *mac);
* Return number of valid MACs in a VNI's MAC hash table - all
* remote MACs and non-internal (auto) local MACs count.
*/
-static u_int32_t num_valid_macs(zebra_vni_t *zvni)
+static uint32_t num_valid_macs(zebra_vni_t *zvni)
{
unsigned int i;
- u_int32_t num_macs = 0;
+ uint32_t num_macs = 0;
struct hash *hash;
struct hash_backet *hb;
zebra_mac_t *mac;
struct vty *vty;
json_object *json = NULL, *json_vni = NULL;
zebra_vni_t *zvni;
- u_int32_t num_neigh;
+ uint32_t num_neigh;
struct neigh_walk_ctx wctx;
char vni_str[VNI_STR_LEN];
json_object *json = NULL, *json_vni = NULL;
json_object *json_mac = NULL;
zebra_vni_t *zvni;
- u_int32_t num_macs;
+ uint32_t num_macs;
struct mac_walk_ctx *wctx = ctxt;
char vni_str[VNI_STR_LEN];
json_object *json = NULL;
json_object *json_vni = NULL;
zebra_l3vni_t *zl3vni = NULL;
- u_int32_t num_rmacs;
+ uint32_t num_rmacs;
struct rmac_walk_ctx wctx;
char vni_str[VNI_STR_LEN];
{
struct vty *vty;
zebra_vtep_t *zvtep;
- u_int32_t num_macs;
- u_int32_t num_neigh;
+ uint32_t num_macs;
+ uint32_t num_neigh;
json_object *json = NULL;
json_object *json_vtep_list = NULL;
json_object *json_ip_str = NULL;
struct vty *vty;
zebra_vni_t *zvni;
zebra_vtep_t *zvtep;
- u_int32_t num_vteps = 0;
- u_int32_t num_macs = 0;
- u_int32_t num_neigh = 0;
+ uint32_t num_vteps = 0;
+ uint32_t num_macs = 0;
+ uint32_t num_neigh = 0;
json_object *json = NULL;
json_object *json_vni = NULL;
json_object *json_ip_str = NULL;
* Inform BGP about local MACIP.
*/
static int zvni_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
- struct ipaddr *ip, u_char flags,
- u_int16_t cmd)
+ struct ipaddr *ip, uint8_t flags,
+ uint16_t cmd)
{
char buf[ETHER_ADDR_STRLEN];
char buf2[INET6_ADDRSTRLEN];
* Delete all neighbor entries for this VNI.
*/
static void zvni_neigh_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
- u_int32_t flags)
+ uint32_t flags)
{
struct neigh_walk_ctx wctx;
*/
static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
struct ethaddr *macaddr,
- u_char neigh_flags)
+ uint8_t neigh_flags)
{
- u_char flags = 0;
+ uint8_t flags = 0;
if (CHECK_FLAG(neigh_flags, ZEBRA_NEIGH_DEF_GW))
SET_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
* Inform BGP about local neighbor deletion.
*/
static int zvni_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
- struct ethaddr *macaddr, u_char flags)
+ struct ethaddr *macaddr, uint8_t flags)
{
return zvni_macip_send_msg_to_client(vni, macaddr, ip, flags,
ZEBRA_MACIP_DEL);
* Delete all MAC entries for this VNI.
*/
static void zvni_mac_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
- u_int32_t flags)
+ uint32_t flags)
{
struct mac_walk_ctx wctx;
* Inform BGP about local MAC addition.
*/
static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
- u_char mac_flags)
+ uint8_t mac_flags)
{
- u_char flags = 0;
+ uint8_t flags = 0;
if (CHECK_FLAG(mac_flags, ZEBRA_MAC_STICKY))
SET_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY);
* Inform BGP about local MAC deletion.
*/
static int zvni_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
- u_char mac_flags)
+ uint8_t mac_flags)
{
- u_char flags = 0;
+ uint8_t flags = 0;
if (CHECK_FLAG(mac_flags, ZEBRA_MAC_STICKY))
SET_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY);
struct zebra_if *zif;
struct zebra_l2info_bridge *br;
struct zebra_l2info_vxlan *vxl = NULL;
- u_char bridge_vlan_aware;
+ uint8_t bridge_vlan_aware;
zebra_vni_t *zvni;
int found = 0;
struct zebra_if *zif;
struct zebra_l2info_bridge *br;
struct zebra_l2info_vxlan *vxl = NULL;
- u_char bridge_vlan_aware;
+ uint8_t bridge_vlan_aware;
vlanid_t vid = 0;
zebra_vni_t *zvni;
int found = 0;
struct zebra_if *zif;
struct zebra_l2info_bridge *br;
struct zebra_l2info_vlan *vl;
- u_char bridge_vlan_aware;
+ uint8_t bridge_vlan_aware;
int found = 0;
/* Defensive check, caller expected to invoke only with valid bridge. */
{
struct zebra_if *zif;
struct zebra_l2info_vxlan *vxl;
- u_char sticky;
+ uint8_t sticky;
if (!(mac->flags & ZEBRA_MAC_REMOTE))
return 0;
* readd stale entries.
*/
static int zl3vni_local_nh_add_update(zebra_l3vni_t *zl3vni, struct ipaddr *ip,
- u_int16_t state)
+ uint16_t state)
{
#ifdef GNU_LINUX
zebra_neigh_t *n = NULL;
{
int found = 0;
vlanid_t vid = 0;
- u_char bridge_vlan_aware = 0;
+ uint8_t bridge_vlan_aware = 0;
zebra_l3vni_t *zl3vni = NULL;
struct zebra_ns *zns = NULL;
struct route_node *rn = NULL;
void zebra_vxlan_print_specific_rmac_l3vni(struct vty *vty, vni_t l3vni,
struct ethaddr *rmac,
- u_char use_json)
+ uint8_t use_json)
{
zebra_l3vni_t *zl3vni = NULL;
zebra_mac_t *zrmac = NULL;
}
void zebra_vxlan_print_rmacs_l3vni(struct vty *vty, vni_t l3vni,
- u_char use_json)
+ uint8_t use_json)
{
zebra_l3vni_t *zl3vni;
- u_int32_t num_rmacs;
+ uint32_t num_rmacs;
struct rmac_walk_ctx wctx;
json_object *json = NULL;
}
}
-void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, u_char use_json)
+void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, uint8_t use_json)
{
struct zebra_ns *zns = NULL;
json_object *json = NULL;
}
void zebra_vxlan_print_specific_nh_l3vni(struct vty *vty, vni_t l3vni,
- struct ipaddr *ip, u_char use_json)
+ struct ipaddr *ip, uint8_t use_json)
{
zebra_l3vni_t *zl3vni = NULL;
zebra_neigh_t *n = NULL;
}
}
-void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t l3vni, u_char use_json)
+void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t l3vni, uint8_t use_json)
{
- u_int32_t num_nh;
+ uint32_t num_nh;
struct nh_walk_ctx wctx;
json_object *json = NULL;
zebra_l3vni_t *zl3vni = NULL;
}
}
-void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, u_char use_json)
+void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, uint8_t use_json)
{
struct zebra_ns *zns = NULL;
json_object *json = NULL;
/*
* Display L3 VNI information (VTY command handler).
*/
-void zebra_vxlan_print_l3vni(struct vty *vty, vni_t vni, u_char use_json)
+void zebra_vxlan_print_l3vni(struct vty *vty, vni_t vni, uint8_t use_json)
{
void *args[2];
json_object *json = NULL;
* Display Neighbors for a VNI (VTY command handler).
*/
void zebra_vxlan_print_neigh_vni(struct vty *vty, struct zebra_vrf *zvrf,
- vni_t vni, u_char use_json)
+ vni_t vni, uint8_t use_json)
{
zebra_vni_t *zvni;
- u_int32_t num_neigh;
+ uint32_t num_neigh;
struct neigh_walk_ctx wctx;
json_object *json = NULL;
* Display neighbors across all VNIs (VTY command handler).
*/
void zebra_vxlan_print_neigh_all_vni(struct vty *vty, struct zebra_vrf *zvrf,
- u_char use_json)
+ uint8_t use_json)
{
json_object *json = NULL;
void *args[2];
*/
void zebra_vxlan_print_specific_neigh_vni(struct vty *vty,
struct zebra_vrf *zvrf, vni_t vni,
- struct ipaddr *ip, u_char use_json)
+ struct ipaddr *ip, uint8_t use_json)
{
zebra_vni_t *zvni;
zebra_neigh_t *n;
*/
void zebra_vxlan_print_neigh_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
vni_t vni, struct in_addr vtep_ip,
- u_char use_json)
+ uint8_t use_json)
{
zebra_vni_t *zvni;
- u_int32_t num_neigh;
+ uint32_t num_neigh;
struct neigh_walk_ctx wctx;
json_object *json = NULL;
* Display MACs for a VNI (VTY command handler).
*/
void zebra_vxlan_print_macs_vni(struct vty *vty, struct zebra_vrf *zvrf,
- vni_t vni, u_char use_json)
+ vni_t vni, uint8_t use_json)
{
zebra_vni_t *zvni;
- u_int32_t num_macs;
+ uint32_t num_macs;
struct mac_walk_ctx wctx;
json_object *json = NULL;
json_object *json_mac = NULL;
* Display MACs for all VNIs (VTY command handler).
*/
void zebra_vxlan_print_macs_all_vni(struct vty *vty, struct zebra_vrf *zvrf,
- u_char use_json)
+ uint8_t use_json)
{
struct mac_walk_ctx wctx;
json_object *json = NULL;
void zebra_vxlan_print_macs_all_vni_vtep(struct vty *vty,
struct zebra_vrf *zvrf,
struct in_addr vtep_ip,
- u_char use_json)
+ uint8_t use_json)
{
struct mac_walk_ctx wctx;
json_object *json = NULL;
*/
void zebra_vxlan_print_macs_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
vni_t vni, struct in_addr vtep_ip,
- u_char use_json)
+ uint8_t use_json)
{
zebra_vni_t *zvni;
- u_int32_t num_macs;
+ uint32_t num_macs;
struct mac_walk_ctx wctx;
json_object *json = NULL;
json_object *json_mac = NULL;
* Display VNI information (VTY command handler).
*/
void zebra_vxlan_print_vni(struct vty *vty, struct zebra_vrf *zvrf, vni_t vni,
- u_char use_json)
+ uint8_t use_json)
{
json_object *json = NULL;
void *args[2];
}
/* Display all global details for EVPN */
-void zebra_vxlan_print_evpn(struct vty *vty, u_char uj)
+void zebra_vxlan_print_evpn(struct vty *vty, uint8_t uj)
{
int num_l2vnis = 0;
int num_l3vnis = 0;
* Display VNI hash table (VTY command handler).
*/
void zebra_vxlan_print_vnis(struct vty *vty, struct zebra_vrf *zvrf,
- u_char use_json)
+ uint8_t use_json)
{
json_object *json = NULL;
struct zebra_ns *zns = NULL;
int zebra_vxlan_local_neigh_add_update(struct interface *ifp,
struct interface *link_if,
struct ipaddr *ip,
- struct ethaddr *macaddr, u_int16_t state,
- u_char ext_learned)
+ struct ethaddr *macaddr, uint16_t state,
+ uint8_t ext_learned)
{
char buf[ETHER_ADDR_STRLEN];
char buf2[INET6_ADDRSTRLEN];
}
memset(&zmac->fwd_info, 0, sizeof(zmac->fwd_info));
- memset(&zmac->flags, 0, sizeof(u_int32_t));
+ memset(&zmac->flags, 0, sizeof(uint32_t));
SET_FLAG(zmac->flags, ZEBRA_MAC_AUTO);
}
zebra_vni_t *zvni;
zebra_mac_t *mac;
zebra_neigh_t *n;
- u_short l = 0, ipa_len;
+ unsigned short l = 0, ipa_len;
char buf[ETHER_ADDR_STRLEN];
char buf1[INET6_ADDRSTRLEN];
struct interface *ifp = NULL;
zebra_vtep_t *zvtep;
zebra_mac_t *mac, *old_mac;
zebra_neigh_t *n;
- u_short l = 0, ipa_len;
+ unsigned short l = 0, ipa_len;
int update_mac = 0, update_neigh = 0;
char buf[ETHER_ADDR_STRLEN];
char buf1[INET6_ADDRSTRLEN];
- u_char sticky = 0;
- u_char flags = 0;
+ uint8_t sticky = 0;
+ uint8_t flags = 0;
struct interface *ifp = NULL;
struct zebra_if *zif = NULL;
int zebra_vxlan_local_mac_add_update(struct interface *ifp,
struct interface *br_if,
struct ethaddr *macaddr, vlanid_t vid,
- u_char sticky)
+ uint8_t sticky)
{
zebra_vni_t *zvni;
zebra_mac_t *mac;
char buf[ETHER_ADDR_STRLEN];
int add = 1;
- u_char mac_sticky;
+ uint8_t mac_sticky;
/* We are interested in MACs only on ports or (port, VLAN) that
* map to a VNI.
void zebra_vxlan_remote_vtep_del(ZAPI_HANDLER_ARGS)
{
struct stream *s;
- u_short l = 0;
+ unsigned short l = 0;
vni_t vni;
struct in_addr vtep_ip;
zebra_vni_t *zvni;
void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
{
struct stream *s;
- u_short l = 0;
+ unsigned short l = 0;
vni_t vni;
struct in_addr vtep_ip;
zebra_vni_t *zvni;
/*
* Handle VxLAN interface update - change to tunnel IP, master or VLAN.
*/
-int zebra_vxlan_if_update(struct interface *ifp, u_int16_t chgflags)
+int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
{
vni_t vni;
struct zebra_if *zif = NULL;
extern int zebra_vxlan_vrf_disable(struct zebra_vrf *zvrf);
extern int zebra_vxlan_vrf_delete(struct zebra_vrf *zvrf);
extern void zebra_vxlan_print_specific_nh_l3vni(struct vty *vty, vni_t l3vni,
- struct ipaddr *ip, u_char uj);
-extern void zebra_vxlan_print_evpn(struct vty *vty, u_char uj);
+ struct ipaddr *ip, uint8_t uj);
+extern void zebra_vxlan_print_evpn(struct vty *vty, uint8_t uj);
extern void zebra_vxlan_print_specific_rmac_l3vni(struct vty *vty, vni_t l3vni,
struct ethaddr *rmac,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_macs_vni(struct vty *vty, struct zebra_vrf *zvrf,
- vni_t vni, u_char use_json);
+ vni_t vni, uint8_t use_json);
extern void zebra_vxlan_print_macs_all_vni(struct vty *vty,
struct zebra_vrf *zvrf,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_macs_all_vni_vtep(struct vty *vty,
struct zebra_vrf *zvrf,
struct in_addr vtep_ip,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_specific_mac_vni(struct vty *vty,
struct zebra_vrf *zvrf,
vni_t vni, struct ethaddr *mac);
extern void zebra_vxlan_print_macs_vni_vtep(struct vty *vty,
struct zebra_vrf *zvrf, vni_t vni,
struct in_addr vtep_ip,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_neigh_vni(struct vty *vty, struct zebra_vrf *zvrf,
- vni_t vni, u_char use_json);
+ vni_t vni, uint8_t use_json);
extern void zebra_vxlan_print_neigh_all_vni(struct vty *vty,
struct zebra_vrf *zvrf,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_specific_neigh_vni(struct vty *vty,
struct zebra_vrf *zvrf,
vni_t vni, struct ipaddr *ip,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_neigh_vni_vtep(struct vty *vty,
struct zebra_vrf *zvrf, vni_t vni,
struct in_addr vtep_ip,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_vni(struct vty *vty, struct zebra_vrf *zvrf,
- vni_t vni, u_char use_json);
+ vni_t vni, uint8_t use_json);
extern void zebra_vxlan_print_vnis(struct vty *vty, struct zebra_vrf *zvrf,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_rmacs_l3vni(struct vty *vty, vni_t vni,
- u_char use_json);
-extern void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, u_char use_json);
+ uint8_t use_json);
+extern void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty,
+ uint8_t use_json);
extern void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t vni,
- u_char use_json);
-extern void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, u_char use_json);
+ uint8_t use_json);
+extern void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, uint8_t use_json);
extern void zebra_vxlan_print_l3vni(struct vty *vty, vni_t vni,
- u_char use_json);
+ uint8_t use_json);
extern void zebra_vxlan_print_vrf_vni(struct vty *vty, struct zebra_vrf *zvrf,
json_object *json_vrfs);
extern int zebra_vxlan_add_del_gw_macip(struct interface *ifp, struct prefix *p,
struct interface *link_if);
extern int zebra_vxlan_local_neigh_add_update(
struct interface *ifp, struct interface *link_if, struct ipaddr *ip,
- struct ethaddr *macaddr, u_int16_t state, u_char ext_learned);
+ struct ethaddr *macaddr, uint16_t state, uint8_t ext_learned);
extern int zebra_vxlan_local_neigh_del(struct interface *ifp,
struct interface *link_if,
struct ipaddr *ip);
extern int zebra_vxlan_local_mac_add_update(struct interface *ifp,
struct interface *br_if,
struct ethaddr *mac, vlanid_t vid,
- u_char sticky);
+ uint8_t sticky);
extern int zebra_vxlan_local_mac_del(struct interface *ifp,
struct interface *br_if,
struct ethaddr *mac, vlanid_t vid);
extern int zebra_vxlan_if_up(struct interface *ifp);
extern int zebra_vxlan_if_down(struct interface *ifp);
extern int zebra_vxlan_if_add(struct interface *ifp);
-extern int zebra_vxlan_if_update(struct interface *ifp, u_int16_t chgflags);
+extern int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags);
extern int zebra_vxlan_if_del(struct interface *ifp);
extern int zebra_vxlan_process_vrf_vni_cmd(struct zebra_vrf *zvrf, vni_t vni,
char *err, int err_str_sz,
{
}
-void zebra_vxlan_print_evpn(struct vty *vty, u_char uj)
+void zebra_vxlan_print_evpn(struct vty *vty, uint8_t uj)
{
}
-void zebra_vxlan_print_rmacs_l3vni(struct vty *, vni_t, u_char)
+void zebra_vxlan_print_rmacs_l3vni(struct vty *, vni_t, uint8_t)
{
}
-void zebra_vxlan_print_rmacs_all_l3vni(struct vty *, u_char)
+void zebra_vxlan_print_rmacs_all_l3vni(struct vty *, uint8_t)
{
}
-void zebra_vxlan_print_nh_l3vni(struct vty *, vni_t, u_char)
+void zebra_vxlan_print_nh_l3vni(struct vty *, vni_t, uint8_t)
{
}
-void zebra_vxlan_print_nh_all_l3vni(struct vty *, u_char)
+void zebra_vxlan_print_nh_all_l3vni(struct vty *, uint8_t)
{
}
return 0;
}
-int zebra_vxlan_remote_macip_add(struct zserv *client, int sock, u_short length,
- struct zebra_vrf *zvrf)
+int zebra_vxlan_remote_macip_add(struct zserv *client, int sock,
+ unsigned short length, struct zebra_vrf *zvrf)
{
return 0;
}
-int zebra_vxlan_remote_macip_del(struct zserv *client, int sock, u_short length,
- struct zebra_vrf *zvrf)
+int zebra_vxlan_remote_macip_del(struct zserv *client, int sock,
+ unsigned short length, struct zebra_vrf *zvrf)
{
return 0;
}
int zebra_vxlan_local_mac_add_update(struct interface *ifp,
struct interface *br_if,
struct ethaddr *mac, vlanid_t vid,
- u_char sticky)
+ uint8_t sticky)
{
return 0;
}
return 0;
}
-int zebra_vxlan_if_update(struct interface *ifp, u_int16_t chgflags)
+int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
{
return 0;
}
return 0;
}
-int zebra_vxlan_remote_vtep_add(struct zserv *client, int sock, u_short length,
- struct zebra_vrf *zvrf)
+int zebra_vxlan_remote_vtep_add(struct zserv *client, int sock,
+ unsigned short length, struct zebra_vrf *zvrf)
{
return 0;
}
-int zebra_vxlan_remote_vtep_del(struct zserv *client, int sock, u_short length,
- struct zebra_vrf *zvrf)
+int zebra_vxlan_remote_vtep_del(struct zserv *client, int sock,
+ unsigned short length, struct zebra_vrf *zvrf)
{
return 0;
}
int zebra_vxlan_advertise_all_vni(struct zserv *client, int sock,
- u_short length, struct zebra_vrf *zvrf)
+ unsigned short length, struct zebra_vrf *zvrf)
{
return 0;
}
vni_t vni;
/* Flag for advertising gw macip */
- u_int8_t advertise_gw_macip;
+ uint8_t advertise_gw_macip;
/* Flag for advertising gw macip */
- u_int8_t advertise_subnet;
+ uint8_t advertise_subnet;
/* Corresponding VxLAN interface. */
struct interface *vxlan_if;
/* MAC address. */
struct ethaddr macaddr;
- u_int32_t flags;
+ uint32_t flags;
#define ZEBRA_MAC_LOCAL 0x01
#define ZEBRA_MAC_REMOTE 0x02
#define ZEBRA_MAC_AUTO 0x04 /* Auto created for neighbor. */
int uninstall; /* uninstall from kernel? */
int upd_client; /* uninstall from client? */
- u_int32_t flags;
+ uint32_t flags;
#define DEL_LOCAL_MAC 0x1
#define DEL_REMOTE_MAC 0x2
#define DEL_ALL_MAC (DEL_LOCAL_MAC | DEL_REMOTE_MAC)
struct in_addr r_vtep_ip; /* To walk MACs from specific VTEP */
struct vty *vty; /* Used by VTY handlers */
- u_int32_t count; /* Used by VTY handlers */
+ uint32_t count; /* Used by VTY handlers */
struct json_object *json; /* Used for JSON Output */
};
/* Underlying interface. */
ifindex_t ifindex;
- u_int32_t flags;
+ uint32_t flags;
#define ZEBRA_NEIGH_LOCAL 0x01
#define ZEBRA_NEIGH_REMOTE 0x02
#define ZEBRA_NEIGH_REMOTE_NH 0x04 /* neigh entry for remote vtep */
int uninstall; /* uninstall from kernel? */
int upd_client; /* uninstall from client? */
- u_int32_t flags;
+ uint32_t flags;
#define DEL_LOCAL_NEIGH 0x1
#define DEL_REMOTE_NEIGH 0x2
#define DEL_ALL_NEIGH (DEL_LOCAL_NEIGH | DEL_REMOTE_NEIGH)
struct in_addr r_vtep_ip; /* To walk neighbors from specific VTEP */
struct vty *vty; /* Used by VTY handlers */
- u_int32_t count; /* Used by VTY handlers */
- u_char addr_width; /* Used by VTY handlers */
+ uint32_t count; /* Used by VTY handlers */
+ uint8_t addr_width; /* Used by VTY handlers */
struct json_object *json; /* Used for JSON Output */
};
{
struct stream *s;
unsigned long nump;
- u_char num;
+ uint8_t num;
struct nexthop *nexthop;
/* Get output stream. */
/* Send response to a label manager connect request to client */
static int zsend_label_manager_connect_response(struct zserv *client,
- vrf_id_t vrf_id, u_short result)
+ vrf_id_t vrf_id,
+ unsigned short result)
{
int ret;
struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
struct rnh *rnh;
struct stream *s;
struct prefix p;
- u_short l = 0;
- u_char flags = 0;
+ unsigned short l = 0;
+ uint8_t flags = 0;
uint16_t type = cmd2type[hdr->command];
if (IS_ZEBRA_DEBUG_NHT)
struct rnh *rnh;
struct stream *s;
struct prefix p;
- u_short l = 0;
+ unsigned short l = 0;
uint16_t type = cmd2type[hdr->command];
if (IS_ZEBRA_DEBUG_NHT)
static void zread_fec_register(ZAPI_HANDLER_ARGS)
{
struct stream *s;
- u_short l = 0;
+ unsigned short l = 0;
struct prefix p;
uint16_t flags;
uint32_t label_index = MPLS_INVALID_LABEL_INDEX;
static void zread_fec_unregister(ZAPI_HANDLER_ARGS)
{
struct stream *s;
- u_short l = 0;
+ unsigned short l = 0;
struct prefix p;
uint16_t flags;
int i;
struct route_entry *re;
struct prefix p;
- u_char message;
+ uint8_t message;
struct in_addr nhop_addr;
- u_char nexthop_num;
- u_char nexthop_type;
+ uint8_t nexthop_num;
+ uint8_t nexthop_type;
struct stream *s;
ifindex_t ifindex;
safi_t safi;
struct stream *s;
struct zapi_ipv4 api;
struct prefix p;
- u_int32_t table_id;
+ uint32_t table_id;
s = msg;
struct stream *s;
struct in6_addr nhop_addr;
struct route_entry *re;
- u_char message;
- u_char nexthop_num;
- u_char nexthop_type;
+ uint8_t message;
+ uint8_t nexthop_num;
+ uint8_t nexthop_type;
struct prefix p;
safi_t safi;
static struct in6_addr nexthops[MULTIPATH_NUM];
struct in6_addr nhop_addr;
ifindex_t ifindex;
struct route_entry *re;
- u_char message;
- u_char nexthop_num;
- u_char nexthop_type;
+ uint8_t message;
+ uint8_t nexthop_num;
+ uint8_t nexthop_type;
struct prefix p;
struct prefix_ipv6 src_p, *src_pp;
safi_t safi;
static void zread_hello(ZAPI_HANDLER_ARGS)
{
/* type of protocol (lib/zebra.h) */
- u_char proto;
- u_short instance;
- u_char notify;
+ uint8_t proto;
+ unsigned short instance;
+ uint8_t notify;
STREAM_GETC(msg, proto);
STREAM_GETW(msg, instance);
union g_addr gate;
ifindex_t ifindex;
mpls_label_t in_label, out_label;
- u_int8_t distance;
+ uint8_t distance;
/* Get input stream. */
s = msg;
{
struct stream *s;
/* type of protocol (lib/zebra.h) */
- u_char proto;
- u_short instance;
+ uint8_t proto;
+ unsigned short instance;
/* Get input stream. */
s = msg;
vrf_id_t vrf_id)
{
struct stream *s;
- u_char keep;
+ uint8_t keep;
uint32_t size;
struct label_manager_chunk *lmc;
client->v6_route_del_cnt);
}
-struct zserv *zebra_find_client(u_char proto, u_short instance)
+struct zserv *zebra_find_client(uint8_t proto, unsigned short instance)
{
struct listnode *node, *nnode;
struct zserv *client;
bool notify_owner;
/* client's protocol */
- u_char proto;
- u_short instance;
- u_char is_synchronous;
+ uint8_t proto;
+ unsigned short instance;
+ uint8_t is_synchronous;
/* Statistics */
- u_int32_t redist_v4_add_cnt;
- u_int32_t redist_v4_del_cnt;
- u_int32_t redist_v6_add_cnt;
- u_int32_t redist_v6_del_cnt;
- u_int32_t v4_route_add_cnt;
- u_int32_t v4_route_upd8_cnt;
- u_int32_t v4_route_del_cnt;
- u_int32_t v6_route_add_cnt;
- u_int32_t v6_route_del_cnt;
- u_int32_t v6_route_upd8_cnt;
- u_int32_t connected_rt_add_cnt;
- u_int32_t connected_rt_del_cnt;
- u_int32_t ifup_cnt;
- u_int32_t ifdown_cnt;
- u_int32_t ifadd_cnt;
- u_int32_t ifdel_cnt;
- u_int32_t if_bfd_cnt;
- u_int32_t bfd_peer_add_cnt;
- u_int32_t bfd_peer_upd8_cnt;
- u_int32_t bfd_peer_del_cnt;
- u_int32_t bfd_peer_replay_cnt;
- u_int32_t vrfadd_cnt;
- u_int32_t vrfdel_cnt;
- u_int32_t if_vrfchg_cnt;
- u_int32_t bfd_client_reg_cnt;
- u_int32_t vniadd_cnt;
- u_int32_t vnidel_cnt;
- u_int32_t l3vniadd_cnt;
- u_int32_t l3vnidel_cnt;
- u_int32_t macipadd_cnt;
- u_int32_t macipdel_cnt;
- u_int32_t prefixadd_cnt;
- u_int32_t prefixdel_cnt;
+ uint32_t redist_v4_add_cnt;
+ uint32_t redist_v4_del_cnt;
+ uint32_t redist_v6_add_cnt;
+ uint32_t redist_v6_del_cnt;
+ uint32_t v4_route_add_cnt;
+ uint32_t v4_route_upd8_cnt;
+ uint32_t v4_route_del_cnt;
+ uint32_t v6_route_add_cnt;
+ uint32_t v6_route_del_cnt;
+ uint32_t v6_route_upd8_cnt;
+ uint32_t connected_rt_add_cnt;
+ uint32_t connected_rt_del_cnt;
+ uint32_t ifup_cnt;
+ uint32_t ifdown_cnt;
+ uint32_t ifadd_cnt;
+ uint32_t ifdel_cnt;
+ uint32_t if_bfd_cnt;
+ uint32_t bfd_peer_add_cnt;
+ uint32_t bfd_peer_upd8_cnt;
+ uint32_t bfd_peer_del_cnt;
+ uint32_t bfd_peer_replay_cnt;
+ uint32_t vrfadd_cnt;
+ uint32_t vrfdel_cnt;
+ uint32_t if_vrfchg_cnt;
+ uint32_t bfd_client_reg_cnt;
+ uint32_t vniadd_cnt;
+ uint32_t vnidel_cnt;
+ uint32_t l3vniadd_cnt;
+ uint32_t l3vnidel_cnt;
+ uint32_t macipadd_cnt;
+ uint32_t macipdel_cnt;
+ uint32_t prefixadd_cnt;
+ uint32_t prefixdel_cnt;
time_t connect_time;
time_t last_read_time;
struct list *client_list;
/* default table */
- u_int32_t rtm_table_default;
+ uint32_t rtm_table_default;
/* rib work queue */
#define ZEBRA_RIB_PROCESS_HOLD_TIME 10
struct work_queue *lsp_process_q;
#define ZEBRA_ZAPI_PACKETS_TO_PROCESS 10
- u_int32_t packets_to_process;
+ uint32_t packets_to_process;
};
extern struct zebra_t zebrad;
extern unsigned int multipath_num;
const unsigned int);
extern int zebra_server_send_message(struct zserv *client, struct stream *msg);
-extern struct zserv *zebra_find_client(u_char proto, u_short instance);
+extern struct zserv *zebra_find_client(uint8_t proto, unsigned short instance);
#if defined(HANDLE_ZAPI_FUZZING)
extern void zserv_read_file(char *input);
projects / mirror / frr.git / commitdiff