Index: lib/libkvm/kvm_proc.c =================================================================== RCS file: /cvs/src/lib/libkvm/kvm_proc.c,v retrieving revision 1.58 diff -u -p -r1.58 kvm_proc.c --- lib/libkvm/kvm_proc.c 7 Nov 2016 00:26:33 -0000 1.58 +++ lib/libkvm/kvm_proc.c 21 Jun 2017 00:00:35 -0000 @@ -77,6 +77,7 @@ #include #include #include +#include #include #include #include @@ -108,6 +109,9 @@ static int proc_verify(kvm_t *, const st static void ps_str_a(struct ps_strings *, u_long *, int *); static void ps_str_e(struct ps_strings *, u_long *, int *); +RBT_PROTOTYPE(uvm_map_addr, vm_map_entry, daddrs.addr_entry, + uvm_mapentry_addrcmp); + static struct vm_anon * _kvm_findanon(kvm_t *kd, struct vm_amap *amapp, int slot) { @@ -166,7 +170,6 @@ _kvm_ureadm(kvm_t *kd, const struct kinf struct vm_anon *anonp, anon; struct vm_map_entry vme; struct vm_page pg; - unsigned long rboff; if (kd->swapspc == 0) { kd->swapspc = _kvm_malloc(kd, kd->nbpg); @@ -174,26 +177,23 @@ _kvm_ureadm(kvm_t *kd, const struct kinf return (NULL); } - rboff = (unsigned long)&vme.daddrs.addr_entry - (unsigned long)&vme; - /* * Look through the address map for the memory object * that corresponds to the given virtual address. */ if (KREAD(kd, (u_long)p->p_vmspace, &vm)) return (NULL); - addr = (u_long)&vm.vm_map.addr.rbh_root.rbt_root; + addr = (u_long)RBT_ROOT(uvm_map_addr, &vm.vm_map.addr); while (1) { if (addr == 0) return (NULL); - addr -= rboff; if (KREAD(kd, addr, &vme)) return (NULL); if (va < vme.start) - addr = (u_long)vme.daddrs.addr_entry.rbt_left; + addr = (u_long)RBT_LEFT(uvm_map_addr, &vme); else if (va >= vme.end + vme.guard + vme.fspace) - addr = (u_long)vme.daddrs.addr_entry.rbt_right; + addr = (u_long)RBT_RIGHT(uvm_map_addr, &vme); else if (va >= vme.end) return (NULL); else @@ -543,3 +543,13 @@ kvm_ureadm(kvm_t *kd, const struct kinfo } return (ssize_t)(cp - buf); } + +static inline int +uvm_mapentry_addrcmp(const struct vm_map_entry *e1, + const struct vm_map_entry *e2) +{ + return e1->start < e2->start ? -1 : e1->start > e2->start; +} + +RBT_GENERATE(uvm_map_addr, vm_map_entry, daddrs.addr_entry, + uvm_mapentry_addrcmp); Index: lib/libkvm/shlib_version =================================================================== RCS file: /cvs/src/lib/libkvm/shlib_version,v retrieving revision 1.19 diff -u -p -r1.19 shlib_version --- lib/libkvm/shlib_version 2 Oct 2016 23:11:55 -0000 1.19 +++ lib/libkvm/shlib_version 21 Jun 2017 00:00:35 -0000 @@ -1,2 +1,2 @@ major=16 -minor=2 +minor=3 Index: sbin/iked/config.c =================================================================== RCS file: /cvs/src/sbin/iked/config.c,v retrieving revision 1.48 diff -u -p -r1.48 config.c --- sbin/iked/config.c 13 Apr 2017 07:04:09 -0000 1.48 +++ sbin/iked/config.c 21 Jun 2017 00:00:36 -0000 @@ -105,11 +105,11 @@ config_free_sa(struct iked *env, struct sa_free_flows(env, &sa->sa_flows); if (sa->sa_addrpool) { - (void)RB_REMOVE(iked_addrpool, &env->sc_addrpool, sa); + (void)RBT_REMOVE(iked_addrpool, &env->sc_addrpool, sa); free(sa->sa_addrpool); } if (sa->sa_addrpool6) { - (void)RB_REMOVE(iked_addrpool6, &env->sc_addrpool6, sa); + (void)RBT_REMOVE(iked_addrpool6, &env->sc_addrpool6, sa); free(sa->sa_addrpool6); } @@ -170,7 +170,7 @@ config_new_policy(struct iked *env) /* XXX caller does this again */ TAILQ_INIT(&pol->pol_proposals); TAILQ_INIT(&pol->pol_sapeers); - RB_INIT(&pol->pol_flows); + RBT_INIT(iked_flows, &pol->pol_flows); return (pol); } @@ -252,10 +252,10 @@ config_free_flows(struct iked *env, stru { struct iked_flow *flow, *next; - for (flow = RB_MIN(iked_flows, head); flow != NULL; flow = next) { - next = RB_NEXT(iked_flows, head, flow); + for (flow = RBT_MIN(iked_flows, head); flow != NULL; flow = next) { + next = RBT_NEXT(iked_flows, flow); log_debug("%s: free %p", __func__, flow); - RB_REMOVE(iked_flows, head, flow); + RBT_REMOVE(iked_flows, head, flow); flow_free(flow); } } @@ -286,7 +286,7 @@ config_free_childsas(struct iked *env, s TAILQ_REMOVE(head, csa, csa_entry); if (csa->csa_loaded) { - RB_REMOVE(iked_activesas, &env->sc_activesas, csa); + RBT_REMOVE(iked_activesas, &env->sc_activesas, csa); (void)pfkey_sa_delete(env->sc_pfkey, csa); } childsa_free(csa); @@ -401,7 +401,7 @@ config_new_user(struct iked *env, struct memcpy(usr, new, sizeof(*usr)); - if ((old = RB_INSERT(iked_users, &env->sc_users, usr)) != NULL) { + if ((old = RBT_INSERT(iked_users, &env->sc_users, usr)) != NULL) { /* Update the password of an existing user*/ memcpy(old, new, sizeof(*old)); @@ -495,20 +495,20 @@ config_getreset(struct iked *env, struct if (mode == RESET_ALL || mode == RESET_SA) { log_debug("%s: flushing SAs", __func__); - for (sa = RB_MIN(iked_sas, &env->sc_sas); + for (sa = RBT_MIN(iked_sas, &env->sc_sas); sa != NULL; sa = nextsa) { - nextsa = RB_NEXT(iked_sas, &env->sc_sas, sa); - RB_REMOVE(iked_sas, &env->sc_sas, sa); + nextsa = RBT_NEXT(iked_sas, sa); + RBT_REMOVE(iked_sas, &env->sc_sas, sa); config_free_sa(env, sa); } } if (mode == RESET_ALL || mode == RESET_USER) { log_debug("%s: flushing users", __func__); - for (usr = RB_MIN(iked_users, &env->sc_users); + for (usr = RBT_MIN(iked_users, &env->sc_users); usr != NULL; usr = nextusr) { - nextusr = RB_NEXT(iked_users, &env->sc_users, usr); - RB_REMOVE(iked_users, &env->sc_users, usr); + nextusr = RBT_NEXT(iked_users, usr); + RBT_REMOVE(iked_users, &env->sc_users, usr); free(usr); } } @@ -679,7 +679,7 @@ config_setflow(struct iked *env, struct if (env->sc_opts & IKED_OPT_NOACTION) return (0); - RB_FOREACH(flow, iked_flows, &pol->pol_flows) { + RBT_FOREACH(flow, iked_flows, &pol->pol_flows) { iov[0].iov_base = &pol->pol_id; iov[0].iov_len = sizeof(pol->pol_id); iov[1].iov_base = flow; @@ -716,7 +716,7 @@ config_getpolicy(struct iked *env, struc TAILQ_INIT(&pol->pol_proposals); TAILQ_INIT(&pol->pol_sapeers); - RB_INIT(&pol->pol_flows); + RBT_INIT(iked_flows, &pol->pol_flows); for (i = 0; i < pol->pol_nproposals; i++) { memcpy(&pp, buf + offset, sizeof(pp)); @@ -781,7 +781,7 @@ config_getflow(struct iked *env, struct memcpy(flow, buf + offset, sizeof(*flow)); - if (RB_INSERT(iked_flows, &pol->pol_flows, flow)) { + if (RBT_INSERT(iked_flows, &pol->pol_flows, flow)) { log_warnx("%s: received duplicate flow", __func__); free(flow); return (-1); Index: sbin/iked/iked.h =================================================================== RCS file: /cvs/src/sbin/iked/iked.h,v retrieving revision 1.115 diff -u -p -r1.115 iked.h --- sbin/iked/iked.h 26 Apr 2017 10:42:38 -0000 1.115 +++ sbin/iked/iked.h 21 Jun 2017 00:00:36 -0000 @@ -155,11 +155,11 @@ struct iked_flow { struct iked_addr *flow_peer; /* outer dest */ struct iked_sa *flow_ikesa; /* parent SA */ - RB_ENTRY(iked_flow) flow_node; + RBT_ENTRY(iked_flow) flow_node; TAILQ_ENTRY(iked_flow) flow_entry; int flow_ipcomp; }; -RB_HEAD(iked_flows, iked_flow); +RBT_HEAD(iked_flows, iked_flow); TAILQ_HEAD(iked_saflows, iked_flow); struct iked_childsa { @@ -192,10 +192,10 @@ struct iked_childsa { struct iked_childsa *csa_parent; /* IPCOMP parent */ unsigned int csa_children; /* IPCOMP children */ - RB_ENTRY(iked_childsa) csa_node; + RBT_ENTRY(iked_childsa) csa_node; TAILQ_ENTRY(iked_childsa) csa_entry; }; -RB_HEAD(iked_activesas, iked_childsa); +RBT_HEAD(iked_activesas, iked_childsa); TAILQ_HEAD(iked_childsas, iked_childsa); @@ -459,17 +459,17 @@ struct iked_sa { #define IKED_RESPONSE_TIMEOUT 120 /* 2 minutes */ TAILQ_ENTRY(iked_sa) sa_peer_entry; - RB_ENTRY(iked_sa) sa_entry; + RBT_ENTRY(iked_sa) sa_entry; struct iked_addr *sa_addrpool; /* address from pool */ - RB_ENTRY(iked_sa) sa_addrpool_entry; /* pool entries */ + RBT_ENTRY(iked_sa) sa_addrpool_entry; /* pool entries */ struct iked_addr *sa_addrpool6; /* address from pool */ - RB_ENTRY(iked_sa) sa_addrpool6_entry; /* pool entries */ + RBT_ENTRY(iked_sa) sa_addrpool6_entry; /* pool entries */ }; -RB_HEAD(iked_sas, iked_sa); -RB_HEAD(iked_addrpool, iked_sa); -RB_HEAD(iked_addrpool6, iked_sa); +RBT_HEAD(iked_sas, iked_sa); +RBT_HEAD(iked_addrpool, iked_sa); +RBT_HEAD(iked_addrpool6, iked_sa); struct iked_message { struct ibuf *msg_data; @@ -523,9 +523,9 @@ struct iked_message { struct iked_user { char usr_name[LOGIN_NAME_MAX]; char usr_pass[IKED_PASSWORD_SIZE]; - RB_ENTRY(iked_user) usr_entry; + RBT_ENTRY(iked_user) usr_entry; }; -RB_HEAD(iked_users, iked_user); +RBT_HEAD(iked_users, iked_user); struct privsep_pipes { int *pp_pipes[PROC_MAX]; @@ -715,12 +715,12 @@ struct iked_sa * sa_lookup(struct iked *, uint64_t, uint64_t, unsigned int); struct iked_user * user_lookup(struct iked *, const char *); -RB_PROTOTYPE(iked_sas, iked_sa, sa_entry, sa_cmp); -RB_PROTOTYPE(iked_addrpool, iked_sa, sa_addrpool_entry, sa_addrpool_cmp); -RB_PROTOTYPE(iked_addrpool6, iked_sa, sa_addrpool6_entry, sa_addrpool6_cmp); -RB_PROTOTYPE(iked_users, iked_user, user_entry, user_cmp); -RB_PROTOTYPE(iked_activesas, iked_childsa, csa_node, childsa_cmp); -RB_PROTOTYPE(iked_flows, iked_flow, flow_node, flow_cmp); +RBT_PROTOTYPE(iked_sas, iked_sa, sa_entry, sa_cmp); +RBT_PROTOTYPE(iked_addrpool, iked_sa, sa_addrpool_entry, sa_addrpool_cmp); +RBT_PROTOTYPE(iked_addrpool6, iked_sa, sa_addrpool6_entry, sa_addrpool6_cmp); +RBT_PROTOTYPE(iked_users, iked_user, user_entry, user_cmp); +RBT_PROTOTYPE(iked_activesas, iked_childsa, csa_node, childsa_cmp); +RBT_PROTOTYPE(iked_flows, iked_flow, flow_node, flow_cmp); /* crypto.c */ struct iked_hash * @@ -938,7 +938,7 @@ void print_hex(uint8_t *, off_t, size_t void print_hexval(uint8_t *, off_t, size_t); const char * print_bits(unsigned short, unsigned char *); -int sockaddr_cmp(struct sockaddr *, struct sockaddr *, int); +int sockaddr_cmp(const struct sockaddr *, const struct sockaddr *, int); uint8_t mask2prefixlen(struct sockaddr *); uint8_t mask2prefixlen6(struct sockaddr *); struct in6_addr * Index: sbin/iked/ikev2.c =================================================================== RCS file: /cvs/src/sbin/iked/ikev2.c,v retrieving revision 1.155 diff -u -p -r1.155 ikev2.c --- sbin/iked/ikev2.c 1 Jun 2017 15:23:43 -0000 1.155 +++ sbin/iked/ikev2.c 21 Jun 2017 00:00:36 -0000 @@ -1381,7 +1381,7 @@ ikev2_add_ts_payload(struct ibuf *buf, u tsp->tsp_count = pol->pol_nflows; len = sizeof(*tsp); - RB_FOREACH(flow, iked_flows, &pol->pol_flows) { + RBT_FOREACH(flow, iked_flows, &pol->pol_flows) { if ((ts = ibuf_advance(buf, sizeof(*ts))) == NULL) return (-1); @@ -3214,16 +3214,16 @@ ikev2_ikesa_enable(struct iked *env, str /* Transfer sa_addrpool address */ if (sa->sa_addrpool) { - RB_REMOVE(iked_addrpool, &env->sc_addrpool, sa); + RBT_REMOVE(iked_addrpool, &env->sc_addrpool, sa); nsa->sa_addrpool = sa->sa_addrpool; sa->sa_addrpool = NULL; - RB_INSERT(iked_addrpool, &env->sc_addrpool, nsa); + RBT_INSERT(iked_addrpool, &env->sc_addrpool, nsa); } if (sa->sa_addrpool6) { - RB_REMOVE(iked_addrpool6, &env->sc_addrpool6, sa); + RBT_REMOVE(iked_addrpool6, &env->sc_addrpool6, sa); nsa->sa_addrpool6 = sa->sa_addrpool6; sa->sa_addrpool6 = NULL; - RB_INSERT(iked_addrpool6, &env->sc_addrpool6, nsa); + RBT_INSERT(iked_addrpool6, &env->sc_addrpool6, nsa); } /* Transfer other attributes */ if (sa->sa_tag) { @@ -4756,7 +4756,7 @@ ikev2_childsa_negotiate(struct iked *env if (ikev2_valid_proposal(prop, NULL, NULL, NULL) != 0) continue; - RB_FOREACH(flow, iked_flows, &sa->sa_policy->pol_flows) { + RBT_FOREACH(flow, iked_flows, &sa->sa_policy->pol_flows) { if ((flowa = calloc(1, sizeof(*flowa))) == NULL) { log_debug("%s: failed to get flow", __func__); @@ -4926,7 +4926,7 @@ ikev2_ipcomp_csa_free(struct iked *env, log_debug("%s: csa %p loaded: calling pfkey_sa_delete", __func__, csa); pfkey_sa_delete(env->sc_pfkey, csa); - RB_REMOVE(iked_activesas, &env->sc_activesas, csa); + RBT_REMOVE(iked_activesas, &env->sc_activesas, csa); } childsa_free(csa); } @@ -5094,17 +5094,17 @@ ikev2_childsa_enable(struct iked *env, s return (-1); } - if ((ocsa = RB_FIND(iked_activesas, &env->sc_activesas, csa)) + if ((ocsa = RBT_FIND(iked_activesas, &env->sc_activesas, csa)) != NULL) { log_debug("%s: replaced CHILD SA %p with %p spi %s", __func__, ocsa, csa, print_spi(ocsa->csa_spi.spi, ocsa->csa_spi.spi_size)); ocsa->csa_loaded = 0; ocsa->csa_rekey = 1; /* prevent re-loading */ - RB_REMOVE(iked_activesas, &env->sc_activesas, ocsa); + RBT_REMOVE(iked_activesas, &env->sc_activesas, ocsa); } - RB_INSERT(iked_activesas, &env->sc_activesas, csa); + RBT_INSERT(iked_activesas, &env->sc_activesas, csa); log_debug("%s: loaded CHILD SA spi %s", __func__, print_spi(csa->csa_spi.spi, csa->csa_spi.spi_size)); @@ -5119,15 +5119,15 @@ ikev2_childsa_enable(struct iked *env, s return (-1); } - if ((oflow = RB_FIND(iked_flows, &env->sc_activeflows, flow)) + if ((oflow = RBT_FIND(iked_flows, &env->sc_activeflows, flow)) != NULL) { log_debug("%s: replaced old flow %p with %p", __func__, oflow, flow); oflow->flow_loaded = 0; - RB_REMOVE(iked_flows, &env->sc_activeflows, oflow); + RBT_REMOVE(iked_flows, &env->sc_activeflows, oflow); } - RB_INSERT(iked_flows, &env->sc_activeflows, flow); + RBT_INSERT(iked_flows, &env->sc_activeflows, flow); log_debug("%s: loaded flow %p", __func__, flow); } @@ -5153,7 +5153,7 @@ ikev2_childsa_delete(struct iked *env, s continue; if (csa->csa_loaded) - RB_REMOVE(iked_activesas, &env->sc_activesas, csa); + RBT_REMOVE(iked_activesas, &env->sc_activesas, csa); if (pfkey_sa_delete(env->sc_pfkey, csa) != 0) log_debug("%s: failed to delete CHILD SA spi %s", @@ -5251,7 +5251,7 @@ ikev2_acquire_sa(struct iked *env, struc return (0); /* First try to find an active flow with IKE SA */ - flow = RB_FIND(iked_flows, &env->sc_activeflows, acquire); + flow = RBT_FIND(iked_flows, &env->sc_activeflows, acquire); if (!flow) { /* Otherwise try to find a matching policy */ bzero(&pol, sizeof(pol)); @@ -5259,8 +5259,8 @@ ikev2_acquire_sa(struct iked *env, struc memcpy(&pol.pol_peer, acquire->flow_peer, sizeof(pol.pol_peer)); - RB_INIT(&pol.pol_flows); - RB_INSERT(iked_flows, &pol.pol_flows, acquire); + RBT_INIT(iked_flows, &pol.pol_flows); + RBT_INSERT(iked_flows, &pol.pol_flows, acquire); pol.pol_nflows = 1; if ((p = policy_test(env, &pol)) == NULL) { @@ -5313,7 +5313,7 @@ ikev2_rekey_sa(struct iked *env, struct struct iked_sa *sa; key.csa_spi = *rekey; - csa = RB_FIND(iked_activesas, &env->sc_activesas, &key); + csa = RBT_FIND(iked_activesas, &env->sc_activesas, &key); if (!csa) return (0); @@ -5355,7 +5355,7 @@ ikev2_drop_sa(struct iked *env, struct i int acquired; key.csa_spi = *drop; - csa = RB_FIND(iked_activesas, &env->sc_activesas, &key); + csa = RBT_FIND(iked_activesas, &env->sc_activesas, &key); if (!csa || csa->csa_rekey) return (0); @@ -5367,7 +5367,7 @@ ikev2_drop_sa(struct iked *env, struct i return (-1); /* busy, retry later */ } - RB_REMOVE(iked_activesas, &env->sc_activesas, csa); + RBT_REMOVE(iked_activesas, &env->sc_activesas, csa); csa->csa_loaded = 0; csa->csa_rekey = 1; /* prevent re-loading */ if (sa == NULL) { @@ -5626,9 +5626,9 @@ ikev2_cp_setaddr(struct iked *env, struc break; } if ((addr.addr_af == AF_INET && - !RB_FIND(iked_addrpool, &env->sc_addrpool, &key)) || + !RBT_FIND(iked_addrpool, &env->sc_addrpool, &key)) || (addr.addr_af == AF_INET6 && - !RB_FIND(iked_addrpool6, &env->sc_addrpool6, &key))) + !RBT_FIND(iked_addrpool6, &env->sc_addrpool6, &key))) break; /* try next address */ host++; @@ -5648,7 +5648,7 @@ ikev2_cp_setaddr(struct iked *env, struc if ((sa->sa_addrpool = calloc(1, sizeof(addr))) == NULL) return (-1); memcpy(sa->sa_addrpool, &addr, sizeof(addr)); - RB_INSERT(iked_addrpool, &env->sc_addrpool, sa); + RBT_INSERT(iked_addrpool, &env->sc_addrpool, sa); break; case AF_INET6: if (!key.sa_addrpool6) @@ -5656,7 +5656,7 @@ ikev2_cp_setaddr(struct iked *env, struc if ((sa->sa_addrpool6 = calloc(1, sizeof(addr))) == NULL) return (-1); memcpy(sa->sa_addrpool6, &addr, sizeof(addr)); - RB_INSERT(iked_addrpool6, &env->sc_addrpool6, sa); + RBT_INSERT(iked_addrpool6, &env->sc_addrpool6, sa); break; default: return (-1); Index: sbin/iked/parse.y =================================================================== RCS file: /cvs/src/sbin/iked/parse.y,v retrieving revision 1.65 diff -u -p -r1.65 parse.y --- sbin/iked/parse.y 24 Apr 2017 07:07:25 -0000 1.65 +++ sbin/iked/parse.y 21 Jun 2017 00:00:36 -0000 @@ -2395,7 +2395,7 @@ print_policy(struct iked_policy *pol) print_verbose(" inet6"); } - RB_FOREACH(flow, iked_flows, &pol->pol_flows) { + RBT_FOREACH(flow, iked_flows, &pol->pol_flows) { print_verbose(" from %s", print_host((struct sockaddr *)&flow->flow_src.addr, NULL, 0)); @@ -2707,7 +2707,7 @@ create_ike(char *name, int af, uint8_t i pol.pol_lifetime = deflifetime; TAILQ_INIT(&pol.pol_proposals); - RB_INIT(&pol.pol_flows); + RBT_INIT(iked_flows, &pol.pol_flows); prop[0].prop_id = ++pol.pol_nproposals; prop[0].prop_protoid = IKEV2_SAPROTO_IKE; @@ -2815,7 +2815,7 @@ create_ike(char *name, int af, uint8_t i flows[j].flow_ipproto = ipproto; - if (RB_INSERT(iked_flows, &pol.pol_flows, &flows[j]) == NULL) + if (RBT_INSERT(iked_flows, &pol.pol_flows, &flows[j]) == NULL) pol.pol_nflows++; else warnx("create_ike: duplicate flow"); Index: sbin/iked/pfkey.c =================================================================== RCS file: /cvs/src/sbin/iked/pfkey.c,v retrieving revision 1.58 diff -u -p -r1.58 pfkey.c --- sbin/iked/pfkey.c 18 Apr 2017 02:29:56 -0000 1.58 +++ sbin/iked/pfkey.c 21 Jun 2017 00:00:36 -0000 @@ -136,7 +136,7 @@ pfkey_couple(int sd, struct iked_sas *sa /* Allow writes to the PF_KEY socket */ sadb_decoupled = 0; - RB_FOREACH(sa, iked_sas, sas) { + RBT_FOREACH(sa, iked_sas, sas) { TAILQ_FOREACH(csa, &sa->sa_childsas, csa_entry) { if (!csa->csa_loaded && couple) (void)pfkey_sa_add(sd, csa, NULL); Index: sbin/iked/policy.c =================================================================== RCS file: /cvs/src/sbin/iked/policy.c,v retrieving revision 1.46 diff -u -p -r1.46 policy.c --- sbin/iked/policy.c 13 Mar 2017 18:48:16 -0000 1.46 +++ sbin/iked/policy.c 21 Jun 2017 00:00:36 -0000 @@ -24,6 +24,7 @@ #include #include +#include #include #include #include @@ -34,13 +35,13 @@ #include "ikev2.h" static __inline int - sa_cmp(struct iked_sa *, struct iked_sa *); + sa_cmp(const struct iked_sa *, const struct iked_sa *); static __inline int - user_cmp(struct iked_user *, struct iked_user *); + user_cmp(const struct iked_user *, const struct iked_user *); static __inline int - childsa_cmp(struct iked_childsa *, struct iked_childsa *); + childsa_cmp(const struct iked_childsa *, const struct iked_childsa *); static __inline int - flow_cmp(struct iked_flow *, struct iked_flow *); + flow_cmp(const struct iked_flow *, const struct iked_flow *); void @@ -48,10 +49,10 @@ policy_init(struct iked *env) { TAILQ_INIT(&env->sc_policies); TAILQ_INIT(&env->sc_ocsp); - RB_INIT(&env->sc_users); - RB_INIT(&env->sc_sas); - RB_INIT(&env->sc_activesas); - RB_INIT(&env->sc_activeflows); + RBT_INIT(iked_users, &env->sc_users); + RBT_INIT(iked_sas, &env->sc_sas); + RBT_INIT(iked_activesas, &env->sc_activesas); + RBT_INIT(iked_flows, &env->sc_activeflows); } int @@ -129,9 +130,9 @@ policy_test(struct iked *env, struct ike * and find a matching flow. */ if (key->pol_nflows && - (flowkey = RB_MIN(iked_flows, + (flowkey = RBT_MIN(iked_flows, &key->pol_flows)) != NULL && - (flow = RB_FIND(iked_flows, &p->pol_flows, + (flow = RBT_FIND(iked_flows, &p->pol_flows, flowkey)) == NULL) { p = TAILQ_NEXT(p, pol_entry); continue; @@ -332,7 +333,7 @@ sa_new(struct iked *env, uint64_t ispi, } if (!initiator) sa->sa_hdr.sh_ispi = ispi; - old = RB_INSERT(iked_sas, &env->sc_sas, sa); + old = RBT_INSERT(iked_sas, &env->sc_sas, sa); if (old && old != sa) { log_warnx("%s: duplicate IKE SA", __func__); config_free_sa(env, sa); @@ -393,14 +394,14 @@ sa_free(struct iked *env, struct iked_sa /* IKE rekeying running? */ if (sa->sa_nexti) { - RB_REMOVE(iked_sas, &env->sc_sas, sa->sa_nexti); + RBT_REMOVE(iked_sas, &env->sc_sas, sa->sa_nexti); config_free_sa(env, sa->sa_nexti); } if (sa->sa_nextr) { - RB_REMOVE(iked_sas, &env->sc_sas, sa->sa_nextr); + RBT_REMOVE(iked_sas, &env->sc_sas, sa->sa_nextr); config_free_sa(env, sa->sa_nextr); } - RB_REMOVE(iked_sas, &env->sc_sas, sa); + RBT_REMOVE(iked_sas, &env->sc_sas, sa); config_free_sa(env, sa); } @@ -415,7 +416,7 @@ sa_free_flows(struct iked *env, struct i log_debug("%s: free %p", __func__, flow); if (flow->flow_loaded) - RB_REMOVE(iked_flows, &env->sc_activeflows, flow); + RBT_REMOVE(iked_flows, &env->sc_activeflows, flow); TAILQ_REMOVE(head, flow, flow_entry); (void)pfkey_flow_delete(env->sc_pfkey, flow); flow_free(flow); @@ -490,7 +491,7 @@ sa_lookup(struct iked *env, uint64_t isp /* key.sa_hdr.sh_rspi = rspi; */ key.sa_hdr.sh_initiator = initiator; - if ((sa = RB_FIND(iked_sas, &env->sc_sas, &key)) != NULL) { + if ((sa = RBT_FIND(iked_sas, &env->sc_sas, &key)) != NULL) { gettimeofday(&sa->sa_timeused, NULL); /* Validate if SPIr matches */ @@ -504,7 +505,7 @@ sa_lookup(struct iked *env, uint64_t isp } static __inline int -sa_cmp(struct iked_sa *a, struct iked_sa *b) +sa_cmp(const struct iked_sa *a, const struct iked_sa *b) { if (a->sa_hdr.sh_initiator > b->sa_hdr.sh_initiator) return (-1); @@ -532,14 +533,14 @@ sa_cmp(struct iked_sa *a, struct iked_sa } static __inline int -sa_addrpool_cmp(struct iked_sa *a, struct iked_sa *b) +sa_addrpool_cmp(const struct iked_sa *a, const struct iked_sa *b) { return (sockaddr_cmp((struct sockaddr *)&a->sa_addrpool->addr, (struct sockaddr *)&b->sa_addrpool->addr, -1)); } static __inline int -sa_addrpool6_cmp(struct iked_sa *a, struct iked_sa *b) +sa_addrpool6_cmp(const struct iked_sa *a, const struct iked_sa *b) { return (sockaddr_cmp((struct sockaddr *)&a->sa_addrpool6->addr, (struct sockaddr *)&b->sa_addrpool6->addr, -1)); @@ -554,17 +555,17 @@ user_lookup(struct iked *env, const char sizeof(key.usr_name)) >= sizeof(key.usr_name)) return (NULL); - return (RB_FIND(iked_users, &env->sc_users, &key)); + return (RBT_FIND(iked_users, &env->sc_users, &key)); } static __inline int -user_cmp(struct iked_user *a, struct iked_user *b) +user_cmp(const struct iked_user *a, const struct iked_user *b) { return (strcmp(a->usr_name, b->usr_name)); } static __inline int -childsa_cmp(struct iked_childsa *a, struct iked_childsa *b) +childsa_cmp(const struct iked_childsa *a, const struct iked_childsa *b) { if (a->csa_spi.spi > b->csa_spi.spi) return (1); @@ -574,12 +575,12 @@ childsa_cmp(struct iked_childsa *a, stru } static __inline int -addr_cmp(struct iked_addr *a, struct iked_addr *b, int useports) +addr_cmp(const struct iked_addr *a, const struct iked_addr *b, int useports) { int diff = 0; - diff = sockaddr_cmp((struct sockaddr *)&a->addr, - (struct sockaddr *)&b->addr, 128); + diff = sockaddr_cmp((const struct sockaddr *)&a->addr, + (const struct sockaddr *)&b->addr, 128); if (!diff) diff = (int)a->addr_mask - (int)b->addr_mask; if (!diff && useports) @@ -589,7 +590,7 @@ addr_cmp(struct iked_addr *a, struct ike } static __inline int -flow_cmp(struct iked_flow *a, struct iked_flow *b) +flow_cmp(const struct iked_flow *a, const struct iked_flow *b) { int diff = 0; @@ -613,9 +614,9 @@ flow_equal(struct iked_flow *a, struct i return (flow_cmp(a, b) == 0); } -RB_GENERATE(iked_sas, iked_sa, sa_entry, sa_cmp); -RB_GENERATE(iked_addrpool, iked_sa, sa_addrpool_entry, sa_addrpool_cmp); -RB_GENERATE(iked_addrpool6, iked_sa, sa_addrpool6_entry, sa_addrpool6_cmp); -RB_GENERATE(iked_users, iked_user, usr_entry, user_cmp); -RB_GENERATE(iked_activesas, iked_childsa, csa_node, childsa_cmp); -RB_GENERATE(iked_flows, iked_flow, flow_node, flow_cmp); +RBT_GENERATE(iked_sas, iked_sa, sa_entry, sa_cmp); +RBT_GENERATE(iked_addrpool, iked_sa, sa_addrpool_entry, sa_addrpool_cmp); +RBT_GENERATE(iked_addrpool6, iked_sa, sa_addrpool6_entry, sa_addrpool6_cmp); +RBT_GENERATE(iked_users, iked_user, usr_entry, user_cmp); +RBT_GENERATE(iked_activesas, iked_childsa, csa_node, childsa_cmp); +RBT_GENERATE(iked_flows, iked_flow, flow_node, flow_cmp); Index: sbin/iked/util.c =================================================================== RCS file: /cvs/src/sbin/iked/util.c,v retrieving revision 1.33 diff -u -p -r1.33 util.c --- sbin/iked/util.c 9 Jan 2017 14:49:21 -0000 1.33 +++ sbin/iked/util.c 21 Jun 2017 00:00:36 -0000 @@ -220,7 +220,7 @@ udp_bind(struct sockaddr *sa, in_port_t } int -sockaddr_cmp(struct sockaddr *a, struct sockaddr *b, int prefixlen) +sockaddr_cmp(const struct sockaddr *a, const struct sockaddr *b, int prefixlen) { struct sockaddr_in *a4, *b4; struct sockaddr_in6 *a6, *b6; Index: sbin/init/init.c =================================================================== RCS file: /cvs/src/sbin/init/init.c,v retrieving revision 1.65 diff -u -p -r1.65 init.c --- sbin/init/init.c 16 Jun 2017 06:46:54 -0000 1.65 +++ sbin/init/init.c 21 Jun 2017 00:00:36 -0000 @@ -49,6 +49,7 @@ #include #include #include +#include #include #include #include @@ -158,13 +159,14 @@ typedef struct init_session { char **se_window_argv; /* pre-parsed argument array */ struct init_session *se_prev; struct init_session *se_next; - RB_ENTRY(init_session) se_entry; + RBT_ENTRY(init_session) se_entry; } session_t; -static int cmp_sessions(session_t *, session_t *); -RB_HEAD(session_tree, init_session) session_tree = RB_INITIALIZER(session_tree); -RB_PROTOTYPE(session_tree, init_session, se_entry, cmp_sessions); -RB_GENERATE(session_tree, init_session, se_entry, cmp_sessions); +static int cmp_sessions(const session_t *, const session_t *); +RBT_HEAD(session_tree, init_session) session_tree = + RBT_INITIALIZER(session_tree); +RBT_PROTOTYPE(session_tree, init_session, se_entry, cmp_sessions); +RBT_GENERATE(session_tree, init_session, se_entry, cmp_sessions); void free_session(session_t *); session_t *new_session(session_t *, int, struct ttyent *); @@ -778,7 +780,7 @@ f_runcom(void) * Compare session keys. */ static int -cmp_sessions(session_t *sp1, session_t *sp2) +cmp_sessions(const session_t *sp1, const session_t *sp2) { if (sp1->se_process < sp2->se_process) return (-1); @@ -793,7 +795,7 @@ cmp_sessions(session_t *sp1, session_t * void add_session(session_t *sp) { - if (RB_INSERT(session_tree, &session_tree, sp) != NULL) + if (RBT_INSERT(session_tree, &session_tree, sp) != NULL) emergency("insert %d: %s", sp->se_process, strerror(errno)); } @@ -803,7 +805,7 @@ add_session(session_t *sp) void del_session(session_t *sp) { - RB_REMOVE(session_tree, &session_tree, sp); + RBT_REMOVE(session_tree, &session_tree, sp); } /* @@ -815,7 +817,7 @@ find_session(pid_t pid) struct init_session s; s.se_process = pid; - return (RB_FIND(session_tree, &session_tree, &s)); + return (RBT_FIND(session_tree, &session_tree, &s)); } /* Index: sbin/pfctl/pfctl.c =================================================================== RCS file: /cvs/src/sbin/pfctl/pfctl.c,v retrieving revision 1.345 diff -u -p -r1.345 pfctl.c --- sbin/pfctl/pfctl.c 16 Jun 2017 19:59:13 -0000 1.345 +++ sbin/pfctl/pfctl.c 21 Jun 2017 00:00:36 -0000 @@ -1543,7 +1543,7 @@ pfctl_rules(int dev, char *filename, int char *p; bzero(&pf, sizeof(pf)); - RB_INIT(&pf_anchors); + RBT_INIT(pf_anchor_global, &pf_anchors); memset(&pf_main_anchor, 0, sizeof(pf_main_anchor)); pf_init_ruleset(&pf_main_anchor.ruleset); pf_main_anchor.ruleset.anchor = &pf_main_anchor; Index: sys/net/if_pfsync.c =================================================================== RCS file: /cvs/src/sys/net/if_pfsync.c,v retrieving revision 1.253 diff -u -p -r1.253 if_pfsync.c --- sys/net/if_pfsync.c 9 Jun 2017 17:43:06 -0000 1.253 +++ sys/net/if_pfsync.c 21 Jun 2017 00:00:37 -0000 @@ -766,8 +766,8 @@ pfsync_in_clr(caddr_t buf, int len, int (kif = pfi_kif_find(clr->ifname)) == NULL) continue; - for (st = RB_MIN(pf_state_tree_id, &tree_id); st; st = nexts) { - nexts = RB_NEXT(pf_state_tree_id, &tree_id, st); + for (st = RBT_MIN(pf_state_tree_id, &tree_id); st; st = nexts) { + nexts = RBT_NEXT(pf_state_tree_id, st); if (st->creatorid == creatorid && ((kif && st->kif == kif) || !kif)) { SET(st->state_flags, PFSTATE_NOSYNC); Index: sys/net/pf.c =================================================================== RCS file: /cvs/src/sys/net/pf.c,v retrieving revision 1.1034 diff -u -p -r1.1034 pf.c --- sys/net/pf.c 5 Jun 2017 22:18:28 -0000 1.1034 +++ sys/net/pf.c 21 Jun 2017 00:00:37 -0000 @@ -300,11 +300,12 @@ struct pf_pool_limit pf_pool_limits[PF_L mrm->r->states_cur++; \ } while (0) -static __inline int pf_src_compare(struct pf_src_node *, struct pf_src_node *); -static __inline int pf_state_compare_key(struct pf_state_key *, - struct pf_state_key *); -static __inline int pf_state_compare_id(struct pf_state *, - struct pf_state *); +static __inline int pf_src_compare(const struct pf_src_node *, + const struct pf_src_node *); +static __inline int pf_state_compare_key(const struct pf_state_key *, + const struct pf_state_key *); +static __inline int pf_state_compare_id(const struct pf_state *, + const struct pf_state *); static __inline void pf_cksum_uncover(u_int16_t *, u_int16_t, u_int8_t); static __inline void pf_cksum_cover(u_int16_t *, u_int16_t, u_int8_t); @@ -313,16 +314,16 @@ struct pf_src_tree tree_src_tracking; struct pf_state_tree_id tree_id; struct pf_state_queue state_list; -RB_GENERATE(pf_src_tree, pf_src_node, entry, pf_src_compare); -RB_GENERATE(pf_state_tree, pf_state_key, entry, pf_state_compare_key); -RB_GENERATE(pf_state_tree_id, pf_state, - entry_id, pf_state_compare_id); +RBT_GENERATE(pf_src_tree, pf_src_node, entry, pf_src_compare); +RBT_GENERATE(pf_state_tree, pf_state_key, entry, pf_state_compare_key); +RBT_GENERATE(pf_state_tree_id, pf_state, entry_id, pf_state_compare_id); SLIST_HEAD(pf_rule_gcl, pf_rule) pf_rule_gcl = SLIST_HEAD_INITIALIZER(pf_rule_gcl); __inline int -pf_addr_compare(struct pf_addr *a, struct pf_addr *b, sa_family_t af) +pf_addr_compare(const struct pf_addr *a, const struct pf_addr *b, + sa_family_t af) { switch (af) { case AF_INET: @@ -356,7 +357,7 @@ pf_addr_compare(struct pf_addr *a, struc } static __inline int -pf_src_compare(struct pf_src_node *a, struct pf_src_node *b) +pf_src_compare(const struct pf_src_node *a, const struct pf_src_node *b) { int diff; @@ -487,7 +488,7 @@ pf_src_connlimit(struct pf_state **state struct pf_state *st; pf_status.lcounters[LCNT_OVERLOAD_FLUSH]++; - RB_FOREACH(st, pf_state_tree_id, &tree_id) { + RBT_FOREACH(st, pf_state_tree_id, &tree_id) { sk = st->key[PF_SK_WIRE]; /* * Kill states from this source. (Only those @@ -535,7 +536,7 @@ pf_insert_src_node(struct pf_src_node ** PF_ACPY(&k.addr, src, af); k.rule.ptr = rule; pf_status.scounters[SCNT_SRC_NODE_SEARCH]++; - *sn = RB_FIND(pf_src_tree, &tree_src_tracking, &k); + *sn = RBT_FIND(pf_src_tree, &tree_src_tracking, &k); } if (*sn == NULL) { if (!rule->max_src_nodes || @@ -556,7 +557,7 @@ pf_insert_src_node(struct pf_src_node ** PF_ACPY(&(*sn)->addr, src, af); if (raddr) PF_ACPY(&(*sn)->raddr, raddr, af); - if (RB_INSERT(pf_src_tree, + if (RBT_INSERT(pf_src_tree, &tree_src_tracking, *sn) != NULL) { if (pf_status.debug >= LOG_NOTICE) { log(LOG_NOTICE, @@ -591,7 +592,7 @@ pf_remove_src_node(struct pf_src_node *s if (sn->rule.ptr->states_cur == 0 && sn->rule.ptr->src_nodes == 0) pf_rm_rule(NULL, sn->rule.ptr); - RB_REMOVE(pf_src_tree, &tree_src_tracking, sn); + RBT_REMOVE(pf_src_tree, &tree_src_tracking, sn); pf_status.scounters[SCNT_SRC_NODE_REMOVALS]++; pf_status.src_nodes--; pool_put(&pf_src_tree_pl, sn); @@ -632,7 +633,7 @@ pf_state_rm_src_node(struct pf_state *s, /* state table stuff */ static __inline int -pf_state_compare_key(struct pf_state_key *a, struct pf_state_key *b) +pf_state_compare_key(const struct pf_state_key *a, const struct pf_state_key *b) { int diff; @@ -654,7 +655,7 @@ pf_state_compare_key(struct pf_state_key } static __inline int -pf_state_compare_id(struct pf_state *a, struct pf_state *b) +pf_state_compare_id(const struct pf_state *a, const struct pf_state *b) { if (a->id > b->id) return (1); @@ -676,7 +677,7 @@ pf_state_key_attach(struct pf_state_key struct pf_state *olds = NULL; KASSERT(s->key[idx] == NULL); - if ((cur = RB_INSERT(pf_state_tree, &pf_statetbl, sk)) != NULL) { + if ((cur = RBT_INSERT(pf_state_tree, &pf_statetbl, sk)) != NULL) { /* key exists. check for same kif, if none, add to key */ TAILQ_FOREACH(si, &cur->states, entry) if (si->s->kif == s->kif && @@ -775,7 +776,7 @@ pf_state_key_detach(struct pf_state *s, sk = s->key[idx]; s->key[idx] = NULL; if (TAILQ_EMPTY(&sk->states)) { - RB_REMOVE(pf_state_tree, &pf_statetbl, sk); + RBT_REMOVE(pf_state_tree, &pf_statetbl, sk); sk->removed = 1; pf_state_key_unlink_reverse(sk); pf_inpcb_unlink_state_key(sk->inp); @@ -948,7 +949,7 @@ pf_state_insert(struct pfi_kif *kif, str s->id = htobe64(pf_status.stateid++); s->creatorid = pf_status.hostid; } - if (RB_INSERT(pf_state_tree_id, &tree_id, s) != NULL) { + if (RBT_INSERT(pf_state_tree_id, &tree_id, s) != NULL) { if (pf_status.debug >= LOG_NOTICE) { log(LOG_NOTICE, "pf: state insert failed: " "id: %016llx creatorid: %08x", @@ -973,7 +974,7 @@ pf_find_state_byid(struct pf_state_cmp * { pf_status.fcounters[FCNT_STATE_SEARCH]++; - return (RB_FIND(pf_state_tree_id, &tree_id, (struct pf_state *)key)); + return (RBT_FIND(pf_state_tree_id, &tree_id, (struct pf_state *)key)); } int @@ -1053,7 +1054,7 @@ pf_find_state(struct pfi_kif *kif, struc } if (sk == NULL) { - if ((sk = RB_FIND(pf_state_tree, &pf_statetbl, + if ((sk = RBT_FIND(pf_state_tree, &pf_statetbl, (struct pf_state_key *)key)) == NULL) return (NULL); if (dir == PF_OUT && pkt_sk && @@ -1089,7 +1090,7 @@ pf_find_state_all(struct pf_state_key_cm pf_status.fcounters[FCNT_STATE_SEARCH]++; - sk = RB_FIND(pf_state_tree, &pf_statetbl, (struct pf_state_key *)key); + sk = RBT_FIND(pf_state_tree, &pf_statetbl, (struct pf_state_key *)key); if (sk != NULL) { TAILQ_FOREACH(si, &sk->states, entry) @@ -1276,11 +1277,11 @@ pf_purge_expired_src_nodes(void) PF_ASSERT_LOCKED(); - for (cur = RB_MIN(pf_src_tree, &tree_src_tracking); cur; cur = next) { - next = RB_NEXT(pf_src_tree, &tree_src_tracking, cur); + for (cur = RBT_MIN(pf_src_tree, &tree_src_tracking); cur; cur = next) { + next = RBT_NEXT(pf_src_tree, cur); if (cur->states == 0 && cur->expire <= time_uptime) { - next = RB_NEXT(pf_src_tree, &tree_src_tracking, cur); + next = RBT_NEXT(pf_src_tree, cur); pf_remove_src_node(cur); } } @@ -1325,7 +1326,7 @@ pf_remove_state(struct pf_state *cur) TH_RST|TH_ACK, 0, 0, 0, 1, cur->tag, cur->key[PF_SK_WIRE]->rdomain); } - RB_REMOVE(pf_state_tree_id, &tree_id, cur); + RBT_REMOVE(pf_state_tree_id, &tree_id, cur); #if NPFLOW > 0 if (cur->state_flags & PFSTATE_PFLOW) export_pflow(cur); @@ -3059,7 +3060,7 @@ pf_step_into_anchor(struct pf_test_ctx * if (r->anchor_wildcard) { struct pf_anchor *child; rv = PF_TEST_OK; - RB_FOREACH(child, pf_anchor_node, &r->anchor->children) { + RBT_FOREACH(child, pf_anchor_node, &r->anchor->children) { rv = pf_match_rule(ctx, &child->ruleset); if ((rv == PF_TEST_QUICK) || (rv == PF_TEST_FAIL)) { /* Index: sys/net/pf_if.c =================================================================== RCS file: /cvs/src/sys/net/pf_if.c,v retrieving revision 1.91 diff -u -p -r1.91 pf_if.c --- sys/net/pf_if.c 30 May 2017 20:00:48 -0000 1.91 +++ sys/net/pf_if.c 21 Jun 2017 00:00:37 -0000 @@ -72,12 +72,12 @@ void pfi_table_update(struct pfr_ktabl void pfi_kifaddr_update(void *); void pfi_instance_add(struct ifnet *, u_int8_t, int); void pfi_address_add(struct sockaddr *, sa_family_t, u_int8_t); -int pfi_if_compare(struct pfi_kif *, struct pfi_kif *); +int pfi_if_compare(const struct pfi_kif *, const struct pfi_kif *); int pfi_skip_if(const char *, struct pfi_kif *); int pfi_unmask(void *); -RB_PROTOTYPE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare); -RB_GENERATE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare); +RBT_PROTOTYPE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare); +RBT_GENERATE(pfi_ifhead, pfi_kif, pfik_tree, pfi_if_compare); #define PFI_BUFFER_MAX 0x10000 #define PFI_MTYPE M_IFADDR @@ -105,7 +105,7 @@ pfi_kif_find(const char *kif_name) bzero(&s, sizeof(s)); strlcpy(s.pfik_name, kif_name, sizeof(s.pfik_name)); - return (RB_FIND(pfi_ifhead, &pfi_ifs, (struct pfi_kif *)&s)); + return (RBT_FIND(pfi_ifhead, &pfi_ifs, (struct pfi_kif *)&s)); } struct pfi_kif * @@ -130,7 +130,7 @@ pfi_kif_get(const char *kif_name) kif->pfik_flags_new |= PFI_IFLAG_ANY; } - RB_INSERT(pfi_ifhead, &pfi_ifs, kif); + RBT_INSERT(pfi_ifhead, &pfi_ifs, kif); return (kif); } @@ -195,7 +195,7 @@ pfi_kif_unref(struct pfi_kif *kif, enum if (kif->pfik_rules || kif->pfik_states || kif->pfik_routes) return; - RB_REMOVE(pfi_ifhead, &pfi_ifs, kif); + RBT_REMOVE(pfi_ifhead, &pfi_ifs, kif); free(kif, PFI_MTYPE, sizeof(*kif)); } @@ -601,7 +601,7 @@ pfi_kifaddr_update(void *v) } int -pfi_if_compare(struct pfi_kif *p, struct pfi_kif *q) +pfi_if_compare(const struct pfi_kif *p, const struct pfi_kif *q) { return (strncmp(p->pfik_name, q->pfik_name, IFNAMSIZ)); } @@ -616,7 +616,7 @@ pfi_update_status(const char *name, stru int i, j, k; if (*name == '\0' && pfs == NULL) { - RB_FOREACH(p, pfi_ifhead, &pfi_ifs) { + RBT_FOREACH(p, pfi_ifhead, &pfi_ifs) { bzero(p->pfik_packets, sizeof(p->pfik_packets)); bzero(p->pfik_bytes, sizeof(p->pfik_bytes)); p->pfik_tzero = time_second; @@ -625,7 +625,7 @@ pfi_update_status(const char *name, stru } strlcpy(key.pfik_name, name, sizeof(key.pfik_name)); - p = RB_FIND(pfi_ifhead, &pfi_ifs, (struct pfi_kif *)&key); + p = RBT_FIND(pfi_ifhead, &pfi_ifs, (struct pfi_kif *)&key); if (p == NULL) { return; } @@ -672,8 +672,8 @@ pfi_get_ifaces(const char *name, struct struct pfi_kif *p, *nextp; int n = 0; - for (p = RB_MIN(pfi_ifhead, &pfi_ifs); p; p = nextp) { - nextp = RB_NEXT(pfi_ifhead, &pfi_ifs, p); + for (p = RBT_MIN(pfi_ifhead, &pfi_ifs); p; p = nextp) { + nextp = RBT_NEXT(pfi_ifhead, p); if (pfi_skip_if(name, p)) continue; if (*size > n++) { @@ -684,7 +684,7 @@ pfi_get_ifaces(const char *name, struct pfi_kif_unref(p, PFI_KIF_REF_RULE); return (EFAULT); } - nextp = RB_NEXT(pfi_ifhead, &pfi_ifs, p); + nextp = RBT_NEXT(pfi_ifhead, p); pfi_kif_unref(p, PFI_KIF_REF_RULE); } } @@ -719,7 +719,7 @@ pfi_set_flags(const char *name, int flag { struct pfi_kif *p; - RB_FOREACH(p, pfi_ifhead, &pfi_ifs) { + RBT_FOREACH(p, pfi_ifhead, &pfi_ifs) { if (pfi_skip_if(name, p)) continue; p->pfik_flags_new = p->pfik_flags | flags; @@ -732,7 +732,7 @@ pfi_clear_flags(const char *name, int fl { struct pfi_kif *p; - RB_FOREACH(p, pfi_ifhead, &pfi_ifs) { + RBT_FOREACH(p, pfi_ifhead, &pfi_ifs) { if (pfi_skip_if(name, p)) continue; p->pfik_flags_new = p->pfik_flags & ~flags; @@ -745,7 +745,7 @@ pfi_xcommit(void) { struct pfi_kif *p; - RB_FOREACH(p, pfi_ifhead, &pfi_ifs) + RBT_FOREACH(p, pfi_ifhead, &pfi_ifs) p->pfik_flags = p->pfik_flags_new; } Index: sys/net/pf_ioctl.c =================================================================== RCS file: /cvs/src/sys/net/pf_ioctl.c,v retrieving revision 1.315 diff -u -p -r1.315 pf_ioctl.c --- sys/net/pf_ioctl.c 5 Jun 2017 22:18:28 -0000 1.315 +++ sys/net/pf_ioctl.c 21 Jun 2017 00:00:37 -0000 @@ -177,8 +177,8 @@ pfattach(int num) pf_pool_limits[PF_LIMIT_TABLE_ENTRIES].limit = PFR_KENTRY_HIWAT_SMALL; - RB_INIT(&tree_src_tracking); - RB_INIT(&pf_anchors); + RBT_INIT(pf_src_tree, &tree_src_tracking); + RBT_INIT(pf_anchor_global, &pf_anchors); pf_init_ruleset(&pf_main_ruleset); TAILQ_INIT(&pf_queues[0]); TAILQ_INIT(&pf_queues[1]); @@ -1436,8 +1436,8 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a struct pfioc_state_kill *psk = (struct pfioc_state_kill *)addr; u_int killed = 0; - for (s = RB_MIN(pf_state_tree_id, &tree_id); s; s = nexts) { - nexts = RB_NEXT(pf_state_tree_id, &tree_id, s); + for (s = RBT_MIN(pf_state_tree_id, &tree_id); s; s = nexts) { + nexts = RBT_NEXT(pf_state_tree_id, s); if (!psk->psk_ifname[0] || !strcmp(psk->psk_ifname, s->kif->pfik_name)) { @@ -1500,7 +1500,7 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a key.port[sidx] = psk->psk_src.port[0]; key.port[didx] = psk->psk_dst.port[0]; - sk = RB_FIND(pf_state_tree, &pf_statetbl, &key); + sk = RBT_FIND(pf_state_tree, &pf_statetbl, &key); if (sk == NULL) continue; @@ -1528,9 +1528,9 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a break; } - for (s = RB_MIN(pf_state_tree_id, &tree_id); s; + for (s = RBT_MIN(pf_state_tree_id, &tree_id); s; s = nexts) { - nexts = RB_NEXT(pf_state_tree_id, &tree_id, s); + nexts = RBT_NEXT(pf_state_tree_id, s); if (s->direction == PF_OUT) { sk = s->key[PF_SK_STACK]; @@ -1812,11 +1812,11 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a pr->nr = 0; if (ruleset->anchor == NULL) { /* XXX kludge for pf_main_ruleset */ - RB_FOREACH(anchor, pf_anchor_global, &pf_anchors) + RBT_FOREACH(anchor, pf_anchor_global, &pf_anchors) if (anchor->parent == NULL) pr->nr++; } else { - RB_FOREACH(anchor, pf_anchor_node, + RBT_FOREACH(anchor, pf_anchor_node, &ruleset->anchor->children) pr->nr++; } @@ -1837,14 +1837,14 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a pr->name[0] = 0; if (ruleset->anchor == NULL) { /* XXX kludge for pf_main_ruleset */ - RB_FOREACH(anchor, pf_anchor_global, &pf_anchors) + RBT_FOREACH(anchor, pf_anchor_global, &pf_anchors) if (anchor->parent == NULL && nr++ == pr->nr) { strlcpy(pr->name, anchor->name, sizeof(pr->name)); break; } } else { - RB_FOREACH(anchor, pf_anchor_node, + RBT_FOREACH(anchor, pf_anchor_node, &ruleset->anchor->children) if (nr++ == pr->nr) { strlcpy(pr->name, anchor->name, @@ -2294,7 +2294,7 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a int space = psn->psn_len; if (space == 0) { - RB_FOREACH(n, pf_src_tree, &tree_src_tracking) + RBT_FOREACH(n, pf_src_tree, &tree_src_tracking) nr++; psn->psn_len = sizeof(struct pf_src_node) * nr; break; @@ -2303,7 +2303,7 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a pstore = malloc(sizeof(*pstore), M_TEMP, M_WAITOK); p = psn->psn_src_nodes; - RB_FOREACH(n, pf_src_tree, &tree_src_tracking) { + RBT_FOREACH(n, pf_src_tree, &tree_src_tracking) { int secs = time_uptime, diff; if ((nr + 1) * sizeof(*p) > (unsigned)psn->psn_len) @@ -2347,9 +2347,9 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a struct pf_src_node *n; struct pf_state *state; - RB_FOREACH(state, pf_state_tree_id, &tree_id) + RBT_FOREACH(state, pf_state_tree_id, &tree_id) pf_src_tree_remove_state(state); - RB_FOREACH(n, pf_src_tree, &tree_src_tracking) + RBT_FOREACH(n, pf_src_tree, &tree_src_tracking) n->expire = 1; pf_purge_expired_src_nodes(1); break; @@ -2362,7 +2362,7 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a (struct pfioc_src_node_kill *)addr; u_int killed = 0; - RB_FOREACH(sn, pf_src_tree, &tree_src_tracking) { + RBT_FOREACH(sn, pf_src_tree, &tree_src_tracking) { if (PF_MATCHA(psnk->psnk_src.neg, &psnk->psnk_src.addr.v.a.addr, &psnk->psnk_src.addr.v.a.mask, @@ -2373,7 +2373,7 @@ pfioctl(dev_t dev, u_long cmd, caddr_t a &sn->raddr, sn->af)) { /* Handle state to src_node linkage */ if (sn->states != 0) - RB_FOREACH(s, pf_state_tree_id, + RBT_FOREACH(s, pf_state_tree_id, &tree_id) pf_state_rm_src_node(s, sn); sn->expire = 1; Index: sys/net/pf_lb.c =================================================================== RCS file: /cvs/src/sys/net/pf_lb.c,v retrieving revision 1.60 diff -u -p -r1.60 pf_lb.c --- sys/net/pf_lb.c 23 Apr 2017 11:37:11 -0000 1.60 +++ sys/net/pf_lb.c 21 Jun 2017 00:00:37 -0000 @@ -276,7 +276,7 @@ pf_map_addr_sticky(sa_family_t af, struc PF_ACPY(&k.addr, saddr, af); k.rule.ptr = r; pf_status.scounters[SCNT_SRC_NODE_SEARCH]++; - sns[type] = RB_FIND(pf_src_tree, &tree_src_tracking, &k); + sns[type] = RBT_FIND(pf_src_tree, &tree_src_tracking, &k); if (sns[type] == NULL) return (-1); @@ -308,7 +308,7 @@ pf_map_addr_sticky(sa_family_t af, struc } if (sns[type]->states != 0) { /* XXX expensive */ - RB_FOREACH(s, pf_state_tree_id, + RBT_FOREACH(s, pf_state_tree_id, &tree_id) pf_state_rm_src_node(s, sns[type]); Index: sys/net/pf_norm.c =================================================================== RCS file: /cvs/src/sys/net/pf_norm.c,v retrieving revision 1.205 diff -u -p -r1.205 pf_norm.c --- sys/net/pf_norm.c 5 Jun 2017 22:18:28 -0000 1.205 +++ sys/net/pf_norm.c 21 Jun 2017 00:00:37 -0000 @@ -76,7 +76,7 @@ struct pf_frent { u_int16_t fe_mff; /* more fragment flag */ }; -/* keep synced with struct pf_fragment, used in RB_FIND */ +/* keep synced with struct pf_fragment, used in RBT_FIND */ struct pf_fragment_cmp { struct pf_addr fr_src; struct pf_addr fr_dst; @@ -94,7 +94,7 @@ struct pf_fragment { u_int8_t fr_proto; /* protocol of this fragment */ u_int8_t fr_direction; /* pf packet direction */ - RB_ENTRY(pf_fragment) fr_entry; + RBT_ENTRY(pf_fragment) fr_entry; TAILQ_ENTRY(pf_fragment) frag_next; TAILQ_HEAD(pf_fragq, pf_frent) fr_queue; int32_t fr_timeout; @@ -109,11 +109,11 @@ struct pf_fragment_tag { TAILQ_HEAD(pf_fragqueue, pf_fragment) pf_fragqueue; -static __inline int pf_frag_compare(struct pf_fragment *, - struct pf_fragment *); -RB_HEAD(pf_frag_tree, pf_fragment) pf_frag_tree, pf_cache_tree; -RB_PROTOTYPE(pf_frag_tree, pf_fragment, fr_entry, pf_frag_compare); -RB_GENERATE(pf_frag_tree, pf_fragment, fr_entry, pf_frag_compare); +static __inline int pf_frag_compare(const struct pf_fragment *, + const struct pf_fragment *); +RBT_HEAD(pf_frag_tree, pf_fragment) pf_frag_tree, pf_cache_tree; +RBT_PROTOTYPE(pf_frag_tree, pf_fragment, fr_entry, pf_frag_compare); +RBT_GENERATE(pf_frag_tree, pf_fragment, fr_entry, pf_frag_compare); /* Private prototypes */ void pf_flush_fragments(void); @@ -167,7 +167,7 @@ pf_normalize_init(void) } static __inline int -pf_frag_compare(struct pf_fragment *a, struct pf_fragment *b) +pf_frag_compare(const struct pf_fragment *a, const struct pf_fragment *b) { int diff; @@ -232,7 +232,7 @@ pf_free_fragment(struct pf_fragment *fra { struct pf_frent *frent; - RB_REMOVE(pf_frag_tree, &pf_frag_tree, frag); + RBT_REMOVE(pf_frag_tree, &pf_frag_tree, frag); TAILQ_REMOVE(&pf_fragqueue, frag, frag_next); /* Free all fragment entries */ @@ -250,7 +250,7 @@ pf_find_fragment(struct pf_fragment_cmp { struct pf_fragment *frag; - frag = RB_FIND(pf_frag_tree, tree, (struct pf_fragment *)key); + frag = RBT_FIND(pf_frag_tree, tree, (struct pf_fragment *)key); if (frag != NULL) { TAILQ_REMOVE(&pf_fragqueue, frag, frag_next); TAILQ_INSERT_HEAD(&pf_fragqueue, frag, frag_next); @@ -330,7 +330,7 @@ pf_fillup_fragment(struct pf_fragment_cm frag->fr_timeout = time_uptime; frag->fr_maxlen = frent->fe_len; - RB_INSERT(pf_frag_tree, &pf_frag_tree, frag); + RBT_INSERT(pf_frag_tree, &pf_frag_tree, frag); TAILQ_INSERT_HEAD(&pf_fragqueue, frag, frag_next); /* We do not have a previous fragment */ Index: sys/net/pf_ruleset.c =================================================================== RCS file: /cvs/src/sys/net/pf_ruleset.c,v retrieving revision 1.15 diff -u -p -r1.15 pf_ruleset.c --- sys/net/pf_ruleset.c 30 May 2017 20:00:48 -0000 1.15 +++ sys/net/pf_ruleset.c 21 Jun 2017 00:00:37 -0000 @@ -66,6 +66,7 @@ #include #include #include +#include #include #define rs_malloc(x) calloc(1, x) #define rs_free(x, siz) freezero(x, siz) @@ -79,13 +80,14 @@ struct pf_anchor_global pf_anchors; struct pf_anchor pf_main_anchor; -static __inline int pf_anchor_compare(struct pf_anchor *, struct pf_anchor *); +static __inline int pf_anchor_compare(const struct pf_anchor *, + const struct pf_anchor *); -RB_GENERATE(pf_anchor_global, pf_anchor, entry_global, pf_anchor_compare); -RB_GENERATE(pf_anchor_node, pf_anchor, entry_node, pf_anchor_compare); +RBT_GENERATE(pf_anchor_global, pf_anchor, entry_global, pf_anchor_compare); +RBT_GENERATE(pf_anchor_node, pf_anchor, entry_node, pf_anchor_compare); static __inline int -pf_anchor_compare(struct pf_anchor *a, struct pf_anchor *b) +pf_anchor_compare(const struct pf_anchor *a, const struct pf_anchor *b) { int c = strcmp(a->path, b->path); @@ -111,7 +113,7 @@ pf_find_anchor(const char *path) if (key == NULL) return (NULL); strlcpy(key->path, path, sizeof(key->path)); - found = RB_FIND(pf_anchor_global, &pf_anchors, key); + found = RBT_FIND(pf_anchor_global, &pf_anchors, key); rs_free(key, sizeof (*key)); return (found); } @@ -180,7 +182,7 @@ pf_find_or_create_ruleset(const char *pa rs_free(p, MAXPATHLEN); return (NULL); } - RB_INIT(&anchor->children); + RBT_INIT(pf_anchor_node, &anchor->children); strlcpy(anchor->name, q, sizeof(anchor->name)); if (parent != NULL) { strlcpy(anchor->path, parent->path, @@ -188,10 +190,10 @@ pf_find_or_create_ruleset(const char *pa strlcat(anchor->path, "/", sizeof(anchor->path)); } strlcat(anchor->path, anchor->name, sizeof(anchor->path)); - if ((dup = RB_INSERT(pf_anchor_global, &pf_anchors, anchor)) != + if ((dup = RBT_INSERT(pf_anchor_global, &pf_anchors, anchor)) != NULL) { DPFPRINTF(LOG_NOTICE, - "pf_find_or_create_ruleset: RB_INSERT1 " + "pf_find_or_create_ruleset: RBT_INSERT1 " "'%s' '%s' collides with '%s' '%s'", anchor->path, anchor->name, dup->path, dup->name); rs_free(anchor, sizeof(*anchor)); @@ -200,14 +202,14 @@ pf_find_or_create_ruleset(const char *pa } if (parent != NULL) { anchor->parent = parent; - if ((dup = RB_INSERT(pf_anchor_node, &parent->children, + if ((dup = RBT_INSERT(pf_anchor_node, &parent->children, anchor)) != NULL) { DPFPRINTF(LOG_NOTICE, "pf_find_or_create_ruleset: " - "RB_INSERT2 '%s' '%s' collides with " + "RBT_INSERT2 '%s' '%s' collides with " "'%s' '%s'", anchor->path, anchor->name, dup->path, dup->name); - RB_REMOVE(pf_anchor_global, &pf_anchors, + RBT_REMOVE(pf_anchor_global, &pf_anchors, anchor); rs_free(anchor, sizeof(*anchor)); rs_free(p, MAXPATHLEN); @@ -233,7 +235,7 @@ pf_remove_if_empty_ruleset(struct pf_rul while (ruleset != NULL) { if (ruleset == &pf_main_ruleset || ruleset->anchor == NULL || - !RB_EMPTY(&ruleset->anchor->children) || + !RBT_EMPTY(pf_anchor_node, &ruleset->anchor->children) || ruleset->anchor->refcnt > 0 || ruleset->tables > 0 || ruleset->topen) return; @@ -241,9 +243,9 @@ pf_remove_if_empty_ruleset(struct pf_rul !TAILQ_EMPTY(ruleset->rules.inactive.ptr) || ruleset->rules.inactive.open) return; - RB_REMOVE(pf_anchor_global, &pf_anchors, ruleset->anchor); + RBT_REMOVE(pf_anchor_global, &pf_anchors, ruleset->anchor); if ((parent = ruleset->anchor->parent) != NULL) - RB_REMOVE(pf_anchor_node, &parent->children, + RBT_REMOVE(pf_anchor_node, &parent->children, ruleset->anchor); rs_free(ruleset->anchor, sizeof(*(ruleset->anchor))); if (parent == NULL) Index: sys/net/pf_table.c =================================================================== RCS file: /cvs/src/sys/net/pf_table.c,v retrieving revision 1.126 diff -u -p -r1.126 pf_table.c --- sys/net/pf_table.c 8 May 2017 20:24:03 -0000 1.126 +++ sys/net/pf_table.c 21 Jun 2017 00:00:37 -0000 @@ -182,8 +182,8 @@ struct pfr_ktable *pfr_create_ktable(str int); void pfr_destroy_ktables(struct pfr_ktableworkq *, int); void pfr_destroy_ktable(struct pfr_ktable *, int); -int pfr_ktable_compare(struct pfr_ktable *, - struct pfr_ktable *); +int pfr_ktable_compare(const struct pfr_ktable *, + const struct pfr_ktable *); void pfr_ktable_winfo_update(struct pfr_ktable *, struct pfr_kentry *); struct pfr_ktable *pfr_lookup_table(struct pfr_table *); @@ -195,8 +195,8 @@ int pfr_skip_table(struct pfr_table * struct pfr_kentry *pfr_kentry_byidx(struct pfr_ktable *, int, int); int pfr_islinklocal(sa_family_t, struct pf_addr *); -RB_PROTOTYPE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare); -RB_GENERATE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare); +RBT_PROTOTYPE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare); +RBT_GENERATE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare); struct pfr_ktablehead pfr_ktables; struct pfr_table pfr_nulltable; @@ -1258,7 +1258,7 @@ pfr_clr_tables(struct pfr_table *filter, return (ENOENT); SLIST_INIT(&workq); - RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) { + RBT_FOREACH(p, pfr_ktablehead, &pfr_ktables) { if (pfr_skip_table(filter, p, flags)) continue; if (!strcmp(p->pfrkt_anchor, PF_RESERVED_ANCHOR)) @@ -1296,7 +1296,7 @@ pfr_add_tables(struct pfr_table *tbl, in flags & PFR_FLAG_USERIOCTL)) senderr(EINVAL); key.pfrkt_flags |= PFR_TFLAG_ACTIVE; - p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key); + p = RBT_FIND(pfr_ktablehead, &pfr_ktables, &key); if (p == NULL) { p = pfr_create_ktable(&key.pfrkt_t, tzero, 1, !(flags & PFR_FLAG_USERIOCTL)); @@ -1313,7 +1313,7 @@ pfr_add_tables(struct pfr_table *tbl, in /* find or create root table */ bzero(key.pfrkt_anchor, sizeof(key.pfrkt_anchor)); - r = RB_FIND(pfr_ktablehead, &pfr_ktables, &key); + r = RBT_FIND(pfr_ktablehead, &pfr_ktables, &key); if (r != NULL) { p->pfrkt_root = r; goto _skip; @@ -1372,7 +1372,7 @@ pfr_del_tables(struct pfr_table *tbl, in if (pfr_validate_table(&key.pfrkt_t, 0, flags & PFR_FLAG_USERIOCTL)) return (EINVAL); - p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key); + p = RBT_FIND(pfr_ktablehead, &pfr_ktables, &key); if (p != NULL && (p->pfrkt_flags & PFR_TFLAG_ACTIVE)) { SLIST_FOREACH(q, &workq, pfrkt_workq) if (!pfr_ktable_compare(p, q)) @@ -1410,7 +1410,7 @@ pfr_get_tables(struct pfr_table *filter, *size = n; return (0); } - RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) { + RBT_FOREACH(p, pfr_ktablehead, &pfr_ktables) { if (pfr_skip_table(filter, p, flags)) continue; if (n-- <= 0) @@ -1448,7 +1448,7 @@ pfr_get_tstats(struct pfr_table *filter, return (0); } SLIST_INIT(&workq); - RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) { + RBT_FOREACH(p, pfr_ktablehead, &pfr_ktables) { if (pfr_skip_table(filter, p, flags)) continue; if (n-- <= 0) @@ -1485,7 +1485,7 @@ pfr_clr_tstats(struct pfr_table *tbl, in return (EFAULT); if (pfr_validate_table(&key.pfrkt_t, 0, 0)) return (EINVAL); - p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key); + p = RBT_FIND(pfr_ktablehead, &pfr_ktables, &key); if (p != NULL) { SLIST_INSERT_HEAD(&workq, p, pfrkt_workq); xzero++; @@ -1520,7 +1520,7 @@ pfr_set_tflags(struct pfr_table *tbl, in if (pfr_validate_table(&key.pfrkt_t, 0, flags & PFR_FLAG_USERIOCTL)) return (EINVAL); - p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key); + p = RBT_FIND(pfr_ktablehead, &pfr_ktables, &key); if (p != NULL && (p->pfrkt_flags & PFR_TFLAG_ACTIVE)) { p->pfrkt_nflags = (p->pfrkt_flags | setflag) & ~clrflag; @@ -1563,7 +1563,7 @@ pfr_ina_begin(struct pfr_table *trs, u_i if (rs == NULL) return (ENOMEM); SLIST_INIT(&workq); - RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) { + RBT_FOREACH(p, pfr_ktablehead, &pfr_ktables) { if (!(p->pfrkt_flags & PFR_TFLAG_INACTIVE) || pfr_skip_table(trs, p, 0)) continue; @@ -1606,7 +1606,7 @@ pfr_ina_define(struct pfr_table *tbl, st return (EBUSY); tbl->pfrt_flags |= PFR_TFLAG_INACTIVE; SLIST_INIT(&tableq); - kt = RB_FIND(pfr_ktablehead, &pfr_ktables, (struct pfr_ktable *)tbl); + kt = RBT_FIND(pfr_ktablehead, &pfr_ktables, (struct pfr_ktable *)tbl); if (kt == NULL) { kt = pfr_create_ktable(tbl, 0, 1, !(flags & PFR_FLAG_USERIOCTL)); @@ -1620,7 +1620,7 @@ pfr_ina_define(struct pfr_table *tbl, st /* find or create root table */ bzero(&key, sizeof(key)); strlcpy(key.pfrkt_name, tbl->pfrt_name, sizeof(key.pfrkt_name)); - rt = RB_FIND(pfr_ktablehead, &pfr_ktables, &key); + rt = RBT_FIND(pfr_ktablehead, &pfr_ktables, &key); if (rt != NULL) { kt->pfrkt_root = rt; goto _skip; @@ -1702,7 +1702,7 @@ pfr_ina_rollback(struct pfr_table *trs, if (rs == NULL || !rs->topen || ticket != rs->tticket) return (0); SLIST_INIT(&workq); - RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) { + RBT_FOREACH(p, pfr_ktablehead, &pfr_ktables) { if (!(p->pfrkt_flags & PFR_TFLAG_INACTIVE) || pfr_skip_table(trs, p, 0)) continue; @@ -1736,7 +1736,7 @@ pfr_ina_commit(struct pfr_table *trs, u_ return (EBUSY); SLIST_INIT(&workq); - RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) { + RBT_FOREACH(p, pfr_ktablehead, &pfr_ktables) { if (!(p->pfrkt_flags & PFR_TFLAG_INACTIVE) || pfr_skip_table(trs, p, 0)) continue; @@ -1909,7 +1909,7 @@ pfr_insert_ktables(struct pfr_ktablework void pfr_insert_ktable(struct pfr_ktable *kt) { - RB_INSERT(pfr_ktablehead, &pfr_ktables, kt); + RBT_INSERT(pfr_ktablehead, &pfr_ktables, kt); pfr_ktable_cnt++; if (kt->pfrkt_root != NULL) if (!kt->pfrkt_root->pfrkt_refcnt[PFR_REFCNT_ANCHOR]++) @@ -1940,7 +1940,7 @@ pfr_setflags_ktable(struct pfr_ktable *k if (!(newf & PFR_TFLAG_ACTIVE)) newf &= ~PFR_TFLAG_USRMASK; if (!(newf & PFR_TFLAG_SETMASK)) { - RB_REMOVE(pfr_ktablehead, &pfr_ktables, kt); + RBT_REMOVE(pfr_ktablehead, &pfr_ktables, kt); if (kt->pfrkt_root != NULL) if (!--kt->pfrkt_root->pfrkt_refcnt[PFR_REFCNT_ANCHOR]) pfr_setflags_ktable(kt->pfrkt_root, @@ -2060,7 +2060,7 @@ pfr_destroy_ktable(struct pfr_ktable *kt } int -pfr_ktable_compare(struct pfr_ktable *p, struct pfr_ktable *q) +pfr_ktable_compare(const struct pfr_ktable *p, const struct pfr_ktable *q) { int d; @@ -2073,7 +2073,7 @@ struct pfr_ktable * pfr_lookup_table(struct pfr_table *tbl) { /* struct pfr_ktable start like a struct pfr_table */ - return (RB_FIND(pfr_ktablehead, &pfr_ktables, + return (RBT_FIND(pfr_ktablehead, &pfr_ktables, (struct pfr_ktable *)tbl)); } Index: sys/net/pfvar.h =================================================================== RCS file: /cvs/src/sys/net/pfvar.h,v retrieving revision 1.457 diff -u -p -r1.457 pfvar.h --- sys/net/pfvar.h 30 May 2017 19:40:54 -0000 1.457 +++ sys/net/pfvar.h 21 Jun 2017 00:00:37 -0000 @@ -618,7 +618,7 @@ SLIST_HEAD(pf_rule_slist, pf_rule_item); enum pf_sn_types { PF_SN_NONE, PF_SN_NAT, PF_SN_RDR, PF_SN_ROUTE, PF_SN_MAX }; struct pf_src_node { - RB_ENTRY(pf_src_node) entry; + RBT_ENTRY(pf_src_node) entry; struct pf_addr addr; struct pf_addr raddr; union pf_rule_ptr rule; @@ -681,7 +681,7 @@ struct pf_state_peer { TAILQ_HEAD(pf_state_queue, pf_state); -/* keep synced with struct pf_state_key, used in RB_FIND */ +/* keep synced with struct pf_state_key, used in RBT_FIND */ struct pf_state_key_cmp { struct pf_addr addr[2]; u_int16_t port[2]; @@ -704,7 +704,7 @@ struct pf_state_key { sa_family_t af; u_int8_t proto; - RB_ENTRY(pf_state_key) entry; + RBT_ENTRY(pf_state_key) entry; struct pf_statelisthead states; struct pf_state_key *reverse; struct inpcb *inp; @@ -715,7 +715,7 @@ struct pf_state_key { ((key[PF_SK_WIRE]->af != key[PF_SK_STACK]->af) && \ (key[PF_SK_WIRE]->af != (family))) -/* keep synced with struct pf_state, used in RB_FIND */ +/* keep synced with struct pf_state, used in RBT_FIND */ struct pf_state_cmp { u_int64_t id; u_int32_t creatorid; @@ -731,7 +731,7 @@ struct pf_state { TAILQ_ENTRY(pf_state) sync_list; TAILQ_ENTRY(pf_state) entry_list; - RB_ENTRY(pf_state) entry_id; + RBT_ENTRY(pf_state) entry_id; struct pf_state_peer src; struct pf_state_peer dst; struct pf_rule_slist match_rules; @@ -915,11 +915,11 @@ struct pf_ruleset { int topen; }; -RB_HEAD(pf_anchor_global, pf_anchor); -RB_HEAD(pf_anchor_node, pf_anchor); +RBT_HEAD(pf_anchor_global, pf_anchor); +RBT_HEAD(pf_anchor_node, pf_anchor); struct pf_anchor { - RB_ENTRY(pf_anchor) entry_global; - RB_ENTRY(pf_anchor) entry_node; + RBT_ENTRY(pf_anchor) entry_global; + RBT_ENTRY(pf_anchor) entry_node; struct pf_anchor *parent; struct pf_anchor_node children; char name[PF_ANCHOR_NAME_SIZE]; @@ -928,8 +928,8 @@ struct pf_anchor { int refcnt; /* anchor rules */ int match; }; -RB_PROTOTYPE(pf_anchor_global, pf_anchor, entry_global, pf_anchor_compare) -RB_PROTOTYPE(pf_anchor_node, pf_anchor, entry_node, pf_anchor_compare) +RBT_PROTOTYPE(pf_anchor_global, pf_anchor, entry_global, pf_anchor_compare); +RBT_PROTOTYPE(pf_anchor_node, pf_anchor, entry_node, pf_anchor_compare); #define PF_RESERVED_ANCHOR "_pf" @@ -1080,10 +1080,10 @@ struct pfr_kentry_all { #define pfrke_rkif u.kr.kif SLIST_HEAD(pfr_ktableworkq, pfr_ktable); -RB_HEAD(pfr_ktablehead, pfr_ktable); +RBT_HEAD(pfr_ktablehead, pfr_ktable); struct pfr_ktable { struct pfr_tstats pfrkt_ts; - RB_ENTRY(pfr_ktable) pfrkt_tree; + RBT_ENTRY(pfr_ktable) pfrkt_tree; SLIST_ENTRY(pfr_ktable) pfrkt_workq; struct radix_node_head *pfrkt_ip4; struct radix_node_head *pfrkt_ip6; @@ -1109,19 +1109,19 @@ struct pfr_ktable { #define pfrkt_nomatch pfrkt_ts.pfrts_nomatch #define pfrkt_tzero pfrkt_ts.pfrts_tzero -RB_HEAD(pf_state_tree, pf_state_key); -RB_PROTOTYPE(pf_state_tree, pf_state_key, entry, pf_state_compare_key) +RBT_HEAD(pf_state_tree, pf_state_key); +RBT_PROTOTYPE(pf_state_tree, pf_state_key, entry, pf_state_compare_key); -RB_HEAD(pf_state_tree_ext_gwy, pf_state_key); -RB_PROTOTYPE(pf_state_tree_ext_gwy, pf_state_key, - entry_ext_gwy, pf_state_compare_ext_gwy) +RBT_HEAD(pf_state_tree_ext_gwy, pf_state_key); +RBT_PROTOTYPE(pf_state_tree_ext_gwy, pf_state_key, + entry_ext_gwy, pf_state_compare_ext_gwy); -RB_HEAD(pfi_ifhead, pfi_kif); +RBT_HEAD(pfi_ifhead, pfi_kif); /* state tables */ extern struct pf_state_tree pf_statetbl; -/* keep synced with pfi_kif, used in RB_FIND */ +/* keep synced with pfi_kif, used in RBT_FIND */ struct pfi_kif_cmp { char pfik_name[IFNAMSIZ]; }; @@ -1131,7 +1131,7 @@ struct ifg_group; struct pfi_kif { char pfik_name[IFNAMSIZ]; - RB_ENTRY(pfi_kif) pfik_tree; + RBT_ENTRY(pfi_kif) pfik_tree; u_int64_t pfik_packets[2][2][2]; u_int64_t pfik_bytes[2][2][2]; time_t pfik_tzero; @@ -1605,12 +1605,12 @@ struct pfioc_iface { struct pf_pdesc; -RB_HEAD(pf_src_tree, pf_src_node); -RB_PROTOTYPE(pf_src_tree, pf_src_node, entry, pf_src_compare); +RBT_HEAD(pf_src_tree, pf_src_node); +RBT_PROTOTYPE(pf_src_tree, pf_src_node, entry, pf_src_compare); extern struct pf_src_tree tree_src_tracking; -RB_HEAD(pf_state_tree_id, pf_state); -RB_PROTOTYPE(pf_state_tree_id, pf_state, +RBT_HEAD(pf_state_tree_id, pf_state); +RBT_PROTOTYPE(pf_state_tree_id, pf_state, entry_id, pf_state_compare_id); extern struct pf_state_tree_id tree_id; extern struct pf_state_queue state_list; @@ -1804,8 +1804,8 @@ void pf_tag2tagname(u_int16_t, char *) void pf_tag_ref(u_int16_t); void pf_tag_unref(u_int16_t); void pf_tag_packet(struct mbuf *, int, int); -int pf_addr_compare(struct pf_addr *, struct pf_addr *, - sa_family_t); +int pf_addr_compare(const struct pf_addr *, + const struct pf_addr *, sa_family_t); extern struct pf_status pf_status; extern struct pool pf_frent_pl, pf_frag_pl; Index: usr.bin/cvs/checkout.c =================================================================== RCS file: /cvs/src/usr.bin/cvs/checkout.c,v retrieving revision 1.171 diff -u -p -r1.171 checkout.c --- usr.bin/cvs/checkout.c 1 Jun 2017 08:08:24 -0000 1.171 +++ usr.bin/cvs/checkout.c 21 Jun 2017 00:00:38 -0000 @@ -301,10 +301,10 @@ checkout_check_repository(int argc, char mc = cvs_module_lookup(argv[i]); current_module = mc; - RB_FOREACH(fl, cvs_flisthead, &(mc->mc_ignores)) + RBT_FOREACH(fl, cvs_flisthead, &(mc->mc_ignores)) cvs_file_ignore(fl->file_path, &checkout_ign_pats); - RB_FOREACH(fl, cvs_flisthead, &(mc->mc_modules)) { + RBT_FOREACH(fl, cvs_flisthead, &(mc->mc_modules)) { module_repo_root = NULL; (void)xsnprintf(repo, sizeof(repo), "%s/%s", @@ -364,11 +364,10 @@ checkout_check_repository(int argc, char } if (mc->mc_canfree == 1) { - for (fl = RB_MIN(cvs_flisthead, &(mc->mc_modules)); + for (fl = RBT_MIN(cvs_flisthead, &(mc->mc_modules)); fl != NULL; fl = nxt) { - nxt = RB_NEXT(cvs_flisthead, - &(mc->mc_modules), fl); - RB_REMOVE(cvs_flisthead, + nxt = RBT_NEXT(cvs_flisthead, fl); + RBT_REMOVE(cvs_flisthead, &(mc->mc_modules), fl); free(fl->file_path); free(fl); @@ -427,8 +426,8 @@ checkout_repository(const char *repobase struct cvs_flisthead fl, dl; struct cvs_recursion cr; - RB_INIT(&fl); - RB_INIT(&dl); + RBT_INIT(cvs_flisthead, &fl); + RBT_INIT(cvs_flisthead, &dl); cvs_history_add((cvs_cmdop == CVS_OP_CHECKOUT) ? CVS_HISTORY_CHECKOUT : CVS_HISTORY_EXPORT, NULL, wdbase); Index: usr.bin/cvs/commit.c =================================================================== RCS file: /cvs/src/usr.bin/cvs/commit.c,v retrieving revision 1.158 diff -u -p -r1.158 commit.c --- usr.bin/cvs/commit.c 1 Jun 2017 08:08:24 -0000 1.158 +++ usr.bin/cvs/commit.c 21 Jun 2017 00:00:38 -0000 @@ -110,10 +110,10 @@ cvs_commit(int argc, char **argv) if (Fflag && mflag) fatal("cannot specify both a log file and a message"); - RB_INIT(&files_affected); - RB_INIT(&files_added); - RB_INIT(&files_removed); - RB_INIT(&files_modified); + RBT_INIT(cvs_flisthead, &files_affected); + RBT_INIT(cvs_flisthead, &files_added); + RBT_INIT(cvs_flisthead, &files_removed); + RBT_INIT(cvs_flisthead, &files_modified); TAILQ_INIT(&files_info); conflicts_found = 0; @@ -132,7 +132,7 @@ cvs_commit(int argc, char **argv) fatal("%d conflicts found, please correct these first", conflicts_found); - if (RB_EMPTY(&files_affected)) + if (RBT_EMPTY(cvs_flisthead, &files_affected)) return (0); if (cvsroot_is_remote()) { @@ -163,7 +163,7 @@ cvs_commit(int argc, char **argv) line_list = cvs_trigger_getlines(CVS_PATH_COMMITINFO, repo); if (line_list != NULL) { - RB_FOREACH(l, cvs_flisthead, &files_affected) { + RBT_FOREACH(l, cvs_flisthead, &files_affected) { fi = xcalloc(1, sizeof(*fi)); fi->file_path = xstrdup(l->file_path); TAILQ_INSERT_TAIL(&files_info, fi, @@ -240,10 +240,10 @@ cvs_commit_loginfo(char *repo) cvs_trigger_loginfo_header(buf, repo); - if (!RB_EMPTY(&files_added)) { + if (!RBT_EMPTY(cvs_flisthead, &files_added)) { buf_puts(buf, "Added Files:"); - RB_FOREACH(cf, cvs_flisthead, &files_added) { + RBT_FOREACH(cf, cvs_flisthead, &files_added) { buf_putc(buf, '\n'); buf_putc(buf, '\t'); buf_puts(buf, cf->file_path); @@ -252,10 +252,10 @@ cvs_commit_loginfo(char *repo) buf_putc(buf, '\n'); } - if (!RB_EMPTY(&files_modified)) { + if (!RBT_EMPTY(cvs_flisthead, &files_modified)) { buf_puts(buf, "Modified Files:"); - RB_FOREACH(cf, cvs_flisthead, &files_modified) { + RBT_FOREACH(cf, cvs_flisthead, &files_modified) { buf_putc(buf, '\n'); buf_putc(buf, '\t'); buf_puts(buf, cf->file_path); @@ -264,10 +264,10 @@ cvs_commit_loginfo(char *repo) buf_putc(buf, '\n'); } - if (!RB_EMPTY(&files_removed)) { + if (!RBT_EMPTY(cvs_flisthead, &files_removed)) { buf_puts(buf, "Removed Files:"); - RB_FOREACH(cf, cvs_flisthead, &files_removed) { + RBT_FOREACH(cf, cvs_flisthead, &files_removed) { buf_putc(buf, '\n'); buf_putc(buf, '\t'); buf_puts(buf, cf->file_path); Index: usr.bin/cvs/file.c =================================================================== RCS file: /cvs/src/usr.bin/cvs/file.c,v retrieving revision 1.273 diff -u -p -r1.273 file.c --- usr.bin/cvs/file.c 1 Jun 2017 08:38:56 -0000 1.273 +++ usr.bin/cvs/file.c 21 Jun 2017 00:00:38 -0000 @@ -37,6 +37,7 @@ #include #include #include +#include #include #include @@ -84,7 +85,7 @@ struct ignore_head cvs_ign_pats; struct ignore_head dir_ign_pats; struct ignore_head checkout_ign_pats; -RB_GENERATE(cvs_flisthead, cvs_filelist, flist, cvs_filelist_cmp); +RBT_GENERATE(cvs_flisthead, cvs_filelist, flist, cvs_filelist_cmp); void cvs_file_init(void) @@ -192,7 +193,7 @@ cvs_file_run(int argc, char **argv, stru int i; struct cvs_flisthead fl; - RB_INIT(&fl); + RBT_INIT(cvs_flisthead, &fl); for (i = 0; i < argc; i++) { STRIP_SLASH(argv[i]); @@ -213,7 +214,7 @@ cvs_file_get(char *name, int flags, stru p += 2; find.file_path = p; - l = RB_FIND(cvs_flisthead, fl, &find); + l = RBT_FIND(cvs_flisthead, fl, &find); if (l != NULL) return (l); @@ -222,7 +223,7 @@ cvs_file_get(char *name, int flags, stru l->flags = flags; l->type = type; - RB_INSERT(cvs_flisthead, fl, l); + RBT_INSERT(cvs_flisthead, fl, l); return (l); } @@ -267,7 +268,7 @@ cvs_file_walklist(struct cvs_flisthead * struct cvs_filelist *l, *nxt; char *d, *f, repo[PATH_MAX], fpath[PATH_MAX]; - for (l = RB_MIN(cvs_flisthead, fl); l != NULL; l = nxt) { + for (l = RBT_MIN(cvs_flisthead, fl); l != NULL; l = nxt) { if (cvs_quit) fatal("received signal %d", sig_received); @@ -384,7 +385,7 @@ cvs_file_walklist(struct cvs_flisthead * cvs_file_free(cf); next: - nxt = RB_NEXT(cvs_flisthead, fl, l); + nxt = RBT_NEXT(cvs_flisthead, l); } } @@ -420,8 +421,8 @@ cvs_file_walkdir(struct cvs_file *cf, st * locally available directories or try to create them. */ if (!(cmdp->cmd_flags & CVS_USE_WDIR)) { - RB_INIT(&fl); - RB_INIT(&dl); + RBT_INIT(cvs_flisthead, &fl); + RBT_INIT(cvs_flisthead, &dl); goto walkrepo; } @@ -467,8 +468,8 @@ cvs_file_walkdir(struct cvs_file *cf, st bufsize = (st.st_size > st.st_blksize) ? st.st_size : st.st_blksize; buf = xmalloc(bufsize); - RB_INIT(&fl); - RB_INIT(&dl); + RBT_INIT(cvs_flisthead, &fl); + RBT_INIT(cvs_flisthead, &dl); while ((nbytes = getdents(cf->fd, buf, bufsize)) > 0) { ebuf = buf + nbytes; @@ -627,9 +628,9 @@ cvs_file_freelist(struct cvs_flisthead * { struct cvs_filelist *f, *nxt; - for (f = RB_MIN(cvs_flisthead, fl); f != NULL; f = nxt) { - nxt = RB_NEXT(cvs_flisthead, fl, f); - RB_REMOVE(cvs_flisthead, fl, f); + for (f = RBT_MIN(cvs_flisthead, fl); f != NULL; f = nxt) { + nxt = RBT_NEXT(cvs_flisthead, f); + RBT_REMOVE(cvs_flisthead, fl, f); free(f->file_path); free(f); } @@ -1132,7 +1133,7 @@ out: } int -cvs_filelist_cmp(struct cvs_filelist *f1, struct cvs_filelist *f2) +cvs_filelist_cmp(const struct cvs_filelist *f1, const struct cvs_filelist *f2) { return (strcmp(f1->file_path, f2->file_path)); } Index: usr.bin/cvs/file.h =================================================================== RCS file: /cvs/src/usr.bin/cvs/file.h,v retrieving revision 1.53 diff -u -p -r1.53 file.h --- usr.bin/cvs/file.h 26 Mar 2009 22:54:37 -0000 1.53 +++ usr.bin/cvs/file.h 21 Jun 2017 00:00:38 -0000 @@ -77,14 +77,14 @@ struct cvs_file { #define FILE_ON_DISK 0x08 struct cvs_filelist { - RB_ENTRY(cvs_filelist) flist; + RBT_ENTRY(cvs_filelist) flist; char *file_path; int flags; int type; }; -RB_HEAD(cvs_flisthead, cvs_filelist); -RB_PROTOTYPE(cvs_flisthead, cvs_filelist, flist, cvs_filelist_cmp); +RBT_HEAD(cvs_flisthead, cvs_filelist); +RBT_PROTOTYPE(cvs_flisthead, cvs_filelist, flist, cvs_filelist_cmp); struct cvs_recursion; @@ -111,7 +111,8 @@ void cvs_file_walkdir(struct cvs_file *, void cvs_file_freelist(struct cvs_flisthead *); struct cvs_filelist *cvs_file_get(char *, int, struct cvs_flisthead *, int); -int cvs_filelist_cmp(struct cvs_filelist *, struct cvs_filelist *); +int cvs_filelist_cmp(const struct cvs_filelist *, + const struct cvs_filelist *); int cvs_file_chkign(const char *); int cvs_file_cmpname(const char *, const char *); int cvs_file_cmp(const char *, const char *); Index: usr.bin/cvs/logmsg.c =================================================================== RCS file: /cvs/src/usr.bin/cvs/logmsg.c,v retrieving revision 1.60 diff -u -p -r1.60 logmsg.c --- usr.bin/cvs/logmsg.c 28 May 2017 16:57:01 -0000 1.60 +++ usr.bin/cvs/logmsg.c 21 Jun 2017 00:00:38 -0000 @@ -163,27 +163,27 @@ cvs_logmsg_create(char *dir, struct cvs_ dir != NULL ? dir : ".", CVS_LOGMSG_PREFIX); } - if (added != NULL && !RB_EMPTY(added)) { + if (added != NULL && !RBT_EMPTY(cvs_flisthead, added)) { fprintf(fp, "%s Added Files:", CVS_LOGMSG_PREFIX); - RB_FOREACH(cf, cvs_flisthead, added) + RBT_FOREACH(cf, cvs_flisthead, added) fprintf(fp, "\n%s \t%s ", CVS_LOGMSG_PREFIX, dir != NULL ? basename(cf->file_path) : cf->file_path); fputs("\n", fp); } - if (removed != NULL && !RB_EMPTY(removed)) { + if (removed != NULL && !RBT_EMPTY(cvs_flisthead, removed)) { fprintf(fp, "%s Removed Files:", CVS_LOGMSG_PREFIX); - RB_FOREACH(cf, cvs_flisthead, removed) + RBT_FOREACH(cf, cvs_flisthead, removed) fprintf(fp, "\n%s \t%s ", CVS_LOGMSG_PREFIX, dir != NULL ? basename(cf->file_path) : cf->file_path); fputs("\n", fp); } - if (modified != NULL && !RB_EMPTY(modified)) { + if (modified != NULL && !RBT_EMPTY(cvs_flisthead, modified)) { fprintf(fp, "%s Modified Files:", CVS_LOGMSG_PREFIX); - RB_FOREACH(cf, cvs_flisthead, modified) + RBT_FOREACH(cf, cvs_flisthead, modified) fprintf(fp, "\n%s \t%s ", CVS_LOGMSG_PREFIX, dir != NULL ? basename(cf->file_path) : cf->file_path); Index: usr.bin/cvs/modules.c =================================================================== RCS file: /cvs/src/usr.bin/cvs/modules.c,v retrieving revision 1.19 diff -u -p -r1.19 modules.c --- usr.bin/cvs/modules.c 5 Nov 2015 09:48:21 -0000 1.19 +++ usr.bin/cvs/modules.c 21 Jun 2017 00:00:38 -0000 @@ -159,8 +159,8 @@ modules_parse_line(char *line, int linen mi->mi_str = bline; dirname = NULL; - RB_INIT(&(mi->mi_modules)); - RB_INIT(&(mi->mi_ignores)); + RBT_INIT(cvs_flisthead, &(mi->mi_modules)); + RBT_INIT(cvs_flisthead, &(mi->mi_ignores)); for (sp = val; *sp != '\0'; sp = dp) { dp = sp; @@ -200,7 +200,8 @@ modules_parse_line(char *line, int linen } } - if (!(mi->mi_flags & MODULE_ALIAS) && RB_EMPTY(&(mi->mi_modules))) + if (!(mi->mi_flags & MODULE_ALIAS) && + RBT_EMPTY(cvs_flisthead, &(mi->mi_modules))) cvs_file_get(dirname, 0, &(mi->mi_modules), 0); TAILQ_INSERT_TAIL(&modules, mi, m_list); @@ -233,8 +234,8 @@ cvs_module_lookup(char *name) } } - RB_INIT(&(mc->mc_modules)); - RB_INIT(&(mc->mc_ignores)); + RBT_INIT(cvs_flisthead, &(mc->mc_modules)); + RBT_INIT(cvs_flisthead, &(mc->mc_ignores)); cvs_file_get(name, 0, &(mc->mc_modules), 0); mc->mc_canfree = 1; mc->mc_name = name; Index: usr.bin/cvs/server.c =================================================================== RCS file: /cvs/src/usr.bin/cvs/server.c,v retrieving revision 1.104 diff -u -p -r1.104 server.c --- usr.bin/cvs/server.c 9 Dec 2015 17:55:42 -0000 1.104 +++ usr.bin/cvs/server.c 21 Jun 2017 00:00:38 -0000 @@ -823,7 +823,7 @@ cvs_server_exp_modules(char *module) mo = cvs_module_lookup(server_argv[1]); - RB_FOREACH(fl, cvs_flisthead, &(mo->mc_modules)) + RBT_FOREACH(fl, cvs_flisthead, &(mo->mc_modules)) cvs_server_send_response("Module-expansion %s", fl->file_path); cvs_server_send_response("ok"); Index: usr.bin/doas/env.c =================================================================== RCS file: /cvs/src/usr.bin/doas/env.c,v retrieving revision 1.6 diff -u -p -r1.6 env.c --- usr.bin/doas/env.c 6 Apr 2017 21:12:06 -0000 1.6 +++ usr.bin/doas/env.c 21 Jun 2017 00:00:38 -0000 @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -28,22 +29,22 @@ #include "doas.h" struct envnode { - RB_ENTRY(envnode) node; + RBT_ENTRY(envnode) node; const char *key; const char *value; }; struct env { - RB_HEAD(envtree, envnode) root; + RBT_HEAD(envtree, envnode) root; u_int count; }; static int -envcmp(struct envnode *a, struct envnode *b) +envcmp(const struct envnode *a, const struct envnode *b) { return strcmp(a->key, b->key); } -RB_GENERATE_STATIC(envtree, envnode, node, envcmp) +RBT_PROTOTYPE(envtree, envnode, node, envcmp); static struct envnode * createnode(const char *key, const char *value) @@ -77,7 +78,7 @@ createenv(const struct rule *rule) env = malloc(sizeof(*env)); if (!env) err(1, NULL); - RB_INIT(&env->root); + RBT_INIT(envtree, &env->root); env->count = 0; if (rule->options & KEEPENV) { @@ -101,7 +102,7 @@ createenv(const struct rule *rule) name[len] = '\0'; node = createnode(name, eq + 1); - if (RB_INSERT(envtree, &env->root, node)) { + if (RBT_INSERT(envtree, &env->root, node)) { /* ignore any later duplicates */ freenode(node); } else { @@ -124,7 +125,7 @@ flattenenv(struct env *env) if (!envp) err(1, NULL); i = 0; - RB_FOREACH(node, envtree, &env->root) { + RBT_FOREACH(node, envtree, &env->root) { if (asprintf(&envp[i], "%s=%s", node->key, node->value) == -1) err(1, NULL); i++; @@ -160,8 +161,8 @@ fillenv(struct env *env, const char **en key.key = name; if (*name == '-') key.key = name + 1; - if ((node = RB_FIND(envtree, &env->root, &key))) { - RB_REMOVE(envtree, &env->root, node); + if ((node = RBT_FIND(envtree, &env->root, &key))) { + RBT_REMOVE(envtree, &env->root, node); freenode(node); env->count--; } @@ -179,7 +180,7 @@ fillenv(struct env *env, const char **en /* at last, we have something to insert */ if (val) { node = createnode(name, val); - RB_INSERT(envtree, &env->root, node); + RBT_INSERT(envtree, &env->root, node); env->count++; } } @@ -205,3 +206,5 @@ prepenv(const struct rule *rule) return flattenenv(env); } + +RBT_GENERATE(envtree, envnode, node, envcmp); Index: usr.bin/du/du.c =================================================================== RCS file: /cvs/src/usr.bin/du/du.c,v retrieving revision 1.32 diff -u -p -r1.32 du.c --- usr.bin/du/du.c 24 Aug 2016 03:13:45 -0000 1.32 +++ usr.bin/du/du.c 21 Jun 2017 00:00:38 -0000 @@ -43,6 +43,7 @@ #include #include #include +#include #include #include #include @@ -215,7 +216,7 @@ main(int argc, char *argv[]) struct links_entry { - RB_ENTRY(links_entry) entry; + RBT_ENTRY(links_entry) entry; struct links_entry *fnext; int links; dev_t dev; @@ -223,7 +224,7 @@ struct links_entry { }; static int -links_cmp(struct links_entry *e1, struct links_entry *e2) +links_cmp(const struct links_entry *e1, const struct links_entry *e2) { if (e1->dev == e2->dev) { if (e1->ino == e2->ino) @@ -235,9 +236,10 @@ links_cmp(struct links_entry *e1, struct return (e1->dev < e2->dev ? -1 : 1); } -RB_HEAD(ltree, links_entry) links = RB_INITIALIZER(&links); +RBT_HEAD(ltree, links_entry) links = RBT_INITIALIZER(&links); -RB_GENERATE_STATIC(ltree, links_entry, entry, links_cmp); +RBT_PROTOTYPE(ltree, links_entry, entry, links_cmp); +RBT_GENERATE(ltree, links_entry, entry, links_cmp); int @@ -253,14 +255,14 @@ linkchk(FTSENT *p) ltmp.ino = st->st_ino; ltmp.dev = st->st_dev; - le = RB_FIND(ltree, &links, <mp); + le = RBT_FIND(ltree, &links, <mp); if (le != NULL) { /* * Save memory by releasing an entry when we've seen * all of it's links. */ if (--le->links <= 0) { - RB_REMOVE(ltree, &links, le); + RBT_REMOVE(ltree, &links, le); /* Recycle this node through the free list */ if (stop_allocating) { free(le); @@ -295,7 +297,7 @@ linkchk(FTSENT *p) le->links = st->st_nlink - 1; le->fnext = NULL; - RB_INSERT(ltree, &links, le); + RBT_INSERT(ltree, &links, le); return (0); } Index: usr.bin/file/magic-dump.c =================================================================== RCS file: /cvs/src/usr.bin/file/magic-dump.c,v retrieving revision 1.2 diff -u -p -r1.2 magic-dump.c --- usr.bin/file/magic-dump.c 1 May 2016 10:56:03 -0000 1.2 +++ usr.bin/file/magic-dump.c 21 Jun 2017 00:00:38 -0000 @@ -52,9 +52,9 @@ magic_dump(struct magic *m) { struct magic_line *ml; - RB_FOREACH(ml, magic_tree, &m->tree) + RBT_FOREACH(ml, magic_tree, &m->tree) magic_dump_line(ml, 0); - RB_FOREACH(ml, magic_named_tree, &m->named) + RBT_FOREACH(ml, magic_named_tree, &m->named) magic_dump_line(ml, 0); } Index: usr.bin/file/magic-load.c =================================================================== RCS file: /cvs/src/usr.bin/file/magic-load.c,v retrieving revision 1.24 diff -u -p -r1.24 magic-load.c --- usr.bin/file/magic-load.c 18 Apr 2017 14:16:48 -0000 1.24 +++ usr.bin/file/magic-load.c 21 Jun 2017 00:00:38 -0000 @@ -25,6 +25,7 @@ #include #include #include +#include #include #include "magic.h" @@ -965,7 +966,7 @@ fail: } int -magic_compare(struct magic_line *ml1, struct magic_line *ml2) +magic_compare(const struct magic_line *ml1, const struct magic_line *ml2) { if (ml1->strength < ml2->strength) return (1); @@ -984,14 +985,14 @@ magic_compare(struct magic_line *ml1, st return (0); } -RB_GENERATE(magic_tree, magic_line, node, magic_compare); +RBT_GENERATE(magic_tree, magic_line, node, magic_compare); int -magic_named_compare(struct magic_line *ml1, struct magic_line *ml2) +magic_named_compare(const struct magic_line *ml1, const struct magic_line *ml2) { return (strcmp(ml1->name, ml2->name)); } -RB_GENERATE(magic_named_tree, magic_line, node, magic_named_compare); +RBT_GENERATE(magic_named_tree, magic_line, node, magic_named_compare); static void magic_adjust_strength(struct magic *m, u_int at, struct magic_line *ml, @@ -1076,7 +1077,7 @@ magic_load(FILE *f, const char *path, in m = xcalloc(1, sizeof *m); m->path = xstrdup(path); m->warnings = warnings; - RB_INIT(&m->tree); + RBT_INIT(magic_tree, &m->tree); parent = NULL; parent0 = NULL; @@ -1160,9 +1161,9 @@ magic_load(FILE *f, const char *path, in ml->strength = magic_get_strength(ml); if (ml->parent == NULL) { if (ml->name != NULL) - RB_INSERT(magic_named_tree, &m->named, ml); + RBT_INSERT(magic_named_tree, &m->named, ml); else - RB_INSERT(magic_tree, &m->tree, ml); + RBT_INSERT(magic_tree, &m->tree, ml); } else TAILQ_INSERT_TAIL(&ml->parent->children, ml, entry); parent0 = ml; Index: usr.bin/file/magic-test.c =================================================================== RCS file: /cvs/src/usr.bin/file/magic-test.c,v retrieving revision 1.25 diff -u -p -r1.25 magic-test.c --- usr.bin/file/magic-test.c 18 Apr 2017 14:16:48 -0000 1.25 +++ usr.bin/file/magic-test.c 21 Jun 2017 00:00:38 -0000 @@ -42,7 +42,7 @@ magic_get_named(struct magic *m, const c struct magic_line ml; ml.name = name; - return (RB_FIND(magic_named_tree, &m->named, &ml)); + return (RBT_FIND(magic_named_tree, &m->named, &ml)); } static enum magic_type @@ -1395,7 +1395,7 @@ magic_test(struct magic *m, const void * ms.text = !!(flags & MAGIC_TEST_TEXT); - RB_FOREACH(ml, magic_tree, &m->tree) { + RBT_FOREACH(ml, magic_tree, &m->tree) { ms.offset = 0; if (ml->text == ms.text && magic_test_line(ml, &ms)) break; Index: usr.bin/file/magic.h =================================================================== RCS file: /cvs/src/usr.bin/file/magic.h,v retrieving revision 1.15 diff -u -p -r1.15 magic.h --- usr.bin/file/magic.h 1 May 2016 20:34:26 -0000 1.15 +++ usr.bin/file/magic.h 21 Jun 2017 00:00:38 -0000 @@ -98,8 +98,8 @@ enum magic_type { }; TAILQ_HEAD(magic_lines, magic_line); -RB_HEAD(magic_tree, magic_line); -RB_HEAD(magic_named_tree, magic_line); +RBT_HEAD(magic_tree, magic_line); +RBT_HEAD(magic_named_tree, magic_line); struct magic_line { struct magic *root; @@ -142,7 +142,7 @@ struct magic_line { struct magic_lines children; TAILQ_ENTRY(magic_line) entry; - RB_ENTRY(magic_line) node; + RBT_ENTRY(magic_line) node; }; struct magic { @@ -177,11 +177,13 @@ struct magic_state { #define MAGIC_TEST_TEXT 0x1 #define MAGIC_TEST_MIME 0x2 -int magic_compare(struct magic_line *, struct magic_line *); -RB_PROTOTYPE(magic_tree, magic_line, node, magic_compare); - -int magic_named_compare(struct magic_line *, struct magic_line *); -RB_PROTOTYPE(magic_named_tree, magic_line, node, magic_named_compare); +int magic_compare(const struct magic_line *, + const struct magic_line *); +RBT_PROTOTYPE(magic_tree, magic_line, node, magic_compare); + +int magic_named_compare(const struct magic_line *, + const struct magic_line *); +RBT_PROTOTYPE(magic_named_tree, magic_line, node, magic_named_compare); char *magic_strtoull(const char *, uint64_t *); char *magic_strtoll(const char *, int64_t *); Index: usr.bin/mg/tags.c =================================================================== RCS file: /cvs/src/usr.bin/mg/tags.c,v retrieving revision 1.15 diff -u -p -r1.15 tags.c --- usr.bin/mg/tags.c 30 May 2017 07:05:22 -0000 1.15 +++ usr.bin/mg/tags.c 21 Jun 2017 00:00:38 -0000 @@ -16,6 +16,7 @@ #include #include #include +#include #include #include #include @@ -27,7 +28,7 @@ struct ctag; static int addctag(char *); static int atbow(void); void closetags(void); -static int ctagcmp(struct ctag *, struct ctag *); +static int ctagcmp(const struct ctag *, const struct ctag *); static int loadbuffer(char *); static int loadtags(const char *); static int pushtag(char *); @@ -43,13 +44,14 @@ int loaded = FALSE; /* ctags(1) entries are parsed and maintained in a tree. */ struct ctag { - RB_ENTRY(ctag) entry; + RBT_ENTRY(ctag) entry; char *tag; char *fname; char *pat; }; -RB_HEAD(tagtree, ctag) tags = RB_INITIALIZER(&tags); -RB_GENERATE(tagtree, ctag, entry, ctagcmp); +RBT_HEAD(tagtree, ctag) tags = RBT_INITIALIZER(&tags); +RBT_PROTOTYPE(tagtree, ctag, entry, ctagcmp); +RBT_GENERATE(tagtree, ctag, entry, ctagcmp); struct tagpos { SLIST_ENTRY(tagpos) entry; @@ -60,7 +62,7 @@ struct tagpos { SLIST_HEAD(tagstack, tagpos) shead = SLIST_HEAD_INITIALIZER(shead); int -ctagcmp(struct ctag *s, struct ctag *t) +ctagcmp(const struct ctag *s, const struct ctag *t) { return strcmp(s->tag, t->tag); } @@ -190,9 +192,9 @@ unloadtags(void) { struct ctag *var, *nxt; - for (var = RB_MIN(tagtree, &tags); var != NULL; var = nxt) { - nxt = RB_NEXT(tagtree, &tags, var); - RB_REMOVE(tagtree, &tags, var); + for (var = RBT_MIN(tagtree, &tags); var != NULL; var = nxt) { + nxt = RBT_NEXT(tagtree, var); + RBT_REMOVE(tagtree, &tags, var); /* line parsed with fparseln needs to be freed */ free(var->tag); free(var); @@ -390,7 +392,7 @@ addctag(char *l) if (*l == '\0') goto cleanup; t->pat = strip(l, strlen(l)); - RB_INSERT(tagtree, &tags, t); + RBT_INSERT(tagtree, &tags, t); return (TRUE); cleanup: free(t); @@ -507,7 +509,7 @@ searchtag(char *tok) struct ctag t, *res; t.tag = tok; - if ((res = RB_FIND(tagtree, &tags, &t)) == NULL) { + if ((res = RBT_FIND(tagtree, &tags, &t)) == NULL) { dobeep(); ewprintf("No tag containing %s", tok); return (NULL); Index: usr.bin/ssh/krl.c =================================================================== RCS file: /cvs/src/usr.bin/ssh/krl.c,v retrieving revision 1.40 diff -u -p -r1.40 krl.c --- usr.bin/ssh/krl.c 31 May 2017 09:15:42 -0000 1.40 +++ usr.bin/ssh/krl.c 21 Jun 2017 00:00:38 -0000 @@ -26,6 +26,7 @@ #include #include #include +#include #include "sshbuf.h" #include "ssherr.h" @@ -53,30 +54,36 @@ /* Tree of serial numbers. XXX make smarter: really need a real sparse bitmap */ struct revoked_serial { u_int64_t lo, hi; - RB_ENTRY(revoked_serial) tree_entry; + RBT_ENTRY(revoked_serial) tree_entry; }; -static int serial_cmp(struct revoked_serial *a, struct revoked_serial *b); -RB_HEAD(revoked_serial_tree, revoked_serial); -RB_GENERATE_STATIC(revoked_serial_tree, revoked_serial, tree_entry, serial_cmp); +static int serial_cmp(const struct revoked_serial *a, + const struct revoked_serial *b); +RBT_HEAD(revoked_serial_tree, revoked_serial); +RBT_PROTOTYPE(revoked_serial_tree, revoked_serial, tree_entry, serial_cmp); +RBT_GENERATE(revoked_serial_tree, revoked_serial, tree_entry, serial_cmp); /* Tree of key IDs */ struct revoked_key_id { char *key_id; - RB_ENTRY(revoked_key_id) tree_entry; + RBT_ENTRY(revoked_key_id) tree_entry; }; -static int key_id_cmp(struct revoked_key_id *a, struct revoked_key_id *b); -RB_HEAD(revoked_key_id_tree, revoked_key_id); -RB_GENERATE_STATIC(revoked_key_id_tree, revoked_key_id, tree_entry, key_id_cmp); +static int key_id_cmp(const struct revoked_key_id *a, + const struct revoked_key_id *b); +RBT_HEAD(revoked_key_id_tree, revoked_key_id); +RBT_PROTOTYPE(revoked_key_id_tree, revoked_key_id, tree_entry, key_id_cmp); +RBT_GENERATE(revoked_key_id_tree, revoked_key_id, tree_entry, key_id_cmp); /* Tree of blobs (used for keys and fingerprints) */ struct revoked_blob { u_char *blob; size_t len; - RB_ENTRY(revoked_blob) tree_entry; + RBT_ENTRY(revoked_blob) tree_entry; }; -static int blob_cmp(struct revoked_blob *a, struct revoked_blob *b); -RB_HEAD(revoked_blob_tree, revoked_blob); -RB_GENERATE_STATIC(revoked_blob_tree, revoked_blob, tree_entry, blob_cmp); +static int blob_cmp(const struct revoked_blob *a, + const struct revoked_blob *b); +RBT_HEAD(revoked_blob_tree, revoked_blob); +RBT_PROTOTYPE(revoked_blob_tree, revoked_blob, tree_entry, blob_cmp); +RBT_GENERATE(revoked_blob_tree, revoked_blob, tree_entry, blob_cmp); /* Tracks revoked certs for a single CA */ struct revoked_certs { @@ -99,7 +106,7 @@ struct ssh_krl { /* Return equal if a and b overlap */ static int -serial_cmp(struct revoked_serial *a, struct revoked_serial *b) +serial_cmp(const struct revoked_serial *a, const struct revoked_serial *b) { if (a->hi >= b->lo && a->lo <= b->hi) return 0; @@ -107,13 +114,13 @@ serial_cmp(struct revoked_serial *a, str } static int -key_id_cmp(struct revoked_key_id *a, struct revoked_key_id *b) +key_id_cmp(const struct revoked_key_id *a, const struct revoked_key_id *b) { return strcmp(a->key_id, b->key_id); } static int -blob_cmp(struct revoked_blob *a, struct revoked_blob *b) +blob_cmp(const struct revoked_blob *a, const struct revoked_blob *b) { int r; @@ -132,8 +139,8 @@ ssh_krl_init(void) if ((krl = calloc(1, sizeof(*krl))) == NULL) return NULL; - RB_INIT(&krl->revoked_keys); - RB_INIT(&krl->revoked_sha1s); + RBT_INIT(revoked_blob_tree, &krl->revoked_keys); + RBT_INIT(revoked_blob_tree, &krl->revoked_sha1s); TAILQ_INIT(&krl->revoked_certs); return krl; } @@ -144,12 +151,12 @@ revoked_certs_free(struct revoked_certs struct revoked_serial *rs, *trs; struct revoked_key_id *rki, *trki; - RB_FOREACH_SAFE(rs, revoked_serial_tree, &rc->revoked_serials, trs) { - RB_REMOVE(revoked_serial_tree, &rc->revoked_serials, rs); + RBT_FOREACH_SAFE(rs, revoked_serial_tree, &rc->revoked_serials, trs) { + RBT_REMOVE(revoked_serial_tree, &rc->revoked_serials, rs); free(rs); } - RB_FOREACH_SAFE(rki, revoked_key_id_tree, &rc->revoked_key_ids, trki) { - RB_REMOVE(revoked_key_id_tree, &rc->revoked_key_ids, rki); + RBT_FOREACH_SAFE(rki, revoked_key_id_tree, &rc->revoked_key_ids, trki) { + RBT_REMOVE(revoked_key_id_tree, &rc->revoked_key_ids, rki); free(rki->key_id); free(rki); } @@ -166,13 +173,13 @@ ssh_krl_free(struct ssh_krl *krl) return; free(krl->comment); - RB_FOREACH_SAFE(rb, revoked_blob_tree, &krl->revoked_keys, trb) { - RB_REMOVE(revoked_blob_tree, &krl->revoked_keys, rb); + RBT_FOREACH_SAFE(rb, revoked_blob_tree, &krl->revoked_keys, trb) { + RBT_REMOVE(revoked_blob_tree, &krl->revoked_keys, rb); free(rb->blob); free(rb); } - RB_FOREACH_SAFE(rb, revoked_blob_tree, &krl->revoked_sha1s, trb) { - RB_REMOVE(revoked_blob_tree, &krl->revoked_sha1s, rb); + RBT_FOREACH_SAFE(rb, revoked_blob_tree, &krl->revoked_sha1s, trb) { + RBT_REMOVE(revoked_blob_tree, &krl->revoked_sha1s, rb); free(rb->blob); free(rb); } @@ -227,8 +234,8 @@ revoked_certs_for_ca_key(struct ssh_krl free(rc); return r; } - RB_INIT(&rc->revoked_serials); - RB_INIT(&rc->revoked_key_ids); + RBT_INIT(revoked_serial_tree, &rc->revoked_serials); + RBT_INIT(revoked_key_id_tree, &rc->revoked_key_ids); TAILQ_INSERT_TAIL(&krl->revoked_certs, rc, entry); KRL_DBG(("%s: new CA %s", __func__, ca_key == NULL ? "*" : sshkey_type(ca_key))); @@ -245,13 +252,13 @@ insert_serial_range(struct revoked_seria memset(&rs, 0, sizeof(rs)); rs.lo = lo; rs.hi = hi; - ers = RB_NFIND(revoked_serial_tree, rt, &rs); + ers = RBT_NFIND(revoked_serial_tree, rt, &rs); if (ers == NULL || serial_cmp(ers, &rs) != 0) { /* No entry matches. Just insert */ if ((irs = malloc(sizeof(rs))) == NULL) return SSH_ERR_ALLOC_FAIL; memcpy(irs, &rs, sizeof(*irs)); - ers = RB_INSERT(revoked_serial_tree, rt, irs); + ers = RBT_INSERT(revoked_serial_tree, rt, irs); if (ers != NULL) { KRL_DBG(("%s: bad: ers != NULL", __func__)); /* Shouldn't happen */ @@ -278,7 +285,7 @@ insert_serial_range(struct revoked_seria */ /* Check predecessors */ - while ((crs = RB_PREV(revoked_serial_tree, rt, ers)) != NULL) { + while ((crs = RBT_PREV(revoked_serial_tree, ers)) != NULL) { KRL_DBG(("%s: pred %llu:%llu", __func__, crs->lo, crs->hi)); if (ers->lo != 0 && crs->hi < ers->lo - 1) break; @@ -288,11 +295,11 @@ insert_serial_range(struct revoked_seria KRL_DBG(("%s: pred extend %llu:%llu", __func__, ers->lo, ers->hi)); } - RB_REMOVE(revoked_serial_tree, rt, crs); + RBT_REMOVE(revoked_serial_tree, rt, crs); free(crs); } /* Check successors */ - while ((crs = RB_NEXT(revoked_serial_tree, rt, ers)) != NULL) { + while ((crs = RBT_NEXT(revoked_serial_tree, ers)) != NULL) { KRL_DBG(("%s: succ %llu:%llu", __func__, crs->lo, crs->hi)); if (ers->hi != (u_int64_t)-1 && crs->lo > ers->hi + 1) break; @@ -302,7 +309,7 @@ insert_serial_range(struct revoked_seria KRL_DBG(("%s: succ extend %llu:%llu", __func__, ers->lo, ers->hi)); } - RB_REMOVE(revoked_serial_tree, rt, crs); + RBT_REMOVE(revoked_serial_tree, rt, crs); free(crs); } KRL_DBG(("%s: done, final %llu:%llu", __func__, ers->lo, ers->hi)); @@ -347,7 +354,7 @@ ssh_krl_revoke_cert_by_key_id(struct ssh free(rki); return SSH_ERR_ALLOC_FAIL; } - erki = RB_INSERT(revoked_key_id_tree, &rc->revoked_key_ids, rki); + erki = RBT_INSERT(revoked_key_id_tree, &rc->revoked_key_ids, rki); if (erki != NULL) { free(rki->key_id); free(rki); @@ -385,7 +392,7 @@ revoke_blob(struct revoked_blob_tree *rb return SSH_ERR_ALLOC_FAIL; rb->blob = blob; rb->len = len; - erb = RB_INSERT(revoked_blob_tree, rbt, rb); + erb = RBT_INSERT(revoked_blob_tree, rbt, rb); if (erb != NULL) { free(rb->blob); free(rb); @@ -566,15 +573,15 @@ revoked_certs_generate(struct revoked_ce goto out; /* Store the revoked serials. */ - for (rs = RB_MIN(revoked_serial_tree, &rc->revoked_serials); + for (rs = RBT_MIN(revoked_serial_tree, &rc->revoked_serials); rs != NULL; - rs = RB_NEXT(revoked_serial_tree, &rc->revoked_serials, rs)) { + rs = RBT_NEXT(revoked_serial_tree, rs)) { KRL_DBG(("%s: serial %llu:%llu state 0x%02x", __func__, (long long unsigned)rs->lo, (long long unsigned)rs->hi, state)); /* Check contiguous length and gap to next section (if any) */ - nrs = RB_NEXT(revoked_serial_tree, &rc->revoked_serials, rs); + nrs = RBT_NEXT(revoked_serial_tree, rs); final = nrs == NULL; gap = nrs == NULL ? 0 : nrs->lo - rs->hi; contig = 1 + (rs->hi - rs->lo); @@ -682,7 +689,7 @@ revoked_certs_generate(struct revoked_ce /* Now output a section for any revocations by key ID */ sshbuf_reset(sect); - RB_FOREACH(rki, revoked_key_id_tree, &rc->revoked_key_ids) { + RBT_FOREACH(rki, revoked_key_id_tree, &rc->revoked_key_ids) { KRL_DBG(("%s: key ID %s", __func__, rki->key_id)); if ((r = sshbuf_put_cstring(sect, rki->key_id)) != 0) goto out; @@ -738,7 +745,7 @@ ssh_krl_to_blob(struct ssh_krl *krl, str /* Finally, output sections for revocations by public key/hash */ sshbuf_reset(sect); - RB_FOREACH(rb, revoked_blob_tree, &krl->revoked_keys) { + RBT_FOREACH(rb, revoked_blob_tree, &krl->revoked_keys) { KRL_DBG(("%s: key len %zu ", __func__, rb->len)); if ((r = sshbuf_put_string(sect, rb->blob, rb->len)) != 0) goto out; @@ -749,7 +756,7 @@ ssh_krl_to_blob(struct ssh_krl *krl, str goto out; } sshbuf_reset(sect); - RB_FOREACH(rb, revoked_blob_tree, &krl->revoked_sha1s) { + RBT_FOREACH(rb, revoked_blob_tree, &krl->revoked_sha1s) { KRL_DBG(("%s: hash len %zu ", __func__, rb->len)); if ((r = sshbuf_put_string(sect, rb->blob, rb->len)) != 0) goto out; @@ -1165,7 +1172,7 @@ is_cert_revoked(const struct sshkey *key /* Check revocation by cert key ID */ memset(&rki, 0, sizeof(rki)); rki.key_id = key->cert->key_id; - erki = RB_FIND(revoked_key_id_tree, &rc->revoked_key_ids, &rki); + erki = RBT_FIND(revoked_key_id_tree, &rc->revoked_key_ids, &rki); if (erki != NULL) { KRL_DBG(("%s: revoked by key ID", __func__)); return SSH_ERR_KEY_REVOKED; @@ -1180,7 +1187,7 @@ is_cert_revoked(const struct sshkey *key memset(&rs, 0, sizeof(rs)); rs.lo = rs.hi = key->cert->serial; - ers = RB_FIND(revoked_serial_tree, &rc->revoked_serials, &rs); + ers = RBT_FIND(revoked_serial_tree, &rc->revoked_serials, &rs); if (ers != NULL) { KRL_DBG(("%s: revoked serial %llu matched %llu:%llu", __func__, key->cert->serial, ers->lo, ers->hi)); @@ -1202,7 +1209,7 @@ is_key_revoked(struct ssh_krl *krl, cons if ((r = sshkey_fingerprint_raw(key, SSH_DIGEST_SHA1, &rb.blob, &rb.len)) != 0) return r; - erb = RB_FIND(revoked_blob_tree, &krl->revoked_sha1s, &rb); + erb = RBT_FIND(revoked_blob_tree, &krl->revoked_sha1s, &rb); free(rb.blob); if (erb != NULL) { KRL_DBG(("%s: revoked by key SHA1", __func__)); @@ -1213,7 +1220,7 @@ is_key_revoked(struct ssh_krl *krl, cons memset(&rb, 0, sizeof(rb)); if ((r = plain_key_blob(key, &rb.blob, &rb.len)) != 0) return r; - erb = RB_FIND(revoked_blob_tree, &krl->revoked_keys, &rb); + erb = RBT_FIND(revoked_blob_tree, &krl->revoked_keys, &rb); free(rb.blob); if (erb != NULL) { KRL_DBG(("%s: revoked by explicit key", __func__)); Index: usr.bin/systat/cache.c =================================================================== RCS file: /cvs/src/usr.bin/systat/cache.c,v retrieving revision 1.7 diff -u -p -r1.7 cache.c --- usr.bin/systat/cache.c 26 Aug 2016 09:10:11 -0000 1.7 +++ usr.bin/systat/cache.c 21 Jun 2017 00:00:38 -0000 @@ -32,6 +32,7 @@ #include #include +#include #include #include @@ -41,12 +42,13 @@ /* prototypes */ void update_state(struct sc_ent *, struct pfsync_state *, double); struct sc_ent *cache_state(struct pfsync_state *); -static __inline int sc_cmp(struct sc_ent *s1, struct sc_ent *s2); +static __inline int sc_cmp(const struct sc_ent *s1, const struct sc_ent *s2); /* initialize the tree and queue */ -RB_HEAD(sc_tree, sc_ent) sctree; +RBT_HEAD(sc_tree, sc_ent) sctree; TAILQ_HEAD(sc_queue, sc_ent) scq1, scq2, scq_free; -RB_GENERATE(sc_tree, sc_ent, tlink, sc_cmp) +RBT_PROTOTYPE(sc_tree, sc_ent, tlink, sc_cmp); +RBT_GENERATE(sc_tree, sc_ent, tlink, sc_cmp); struct sc_queue *scq_act = NULL; struct sc_queue *scq_exp = NULL; @@ -74,7 +76,7 @@ cache_init(int max) return (1); } - RB_INIT(&sctree); + RBT_INIT(sc_tree, &sctree); TAILQ_INIT(&scq1); TAILQ_INIT(&scq2); TAILQ_INIT(&scq_free); @@ -126,7 +128,7 @@ add_state(struct pfsync_state *st) ent->rate = 0; ent->t = 0; - RB_INSERT(sc_tree, &sctree, ent); + RBT_INSERT(sc_tree, &sctree, ent); TAILQ_INSERT_HEAD(scq_act, ent, qlink); } @@ -142,7 +144,7 @@ cache_state(struct pfsync_state *st) ent.id = st->id; ent.creatorid = st->creatorid; - old = RB_FIND(sc_tree, &sctree, &ent); + old = RBT_FIND(sc_tree, &sctree, &ent); if (old == NULL) { add_state(st); @@ -177,7 +179,7 @@ cache_endupdate(void) while (! TAILQ_EMPTY(scq_exp)) { ent = TAILQ_FIRST(scq_exp); TAILQ_REMOVE(scq_exp, ent, qlink); - RB_REMOVE(sc_tree, &sctree, ent); + RBT_REMOVE(sc_tree, &sctree, ent); TAILQ_INSERT_HEAD(&scq_free, ent, qlink); cache_size++; } @@ -188,7 +190,7 @@ cache_endupdate(void) } static __inline int -sc_cmp(struct sc_ent *a, struct sc_ent *b) +sc_cmp(const struct sc_ent *a, const struct sc_ent *b) { if (a->id > b->id) return (1); Index: usr.bin/tmux/alerts.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/alerts.c,v retrieving revision 1.19 diff -u -p -r1.19 alerts.c --- usr.bin/tmux/alerts.c 28 Apr 2017 19:13:55 -0000 1.19 +++ usr.bin/tmux/alerts.c 21 Jun 2017 00:00:38 -0000 @@ -85,7 +85,7 @@ alerts_check_session(struct session *s) { struct winlink *wl; - RB_FOREACH(wl, winlinks, &s->windows) + RBT_FOREACH(wl, winlinks, &s->windows) alerts_check_all(wl->window); } @@ -110,7 +110,7 @@ alerts_reset_all(void) { struct window *w; - RB_FOREACH(w, windows, &windows) + RBT_FOREACH(w, windows, &windows) alerts_reset(w); } Index: usr.bin/tmux/arguments.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/arguments.c,v retrieving revision 1.19 diff -u -p -r1.19 arguments.c --- usr.bin/tmux/arguments.c 30 May 2017 21:44:59 -0000 1.19 +++ usr.bin/tmux/arguments.c 21 Jun 2017 00:00:38 -0000 @@ -19,6 +19,7 @@ #include #include +#include #include #include #include @@ -32,17 +33,18 @@ struct args_entry { u_char flag; char *value; - RB_ENTRY(args_entry) entry; + RBT_ENTRY(args_entry) entry; }; static struct args_entry *args_find(struct args *, u_char); -static int args_cmp(struct args_entry *, struct args_entry *); -RB_GENERATE_STATIC(args_tree, args_entry, entry, args_cmp); +static int args_cmp(const struct args_entry *, const struct args_entry *); +RBT_PROTOTYPE(args_tree, args_entry, entry, args_cmp); +RBT_GENERATE(args_tree, args_entry, entry, args_cmp); /* Arguments tree comparison function. */ static int -args_cmp(struct args_entry *a1, struct args_entry *a2) +args_cmp(const struct args_entry *a1, const struct args_entry *a2) { return (a1->flag - a2->flag); } @@ -54,7 +56,7 @@ args_find(struct args *args, u_char ch) struct args_entry entry; entry.flag = ch; - return (RB_FIND(args_tree, &args->tree, &entry)); + return (RBT_FIND(args_tree, &args->tree, &entry)); } /* Parse an argv and argc into a new argument set. */ @@ -96,8 +98,8 @@ args_free(struct args *args) cmd_free_argv(args->argc, args->argv); - RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) { - RB_REMOVE(args_tree, &args->tree, entry); + RBT_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) { + RBT_REMOVE(args_tree, &args->tree, entry); free(entry->value); free(entry); } @@ -138,7 +140,7 @@ args_print(struct args *args) buf = xcalloc(1, len); /* Process the flags first. */ - RB_FOREACH(entry, args_tree, &args->tree) { + RBT_FOREACH(entry, args_tree, &args->tree) { if (entry->value != NULL) continue; @@ -148,7 +150,7 @@ args_print(struct args *args) } /* Then the flags with arguments. */ - RB_FOREACH(entry, args_tree, &args->tree) { + RBT_FOREACH(entry, args_tree, &args->tree) { if (entry->value == NULL) continue; @@ -207,7 +209,7 @@ args_set(struct args *args, u_char ch, c } else { entry = xcalloc(1, sizeof *entry); entry->flag = ch; - RB_INSERT(args_tree, &args->tree, entry); + RBT_INSERT(args_tree, &args->tree, entry); } if (value != NULL) Index: usr.bin/tmux/cfg.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cfg.c,v retrieving revision 1.60 diff -u -p -r1.60 cfg.c --- usr.bin/tmux/cfg.c 30 May 2017 21:44:59 -0000 1.60 +++ usr.bin/tmux/cfg.c 21 Jun 2017 00:00:38 -0000 @@ -48,8 +48,8 @@ cfg_done(__unused struct cmdq_item *item return (CMD_RETURN_NORMAL); cfg_finished = 1; - if (!RB_EMPTY(&sessions)) - cfg_show_causes(RB_MIN(sessions, &sessions)); + if (!RBT_EMPTY(sessions, &sessions)) + cfg_show_causes(RBT_MIN(sessions, &sessions)); if (cfg_item != NULL) cfg_item->flags &= ~CMDQ_WAITING; Index: usr.bin/tmux/cmd-attach-session.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-attach-session.c,v retrieving revision 1.73 diff -u -p -r1.73 cmd-attach-session.c --- usr.bin/tmux/cmd-attach-session.c 22 Apr 2017 10:22:39 -0000 1.73 +++ usr.bin/tmux/cmd-attach-session.c 21 Jun 2017 00:00:38 -0000 @@ -59,7 +59,7 @@ cmd_attach_session(struct cmdq_item *ite struct window_pane *wp; char *cause; - if (RB_EMPTY(&sessions)) { + if (RBT_EMPTY(sessions, &sessions)) { cmdq_error(item, "no sessions"); return (CMD_RETURN_ERROR); } Index: usr.bin/tmux/cmd-find.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-find.c,v retrieving revision 1.54 diff -u -p -r1.54 cmd-find.c --- usr.bin/tmux/cmd-find.c 16 Jun 2017 15:12:38 -0000 1.54 +++ usr.bin/tmux/cmd-find.c 21 Jun 2017 00:00:38 -0000 @@ -158,7 +158,7 @@ cmd_find_best_session(struct session **s s = slist[i]; } } else { - RB_FOREACH(s_loop, sessions, &sessions) { + RBT_FOREACH(s_loop, sessions, &sessions) { if (cmd_find_session_better(s_loop, s, flags)) s = s_loop; } @@ -175,7 +175,7 @@ cmd_find_best_session_with_window(struct struct session *s; ssize = 0; - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { if (!session_has(s, fs->w)) continue; slist = xreallocarray(slist, ssize + 1, sizeof *slist); @@ -207,7 +207,7 @@ cmd_find_best_winlink_with_window(struct if (fs->s->curw != NULL && fs->s->curw->window == fs->w) wl = fs->s->curw; else { - RB_FOREACH(wl_loop, winlinks, &fs->s->windows) { + RBT_FOREACH(wl_loop, winlinks, &fs->s->windows) { if (wl_loop->window == fs->w) { wl = wl_loop; break; @@ -269,7 +269,7 @@ cmd_find_get_session(struct cmd_find_sta /* Otherwise look for prefix. */ s = NULL; - RB_FOREACH(s_loop, sessions, &sessions) { + RBT_FOREACH(s_loop, sessions, &sessions) { if (strncmp(session, s_loop->name, strlen(session)) == 0) { if (s != NULL) return (-1); @@ -283,7 +283,7 @@ cmd_find_get_session(struct cmd_find_sta /* Then as a pattern. */ s = NULL; - RB_FOREACH(s_loop, sessions, &sessions) { + RBT_FOREACH(s_loop, sessions, &sessions) { if (fnmatch(session, s_loop->name, 0) == 0) { if (s != NULL) return (-1); @@ -401,14 +401,14 @@ cmd_find_get_window_with_session(struct fs->w = fs->wl->window; return (0); } else if (strcmp(window, "^") == 0) { - fs->wl = RB_MIN(winlinks, &fs->s->windows); + fs->wl = RBT_MIN(winlinks, &fs->s->windows); if (fs->wl == NULL) return (-1); fs->idx = fs->wl->idx; fs->w = fs->wl->window; return (0); } else if (strcmp(window, "$") == 0) { - fs->wl = RB_MAX(winlinks, &fs->s->windows); + fs->wl = RBT_MAX(winlinks, &fs->s->windows); if (fs->wl == NULL) return (-1); fs->idx = fs->wl->idx; @@ -435,7 +435,7 @@ cmd_find_get_window_with_session(struct /* Look for exact matches, error if more than one. */ fs->wl = NULL; - RB_FOREACH(wl, winlinks, &fs->s->windows) { + RBT_FOREACH(wl, winlinks, &fs->s->windows) { if (strcmp(window, wl->window->name) == 0) { if (fs->wl != NULL) return (-1); @@ -454,7 +454,7 @@ cmd_find_get_window_with_session(struct /* Try as the start of a window name, error if multiple. */ fs->wl = NULL; - RB_FOREACH(wl, winlinks, &fs->s->windows) { + RBT_FOREACH(wl, winlinks, &fs->s->windows) { if (strncmp(window, wl->window->name, strlen(window)) == 0) { if (fs->wl != NULL) return (-1); @@ -469,7 +469,7 @@ cmd_find_get_window_with_session(struct /* Now look for pattern matches, again error if multiple. */ fs->wl = NULL; - RB_FOREACH(wl, winlinks, &fs->s->windows) { + RBT_FOREACH(wl, winlinks, &fs->s->windows) { if (fnmatch(window, wl->window->name, 0) == 0) { if (fs->wl != NULL) return (-1); @@ -663,7 +663,7 @@ cmd_find_valid_state(struct cmd_find_sta if (!session_alive(fs->s)) return (0); - RB_FOREACH(wl, winlinks, &fs->s->windows) { + RBT_FOREACH(wl, winlinks, &fs->s->windows) { if (wl->window == fs->w && wl == fs->wl) break; } @@ -875,7 +875,7 @@ cmd_find_from_client(struct cmd_find_sta * If this is an unattached client running in a pane, we can use that * to limit the list of sessions to those containing that pane. */ - RB_FOREACH(wp, window_pane_tree, &all_window_panes) { + RBT_FOREACH(wp, window_pane_tree, &all_window_panes) { if (strcmp(wp->tty, c->ttyname) == 0) break; } @@ -885,7 +885,7 @@ cmd_find_from_client(struct cmd_find_sta /* If we have a session in TMUX, see if it has this pane. */ s = cmd_find_try_TMUX(c); if (s != NULL) { - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { if (window_has_pane(wl->window, wp)) break; } Index: usr.bin/tmux/cmd-kill-session.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-kill-session.c,v retrieving revision 1.23 diff -u -p -r1.23 cmd-kill-session.c --- usr.bin/tmux/cmd-kill-session.c 22 Apr 2017 10:22:39 -0000 1.23 +++ usr.bin/tmux/cmd-kill-session.c 21 Jun 2017 00:00:38 -0000 @@ -52,13 +52,13 @@ cmd_kill_session_exec(struct cmd *self, s = item->target.s; if (args_has(args, 'C')) { - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { wl->window->flags &= ~WINDOW_ALERTFLAGS; wl->flags &= ~WINLINK_ALERTFLAGS; } server_redraw_session(s); } else if (args_has(args, 'a')) { - RB_FOREACH_SAFE(sloop, sessions, &sessions, stmp) { + RBT_FOREACH_SAFE(sloop, sessions, &sessions, stmp) { if (sloop != s) { server_destroy_session(sloop); session_destroy(sloop); Index: usr.bin/tmux/cmd-kill-window.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-kill-window.c,v retrieving revision 1.24 diff -u -p -r1.24 cmd-kill-window.c --- usr.bin/tmux/cmd-kill-window.c 22 Apr 2017 10:22:39 -0000 1.24 +++ usr.bin/tmux/cmd-kill-window.c 21 Jun 2017 00:00:38 -0000 @@ -68,7 +68,7 @@ cmd_kill_window_exec(struct cmd *self, s server_unlink_window(s, wl); } else { if (args_has(args, 'a')) { - RB_FOREACH_SAFE(wl2, winlinks, &s->windows, wl3) { + RBT_FOREACH_SAFE(wl2, winlinks, &s->windows, wl3) { if (wl != wl2) server_kill_window(wl2->window); } Index: usr.bin/tmux/cmd-list-keys.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-list-keys.c,v retrieving revision 1.44 diff -u -p -r1.44 cmd-list-keys.c --- usr.bin/tmux/cmd-list-keys.c 1 May 2017 12:20:55 -0000 1.44 +++ usr.bin/tmux/cmd-list-keys.c 21 Jun 2017 00:00:38 -0000 @@ -75,10 +75,10 @@ cmd_list_keys_exec(struct cmd *self, str repeat = 0; tablewidth = keywidth = 0; - RB_FOREACH(table, key_tables, &key_tables) { + RBT_FOREACH(table, key_tables, &key_tables) { if (tablename != NULL && strcmp(table->name, tablename) != 0) continue; - RB_FOREACH(bd, key_bindings, &table->key_bindings) { + RBT_FOREACH(bd, key_bindings, &table->key_bindings) { key = key_string_lookup_key(bd->key); if (bd->flags & KEY_BINDING_REPEAT) @@ -93,10 +93,10 @@ cmd_list_keys_exec(struct cmd *self, str } } - RB_FOREACH(table, key_tables, &key_tables) { + RBT_FOREACH(table, key_tables, &key_tables) { if (tablename != NULL && strcmp(table->name, tablename) != 0) continue; - RB_FOREACH(bd, key_bindings, &table->key_bindings) { + RBT_FOREACH(bd, key_bindings, &table->key_bindings) { key = key_string_lookup_key(bd->key); if (!repeat) Index: usr.bin/tmux/cmd-list-panes.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-list-panes.c,v retrieving revision 1.33 diff -u -p -r1.33 cmd-list-panes.c --- usr.bin/tmux/cmd-list-panes.c 1 May 2017 12:20:55 -0000 1.33 +++ usr.bin/tmux/cmd-list-panes.c 21 Jun 2017 00:00:38 -0000 @@ -69,7 +69,7 @@ cmd_list_panes_server(struct cmd *self, { struct session *s; - RB_FOREACH(s, sessions, &sessions) + RBT_FOREACH(s, sessions, &sessions) cmd_list_panes_session(self, s, item, 2); } @@ -79,7 +79,7 @@ cmd_list_panes_session(struct cmd *self, { struct winlink *wl; - RB_FOREACH(wl, winlinks, &s->windows) + RBT_FOREACH(wl, winlinks, &s->windows) cmd_list_panes_window(self, s, wl, item, type); } Index: usr.bin/tmux/cmd-list-sessions.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-list-sessions.c,v retrieving revision 1.29 diff -u -p -r1.29 cmd-list-sessions.c --- usr.bin/tmux/cmd-list-sessions.c 1 May 2017 12:20:55 -0000 1.29 +++ usr.bin/tmux/cmd-list-sessions.c 21 Jun 2017 00:00:38 -0000 @@ -64,7 +64,7 @@ cmd_list_sessions_exec(struct cmd *self, template = LIST_SESSIONS_TEMPLATE; n = 0; - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { ft = format_create(item->client, item, FORMAT_NONE, 0); format_add(ft, "line", "%u", n); format_defaults(ft, NULL, s, NULL, NULL); Index: usr.bin/tmux/cmd-list-windows.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-list-windows.c,v retrieving revision 1.43 diff -u -p -r1.43 cmd-list-windows.c --- usr.bin/tmux/cmd-list-windows.c 1 May 2017 12:20:55 -0000 1.43 +++ usr.bin/tmux/cmd-list-windows.c 21 Jun 2017 00:00:38 -0000 @@ -76,7 +76,7 @@ cmd_list_windows_server(struct cmd *self { struct session *s; - RB_FOREACH(s, sessions, &sessions) + RBT_FOREACH(s, sessions, &sessions) cmd_list_windows_session(self, s, item, 1); } @@ -104,7 +104,7 @@ cmd_list_windows_session(struct cmd *sel } n = 0; - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { ft = format_create(item->client, item, FORMAT_NONE, 0); format_add(ft, "line", "%u", n); format_defaults(ft, NULL, s, wl, NULL); Index: usr.bin/tmux/cmd-new-session.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-new-session.c,v retrieving revision 1.107 diff -u -p -r1.107 cmd-new-session.c --- usr.bin/tmux/cmd-new-session.c 28 May 2017 19:46:55 -0000 1.107 +++ usr.bin/tmux/cmd-new-session.c 21 Jun 2017 00:00:38 -0000 @@ -280,7 +280,7 @@ cmd_new_session_exec(struct cmd *self, s } session_group_add(sg, s); session_group_synchronize_to(s); - session_select(s, RB_MIN(winlinks, &s->windows)->idx); + session_select(s, RBT_MIN(winlinks, &s->windows)->idx); } notify_session("session-created", s); Index: usr.bin/tmux/cmd-rename-session.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-rename-session.c,v retrieving revision 1.26 diff -u -p -r1.26 cmd-rename-session.c --- usr.bin/tmux/cmd-rename-session.c 22 Apr 2017 10:22:39 -0000 1.26 +++ usr.bin/tmux/cmd-rename-session.c 21 Jun 2017 00:00:38 -0000 @@ -63,10 +63,10 @@ cmd_rename_session_exec(struct cmd *self return (CMD_RETURN_ERROR); } - RB_REMOVE(sessions, &sessions, s); + RBT_REMOVE(sessions, &sessions, s); free(s->name); s->name = xstrdup(newname); - RB_INSERT(sessions, &sessions, s); + RBT_INSERT(sessions, &sessions, s); server_status_session(s); notify_session("session-renamed", s); Index: usr.bin/tmux/cmd-send-keys.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-send-keys.c,v retrieving revision 1.41 diff -u -p -r1.41 cmd-send-keys.c --- usr.bin/tmux/cmd-send-keys.c 10 May 2017 10:46:59 -0000 1.41 +++ usr.bin/tmux/cmd-send-keys.c 21 Jun 2017 00:00:38 -0000 @@ -70,7 +70,7 @@ cmd_send_keys_inject(struct client *c, s table = key_bindings_get_table(wp->mode->key_table(wp), 1); bd_find.key = (key & ~KEYC_XTERM); - bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find); + bd = RBT_FIND(key_bindings, &table->key_bindings, &bd_find); if (bd != NULL) { table->references++; key_bindings_dispatch(bd, item, c, NULL, &item->target); Index: usr.bin/tmux/cmd-set-option.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-set-option.c,v retrieving revision 1.116 diff -u -p -r1.116 cmd-set-option.c --- usr.bin/tmux/cmd-set-option.c 31 May 2017 17:56:48 -0000 1.116 +++ usr.bin/tmux/cmd-set-option.c 21 Jun 2017 00:00:38 -0000 @@ -229,7 +229,7 @@ cmd_set_option_exec(struct cmd *self, st /* Update timers and so on for various options. */ if (strcmp(name, "automatic-rename") == 0) { - RB_FOREACH(w, windows, &windows) { + RBT_FOREACH(w, windows, &windows) { if (w->active == NULL) continue; if (options_get_number(w->options, "automatic-rename")) @@ -247,14 +247,14 @@ cmd_set_option_exec(struct cmd *self, st alerts_reset_all(); if (strcmp(name, "window-style") == 0 || strcmp(name, "window-active-style") == 0) { - RB_FOREACH(w, windows, &windows) + RBT_FOREACH(w, windows, &windows) w->flags |= WINDOW_STYLECHANGED; } if (strcmp(name, "pane-border-status") == 0) { - RB_FOREACH(w, windows, &windows) + RBT_FOREACH(w, windows, &windows) layout_fix_panes(w, w->sx, w->sy); } - RB_FOREACH(s, sessions, &sessions) + RBT_FOREACH(s, sessions, &sessions) status_update_saved(s); /* Index: usr.bin/tmux/cmd-wait-for.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/cmd-wait-for.c,v retrieving revision 1.16 diff -u -p -r1.16 cmd-wait-for.c --- usr.bin/tmux/cmd-wait-for.c 16 Oct 2016 19:04:05 -0000 1.16 +++ usr.bin/tmux/cmd-wait-for.c 21 Jun 2017 00:00:38 -0000 @@ -20,6 +20,7 @@ #include #include +#include #include #include "tmux.h" @@ -54,16 +55,19 @@ struct wait_channel { TAILQ_HEAD(, wait_item) waiters; TAILQ_HEAD(, wait_item) lockers; - RB_ENTRY(wait_channel) entry; + RBT_ENTRY(wait_channel) entry; }; -RB_HEAD(wait_channels, wait_channel); -static struct wait_channels wait_channels = RB_INITIALIZER(wait_channels); +RBT_HEAD(wait_channels, wait_channel); +static struct wait_channels wait_channels = RBT_INITIALIZER(wait_channels); -static int wait_channel_cmp(struct wait_channel *, struct wait_channel *); -RB_GENERATE_STATIC(wait_channels, wait_channel, entry, wait_channel_cmp); +static int wait_channel_cmp(const struct wait_channel *, + const struct wait_channel *); +RBT_PROTOTYPE(wait_channels, wait_channel, entry, wait_channel_cmp); +RBT_GENERATE(wait_channels, wait_channel, entry, wait_channel_cmp); static int -wait_channel_cmp(struct wait_channel *wc1, struct wait_channel *wc2) +wait_channel_cmp(const struct wait_channel *wc1, + const struct wait_channel *wc2) { return (strcmp(wc1->name, wc2->name)); } @@ -94,7 +98,7 @@ cmd_wait_for_add(const char *name) TAILQ_INIT(&wc->waiters); TAILQ_INIT(&wc->lockers); - RB_INSERT(wait_channels, &wait_channels, wc); + RBT_INSERT(wait_channels, &wait_channels, wc); log_debug("add wait channel %s", wc->name); @@ -111,7 +115,7 @@ cmd_wait_for_remove(struct wait_channel log_debug("remove wait channel %s", wc->name); - RB_REMOVE(wait_channels, &wait_channels, wc); + RBT_REMOVE(wait_channels, &wait_channels, wc); free((void *)wc->name); free(wc); @@ -125,7 +129,7 @@ cmd_wait_for_exec(struct cmd *self, stru struct wait_channel *wc, wc0; wc0.name = name; - wc = RB_FIND(wait_channels, &wait_channels, &wc0); + wc = RBT_FIND(wait_channels, &wait_channels, &wc0); if (args_has(args, 'S')) return (cmd_wait_for_signal(item, name, wc)); @@ -246,7 +250,7 @@ cmd_wait_for_flush(void) struct wait_channel *wc, *wc1; struct wait_item *wi, *wi1; - RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) { + RBT_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) { TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) { wi->item->flags &= ~CMDQ_WAITING; TAILQ_REMOVE(&wc->waiters, wi, entry); Index: usr.bin/tmux/environ.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/environ.c,v retrieving revision 1.20 diff -u -p -r1.20 environ.c --- usr.bin/tmux/environ.c 11 May 2017 07:34:54 -0000 1.20 +++ usr.bin/tmux/environ.c 21 Jun 2017 00:00:38 -0000 @@ -19,6 +19,7 @@ #include #include +#include #include #include @@ -28,12 +29,15 @@ * Environment - manipulate a set of environment variables. */ -RB_HEAD(environ, environ_entry); -static int environ_cmp(struct environ_entry *, struct environ_entry *); -RB_GENERATE_STATIC(environ, environ_entry, entry, environ_cmp); +RBT_HEAD(environ, environ_entry); +static int environ_cmp(const struct environ_entry *, + const struct environ_entry *); +RBT_PROTOTYPE(environ, environ_entry, entry, environ_cmp); +RBT_GENERATE(environ, environ_entry, entry, environ_cmp); static int -environ_cmp(struct environ_entry *envent1, struct environ_entry *envent2) +environ_cmp(const struct environ_entry *envent1, + const struct environ_entry *envent2) { return (strcmp(envent1->name, envent2->name)); } @@ -45,7 +49,7 @@ environ_create(void) struct environ *env; env = xcalloc(1, sizeof *env); - RB_INIT(env); + RBT_INIT(environ, env); return (env); } @@ -56,8 +60,8 @@ environ_free(struct environ *env) { struct environ_entry *envent, *envent1; - RB_FOREACH_SAFE(envent, environ, env, envent1) { - RB_REMOVE(environ, env, envent); + RBT_FOREACH_SAFE(envent, environ, env, envent1) { + RBT_REMOVE(environ, env, envent); free(envent->name); free(envent->value); free(envent); @@ -68,13 +72,13 @@ environ_free(struct environ *env) struct environ_entry * environ_first(struct environ *env) { - return (RB_MIN(environ, env)); + return (RBT_MIN(environ, env)); } struct environ_entry * environ_next(struct environ_entry *envent) { - return (RB_NEXT(environ, env, envent)); + return (RBT_NEXT(environ, envent)); } /* Copy one environment into another. */ @@ -83,7 +87,7 @@ environ_copy(struct environ *srcenv, str { struct environ_entry *envent; - RB_FOREACH(envent, environ, srcenv) { + RBT_FOREACH(envent, environ, srcenv) { if (envent->value == NULL) environ_clear(dstenv, envent->name); else @@ -98,7 +102,7 @@ environ_find(struct environ *env, const struct environ_entry envent; envent.name = (char *) name; - return (RB_FIND(environ, env, &envent)); + return (RBT_FIND(environ, env, &envent)); } /* Set an environment variable. */ @@ -116,7 +120,7 @@ environ_set(struct environ *env, const c envent = xmalloc(sizeof *envent); envent->name = xstrdup(name); xvasprintf(&envent->value, fmt, ap); - RB_INSERT(environ, env, envent); + RBT_INSERT(environ, env, envent); } va_end(ap); } @@ -134,7 +138,7 @@ environ_clear(struct environ *env, const envent = xmalloc(sizeof *envent); envent->name = xstrdup(name); envent->value = NULL; - RB_INSERT(environ, env, envent); + RBT_INSERT(environ, env, envent); } } @@ -164,7 +168,7 @@ environ_unset(struct environ *env, const if ((envent = environ_find(env, name)) == NULL) return; - RB_REMOVE(environ, env, envent); + RBT_REMOVE(environ, env, envent); free(envent->name); free(envent->value); free(envent); @@ -200,7 +204,7 @@ environ_push(struct environ *env) struct environ_entry *envent; environ = xcalloc(1, sizeof *environ); - RB_FOREACH(envent, environ, env) { + RBT_FOREACH(envent, environ, env) { if (envent->value != NULL && *envent->name != '\0') setenv(envent->name, envent->value, 1); } @@ -218,7 +222,7 @@ environ_log(struct environ *env, const c vasprintf(&prefix, fmt, ap); va_end(ap); - RB_FOREACH(envent, environ, env) { + RBT_FOREACH(envent, environ, env) { if (envent->value != NULL && *envent->name != '\0') { log_debug("%s%s=%s", prefix, envent->name, envent->value); Index: usr.bin/tmux/format.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/format.c,v retrieving revision 1.142 diff -u -p -r1.142 format.c --- usr.bin/tmux/format.c 31 May 2017 17:56:48 -0000 1.142 +++ usr.bin/tmux/format.c 21 Jun 2017 00:00:38 -0000 @@ -24,6 +24,8 @@ #include #include #include +#include +#include #include #include #include @@ -68,18 +70,19 @@ struct format_job { struct job *job; int status; - RB_ENTRY(format_job) entry; + RBT_ENTRY(format_job) entry; }; /* Format job tree. */ static struct event format_job_event; -static int format_job_cmp(struct format_job *, struct format_job *); -static RB_HEAD(format_job_tree, format_job) format_jobs = RB_INITIALIZER(); -RB_GENERATE_STATIC(format_job_tree, format_job, entry, format_job_cmp); +static int format_job_cmp(const struct format_job *, const struct format_job *); +static RBT_HEAD(format_job_tree, format_job) format_jobs = RBT_INITIALIZER(); +RBT_PROTOTYPE(format_job_tree, format_job, entry, format_job_cmp); +RBT_GENERATE(format_job_tree, format_job, entry, format_job_cmp); /* Format job tree comparison function. */ static int -format_job_cmp(struct format_job *fj1, struct format_job *fj2) +format_job_cmp(const struct format_job *fj1, const struct format_job *fj2) { if (fj1->tag < fj2->tag) return (-1); @@ -100,7 +103,7 @@ struct format_entry { char *value; time_t t; format_cb cb; - RB_ENTRY(format_entry) entry; + RBT_ENTRY(format_entry) entry; }; /* Format entry tree. */ @@ -114,14 +117,17 @@ struct format_tree { u_int tag; int flags; - RB_HEAD(format_entry_tree, format_entry) tree; + RBT_HEAD(format_entry_tree, format_entry) tree; }; -static int format_entry_cmp(struct format_entry *, struct format_entry *); -RB_GENERATE_STATIC(format_entry_tree, format_entry, entry, format_entry_cmp); +static int format_entry_cmp(const struct format_entry *, + const struct format_entry *); +RBT_PROTOTYPE(format_entry_tree, format_entry, entry, format_entry_cmp); +RBT_GENERATE(format_entry_tree, format_entry, entry, format_entry_cmp); /* Format entry tree comparison function. */ static int -format_entry_cmp(struct format_entry *fe1, struct format_entry *fe2) +format_entry_cmp(const struct format_entry *fe1, + const struct format_entry *fe2) { return (strcmp(fe1->key, fe2->key)); } @@ -262,12 +268,12 @@ format_job_get(struct format_tree *ft, c jobs = ft->client->jobs; else { jobs = ft->client->jobs = xmalloc(sizeof *ft->client->jobs); - RB_INIT(jobs); + RBT_INIT(format_job_tree, jobs); } fj0.tag = ft->tag; fj0.cmd = cmd; - if ((fj = RB_FIND(format_job_tree, jobs, &fj0)) == NULL) { + if ((fj = RBT_FIND(format_job_tree, jobs, &fj0)) == NULL) { fj = xcalloc(1, sizeof *fj); fj->client = ft->client; fj->tag = ft->tag; @@ -276,7 +282,7 @@ format_job_get(struct format_tree *ft, c xasprintf(&fj->out, "<'%s' not ready>", fj->cmd); - RB_INSERT(format_job_tree, jobs, fj); + RBT_INSERT(format_job_tree, jobs, fj); } expanded = format_expand(ft, cmd); @@ -314,10 +320,10 @@ format_job_tidy(struct format_job_tree * time_t now; now = time(NULL); - RB_FOREACH_SAFE(fj, format_job_tree, jobs, fj1) { + RBT_FOREACH_SAFE(fj, format_job_tree, jobs, fj1) { if (!force && (fj->last > now || now - fj->last < 3600)) continue; - RB_REMOVE(format_job_tree, jobs, fj); + RBT_REMOVE(format_job_tree, jobs, fj); log_debug("%s: %s", __func__, fj->cmd); @@ -404,7 +410,7 @@ format_cb_session_alerts(struct format_t return; *alerts = '\0'; - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { if ((wl->flags & WINLINK_ALERTFLAGS) == 0) continue; xsnprintf(tmp, sizeof tmp, "%u", wl->idx); @@ -583,7 +589,7 @@ format_merge(struct format_tree *ft, str { struct format_entry *fe; - RB_FOREACH(fe, format_entry_tree, &from->tree) { + RBT_FOREACH(fe, format_entry_tree, &from->tree) { if (fe->value != NULL) format_add(ft, fe->key, "%s", fe->value); } @@ -601,7 +607,7 @@ format_create(struct client *c, struct c } ft = xcalloc(1, sizeof *ft); - RB_INIT(&ft->tree); + RBT_INIT(format_entry_tree, &ft->tree); if (c != NULL) { ft->client = c; @@ -633,8 +639,8 @@ format_free(struct format_tree *ft) { struct format_entry *fe, *fe1; - RB_FOREACH_SAFE(fe, format_entry_tree, &ft->tree, fe1) { - RB_REMOVE(format_entry_tree, &ft->tree, fe); + RBT_FOREACH_SAFE(fe, format_entry_tree, &ft->tree, fe1) { + RBT_REMOVE(format_entry_tree, &ft->tree, fe); free(fe->value); free(fe->key); free(fe); @@ -656,7 +662,7 @@ format_add(struct format_tree *ft, const fe = xmalloc(sizeof *fe); fe->key = xstrdup(key); - fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe); + fe_now = RBT_INSERT(format_entry_tree, &ft->tree, fe); if (fe_now != NULL) { free(fe->key); free(fe); @@ -682,7 +688,7 @@ format_add_tv(struct format_tree *ft, co fe = xmalloc(sizeof *fe); fe->key = xstrdup(key); - fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe); + fe_now = RBT_INSERT(format_entry_tree, &ft->tree, fe); if (fe_now != NULL) { free(fe->key); free(fe); @@ -706,7 +712,7 @@ format_add_cb(struct format_tree *ft, co fe = xmalloc(sizeof *fe); fe->key = xstrdup(key); - fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe); + fe_now = RBT_INSERT(format_entry_tree, &ft->tree, fe); if (fe_now != NULL) { free(fe->key); free(fe); @@ -750,7 +756,7 @@ format_find(struct format_tree *ft, cons found = NULL; fe_find.key = (char *) key; - fe = RB_FIND(format_entry_tree, &ft->tree, &fe_find); + fe = RBT_FIND(format_entry_tree, &ft->tree, &fe_find); if (fe != NULL) { if (modifiers & FORMAT_TIMESTRING) { if (fe->t == 0) Index: usr.bin/tmux/hooks.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/hooks.c,v retrieving revision 1.9 diff -u -p -r1.9 hooks.c --- usr.bin/tmux/hooks.c 16 Oct 2016 19:36:37 -0000 1.9 +++ usr.bin/tmux/hooks.c 21 Jun 2017 00:00:38 -0000 @@ -19,23 +19,25 @@ #include #include +#include #include #include "tmux.h" struct hooks { - RB_HEAD(hooks_tree, hook) tree; + RBT_HEAD(hooks_tree, hook) tree; struct hooks *parent; }; -static int hooks_cmp(struct hook *, struct hook *); -RB_GENERATE_STATIC(hooks_tree, hook, entry, hooks_cmp); +static int hooks_cmp(const struct hook *, const struct hook *); +RBT_PROTOTYPE(hooks_tree, hook, entry, hooks_cmp); +RBT_GENERATE(hooks_tree, hook, entry, hooks_cmp); static struct hook *hooks_find1(struct hooks *, const char *); static void hooks_free1(struct hooks *, struct hook *); static int -hooks_cmp(struct hook *hook1, struct hook *hook2) +hooks_cmp(const struct hook *hook1, const struct hook *hook2) { return (strcmp(hook1->name, hook2->name)); } @@ -54,7 +56,7 @@ hooks_create(struct hooks *parent) struct hooks *hooks; hooks = xcalloc(1, sizeof *hooks); - RB_INIT(&hooks->tree); + RBT_INIT(hooks_tree, &hooks->tree); hooks->parent = parent; return (hooks); } @@ -62,7 +64,7 @@ hooks_create(struct hooks *parent) static void hooks_free1(struct hooks *hooks, struct hook *hook) { - RB_REMOVE(hooks_tree, &hooks->tree, hook); + RBT_REMOVE(hooks_tree, &hooks->tree, hook); cmd_list_free(hook->cmdlist); free((char *)hook->name); free(hook); @@ -73,7 +75,7 @@ hooks_free(struct hooks *hooks) { struct hook *hook, *hook1; - RB_FOREACH_SAFE(hook, hooks_tree, &hooks->tree, hook1) + RBT_FOREACH_SAFE(hook, hooks_tree, &hooks->tree, hook1) hooks_free1(hooks, hook); free(hooks); } @@ -81,13 +83,13 @@ hooks_free(struct hooks *hooks) struct hook * hooks_first(struct hooks *hooks) { - return (RB_MIN(hooks_tree, &hooks->tree)); + return (RBT_MIN(hooks_tree, &hooks->tree)); } struct hook * hooks_next(struct hook *hook) { - return (RB_NEXT(hooks_tree, &hooks->tree, hook)); + return (RBT_NEXT(hooks_tree, hook)); } void @@ -102,7 +104,7 @@ hooks_add(struct hooks *hooks, const cha hook->name = xstrdup(name); hook->cmdlist = cmdlist; hook->cmdlist->references++; - RB_INSERT(hooks_tree, &hooks->tree, hook); + RBT_INSERT(hooks_tree, &hooks->tree, hook); } void @@ -120,7 +122,7 @@ hooks_find1(struct hooks *hooks, const c struct hook hook; hook.name = name; - return (RB_FIND(hooks_tree, &hooks->tree, &hook)); + return (RBT_FIND(hooks_tree, &hooks->tree, &hook)); } struct hook * @@ -129,12 +131,12 @@ hooks_find(struct hooks *hooks, const ch struct hook hook0, *hook; hook0.name = name; - hook = RB_FIND(hooks_tree, &hooks->tree, &hook0); + hook = RBT_FIND(hooks_tree, &hooks->tree, &hook0); while (hook == NULL) { hooks = hooks->parent; if (hooks == NULL) break; - hook = RB_FIND(hooks_tree, &hooks->tree, &hook0); + hook = RBT_FIND(hooks_tree, &hooks->tree, &hook0); } return (hook); } Index: usr.bin/tmux/key-bindings.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/key-bindings.c,v retrieving revision 1.81 diff -u -p -r1.81 key-bindings.c --- usr.bin/tmux/key-bindings.c 9 Jun 2017 14:00:46 -0000 1.81 +++ usr.bin/tmux/key-bindings.c 21 Jun 2017 00:00:38 -0000 @@ -20,22 +20,23 @@ #include #include +#include #include #include "tmux.h" -RB_GENERATE(key_bindings, key_binding, entry, key_bindings_cmp); -RB_GENERATE(key_tables, key_table, entry, key_table_cmp); -struct key_tables key_tables = RB_INITIALIZER(&key_tables); +RBT_GENERATE(key_bindings, key_binding, entry, key_bindings_cmp); +RBT_GENERATE(key_tables, key_table, entry, key_table_cmp); +struct key_tables key_tables = RBT_INITIALIZER(key_tables); int -key_table_cmp(struct key_table *e1, struct key_table *e2) +key_table_cmp(const struct key_table *e1, const struct key_table *e2) { return (strcmp(e1->name, e2->name)); } int -key_bindings_cmp(struct key_binding *bd1, struct key_binding *bd2) +key_bindings_cmp(const struct key_binding *bd1, const struct key_binding *bd2) { if (bd1->key < bd2->key) return (-1); @@ -50,16 +51,16 @@ key_bindings_get_table(const char *name, struct key_table table_find, *table; table_find.name = name; - table = RB_FIND(key_tables, &key_tables, &table_find); + table = RBT_FIND(key_tables, &key_tables, &table_find); if (table != NULL || !create) return (table); table = xmalloc(sizeof *table); table->name = xstrdup(name); - RB_INIT(&table->key_bindings); + RBT_INIT(key_bindings, &table->key_bindings); table->references = 1; /* one reference in key_tables */ - RB_INSERT(key_tables, &key_tables, table); + RBT_INSERT(key_tables, &key_tables, table); return (table); } @@ -73,8 +74,8 @@ key_bindings_unref_table(struct key_tabl if (--table->references != 0) return; - RB_FOREACH_SAFE(bd, key_bindings, &table->key_bindings, bd1) { - RB_REMOVE(key_bindings, &table->key_bindings, bd); + RBT_FOREACH_SAFE(bd, key_bindings, &table->key_bindings, bd1) { + RBT_REMOVE(key_bindings, &table->key_bindings, bd); cmd_list_free(bd->cmdlist); free(bd); } @@ -93,16 +94,16 @@ key_bindings_add(const char *name, key_c table = key_bindings_get_table(name, 1); bd_find.key = (key & ~KEYC_XTERM); - bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find); + bd = RBT_FIND(key_bindings, &table->key_bindings, &bd_find); if (bd != NULL) { - RB_REMOVE(key_bindings, &table->key_bindings, bd); + RBT_REMOVE(key_bindings, &table->key_bindings, bd); cmd_list_free(bd->cmdlist); free(bd); } bd = xcalloc(1, sizeof *bd); bd->key = key; - RB_INSERT(key_bindings, &table->key_bindings, bd); + RBT_INSERT(key_bindings, &table->key_bindings, bd); if (repeat) bd->flags |= KEY_BINDING_REPEAT; @@ -120,16 +121,16 @@ key_bindings_remove(const char *name, ke return; bd_find.key = (key & ~KEYC_XTERM); - bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find); + bd = RBT_FIND(key_bindings, &table->key_bindings, &bd_find); if (bd == NULL) return; - RB_REMOVE(key_bindings, &table->key_bindings, bd); + RBT_REMOVE(key_bindings, &table->key_bindings, bd); cmd_list_free(bd->cmdlist); free(bd); - if (RB_EMPTY(&table->key_bindings)) { - RB_REMOVE(key_tables, &key_tables, table); + if (RBT_EMPTY(key_bindings, &table->key_bindings)) { + RBT_REMOVE(key_tables, &key_tables, table); key_bindings_unref_table(table); } } @@ -141,7 +142,7 @@ key_bindings_remove_table(const char *na table = key_bindings_get_table(name, 0); if (table != NULL) { - RB_REMOVE(key_tables, &key_tables, table); + RBT_REMOVE(key_tables, &key_tables, table); key_bindings_unref_table(table); } } Index: usr.bin/tmux/options.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/options.c,v retrieving revision 1.35 diff -u -p -r1.35 options.c --- usr.bin/tmux/options.c 31 May 2017 17:56:48 -0000 1.35 +++ usr.bin/tmux/options.c 21 Jun 2017 00:00:38 -0000 @@ -21,6 +21,7 @@ #include #include #include +#include #include #include "tmux.h" @@ -46,11 +47,11 @@ struct options_entry { }; }; - RB_ENTRY(options_entry) entry; + RBT_ENTRY(options_entry) entry; }; struct options { - RB_HEAD(options_tree, options_entry) tree; + RBT_HEAD(options_tree, options_entry) tree; struct options *parent; }; @@ -76,11 +77,13 @@ static struct options_entry *options_add ((o)->tableentry != NULL && \ (o)->tableentry->type == OPTIONS_TABLE_ARRAY) -static int options_cmp(struct options_entry *, struct options_entry *); -RB_GENERATE_STATIC(options_tree, options_entry, entry, options_cmp); +static int options_cmp(const struct options_entry *, + const struct options_entry *); +RBT_PROTOTYPE(options_tree, options_entry, entry, options_cmp); +RBT_GENERATE(options_tree, options_entry, entry, options_cmp); static int -options_cmp(struct options_entry *lhs, struct options_entry *rhs) +options_cmp(const struct options_entry *lhs, const struct options_entry *rhs) { return (strcmp(lhs->name, rhs->name)); } @@ -104,7 +107,7 @@ options_create(struct options *parent) struct options *oo; oo = xcalloc(1, sizeof *oo); - RB_INIT(&oo->tree); + RBT_INIT(options_tree, &oo->tree); oo->parent = parent; return (oo); } @@ -114,7 +117,7 @@ options_free(struct options *oo) { struct options_entry *o, *tmp; - RB_FOREACH_SAFE(o, options_tree, &oo->tree, tmp) + RBT_FOREACH_SAFE(o, options_tree, &oo->tree, tmp) options_remove(o); free(oo); } @@ -122,13 +125,13 @@ options_free(struct options *oo) struct options_entry * options_first(struct options *oo) { - return (RB_MIN(options_tree, &oo->tree)); + return (RBT_MIN(options_tree, &oo->tree)); } struct options_entry * options_next(struct options_entry *o) { - return (RB_NEXT(options_tree, &oo->tree, o)); + return (RBT_NEXT(options_tree, o)); } struct options_entry * @@ -137,7 +140,7 @@ options_get_only(struct options *oo, con struct options_entry o; o.name = name; - return (RB_FIND(options_tree, &oo->tree, &o)); + return (RBT_FIND(options_tree, &oo->tree, &o)); } struct options_entry * @@ -197,7 +200,7 @@ options_add(struct options *oo, const ch o->owner = oo; o->name = xstrdup(name); - RB_INSERT(options_tree, &oo->tree, o); + RBT_INSERT(options_tree, &oo->tree, o); return (o); } @@ -215,7 +218,7 @@ options_remove(struct options_entry *o) free(o->array); } - RB_REMOVE(options_tree, &oo->tree, o); + RBT_REMOVE(options_tree, &oo->tree, o); free(o); } Index: usr.bin/tmux/paste.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/paste.c,v retrieving revision 1.39 diff -u -p -r1.39 paste.c --- usr.bin/tmux/paste.c 24 Jan 2017 13:28:33 -0000 1.39 +++ usr.bin/tmux/paste.c 21 Jun 2017 00:00:38 -0000 @@ -19,6 +19,7 @@ #include #include +#include #include #include #include @@ -39,23 +40,25 @@ struct paste_buffer { int automatic; u_int order; - RB_ENTRY(paste_buffer) name_entry; - RB_ENTRY(paste_buffer) time_entry; + RBT_ENTRY(paste_buffer) name_entry; + RBT_ENTRY(paste_buffer) time_entry; }; static u_int paste_next_index; static u_int paste_next_order; static u_int paste_num_automatic; -static RB_HEAD(paste_name_tree, paste_buffer) paste_by_name; -static RB_HEAD(paste_time_tree, paste_buffer) paste_by_time; +static RBT_HEAD(paste_name_tree, paste_buffer) paste_by_name; +static RBT_HEAD(paste_time_tree, paste_buffer) paste_by_time; static int paste_cmp_names(const struct paste_buffer *, const struct paste_buffer *); -RB_GENERATE_STATIC(paste_name_tree, paste_buffer, name_entry, paste_cmp_names); +RBT_PROTOTYPE(paste_name_tree, paste_buffer, name_entry, paste_cmp_names); +RBT_GENERATE(paste_name_tree, paste_buffer, name_entry, paste_cmp_names); static int paste_cmp_times(const struct paste_buffer *, const struct paste_buffer *); -RB_GENERATE_STATIC(paste_time_tree, paste_buffer, time_entry, paste_cmp_times); +RBT_PROTOTYPE(paste_time_tree, paste_buffer, time_entry, paste_cmp_times); +RBT_GENERATE(paste_time_tree, paste_buffer, time_entry, paste_cmp_times); static int paste_cmp_names(const struct paste_buffer *a, const struct paste_buffer *b) @@ -108,8 +111,8 @@ struct paste_buffer * paste_walk(struct paste_buffer *pb) { if (pb == NULL) - return (RB_MIN(paste_time_tree, &paste_by_time)); - return (RB_NEXT(paste_time_tree, &paste_by_time, pb)); + return (RBT_MIN(paste_time_tree, &paste_by_time)); + return (RBT_NEXT(paste_time_tree, pb)); } /* Get the most recent automatic buffer. */ @@ -118,7 +121,7 @@ paste_get_top(const char **name) { struct paste_buffer *pb; - pb = RB_MIN(paste_time_tree, &paste_by_time); + pb = RBT_MIN(paste_time_tree, &paste_by_time); if (pb == NULL) return (NULL); if (name != NULL) @@ -136,15 +139,15 @@ paste_get_name(const char *name) return (NULL); pbfind.name = (char *)name; - return (RB_FIND(paste_name_tree, &paste_by_name, &pbfind)); + return (RBT_FIND(paste_name_tree, &paste_by_name, &pbfind)); } /* Free a paste buffer. */ void paste_free(struct paste_buffer *pb) { - RB_REMOVE(paste_name_tree, &paste_by_name, pb); - RB_REMOVE(paste_time_tree, &paste_by_time, pb); + RBT_REMOVE(paste_name_tree, &paste_by_name, pb); + RBT_REMOVE(paste_time_tree, &paste_by_time, pb); if (pb->automatic) paste_num_automatic--; @@ -169,7 +172,7 @@ paste_add(char *data, size_t size) } limit = options_get_number(global_options, "buffer-limit"); - RB_FOREACH_REVERSE_SAFE(pb, paste_time_tree, &paste_by_time, pb1) { + RBT_FOREACH_REVERSE_SAFE(pb, paste_time_tree, &paste_by_time, pb1) { if (paste_num_automatic < limit) break; if (pb->automatic) @@ -194,8 +197,8 @@ paste_add(char *data, size_t size) pb->created = time(NULL); pb->order = paste_next_order++; - RB_INSERT(paste_name_tree, &paste_by_name, pb); - RB_INSERT(paste_time_tree, &paste_by_time, pb); + RBT_INSERT(paste_name_tree, &paste_by_name, pb); + RBT_INSERT(paste_time_tree, &paste_by_time, pb); } /* Rename a paste buffer. */ @@ -232,7 +235,7 @@ paste_rename(const char *oldname, const return (-1); } - RB_REMOVE(paste_name_tree, &paste_by_name, pb); + RBT_REMOVE(paste_name_tree, &paste_by_name, pb); free(pb->name); pb->name = xstrdup(newname); @@ -241,7 +244,7 @@ paste_rename(const char *oldname, const paste_num_automatic--; pb->automatic = 0; - RB_INSERT(paste_name_tree, &paste_by_name, pb); + RBT_INSERT(paste_name_tree, &paste_by_name, pb); return (0); } @@ -288,8 +291,8 @@ paste_set(char *data, size_t size, const if ((old = paste_get_name(name)) != NULL) paste_free(old); - RB_INSERT(paste_name_tree, &paste_by_name, pb); - RB_INSERT(paste_time_tree, &paste_by_time, pb); + RBT_INSERT(paste_name_tree, &paste_by_name, pb); + RBT_INSERT(paste_time_tree, &paste_by_time, pb); return (0); } Index: usr.bin/tmux/resize.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/resize.c,v retrieving revision 1.23 diff -u -p -r1.23 resize.c --- usr.bin/tmux/resize.c 10 May 2017 16:48:36 -0000 1.23 +++ usr.bin/tmux/resize.c 21 Jun 2017 00:00:38 -0000 @@ -52,7 +52,7 @@ recalculate_sizes(void) u_int ssx, ssy, has, limit; int flag, has_status, is_zoomed, forced; - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { has_status = options_get_number(s->options, "status"); s->attached = 0; @@ -96,13 +96,13 @@ recalculate_sizes(void) status_update_saved(s); } - RB_FOREACH(w, windows, &windows) { + RBT_FOREACH(w, windows, &windows) { if (w->active == NULL) continue; flag = options_get_number(w->options, "aggressive-resize"); ssx = ssy = UINT_MAX; - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { if (s->flags & SESSION_UNATTACHED) continue; if (flag) Index: usr.bin/tmux/server-client.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/server-client.c,v retrieving revision 1.239 diff -u -p -r1.239 server-client.c --- usr.bin/tmux/server-client.c 13 Jun 2017 07:12:33 -0000 1.239 +++ usr.bin/tmux/server-client.c 21 Jun 2017 00:00:38 -0000 @@ -119,7 +119,7 @@ server_client_check_nested(struct client if (envent == NULL || *envent->value == '\0') return (0); - RB_FOREACH(wp, window_pane_tree, &all_window_panes) { + RBT_FOREACH(wp, window_pane_tree, &all_window_panes) { if (strcmp(wp->tty, c->ttyname) == 0) return (1); } @@ -928,7 +928,7 @@ retry: /* Try to see if there is a key binding in the current table. */ bd_find.key = key0; - bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find); + bd = RBT_FIND(key_bindings, &table->key_bindings, &bd_find); if (bd != NULL) { /* * Key was matched in this table. If currently repeating but a @@ -1028,7 +1028,7 @@ server_client_loop(void) * their flags now. Also check pane focus and resize. */ focus = options_get_number(global_options, "focus-events"); - RB_FOREACH(w, windows, &windows) { + RBT_FOREACH(w, windows, &windows) { TAILQ_FOREACH(wp, &w->panes, entry) { if (wp->fd != -1) { if (focus) Index: usr.bin/tmux/server-fn.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/server-fn.c,v retrieving revision 1.108 diff -u -p -r1.108 server-fn.c --- usr.bin/tmux/server-fn.c 12 May 2017 13:00:56 -0000 1.108 +++ usr.bin/tmux/server-fn.c 21 Jun 2017 00:00:38 -0000 @@ -124,7 +124,7 @@ server_status_window(struct window *w) * current window. */ - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { if (session_has(s, w)) server_status_session(s); } @@ -183,10 +183,10 @@ server_kill_window(struct window *w) struct session_group *sg; struct winlink *wl; - next_s = RB_MIN(sessions, &sessions); + next_s = RBT_MIN(sessions, &sessions); while (next_s != NULL) { s = next_s; - next_s = RB_NEXT(sessions, &sessions, s); + next_s = RBT_NEXT(sessions, s); if (!session_has(s, w)) continue; @@ -344,7 +344,7 @@ server_next_session(struct session *s) struct session *s_loop, *s_out; s_out = NULL; - RB_FOREACH(s_loop, sessions, &sessions) { + RBT_FOREACH(s_loop, sessions, &sessions) { if (s_loop == s) continue; if (s_out == NULL || @@ -395,7 +395,7 @@ server_check_unattached(void) * If any sessions are no longer attached and have destroy-unattached * set, collect them. */ - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { if (!(s->flags & SESSION_UNATTACHED)) continue; if (options_get_number (s->options, "destroy-unattached")) Index: usr.bin/tmux/server.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/server.c,v retrieving revision 1.171 diff -u -p -r1.171 server.c --- usr.bin/tmux/server.c 4 Jun 2017 08:25:57 -0000 1.171 +++ usr.bin/tmux/server.c 21 Jun 2017 00:00:38 -0000 @@ -157,11 +157,11 @@ server_start(struct event_base *base, in "tty ps", NULL) != 0) fatal("pledge failed"); - RB_INIT(&windows); - RB_INIT(&all_window_panes); + RBT_INIT(windows, &windows); + RBT_INIT(window_pane_tree, &all_window_panes); TAILQ_INIT(&clients); - RB_INIT(&sessions); - RB_INIT(&session_groups); + RBT_INIT(sessions, &sessions); + RBT_INIT(session_groups, &session_groups); key_bindings_init(); gettimeofday(&start_time, NULL); @@ -211,7 +211,7 @@ server_loop(void) server_client_loop(); if (!options_get_number(global_options, "exit-unattached")) { - if (!RB_EMPTY(&sessions)) + if (!RBT_EMPTY(sessions, &sessions)) return (0); } @@ -248,7 +248,7 @@ server_send_exit(void) c->session = NULL; } - RB_FOREACH_SAFE(s, sessions, &sessions, s1) + RBT_FOREACH_SAFE(s, sessions, &sessions, s1) session_destroy(s); } @@ -262,7 +262,7 @@ server_update_socket(void) struct stat sb; n = 0; - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { if (!(s->flags & SESSION_UNATTACHED)) { n++; break; @@ -402,7 +402,7 @@ server_child_exited(pid_t pid, int statu struct window_pane *wp; struct job *job; - RB_FOREACH_SAFE(w, windows, &windows, w1) { + RBT_FOREACH_SAFE(w, windows, &windows, w1) { TAILQ_FOREACH(wp, &w->panes, entry) { if (wp->pid == pid) { wp->status = status; @@ -430,7 +430,7 @@ server_child_stopped(pid_t pid, int stat if (WSTOPSIG(status) == SIGTTIN || WSTOPSIG(status) == SIGTTOU) return; - RB_FOREACH(w, windows, &windows) { + RBT_FOREACH(w, windows, &windows) { TAILQ_FOREACH(wp, &w->panes, entry) { if (wp->pid == pid) { if (killpg(pid, SIGCONT) != 0) Index: usr.bin/tmux/session.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/session.c,v retrieving revision 1.76 diff -u -p -r1.76 session.c --- usr.bin/tmux/session.c 4 May 2017 07:16:43 -0000 1.76 +++ usr.bin/tmux/session.c 21 Jun 2017 00:00:38 -0000 @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -45,18 +46,19 @@ static void session_group_synchronize1(s static u_int session_group_count(struct session_group *); static void session_group_synchronize1(struct session *, struct session *); -RB_GENERATE(sessions, session, entry, session_cmp); +RBT_GENERATE(sessions, session, entry, session_cmp); int -session_cmp(struct session *s1, struct session *s2) +session_cmp(const struct session *s1, const struct session *s2) { return (strcmp(s1->name, s2->name)); } -RB_GENERATE(session_groups, session_group, entry, session_group_cmp); +RBT_GENERATE(session_groups, session_group, entry, session_group_cmp); int -session_group_cmp(struct session_group *s1, struct session_group *s2) +session_group_cmp(const struct session_group *s1, + const struct session_group *s2) { return (strcmp(s1->name, s2->name)); } @@ -70,7 +72,7 @@ session_alive(struct session *s) { struct session *s_loop; - RB_FOREACH(s_loop, sessions, &sessions) { + RBT_FOREACH(s_loop, sessions, &sessions) { if (s_loop == s) return (1); } @@ -84,7 +86,7 @@ session_find(const char *name) struct session s; s.name = (char *) name; - return (RB_FIND(sessions, &sessions, &s)); + return (RBT_FIND(sessions, &sessions, &s)); } /* Find session by id parsed from a string. */ @@ -109,7 +111,7 @@ session_find_by_id(u_int id) { struct session *s; - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { if (s->id == id) return (s); } @@ -133,7 +135,7 @@ session_create(const char *prefix, const s->curw = NULL; TAILQ_INIT(&s->lastw); - RB_INIT(&s->windows); + RBT_INIT(winlinks, &s->windows); s->environ = environ_create(); if (env != NULL) @@ -165,9 +167,9 @@ session_create(const char *prefix, const xasprintf(&s->name, "%s-%u", prefix, s->id); else xasprintf(&s->name, "%u", s->id); - } while (RB_FIND(sessions, &sessions, s) != NULL); + } while (RBT_FIND(sessions, &sessions, s) != NULL); } - RB_INSERT(sessions, &sessions, s); + RBT_INSERT(sessions, &sessions, s); log_debug("new session %s $%u", s->name, s->id); @@ -181,7 +183,7 @@ session_create(const char *prefix, const session_destroy(s); return (NULL); } - session_select(s, RB_ROOT(&s->windows)->idx); + session_select(s, RBT_ROOT(winlinks, &s->windows)->idx); } log_debug("session %s created", s->name); @@ -236,7 +238,7 @@ session_destroy(struct session *s) log_debug("session %s destroyed", s->name); s->curw = NULL; - RB_REMOVE(sessions, &sessions, s); + RBT_REMOVE(sessions, &sessions, s); notify_session("session-closed", s); free(s->tio); @@ -248,8 +250,8 @@ session_destroy(struct session *s) while (!TAILQ_EMPTY(&s->lastw)) winlink_stack_remove(&s->lastw, TAILQ_FIRST(&s->lastw)); - while (!RB_EMPTY(&s->windows)) { - wl = RB_ROOT(&s->windows); + while (!RBT_EMPTY(winlinks, &s->windows)) { + wl = RBT_ROOT(winlinks, &s->windows); notify_session_window("window-unlinked", s, wl->window); winlink_remove(&s->windows, wl); } @@ -318,12 +320,12 @@ session_next_session(struct session *s) { struct session *s2; - if (RB_EMPTY(&sessions) || !session_alive(s)) + if (RBT_EMPTY(sessions, &sessions) || !session_alive(s)) return (NULL); - s2 = RB_NEXT(sessions, &sessions, s); + s2 = RBT_NEXT(sessions, s); if (s2 == NULL) - s2 = RB_MIN(sessions, &sessions); + s2 = RBT_MIN(sessions, &sessions); if (s2 == s) return (NULL); return (s2); @@ -335,12 +337,12 @@ session_previous_session(struct session { struct session *s2; - if (RB_EMPTY(&sessions) || !session_alive(s)) + if (RBT_EMPTY(sessions, &sessions) || !session_alive(s)) return (NULL); - s2 = RB_PREV(sessions, &sessions, s); + s2 = RBT_PREV(sessions, s); if (s2 == NULL) - s2 = RB_MAX(sessions, &sessions); + s2 = RBT_MAX(sessions, &sessions); if (s2 == s) return (NULL); return (s2); @@ -418,7 +420,7 @@ session_detach(struct session *s, struct session_group_synchronize_from(s); - if (RB_EMPTY(&s->windows)) { + if (RBT_EMPTY(winlinks, &s->windows)) { session_destroy(s); return (1); } @@ -476,7 +478,7 @@ session_next(struct session *s, int aler if (alert) wl = session_next_alert(wl); if (wl == NULL) { - wl = RB_MIN(winlinks, &s->windows); + wl = RBT_MIN(winlinks, &s->windows); if (alert && ((wl = session_next_alert(wl)) == NULL)) return (-1); } @@ -507,7 +509,7 @@ session_previous(struct session *s, int if (alert) wl = session_previous_alert(wl); if (wl == NULL) { - wl = RB_MAX(winlinks, &s->windows); + wl = RBT_MAX(winlinks, &s->windows); if (alert && (wl = session_previous_alert(wl)) == NULL) return (-1); } @@ -564,7 +566,7 @@ session_group_contains(struct session *t struct session_group *sg; struct session *s; - RB_FOREACH(sg, session_groups, &session_groups) { + RBT_FOREACH(sg, session_groups, &session_groups) { TAILQ_FOREACH(s, &sg->sessions, gentry) { if (s == target) return (sg); @@ -580,7 +582,7 @@ session_group_find(const char *name) struct session_group sg; sg.name = name; - return (RB_FIND(session_groups, &session_groups, &sg)); + return (RBT_FIND(session_groups, &session_groups, &sg)); } /* Create a new session group. */ @@ -596,7 +598,7 @@ session_group_new(const char *name) sg->name = xstrdup(name); TAILQ_INIT(&sg->sessions); - RB_INSERT(session_groups, &session_groups, sg); + RBT_INSERT(session_groups, &session_groups, sg); return (sg); } @@ -618,7 +620,7 @@ session_group_remove(struct session *s) return; TAILQ_REMOVE(&sg->sessions, s, gentry); if (TAILQ_EMPTY(&sg->sessions)) { - RB_REMOVE(session_groups, &session_groups, sg); + RBT_REMOVE(session_groups, &session_groups, sg); free(sg); } } @@ -685,7 +687,7 @@ session_group_synchronize1(struct sessio /* Don't do anything if the session is empty (it'll be destroyed). */ ww = &target->windows; - if (RB_EMPTY(ww)) + if (RBT_EMPTY(winlinks, ww)) return; /* If the current window has vanished, move to the next now. */ @@ -696,10 +698,10 @@ session_group_synchronize1(struct sessio /* Save the old pointer and reset it. */ memcpy(&old_windows, &s->windows, sizeof old_windows); - RB_INIT(&s->windows); + RBT_INIT(winlinks, &s->windows); /* Link all the windows from the target. */ - RB_FOREACH(wl, winlinks, ww) { + RBT_FOREACH(wl, winlinks, ww) { wl2 = winlink_add(&s->windows, wl->idx); wl2->session = s; winlink_set_window(wl2, wl->window); @@ -723,8 +725,8 @@ session_group_synchronize1(struct sessio } /* Then free the old winlinks list. */ - while (!RB_EMPTY(&old_windows)) { - wl = RB_ROOT(&old_windows); + while (!RBT_EMPTY(winlinks, &old_windows)) { + wl = RBT_ROOT(winlinks, &old_windows); wl2 = winlink_find_by_window_id(&s->windows, wl->window->id); if (wl2 == NULL) notify_session_window("window-unlinked", s, wl->window); @@ -743,14 +745,14 @@ session_renumber_windows(struct session /* Save and replace old window list. */ memcpy(&old_wins, &s->windows, sizeof old_wins); - RB_INIT(&s->windows); + RBT_INIT(winlinks, &s->windows); /* Start renumbering from the base-index if it's set. */ new_idx = options_get_number(s->options, "base-index"); new_curw_idx = 0; /* Go through the winlinks and assign new indexes. */ - RB_FOREACH(wl, winlinks, &old_wins) { + RBT_FOREACH(wl, winlinks, &old_wins) { wl_new = winlink_add(&s->windows, new_idx); wl_new->session = s; winlink_set_window(wl_new, wl->window); @@ -775,6 +777,6 @@ session_renumber_windows(struct session s->curw = winlink_find_by_index(&s->windows, new_curw_idx); /* Free the old winlinks (reducing window references too). */ - RB_FOREACH_SAFE(wl, winlinks, &old_wins, wl1) + RBT_FOREACH_SAFE(wl, winlinks, &old_wins, wl1) winlink_remove(&old_wins, wl); } Index: usr.bin/tmux/status.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/status.c,v retrieving revision 1.168 diff -u -p -r1.168 status.c --- usr.bin/tmux/status.c 29 May 2017 20:42:53 -0000 1.168 +++ usr.bin/tmux/status.c 21 Jun 2017 00:00:38 -0000 @@ -270,7 +270,7 @@ status_get_window_at(struct client *c, u size_t seplen; x += c->wlmouse; - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { oo = wl->window->options; sep = options_get_string(oo, "window-status-separator"); @@ -353,7 +353,7 @@ status_redraw(struct client *c) /* Calculate the total size needed for the window list. */ wlstart = wloffset = wlwidth = 0; - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { free(wl->status_text); memcpy(&wl->status_cell, &stdgc, sizeof wl->status_cell); wl->status_text = status_print(c, wl, t, &wl->status_cell); @@ -373,7 +373,7 @@ status_redraw(struct client *c) /* And draw the window list into it. */ screen_write_start(&ctx, NULL, &window_list); - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { screen_write_cnputs(&ctx, -1, &wl->status_cell, "%s", wl->status_text); @@ -432,7 +432,7 @@ status_redraw(struct client *c) * right arrows. */ offset = 0; - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { if (wl->flags & WINLINK_ALERTFLAGS && larrow == 1 && offset < wlstart) larrow = -1; @@ -1512,7 +1512,7 @@ status_prompt_complete(struct session *s colon = ""; s = copy + 2; - RB_FOREACH(s_loop, sessions, &sessions) { + RBT_FOREACH(s_loop, sessions, &sessions) { if (strncmp(s_loop->name, s, strlen(s)) == 0) { list = xreallocarray(list, size + 2, sizeof *list); list[size++] = s_loop->name; @@ -1533,7 +1533,7 @@ status_prompt_complete(struct session *s colon = ""; if (*s == ':') { - RB_FOREACH(wl, winlinks, &session->windows) { + RBT_FOREACH(wl, winlinks, &session->windows) { xasprintf(&tmp, ":%s", wl->window->name); if (strncmp(tmp, s, strlen(s)) == 0){ list = xreallocarray(list, size + 1, @@ -1553,8 +1553,8 @@ status_prompt_complete(struct session *s free(tmp); } } else { - RB_FOREACH(s_loop, sessions, &sessions) { - RB_FOREACH(wl, winlinks, &s_loop->windows) { + RBT_FOREACH(s_loop, sessions, &sessions) { + RBT_FOREACH(wl, winlinks, &s_loop->windows) { w = wl->window; xasprintf(&tmp, "%s:%s", s_loop->name, w->name); Index: usr.bin/tmux/tmux.h =================================================================== RCS file: /cvs/src/usr.bin/tmux/tmux.h,v retrieving revision 1.786 diff -u -p -r1.786 tmux.h --- usr.bin/tmux/tmux.h 12 Jun 2017 07:04:24 -0000 1.786 +++ usr.bin/tmux/tmux.h 21 Jun 2017 00:00:38 -0000 @@ -594,7 +594,7 @@ struct hook { struct cmd_list *cmdlist; - RB_ENTRY(hook) entry; + RBT_ENTRY(hook) entry; }; /* Scheduled job. */ @@ -809,10 +809,10 @@ struct window_pane { char *searchstr; TAILQ_ENTRY(window_pane) entry; - RB_ENTRY(window_pane) tree_entry; + RBT_ENTRY(window_pane) tree_entry; }; TAILQ_HEAD(window_panes, window_pane); -RB_HEAD(window_pane_tree, window_pane); +RBT_HEAD(window_pane_tree, window_pane); /* Window structure. */ struct window { @@ -860,9 +860,9 @@ struct window { u_int references; TAILQ_HEAD(, winlink) winlinks; - RB_ENTRY(window) entry; + RBT_ENTRY(window) entry; }; -RB_HEAD(windows, window); +RBT_HEAD(windows, window); /* Entry on local window list. */ struct winlink { @@ -880,11 +880,11 @@ struct winlink { #define WINLINK_SILENCE 0x4 #define WINLINK_ALERTFLAGS (WINLINK_BELL|WINLINK_ACTIVITY|WINLINK_SILENCE) - RB_ENTRY(winlink) entry; + RBT_ENTRY(winlink) entry; TAILQ_ENTRY(winlink) wentry; TAILQ_ENTRY(winlink) sentry; }; -RB_HEAD(winlinks, winlink); +RBT_HEAD(winlinks, winlink); TAILQ_HEAD(winlink_stack, winlink); /* Layout direction. */ @@ -920,7 +920,7 @@ struct environ_entry { char *name; char *value; - RB_ENTRY(environ_entry) entry; + RBT_ENTRY(environ_entry) entry; }; /* Client session. */ @@ -928,9 +928,9 @@ struct session_group { const char *name; TAILQ_HEAD(, session) sessions; - RB_ENTRY(session_group) entry; + RBT_ENTRY(session_group) entry; }; -RB_HEAD(session_groups, session_group); +RBT_HEAD(session_groups, session_group); struct session { u_int id; @@ -971,9 +971,9 @@ struct session { int references; TAILQ_ENTRY(session) gentry; - RB_ENTRY(session) entry; + RBT_ENTRY(session) entry; }; -RB_HEAD(sessions, session); +RBT_HEAD(sessions, session); /* Mouse button masks. */ #define MOUSE_MASK_BUTTONS 3 @@ -1152,7 +1152,7 @@ struct message_entry { /* Parsed arguments structures. */ struct args_entry; -RB_HEAD(args_tree, args_entry); +RBT_HEAD(args_tree, args_entry); struct args { struct args_tree tree; int argc; @@ -1412,9 +1412,9 @@ struct key_binding { int flags; #define KEY_BINDING_REPEAT 0x1 - RB_ENTRY(key_binding) entry; + RBT_ENTRY(key_binding) entry; }; -RB_HEAD(key_bindings, key_binding); +RBT_HEAD(key_bindings, key_binding); struct key_table { const char *name; @@ -1422,9 +1422,9 @@ struct key_table { u_int references; - RB_ENTRY(key_table) entry; + RBT_ENTRY(key_table) entry; }; -RB_HEAD(key_tables, key_table); +RBT_HEAD(key_tables, key_table); /* Option table entries. */ enum options_table_type { @@ -1819,11 +1819,12 @@ void cmd_wait_for_flush(void); int client_main(struct event_base *, int, char **, int, const char *); /* key-bindings.c */ -RB_PROTOTYPE(key_bindings, key_binding, entry, key_bindings_cmp); -RB_PROTOTYPE(key_tables, key_table, entry, key_table_cmp); +RBT_PROTOTYPE(key_bindings, key_binding, entry, key_bindings_cmp); +RBT_PROTOTYPE(key_tables, key_table, entry, key_table_cmp); extern struct key_tables key_tables; -int key_table_cmp(struct key_table *, struct key_table *); -int key_bindings_cmp(struct key_binding *, struct key_binding *); +int key_table_cmp(const struct key_table *, const struct key_table *); +int key_bindings_cmp(const struct key_binding *, + const struct key_binding *); struct key_table *key_bindings_get_table(const char *, int); void key_bindings_unref_table(struct key_table *); void key_bindings_add(const char *, key_code, int, struct cmd_list *); @@ -2077,12 +2078,13 @@ void screen_select_cell(struct screen * /* window.c */ extern struct windows windows; extern struct window_pane_tree all_window_panes; -int window_cmp(struct window *, struct window *); -RB_PROTOTYPE(windows, window, entry, window_cmp); -int winlink_cmp(struct winlink *, struct winlink *); -RB_PROTOTYPE(winlinks, winlink, entry, winlink_cmp); -int window_pane_cmp(struct window_pane *, struct window_pane *); -RB_PROTOTYPE(window_pane_tree, window_pane, tree_entry, window_pane_cmp); +int window_cmp(const struct window *, const struct window *); +RBT_PROTOTYPE(windows, window, entry, window_cmp); +int winlink_cmp(const struct winlink *, const struct winlink *); +RBT_PROTOTYPE(winlinks, winlink, entry, winlink_cmp); +int window_pane_cmp(const struct window_pane *, + const struct window_pane *); +RBT_PROTOTYPE(window_pane_tree, window_pane, tree_entry, window_pane_cmp); struct winlink *winlink_find_by_index(struct winlinks *, int); struct winlink *winlink_find_by_window(struct winlinks *, struct window *); struct winlink *winlink_find_by_window_id(struct winlinks *, u_int); @@ -2278,10 +2280,11 @@ void control_notify_session_window_chang /* session.c */ extern struct sessions sessions; extern struct session_groups session_groups; -int session_cmp(struct session *, struct session *); -RB_PROTOTYPE(sessions, session, entry, session_cmp); -int session_group_cmp(struct session_group *, struct session_group *); -RB_PROTOTYPE(session_groups, session_group, entry, session_group_cmp); +int session_cmp(const struct session *, const struct session *); +RBT_PROTOTYPE(sessions, session, entry, session_cmp); +int session_group_cmp(const struct session_group *, + const struct session_group *); +RBT_PROTOTYPE(session_groups, session_group, entry, session_group_cmp); int session_alive(struct session *); struct session *session_find(const char *); struct session *session_find_by_id_str(const char *); Index: usr.bin/tmux/window-tree.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/window-tree.c,v retrieving revision 1.5 diff -u -p -r1.5 window-tree.c --- usr.bin/tmux/window-tree.c 9 Jun 2017 16:01:39 -0000 1.5 +++ usr.bin/tmux/window-tree.c 21 Jun 2017 00:00:38 -0000 @@ -329,7 +329,7 @@ window_tree_build_session(struct session l = NULL; n = 0; - RB_FOREACH(wl, winlinks, &s->windows) { + RBT_FOREACH(wl, winlinks, &s->windows) { l = xreallocarray(l, n + 1, sizeof *l); l[n++] = wl; } @@ -374,7 +374,7 @@ window_tree_build(void *modedata, u_int l = NULL; n = 0; - RB_FOREACH(s, sessions, &sessions) { + RBT_FOREACH(s, sessions, &sessions) { l = xreallocarray(l, n + 1, sizeof *l); l[n++] = s; } Index: usr.bin/tmux/window.c =================================================================== RCS file: /cvs/src/usr.bin/tmux/window.c,v retrieving revision 1.198 diff -u -p -r1.198 window.c --- usr.bin/tmux/window.c 4 Jun 2017 09:02:36 -0000 1.198 +++ usr.bin/tmux/window.c 21 Jun 2017 00:00:38 -0000 @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -75,24 +76,24 @@ static int winlink_next_index(struct win static struct window_pane *window_pane_choose_best(struct window_pane **, u_int); -RB_GENERATE(windows, window, entry, window_cmp); -RB_GENERATE(winlinks, winlink, entry, winlink_cmp); -RB_GENERATE(window_pane_tree, window_pane, tree_entry, window_pane_cmp); +RBT_GENERATE(windows, window, entry, window_cmp); +RBT_GENERATE(winlinks, winlink, entry, winlink_cmp); +RBT_GENERATE(window_pane_tree, window_pane, tree_entry, window_pane_cmp); int -window_cmp(struct window *w1, struct window *w2) +window_cmp(const struct window *w1, const struct window *w2) { return (w1->id - w2->id); } int -winlink_cmp(struct winlink *wl1, struct winlink *wl2) +winlink_cmp(const struct winlink *wl1, const struct winlink *wl2) { return (wl1->idx - wl2->idx); } int -window_pane_cmp(struct window_pane *wp1, struct window_pane *wp2) +window_pane_cmp(const struct window_pane *wp1, const struct window_pane *wp2) { return (wp1->id - wp2->id); } @@ -102,7 +103,7 @@ winlink_find_by_window(struct winlinks * { struct winlink *wl; - RB_FOREACH(wl, winlinks, wwl) { + RBT_FOREACH(wl, winlinks, wwl) { if (wl->window == w) return (wl); } @@ -119,7 +120,7 @@ winlink_find_by_index(struct winlinks *w fatalx("bad index"); wl.idx = idx; - return (RB_FIND(winlinks, wwl, &wl)); + return (RBT_FIND(winlinks, wwl, &wl)); } struct winlink * @@ -127,7 +128,7 @@ winlink_find_by_window_id(struct winlink { struct winlink *wl; - RB_FOREACH(wl, winlinks, wwl) { + RBT_FOREACH(wl, winlinks, wwl) { if (wl->window->id == id) return (wl); } @@ -158,7 +159,7 @@ winlink_count(struct winlinks *wwl) u_int n; n = 0; - RB_FOREACH(wl, winlinks, wwl) + RBT_FOREACH(wl, winlinks, wwl) n++; return (n); @@ -177,7 +178,7 @@ winlink_add(struct winlinks *wwl, int id wl = xcalloc(1, sizeof *wl); wl->idx = idx; - RB_INSERT(winlinks, wwl, wl); + RBT_INSERT(winlinks, wwl, wl); return (wl); } @@ -204,7 +205,7 @@ winlink_remove(struct winlinks *wwl, str window_remove_ref(w, __func__); } - RB_REMOVE(winlinks, wwl, wl); + RBT_REMOVE(winlinks, wwl, wl); free(wl->status_text); free(wl); } @@ -212,21 +213,21 @@ winlink_remove(struct winlinks *wwl, str struct winlink * winlink_next(struct winlink *wl) { - return (RB_NEXT(winlinks, wwl, wl)); + return (RBT_NEXT(winlinks, wl)); } struct winlink * winlink_previous(struct winlink *wl) { - return (RB_PREV(winlinks, wwl, wl)); + return (RBT_PREV(winlinks, wl)); } struct winlink * winlink_next_by_number(struct winlink *wl, struct session *s, int n) { for (; n > 0; n--) { - if ((wl = RB_NEXT(winlinks, wwl, wl)) == NULL) - wl = RB_MIN(winlinks, &s->windows); + if ((wl = RBT_NEXT(winlinks, wl)) == NULL) + wl = RBT_MIN(winlinks, &s->windows); } return (wl); @@ -236,8 +237,8 @@ struct winlink * winlink_previous_by_number(struct winlink *wl, struct session *s, int n) { for (; n > 0; n--) { - if ((wl = RB_PREV(winlinks, wwl, wl)) == NULL) - wl = RB_MAX(winlinks, &s->windows); + if ((wl = RBT_PREV(winlinks, wl)) == NULL) + wl = RBT_MAX(winlinks, &s->windows); } return (wl); @@ -290,7 +291,7 @@ window_find_by_id(u_int id) struct window w; w.id = id; - return (RB_FIND(windows, &windows, &w)); + return (RBT_FIND(windows, &windows, &w)); } void @@ -324,7 +325,7 @@ window_create(u_int sx, u_int sy) TAILQ_INIT(&w->winlinks); w->id = next_window_id++; - RB_INSERT(windows, &windows, w); + RBT_INSERT(windows, &windows, w); window_update_activity(w); @@ -366,7 +367,7 @@ window_destroy(struct window *w) { log_debug("window @%u destroyed (%d references)", w->id, w->references); - RB_REMOVE(windows, &windows, w); + RBT_REMOVE(windows, &windows, w); if (w->layout_root != NULL) layout_free_cell(w->layout_root); @@ -770,7 +771,7 @@ window_pane_find_by_id(u_int id) struct window_pane wp; wp.id = id; - return (RB_FIND(window_pane_tree, &all_window_panes, &wp)); + return (RBT_FIND(window_pane_tree, &all_window_panes, &wp)); } static struct window_pane * @@ -783,7 +784,7 @@ window_pane_create(struct window *w, u_i wp->window = w; wp->id = next_window_pane_id++; - RB_INSERT(window_pane_tree, &all_window_panes, wp); + RBT_INSERT(window_pane_tree, &all_window_panes, wp); wp->argc = 0; wp->argv = NULL; @@ -850,7 +851,7 @@ window_pane_destroy(struct window_pane * if (event_initialized(&wp->resize_timer)) event_del(&wp->resize_timer); - RB_REMOVE(window_pane_tree, &all_window_panes, wp); + RBT_REMOVE(window_pane_tree, &all_window_panes, wp); free((void *)wp->cwd); free(wp->shell); Index: usr.sbin/bgpctl/irr_asset.c =================================================================== RCS file: /cvs/src/usr.sbin/bgpctl/irr_asset.c,v retrieving revision 1.11 diff -u -p -r1.11 irr_asset.c --- usr.sbin/bgpctl/irr_asset.c 16 Jan 2015 06:40:15 -0000 1.11 +++ usr.sbin/bgpctl/irr_asset.c 21 Jun 2017 00:00:38 -0000 @@ -20,18 +20,19 @@ #include #include #include +#include #include #include #include #include "irrfilter.h" -int as_set_compare(struct as_set *, struct as_set *); +int as_set_compare(const struct as_set *, const struct as_set *); struct as_set *as_set_find(char *); -RB_HEAD(as_set_h, as_set) as_set_h; -RB_PROTOTYPE(as_set_h, as_set, entry, as_set_compare) -RB_GENERATE(as_set_h, as_set, entry, as_set_compare) +RBT_HEAD(as_set_h, as_set) as_set_h; +RBT_PROTOTYPE(as_set_h, as_set, entry, as_set_compare); +RBT_GENERATE(as_set_h, as_set, entry, as_set_compare); enum obj_type { T_UNKNOWN, @@ -75,7 +76,7 @@ asset_get(char *name) /* * the caching prevents the endless recursion. - * MUST have the RB_INSERT before calling self again. + * MUST have the RBT_INSERT before calling self again. */ /* cached? then things are easy */ @@ -86,7 +87,7 @@ asset_get(char *name) err(1, "expand_as_set calloc"); if ((ass->name = strdup(name)) == NULL) err(1, "expand_as_set strdup"); - RB_INSERT(as_set_h, &as_set_h, ass); + RBT_INSERT(as_set_h, &as_set_h, ass); switch (asset_membertype(name)) { case T_ASSET: @@ -276,7 +277,7 @@ asset_add_asset(struct as_set *ass, char /* RB helpers */ int -as_set_compare(struct as_set *a, struct as_set *b) +as_set_compare(const struct as_set *a, const struct as_set *b) { return (strcmp(a->name, b->name)); } @@ -287,5 +288,5 @@ as_set_find(char *name) struct as_set s; s.name = name; - return (RB_FIND(as_set_h, &as_set_h, &s)); + return (RBT_FIND(as_set_h, &as_set_h, &s)); } Index: usr.sbin/bgpctl/irr_prefix.c =================================================================== RCS file: /cvs/src/usr.sbin/bgpctl/irr_prefix.c,v retrieving revision 1.21 diff -u -p -r1.21 irr_prefix.c --- usr.sbin/bgpctl/irr_prefix.c 5 Oct 2015 14:18:33 -0000 1.21 +++ usr.sbin/bgpctl/irr_prefix.c 21 Jun 2017 00:00:38 -0000 @@ -32,13 +32,14 @@ void prefixset_aggregate(struct prefix_set *); int prefix_aggregate(struct irr_prefix *, const struct irr_prefix *); int irr_prefix_cmp(const void *, const void *); -int prefix_set_compare(struct prefix_set *, struct prefix_set *); +int prefix_set_compare(const struct prefix_set *, + const struct prefix_set *); struct prefix_set *prefix_set_find(char *); -RB_HEAD(prefix_set_h, prefix_set) prefix_set_h; -RB_PROTOTYPE(prefix_set_h, prefix_set, entry, prefix_set_compare) -RB_GENERATE(prefix_set_h, prefix_set, entry, prefix_set_compare) +RBT_HEAD(prefix_set_h, prefix_set) prefix_set_h; +RBT_PROTOTYPE(prefix_set_h, prefix_set, entry, prefix_set_compare); +RBT_GENERATE(prefix_set_h, prefix_set, entry, prefix_set_compare); struct prefix_set *curpfxs = NULL; @@ -55,7 +56,7 @@ prefixset_get(char *as) err(1, "get_prefixset calloc"); if ((pfxs->as = strdup(as)) == NULL) err(1, "get_prefixset strdup"); - RB_INSERT(prefix_set_h, &prefix_set_h, pfxs); + RBT_INSERT(prefix_set_h, &prefix_set_h, pfxs); if (irrverbose >= 3) { fprintf(stdout, "query routes for %s... ", as); @@ -274,7 +275,7 @@ irr_prefix_cmp(const void *a, const void /* RB helpers */ int -prefix_set_compare(struct prefix_set *a, struct prefix_set *b) +prefix_set_compare(const struct prefix_set *a, const struct prefix_set *b) { return (strcmp(a->as, b->as)); } @@ -285,5 +286,5 @@ prefix_set_find(char *as) struct prefix_set s; s.as = as; - return (RB_FIND(prefix_set_h, &prefix_set_h, &s)); + return (RBT_FIND(prefix_set_h, &prefix_set_h, &s)); } Index: usr.sbin/bgpctl/irrfilter.h =================================================================== RCS file: /cvs/src/usr.sbin/bgpctl/irrfilter.h,v retrieving revision 1.9 diff -u -p -r1.9 irrfilter.h --- usr.sbin/bgpctl/irrfilter.h 8 Sep 2009 16:11:36 -0000 1.9 +++ usr.sbin/bgpctl/irrfilter.h 21 Jun 2017 00:00:38 -0000 @@ -62,7 +62,7 @@ enum qtype { }; struct as_set { - RB_ENTRY(as_set) entry; + RBT_ENTRY(as_set) entry; char *name; char **members; /* direct members */ char **as_set; /* members as-set */ @@ -83,7 +83,7 @@ struct irr_prefix { }; struct prefix_set { - RB_ENTRY(prefix_set) entry; + RBT_ENTRY(prefix_set) entry; char *as; struct irr_prefix **prefix; u_int prefixcnt; Index: usr.sbin/bgpd/bgpd.h =================================================================== RCS file: /cvs/src/usr.sbin/bgpd/bgpd.h,v retrieving revision 1.308 diff -u -p -r1.308 bgpd.h --- usr.sbin/bgpd/bgpd.h 31 May 2017 10:44:00 -0000 1.308 +++ usr.sbin/bgpd/bgpd.h 21 Jun 2017 00:00:38 -0000 @@ -30,6 +30,7 @@ #include #include +#include #include @@ -495,9 +496,9 @@ enum suberr_cease { struct kroute_node; struct kroute6_node; struct knexthop_node; -RB_HEAD(kroute_tree, kroute_node); -RB_HEAD(kroute6_tree, kroute6_node); -RB_HEAD(knexthop_tree, knexthop_node); +RBT_HEAD(kroute_tree, kroute_node); +RBT_HEAD(kroute6_tree, kroute6_node); +RBT_HEAD(knexthop_tree, knexthop_node); struct ktable { char descr[PEER_DESCR_LEN]; Index: usr.sbin/bgpd/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/bgpd/kroute.c,v retrieving revision 1.215 diff -u -p -r1.215 kroute.c --- usr.sbin/bgpd/kroute.c 31 May 2017 10:47:21 -0000 1.215 +++ usr.sbin/bgpd/kroute.c 21 Jun 2017 00:00:38 -0000 @@ -48,19 +48,19 @@ struct { } kr_state; struct kroute_node { - RB_ENTRY(kroute_node) entry; + RBT_ENTRY(kroute_node) entry; struct kroute r; struct kroute_node *next; }; struct kroute6_node { - RB_ENTRY(kroute6_node) entry; + RBT_ENTRY(kroute6_node) entry; struct kroute6 r; struct kroute6_node *next; }; struct knexthop_node { - RB_ENTRY(knexthop_node) entry; + RBT_ENTRY(knexthop_node) entry; struct bgpd_addr nexthop; void *kroute; }; @@ -79,7 +79,7 @@ LIST_HEAD(kif_kr_head, kif_kr); LIST_HEAD(kif_kr6_head, kif_kr6); struct kif_node { - RB_ENTRY(kif_node) entry; + RBT_ENTRY(kif_node) entry; struct kif k; struct kif_kr_head kroute_l; struct kif_kr6_head kroute6_l; @@ -104,10 +104,12 @@ int kr_redistribute(int, struct ktable * int kr_redistribute6(int, struct ktable *, struct kroute6 *); struct kroute_full *kr_tofull(struct kroute *); struct kroute_full *kr6_tofull(struct kroute6 *); -int kroute_compare(struct kroute_node *, struct kroute_node *); -int kroute6_compare(struct kroute6_node *, struct kroute6_node *); -int knexthop_compare(struct knexthop_node *, struct knexthop_node *); -int kif_compare(struct kif_node *, struct kif_node *); +int kroute_compare(const struct kroute_node *, const struct kroute_node *); +int kroute6_compare(const struct kroute6_node *, + const struct kroute6_node *); +int knexthop_compare(const struct knexthop_node *, + const struct knexthop_node *); +int kif_compare(const struct kif_node *, const struct kif_node *); void kr_fib_update_prio(u_int, u_int8_t); struct kroute_node *kroute_find(struct ktable *, in_addr_t, u_int8_t, @@ -174,18 +176,18 @@ int fetchifs(int); int dispatch_rtmsg_addr(struct rt_msghdr *, struct sockaddr *[RTAX_MAX], struct ktable *); -RB_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare) -RB_GENERATE(kroute_tree, kroute_node, entry, kroute_compare) +RBT_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare); +RBT_GENERATE(kroute_tree, kroute_node, entry, kroute_compare); -RB_PROTOTYPE(kroute6_tree, kroute6_node, entry, kroute6_compare) -RB_GENERATE(kroute6_tree, kroute6_node, entry, kroute6_compare) +RBT_PROTOTYPE(kroute6_tree, kroute6_node, entry, kroute6_compare); +RBT_GENERATE(kroute6_tree, kroute6_node, entry, kroute6_compare); -RB_PROTOTYPE(knexthop_tree, knexthop_node, entry, knexthop_compare) -RB_GENERATE(knexthop_tree, knexthop_node, entry, knexthop_compare) +RBT_PROTOTYPE(knexthop_tree, knexthop_node, entry, knexthop_compare); +RBT_GENERATE(knexthop_tree, knexthop_node, entry, knexthop_compare); -RB_HEAD(kif_tree, kif_node) kit; -RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) -RB_GENERATE(kif_tree, kif_node, entry, kif_compare) +RBT_HEAD(kif_tree, kif_node) kit; +RBT_PROTOTYPE(kif_tree, kif_node, entry, kif_compare); +RBT_GENERATE(kif_tree, kif_node, entry, kif_compare); #define KT2KNT(x) (&(ktable_get((x)->nhtableid)->knt)) @@ -233,7 +235,7 @@ kr_init(void) kr_state.pid = getpid(); kr_state.rtseq = 1; - RB_INIT(&kit); + RBT_INIT(kif_tree, &kit); if (fetchifs(0) == -1) return (-1); @@ -275,9 +277,9 @@ ktable_new(u_int rtableid, u_int rdomid, /* initialize structure ... */ strlcpy(kt->descr, name, sizeof(kt->descr)); - RB_INIT(&kt->krt); - RB_INIT(&kt->krt6); - RB_INIT(&kt->knt); + RBT_INIT(kroute_tree, &kt->krt); + RBT_INIT(kroute6_tree, &kt->krt6); + RBT_INIT(knexthop_tree, &kt->knt); TAILQ_INIT(&kt->krn); kt->fib_conf = kt->fib_sync = fs; kt->rtableid = rtableid; @@ -782,10 +784,10 @@ kr_fib_couple(u_int rtableid, u_int8_t f kt->fib_sync = 1; - RB_FOREACH(kr, kroute_tree, &kt->krt) + RBT_FOREACH(kr, kroute_tree, &kt->krt) if ((kr->r.flags & F_BGPD_INSERTED)) send_rtmsg(kr_state.fd, RTM_ADD, kt, &kr->r, fib_prio); - RB_FOREACH(kr6, kroute6_tree, &kt->krt6) + RBT_FOREACH(kr6, kroute6_tree, &kt->krt6) if ((kr6->r.flags & F_BGPD_INSERTED)) send_rt6msg(kr_state.fd, RTM_ADD, kt, &kr6->r, fib_prio); @@ -816,11 +818,11 @@ kr_fib_decouple(u_int rtableid, u_int8_t if (!kt->fib_sync) /* already decoupled */ return; - RB_FOREACH(kr, kroute_tree, &kt->krt) + RBT_FOREACH(kr, kroute_tree, &kt->krt) if ((kr->r.flags & F_BGPD_INSERTED)) send_rtmsg(kr_state.fd, RTM_DELETE, kt, &kr->r, fib_prio); - RB_FOREACH(kr6, kroute6_tree, &kt->krt6) + RBT_FOREACH(kr6, kroute6_tree, &kt->krt6) if ((kr6->r.flags & F_BGPD_INSERTED)) send_rt6msg(kr_state.fd, RTM_DELETE, kt, &kr6->r, fib_prio); @@ -850,11 +852,11 @@ kr_fib_update_prio(u_int rtableid, u_int if ((kt = ktable_get(rtableid)) == NULL) /* table does not exist */ return; - RB_FOREACH(kr, kroute_tree, &kt->krt) + RBT_FOREACH(kr, kroute_tree, &kt->krt) if ((kr->r.flags & F_BGPD_INSERTED)) kr->r.priority = fib_prio; - RB_FOREACH(kr6, kroute6_tree, &kt->krt6) + RBT_FOREACH(kr6, kroute6_tree, &kt->krt6) if ((kr6->r.flags & F_BGPD_INSERTED)) kr6->r.priority = fib_prio; } @@ -956,7 +958,7 @@ kr_show_route(struct imsg *imsg) memcpy(&flags, imsg->data, sizeof(flags)); memcpy(&af, (char *)imsg->data + sizeof(flags), sizeof(af)); if (!af || af == AF_INET) - RB_FOREACH(kr, kroute_tree, &kt->krt) { + RBT_FOREACH(kr, kroute_tree, &kt->krt) { if (flags && (kr->r.flags & flags) == 0) continue; kn = kr; @@ -967,7 +969,7 @@ kr_show_route(struct imsg *imsg) } while ((kn = kn->next) != NULL); } if (!af || af == AF_INET6) - RB_FOREACH(kr6, kroute6_tree, &kt->krt6) { + RBT_FOREACH(kr6, kroute6_tree, &kt->krt6) { if (flags && (kr6->r.flags & flags) == 0) continue; kn6 = kr6; @@ -1016,7 +1018,7 @@ kr_show_route(struct imsg *imsg) imsg->hdr.peerid); break; } - RB_FOREACH(h, knexthop_tree, KT2KNT(kt)) { + RBT_FOREACH(h, knexthop_tree, KT2KNT(kt)) { bzero(&snh, sizeof(snh)); memcpy(&snh.addr, &h->nexthop, sizeof(snh.addr)); if (h->kroute != NULL) { @@ -1047,7 +1049,7 @@ kr_show_route(struct imsg *imsg) } break; case IMSG_CTL_SHOW_INTERFACE: - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) send_imsg_session(IMSG_CTL_SHOW_INTERFACE, imsg->hdr.pid, &kif->k, sizeof(kif->k)); break; @@ -1060,9 +1062,9 @@ kr_show_route(struct imsg *imsg) ktab = *kt; /* do not leak internal information */ - RB_INIT(&ktab.krt); - RB_INIT(&ktab.krt6); - RB_INIT(&ktab.knt); + RBT_INIT(kroute_tree, &ktab.krt); + RBT_INIT(kroute6_tree, &ktab.krt6); + RBT_INIT(knexthop_tree, &ktab.knt); TAILQ_INIT(&ktab.krn); send_imsg_session(IMSG_CTL_SHOW_FIB_TABLES, @@ -1081,7 +1083,7 @@ kr_ifinfo(char *ifname) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (!strcmp(ifname, kif->k.ifname)) { send_imsg_session(IMSG_IFINFO, 0, &kif->k, sizeof(kif->k)); @@ -1375,7 +1377,7 @@ kr_reload(void) if ((kt = ktable_get(rid)) == NULL) continue; - RB_FOREACH(nh, knexthop_tree, KT2KNT(kt)) + RBT_FOREACH(nh, knexthop_tree, KT2KNT(kt)) knexthop_validate(kt, nh); TAILQ_FOREACH(n, &kt->krn, entry) @@ -1388,9 +1390,9 @@ kr_reload(void) if (hasdyn) { /* only evaluate the full tree if we need */ - RB_FOREACH(kr, kroute_tree, &kt->krt) + RBT_FOREACH(kr, kroute_tree, &kt->krt) kr_redistribute(IMSG_NETWORK_ADD, kt, &kr->r); - RB_FOREACH(kr6, kroute6_tree, &kt->krt6) + RBT_FOREACH(kr6, kroute6_tree, &kt->krt6) kr_redistribute6(IMSG_NETWORK_ADD, kt, &kr6->r); } } @@ -1445,7 +1447,7 @@ kr6_tofull(struct kroute6 *kr6) */ int -kroute_compare(struct kroute_node *a, struct kroute_node *b) +kroute_compare(const struct kroute_node *a, const struct kroute_node *b) { if (ntohl(a->r.prefix.s_addr) < ntohl(b->r.prefix.s_addr)) return (-1); @@ -1467,7 +1469,7 @@ kroute_compare(struct kroute_node *a, st } int -kroute6_compare(struct kroute6_node *a, struct kroute6_node *b) +kroute6_compare(const struct kroute6_node *a, const struct kroute6_node *b) { int i; @@ -1494,7 +1496,7 @@ kroute6_compare(struct kroute6_node *a, } int -knexthop_compare(struct knexthop_node *a, struct knexthop_node *b) +knexthop_compare(const struct knexthop_node *a, const struct knexthop_node *b) { int i; @@ -1524,7 +1526,7 @@ knexthop_compare(struct knexthop_node *a } int -kif_compare(struct kif_node *a, struct kif_node *b) +kif_compare(const struct kif_node *a, const struct kif_node *b) { return (b->k.ifindex - a->k.ifindex); } @@ -1545,15 +1547,15 @@ kroute_find(struct ktable *kt, in_addr_t s.r.prefixlen = prefixlen; s.r.priority = prio; - kn = RB_FIND(kroute_tree, &kt->krt, &s); + kn = RBT_FIND(kroute_tree, &kt->krt, &s); if (kn && prio == RTP_ANY) { - tmp = RB_PREV(kroute_tree, &kt->krt, kn); + tmp = RBT_PREV(kroute_tree, kn); while (tmp) { if (kroute_compare(&s, tmp) == 0) kn = tmp; else break; - tmp = RB_PREV(kroute_tree, &kt->krt, kn); + tmp = RBT_PREV(kroute_tree, kn); } } return (kn); @@ -1586,7 +1588,7 @@ kroute_insert(struct ktable *kt, struct struct knexthop_node *h; in_addr_t mask, ina; - if ((krm = RB_INSERT(kroute_tree, &kt->krt, kr)) != NULL) { + if ((krm = RBT_INSERT(kroute_tree, &kt->krt, kr)) != NULL) { /* multipath route, add at end of list */ while (krm->next != NULL) krm = krm->next; @@ -1598,7 +1600,7 @@ kroute_insert(struct ktable *kt, struct if (kr->r.flags & F_KERNEL) { mask = prefixlen2mask(kr->r.prefixlen); ina = ntohl(kr->r.prefix.s_addr); - RB_FOREACH(h, knexthop_tree, KT2KNT(kt)) + RBT_FOREACH(h, knexthop_tree, KT2KNT(kt)) if (h->nexthop.aid == AID_INET && (ntohl(h->nexthop.v4.s_addr) & mask) == ina) knexthop_validate(kt, h); @@ -1621,7 +1623,7 @@ kroute_remove(struct ktable *kt, struct struct kroute_node *krm; struct knexthop_node *s; - if ((krm = RB_FIND(kroute_tree, &kt->krt, kr)) == NULL) { + if ((krm = RBT_FIND(kroute_tree, &kt->krt, kr)) == NULL) { log_warnx("kroute_remove failed to find %s/%u", inet_ntoa(kr->r.prefix), kr->r.prefixlen); return (-1); @@ -1629,13 +1631,13 @@ kroute_remove(struct ktable *kt, struct if (krm == kr) { /* head element */ - if (RB_REMOVE(kroute_tree, &kt->krt, kr) == NULL) { + if (RBT_REMOVE(kroute_tree, &kt->krt, kr) == NULL) { log_warnx("kroute_remove failed for %s/%u", inet_ntoa(kr->r.prefix), kr->r.prefixlen); return (-1); } if (kr->next != NULL) { - if (RB_INSERT(kroute_tree, &kt->krt, kr->next) != + if (RBT_INSERT(kroute_tree, &kt->krt, kr->next) != NULL) { log_warnx("kroute_remove failed to add %s/%u", inet_ntoa(kr->r.prefix), kr->r.prefixlen); @@ -1657,7 +1659,7 @@ kroute_remove(struct ktable *kt, struct /* check whether a nexthop depends on this kroute */ if (kr->r.flags & F_NEXTHOP) - RB_FOREACH(s, knexthop_tree, KT2KNT(kt)) + RBT_FOREACH(s, knexthop_tree, KT2KNT(kt)) if (s->kroute == kr) knexthop_validate(kt, s); @@ -1680,7 +1682,7 @@ kroute_clear(struct ktable *kt) { struct kroute_node *kr; - while ((kr = RB_MIN(kroute_tree, &kt->krt)) != NULL) + while ((kr = RBT_MIN(kroute_tree, &kt->krt)) != NULL) kroute_remove(kt, kr); } @@ -1695,15 +1697,15 @@ kroute6_find(struct ktable *kt, const st s.r.prefixlen = prefixlen; s.r.priority = prio; - kn6 = RB_FIND(kroute6_tree, &kt->krt6, &s); + kn6 = RBT_FIND(kroute6_tree, &kt->krt6, &s); if (kn6 && prio == RTP_ANY) { - tmp = RB_PREV(kroute6_tree, &kt->krt6, kn6); + tmp = RBT_PREV(kroute6_tree, kn6); while (tmp) { if (kroute6_compare(&s, tmp) == 0) kn6 = tmp; else break; - tmp = RB_PREV(kroute6_tree, &kt->krt6, kn6); + tmp = RBT_PREV(kroute6_tree, kn6); } } return (kn6); @@ -1736,7 +1738,7 @@ kroute6_insert(struct ktable *kt, struct struct knexthop_node *h; struct in6_addr ina, inb; - if ((krm = RB_INSERT(kroute6_tree, &kt->krt6, kr)) != NULL) { + if ((krm = RBT_INSERT(kroute6_tree, &kt->krt6, kr)) != NULL) { /* multipath route, add at end of list */ while (krm->next != NULL) krm = krm->next; @@ -1747,7 +1749,7 @@ kroute6_insert(struct ktable *kt, struct /* XXX this is wrong for nexthop validated via BGP */ if (kr->r.flags & F_KERNEL) { inet6applymask(&ina, &kr->r.prefix, kr->r.prefixlen); - RB_FOREACH(h, knexthop_tree, KT2KNT(kt)) + RBT_FOREACH(h, knexthop_tree, KT2KNT(kt)) if (h->nexthop.aid == AID_INET6) { inet6applymask(&inb, &h->nexthop.v6, kr->r.prefixlen); @@ -1773,7 +1775,7 @@ kroute6_remove(struct ktable *kt, struct struct kroute6_node *krm; struct knexthop_node *s; - if ((krm = RB_FIND(kroute6_tree, &kt->krt6, kr)) == NULL) { + if ((krm = RBT_FIND(kroute6_tree, &kt->krt6, kr)) == NULL) { log_warnx("kroute6_remove failed for %s/%u", log_in6addr(&kr->r.prefix), kr->r.prefixlen); return (-1); @@ -1781,13 +1783,13 @@ kroute6_remove(struct ktable *kt, struct if (krm == kr) { /* head element */ - if (RB_REMOVE(kroute6_tree, &kt->krt6, kr) == NULL) { + if (RBT_REMOVE(kroute6_tree, &kt->krt6, kr) == NULL) { log_warnx("kroute6_remove failed for %s/%u", log_in6addr(&kr->r.prefix), kr->r.prefixlen); return (-1); } if (kr->next != NULL) { - if (RB_INSERT(kroute6_tree, &kt->krt6, kr->next) != + if (RBT_INSERT(kroute6_tree, &kt->krt6, kr->next) != NULL) { log_warnx("kroute6_remove failed to add %s/%u", log_in6addr(&kr->r.prefix), @@ -1810,7 +1812,7 @@ kroute6_remove(struct ktable *kt, struct /* check whether a nexthop depends on this kroute */ if (kr->r.flags & F_NEXTHOP) - RB_FOREACH(s, knexthop_tree, KT2KNT(kt)) + RBT_FOREACH(s, knexthop_tree, KT2KNT(kt)) if (s->kroute == kr) knexthop_validate(kt, s); @@ -1833,7 +1835,7 @@ kroute6_clear(struct ktable *kt) { struct kroute6_node *kr; - while ((kr = RB_MIN(kroute6_tree, &kt->krt6)) != NULL) + while ((kr = RBT_MIN(kroute6_tree, &kt->krt6)) != NULL) kroute6_remove(kt, kr); } @@ -1845,13 +1847,13 @@ knexthop_find(struct ktable *kt, struct bzero(&s, sizeof(s)); memcpy(&s.nexthop, addr, sizeof(s.nexthop)); - return (RB_FIND(knexthop_tree, KT2KNT(kt), &s)); + return (RBT_FIND(knexthop_tree, KT2KNT(kt), &s)); } int knexthop_insert(struct ktable *kt, struct knexthop_node *kn) { - if (RB_INSERT(knexthop_tree, KT2KNT(kt), kn) != NULL) { + if (RBT_INSERT(knexthop_tree, KT2KNT(kt), kn) != NULL) { log_warnx("knexthop_insert failed for %s", log_addr(&kn->nexthop)); free(kn); @@ -1868,7 +1870,7 @@ knexthop_remove(struct ktable *kt, struc { kroute_detach_nexthop(kt, kn); - if (RB_REMOVE(knexthop_tree, KT2KNT(kt), kn) == NULL) { + if (RBT_REMOVE(knexthop_tree, KT2KNT(kt), kn) == NULL) { log_warnx("knexthop_remove failed for %s", log_addr(&kn->nexthop)); return (-1); @@ -1883,7 +1885,7 @@ knexthop_clear(struct ktable *kt) { struct knexthop_node *kn; - while ((kn = RB_MIN(knexthop_tree, KT2KNT(kt))) != NULL) + while ((kn = RBT_MIN(knexthop_tree, KT2KNT(kt))) != NULL) knexthop_remove(kt, kn); } @@ -1895,7 +1897,7 @@ kif_find(int ifindex) bzero(&s, sizeof(s)); s.k.ifindex = ifindex; - return (RB_FIND(kif_tree, &kit, &s)); + return (RBT_FIND(kif_tree, &kit, &s)); } int @@ -1904,8 +1906,8 @@ kif_insert(struct kif_node *kif) LIST_INIT(&kif->kroute_l); LIST_INIT(&kif->kroute6_l); - if (RB_INSERT(kif_tree, &kit, kif) != NULL) { - log_warnx("RB_INSERT(kif_tree, &kit, kif)"); + if (RBT_INSERT(kif_tree, &kit, kif) != NULL) { + log_warnx("RBT_INSERT(kif_tree, &kit, kif)"); free(kif); return (-1); } @@ -1920,8 +1922,8 @@ kif_remove(struct kif_node *kif) struct kif_kr *kkr; struct kif_kr6 *kkr6; - if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { - log_warnx("RB_REMOVE(kif_tree, &kit, kif)"); + if (RBT_REMOVE(kif_tree, &kit, kif) == NULL) { + log_warnx("RBT_REMOVE(kif_tree, &kit, kif)"); return (-1); } @@ -1951,7 +1953,7 @@ kif_clear(void) { struct kif_node *kif; - while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + while ((kif = RBT_MIN(kif_tree, &kit)) != NULL) kif_remove(kif); } @@ -2181,7 +2183,7 @@ knexthop_track(struct ktable *kt, void * { struct knexthop_node *kn; - RB_FOREACH(kn, knexthop_tree, KT2KNT(kt)) + RBT_FOREACH(kn, knexthop_tree, KT2KNT(kt)) if (kn->kroute == krp) knexthop_send_update(kn); } @@ -2299,7 +2301,7 @@ kroute_detach_nexthop(struct ktable *kt, * check whether there's another nexthop depending on this kroute * if not remove the flag */ - RB_FOREACH(s, knexthop_tree, KT2KNT(kt)) + RBT_FOREACH(s, knexthop_tree, KT2KNT(kt)) if (s->kroute == kn->kroute && s != kn) break; @@ -2338,7 +2340,7 @@ protect_lo(struct ktable *kt) kr->r.prefixlen = 8; kr->r.flags = F_KERNEL|F_CONNECTED; - if (RB_INSERT(kroute_tree, &kt->krt, kr) != NULL) + if (RBT_INSERT(kroute_tree, &kt->krt, kr) != NULL) free(kr); /* kernel route already there, no problem */ /* special protection for loopback */ @@ -2350,7 +2352,7 @@ protect_lo(struct ktable *kt) kr6->r.prefixlen = 128; kr6->r.flags = F_KERNEL|F_CONNECTED; - if (RB_INSERT(kroute6_tree, &kt->krt6, kr6) != NULL) + if (RBT_INSERT(kroute6_tree, &kt->krt6, kr6) != NULL) free(kr6); /* kernel route already there, no problem */ return (0); Index: usr.sbin/bgpd/rde.h =================================================================== RCS file: /cvs/src/usr.sbin/bgpd/rde.h,v retrieving revision 1.162 diff -u -p -r1.162 rde.h --- usr.sbin/bgpd/rde.h 30 May 2017 18:08:15 -0000 1.162 +++ usr.sbin/bgpd/rde.h 21 Jun 2017 00:00:38 -0000 @@ -41,11 +41,11 @@ enum peer_state { */ LIST_HEAD(rde_peer_head, rde_peer); LIST_HEAD(aspath_head, rde_aspath); -RB_HEAD(uptree_prefix, update_prefix); -RB_HEAD(uptree_attr, update_attr); +RBT_HEAD(uptree_prefix, update_prefix); +RBT_HEAD(uptree_attr, update_attr); struct rib_desc; struct rib; -RB_HEAD(rib_tree, rib_entry); +RBT_HEAD(rib_tree, rib_entry); TAILQ_HEAD(uplist_prefix, update_prefix); TAILQ_HEAD(uplist_attr, update_attr); @@ -232,14 +232,14 @@ struct nexthop { /* generic entry without address specific part */ struct pt_entry { - RB_ENTRY(pt_entry) pt_e; + RBT_ENTRY(pt_entry) pt_e; u_int8_t aid; u_int8_t prefixlen; u_int16_t refcnt; }; struct pt_entry4 { - RB_ENTRY(pt_entry) pt_e; + RBT_ENTRY(pt_entry) pt_e; u_int8_t aid; u_int8_t prefixlen; u_int16_t refcnt; @@ -247,7 +247,7 @@ struct pt_entry4 { }; struct pt_entry6 { - RB_ENTRY(pt_entry) pt_e; + RBT_ENTRY(pt_entry) pt_e; u_int8_t aid; u_int8_t prefixlen; u_int16_t refcnt; @@ -255,7 +255,7 @@ struct pt_entry6 { }; struct pt_entry_vpn4 { - RB_ENTRY(pt_entry) pt_e; + RBT_ENTRY(pt_entry) pt_e; u_int8_t aid; u_int8_t prefixlen; u_int16_t refcnt; @@ -279,7 +279,7 @@ struct rib_context { }; struct rib_entry { - RB_ENTRY(rib_entry) rib_e; + RBT_ENTRY(rib_entry) rib_e; struct prefix_head prefix_h; struct prefix *active; /* for fast access */ struct pt_entry *prefix; Index: usr.sbin/bgpd/rde_prefix.c =================================================================== RCS file: /cvs/src/usr.sbin/bgpd/rde_prefix.c,v retrieving revision 1.33 diff -u -p -r1.33 rde_prefix.c --- usr.sbin/bgpd/rde_prefix.c 24 Jan 2017 04:22:42 -0000 1.33 +++ usr.sbin/bgpd/rde_prefix.c 21 Jun 2017 00:00:38 -0000 @@ -49,22 +49,22 @@ static void pt_free(struct pt_entry *) size_t pt_sizes[AID_MAX] = AID_PTSIZE; -RB_HEAD(pt_tree, pt_entry); -RB_PROTOTYPE(pt_tree, pt_entry, pt_e, pt_prefix_cmp); -RB_GENERATE(pt_tree, pt_entry, pt_e, pt_prefix_cmp); +RBT_HEAD(pt_tree, pt_entry); +RBT_PROTOTYPE(pt_tree, pt_entry, pt_e, pt_prefix_cmp); +RBT_GENERATE(pt_tree, pt_entry, pt_e, pt_prefix_cmp); struct pt_tree pttable; void pt_init(void) { - RB_INIT(&pttable); + RBT_INIT(pt_tree, &pttable); } void pt_shutdown(void) { - if (!RB_EMPTY(&pttable)) + if (!RBT_EMPTY(pt_tree, &pttable)) log_debug("pt_shutdown: tree is not empty."); } @@ -147,7 +147,7 @@ pt_get(struct bgpd_addr *prefix, int pre struct pt_entry *pte; pte = pt_fill(prefix, prefixlen); - return RB_FIND(pt_tree, &pttable, pte); + return RBT_FIND(pt_tree, &pttable, pte); } struct pt_entry * @@ -158,7 +158,7 @@ pt_add(struct bgpd_addr *prefix, int pre p = pt_fill(prefix, prefixlen); p = pt_alloc(p); - if (RB_INSERT(pt_tree, &pttable, p) != NULL) + if (RBT_INSERT(pt_tree, &pttable, p) != NULL) fatalx("pt_add: insert failed"); return (p); @@ -170,7 +170,7 @@ pt_remove(struct pt_entry *pte) if (!pt_empty(pte)) fatalx("pt_remove: entry still holds references"); - if (RB_REMOVE(pt_tree, &pttable, pte) == NULL) + if (RBT_REMOVE(pt_tree, &pttable, pte) == NULL) log_warnx("pt_remove: remove failed."); pt_free(pte); } Index: usr.sbin/bgpd/rde_rib.c =================================================================== RCS file: /cvs/src/usr.sbin/bgpd/rde_rib.c,v retrieving revision 1.154 diff -u -p -r1.154 rde_rib.c --- usr.sbin/bgpd/rde_rib.c 28 May 2017 12:21:36 -0000 1.154 +++ usr.sbin/bgpd/rde_rib.c 21 Jun 2017 00:00:38 -0000 @@ -44,8 +44,8 @@ void rib_remove(struct rib_entry *); int rib_empty(struct rib_entry *); struct rib_entry *rib_restart(struct rib_context *); -RB_PROTOTYPE(rib_tree, rib_entry, rib_e, rib_compare); -RB_GENERATE(rib_tree, rib_entry, rib_e, rib_compare); +RBT_PROTOTYPE(rib_tree, rib_entry, rib_e, rib_compare); +RBT_GENERATE(rib_tree, rib_entry, rib_e, rib_compare); static inline void re_lock(struct rib_entry *re) @@ -95,7 +95,7 @@ rib_new(char *name, u_int rtableid, u_in bzero(&ribs[id], sizeof(struct rib_desc)); strlcpy(ribs[id].name, name, sizeof(ribs[id].name)); - RB_INIT(rib_tree(&ribs[id].rib)); + RBT_INIT(rib_tree, rib_tree(&ribs[id].rib)); ribs[id].state = RECONF_REINIT; ribs[id].rib.id = id; ribs[id].rib.flags = flags; @@ -138,8 +138,8 @@ rib_free(struct rib *rib) struct rib_entry *re, *xre; struct prefix *p, *np; - for (re = RB_MIN(rib_tree, rib_tree(rib)); re != NULL; re = xre) { - xre = RB_NEXT(rib_tree, rib_tree(rib), re); + for (re = RBT_MIN(rib_tree, rib_tree(rib)); re != NULL; re = xre) { + xre = RBT_NEXT(rib_tree, re); /* * Removing the prefixes is tricky because the last one @@ -184,7 +184,7 @@ rib_get(struct rib *rib, struct bgpd_add bzero(&xre, sizeof(xre)); xre.prefix = pte; - return (RB_FIND(rib_tree, rib_tree(rib), &xre)); + return (RBT_FIND(rib_tree, rib_tree(rib), &xre)); } struct rib_entry * @@ -233,7 +233,7 @@ rib_add(struct rib *rib, struct bgpd_add re->prefix = pte; re->__rib = rib; - if (RB_INSERT(rib_tree, rib_tree(rib), re) != NULL) { + if (RBT_INSERT(rib_tree, rib_tree(rib), re) != NULL) { log_warnx("rib_add: insert failed"); free(re); return (NULL); @@ -260,7 +260,7 @@ rib_remove(struct rib_entry *re) if (pt_empty(re->prefix)) pt_remove(re->prefix); - if (RB_REMOVE(rib_tree, rib_tree(re_rib(re)), re) == NULL) + if (RBT_REMOVE(rib_tree, rib_tree(re_rib(re)), re) == NULL) log_warnx("rib_remove: remove failed."); free(re); @@ -295,11 +295,11 @@ rib_dump_r(struct rib_context *ctx) unsigned int i; if (ctx->ctx_re == NULL) - re = RB_MIN(rib_tree, rib_tree(ctx->ctx_rib)); + re = RBT_MIN(rib_tree, rib_tree(ctx->ctx_rib)); else re = rib_restart(ctx); - for (i = 0; re != NULL; re = RB_NEXT(rib_tree, unused, re)) { + for (i = 0; re != NULL; re = RBT_NEXT(rib_tree, re)) { if (ctx->ctx_aid != AID_UNSPEC && ctx->ctx_aid != re->prefix->aid) continue; @@ -329,7 +329,7 @@ rib_restart(struct rib_context *ctx) /* find first non empty element */ while (re && rib_empty(re)) - re = RB_NEXT(rib_tree, unused, re); + re = RBT_NEXT(rib_tree, re); /* free the previously locked rib element if empty */ if (rib_empty(ctx->ctx_re)) Index: usr.sbin/bgpd/rde_update.c =================================================================== RCS file: /cvs/src/usr.sbin/bgpd/rde_update.c,v retrieving revision 1.86 diff -u -p -r1.86 rde_update.c --- usr.sbin/bgpd/rde_update.c 30 May 2017 18:08:15 -0000 1.86 +++ usr.sbin/bgpd/rde_update.c 21 Jun 2017 00:00:38 -0000 @@ -36,7 +36,7 @@ int up_generate_attr(struct rde_peer *, /* update stuff. */ struct update_prefix { TAILQ_ENTRY(update_prefix) prefix_l; - RB_ENTRY(update_prefix) entry; + RBT_ENTRY(update_prefix) entry; struct uplist_prefix *prefix_h; struct bgpd_addr prefix; int prefixlen; @@ -44,7 +44,7 @@ struct update_prefix { struct update_attr { TAILQ_ENTRY(update_attr) attr_l; - RB_ENTRY(update_attr) entry; + RBT_ENTRY(update_attr) entry; struct uplist_prefix prefix_h; u_char *attr; u_char *mpattr; @@ -54,15 +54,16 @@ struct update_attr { }; void up_clear(struct uplist_attr *, struct uplist_prefix *); -int up_prefix_cmp(struct update_prefix *, struct update_prefix *); -int up_attr_cmp(struct update_attr *, struct update_attr *); +int up_prefix_cmp(const struct update_prefix *, + const struct update_prefix *); +int up_attr_cmp(const struct update_attr *, const struct update_attr *); int up_add(struct rde_peer *, struct update_prefix *, struct update_attr *); -RB_PROTOTYPE(uptree_prefix, update_prefix, entry, up_prefix_cmp) -RB_GENERATE(uptree_prefix, update_prefix, entry, up_prefix_cmp) +RBT_PROTOTYPE(uptree_prefix, update_prefix, entry, up_prefix_cmp); +RBT_GENERATE(uptree_prefix, update_prefix, entry, up_prefix_cmp); -RB_PROTOTYPE(uptree_attr, update_attr, entry, up_attr_cmp) -RB_GENERATE(uptree_attr, update_attr, entry, up_attr_cmp) +RBT_PROTOTYPE(uptree_attr, update_attr, entry, up_attr_cmp); +RBT_GENERATE(uptree_attr, update_attr, entry, up_attr_cmp); SIPHASH_KEY uptree_key; @@ -75,8 +76,8 @@ up_init(struct rde_peer *peer) TAILQ_INIT(&peer->updates[i]); TAILQ_INIT(&peer->withdraws[i]); } - RB_INIT(&peer->up_prefix); - RB_INIT(&peer->up_attrs); + RBT_INIT(uptree_prefix, &peer->up_prefix); + RBT_INIT(uptree_attr, &peer->up_attrs); peer->up_pcnt = 0; peer->up_acnt = 0; peer->up_nlricnt = 0; @@ -115,8 +116,8 @@ up_down(struct rde_peer *peer) for (i = 0; i < AID_MAX; i++) up_clear(&peer->updates[i], &peer->withdraws[i]); - RB_INIT(&peer->up_prefix); - RB_INIT(&peer->up_attrs); + RBT_INIT(uptree_prefix, &peer->up_prefix); + RBT_INIT(uptree_attr, &peer->up_attrs); peer->up_pcnt = 0; peer->up_acnt = 0; @@ -125,7 +126,7 @@ up_down(struct rde_peer *peer) } int -up_prefix_cmp(struct update_prefix *a, struct update_prefix *b) +up_prefix_cmp(const struct update_prefix *a, const struct update_prefix *b) { int i; @@ -179,7 +180,7 @@ up_prefix_cmp(struct update_prefix *a, s } int -up_attr_cmp(struct update_attr *a, struct update_attr *b) +up_attr_cmp(const struct update_attr *a, const struct update_attr *b) { int r; @@ -206,11 +207,11 @@ up_add(struct rde_peer *peer, struct upd wdl = &peer->withdraws[p->prefix.aid]; /* 1. search for attr */ - if (a != NULL && (na = RB_FIND(uptree_attr, &peer->up_attrs, a)) == + if (a != NULL && (na = RBT_FIND(uptree_attr, &peer->up_attrs, a)) == NULL) { /* 1.1 if not found -> add */ TAILQ_INIT(&a->prefix_h); - if (RB_INSERT(uptree_attr, &peer->up_attrs, a) != NULL) { + if (RBT_INSERT(uptree_attr, &peer->up_attrs, a) != NULL) { log_warnx("uptree_attr insert failed"); /* cleanup */ free(a->attr); @@ -235,9 +236,9 @@ up_add(struct rde_peer *peer, struct upd } /* 2. search for prefix */ - if ((np = RB_FIND(uptree_prefix, &peer->up_prefix, p)) == NULL) { + if ((np = RBT_FIND(uptree_prefix, &peer->up_prefix, p)) == NULL) { /* 2.1 if not found -> add */ - if (RB_INSERT(uptree_prefix, &peer->up_prefix, p) != NULL) { + if (RBT_INSERT(uptree_prefix, &peer->up_prefix, p) != NULL) { log_warnx("uptree_prefix insert failed"); /* * cleanup. But do not free a because it is already @@ -510,10 +511,10 @@ up_generate_marker(struct rde_peer *peer upl = &peer->updates[aid]; /* 1. search for attr */ - if ((na = RB_FIND(uptree_attr, &peer->up_attrs, ua)) == NULL) { + if ((na = RBT_FIND(uptree_attr, &peer->up_attrs, ua)) == NULL) { /* 1.1 if not found -> add */ TAILQ_INIT(&ua->prefix_h); - if (RB_INSERT(uptree_attr, &peer->up_attrs, ua) != NULL) { + if (RBT_INSERT(uptree_attr, &peer->up_attrs, ua) != NULL) { log_warnx("uptree_attr insert failed"); /* cleanup */ free(ua); @@ -961,7 +962,7 @@ up_dump_prefix(u_char *buf, int len, str &upp->prefix, upp->prefixlen)) == -1) break; wpos += r; - if (RB_REMOVE(uptree_prefix, &peer->up_prefix, upp) == NULL) + if (RBT_REMOVE(uptree_prefix, &peer->up_prefix, upp) == NULL) log_warnx("dequeuing update failed."); TAILQ_REMOVE(upp->prefix_h, upp, prefix_l); peer->up_pcnt--; @@ -993,7 +994,7 @@ up_dump_attrnlri(u_char *buf, int len, s while ((upa = TAILQ_FIRST(&peer->updates[AID_INET])) != NULL) if (TAILQ_EMPTY(&upa->prefix_h)) { attr_len = upa->attr_len; - if (RB_REMOVE(uptree_attr, &peer->up_attrs, + if (RBT_REMOVE(uptree_attr, &peer->up_attrs, upa) == NULL) log_warnx("dequeuing update failed."); TAILQ_REMOVE(&peer->updates[AID_INET], upa, attr_l); @@ -1033,7 +1034,7 @@ up_dump_attrnlri(u_char *buf, int len, s /* now check if all prefixes were written */ if (TAILQ_EMPTY(&upa->prefix_h)) { - if (RB_REMOVE(uptree_attr, &peer->up_attrs, upa) == NULL) + if (RBT_REMOVE(uptree_attr, &peer->up_attrs, upa) == NULL) log_warnx("dequeuing update failed."); TAILQ_REMOVE(&peer->updates[AID_INET], upa, attr_l); free(upa->attr); @@ -1129,7 +1130,7 @@ up_dump_mp_reach(u_char *buf, u_int16_t while ((upa = TAILQ_FIRST(&peer->updates[aid])) != NULL) if (TAILQ_EMPTY(&upa->prefix_h)) { attr_len = upa->attr_len; - if (RB_REMOVE(uptree_attr, &peer->up_attrs, + if (RBT_REMOVE(uptree_attr, &peer->up_attrs, upa) == NULL) log_warnx("dequeuing update failed."); TAILQ_REMOVE(&peer->updates[aid], upa, attr_l); @@ -1196,7 +1197,7 @@ up_dump_mp_reach(u_char *buf, u_int16_t /* now check if all prefixes were written */ if (TAILQ_EMPTY(&upa->prefix_h)) { - if (RB_REMOVE(uptree_attr, &peer->up_attrs, upa) == NULL) + if (RBT_REMOVE(uptree_attr, &peer->up_attrs, upa) == NULL) log_warnx("dequeuing update failed."); TAILQ_REMOVE(&peer->updates[aid], upa, attr_l); free(upa->attr); Index: usr.sbin/dvmrpd/dvmrpd.h =================================================================== RCS file: /cvs/src/usr.sbin/dvmrpd/dvmrpd.h,v retrieving revision 1.22 diff -u -p -r1.22 dvmrpd.h --- usr.sbin/dvmrpd/dvmrpd.h 2 Sep 2016 16:20:34 -0000 1.22 +++ usr.sbin/dvmrpd/dvmrpd.h 21 Jun 2017 00:00:38 -0000 @@ -176,7 +176,7 @@ struct nbr_msg { }; TAILQ_HEAD(rr_head, rr_entry); -RB_HEAD(src_head, src_node); +RBT_HEAD(src_head, src_node); struct iface { LIST_ENTRY(iface) entry; Index: usr.sbin/dvmrpd/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/dvmrpd/kroute.c,v retrieving revision 1.13 diff -u -p -r1.13 kroute.c --- usr.sbin/dvmrpd/kroute.c 7 Dec 2015 19:14:49 -0000 1.13 +++ usr.sbin/dvmrpd/kroute.c 21 Jun 2017 00:00:38 -0000 @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -46,11 +47,11 @@ struct { } kr_state; struct kif_node { - RB_ENTRY(kif_node) entry; + RBT_ENTRY(kif_node) entry; struct kif k; }; -int kif_compare(struct kif_node *, struct kif_node *); +int kif_compare(const struct kif_node *, const struct kif_node *); struct kif_node *kif_find(int); int kif_insert(struct kif_node *); @@ -64,14 +65,14 @@ void if_announce(void *); int fetchifs(int); -RB_HEAD(kif_tree, kif_node) kit; -RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) -RB_GENERATE(kif_tree, kif_node, entry, kif_compare) +RBT_HEAD(kif_tree, kif_node) kit; +RBT_PROTOTYPE(kif_tree, kif_node, entry, kif_compare); +RBT_GENERATE(kif_tree, kif_node, entry, kif_compare); int kif_init(void) { - RB_INIT(&kit); + RBT_INIT(kif_tree, &kit); if (fetchifs(0) == -1) return (-1); @@ -116,7 +117,7 @@ kr_ifinfo(char *ifname) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (!strcmp(ifname, kif->k.ifname)) { main_imsg_compose_dvmrpe(IMSG_CTL_IFINFO, 0, &kif->k, sizeof(kif->k)); @@ -126,7 +127,7 @@ kr_ifinfo(char *ifname) /* rb-tree compare */ int -kif_compare(struct kif_node *a, struct kif_node *b) +kif_compare(const struct kif_node *a, const struct kif_node *b) { return (b->k.ifindex - a->k.ifindex); } @@ -139,7 +140,7 @@ kif_find(int ifindex) memset(&s, 0, sizeof(s)); s.k.ifindex = ifindex; - return (RB_FIND(kif_tree, &kit, &s)); + return (RBT_FIND(kif_tree, &kit, &s)); } struct kif * @@ -147,7 +148,7 @@ kif_findname(char *ifname) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (!strcmp(ifname, kif->k.ifname)) return (&kif->k); @@ -157,8 +158,8 @@ kif_findname(char *ifname) int kif_insert(struct kif_node *kif) { - if (RB_INSERT(kif_tree, &kit, kif) != NULL) { - log_warnx("RB_INSERT(kif_tree, &kit, kif)"); + if (RBT_INSERT(kif_tree, &kit, kif) != NULL) { + log_warnx("RBT_INSERT(kif_tree, &kit, kif)"); free(kif); return (-1); } @@ -169,8 +170,8 @@ kif_insert(struct kif_node *kif) int kif_remove(struct kif_node *kif) { - if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { - log_warnx("RB_REMOVE(kif_tree, &kit, kif)"); + if (RBT_REMOVE(kif_tree, &kit, kif) == NULL) { + log_warnx("RBT_REMOVE(kif_tree, &kit, kif)"); return (-1); } @@ -183,7 +184,7 @@ kif_clear(void) { struct kif_node *kif; - while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + while ((kif = RBT_MIN(kif_tree, &kit)) != NULL) kif_remove(kif); } Index: usr.sbin/dvmrpd/rde.h =================================================================== RCS file: /cvs/src/usr.sbin/dvmrpd/rde.h,v retrieving revision 1.16 diff -u -p -r1.16 rde.h --- usr.sbin/dvmrpd/rde.h 6 Sep 2009 09:52:14 -0000 1.16 +++ usr.sbin/dvmrpd/rde.h 21 Jun 2017 00:00:38 -0000 @@ -32,7 +32,7 @@ struct adv_rtr { }; struct rt_node { - RB_ENTRY(rt_node) entry; + RBT_ENTRY(rt_node) entry; struct event expiration_timer; struct event holddown_timer; @@ -68,7 +68,7 @@ struct prune_node { }; struct mfc_node { - RB_ENTRY(mfc_node) entry; + RBT_ENTRY(mfc_node) entry; struct event expiration_timer; struct event prune_timer; @@ -99,7 +99,6 @@ void rde_group_list_remove(struct iface /* rde_mfc.c */ void mfc_init(void); -int mfc_compare(struct mfc_node *, struct mfc_node *); struct mfc_node *mfc_find(in_addr_t, in_addr_t); int mfc_insert(struct mfc_node *); int mfc_remove(struct mfc_node *); @@ -114,7 +113,7 @@ void mfc_recv_prune(struct prune *); /* rde_srt.c */ void rt_init(void); -int rt_compare(struct rt_node *, struct rt_node *); +int rt_compare(const struct rt_node *, const struct rt_node *); struct rt_node *rt_find(in_addr_t, u_int8_t); struct rt_node *rr_new_rt(struct route_report *, u_int32_t, int); int rt_insert(struct rt_node *); @@ -126,12 +125,9 @@ void rt_dump(pid_t); struct rt_node *rt_match_origin(in_addr_t); int srt_check_route(struct route_report *, int); -int src_compare(struct src_node *, struct src_node *); struct ds_nbr *srt_find_ds(struct rt_node *, u_int32_t); void srt_expire_nbr(struct in_addr, unsigned int); void srt_check_downstream_ifaces(struct rt_node *, struct iface *); - -RB_PROTOTYPE(src_head, src_node, entry, src_compare); #endif /* _RDE_H_ */ Index: usr.sbin/dvmrpd/rde_mfc.c =================================================================== RCS file: /cvs/src/usr.sbin/dvmrpd/rde_mfc.c,v retrieving revision 1.10 diff -u -p -r1.10 rde_mfc.c --- usr.sbin/dvmrpd/rde_mfc.c 7 Dec 2015 19:14:49 -0000 1.10 +++ usr.sbin/dvmrpd/rde_mfc.c 21 Jun 2017 00:00:38 -0000 @@ -24,6 +24,7 @@ #include #include #include +#include #include #include "igmp.h" @@ -53,12 +54,12 @@ void mfc_prune_timer(int, short, void * int mfc_start_prune_timer(struct mfc_node *); int mfc_reset_prune_timer(struct mfc_node *); -int mfc_compare(struct mfc_node *, struct mfc_node *); +int mfc_compare(const struct mfc_node *, const struct mfc_node *); void mfc_invalidate(void); -RB_HEAD(mfc_tree, mfc_node) mfc; -RB_PROTOTYPE(mfc_tree, mfc_node, entry, mfc_compare) -RB_GENERATE(mfc_tree, mfc_node, entry, mfc_compare) +RBT_HEAD(mfc_tree, mfc_node) mfc; +RBT_PROTOTYPE(mfc_tree, mfc_node, entry, mfc_compare); +RBT_GENERATE(mfc_tree, mfc_node, entry, mfc_compare); extern struct dvmrpd_conf *rdeconf; @@ -138,11 +139,11 @@ mfc_reset_prune_timer(struct mfc_node *m void mfc_init(void) { - RB_INIT(&mfc); + RBT_INIT(mfc_tree, &mfc); } int -mfc_compare(struct mfc_node *a, struct mfc_node *b) +mfc_compare(const struct mfc_node *a, const struct mfc_node *b) { if (ntohl(a->origin.s_addr) < ntohl(b->origin.s_addr)) return (-1); @@ -163,13 +164,13 @@ mfc_find(in_addr_t origin, in_addr_t gro s.origin.s_addr = origin; s.group.s_addr = group; - return (RB_FIND(mfc_tree, &mfc, &s)); + return (RBT_FIND(mfc_tree, &mfc, &s)); } int mfc_insert(struct mfc_node *m) { - if (RB_INSERT(mfc_tree, &mfc, m) != NULL) { + if (RBT_INSERT(mfc_tree, &mfc, m) != NULL) { log_warnx("mfc_insert failed for group %s", inet_ntoa(m->group)); free(m); @@ -182,7 +183,7 @@ mfc_insert(struct mfc_node *m) int mfc_remove(struct mfc_node *m) { - if (RB_REMOVE(mfc_tree, &mfc, m) == NULL) { + if (RBT_REMOVE(mfc_tree, &mfc, m) == NULL) { log_warnx("mfc_remove failed for group %s", inet_ntoa(m->group)); return (-1); @@ -197,7 +198,7 @@ mfc_clear(void) { struct mfc_node *m; - while ((m = RB_MIN(mfc_tree, &mfc)) != NULL) + while ((m = RBT_MIN(mfc_tree, &mfc)) != NULL) mfc_remove(m); } @@ -212,7 +213,7 @@ mfc_dump(pid_t pid) clock_gettime(CLOCK_MONOTONIC, &now); - RB_FOREACH(mn, mfc_tree, &mfc) { + RBT_FOREACH(mn, mfc_tree, &mfc) { mfcctl.origin.s_addr = mn->origin.s_addr; mfcctl.group.s_addr = mn->group.s_addr; mfcctl.uptime = now.tv_sec - mn->uptime; @@ -239,7 +240,7 @@ mfc_find_origin(struct in_addr group) { struct mfc_node *mn; - RB_FOREACH(mn, mfc_tree, &mfc) + RBT_FOREACH(mn, mfc_tree, &mfc) if (group.s_addr == mn->group.s_addr) return (rt_match_origin(mn->origin.s_addr)); @@ -273,7 +274,7 @@ mfc_update_source(struct rt_node *rn) int i; u_int8_t found; - RB_FOREACH(mn, mfc_tree, &mfc) { + RBT_FOREACH(mn, mfc_tree, &mfc) { if (rn->prefix.s_addr == (mn->origin.s_addr & htonl(prefixlen2mask(rn->prefixlen)))) { mn->ifindex = rn->ifindex; @@ -370,7 +371,7 @@ mfc_check_members(struct rt_node *rn, st { struct mfc_node *mn; - RB_FOREACH(mn, mfc_tree, &mfc) { + RBT_FOREACH(mn, mfc_tree, &mfc) { if (mn->origin.s_addr == rn->prefix.s_addr) { if (rde_group_list_find(iface, mn->group) != 0) return (1); Index: usr.sbin/dvmrpd/rde_srt.c =================================================================== RCS file: /cvs/src/usr.sbin/dvmrpd/rde_srt.c,v retrieving revision 1.26 diff -u -p -r1.26 rde_srt.c --- usr.sbin/dvmrpd/rde_srt.c 22 May 2015 01:30:27 -0000 1.26 +++ usr.sbin/dvmrpd/rde_srt.c 21 Jun 2017 00:00:38 -0000 @@ -24,6 +24,7 @@ #include #include #include +#include #include #include "igmp.h" @@ -59,9 +60,9 @@ void srt_delete_ds(struct rt_node *, s void flash_update(struct rt_node *); void flash_update_ds(struct rt_node *); -RB_HEAD(rt_tree, rt_node) rt; -RB_PROTOTYPE(rt_tree, rt_node, entry, rt_compare) -RB_GENERATE(rt_tree, rt_node, entry, rt_compare) +RBT_HEAD(rt_tree, rt_node) rt; +RBT_PROTOTYPE(rt_tree, rt_node, entry, rt_compare); +RBT_GENERATE(rt_tree, rt_node, entry, rt_compare); extern struct dvmrpd_conf *rdeconf; @@ -129,11 +130,11 @@ rt_start_holddown_timer(struct rt_node * void rt_init(void) { - RB_INIT(&rt); + RBT_INIT(rt_tree, &rt); } int -rt_compare(struct rt_node *a, struct rt_node *b) +rt_compare(const struct rt_node *a, const struct rt_node *b) { /* * sort route entries based on prefixlen since generating route @@ -158,7 +159,7 @@ rt_find(in_addr_t prefix, u_int8_t prefi s.prefix.s_addr = prefix; s.prefixlen = prefixlen; - return (RB_FIND(rt_tree, &rt, &s)); + return (RBT_FIND(rt_tree, &rt, &s)); } struct rt_node * @@ -204,7 +205,7 @@ rt_insert(struct rt_node *r) log_debug("rt_insert: inserting route %s/%d", inet_ntoa(r->prefix), r->prefixlen); - if (RB_INSERT(rt_tree, &rt, r) != NULL) { + if (RBT_INSERT(rt_tree, &rt, r) != NULL) { log_warnx("rt_insert failed for %s/%u", inet_ntoa(r->prefix), r->prefixlen); free(r); @@ -219,7 +220,7 @@ rt_remove(struct rt_node *r) { struct ds_nbr *ds_nbr; - if (RB_REMOVE(rt_tree, &rt, r) == NULL) { + if (RBT_REMOVE(rt_tree, &rt, r) == NULL) { log_warnx("rt_remove failed for %s/%u", inet_ntoa(r->prefix), r->prefixlen); return (-1); @@ -239,8 +240,8 @@ rt_invalidate(void) { struct rt_node *r, *nr; - for (r = RB_MIN(rt_tree, &rt); r != NULL; r = nr) { - nr = RB_NEXT(rt_tree, &rt, r); + for (r = RBT_MIN(rt_tree, &rt); r != NULL; r = nr) { + nr = RBT_NEXT(rt_tree, r); if (r->invalid) rt_remove(r); else @@ -253,7 +254,7 @@ rt_clear(void) { struct rt_node *r; - while ((r = RB_MIN(rt_tree, &rt)) != NULL) + while ((r = RBT_MIN(rt_tree, &rt)) != NULL) rt_remove(r); } @@ -263,7 +264,7 @@ rt_snap(u_int32_t peerid) struct rt_node *r; struct route_report rr; - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { if (r->invalid) continue; @@ -286,7 +287,7 @@ rt_dump(pid_t pid) clock_gettime(CLOCK_MONOTONIC, &now); - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { if (r->invalid) continue; @@ -321,7 +322,7 @@ rt_match_origin(in_addr_t src) { struct rt_node *r; - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { if (r->prefix.s_addr == (src & htonl(prefixlen2mask(r->prefixlen)))) return (r); @@ -580,7 +581,7 @@ srt_expire_nbr(struct in_addr addr, unsi if (iface == NULL) fatal("srt_expire_nbr: interface not found"); - RB_FOREACH(rn, rt_tree, &rt) { + RBT_FOREACH(rn, rt_tree, &rt) { if (rn->adv_rtr[ifindex].addr.s_addr == addr.s_addr) { rn->adv_rtr[ifindex].addr.s_addr = iface->addr.s_addr; Index: usr.sbin/eigrpd/eigrpd.h =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/eigrpd.h,v retrieving revision 1.23 diff -u -p -r1.23 eigrpd.h --- usr.sbin/eigrpd/eigrpd.h 22 Feb 2017 14:24:50 -0000 1.23 +++ usr.sbin/eigrpd/eigrpd.h 21 Jun 2017 00:00:38 -0000 @@ -126,14 +126,14 @@ enum imsg_type { /* forward declarations */ struct eigrp_iface; -RB_HEAD(iface_id_head, eigrp_iface); +RBT_HEAD(iface_id_head, eigrp_iface); struct nbr; -RB_HEAD(nbr_addr_head, nbr); -RB_HEAD(nbr_pid_head, nbr); +RBT_HEAD(nbr_addr_head, nbr); +RBT_HEAD(nbr_pid_head, nbr); struct rde_nbr; -RB_HEAD(rde_nbr_head, rde_nbr); +RBT_HEAD(rde_nbr_head, rde_nbr); struct rt_node; -RB_HEAD(rt_tree, rt_node); +RBT_HEAD(rt_tree, rt_node); union eigrpd_addr { struct in_addr v4; @@ -211,7 +211,7 @@ struct summary_addr { }; struct eigrp_iface { - RB_ENTRY(eigrp_iface) id_tree; + RBT_ENTRY(eigrp_iface) id_tree; TAILQ_ENTRY(eigrp_iface) e_entry; TAILQ_ENTRY(eigrp_iface) i_entry; struct eigrp *eigrp; @@ -232,7 +232,7 @@ struct eigrp_iface { struct rinfo_head query_list; /* multicast queries */ TAILQ_HEAD(, summary_addr) summary_list; }; -RB_PROTOTYPE(iface_id_head, eigrp_iface, id_tree, iface_id_compare) +RBT_PROTOTYPE(iface_id_head, eigrp_iface, id_tree, iface_id_compare) #define INADDRSZ 4 #define IN6ADDRSZ 16 Index: usr.sbin/eigrpd/eigrpe.c =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/eigrpe.c,v retrieving revision 1.34 diff -u -p -r1.34 eigrpe.c --- usr.sbin/eigrpd/eigrpe.c 2 Sep 2016 17:59:58 -0000 1.34 +++ usr.sbin/eigrpd/eigrpe.c 21 Jun 2017 00:00:38 -0000 @@ -331,8 +331,8 @@ eigrpe_dispatch_main(int fd, short event SIMPLEQ_INIT(&neigrp->redist_list); TAILQ_INIT(&neigrp->ei_list); - RB_INIT(&neigrp->nbrs); - RB_INIT(&neigrp->topology); + RBT_INIT(rde_nbr_head, &neigrp->nbrs); + RBT_INIT(rt_tree, &neigrp->topology); TAILQ_INSERT_TAIL(&nconf->instances, neigrp, entry); break; case IMSG_RECONF_IFACE: @@ -364,10 +364,10 @@ eigrpe_dispatch_main(int fd, short event TAILQ_INIT(&nei->summary_list); TAILQ_INSERT_TAIL(&niface->ei_list, nei, i_entry); TAILQ_INSERT_TAIL(&neigrp->ei_list, nei, e_entry); - if (RB_INSERT(iface_id_head, &ifaces_by_id, nei) != + if (RBT_INSERT(iface_id_head, &ifaces_by_id, nei) != NULL) fatalx("eigrpe_dispatch_main: " - "RB_INSERT(ifaces_by_id) failed"); + "RBT_INSERT(ifaces_by_id) failed"); break; case IMSG_RECONF_END: merge_config(econf, nconf); @@ -664,7 +664,7 @@ eigrpe_nbr_ctl(struct ctl_conn *c) struct ctl_nbr *nctl; TAILQ_FOREACH(eigrp, &econf->instances, entry) { - RB_FOREACH(nbr, nbr_addr_head, &eigrp->nbrs) { + RBT_FOREACH(nbr, nbr_addr_head, &eigrp->nbrs) { if (nbr->flags & (F_EIGRP_NBR_PENDING|F_EIGRP_NBR_SELF)) continue; Index: usr.sbin/eigrpd/eigrpe.h =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/eigrpe.h,v retrieving revision 1.16 diff -u -p -r1.16 eigrpe.h --- usr.sbin/eigrpd/eigrpe.h 22 Feb 2017 14:24:50 -0000 1.16 +++ usr.sbin/eigrpd/eigrpe.h 21 Jun 2017 00:00:38 -0000 @@ -42,7 +42,7 @@ struct packet { }; struct nbr { - RB_ENTRY(nbr) addr_tree, pid_tree; + RBT_ENTRY(nbr) addr_tree, pid_tree; TAILQ_ENTRY(nbr) entry; struct event ev_ack; struct event ev_hello_timeout; @@ -65,8 +65,8 @@ struct nbr { uint32_t next_mcast_seq; TAILQ_HEAD(, packet) retrans_list; }; -RB_PROTOTYPE(nbr_addr_head, nbr, addr_tree, nbr_compare) -RB_PROTOTYPE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare) +RBT_PROTOTYPE(nbr_addr_head, nbr, addr_tree, nbr_compare) +RBT_PROTOTYPE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare) #define PREFIX_SIZE4(x) (((x - 1) / 8) + 1) #define PREFIX_SIZE6(x) ((x == 128) ? 16 : ((x / 8) + 1)) Index: usr.sbin/eigrpd/interface.c =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/interface.c,v retrieving revision 1.24 diff -u -p -r1.24 interface.c --- usr.sbin/eigrpd/interface.c 22 Feb 2017 14:24:50 -0000 1.24 +++ usr.sbin/eigrpd/interface.c 21 Jun 2017 00:00:38 -0000 @@ -25,6 +25,7 @@ #include #include +#include #include #include @@ -32,8 +33,8 @@ #include "eigrpe.h" #include "log.h" -static __inline int iface_id_compare(struct eigrp_iface *, - struct eigrp_iface *); +static __inline int iface_id_compare(const struct eigrp_iface *, + const struct eigrp_iface *); static struct iface *if_new(struct eigrpd_conf *, struct kif *); static void if_del(struct iface *); static struct if_addr *if_addr_lookup(struct if_addr_head *, struct kaddr *); @@ -47,12 +48,12 @@ static int if_leave_ipv4_group(struct static int if_join_ipv6_group(struct iface *, struct in6_addr *); static int if_leave_ipv6_group(struct iface *, struct in6_addr *); -RB_GENERATE(iface_id_head, eigrp_iface, id_tree, iface_id_compare) +RBT_GENERATE(iface_id_head, eigrp_iface, id_tree, iface_id_compare); -struct iface_id_head ifaces_by_id = RB_INITIALIZER(&ifaces_by_id); +struct iface_id_head ifaces_by_id = RBT_INITIALIZER(ifaces_by_id); static __inline int -iface_id_compare(struct eigrp_iface *a, struct eigrp_iface *b) +iface_id_compare(const struct eigrp_iface *a, const struct eigrp_iface *b) { return (a->ifaceid - b->ifaceid); } @@ -305,8 +306,8 @@ eigrp_if_new(struct eigrpd_conf *xconf, TAILQ_INIT(&ei->summary_list); TAILQ_INSERT_TAIL(&iface->ei_list, ei, i_entry); TAILQ_INSERT_TAIL(&eigrp->ei_list, ei, e_entry); - if (RB_INSERT(iface_id_head, &ifaces_by_id, ei) != NULL) - fatalx("eigrp_if_new: RB_INSERT(ifaces_by_id) failed"); + if (RBT_INSERT(iface_id_head, &ifaces_by_id, ei) != NULL) + fatalx("eigrp_if_new: RBT_INSERT(ifaces_by_id) failed"); return (ei); } @@ -316,7 +317,7 @@ eigrp_if_del(struct eigrp_iface *ei) { struct summary_addr *summary; - RB_REMOVE(iface_id_head, &ifaces_by_id, ei); + RBT_REMOVE(iface_id_head, &ifaces_by_id, ei); TAILQ_REMOVE(&ei->eigrp->ei_list, ei, e_entry); TAILQ_REMOVE(&ei->iface->ei_list, ei, i_entry); while ((summary = TAILQ_FIRST(&ei->summary_list)) != NULL) { @@ -353,7 +354,7 @@ eigrp_if_lookup_id(uint32_t ifaceid) { struct eigrp_iface e; e.ifaceid = ifaceid; - return (RB_FIND(iface_id_head, &ifaces_by_id, &e)); + return (RBT_FIND(iface_id_head, &ifaces_by_id, &e)); } static void Index: usr.sbin/eigrpd/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/kroute.c,v retrieving revision 1.17 diff -u -p -r1.17 kroute.c --- usr.sbin/eigrpd/kroute.c 22 Feb 2017 14:24:50 -0000 1.17 +++ usr.sbin/eigrpd/kroute.c 21 Jun 2017 00:00:38 -0000 @@ -29,6 +29,7 @@ #include #include #include +#include #include #include @@ -58,14 +59,14 @@ struct kroute_priority { }; struct kroute_prefix { - RB_ENTRY(kroute_prefix) entry; + RBT_ENTRY(kroute_prefix) entry; int af; union eigrpd_addr prefix; uint8_t prefixlen; TAILQ_HEAD(plist, kroute_priority) priorities; }; -RB_HEAD(kroute_tree, kroute_prefix); -RB_PROTOTYPE(kroute_tree, kroute_prefix, entry, kroute_compare) +RBT_HEAD(kroute_tree, kroute_prefix); +RBT_PROTOTYPE(kroute_tree, kroute_prefix, entry, kroute_compare) struct kif_addr { TAILQ_ENTRY(kif_addr) entry; @@ -73,19 +74,19 @@ struct kif_addr { }; struct kif_node { - RB_ENTRY(kif_node) entry; + RBT_ENTRY(kif_node) entry; TAILQ_HEAD(, kif_addr) addrs; struct kif k; }; -RB_HEAD(kif_tree, kif_node); -RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) +RBT_HEAD(kif_tree, kif_node); +RBT_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) static void kr_dispatch_msg(int, short, void *); static void kr_redist_remove(struct kroute *); static int kr_redist_eval(struct kroute *); static void kr_redistribute(struct kroute_prefix *); -static __inline int kroute_compare(struct kroute_prefix *, - struct kroute_prefix *); +static __inline int kroute_compare(const struct kroute_prefix *, + const struct kroute_prefix *); static struct kroute_prefix *kroute_find_prefix(int, union eigrpd_addr *, uint8_t); static struct kroute_priority *kroute_find_prio(struct kroute_prefix *, @@ -122,11 +123,11 @@ static int rtmsg_process(char *, size_ static int rtmsg_process_route(struct rt_msghdr *, struct sockaddr *[RTAX_MAX]); -RB_GENERATE(kroute_tree, kroute_prefix, entry, kroute_compare) -RB_GENERATE(kif_tree, kif_node, entry, kif_compare) +RBT_GENERATE(kroute_tree, kroute_prefix, entry, kroute_compare); +RBT_GENERATE(kif_tree, kif_node, entry, kif_compare); -static struct kroute_tree krt = RB_INITIALIZER(&krt); -static struct kif_tree kit = RB_INITIALIZER(&kit); +static struct kroute_tree krt = RBT_INITIALIZER(krt); +static struct kif_tree kit = RBT_INITIALIZER(kit); int kif_init(void) @@ -191,7 +192,7 @@ kif_redistribute(void) struct kif_node *kif; struct kif_addr *ka; - RB_FOREACH(kif, kif_tree, &kit) { + RBT_FOREACH(kif, kif_tree, &kit) { main_imsg_compose_eigrpe(IMSG_IFINFO, 0, &kif->k, sizeof(struct kif)); TAILQ_FOREACH(ka, &kif->addrs, entry) { @@ -283,7 +284,7 @@ kr_fib_couple(void) kr_state.fib_sync = 1; - RB_FOREACH(kp, kroute_tree, &krt) + RBT_FOREACH(kp, kroute_tree, &krt) TAILQ_FOREACH(kprio, &kp->priorities, entry) TAILQ_FOREACH(kn, &kprio->nexthops, entry) { if (!(kn->r.flags & F_EIGRPD_INSERTED)) @@ -304,7 +305,7 @@ kr_fib_decouple(void) if (kr_state.fib_sync == 0) /* already decoupled */ return; - RB_FOREACH(kp, kroute_tree, &krt) + RBT_FOREACH(kp, kroute_tree, &krt) TAILQ_FOREACH(kprio, &kp->priorities, entry) TAILQ_FOREACH(kn, &kprio->nexthops, entry) { if (!(kn->r.flags & F_EIGRPD_INSERTED)) @@ -340,7 +341,7 @@ kr_show_route(struct imsg *imsg) return; } memcpy(&flags, imsg->data, sizeof(flags)); - RB_FOREACH(kp, kroute_tree, &krt) + RBT_FOREACH(kp, kroute_tree, &krt) TAILQ_FOREACH(kprio, &kp->priorities, entry) TAILQ_FOREACH(kn, &kprio->nexthops, entry) { if (flags && !(kn->r.flags & flags)) @@ -362,7 +363,7 @@ kr_ifinfo(char *ifname, pid_t pid) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (ifname == NULL || !strcmp(ifname, kif->k.ifname)) { main_imsg_compose_eigrpe(IMSG_CTL_IFINFO, pid, &kif->k, sizeof(kif->k)); @@ -454,7 +455,7 @@ kr_redistribute(struct kroute_prefix *kp } static __inline int -kroute_compare(struct kroute_prefix *a, struct kroute_prefix *b) +kroute_compare(const struct kroute_prefix *a, const struct kroute_prefix *b) { int addrcmp; @@ -485,7 +486,7 @@ kroute_find_prefix(int af, union eigrpd_ s.prefix = *prefix; s.prefixlen = prefixlen; - return (RB_FIND(kroute_tree, &krt, &s)); + return (RBT_FIND(kroute_tree, &krt, &s)); } static struct kroute_priority * @@ -532,7 +533,7 @@ kroute_insert(struct kroute *kr) kp->prefix = kr->prefix; kp->prefixlen = kr->prefixlen; TAILQ_INIT(&kp->priorities); - RB_INSERT(kroute_tree, &krt, kp); + RBT_INSERT(kroute_tree, &krt, kp); } kprio = kroute_find_prio(kp, kr->priority); @@ -607,7 +608,7 @@ kroute_remove(struct kroute *kr) } if (TAILQ_EMPTY(&kp->priorities)) { - if (RB_REMOVE(kroute_tree, &krt, kp) == NULL) { + if (RBT_REMOVE(kroute_tree, &krt, kp) == NULL) { log_warnx("%s failed for %s/%u", __func__, log_addr(kr->af, &kr->prefix), kp->prefixlen); return (-1); @@ -631,7 +632,7 @@ kroute_clear(void) struct kroute_priority *kprio; struct kroute_node *kn; - while ((kp = RB_MIN(kroute_tree, &krt)) != NULL) { + while ((kp = RBT_MIN(kroute_tree, &krt)) != NULL) { while ((kprio = TAILQ_FIRST(&kp->priorities)) != NULL) { while ((kn = TAILQ_FIRST(&kprio->nexthops)) != NULL) { TAILQ_REMOVE(&kprio->nexthops, kn, entry); @@ -640,7 +641,7 @@ kroute_clear(void) TAILQ_REMOVE(&kp->priorities, kprio, entry); free(kprio); } - RB_REMOVE(kroute_tree, &krt, kp); + RBT_REMOVE(kroute_tree, &krt, kp); free(kp); } } @@ -660,7 +661,7 @@ kif_find(unsigned short ifindex) memset(&s, 0, sizeof(s)); s.k.ifindex = ifindex; - return (RB_FIND(kif_tree, &kit, &s)); + return (RBT_FIND(kif_tree, &kit, &s)); } struct kif * @@ -668,7 +669,7 @@ kif_findname(char *ifname) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (!strcmp(ifname, kif->k.ifname)) return (&kif->k); @@ -686,8 +687,8 @@ kif_insert(unsigned short ifindex) kif->k.ifindex = ifindex; TAILQ_INIT(&kif->addrs); - if (RB_INSERT(kif_tree, &kit, kif) != NULL) - fatalx("kif_insert: RB_INSERT"); + if (RBT_INSERT(kif_tree, &kit, kif) != NULL) + fatalx("kif_insert: RBT_INSERT"); return (kif); } @@ -697,7 +698,7 @@ kif_remove(struct kif_node *kif) { struct kif_addr *ka; - if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { + if (RBT_REMOVE(kif_tree, &kit, kif) == NULL) { log_warnx("%s failed for inteface %s", __func__, kif->k.ifname); return (-1); } @@ -715,7 +716,7 @@ kif_clear(void) { struct kif_node *kif; - while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + while ((kif = RBT_MIN(kif_tree, &kit)) != NULL) kif_remove(kif); } @@ -853,7 +854,7 @@ if_change(unsigned short ifindex, int fl main_imsg_compose_rde(IMSG_IFDOWN, 0, kif, sizeof(struct kif)); /* update redistribute list */ - RB_FOREACH(kp, kroute_tree, &krt) { + RBT_FOREACH(kp, kroute_tree, &krt) { TAILQ_FOREACH(kprio, &kp->priorities, entry) { TAILQ_FOREACH(kn, &kprio->nexthops, entry) { if (kn->r.ifindex != ifindex) Index: usr.sbin/eigrpd/neighbor.c =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/neighbor.c,v retrieving revision 1.10 diff -u -p -r1.10 neighbor.c --- usr.sbin/eigrpd/neighbor.c 2 Sep 2016 16:44:33 -0000 1.10 +++ usr.sbin/eigrpd/neighbor.c 21 Jun 2017 00:00:38 -0000 @@ -20,25 +20,27 @@ #include #include +#include #include "eigrpd.h" #include "eigrpe.h" #include "rde.h" #include "log.h" -static __inline int nbr_compare(struct nbr *, struct nbr *); -static __inline int nbr_pid_compare(struct nbr *, struct nbr *); +static __inline int nbr_compare(const struct nbr *, const struct nbr *); +static __inline int nbr_pid_compare(const struct nbr *, + const struct nbr *); static void nbr_update_peerid(struct nbr *); static void nbr_timeout(int, short, void *); static void nbr_stop_timeout(struct nbr *); -RB_GENERATE(nbr_addr_head, nbr, addr_tree, nbr_compare) -RB_GENERATE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare) +RBT_GENERATE(nbr_addr_head, nbr, addr_tree, nbr_compare); +RBT_GENERATE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare); -struct nbr_pid_head nbrs_by_pid = RB_INITIALIZER(&nbrs_by_pid); +struct nbr_pid_head nbrs_by_pid = RBT_INITIALIZER(nbrs_by_pid); static __inline int -nbr_compare(struct nbr *a, struct nbr *b) +nbr_compare(const struct nbr *a, const struct nbr *b) { if (a->ei->iface->ifindex < b->ei->iface->ifindex) return (-1); @@ -49,7 +51,7 @@ nbr_compare(struct nbr *a, struct nbr *b } static __inline int -nbr_pid_compare(struct nbr *a, struct nbr *b) +nbr_pid_compare(const struct nbr *a, const struct nbr *b) { return (a->peerid - b->peerid); } @@ -81,8 +83,8 @@ nbr_new(struct eigrp_iface *ei, union ei TAILQ_INIT(&nbr->reply_list); TAILQ_INIT(&nbr->retrans_list); - if (RB_INSERT(nbr_addr_head, &eigrp->nbrs, nbr) != NULL) - fatalx("nbr_new: RB_INSERT(eigrp->nbrs) failed"); + if (RBT_INSERT(nbr_addr_head, &eigrp->nbrs, nbr) != NULL) + fatalx("nbr_new: RBT_INSERT(eigrp->nbrs) failed"); /* timeout handling */ if (!self) { @@ -137,8 +139,8 @@ nbr_del(struct nbr *nbr) rtp_packet_del(pkt); if (nbr->peerid) - RB_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); - RB_REMOVE(nbr_addr_head, &eigrp->nbrs, nbr); + RBT_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); + RBT_REMOVE(nbr_addr_head, &eigrp->nbrs, nbr); TAILQ_REMOVE(&nbr->ei->nbr_list, nbr, entry); free(nbr); @@ -150,15 +152,15 @@ nbr_update_peerid(struct nbr *nbr) static uint32_t peercnt = NBR_CNTSTART; if (nbr->peerid) - RB_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); + RBT_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); /* get next unused peerid */ while (nbr_find_peerid(++peercnt)) ; nbr->peerid = peercnt; - if (RB_INSERT(nbr_pid_head, &nbrs_by_pid, nbr) != NULL) - fatalx("nbr_new: RB_INSERT(nbrs_by_pid) failed"); + if (RBT_INSERT(nbr_pid_head, &nbrs_by_pid, nbr) != NULL) + fatalx("nbr_new: RBT_INSERT(nbrs_by_pid) failed"); } struct nbr * @@ -175,7 +177,7 @@ nbr_find(struct eigrp_iface *ei, union e n.ei = &i; n.addr = *addr; - return (RB_FIND(nbr_addr_head, &ei->eigrp->nbrs, &n)); + return (RBT_FIND(nbr_addr_head, &ei->eigrp->nbrs, &n)); } struct nbr * @@ -183,7 +185,7 @@ nbr_find_peerid(uint32_t peerid) { struct nbr n; n.peerid = peerid; - return (RB_FIND(nbr_pid_head, &nbrs_by_pid, &n)); + return (RBT_FIND(nbr_pid_head, &nbrs_by_pid, &n)); } struct ctl_nbr * @@ -215,7 +217,7 @@ nbr_clear_ctl(struct ctl_nbr *nctl) if (nctl->as && nctl->as != eigrp->as) continue; - RB_FOREACH_SAFE(nbr, nbr_addr_head, &eigrp->nbrs, safe) { + RBT_FOREACH_SAFE(nbr, nbr_addr_head, &eigrp->nbrs, safe) { if (nbr->flags & (F_EIGRP_NBR_PENDING|F_EIGRP_NBR_SELF)) continue; if (eigrp_addrisset(nctl->af, &nctl->addr) && Index: usr.sbin/eigrpd/parse.y =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/parse.y,v retrieving revision 1.22 diff -u -p -r1.22 parse.y --- usr.sbin/eigrpd/parse.y 22 Feb 2017 14:24:50 -0000 1.22 +++ usr.sbin/eigrpd/parse.y 21 Jun 2017 00:00:38 -0000 @@ -39,6 +39,7 @@ #include "eigrpd.h" #include "eigrpe.h" +#include "rde.h" #include "log.h" struct file { @@ -1110,8 +1111,8 @@ conf_get_instance(uint16_t as) e->as = as; SIMPLEQ_INIT(&e->redist_list); TAILQ_INIT(&e->ei_list); - RB_INIT(&e->nbrs); - RB_INIT(&e->topology); + RBT_INIT(nbr_addr_head, &e->nbrs); + RBT_INIT(rt_tree, &e->topology); /* start local sequence number used by RTP */ e->seq_num = 1; @@ -1181,7 +1182,7 @@ clear_config(struct eigrpd_conf *xconf) } while ((i = TAILQ_FIRST(&e->ei_list)) != NULL) { - RB_REMOVE(iface_id_head, &ifaces_by_id, i); + RBT_REMOVE(iface_id_head, &ifaces_by_id, i); TAILQ_REMOVE(&e->ei_list, i, e_entry); TAILQ_REMOVE(&e->ei_list, i, i_entry); while ((s = TAILQ_FIRST(&i->summary_list)) != NULL) { Index: usr.sbin/eigrpd/rde.c =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/rde.c,v retrieving revision 1.23 diff -u -p -r1.23 rde.c --- usr.sbin/eigrpd/rde.c 2 Sep 2016 16:46:29 -0000 1.23 +++ usr.sbin/eigrpd/rde.c 21 Jun 2017 00:00:38 -0000 @@ -390,8 +390,8 @@ rde_dispatch_parent(int fd, short event, SIMPLEQ_INIT(&neigrp->redist_list); TAILQ_INIT(&neigrp->ei_list); - RB_INIT(&neigrp->nbrs); - RB_INIT(&neigrp->topology); + RBT_INIT(nbr_addr_head, &neigrp->nbrs); + RBT_INIT(rt_tree, &neigrp->topology); TAILQ_INSERT_TAIL(&nconf->instances, neigrp, entry); break; case IMSG_RECONF_IFACE: @@ -423,10 +423,10 @@ rde_dispatch_parent(int fd, short event, TAILQ_INIT(&nei->summary_list); TAILQ_INSERT_TAIL(&niface->ei_list, nei, i_entry); TAILQ_INSERT_TAIL(&neigrp->ei_list, nei, e_entry); - if (RB_INSERT(iface_id_head, &ifaces_by_id, nei) != + if (RBT_INSERT(iface_id_head, &ifaces_by_id, nei) != NULL) fatalx("rde_dispatch_parent: " - "RB_INSERT(ifaces_by_id) failed"); + "RBT_INSERT(ifaces_by_id) failed"); break; case IMSG_RECONF_END: merge_config(rdeconf, nconf); @@ -469,11 +469,11 @@ rde_instance_del(struct eigrp *eigrp) struct rt_node *rn; /* clear topology */ - while((rn = RB_MIN(rt_tree, &eigrp->topology)) != NULL) + while((rn = RBT_MIN(rt_tree, &eigrp->topology)) != NULL) rt_del(rn); /* clear nbrs */ - RB_FOREACH_SAFE(nbr, rde_nbr_head, &rde_nbrs, safe) + RBT_FOREACH_SAFE(nbr, rde_nbr_head, &rde_nbrs, safe) if (nbr->eigrp == eigrp) rde_nbr_del(nbr, 0); rde_nbr_del(eigrp->rnbr_redist, 0); @@ -722,7 +722,7 @@ rt_snap(struct rde_nbr *nbr) struct rt_node *rn; struct rinfo ri; - RB_FOREACH(rn, rt_tree, &eigrp->topology) + RBT_FOREACH(rn, rt_tree, &eigrp->topology) if (rn->state == DUAL_STA_PASSIVE && !rde_summary_check(nbr->ei, &rn->prefix, rn->prefixlen)) { rinfo_fill_successor(rn, &ri); @@ -787,7 +787,7 @@ rt_dump(struct ctl_show_topology_req *tr int first = 1; TAILQ_FOREACH(eigrp, &rdeconf->instances, entry) { - RB_FOREACH(rn, rt_tree, &eigrp->topology) { + RBT_FOREACH(rn, rt_tree, &eigrp->topology) { if (eigrp_addrisset(treq->af, &treq->prefix) && eigrp_addrcmp(treq->af, &treq->prefix, &rn->prefix)) Index: usr.sbin/eigrpd/rde.h =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/rde.h,v retrieving revision 1.12 diff -u -p -r1.12 rde.h --- usr.sbin/eigrpd/rde.h 2 Sep 2016 16:46:29 -0000 1.12 +++ usr.sbin/eigrpd/rde.h 21 Jun 2017 00:00:38 -0000 @@ -26,7 +26,7 @@ /* just the info RDE needs */ struct rde_nbr { - RB_ENTRY(rde_nbr) entry; + RBT_ENTRY(rde_nbr) entry; uint32_t peerid; uint32_t ifaceid; union eigrpd_addr addr; @@ -47,7 +47,7 @@ struct rde_nbr { #define F_RDE_NBR_REDIST 0x04 #define F_RDE_NBR_SUMMARY 0x08 }; -RB_PROTOTYPE(rde_nbr_head, rde_nbr, entry, rde_nbr_compare) +RBT_PROTOTYPE(rde_nbr_head, rde_nbr, entry, rde_nbr_compare); struct reply_node { TAILQ_ENTRY(reply_node) rn_entry; @@ -75,7 +75,7 @@ struct eigrp_route { #define F_EIGRP_ROUTE_M_CHANGED 0x02 struct rt_node { - RB_ENTRY(rt_node) entry; + RBT_ENTRY(rt_node) entry; struct eigrp *eigrp; union eigrpd_addr prefix; uint8_t prefixlen; @@ -92,7 +92,7 @@ struct rt_node { struct classic_emetric emetric; } successor; }; -RB_PROTOTYPE(rt_tree, rt_node, entry, rt_compare) +RBT_PROTOTYPE(rt_tree, rt_node, entry, rt_compare); /* DUAL states */ #define DUAL_STA_PASSIVE 0x0001 Index: usr.sbin/eigrpd/rde_dual.c =================================================================== RCS file: /cvs/src/usr.sbin/eigrpd/rde_dual.c,v retrieving revision 1.28 diff -u -p -r1.28 rde_dual.c --- usr.sbin/eigrpd/rde_dual.c 2 Sep 2016 16:44:33 -0000 1.28 +++ usr.sbin/eigrpd/rde_dual.c 21 Jun 2017 00:00:38 -0000 @@ -19,6 +19,7 @@ #include #include +#include #include #include "eigrpd.h" @@ -27,7 +28,8 @@ #include "log.h" static int dual_fsm(struct rt_node *, enum dual_event); -static __inline int rt_compare(struct rt_node *, struct rt_node *); +static __inline int rt_compare(const struct rt_node *, + const struct rt_node *); static struct rt_node *rt_find(struct eigrp *, struct rinfo *); static struct rt_node *rt_new(struct eigrp *, struct rinfo *); static struct eigrp_route *route_find(struct rde_nbr *, struct rt_node *); @@ -66,12 +68,13 @@ static void rde_send_query_all(struct int); static void rde_send_reply(struct rde_nbr *, struct rinfo *, int); static void rde_last_reply(struct rt_node *); -static __inline int rde_nbr_compare(struct rde_nbr *, struct rde_nbr *); +static __inline int rde_nbr_compare(const struct rde_nbr *, + const struct rde_nbr *); -RB_GENERATE(rt_tree, rt_node, entry, rt_compare) -RB_GENERATE(rde_nbr_head, rde_nbr, entry, rde_nbr_compare) +RBT_GENERATE(rt_tree, rt_node, entry, rt_compare); +RBT_GENERATE(rde_nbr_head, rde_nbr, entry, rde_nbr_compare); -struct rde_nbr_head rde_nbrs = RB_INITIALIZER(&rde_nbrs); +struct rde_nbr_head rde_nbrs = RBT_INITIALIZER(rde_nbrs); /* * NOTE: events that don't cause a state transition aren't triggered to avoid @@ -170,7 +173,7 @@ dual_fsm(struct rt_node *rn, enum dual_e } static __inline int -rt_compare(struct rt_node *a, struct rt_node *b) +rt_compare(const struct rt_node *a, const struct rt_node *b) { int addrcmp; @@ -195,7 +198,7 @@ rt_find(struct eigrp *eigrp, struct rinf rn.prefix = ri->prefix; rn.prefixlen = ri->prefixlen; - return (RB_FIND(rt_tree, &eigrp->topology, &rn)); + return (RBT_FIND(rt_tree, &eigrp->topology, &rn)); } static struct rt_node * @@ -214,7 +217,7 @@ rt_new(struct eigrp *eigrp, struct rinfo TAILQ_INIT(&rn->rijk); rt_set_successor(rn, NULL); - if (RB_INSERT(rt_tree, &eigrp->topology, rn) != NULL) { + if (RBT_INSERT(rt_tree, &eigrp->topology, rn) != NULL) { log_warnx("%s failed for %s", __func__, log_prefix(rn)); free(rn); return (NULL); @@ -237,7 +240,7 @@ rt_del(struct rt_node *rn) reply_outstanding_remove(reply); while ((route = TAILQ_FIRST(&rn->routes)) != NULL) route_del(rn, route); - RB_REMOVE(rt_tree, &rn->eigrp->topology, rn); + RBT_REMOVE(rt_tree, &rn->eigrp->topology, rn); free(rn); } @@ -824,7 +827,7 @@ rde_send_query_all(struct eigrp *eigrp, rde_send_query(ei, &ri, push); } - RB_FOREACH(nbr, rde_nbr_head, &rde_nbrs) + RBT_FOREACH(nbr, rde_nbr_head, &rde_nbrs) if (nbr->ei->eigrp == eigrp && !(nbr->flags & F_RDE_NBR_SELF)) { /* respect split-horizon configuration */ if (rn->successor.nbr && @@ -1238,7 +1241,7 @@ rde_check_link_down_nbr(struct rde_nbr * struct rt_node *rn, *safe; struct eigrp_route *route; - RB_FOREACH_SAFE(rn, rt_tree, &eigrp->topology, safe) { + RBT_FOREACH_SAFE(rn, rt_tree, &eigrp->topology, safe) { route = route_find(nbr, rn); if (route) { rde_check_link_down_rn(nbr, rn, route); @@ -1253,7 +1256,7 @@ rde_check_link_down(unsigned int ifindex { struct rde_nbr *nbr; - RB_FOREACH(nbr, rde_nbr_head, &rde_nbrs) + RBT_FOREACH(nbr, rde_nbr_head, &rde_nbrs) if (nbr->ei->iface->ifindex == ifindex) rde_check_link_down_nbr(nbr); @@ -1266,7 +1269,7 @@ rde_check_link_cost_change(struct rde_nb } static __inline int -rde_nbr_compare(struct rde_nbr *a, struct rde_nbr *b) +rde_nbr_compare(const struct rde_nbr *a, const struct rde_nbr *b) { return (a->peerid - b->peerid); } @@ -1278,7 +1281,7 @@ rde_nbr_find(uint32_t peerid) n.peerid = peerid; - return (RB_FIND(rde_nbr_head, &rde_nbrs, &n)); + return (RBT_FIND(rde_nbr_head, &rde_nbrs, &n)); } struct rde_nbr * @@ -1299,8 +1302,8 @@ rde_nbr_new(uint32_t peerid, struct rde_ nbr->flags = new->flags; if (nbr->peerid != NBR_IDSELF && - RB_INSERT(rde_nbr_head, &rde_nbrs, nbr) != NULL) - fatalx("rde_nbr_new: RB_INSERT failed"); + RBT_INSERT(rde_nbr_head, &rde_nbrs, nbr) != NULL) + fatalx("rde_nbr_new: RBT_INSERT failed"); return (nbr); } @@ -1318,6 +1321,6 @@ rde_nbr_del(struct rde_nbr *nbr, int pee reply_outstanding_remove(reply); if (nbr->peerid != NBR_IDSELF) - RB_REMOVE(rde_nbr_head, &rde_nbrs, nbr); + RBT_REMOVE(rde_nbr_head, &rde_nbrs, nbr); free(nbr); } Index: usr.sbin/hostapd/hostapd.c =================================================================== RCS file: /cvs/src/usr.sbin/hostapd/hostapd.c,v retrieving revision 1.38 diff -u -p -r1.38 hostapd.c --- usr.sbin/hostapd/hostapd.c 19 Apr 2017 05:36:13 -0000 1.38 +++ usr.sbin/hostapd/hostapd.c 21 Jun 2017 00:00:38 -0000 @@ -41,6 +41,7 @@ #include #include #include +#include #include #include #include @@ -53,8 +54,6 @@ void hostapd_usage(void); void hostapd_udp_init(struct hostapd_config *); void hostapd_sig_handler(int, short, void *); -static __inline int - hostapd_entry_cmp(struct hostapd_entry *, struct hostapd_entry *); struct hostapd_config hostapd_cfg; @@ -349,8 +348,8 @@ hostapd_cleanup(struct hostapd_config *c /* Cleanup tables */ while ((table = TAILQ_FIRST(&cfg->c_tables)) != NULL) { - while ((entry = RB_MIN(hostapd_tree, &table->t_tree)) != NULL) { - RB_REMOVE(hostapd_tree, &table->t_tree, entry); + while ((entry = RBT_MIN(hostapd_tree, &table->t_tree)) != NULL) { + RBT_REMOVE(hostapd_tree, &table->t_tree, entry); free(entry); } while ((entry = TAILQ_FIRST(&table->t_mask_head)) != NULL) { @@ -547,7 +546,7 @@ hostapd_table_add(struct hostapd_config free(table); return (NULL); } - RB_INIT(&table->t_tree); + RBT_INIT(hostapd_tree, &table->t_tree); TAILQ_INIT(&table->t_mask_head); TAILQ_INSERT_TAIL(&cfg->c_tables, table, t_entries); @@ -580,7 +579,7 @@ hostapd_entry_add(struct hostapd_table * return (NULL); bcopy(lladdr, entry->e_lladdr, IEEE80211_ADDR_LEN); - RB_INSERT(hostapd_tree, &table->t_tree, entry); + RBT_INSERT(hostapd_tree, &table->t_tree, entry); return (entry); } @@ -591,7 +590,7 @@ hostapd_entry_lookup(struct hostapd_tabl struct hostapd_entry *entry, key; bcopy(lladdr, key.e_lladdr, IEEE80211_ADDR_LEN); - if ((entry = RB_FIND(hostapd_tree, &table->t_tree, &key)) != NULL) + if ((entry = RBT_FIND(hostapd_tree, &table->t_tree, &key)) != NULL) return (entry); /* Masked entries can't be handled by the red-black tree */ @@ -606,21 +605,21 @@ hostapd_entry_lookup(struct hostapd_tabl void hostapd_entry_update(struct hostapd_table *table, struct hostapd_entry *entry) { - RB_REMOVE(hostapd_tree, &table->t_tree, entry); + RBT_REMOVE(hostapd_tree, &table->t_tree, entry); /* Apply mask to entry */ if (entry->e_flags & HOSTAPD_ENTRY_F_MASK) { HOSTAPD_ENTRY_MASK_ADD(entry->e_lladdr, entry->e_mask); TAILQ_INSERT_TAIL(&table->t_mask_head, entry, e_entries); } else { - RB_INSERT(hostapd_tree, &table->t_tree, entry); + RBT_INSERT(hostapd_tree, &table->t_tree, entry); } } static __inline int -hostapd_entry_cmp(struct hostapd_entry *a, struct hostapd_entry *b) +hostapd_entry_cmp(const struct hostapd_entry *a, const struct hostapd_entry *b) { return (memcmp(a->e_lladdr, b->e_lladdr, IEEE80211_ADDR_LEN)); } -RB_GENERATE(hostapd_tree, hostapd_entry, e_nodes, hostapd_entry_cmp); +RBT_GENERATE(hostapd_tree, hostapd_entry, e_nodes, hostapd_entry_cmp); Index: usr.sbin/hostapd/hostapd.h =================================================================== RCS file: /cvs/src/usr.sbin/hostapd/hostapd.h,v retrieving revision 1.21 diff -u -p -r1.21 hostapd.h --- usr.sbin/hostapd/hostapd.h 16 Jan 2015 06:40:17 -0000 1.21 +++ usr.sbin/hostapd/hostapd.h 21 Jun 2017 00:00:38 -0000 @@ -117,7 +117,7 @@ struct hostapd_entry { struct hostapd_inaddr a_inaddr; } e_addr; - RB_ENTRY(hostapd_entry) e_nodes; + RBT_ENTRY(hostapd_entry) e_nodes; TAILQ_ENTRY(hostapd_entry) e_entries; }; @@ -126,7 +126,7 @@ struct hostapd_entry { #define HOSTAPD_TABLE_NAMELEN 32 -RB_HEAD(hostapd_tree, hostapd_entry); +RBT_HEAD(hostapd_tree, hostapd_entry); struct hostapd_table { char t_name[HOSTAPD_TABLE_NAMELEN]; @@ -395,7 +395,7 @@ struct hostapd_entry *hostapd_entry_look void hostapd_entry_update(struct hostapd_table *, struct hostapd_entry *); -RB_PROTOTYPE(hostapd_tree, hostapd_entry, e_nodes, hostapd_entry_cmp); +RBT_PROTOTYPE(hostapd_tree, hostapd_entry, e_nodes, hostapd_entry_cmp); int hostapd_parse_file(struct hostapd_config *); int hostapd_parse_symset(char *); Index: usr.sbin/hostapd/roaming.c =================================================================== RCS file: /cvs/src/usr.sbin/hostapd/roaming.c,v retrieving revision 1.6 diff -u -p -r1.6 roaming.c --- usr.sbin/hostapd/roaming.c 16 Jan 2015 06:40:17 -0000 1.6 +++ usr.sbin/hostapd/roaming.c 21 Jun 2017 00:00:38 -0000 @@ -91,7 +91,7 @@ hostapd_roaming_term(struct hostapd_apme if (iapp->i_flags & HOSTAPD_IAPP_F_ROAMING_ROUTE && iapp->i_route_tbl != NULL) { - RB_FOREACH(entry, hostapd_tree, &iapp->i_route_tbl->t_tree) { + RBT_FOREACH(entry, hostapd_tree, &iapp->i_route_tbl->t_tree) { if ((entry->e_flags & HOSTAPD_ENTRY_F_INADDR) == 0) continue; (void)hostapd_roaming_rt(apme, &entry->e_inaddr, 0); @@ -100,7 +100,7 @@ hostapd_roaming_term(struct hostapd_apme if (iapp->i_flags & HOSTAPD_IAPP_F_ROAMING_ADDRESS && iapp->i_addr_tbl != NULL) { - RB_FOREACH(entry, hostapd_tree, &iapp->i_addr_tbl->t_tree) { + RBT_FOREACH(entry, hostapd_tree, &iapp->i_addr_tbl->t_tree) { if ((entry->e_flags & HOSTAPD_ENTRY_F_INADDR) == 0) continue; (void)hostapd_roaming_addr(apme, &entry->e_inaddr, 0); Index: usr.sbin/httpd/config.c =================================================================== RCS file: /cvs/src/usr.sbin/httpd/config.c,v retrieving revision 1.52 diff -u -p -r1.52 config.c --- usr.sbin/httpd/config.c 28 May 2017 10:37:26 -0000 1.52 +++ usr.sbin/httpd/config.c 21 Jun 2017 00:00:38 -0000 @@ -63,7 +63,7 @@ config_init(struct httpd *env) if ((env->sc_mediatypes = calloc(1, sizeof(*env->sc_mediatypes))) == NULL) return (-1); - RB_INIT(env->sc_mediatypes); + RBT_INIT(mediatypes, env->sc_mediatypes); } if (what & CONFIG_AUTH) { Index: usr.sbin/httpd/httpd.c =================================================================== RCS file: /cvs/src/usr.sbin/httpd/httpd.c,v retrieving revision 1.67 diff -u -p -r1.67 httpd.c --- usr.sbin/httpd/httpd.c 28 May 2017 10:37:26 -0000 1.67 +++ usr.sbin/httpd/httpd.c 21 Jun 2017 00:00:38 -0000 @@ -278,7 +278,7 @@ parent_configure(struct httpd *env) struct media_type *media; struct auth *auth; - RB_FOREACH(media, mediatypes, env->sc_mediatypes) { + RBT_FOREACH(media, mediatypes, env->sc_mediatypes) { if (config_setmedia(env, media) == -1) fatal("send media"); } @@ -1000,7 +1000,7 @@ kv_add(struct kvtree *keys, char *key, c } TAILQ_INIT(&kv->kv_children); - if ((oldkv = RB_INSERT(kvtree, keys, kv)) != NULL) { + if ((oldkv = RBT_INSERT(kvtree, keys, kv)) != NULL) { TAILQ_INSERT_TAIL(&oldkv->kv_children, kv, kv_entry); kv->kv_parent = oldkv; } @@ -1060,7 +1060,7 @@ kv_delete(struct kvtree *keys, struct kv { struct kv *ckv; - RB_REMOVE(kvtree, keys, kv); + RBT_REMOVE(kvtree, keys, kv); /* Remove all children */ while ((ckv = TAILQ_FIRST(&kv->kv_children)) != NULL) { @@ -1097,7 +1097,7 @@ kv_purge(struct kvtree *keys) { struct kv *kv; - while ((kv = RB_MIN(kvtree, keys)) != NULL) + while ((kv = RBT_MIN(kvtree, keys)) != NULL) kv_delete(keys, kv); } @@ -1164,32 +1164,32 @@ kv_find(struct kvtree *keys, struct kv * if (kv->kv_flags & KV_FLAG_GLOBBING) { /* Test header key using shell globbing rules */ key = kv->kv_key == NULL ? "" : kv->kv_key; - RB_FOREACH(match, kvtree, keys) { + RBT_FOREACH(match, kvtree, keys) { if (fnmatch(key, match->kv_key, FNM_CASEFOLD) == 0) break; } } else { /* Fast tree-based lookup only works without globbing */ - match = RB_FIND(kvtree, keys, kv); + match = RBT_FIND(kvtree, keys, kv); } return (match); } int -kv_cmp(struct kv *a, struct kv *b) +kv_cmp(const struct kv *a, const struct kv *b) { return (strcasecmp(a->kv_key, b->kv_key)); } -RB_GENERATE(kvtree, kv, kv_node, kv_cmp); +RBT_GENERATE(kvtree, kv, kv_node, kv_cmp); struct media_type * media_add(struct mediatypes *types, struct media_type *media) { struct media_type *entry; - if ((entry = RB_FIND(mediatypes, types, media)) != NULL) { + if ((entry = RBT_FIND(mediatypes, types, media)) != NULL) { log_debug("%s: duplicated entry for \"%s\"", __func__, media->media_name); return (NULL); @@ -1204,7 +1204,7 @@ media_add(struct mediatypes *types, stru free(entry); return (NULL); } - RB_INSERT(mediatypes, types, entry); + RBT_INSERT(mediatypes, types, entry); return (entry); } @@ -1212,7 +1212,7 @@ media_add(struct mediatypes *types, stru void media_delete(struct mediatypes *types, struct media_type *media) { - RB_REMOVE(mediatypes, types, media); + RBT_REMOVE(mediatypes, types, media); free(media->media_encoding); free(media); @@ -1223,7 +1223,7 @@ media_purge(struct mediatypes *types) { struct media_type *media; - while ((media = RB_MIN(mediatypes, types)) != NULL) + while ((media = RBT_MIN(mediatypes, types)) != NULL) media_delete(types, media); } @@ -1247,7 +1247,7 @@ media_find(struct mediatypes *types, con } /* Find media type by extension name */ - match = RB_FIND(mediatypes, types, &media); + match = RBT_FIND(mediatypes, types, &media); return (match); } @@ -1268,12 +1268,12 @@ media_find_config(struct httpd *env, str } int -media_cmp(struct media_type *a, struct media_type *b) +media_cmp(const struct media_type *a, const struct media_type *b) { return (strcasecmp(a->media_name, b->media_name)); } -RB_GENERATE(mediatypes, media_type, media_entry, media_cmp); +RBT_GENERATE(mediatypes, media_type, media_entry, media_cmp); struct auth * auth_add(struct serverauth *serverauth, struct auth *auth) Index: usr.sbin/httpd/httpd.h =================================================================== RCS file: /cvs/src/usr.sbin/httpd/httpd.h,v retrieving revision 1.132 diff -u -p -r1.132 httpd.h --- usr.sbin/httpd/httpd.h 28 May 2017 10:37:26 -0000 1.132 +++ usr.sbin/httpd/httpd.h 21 Jun 2017 00:00:38 -0000 @@ -126,7 +126,7 @@ enum key_type { }; TAILQ_HEAD(kvlist, kv); -RB_HEAD(kvtree, kv); +RBT_HEAD(kvtree, kv); struct kv { char *kv_key; @@ -142,7 +142,7 @@ struct kv { struct kv *kv_parent; TAILQ_ENTRY(kv) kv_entry; - RB_ENTRY(kv) kv_node; + RBT_ENTRY(kv) kv_node; }; struct portrange { @@ -438,9 +438,9 @@ struct media_type { char media_type[MEDIATYPE_TYPEMAX]; char media_subtype[MEDIATYPE_TYPEMAX]; char *media_encoding; - RB_ENTRY(media_type) media_entry; + RBT_ENTRY(media_type) media_entry; }; -RB_HEAD(mediatypes, media_type); +RBT_HEAD(mediatypes, media_type); struct auth { char auth_htpasswd[PATH_MAX]; @@ -701,7 +701,7 @@ void kv_free(struct kv *); struct kv *kv_inherit(struct kv *, struct kv *); int kv_log(struct evbuffer *, struct kv *); struct kv *kv_find(struct kvtree *, struct kv *); -int kv_cmp(struct kv *, struct kv *); +int kv_cmp(const struct kv *, const struct kv *); struct media_type *media_add(struct mediatypes *, struct media_type *); void media_delete(struct mediatypes *, struct media_type *); @@ -711,9 +711,10 @@ struct media_type * struct media_type * media_find_config(struct httpd *, struct server_config *, const char *); -int media_cmp(struct media_type *, struct media_type *); -RB_PROTOTYPE(kvtree, kv, kv_node, kv_cmp); -RB_PROTOTYPE(mediatypes, media_type, media_entry, media_cmp); +int media_cmp(const struct media_type *, + const struct media_type *); +RBT_PROTOTYPE(kvtree, kv, kv_node, kv_cmp); +RBT_PROTOTYPE(mediatypes, media_type, media_entry, media_cmp); struct auth *auth_add(struct serverauth *, struct auth *); struct auth *auth_byid(struct serverauth *, uint32_t); void auth_free(struct serverauth *, struct auth *); Index: usr.sbin/httpd/parse.y =================================================================== RCS file: /cvs/src/usr.sbin/httpd/parse.y,v retrieving revision 1.90 diff -u -p -r1.90 parse.y --- usr.sbin/httpd/parse.y 25 Mar 2017 17:25:34 -0000 1.90 +++ usr.sbin/httpd/parse.y 21 Jun 2017 00:00:38 -0000 @@ -1685,7 +1685,7 @@ load_config(const char *filename, struct errors++; } - if (RB_EMPTY(conf->sc_mediatypes)) { + if (RBT_EMPTY(mediatypes, conf->sc_mediatypes)) { /* Add default media types */ for (i = 0; mediatypes[i].media_name != NULL; i++) { (void)strlcpy(m.media_name, mediatypes[i].media_name, Index: usr.sbin/httpd/server_http.c =================================================================== RCS file: /cvs/src/usr.sbin/httpd/server_http.c,v retrieving revision 1.117 diff -u -p -r1.117 server_http.c --- usr.sbin/httpd/server_http.c 15 May 2017 10:40:47 -0000 1.117 +++ usr.sbin/httpd/server_http.c 21 Jun 2017 00:00:38 -0000 @@ -79,14 +79,14 @@ server_httpdesc_init(struct client *clt) if ((desc = calloc(1, sizeof(*desc))) == NULL) return (-1); - RB_INIT(&desc->http_headers); + RBT_INIT(kvtree, &desc->http_headers); clt->clt_descreq = desc; if ((desc = calloc(1, sizeof(*desc))) == NULL) { /* req will be cleaned up later */ return (-1); } - RB_INIT(&desc->http_headers); + RBT_INIT(kvtree, &desc->http_headers); clt->clt_descresp = desc; return (0); @@ -1493,7 +1493,7 @@ server_headers(struct client *clt, void struct kv *hdr, *kv; struct http_descriptor *desc = descp; - RB_FOREACH(hdr, kvtree, &desc->http_headers) { + RBT_FOREACH(hdr, kvtree, &desc->http_headers) { if ((hdr_cb)(clt, hdr, arg) == -1) return (-1); TAILQ_FOREACH(kv, &hdr->kv_children, kv_entry) { Index: usr.sbin/ldapd/btree.c =================================================================== RCS file: /cvs/src/usr.sbin/ldapd/btree.c,v retrieving revision 1.38 diff -u -p -r1.38 btree.c --- usr.sbin/ldapd/btree.c 26 May 2017 21:23:14 -0000 1.38 +++ usr.sbin/ldapd/btree.c 21 Jun 2017 00:00:38 -0000 @@ -123,7 +123,7 @@ struct btkey { }; struct mpage { /* an in-memory cached page */ - RB_ENTRY(mpage) entry; /* page cache entry */ + RBT_ENTRY(mpage) entry; /* page cache entry */ SIMPLEQ_ENTRY(mpage) next; /* queue of dirty pages */ TAILQ_ENTRY(mpage) lru_next; /* LRU queue */ struct mpage *parent; /* NULL if root */ @@ -134,11 +134,12 @@ struct mpage { /* an in-memory cache short ref; /* increased by cursors */ short dirty; /* 1 if on dirty queue */ }; -RB_HEAD(page_cache, mpage); +RBT_HEAD(page_cache, mpage); SIMPLEQ_HEAD(dirty_queue, mpage); TAILQ_HEAD(lru_queue, mpage); -static int mpage_cmp(struct mpage *a, struct mpage *b); +static int mpage_cmp(const struct mpage *a, + const struct mpage *b); static struct mpage *mpage_lookup(struct btree *bt, pgno_t pgno); static void mpage_add(struct btree *bt, struct mpage *mp); static void mpage_free(struct mpage *mp); @@ -149,8 +150,8 @@ static void mpage_prune(struct btree * static void mpage_dirty(struct btree *bt, struct mpage *mp); static struct mpage *mpage_touch(struct btree *bt, struct mpage *mp); -RB_PROTOTYPE(page_cache, mpage, entry, mpage_cmp); -RB_GENERATE(page_cache, mpage, entry, mpage_cmp); +RBT_PROTOTYPE(page_cache, mpage, entry, mpage_cmp); +RBT_GENERATE(page_cache, mpage, entry, mpage_cmp); struct ppage { /* ordered list of pages */ SLIST_ENTRY(ppage) entry; @@ -455,7 +456,7 @@ btval_reset(struct btval *btv) } static int -mpage_cmp(struct mpage *a, struct mpage *b) +mpage_cmp(const struct mpage *a, const struct mpage *b) { if (a->pgno > b->pgno) return 1; @@ -470,7 +471,7 @@ mpage_lookup(struct btree *bt, pgno_t pg struct mpage find, *mp; find.pgno = pgno; - mp = RB_FIND(page_cache, bt->page_cache, &find); + mp = RBT_FIND(page_cache, bt->page_cache, &find); if (mp) { bt->stat.hits++; /* Update LRU queue. Move page to the end. */ @@ -483,7 +484,7 @@ mpage_lookup(struct btree *bt, pgno_t pg static void mpage_add(struct btree *bt, struct mpage *mp) { - assert(RB_INSERT(page_cache, bt->page_cache, mp) == NULL); + assert(RBT_INSERT(page_cache, bt->page_cache, mp) == NULL); bt->stat.cache_size++; TAILQ_INSERT_TAIL(bt->lru_queue, mp, lru_next); } @@ -500,7 +501,7 @@ mpage_free(struct mpage *mp) static void mpage_del(struct btree *bt, struct mpage *mp) { - assert(RB_REMOVE(page_cache, bt->page_cache, mp) == mp); + assert(RBT_REMOVE(page_cache, bt->page_cache, mp) == mp); assert(bt->stat.cache_size > 0); bt->stat.cache_size--; TAILQ_REMOVE(bt->lru_queue, mp, lru_next); @@ -511,7 +512,7 @@ mpage_flush(struct btree *bt) { struct mpage *mp; - while ((mp = RB_MIN(page_cache, bt->page_cache)) != NULL) { + while ((mp = RBT_MIN(page_cache, bt->page_cache)) != NULL) { mpage_del(bt, mp); mpage_free(mp); } @@ -1100,7 +1101,7 @@ btree_open_fd(int fd, unsigned int flags if ((bt->page_cache = calloc(1, sizeof(*bt->page_cache))) == NULL) goto fail; bt->stat.max_cache = BT_MAXCACHE_DEF; - RB_INIT(bt->page_cache); + RBT_INIT(page_cache, bt->page_cache); if ((bt->lru_queue = calloc(1, sizeof(*bt->lru_queue))) == NULL) goto fail; Index: usr.sbin/ldapd/ldapd.h =================================================================== RCS file: /cvs/src/usr.sbin/ldapd/ldapd.h,v retrieving revision 1.28 diff -u -p -r1.28 ldapd.h --- usr.sbin/ldapd/ldapd.h 24 Feb 2017 14:28:31 -0000 1.28 +++ usr.sbin/ldapd/ldapd.h 21 Jun 2017 00:00:38 -0000 @@ -166,11 +166,11 @@ struct plan * all DNs sent to the client to make them unique. */ struct uniqdn { - RB_ENTRY(uniqdn) link; + RBT_ENTRY(uniqdn) link; struct btval key; }; -RB_HEAD(dn_tree, uniqdn); -RB_PROTOTYPE(dn_tree, uniqdn, link, uniqdn_cmp); +RBT_HEAD(dn_tree, uniqdn); +RBT_PROTOTYPE(dn_tree, uniqdn, link, uniqdn_cmp); /* An LDAP search request. */ Index: usr.sbin/ldapd/schema.c =================================================================== RCS file: /cvs/src/usr.sbin/ldapd/schema.c,v retrieving revision 1.17 diff -u -p -r1.17 schema.c --- usr.sbin/ldapd/schema.c 20 Jan 2017 11:55:08 -0000 1.17 +++ usr.sbin/ldapd/schema.c 21 Jun 2017 00:00:38 -0000 @@ -29,34 +29,34 @@ #define ERROR -1 #define STRING 1 -static int -attr_oid_cmp(struct attr_type *a, struct attr_type *b) +static inline int +attr_oid_cmp(const struct attr_type *a, const struct attr_type *b) { return strcasecmp(a->oid, b->oid); } -static int -obj_oid_cmp(struct object *a, struct object *b) +static inline int +obj_oid_cmp(const struct object *a, const struct object *b) { return strcasecmp(a->oid, b->oid); } -static int -oidname_cmp(struct oidname *a, struct oidname *b) +static inline int +oidname_cmp(const struct oidname *a, const struct oidname *b) { return strcasecmp(a->on_name, b->on_name); } -static int -symoid_cmp(struct symoid *a, struct symoid *b) +static inline int +symoid_cmp(const struct symoid *a, const struct symoid *b) { return strcasecmp(a->name, b->name); } -RB_GENERATE(attr_type_tree, attr_type, link, attr_oid_cmp); -RB_GENERATE(object_tree, object, link, obj_oid_cmp); -RB_GENERATE(oidname_tree, oidname, link, oidname_cmp); -RB_GENERATE(symoid_tree, symoid, link, symoid_cmp); +RBT_GENERATE(attr_type_tree, attr_type, link, attr_oid_cmp); +RBT_GENERATE(object_tree, object, link, obj_oid_cmp); +RBT_GENERATE(oidname_tree, oidname, link, oidname_cmp); +RBT_GENERATE(symoid_tree, symoid, link, symoid_cmp); static struct attr_list *push_attr(struct attr_list *alist, struct attr_type *a); static struct obj_list *push_obj(struct obj_list *olist, struct object *obj); @@ -69,7 +69,7 @@ lookup_attribute_by_name(struct schema * struct oidname *on, find; find.on_name = name; - on = RB_FIND(oidname_tree, &schema->attr_names, &find); + on = RBT_FIND(oidname_tree, &schema->attr_names, &find); if (on) return on->on_attr_type; @@ -82,7 +82,7 @@ lookup_attribute_by_oid(struct schema *s struct attr_type find; find.oid = oid; - return RB_FIND(attr_type_tree, &schema->attr_types, &find); + return RBT_FIND(attr_type_tree, &schema->attr_types, &find); } struct attr_type * @@ -99,7 +99,7 @@ lookup_object_by_oid(struct schema *sche struct object find; find.oid = oid; - return RB_FIND(object_tree, &schema->objects, &find); + return RBT_FIND(object_tree, &schema->objects, &find); } struct object * @@ -108,7 +108,7 @@ lookup_object_by_name(struct schema *sch struct oidname *on, find; find.on_name = name; - on = RB_FIND(oidname_tree, &schema->object_names, &find); + on = RBT_FIND(oidname_tree, &schema->object_names, &find); if (on) return on->on_object; @@ -149,7 +149,7 @@ lookup_symbolic_oid(struct schema *schem } find.name = name; - symoid = RB_FIND(symoid_tree, &schema->symbolic_oids, &find); + symoid = RBT_FIND(symoid_tree, &schema->symbolic_oids, &find); if (symoid == NULL) return NULL; @@ -180,7 +180,7 @@ push_symbolic_oid(struct schema *schema, struct symoid *symoid, find; find.name = name; - symoid = RB_FIND(symoid_tree, &schema->symbolic_oids, &find); + symoid = RBT_FIND(symoid_tree, &schema->symbolic_oids, &find); if (symoid == NULL) { symoid = calloc(1, sizeof(*symoid)); @@ -190,7 +190,7 @@ push_symbolic_oid(struct schema *schema, } symoid->name = name; - RB_INSERT(symoid_tree, &schema->symbolic_oids, symoid); + RBT_INSERT(symoid_tree, &schema->symbolic_oids, symoid); } free(symoid->oid); @@ -429,11 +429,11 @@ schema_new(void) if ((schema = calloc(1, sizeof(*schema))) == NULL) return NULL; - RB_INIT(&schema->attr_types); - RB_INIT(&schema->attr_names); - RB_INIT(&schema->objects); - RB_INIT(&schema->object_names); - RB_INIT(&schema->symbolic_oids); + RBT_INIT(attr_type_tree, &schema->attr_types); + RBT_INIT(oidname_tree, &schema->attr_names); + RBT_INIT(object_tree, &schema->objects); + RBT_INIT(oidname_tree, &schema->object_names); + RBT_INIT(symoid_tree, &schema->symbolic_oids); return schema; } @@ -466,7 +466,7 @@ schema_link_attr_name(struct schema *sch oidname->on_name = name; oidname->on_attr_type = attr; - prev = RB_INSERT(oidname_tree, &schema->attr_names, oidname); + prev = RBT_INSERT(oidname_tree, &schema->attr_names, oidname); if (prev != NULL) { schema_err(schema, "attribute type name '%s'" " already defined for oid %s", @@ -502,7 +502,7 @@ schema_link_obj_name(struct schema *sche oidname->on_name = name; oidname->on_object = obj; - prev = RB_INSERT(oidname_tree, &schema->object_names, oidname); + prev = RBT_INSERT(oidname_tree, &schema->object_names, oidname); if (prev != NULL) { schema_err(schema, "object class name '%s'" " already defined for oid %s", @@ -726,7 +726,7 @@ schema_parse_attributetype(struct schema } kw = NULL; - prev = RB_INSERT(attr_type_tree, &schema->attr_types, attr); + prev = RBT_INSERT(attr_type_tree, &schema->attr_types, attr); if (prev != NULL) { schema_err(schema, "attribute type %s already defined", attr->oid); goto fail; @@ -881,7 +881,7 @@ fail: free(kw); if (attr != NULL) { if (attr->oid != NULL) { - RB_REMOVE(attr_type_tree, &schema->attr_types, attr); + RBT_REMOVE(attr_type_tree, &schema->attr_types, attr); free(attr->oid); } free(attr->desc); @@ -921,7 +921,7 @@ schema_parse_objectclass(struct schema * } kw = NULL; - prev = RB_INSERT(object_tree, &schema->objects, obj); + prev = RBT_INSERT(object_tree, &schema->objects, obj); if (prev != NULL) { schema_err(schema, "object class %s already defined", obj->oid); goto fail; @@ -1015,7 +1015,7 @@ fail: free(kw); if (obj != NULL) { if (obj->oid != NULL) { - RB_REMOVE(object_tree, &schema->objects, obj); + RBT_REMOVE(object_tree, &schema->objects, obj); free(obj->oid); } free(obj->desc); Index: usr.sbin/ldapd/schema.h =================================================================== RCS file: /cvs/src/usr.sbin/ldapd/schema.h,v retrieving revision 1.7 diff -u -p -r1.7 schema.h --- usr.sbin/ldapd/schema.h 4 Nov 2010 15:35:00 -0000 1.7 +++ usr.sbin/ldapd/schema.h 21 Jun 2017 00:00:38 -0000 @@ -61,7 +61,7 @@ struct match_rule }; struct attr_type { - RB_ENTRY(attr_type) link; + RBT_ENTRY(attr_type) link; char *oid; struct name_list *names; char *desc; @@ -76,8 +76,8 @@ struct attr_type { int immutable; /* no-user-modification */ enum usage usage; }; -RB_HEAD(attr_type_tree, attr_type); -RB_PROTOTYPE(attr_type_tree, attr_type, link, attr_oid_cmp); +RBT_HEAD(attr_type_tree, attr_type); +RBT_PROTOTYPE(attr_type_tree, attr_type, link, attr_oid_cmp); struct attr_ptr { SLIST_ENTRY(attr_ptr) next; @@ -99,7 +99,7 @@ struct obj_ptr { SLIST_HEAD(obj_list, obj_ptr); struct object { - RB_ENTRY(object) link; + RBT_ENTRY(object) link; char *oid; struct name_list *names; char *desc; @@ -109,11 +109,11 @@ struct object { struct attr_list *must; struct attr_list *may; }; -RB_HEAD(object_tree, object); -RB_PROTOTYPE(object_tree, object, link, obj_oid_cmp); +RBT_HEAD(object_tree, object); +RBT_PROTOTYPE(object_tree, object, link, obj_oid_cmp); struct oidname { - RB_ENTRY(oidname) link; + RBT_ENTRY(oidname) link; const char *on_name; #define on_attr_type on_ptr.ou_attr_type #define on_object on_ptr.ou_object @@ -122,16 +122,16 @@ struct oidname { struct object *ou_object; } on_ptr; }; -RB_HEAD(oidname_tree, oidname); -RB_PROTOTYPE(oidname_tree, oidname, link, oidname_cmp); +RBT_HEAD(oidname_tree, oidname); +RBT_PROTOTYPE(oidname_tree, oidname, link, oidname_cmp); struct symoid { - RB_ENTRY(symoid) link; + RBT_ENTRY(symoid) link; char *name; /* symbolic name */ char *oid; }; -RB_HEAD(symoid_tree, symoid); -RB_PROTOTYPE(symoid_tree, symoid, link, symoid_cmp); +RBT_HEAD(symoid_tree, symoid); +RBT_PROTOTYPE(symoid_tree, symoid, link, symoid_cmp); #define SCHEMA_MAXPUSHBACK 128 Index: usr.sbin/ldapd/search.c =================================================================== RCS file: /cvs/src/usr.sbin/ldapd/search.c,v retrieving revision 1.18 diff -u -p -r1.18 search.c --- usr.sbin/ldapd/search.c 20 Jan 2017 11:55:08 -0000 1.18 +++ usr.sbin/ldapd/search.c 21 Jun 2017 00:00:38 -0000 @@ -37,8 +37,8 @@ static int search_result(const char *d struct ber_element *attrs, struct search *search); -static int -uniqdn_cmp(struct uniqdn *a, struct uniqdn *b) +static inline int +uniqdn_cmp(const struct uniqdn *a, const struct uniqdn *b) { if (a->key.size < b->key.size) return -1; @@ -47,7 +47,7 @@ uniqdn_cmp(struct uniqdn *a, struct uniq return memcmp(a->key.data, b->key.data, a->key.size); } -RB_GENERATE(dn_tree, uniqdn, link, uniqdn_cmp); +RBT_GENERATE(dn_tree, uniqdn, link, uniqdn_cmp); /* Return true if the attribute is operational. */ @@ -165,9 +165,9 @@ search_close(struct search *search) { struct uniqdn *dn, *next; - for (dn = RB_MIN(dn_tree, &search->uniqdns); dn; dn = next) { - next = RB_NEXT(dn_tree, &search->uniqdns, dn); - RB_REMOVE(dn_tree, &search->uniqdns, dn); + for (dn = RBT_MIN(dn_tree, &search->uniqdns); dn; dn = next) { + next = RBT_NEXT(dn_tree, dn); + RBT_REMOVE(dn_tree, &search->uniqdns, dn); free(dn->key.data); free(dn); } @@ -263,7 +263,7 @@ mk_dup(struct search *search, struct btv } bcopy(key->data, udn->key.data, key->size); udn->key.size = key->size; - RB_INSERT(dn_tree, &search->uniqdns, udn); + RBT_INSERT(dn_tree, &search->uniqdns, udn); return BT_SUCCESS; } @@ -275,7 +275,7 @@ is_dup(struct search *search, struct btv find.key.data = key->data; find.key.size = key->size; - return RB_FIND(dn_tree, &search->uniqdns, &find) != NULL; + return RBT_FIND(dn_tree, &search->uniqdns, &find) != NULL; } void @@ -566,7 +566,7 @@ ldap_search_subschema(struct search *sea key = ber_add_string(elm, "objectClasses"); val = ber_add_set(key); - RB_FOREACH(obj, object_tree, &conf->schema->objects) { + RBT_FOREACH(obj, object_tree, &conf->schema->objects) { if (schema_dump_object(obj, buf, sizeof(buf)) != 0) { rc = LDAP_OTHER; goto done; @@ -580,7 +580,7 @@ ldap_search_subschema(struct search *sea key = ber_add_string(elm, "attributeTypes"); val = ber_add_set(key); - RB_FOREACH(at, attr_type_tree, &conf->schema->attr_types) { + RBT_FOREACH(at, attr_type_tree, &conf->schema->attr_types) { if (schema_dump_attribute(at, buf, sizeof(buf)) != 0) { rc = LDAP_OTHER; goto done; @@ -858,7 +858,7 @@ ldap_search(struct request *req) search->init = 0; search->started_at = time(0); TAILQ_INSERT_HEAD(&req->conn->searches, search, next); - RB_INIT(&search->uniqdns); + RBT_INIT(dn_tree, &search->uniqdns); if (ber_scanf_elements(req->op, "{sEEiibeSeS", &search->basedn, Index: usr.sbin/ldpd/interface.c =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/interface.c,v retrieving revision 1.50 diff -u -p -r1.50 interface.c --- usr.sbin/ldpd/interface.c 3 Mar 2017 23:41:27 -0000 1.50 +++ usr.sbin/ldpd/interface.c 21 Jun 2017 00:00:38 -0000 @@ -168,7 +168,7 @@ if_addr_add(struct kaddr *ka) if_addr = if_addr_new(ka); LIST_INSERT_HEAD(&global.addr_list, if_addr, entry); - RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { + RBT_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { if (nbr->state != NBR_STA_OPER) continue; if (if_addr->af == AF_INET && !nbr->v4_enabled) @@ -216,7 +216,7 @@ if_addr_del(struct kaddr *ka) if_addr = if_addr_lookup(&global.addr_list, ka); if (if_addr) { - RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { + RBT_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { if (nbr->state != NBR_STA_OPER) continue; if (if_addr->af == AF_INET && !nbr->v4_enabled) Index: usr.sbin/ldpd/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/kroute.c,v retrieving revision 1.65 diff -u -p -r1.65 kroute.c --- usr.sbin/ldpd/kroute.c 4 Mar 2017 00:21:48 -0000 1.65 +++ usr.sbin/ldpd/kroute.c 21 Jun 2017 00:00:38 -0000 @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -61,14 +62,14 @@ struct kroute_priority { }; struct kroute_prefix { - RB_ENTRY(kroute_prefix) entry; + RBT_ENTRY(kroute_prefix) entry; int af; union ldpd_addr prefix; uint8_t prefixlen; TAILQ_HEAD(plist, kroute_priority) priorities; }; -RB_HEAD(kroute_tree, kroute_prefix); -RB_PROTOTYPE(kroute_tree, kroute_prefix, entry, kroute_compare) +RBT_HEAD(kroute_tree, kroute_prefix); +RBT_PROTOTYPE(kroute_tree, kroute_prefix, entry, kroute_compare); struct kif_addr { TAILQ_ENTRY(kif_addr) entry; @@ -76,20 +77,20 @@ struct kif_addr { }; struct kif_node { - RB_ENTRY(kif_node) entry; + RBT_ENTRY(kif_node) entry; TAILQ_HEAD(, kif_addr) addrs; struct kif k; struct kpw *kpw; }; -RB_HEAD(kif_tree, kif_node); -RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) +RBT_HEAD(kif_tree, kif_node); +RBT_PROTOTYPE(kif_tree, kif_node, entry, kif_compare); static void kr_dispatch_msg(int, short, void *); static void kr_redist_remove(struct kroute *); static int kr_redist_eval(struct kroute *); static void kr_redistribute(struct kroute_prefix *); -static __inline int kroute_compare(struct kroute_prefix *, - struct kroute_prefix *); +static __inline int kroute_compare(const struct kroute_prefix *, + const struct kroute_prefix *); static struct kroute_prefix *kroute_find_prefix(int, union ldpd_addr *, uint8_t); static struct kroute_priority *kroute_find_prio(struct kroute_prefix *, @@ -100,7 +101,8 @@ static int kroute_insert(struct kroute static int kroute_uninstall(struct kroute_node *); static int kroute_remove(struct kroute *); static void kroute_clear(void); -static __inline int kif_compare(struct kif_node *, struct kif_node *); +static __inline int kif_compare(const struct kif_node *, + const struct kif_node *); static struct kif_node *kif_find(unsigned short); static struct kif_node *kif_insert(unsigned short); static int kif_remove(struct kif_node *); @@ -129,11 +131,11 @@ static int rtmsg_process_route(struct static int kmpw_install(const char *, struct kpw *); static int kmpw_uninstall(const char *); -RB_GENERATE(kroute_tree, kroute_prefix, entry, kroute_compare) -RB_GENERATE(kif_tree, kif_node, entry, kif_compare) +RBT_GENERATE(kroute_tree, kroute_prefix, entry, kroute_compare); +RBT_GENERATE(kif_tree, kif_node, entry, kif_compare); -static struct kroute_tree krt = RB_INITIALIZER(&krt); -static struct kif_tree kit = RB_INITIALIZER(&kit); +static struct kroute_tree krt = RBT_INITIALIZER(krt); +static struct kif_tree kit = RBT_INITIALIZER(kit); int kif_init(void) @@ -213,7 +215,7 @@ kif_redistribute(const char *ifname) struct kif_node *kif; struct kif_addr *ka; - RB_FOREACH(kif, kif_tree, &kit) { + RBT_FOREACH(kif, kif_tree, &kit) { if (kif->k.rdomain != kr_state.rdomain) continue; @@ -332,7 +334,7 @@ kr_fib_couple(void) kr_state.fib_sync = 1; - RB_FOREACH(kp, kroute_tree, &krt) { + RBT_FOREACH(kp, kroute_tree, &krt) { kprio = TAILQ_FIRST(&kp->priorities); if (kprio == NULL) continue; @@ -351,7 +353,7 @@ kr_fib_couple(void) } } - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (kif->kpw) kmpw_install(kif->k.ifname, kif->kpw); @@ -370,7 +372,7 @@ kr_fib_decouple(void) if (kr_state.fib_sync == 0) /* already decoupled */ return; - RB_FOREACH(kp, kroute_tree, &krt) { + RBT_FOREACH(kp, kroute_tree, &krt) { kprio = TAILQ_FIRST(&kp->priorities); if (kprio == NULL) continue; @@ -393,7 +395,7 @@ kr_fib_decouple(void) } } - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (kif->kpw) kmpw_uninstall(kif->k.ifname); @@ -408,7 +410,7 @@ kr_change_egress_label(int af, int was_i struct kroute_priority *kprio; struct kroute_node *kn; - RB_FOREACH(kp, kroute_tree, &krt) { + RBT_FOREACH(kp, kroute_tree, &krt) { if (kp->af != af) continue; @@ -462,7 +464,7 @@ kr_show_route(struct imsg *imsg) } memcpy(&flags, imsg->data, sizeof(flags)); - RB_FOREACH(kp, kroute_tree, &krt) + RBT_FOREACH(kp, kroute_tree, &krt) TAILQ_FOREACH(kprio, &kp->priorities, entry) TAILQ_FOREACH(kn, &kprio->nexthops, entry) { if (flags && !(kn->r.flags & flags)) @@ -500,7 +502,7 @@ kr_ifinfo(char *ifname, pid_t pid) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (ifname == NULL || !strcmp(ifname, kif->k.ifname)) { main_imsg_compose_ldpe(IMSG_CTL_IFINFO, pid, &kif->k, sizeof(kif->k)); @@ -589,7 +591,7 @@ kr_redistribute(struct kroute_prefix *kp /* rb-tree compare */ static __inline int -kroute_compare(struct kroute_prefix *a, struct kroute_prefix *b) +kroute_compare(const struct kroute_prefix *a, const struct kroute_prefix *b) { int addrcmp; @@ -620,7 +622,7 @@ kroute_find_prefix(int af, union ldpd_ad s.prefix = *prefix; s.prefixlen = prefixlen; - return (RB_FIND(kroute_tree, &krt, &s)); + return (RBT_FIND(kroute_tree, &krt, &s)); } static struct kroute_priority * @@ -667,7 +669,7 @@ kroute_insert(struct kroute *kr) kp->prefix = kr->prefix; kp->prefixlen = kr->prefixlen; TAILQ_INIT(&kp->priorities); - RB_INSERT(kroute_tree, &krt, kp); + RBT_INSERT(kroute_tree, &krt, kp); } kprio = kroute_find_prio(kp, kr->priority); @@ -744,7 +746,7 @@ kroute_remove(struct kroute *kr) } if (TAILQ_EMPTY(&kp->priorities)) { - if (RB_REMOVE(kroute_tree, &krt, kp) == NULL) { + if (RBT_REMOVE(kroute_tree, &krt, kp) == NULL) { log_warnx("%s failed for %s/%u", __func__, log_addr(kr->af, &kr->prefix), kp->prefixlen); return (-1); @@ -768,7 +770,7 @@ kroute_clear(void) struct kroute_priority *kprio; struct kroute_node *kn; - while ((kp = RB_MIN(kroute_tree, &krt)) != NULL) { + while ((kp = RBT_MIN(kroute_tree, &krt)) != NULL) { while ((kprio = TAILQ_FIRST(&kp->priorities)) != NULL) { while ((kn = TAILQ_FIRST(&kprio->nexthops)) != NULL) { kr_redist_remove(&kn->r); @@ -779,13 +781,13 @@ kroute_clear(void) TAILQ_REMOVE(&kp->priorities, kprio, entry); free(kprio); } - RB_REMOVE(kroute_tree, &krt, kp); + RBT_REMOVE(kroute_tree, &krt, kp); free(kp); } } static __inline int -kif_compare(struct kif_node *a, struct kif_node *b) +kif_compare(const struct kif_node *a, const struct kif_node *b) { return (b->k.ifindex - a->k.ifindex); } @@ -799,7 +801,7 @@ kif_find(unsigned short ifindex) memset(&s, 0, sizeof(s)); s.k.ifindex = ifindex; - return (RB_FIND(kif_tree, &kit, &s)); + return (RBT_FIND(kif_tree, &kit, &s)); } struct kif * @@ -807,7 +809,7 @@ kif_findname(char *ifname) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (!strcmp(ifname, kif->k.ifname)) return (&kif->k); @@ -825,8 +827,8 @@ kif_insert(unsigned short ifindex) kif->k.ifindex = ifindex; TAILQ_INIT(&kif->addrs); - if (RB_INSERT(kif_tree, &kit, kif) != NULL) - fatalx("kif_insert: RB_INSERT"); + if (RBT_INSERT(kif_tree, &kit, kif) != NULL) + fatalx("kif_insert: RBT_INSERT"); return (kif); } @@ -836,8 +838,8 @@ kif_remove(struct kif_node *kif) { struct kif_addr *ka; - if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { - log_warnx("RB_REMOVE(kif_tree, &kit, kif)"); + if (RBT_REMOVE(kif_tree, &kit, kif) == NULL) { + log_warnx("RBT_REMOVE(kif_tree, &kit, kif)"); return (-1); } @@ -855,7 +857,7 @@ kif_clear(void) { struct kif_node *kif; - while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + while ((kif = RBT_MIN(kif_tree, &kit)) != NULL) kif_remove(kif); } Index: usr.sbin/ldpd/l2vpn.c =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/l2vpn.c,v retrieving revision 1.24 diff -u -p -r1.24 l2vpn.c --- usr.sbin/ldpd/l2vpn.c 4 Mar 2017 00:21:48 -0000 1.24 +++ usr.sbin/ldpd/l2vpn.c 21 Jun 2017 00:00:38 -0000 @@ -415,7 +415,7 @@ l2vpn_recv_pw_status_wcard(struct lde_nb struct l2vpn_pw *pw; struct map *wcard = &nm->fec; - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; if (fn->fec.type != FEC_TYPE_PWID) continue; @@ -515,7 +515,7 @@ l2vpn_binding_ctl(pid_t pid) struct l2vpn_pw *pw; static struct ctl_pw pwctl; - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { if (f->type != FEC_TYPE_PWID) continue; Index: usr.sbin/ldpd/lde.c =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/lde.c,v retrieving revision 1.73 diff -u -p -r1.73 lde.c --- usr.sbin/ldpd/lde.c 4 Mar 2017 00:15:35 -0000 1.73 +++ usr.sbin/ldpd/lde.c 21 Jun 2017 00:00:38 -0000 @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -44,8 +45,8 @@ static __dead void lde_shutdown(void); static int lde_imsg_compose_parent(int, pid_t, void *, uint16_t); static void lde_dispatch_imsg(int, short, void *); static void lde_dispatch_parent(int, short, void *); -static __inline int lde_nbr_compare(struct lde_nbr *, - struct lde_nbr *); +static __inline int lde_nbr_compare(const struct lde_nbr *, + const struct lde_nbr *); static struct lde_nbr *lde_nbr_new(uint32_t, struct lde_nbr *); static void lde_nbr_del(struct lde_nbr *); static struct lde_nbr *lde_nbr_find(uint32_t); @@ -57,10 +58,10 @@ static int lde_address_add(struct lde_ static int lde_address_del(struct lde_nbr *, struct lde_addr *); static void lde_address_list_free(struct lde_nbr *); -RB_GENERATE(nbr_tree, lde_nbr, entry, lde_nbr_compare) +RBT_GENERATE(nbr_tree, lde_nbr, entry, lde_nbr_compare); struct ldpd_conf *ldeconf; -struct nbr_tree lde_nbrs = RB_INITIALIZER(&lde_nbrs); +struct nbr_tree lde_nbrs = RBT_INITIALIZER(lde_nbrs); static struct imsgev *iev_ldpe; static struct imsgev *iev_main; @@ -875,7 +876,7 @@ lde_send_labelwithdraw(struct lde_nbr *l } else { struct lde_map *me; - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; me = (struct lde_map *)fec_find(&ln->sent_map, &fn->fec); if (lde_wildcard_apply(wcard, &fn->fec, me) == 0) @@ -1030,7 +1031,7 @@ lde_send_notification_eol_pwid(struct ld } static __inline int -lde_nbr_compare(struct lde_nbr *a, struct lde_nbr *b) +lde_nbr_compare(const struct lde_nbr *a, const struct lde_nbr *b) { return (a->peerid - b->peerid); } @@ -1056,8 +1057,8 @@ lde_nbr_new(uint32_t peerid, struct lde_ TAILQ_INIT(&ln->addr_list); - if (RB_INSERT(nbr_tree, &lde_nbrs, ln) != NULL) - fatalx("lde_nbr_new: RB_INSERT failed"); + if (RBT_INSERT(nbr_tree, &lde_nbrs, ln) != NULL) + fatalx("lde_nbr_new: RBT_INSERT failed"); return (ln); } @@ -1074,7 +1075,7 @@ lde_nbr_del(struct lde_nbr *ln) return; /* uninstall received mappings */ - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; LIST_FOREACH(fnh, &fn->nexthops, entry) { @@ -1109,7 +1110,7 @@ lde_nbr_del(struct lde_nbr *ln) fec_clear(&ln->sent_req, free); fec_clear(&ln->sent_wdraw, free); - RB_REMOVE(nbr_tree, &lde_nbrs, ln); + RBT_REMOVE(nbr_tree, &lde_nbrs, ln); free(ln); } @@ -1121,7 +1122,7 @@ lde_nbr_find(uint32_t peerid) ln.peerid = peerid; - return (RB_FIND(nbr_tree, &lde_nbrs, &ln)); + return (RBT_FIND(nbr_tree, &lde_nbrs, &ln)); } struct lde_nbr * @@ -1129,7 +1130,7 @@ lde_nbr_find_by_lsrid(struct in_addr add { struct lde_nbr *ln; - RB_FOREACH(ln, nbr_tree, &lde_nbrs) + RBT_FOREACH(ln, nbr_tree, &lde_nbrs) if (ln->id.s_addr == addr.s_addr) return (ln); @@ -1141,7 +1142,7 @@ lde_nbr_find_by_addr(int af, union ldpd_ { struct lde_nbr *ln; - RB_FOREACH(ln, nbr_tree, &lde_nbrs) + RBT_FOREACH(ln, nbr_tree, &lde_nbrs) if (lde_address_find(ln, af, addr) != NULL) return (ln); @@ -1153,7 +1154,7 @@ lde_nbr_clear(void) { struct lde_nbr *ln; - while ((ln = RB_ROOT(&lde_nbrs)) != NULL) + while ((ln = RBT_ROOT(nbr_tree, &lde_nbrs)) != NULL) lde_nbr_del(ln); } @@ -1165,7 +1166,7 @@ lde_nbr_addr_update(struct lde_nbr *ln, struct fec_nh *fnh; struct lde_map *me; - RB_FOREACH(fec, fec_tree, &ln->recv_map) { + RBT_FOREACH(fec, fec_tree, &ln->recv_map) { fn = (struct fec_node *)fec_find(&ft, fec); switch (fec->type) { case FEC_TYPE_IPV4: @@ -1312,7 +1313,7 @@ lde_change_egress_label(int af, int was_ struct fec *f; struct fec_node *fn; - RB_FOREACH(ln, nbr_tree, &lde_nbrs) { + RBT_FOREACH(ln, nbr_tree, &lde_nbrs) { /* explicit withdraw */ if (was_implicit) lde_send_labelwithdraw_wcard(ln, MPLS_LABEL_IMPLNULL); @@ -1326,7 +1327,7 @@ lde_change_egress_label(int af, int was_ } /* advertise new label of connected prefixes */ - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; if (fn->local_label > MPLS_LABEL_RESERVED_MAX) continue; Index: usr.sbin/ldpd/lde.h =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/lde.h,v retrieving revision 1.50 diff -u -p -r1.50 lde.h --- usr.sbin/ldpd/lde.h 4 Mar 2017 00:21:48 -0000 1.50 +++ usr.sbin/ldpd/lde.h 21 Jun 2017 00:00:38 -0000 @@ -32,7 +32,7 @@ enum fec_type { }; struct fec { - RB_ENTRY(fec) entry; + RBT_ENTRY(fec) entry; enum fec_type type; union { struct { @@ -50,8 +50,8 @@ struct fec { } pwid; } u; }; -RB_HEAD(fec_tree, fec); -RB_PROTOTYPE(fec_tree, fec, entry, fec_compare) +RBT_HEAD(fec_tree, fec); +RBT_PROTOTYPE(fec_tree, fec, entry, fec_compare); /* request entries */ struct lde_req { @@ -82,7 +82,7 @@ struct lde_addr { /* just the info LDE needs */ struct lde_nbr { - RB_ENTRY(lde_nbr) entry; + RBT_ENTRY(lde_nbr) entry; uint32_t peerid; struct in_addr id; int v4_enabled; /* announce/process v4 msgs */ @@ -95,8 +95,8 @@ struct lde_nbr { struct fec_tree sent_wdraw; TAILQ_HEAD(, lde_addr) addr_list; }; -RB_HEAD(nbr_tree, lde_nbr); -RB_PROTOTYPE(nbr_tree, lde_nbr, entry, lde_nbr_compare) +RBT_HEAD(nbr_tree, lde_nbr); +RBT_PROTOTYPE(nbr_tree, lde_nbr, entry, lde_nbr_compare); struct fec_nh { LIST_ENTRY(fec_nh) entry; Index: usr.sbin/ldpd/lde_lib.c =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/lde_lib.c,v retrieving revision 1.69 diff -u -p -r1.69 lde_lib.c --- usr.sbin/ldpd/lde_lib.c 4 Mar 2017 00:15:35 -0000 1.69 +++ usr.sbin/ldpd/lde_lib.c 21 Jun 2017 00:00:38 -0000 @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -29,7 +30,7 @@ #include "ldpe.h" #include "log.h" -static __inline int fec_compare(struct fec *, struct fec *); +static __inline int fec_compare(const struct fec *, const struct fec *); static int lde_nbr_is_nexthop(struct fec_node *, struct lde_nbr *); static void fec_free(void *); @@ -38,20 +39,20 @@ static struct fec_nh *fec_nh_add(struct uint8_t priority); static void fec_nh_del(struct fec_nh *); -RB_GENERATE(fec_tree, fec, entry, fec_compare) +RBT_GENERATE(fec_tree, fec, entry, fec_compare); -struct fec_tree ft = RB_INITIALIZER(&ft); +struct fec_tree ft = RBT_INITIALIZER(ft); struct event gc_timer; /* FEC tree functions */ void fec_init(struct fec_tree *fh) { - RB_INIT(fh); + RBT_INIT(fec_tree, fh); } static __inline int -fec_compare(struct fec *a, struct fec *b) +fec_compare(const struct fec *a, const struct fec *b) { if (a->type < b->type) return (-1); @@ -107,13 +108,13 @@ fec_compare(struct fec *a, struct fec *b struct fec * fec_find(struct fec_tree *fh, struct fec *f) { - return (RB_FIND(fec_tree, fh, f)); + return (RBT_FIND(fec_tree, fh, f)); } int fec_insert(struct fec_tree *fh, struct fec *f) { - if (RB_INSERT(fec_tree, fh, f) != NULL) + if (RBT_INSERT(fec_tree, fh, f) != NULL) return (-1); return (0); } @@ -121,7 +122,7 @@ fec_insert(struct fec_tree *fh, struct f int fec_remove(struct fec_tree *fh, struct fec *f) { - if (RB_REMOVE(fec_tree, fh, f) == NULL) { + if (RBT_REMOVE(fec_tree, fh, f) == NULL) { log_warnx("%s failed for %s", __func__, log_fec(f)); return (-1); } @@ -133,7 +134,7 @@ fec_clear(struct fec_tree *fh, void (*fr { struct fec *f; - while ((f = RB_ROOT(fh)) != NULL) { + while ((f = RBT_ROOT(fec_tree, fh)) != NULL) { fec_remove(fh, f); free_cb(f); } @@ -160,7 +161,7 @@ rt_dump(pid_t pid) struct lde_map *me; static struct ctl_rt rtctl; - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; if (fn->local_label == NO_LABEL && LIST_EMPTY(&fn->downstream)) @@ -207,7 +208,7 @@ fec_snap(struct lde_nbr *ln) struct fec *f; struct fec_node *fn; - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; if (fn->local_label == NO_LABEL) continue; @@ -368,7 +369,7 @@ lde_kernel_insert(struct fec *fec, int a fn->local_label = lde_assign_label(); /* FEC.1: perform lsr label distribution procedure */ - RB_FOREACH(ln, nbr_tree, &lde_nbrs) + RBT_FOREACH(ln, nbr_tree, &lde_nbrs) lde_send_labelmapping(ln, fn, 1); } @@ -420,7 +421,7 @@ lde_kernel_remove(struct fec *fec, int a lde_send_delete_klabel(fn, fnh); fec_nh_del(fnh); if (LIST_EMPTY(&fn->nexthops)) { - RB_FOREACH(ln, nbr_tree, &lde_nbrs) + RBT_FOREACH(ln, nbr_tree, &lde_nbrs) lde_send_labelwithdraw(ln, fn, NULL, NULL); fn->local_label = NO_LABEL; if (fn->fec.type == FEC_TYPE_PWID) @@ -604,7 +605,7 @@ lde_check_request_wcard(struct map *map, struct fec_node *fn; struct lde_req *lre; - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; /* only a typed wildcard is possible here */ @@ -705,7 +706,7 @@ lde_check_release_wcard(struct map *map, struct lde_wdraw *lw; struct lde_map *me; - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; me = (struct lde_map *)fec_find(&ln->sent_map, &fn->fec); @@ -798,7 +799,7 @@ lde_check_withdraw_wcard(struct map *map /* LWd.2: send label release */ lde_send_labelrelease(ln, NULL, map, map->label); - RB_FOREACH(f, fec_tree, &ft) { + RBT_FOREACH(f, fec_tree, &ft) { fn = (struct fec_node *)f; me = (struct lde_map *)fec_find(&ln->recv_map, &fn->fec); @@ -893,7 +894,7 @@ lde_gc_timer(int fd, short event, void * struct fec_node *fn; int count = 0; - RB_FOREACH_SAFE(fec, fec_tree, &ft, safe) { + RBT_FOREACH_SAFE(fec, fec_tree, &ft, safe) { fn = (struct fec_node *) fec; if (!LIST_EMPTY(&fn->nexthops) || Index: usr.sbin/ldpd/ldpe.c =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/ldpe.c,v retrieving revision 1.74 diff -u -p -r1.74 ldpe.c --- usr.sbin/ldpd/ldpe.c 4 Mar 2017 00:21:48 -0000 1.74 +++ usr.sbin/ldpd/ldpe.c 21 Jun 2017 00:00:38 -0000 @@ -322,7 +322,7 @@ ldpe_dispatch_main(int fd, short event, case IMSG_CLOSE_SOCKETS: af = imsg.hdr.peerid; - RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { + RBT_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { if (nbr->af != af) continue; session_shutdown(nbr, S_SHUTDOWN, 0, 0); @@ -375,7 +375,7 @@ ldpe_dispatch_main(int fd, short event, session_socket); if_update_all(af); tnbr_update_all(af); - RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { + RBT_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { if (nbr->af != af) continue; nbr->laddr = (ldp_af_conf_get(leconf, @@ -684,7 +684,7 @@ ldpe_reset_nbrs(int af) { struct nbr *nbr; - RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { + RBT_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { if (nbr->af == af) session_shutdown(nbr, S_SHUTDOWN, 0, 0); } @@ -695,7 +695,7 @@ ldpe_reset_ds_nbrs(void) { struct nbr *nbr; - RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { + RBT_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { if (nbr->ds_tlv) session_shutdown(nbr, S_SHUTDOWN, 0, 0); } @@ -720,7 +720,7 @@ ldpe_stop_init_backoff(int af) { struct nbr *nbr; - RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { + RBT_FOREACH(nbr, nbr_id_head, &nbrs_by_id) { if (nbr->af == af && nbr_pending_idtimer(nbr)) { nbr_stop_idtimer(nbr); nbr_establish_connection(nbr); @@ -762,7 +762,7 @@ ldpe_adj_ctl(struct ctl_conn *c) struct adj *adj; struct ctl_adj *actl; - RB_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) { + RBT_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) { LIST_FOREACH(adj, &nbr->adj_list, nbr_entry) { actl = adj_to_ctl(adj); imsg_compose_event(&c->iev, IMSG_CTL_SHOW_DISCOVERY, @@ -788,7 +788,7 @@ ldpe_nbr_ctl(struct ctl_conn *c) struct nbr *nbr; struct ctl_nbr *nctl; - RB_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) { + RBT_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) { nctl = nbr_to_ctl(nbr); imsg_compose_event(&c->iev, IMSG_CTL_SHOW_NBR, 0, 0, -1, nctl, sizeof(struct ctl_nbr)); Index: usr.sbin/ldpd/ldpe.h =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/ldpe.h,v retrieving revision 1.75 diff -u -p -r1.75 ldpe.h --- usr.sbin/ldpd/ldpe.h 4 Mar 2017 00:21:48 -0000 1.75 +++ usr.sbin/ldpd/ldpe.h 21 Jun 2017 00:00:38 -0000 @@ -62,7 +62,7 @@ struct tcp_conn { }; struct nbr { - RB_ENTRY(nbr) id_tree, addr_tree, pid_tree; + RBT_ENTRY(nbr) id_tree, addr_tree, pid_tree; struct tcp_conn *tcp; LIST_HEAD(, adj) adj_list; /* adjacencies */ struct event ev_connect; @@ -108,12 +108,12 @@ struct nbr { #define F_NBR_CAP_TWCARD 0x04 #define F_NBR_CAP_UNOTIF 0x08 -RB_HEAD(nbr_id_head, nbr); -RB_PROTOTYPE(nbr_id_head, nbr, id_tree, nbr_id_compare) -RB_HEAD(nbr_addr_head, nbr); -RB_PROTOTYPE(nbr_addr_head, nbr, addr_tree, nbr_addr_compare) -RB_HEAD(nbr_pid_head, nbr); -RB_PROTOTYPE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare) +RBT_HEAD(nbr_id_head, nbr); +RBT_PROTOTYPE(nbr_id_head, nbr, id_tree, nbr_id_compare); +RBT_HEAD(nbr_addr_head, nbr); +RBT_PROTOTYPE(nbr_addr_head, nbr, addr_tree, nbr_addr_compare); +RBT_HEAD(nbr_pid_head, nbr); +RBT_PROTOTYPE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare); struct pending_conn { TAILQ_ENTRY(pending_conn) entry; Index: usr.sbin/ldpd/neighbor.c =================================================================== RCS file: /cvs/src/usr.sbin/ldpd/neighbor.c,v retrieving revision 1.79 diff -u -p -r1.79 neighbor.c --- usr.sbin/ldpd/neighbor.c 4 Mar 2017 00:15:35 -0000 1.79 +++ usr.sbin/ldpd/neighbor.c 21 Jun 2017 00:00:38 -0000 @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -33,9 +34,12 @@ #include "lde.h" #include "log.h" -static __inline int nbr_id_compare(struct nbr *, struct nbr *); -static __inline int nbr_addr_compare(struct nbr *, struct nbr *); -static __inline int nbr_pid_compare(struct nbr *, struct nbr *); +static __inline int nbr_id_compare(const struct nbr *, + const struct nbr *); +static __inline int nbr_addr_compare(const struct nbr *, + const struct nbr *); +static __inline int nbr_pid_compare(const struct nbr *, + const struct nbr *); static void nbr_update_peerid(struct nbr *); static void nbr_ktimer(int, short, void *); static void nbr_start_ktimer(struct nbr *); @@ -47,9 +51,9 @@ static void nbr_idtimer(int, short, vo static int nbr_act_session_operational(struct nbr *); static void nbr_send_labelmappings(struct nbr *); -RB_GENERATE(nbr_id_head, nbr, id_tree, nbr_id_compare) -RB_GENERATE(nbr_addr_head, nbr, addr_tree, nbr_addr_compare) -RB_GENERATE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare) +RBT_GENERATE(nbr_id_head, nbr, id_tree, nbr_id_compare); +RBT_GENERATE(nbr_addr_head, nbr, addr_tree, nbr_addr_compare); +RBT_GENERATE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare); struct { int state; @@ -100,18 +104,18 @@ const char * const nbr_action_names[] = "CLOSE SESSION" }; -struct nbr_id_head nbrs_by_id = RB_INITIALIZER(&nbrs_by_id); -struct nbr_addr_head nbrs_by_addr = RB_INITIALIZER(&nbrs_by_addr); -struct nbr_pid_head nbrs_by_pid = RB_INITIALIZER(&nbrs_by_pid); +struct nbr_id_head nbrs_by_id = RBT_INITIALIZER(nbrs_by_id); +struct nbr_addr_head nbrs_by_addr = RBT_INITIALIZER(nbrs_by_addr); +struct nbr_pid_head nbrs_by_pid = RBT_INITIALIZER(nbrs_by_pid); static __inline int -nbr_id_compare(struct nbr *a, struct nbr *b) +nbr_id_compare(const struct nbr *a, const struct nbr *b) { return (ntohl(a->id.s_addr) - ntohl(b->id.s_addr)); } static __inline int -nbr_addr_compare(struct nbr *a, struct nbr *b) +nbr_addr_compare(const struct nbr *a, const struct nbr *b) { if (a->af < b->af) return (-1); @@ -122,7 +126,7 @@ nbr_addr_compare(struct nbr *a, struct n } static __inline int -nbr_pid_compare(struct nbr *a, struct nbr *b) +nbr_pid_compare(const struct nbr *a, const struct nbr *b) { return (a->peerid - b->peerid); } @@ -255,10 +259,10 @@ nbr_new(struct in_addr id, int af, int d } } - if (RB_INSERT(nbr_id_head, &nbrs_by_id, nbr) != NULL) - fatalx("nbr_new: RB_INSERT(nbrs_by_id) failed"); - if (RB_INSERT(nbr_addr_head, &nbrs_by_addr, nbr) != NULL) - fatalx("nbr_new: RB_INSERT(nbrs_by_addr) failed"); + if (RBT_INSERT(nbr_id_head, &nbrs_by_id, nbr) != NULL) + fatalx("nbr_new: RBT_INSERT(nbrs_by_id) failed"); + if (RBT_INSERT(nbr_addr_head, &nbrs_by_addr, nbr) != NULL) + fatalx("nbr_new: RBT_INSERT(nbrs_by_addr) failed"); TAILQ_INIT(&nbr->mapping_list); TAILQ_INIT(&nbr->withdraw_list); @@ -307,9 +311,9 @@ nbr_del(struct nbr *nbr) mapping_list_clr(&nbr->abortreq_list); if (nbr->peerid) - RB_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); - RB_REMOVE(nbr_id_head, &nbrs_by_id, nbr); - RB_REMOVE(nbr_addr_head, &nbrs_by_addr, nbr); + RBT_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); + RBT_REMOVE(nbr_id_head, &nbrs_by_id, nbr); + RBT_REMOVE(nbr_addr_head, &nbrs_by_addr, nbr); free(nbr); } @@ -320,15 +324,15 @@ nbr_update_peerid(struct nbr *nbr) static uint32_t peercnt = 1; if (nbr->peerid) - RB_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); + RBT_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr); /* get next unused peerid */ while (nbr_find_peerid(++peercnt)) ; nbr->peerid = peercnt; - if (RB_INSERT(nbr_pid_head, &nbrs_by_pid, nbr) != NULL) - fatalx("nbr_update_peerid: RB_INSERT(nbrs_by_pid) failed"); + if (RBT_INSERT(nbr_pid_head, &nbrs_by_pid, nbr) != NULL) + fatalx("nbr_update_peerid: RBT_INSERT(nbrs_by_pid) failed"); } struct nbr * @@ -336,7 +340,7 @@ nbr_find_ldpid(uint32_t lsr_id) { struct nbr n; n.id.s_addr = lsr_id; - return (RB_FIND(nbr_id_head, &nbrs_by_id, &n)); + return (RBT_FIND(nbr_id_head, &nbrs_by_id, &n)); } struct nbr * @@ -345,7 +349,7 @@ nbr_find_addr(int af, union ldpd_addr *a struct nbr n; n.af = af; n.raddr = *addr; - return (RB_FIND(nbr_addr_head, &nbrs_by_addr, &n)); + return (RBT_FIND(nbr_addr_head, &nbrs_by_addr, &n)); } struct nbr * @@ -353,7 +357,7 @@ nbr_find_peerid(uint32_t peerid) { struct nbr n; n.peerid = peerid; - return (RB_FIND(nbr_pid_head, &nbrs_by_pid, &n)); + return (RBT_FIND(nbr_pid_head, &nbrs_by_pid, &n)); } int @@ -816,7 +820,7 @@ nbr_clear_ctl(struct ctl_nbr *nctl) { struct nbr *nbr; - RB_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) { + RBT_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) { if (ldp_addrisset(nctl->af, &nctl->raddr) && ldp_addrcmp(nctl->af, &nctl->raddr, &nbr->raddr)) continue; Index: usr.sbin/ospf6d/area.c =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/area.c,v retrieving revision 1.4 diff -u -p -r1.4 area.c --- usr.sbin/ospf6d/area.c 28 Dec 2008 20:08:31 -0000 1.4 +++ usr.sbin/ospf6d/area.c 21 Jun 2017 00:00:38 -0000 @@ -38,7 +38,7 @@ area_new(void) LIST_INIT(&area->iface_list); LIST_INIT(&area->nbr_list); - RB_INIT(&area->lsa_tree); + RBT_INIT(lsa_tree, &area->lsa_tree); return (area); } @@ -63,8 +63,8 @@ area_del(struct area *area) while ((n = LIST_FIRST(&area->nbr_list)) != NULL) rde_nbr_del(n); - for (v = RB_MIN(lsa_tree, &area->lsa_tree); v != NULL; v = nv) { - nv = RB_NEXT(lsa_tree, &area->lsa_tree, v); + for (v = RBT_MIN(lsa_tree, &area->lsa_tree); v != NULL; v = nv) { + nv = RBT_NEXT(lsa_tree, v); vertex_free(v); } Index: usr.sbin/ospf6d/interface.c =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/interface.c,v retrieving revision 1.22 diff -u -p -r1.22 interface.c --- usr.sbin/ospf6d/interface.c 27 Sep 2015 17:31:50 -0000 1.22 +++ usr.sbin/ospf6d/interface.c 21 Jun 2017 00:00:38 -0000 @@ -38,6 +38,7 @@ #include "ospf6.h" #include "log.h" #include "ospfe.h" +#include "rde.h" void if_hello_timer(int, short, void *); void if_start_hello_timer(struct iface *); @@ -212,7 +213,7 @@ if_new(u_short ifindex, char *ifname) LIST_INIT(&iface->nbr_list); TAILQ_INIT(&iface->ifa_list); TAILQ_INIT(&iface->ls_ack_list); - RB_INIT(&iface->lsa_tree); + RBT_INIT(lsa_tree, &iface->lsa_tree); #if 0 /* TODO */ Index: usr.sbin/ospf6d/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/kroute.c,v retrieving revision 1.51 diff -u -p -r1.51 kroute.c --- usr.sbin/ospf6d/kroute.c 30 May 2017 12:42:31 -0000 1.51 +++ usr.sbin/ospf6d/kroute.c 21 Jun 2017 00:00:38 -0000 @@ -50,7 +50,7 @@ struct { } kr_state; struct kroute_node { - RB_ENTRY(kroute_node) entry; + RBT_ENTRY(kroute_node) entry; struct kroute_node *next; struct kroute r; }; @@ -58,7 +58,7 @@ struct kroute_node { void kr_redist_remove(struct kroute_node *, struct kroute_node *); int kr_redist_eval(struct kroute *, struct kroute *); void kr_redistribute(struct kroute_node *); -int kroute_compare(struct kroute_node *, struct kroute_node *); +int kroute_compare(const struct kroute_node *, const struct kroute_node *); int kr_change_fib(struct kroute_node *, struct kroute *, int, int); int kr_delete_fib(struct kroute_node *); @@ -88,9 +88,9 @@ int send_rtmsg(int, int, struct kroute int dispatch_rtmsg(void); int fetchtable(void); -RB_HEAD(kroute_tree, kroute_node) krt; -RB_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare) -RB_GENERATE(kroute_tree, kroute_node, entry, kroute_compare) +RBT_HEAD(kroute_tree, kroute_node) krt; +RBT_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare); +RBT_GENERATE(kroute_tree, kroute_node, entry, kroute_compare); int kr_init(int fs) @@ -127,7 +127,7 @@ kr_init(int fs) kr_state.pid = getpid(); kr_state.rtseq = 1; - RB_INIT(&krt); + RBT_INIT(kroute_tree, &krt); if (fetchtable() == -1) return (-1); @@ -325,7 +325,7 @@ kr_fib_couple(void) kr_state.fib_sync = 1; - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (!(kr->r.flags & F_KERNEL)) for (kn = kr; kn != NULL; kn = kn->next) { send_rtmsg(kr_state.fd, RTM_ADD, &kn->r); @@ -343,7 +343,7 @@ kr_fib_decouple(void) if (kr_state.fib_sync == 0) /* already decoupled */ return; - RB_FOREACH(kr, kroute_tree, &krt) { + RBT_FOREACH(kr, kroute_tree, &krt) { if (!(kr->r.flags & F_KERNEL)) for (kn = kr; kn != NULL; kn = kn->next) { send_rtmsg(kr_state.fd, RTM_DELETE, &kn->r); @@ -377,7 +377,7 @@ kr_show_route(struct imsg *imsg) return; } memcpy(&flags, imsg->data, sizeof(flags)); - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (!flags || kr->r.flags & flags) { kn = kr; do { @@ -526,7 +526,7 @@ kr_reload(void) u_int32_t dummy; int r; - RB_FOREACH(kr, kroute_tree, &krt) { + RBT_FOREACH(kr, kroute_tree, &krt) { for (kn = kr; kn; kn = kn->next) { r = ospf_redistribute(&kn->r, &dummy); /* @@ -548,7 +548,7 @@ kr_reload(void) /* rb-tree compare */ int -kroute_compare(struct kroute_node *a, struct kroute_node *b) +kroute_compare(const struct kroute_node *a, const struct kroute_node *b) { int i; @@ -572,7 +572,7 @@ kroute_find(const struct in6_addr *prefi s.r.prefix = *prefix; s.r.prefixlen = prefixlen; - return (RB_FIND(kroute_tree, &krt, &s)); + return (RBT_FIND(kroute_tree, &krt, &s)); } struct kroute_node * @@ -593,7 +593,7 @@ kroute_insert(struct kroute_node *kr) { struct kroute_node *krm, *krh; - if ((krh = RB_INSERT(kroute_tree, &krt, kr)) != NULL) { + if ((krh = RBT_INSERT(kroute_tree, &krt, kr)) != NULL) { /* * Multipath route, add at end of list and clone the * ospfd inserted flag. @@ -627,7 +627,7 @@ kroute_remove(struct kroute_node *kr) { struct kroute_node *krm; - if ((krm = RB_FIND(kroute_tree, &krt, kr)) == NULL) { + if ((krm = RBT_FIND(kroute_tree, &krt, kr)) == NULL) { log_warnx("kroute_remove failed to find %s/%u", log_in6addr(&kr->r.prefix), kr->r.prefixlen); return (-1); @@ -635,13 +635,13 @@ kroute_remove(struct kroute_node *kr) if (krm == kr) { /* head element */ - if (RB_REMOVE(kroute_tree, &krt, kr) == NULL) { + if (RBT_REMOVE(kroute_tree, &krt, kr) == NULL) { log_warnx("kroute_remove failed for %s/%u", log_in6addr(&kr->r.prefix), kr->r.prefixlen); return (-1); } if (kr->next != NULL) { - if (RB_INSERT(kroute_tree, &krt, kr->next) != NULL) { + if (RBT_INSERT(kroute_tree, &krt, kr->next) != NULL) { log_warnx("kroute_remove failed to add %s/%u", log_in6addr(&kr->r.prefix), kr->r.prefixlen); @@ -673,7 +673,7 @@ kroute_clear(void) { struct kroute_node *kr; - while ((kr = RB_MIN(kroute_tree, &krt)) != NULL) + while ((kr = RBT_MIN(kroute_tree, &krt)) != NULL) kroute_remove(kr); } @@ -756,7 +756,7 @@ protect_lo(void) kr->r.prefixlen = 128; kr->r.flags = F_KERNEL|F_CONNECTED; - if (RB_INSERT(kroute_tree, &krt, kr) != NULL) + if (RBT_INSERT(kroute_tree, &krt, kr) != NULL) free(kr); /* kernel route already there, no problem */ return (0); @@ -809,7 +809,7 @@ if_change(u_short ifindex, int flags, st return; /* nothing changed wrt validity */ /* update redistribute list */ - RB_FOREACH(kr, kroute_tree, &krt) { + RBT_FOREACH(kr, kroute_tree, &krt) { for (tkr = kr; tkr != NULL; tkr = tkr->next) { if (tkr->r.ifindex == ifindex) { if (isvalid) Index: usr.sbin/ospf6d/ospf6d.h =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/ospf6d.h,v retrieving revision 1.32 diff -u -p -r1.32 ospf6d.h --- usr.sbin/ospf6d/ospf6d.h 30 May 2017 12:42:31 -0000 1.32 +++ usr.sbin/ospf6d/ospf6d.h 21 Jun 2017 00:00:38 -0000 @@ -134,7 +134,7 @@ enum imsg_type { /* area */ struct vertex; struct rde_nbr; -RB_HEAD(lsa_tree, vertex); +RBT_HEAD(lsa_tree, vertex); struct area { LIST_ENTRY(area) entry; Index: usr.sbin/ospf6d/ospfe.c =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/ospfe.c,v retrieving revision 1.50 diff -u -p -r1.50 ospfe.c --- usr.sbin/ospf6d/ospfe.c 22 Dec 2016 22:56:52 -0000 1.50 +++ usr.sbin/ospf6d/ospfe.c 21 Jun 2017 00:00:38 -0000 @@ -320,7 +320,7 @@ ospfe_dispatch_main(int fd, short event, LIST_INIT(&iface->nbr_list); TAILQ_INIT(&iface->ls_ack_list); - RB_INIT(&iface->lsa_tree); + RBT_INIT(lsa_tree, &iface->lsa_tree); area = area_find(oeconf, iface->area_id); LIST_INSERT_HEAD(&area->iface_list, iface, entry); @@ -398,7 +398,7 @@ ospfe_dispatch_main(int fd, short event, LIST_INIT(&narea->iface_list); LIST_INIT(&narea->nbr_list); - RB_INIT(&narea->lsa_tree); + RBT_INIT(lsa_tree, &narea->lsa_tree); LIST_INSERT_HEAD(&nconf->area_list, narea, entry); break; Index: usr.sbin/ospf6d/rde.c =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/rde.c,v retrieving revision 1.70 diff -u -p -r1.70 rde.c --- usr.sbin/ospf6d/rde.c 30 May 2017 12:42:31 -0000 1.70 +++ usr.sbin/ospf6d/rde.c 21 Jun 2017 00:00:38 -0000 @@ -78,12 +78,13 @@ void append_prefix_lsa(struct lsa **, /* Tree of prefixes with global scope on given a link, * see orig_intra_lsa_*() */ struct prefix_node { - RB_ENTRY(prefix_node) entry; + RBT_ENTRY(prefix_node) entry; struct lsa_prefix *prefix; }; -RB_HEAD(prefix_tree, prefix_node); -RB_PROTOTYPE(prefix_tree, prefix_node, entry, prefix_compare); -int prefix_compare(struct prefix_node *, struct prefix_node *); +RBT_HEAD(prefix_tree, prefix_node); +RBT_PROTOTYPE(prefix_tree, prefix_node, entry, prefix_compare); +int prefix_compare(const struct prefix_node *, + const struct prefix_node *); void prefix_tree_add(struct prefix_tree *, struct lsa_link *); struct ospfd_conf *rdeconf = NULL, *nconf = NULL; @@ -743,7 +744,7 @@ rde_dispatch_parent(int fd, short event, LIST_INIT(&iface->nbr_list); TAILQ_INIT(&iface->ls_ack_list); - RB_INIT(&iface->lsa_tree); + RBT_INIT(lsa_tree, &iface->lsa_tree); area = area_find(rdeconf, iface->area_id); LIST_INSERT_HEAD(&area->iface_list, iface, entry); @@ -825,7 +826,7 @@ rde_dispatch_parent(int fd, short event, LIST_INIT(&narea->iface_list); LIST_INIT(&narea->nbr_list); - RB_INIT(&narea->lsa_tree); + RBT_INIT(lsa_tree, &narea->lsa_tree); LIST_INSERT_HEAD(&nconf->area_list, narea, entry); break; @@ -941,7 +942,7 @@ rde_send_summary(pid_t pid) LIST_FOREACH(area, &rdeconf->area_list, entry) sumctl.num_area++; - RB_FOREACH(v, lsa_tree, &asext_tree) + RBT_FOREACH(v, lsa_tree, &asext_tree) sumctl.num_ext_lsa++; gettimeofday(&now, NULL); @@ -975,7 +976,7 @@ rde_send_summary_area(struct area *area, if (nbr->state == NBR_STA_FULL && !nbr->self) sumareactl.num_adj_nbr++; - RB_FOREACH(v, lsa_tree, tree) + RBT_FOREACH(v, lsa_tree, tree) sumareactl.num_lsa++; rde_imsg_compose_ospfe(IMSG_CTL_SHOW_SUM_AREA, 0, pid, &sumareactl, @@ -1319,7 +1320,7 @@ append_prefix_lsa(struct lsa **lsa, u_in } int -prefix_compare(struct prefix_node *a, struct prefix_node *b) +prefix_compare(const struct prefix_node *a, const struct prefix_node *b) { struct lsa_prefix *p; struct lsa_prefix *q; @@ -1368,7 +1369,7 @@ prefix_tree_add(struct prefix_tree *tree if (!(IN6_IS_ADDR_LINKLOCAL(&addr)) && (new->prefix->options & OSPF_PREFIX_NU) == 0 && (new->prefix->options & OSPF_PREFIX_LA) == 0) { - old = RB_INSERT(prefix_tree, tree, new); + old = RBT_INSERT(prefix_tree, tree, new); if (old != NULL) { old->prefix->options |= new->prefix->options; free(new); @@ -1379,7 +1380,7 @@ prefix_tree_add(struct prefix_tree *tree } } -RB_GENERATE(prefix_tree, prefix_node, entry, prefix_compare) +RBT_GENERATE(prefix_tree, prefix_node, entry, prefix_compare); struct lsa * orig_intra_lsa_net(struct area *area, struct iface *iface, struct vertex *old) @@ -1396,7 +1397,7 @@ orig_intra_lsa_net(struct area *area, st log_debug("orig_intra_lsa_net: area %s, interface %s", inet_ntoa(area->id), iface->name); - RB_INIT(&tree); + RBT_INIT(prefix_tree, &tree); if (iface->state & IF_STA_DR) { num_full_nbr = 0; @@ -1440,15 +1441,17 @@ orig_intra_lsa_net(struct area *area, st lsa->data.pref_intra.ref_adv_rtr = rde_router_id(); numprefix = 0; - RB_FOREACH(node, prefix_tree, &tree) { + RBT_FOREACH(node, prefix_tree, &tree) { append_prefix_lsa(&lsa, &len, node->prefix); numprefix++; } lsa->data.pref_intra.numprefix = htons(numprefix); - while (!RB_EMPTY(&tree)) - free(RB_REMOVE(prefix_tree, &tree, RB_ROOT(&tree))); + while (!RBT_EMPTY(prefix_tree, &tree)) { + free(RBT_REMOVE(prefix_tree, &tree, + RBT_ROOT(prefix_tree, &tree))); + } /* LSA header */ /* If numprefix is zero, originate with MAX_AGE to flush LSA. */ Index: usr.sbin/ospf6d/rde.h =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/rde.h,v retrieving revision 1.22 diff -u -p -r1.22 rde.h --- usr.sbin/ospf6d/rde.h 1 Jul 2010 19:47:04 -0000 1.22 +++ usr.sbin/ospf6d/rde.h 21 Jun 2017 00:00:38 -0000 @@ -36,7 +36,7 @@ struct v_nexthop { TAILQ_HEAD(v_nexthead, v_nexthop); struct vertex { - RB_ENTRY(vertex) entry; + RBT_ENTRY(vertex) entry; TAILQ_ENTRY(vertex) cand; struct v_nexthead nexthop; struct event ev; @@ -98,7 +98,7 @@ struct rt_nexthop { }; struct rt_node { - RB_ENTRY(rt_node) entry; + RBT_ENTRY(rt_node) entry; TAILQ_HEAD(,rt_nexthop) nexthop; struct in6_addr prefix; struct in_addr area; @@ -138,7 +138,7 @@ void orig_intra_area_prefix_lsas(struc /* rde_lsdb.c */ void lsa_init(struct lsa_tree *); -int lsa_compare(struct vertex *, struct vertex *); +int lsa_compare(const struct vertex *, const struct vertex *); void vertex_free(struct vertex *); int lsa_newer(struct lsa_hdr *, struct lsa_hdr *); int lsa_check(struct rde_nbr *, struct lsa *, u_int16_t); @@ -179,7 +179,7 @@ void stop_spf_timer(struct ospfd_conf void start_spf_holdtimer(struct ospfd_conf *); void rt_init(void); -int rt_compare(struct rt_node *, struct rt_node *); +int rt_compare(const struct rt_node *, const struct rt_node *); struct rt_node *rt_find(struct in6_addr *, u_int8_t, enum dst_type); int rt_insert(struct rt_node *); int rt_remove(struct rt_node *); @@ -189,6 +189,6 @@ void rt_dump(struct in_addr, pid_t, u_ struct lsa_rtr_link *get_rtr_link(struct vertex *, unsigned int); struct lsa_net_link *get_net_link(struct vertex *, unsigned int); -RB_PROTOTYPE(lsa_tree, vertex, entry, lsa_compare) +RBT_PROTOTYPE(lsa_tree, vertex, entry, lsa_compare); #endif /* _RDE_H_ */ Index: usr.sbin/ospf6d/rde_lsdb.c =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/rde_lsdb.c,v retrieving revision 1.38 diff -u -p -r1.38 rde_lsdb.c --- usr.sbin/ospf6d/rde_lsdb.c 18 Oct 2013 11:16:52 -0000 1.38 +++ usr.sbin/ospf6d/rde_lsdb.c 21 Jun 2017 00:00:38 -0000 @@ -37,18 +37,18 @@ void lsa_refresh(struct vertex *); int lsa_equal(struct lsa *, struct lsa *); int lsa_get_prefix(void *, u_int16_t, struct rt_prefix *); -RB_GENERATE(lsa_tree, vertex, entry, lsa_compare) +RBT_GENERATE(lsa_tree, vertex, entry, lsa_compare); extern struct ospfd_conf *rdeconf; void lsa_init(struct lsa_tree *t) { - RB_INIT(t); + RBT_INIT(lsa_tree, t); } int -lsa_compare(struct vertex *a, struct vertex *b) +lsa_compare(const struct vertex *a, const struct vertex *b) { if (a->type < b->type) return (-1); @@ -98,7 +98,7 @@ vertex_get(struct lsa *lsa, struct rde_n void vertex_free(struct vertex *v) { - RB_REMOVE(lsa_tree, v->lsa_tree, v); + RBT_REMOVE(lsa_tree, v->lsa_tree, v); (void)evtimer_del(&v->ev); free(v->lsa); free(v); @@ -444,7 +444,7 @@ lsa_add(struct rde_nbr *nbr, struct lsa fatalx("unknown scope type"); new = vertex_get(lsa, nbr, tree); - old = RB_INSERT(lsa_tree, tree, new); + old = RBT_INSERT(lsa_tree, tree, new); if (old != NULL) { if (old->deleted && evtimer_pending(&old->ev, &tv)) { @@ -454,7 +454,7 @@ lsa_add(struct rde_nbr *nbr, struct lsa /* remove old LSA and insert new LSA with delay */ vertex_free(old); - RB_INSERT(lsa_tree, tree, new); + RBT_INSERT(lsa_tree, tree, new); new->deleted = 1; if (evtimer_add(&new->ev, &res) != 0) @@ -464,7 +464,7 @@ lsa_add(struct rde_nbr *nbr, struct lsa if (lsa_equal(new->lsa, old->lsa)) update = 0; vertex_free(old); - RB_INSERT(lsa_tree, tree, new); + RBT_INSERT(lsa_tree, tree, new); } if (update) { @@ -569,7 +569,7 @@ lsa_find_tree(struct lsa_tree *tree, u_i key.adv_rtr = ntohl(adv_rtr); key.type = ntohs(type); - v = RB_FIND(lsa_tree, tree, &key); + v = RBT_FIND(lsa_tree, tree, &key); /* LSA that are deleted are not findable */ if (v && v->deleted) @@ -599,7 +599,7 @@ lsa_find_rtr_frag(struct area *area, u_i key.type = LSA_TYPE_ROUTER; i = 0; - v = RB_NFIND(lsa_tree, &area->lsa_tree, &key); + v = RBT_NFIND(lsa_tree, &area->lsa_tree, &key); while (v) { if (v->type != LSA_TYPE_ROUTER || v->adv_rtr != ntohl(rtr_id)) { @@ -612,7 +612,7 @@ lsa_find_rtr_frag(struct area *area, u_i break; i++; } - v = RB_NEXT(lsa_tree, &area->lsa_tree, v); + v = RBT_NEXT(lsa_tree, v); } if (v) { @@ -640,7 +640,7 @@ lsa_find_lsid(struct lsa_tree *tree, u_i cur = 0; min = 0xffffffffU; - v = RB_NFIND(lsa_tree, tree, &key); + v = RBT_NFIND(lsa_tree, tree, &key); while (v) { if (v->type != key.type || v->adv_rtr != key.adv_rtr) { @@ -657,7 +657,7 @@ lsa_find_lsid(struct lsa_tree *tree, u_i cur = v->ls_id; if (cur + 1 < cur) fatalx("King Bula sez: somebody got to many LSA"); - v = RB_NEXT(lsa_tree, tree, v); + v = RBT_NEXT(lsa_tree, v); } min = MIN(min, cur + 1); return (htonl(min)); @@ -696,7 +696,7 @@ lsa_snap(struct rde_nbr *nbr, u_int32_t struct vertex *v; do { - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { if (v->deleted) continue; lsa_age(v); @@ -722,7 +722,7 @@ lsa_dump(struct lsa_tree *tree, int imsg { struct vertex *v; - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { if (v->deleted) continue; lsa_age(v); @@ -906,8 +906,8 @@ lsa_remove_invalid_sums(struct area *are struct vertex *v, *nv; /* XXX speed me up */ - for (v = RB_MIN(lsa_tree, tree); v != NULL; v = nv) { - nv = RB_NEXT(lsa_tree, tree, v); + for (v = RBT_MIN(lsa_tree, tree); v != NULL; v = nv) { + nv = RBT_NEXT(lsa_tree, v); if ((v->type == LSA_TYPE_INTER_A_PREFIX || v->type == LSA_TYPE_INTER_A_ROUTER) && v->self && v->cost == LS_INFINITY && Index: usr.sbin/ospf6d/rde_spf.c =================================================================== RCS file: /cvs/src/usr.sbin/ospf6d/rde_spf.c,v retrieving revision 1.25 diff -u -p -r1.25 rde_spf.c --- usr.sbin/ospf6d/rde_spf.c 5 Dec 2015 06:45:19 -0000 1.25 +++ usr.sbin/ospf6d/rde_spf.c 21 Jun 2017 00:00:38 -0000 @@ -31,9 +31,9 @@ extern struct ospfd_conf *rdeconf; TAILQ_HEAD(, vertex) cand_list; -RB_HEAD(rt_tree, rt_node) rt; -RB_PROTOTYPE(rt_tree, rt_node, entry, rt_compare) -RB_GENERATE(rt_tree, rt_node, entry, rt_compare) +RBT_HEAD(rt_tree, rt_node) rt; +RBT_PROTOTYPE(rt_tree, rt_node, entry, rt_compare); +RBT_GENERATE(rt_tree, rt_node, entry, rt_compare); struct vertex *spf_root = NULL; void calc_nexthop_clear(struct vertex *); @@ -171,7 +171,7 @@ spf_calc(struct area *area) log_debug("spf_calc: area %s calculated", inet_ntoa(area->id)); /* Dump SPF tree to log */ - RB_FOREACH(v, lsa_tree, &area->lsa_tree) { + RBT_FOREACH(v, lsa_tree, &area->lsa_tree) { struct v_nexthop *vn; char hops[4096]; struct iface *iface; @@ -452,7 +452,7 @@ spf_tree_clr(struct area *area) struct lsa_tree *tree = &area->lsa_tree; struct vertex *v; - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { v->cost = LS_INFINITY; calc_nexthop_clear(v); } @@ -684,7 +684,7 @@ spf_timer(int fd, short event, void *arg spf_calc(area); /* calculate route table */ - RB_FOREACH(v, lsa_tree, &area->lsa_tree) { + RBT_FOREACH(v, lsa_tree, &area->lsa_tree) { rt_calc(v, area, conf); } @@ -694,11 +694,11 @@ spf_timer(int fd, short event, void *arg /* calculate as-external routes, first invalidate them */ rt_invalidate(NULL); - RB_FOREACH(v, lsa_tree, &asext_tree) { + RBT_FOREACH(v, lsa_tree, &asext_tree) { asext_calc(v); } - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { LIST_FOREACH(area, &conf->area_list, entry) rde_summary_update(r, area); @@ -784,11 +784,11 @@ start_spf_holdtimer(struct ospfd_conf *c void rt_init(void) { - RB_INIT(&rt); + RBT_INIT(rt_tree, &rt); } int -rt_compare(struct rt_node *a, struct rt_node *b) +rt_compare(const struct rt_node *a, const struct rt_node *b) { int i; @@ -816,13 +816,13 @@ rt_find(struct in6_addr *prefix, u_int8_ s.prefixlen = prefixlen; s.d_type = d_type; - return (RB_FIND(rt_tree, &rt, &s)); + return (RBT_FIND(rt_tree, &rt, &s)); } int rt_insert(struct rt_node *r) { - if (RB_INSERT(rt_tree, &rt, r) != NULL) { + if (RBT_INSERT(rt_tree, &rt, r) != NULL) { log_warnx("rt_insert failed for %s/%u", log_in6addr(&r->prefix), r->prefixlen); free(r); @@ -835,7 +835,7 @@ rt_insert(struct rt_node *r) int rt_remove(struct rt_node *r) { - if (RB_REMOVE(rt_tree, &rt, r) == NULL) { + if (RBT_REMOVE(rt_tree, &rt, r) == NULL) { log_warnx("rt_remove failed for %s/%u", log_in6addr(&r->prefix), r->prefixlen); return (-1); @@ -852,8 +852,8 @@ rt_invalidate(struct area *area) struct rt_node *r, *nr; struct rt_nexthop *rn, *nrn; - for (r = RB_MIN(rt_tree, &rt); r != NULL; r = nr) { - nr = RB_NEXT(rt_tree, &rt, r); + for (r = RBT_MIN(rt_tree, &rt); r != NULL; r = nr) { + nr = RBT_NEXT(rt_tree, r); if (area == NULL) { /* look only at as_ext routes */ if (r->p_type != PT_TYPE1_EXT && @@ -938,7 +938,7 @@ rt_clear(void) { struct rt_node *r; - while ((r = RB_MIN(rt_tree, &rt)) != NULL) + while ((r = RBT_MIN(rt_tree, &rt)) != NULL) rt_remove(r); } @@ -952,7 +952,7 @@ rt_dump(struct in_addr area, pid_t pid, clock_gettime(CLOCK_MONOTONIC, &now); - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { if (r->invalid) continue; Index: usr.sbin/ospfd/area.c =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/area.c,v retrieving revision 1.10 diff -u -p -r1.10 area.c --- usr.sbin/ospfd/area.c 22 Nov 2015 13:09:10 -0000 1.10 +++ usr.sbin/ospfd/area.c 21 Jun 2017 00:00:38 -0000 @@ -37,7 +37,7 @@ area_new(void) LIST_INIT(&area->iface_list); LIST_INIT(&area->nbr_list); - RB_INIT(&area->lsa_tree); + RBT_INIT(lsa_tree, &area->lsa_tree); SIMPLEQ_INIT(&area->redist_list); return (area); @@ -64,8 +64,8 @@ area_del(struct area *area) while ((n = LIST_FIRST(&area->nbr_list)) != NULL) rde_nbr_del(n); - for (v = RB_MIN(lsa_tree, &area->lsa_tree); v != NULL; v = nv) { - nv = RB_NEXT(lsa_tree, &area->lsa_tree, v); + for (v = RBT_MIN(lsa_tree, &area->lsa_tree); v != NULL; v = nv) { + nv = RBT_NEXT(lsa_tree, v); vertex_free(v); } Index: usr.sbin/ospfd/interface.c =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/interface.c,v retrieving revision 1.81 diff -u -p -r1.81 interface.c --- usr.sbin/ospfd/interface.c 5 Dec 2015 12:20:13 -0000 1.81 +++ usr.sbin/ospfd/interface.c 21 Jun 2017 00:00:38 -0000 @@ -37,6 +37,7 @@ #include "ospf.h" #include "log.h" #include "ospfe.h" +#include "rde.h" void if_hello_timer(int, short, void *); void if_start_hello_timer(struct iface *); @@ -169,7 +170,7 @@ if_new(struct kif *kif, struct kif_addr LIST_INIT(&iface->nbr_list); TAILQ_INIT(&iface->ls_ack_list); TAILQ_INIT(&iface->auth_md_list); - RB_INIT(&iface->lsa_tree); + RBT_INIT(lsa_tree, &iface->lsa_tree); iface->crypt_seq_num = arc4random() & 0x0fffffff; Index: usr.sbin/ospfd/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/kroute.c,v retrieving revision 1.107 diff -u -p -r1.107 kroute.c --- usr.sbin/ospfd/kroute.c 27 Dec 2016 09:15:16 -0000 1.107 +++ usr.sbin/ospfd/kroute.c 21 Jun 2017 00:00:38 -0000 @@ -56,14 +56,14 @@ struct { } kr_state; struct kroute_node { - RB_ENTRY(kroute_node) entry; + RBT_ENTRY(kroute_node) entry; struct kroute_node *next; struct kroute r; int serial; }; struct kif_node { - RB_ENTRY(kif_node) entry; + RBT_ENTRY(kif_node) entry; TAILQ_HEAD(, kif_addr) addrs; struct kif k; }; @@ -71,8 +71,8 @@ struct kif_node { void kr_redist_remove(struct kroute_node *, struct kroute_node *); int kr_redist_eval(struct kroute *, struct kroute *); void kr_redistribute(struct kroute_node *); -int kroute_compare(struct kroute_node *, struct kroute_node *); -int kif_compare(struct kif_node *, struct kif_node *); +int kroute_compare(const struct kroute_node *, const struct kroute_node *); +int kif_compare(const struct kif_node *, const struct kif_node *); int kr_change_fib(struct kroute_node *, struct kroute *, int, int); int kr_delete_fib(struct kroute_node *); @@ -109,13 +109,13 @@ int rtmsg_process(char *, size_t); void kr_fib_reload_timer(int, short, void *); void kr_fib_reload_arm_timer(int); -RB_HEAD(kroute_tree, kroute_node) krt = RB_INITIALIZER(&krt); -RB_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare) -RB_GENERATE(kroute_tree, kroute_node, entry, kroute_compare) - -RB_HEAD(kif_tree, kif_node) kit = RB_INITIALIZER(&kit); -RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) -RB_GENERATE(kif_tree, kif_node, entry, kif_compare) +RBT_HEAD(kroute_tree, kroute_node) krt = RBT_INITIALIZER(krt); +RBT_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare); +RBT_GENERATE(kroute_tree, kroute_node, entry, kroute_compare); + +RBT_HEAD(kif_tree, kif_node) kit = RBT_INITIALIZER(&kit); +RBT_PROTOTYPE(kif_tree, kif_node, entry, kif_compare); +RBT_GENERATE(kif_tree, kif_node, entry, kif_compare); int kif_init(void) @@ -334,7 +334,7 @@ kr_fib_couple(void) kr_state.fib_sync = 1; - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (kr->r.priority == RTP_OSPF) for (kn = kr; kn != NULL; kn = kn->next) send_rtmsg(kr_state.fd, RTM_ADD, &kn->r); @@ -351,7 +351,7 @@ kr_fib_decouple(void) if (kr_state.fib_sync == 0) /* already decoupled */ return; - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (kr->r.priority == RTP_OSPF) for (kn = kr; kn != NULL; kn = kn->next) send_rtmsg(kr_state.fd, RTM_DELETE, &kn->r); @@ -398,8 +398,8 @@ kr_fib_reload() if (fetchifs(0) == -1 || fetchtable() == -1) return; - for (kr = RB_MIN(kroute_tree, &krt); kr != NULL; kr = krn) { - krn = RB_NEXT(kroute_tree, &krt, kr); + for (kr = RBT_MIN(kroute_tree, &krt); kr != NULL; kr = krn) { + krn = RBT_NEXT(kroute_tree, kr); do { kn = kr->next; @@ -442,7 +442,7 @@ kr_show_route(struct imsg *imsg) return; } memcpy(&flags, imsg->data, sizeof(flags)); - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (!flags || kr->r.flags & flags) { kn = kr; do { @@ -478,7 +478,7 @@ kr_ifinfo(char *ifname, pid_t pid) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (ifname == NULL || !strcmp(ifname, kif->k.ifname)) { main_imsg_compose_ospfe(IMSG_CTL_IFINFO, pid, &kif->k, sizeof(kif->k)); @@ -606,7 +606,7 @@ kr_reload(void) u_int32_t dummy; int r; - RB_FOREACH(kr, kroute_tree, &krt) { + RBT_FOREACH(kr, kroute_tree, &krt) { for (kn = kr; kn; kn = kn->next) { r = ospf_redistribute(&kn->r, &dummy); /* @@ -628,7 +628,7 @@ kr_reload(void) /* rb-tree compare */ int -kroute_compare(struct kroute_node *a, struct kroute_node *b) +kroute_compare(const struct kroute_node *a, const struct kroute_node *b) { if (ntohl(a->r.prefix.s_addr) < ntohl(b->r.prefix.s_addr)) return (-1); @@ -650,7 +650,7 @@ kroute_compare(struct kroute_node *a, st } int -kif_compare(struct kif_node *a, struct kif_node *b) +kif_compare(const struct kif_node *a, const struct kif_node *b) { return (b->k.ifindex - a->k.ifindex); } @@ -666,15 +666,15 @@ kroute_find(in_addr_t prefix, u_int8_t p s.r.prefixlen = prefixlen; s.r.priority = prio; - kn = RB_FIND(kroute_tree, &krt, &s); + kn = RBT_FIND(kroute_tree, &krt, &s); if (kn && prio == RTP_ANY) { - tmp = RB_PREV(kroute_tree, &krt, kn); + tmp = RBT_PREV(kroute_tree, kn); while (tmp) { if (kroute_compare(&s, tmp) == 0) kn = tmp; else break; - tmp = RB_PREV(kroute_tree, &krt, kn); + tmp = RBT_PREV(kroute_tree, kn); } } return (kn); @@ -703,7 +703,7 @@ kroute_insert(struct kroute_node *kr) kr->serial = kr_state.fib_serial; - if ((krh = RB_INSERT(kroute_tree, &krt, kr)) != NULL) { + if ((krh = RBT_INSERT(kroute_tree, &krt, kr)) != NULL) { /* * Multipath route, add at end of list. */ @@ -735,7 +735,7 @@ kroute_remove(struct kroute_node *kr) { struct kroute_node *krm; - if ((krm = RB_FIND(kroute_tree, &krt, kr)) == NULL) { + if ((krm = RBT_FIND(kroute_tree, &krt, kr)) == NULL) { log_warnx("kroute_remove failed to find %s/%u", inet_ntoa(kr->r.prefix), kr->r.prefixlen); return (-1); @@ -743,13 +743,13 @@ kroute_remove(struct kroute_node *kr) if (krm == kr) { /* head element */ - if (RB_REMOVE(kroute_tree, &krt, kr) == NULL) { + if (RBT_REMOVE(kroute_tree, &krt, kr) == NULL) { log_warnx("kroute_remove failed for %s/%u", inet_ntoa(kr->r.prefix), kr->r.prefixlen); return (-1); } if (kr->next != NULL) { - if (RB_INSERT(kroute_tree, &krt, kr->next) != NULL) { + if (RBT_INSERT(kroute_tree, &krt, kr->next) != NULL) { log_warnx("kroute_remove failed to add %s/%u", inet_ntoa(kr->r.prefix), kr->r.prefixlen); return (-1); @@ -780,7 +780,7 @@ kroute_clear(void) { struct kroute_node *kr; - while ((kr = RB_MIN(kroute_tree, &krt)) != NULL) + while ((kr = RBT_MIN(kroute_tree, &krt)) != NULL) kroute_remove(kr); } @@ -792,7 +792,7 @@ kif_find(u_short ifindex) bzero(&s, sizeof(s)); s.k.ifindex = ifindex; - return (RB_FIND(kif_tree, &kit, &s)); + return (RBT_FIND(kif_tree, &kit, &s)); } struct kif * @@ -801,7 +801,7 @@ kif_findname(char *ifname, struct in_add struct kif_node *kif; struct kif_addr *ka; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (!strcmp(ifname, kif->k.ifname)) { ka = TAILQ_FIRST(&kif->addrs); if (addr.s_addr != 0) { @@ -829,8 +829,8 @@ kif_insert(u_short ifindex) kif->k.ifindex = ifindex; TAILQ_INIT(&kif->addrs); - if (RB_INSERT(kif_tree, &kit, kif) != NULL) - fatalx("kif_insert: RB_INSERT"); + if (RBT_INSERT(kif_tree, &kit, kif) != NULL) + fatalx("kif_insert: RBT_INSERT"); return (kif); } @@ -840,8 +840,8 @@ kif_remove(struct kif_node *kif) { struct kif_addr *ka; - if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { - log_warnx("RB_REMOVE(kif_tree, &kit, kif)"); + if (RBT_REMOVE(kif_tree, &kit, kif) == NULL) { + log_warnx("RBT_REMOVE(kif_tree, &kit, kif)"); return (-1); } @@ -858,7 +858,7 @@ kif_clear(void) { struct kif_node *kif; - while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + while ((kif = RBT_MIN(kif_tree, &kit)) != NULL) kif_remove(kif); } @@ -942,7 +942,7 @@ protect_lo(void) kr->r.prefixlen = 8; kr->r.flags = F_KERNEL|F_CONNECTED; - if (RB_INSERT(kroute_tree, &krt, kr) != NULL) + if (RBT_INSERT(kroute_tree, &krt, kr) != NULL) free(kr); /* kernel route already there, no problem */ return (0); @@ -1026,7 +1026,7 @@ if_change(u_short ifindex, int flags, st kif->nh_reachable = reachable; /* update redistribute list */ - RB_FOREACH(kr, kroute_tree, &krt) { + RBT_FOREACH(kr, kroute_tree, &krt) { for (tkr = kr; tkr != NULL; tkr = tkr->next) { if (tkr->r.ifindex == ifindex) { if (reachable) Index: usr.sbin/ospfd/ospfd.h =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/ospfd.h,v retrieving revision 1.97 diff -u -p -r1.97 ospfd.h --- usr.sbin/ospfd/ospfd.h 24 Jan 2017 04:24:25 -0000 1.97 +++ usr.sbin/ospfd/ospfd.h 21 Jun 2017 00:00:38 -0000 @@ -154,7 +154,7 @@ SIMPLEQ_HEAD(redist_list, redistribute); struct vertex; struct rde_nbr; -RB_HEAD(lsa_tree, vertex); +RBT_HEAD(lsa_tree, vertex); struct area { LIST_ENTRY(area) entry; Index: usr.sbin/ospfd/ospfe.c =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/ospfe.c,v retrieving revision 1.99 diff -u -p -r1.99 ospfe.c --- usr.sbin/ospfd/ospfe.c 24 Jan 2017 04:24:25 -0000 1.99 +++ usr.sbin/ospfd/ospfe.c 21 Jun 2017 00:00:38 -0000 @@ -385,7 +385,7 @@ ospfe_dispatch_main(int fd, short event, LIST_INIT(&narea->iface_list); LIST_INIT(&narea->nbr_list); - RB_INIT(&narea->lsa_tree); + RBT_INIT(lsa_tree, &narea->lsa_tree); SIMPLEQ_INIT(&narea->redist_list); LIST_INSERT_HEAD(&nconf->area_list, narea, entry); @@ -398,7 +398,7 @@ ospfe_dispatch_main(int fd, short event, LIST_INIT(&niface->nbr_list); TAILQ_INIT(&niface->ls_ack_list); TAILQ_INIT(&niface->auth_md_list); - RB_INIT(&niface->lsa_tree); + RBT_INIT(lsa_tree, &niface->lsa_tree); niface->area = narea; LIST_INSERT_HEAD(&narea->iface_list, niface, entry); Index: usr.sbin/ospfd/rde.c =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/rde.c,v retrieving revision 1.108 diff -u -p -r1.108 rde.c --- usr.sbin/ospfd/rde.c 24 Jan 2017 04:24:25 -0000 1.108 +++ usr.sbin/ospfd/rde.c 21 Jun 2017 00:00:38 -0000 @@ -224,8 +224,8 @@ rde_shutdown(void) LIST_REMOVE(a, entry); area_del(a); } - for (v = RB_MIN(lsa_tree, &asext_tree); v != NULL; v = nv) { - nv = RB_NEXT(lsa_tree, &asext_tree, v); + for (v = RBT_MIN(lsa_tree, &asext_tree); v != NULL; v = nv) { + nv = RBT_NEXT(lsa_tree, v); vertex_free(v); } rde_asext_free(); @@ -697,7 +697,7 @@ rde_dispatch_parent(int fd, short event, LIST_INIT(&narea->iface_list); LIST_INIT(&narea->nbr_list); - RB_INIT(&narea->lsa_tree); + RBT_INIT(lsa_tree, &narea->lsa_tree); SIMPLEQ_INIT(&narea->redist_list); LIST_INSERT_HEAD(&nconf->area_list, narea, entry); @@ -717,7 +717,7 @@ rde_dispatch_parent(int fd, short event, LIST_INIT(&niface->nbr_list); TAILQ_INIT(&niface->ls_ack_list); TAILQ_INIT(&niface->auth_md_list); - RB_INIT(&niface->lsa_tree); + RBT_INIT(lsa_tree, &niface->lsa_tree); niface->area = narea; LIST_INSERT_HEAD(&narea->iface_list, niface, entry); @@ -847,7 +847,7 @@ rde_send_summary(pid_t pid) LIST_FOREACH(area, &rdeconf->area_list, entry) sumctl.num_area++; - RB_FOREACH(v, lsa_tree, &asext_tree) { + RBT_FOREACH(v, lsa_tree, &asext_tree) { sumctl.num_ext_lsa++; sumctl.ext_lsa_cksum += ntohs(v->lsa->hdr.ls_chksum); } @@ -885,7 +885,7 @@ rde_send_summary_area(struct area *area, if (nbr->state == NBR_STA_FULL && !nbr->self) sumareactl.num_adj_nbr++; - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { sumareactl.num_lsa++; sumareactl.lsa_cksum += ntohs(v->lsa->hdr.ls_chksum); } @@ -1125,20 +1125,21 @@ rde_req_list_free(struct rde_nbr *nbr) * as-external LSA handling */ struct asext_node { - RB_ENTRY(asext_node) entry; + RBT_ENTRY(asext_node) entry; struct kroute r; u_int32_t ls_id; }; -static __inline int asext_compare(struct asext_node *, struct asext_node *); +static __inline int asext_compare(const struct asext_node *, + const struct asext_node *); struct asext_node *asext_find(u_int32_t, u_int8_t); -RB_HEAD(asext_tree, asext_node) ast; -RB_PROTOTYPE(asext_tree, asext_node, entry, asext_compare) -RB_GENERATE(asext_tree, asext_node, entry, asext_compare) +RBT_HEAD(asext_tree, asext_node) ast; +RBT_PROTOTYPE(asext_tree, asext_node, entry, asext_compare); +RBT_GENERATE(asext_tree, asext_node, entry, asext_compare); static __inline int -asext_compare(struct asext_node *a, struct asext_node *b) +asext_compare(const struct asext_node *a, const struct asext_node *b) { if (ntohl(a->r.prefix.s_addr) < ntohl(b->r.prefix.s_addr)) return (-1); @@ -1159,7 +1160,7 @@ asext_find(u_int32_t addr, u_int8_t pref a.r.prefix.s_addr = addr; a.r.prefixlen = prefixlen; - return (RB_FIND(asext_tree, &ast, &a)); + return (RBT_FIND(asext_tree, &ast, &a)); } struct iface * @@ -1200,7 +1201,7 @@ rde_asext_get(struct kroute *kr) fatal("rde_asext_get"); bcopy(kr, &an->r, sizeof(*kr)); an->ls_id = kr->prefix.s_addr; - RB_INSERT(asext_tree, &ast, an); + RBT_INSERT(asext_tree, &ast, an); } else { /* the bcopy does not change the lookup key so it is save */ bcopy(kr, &an->r, sizeof(*kr)); @@ -1238,7 +1239,7 @@ rde_asext_get(struct kroute *kr) log_warnx("prefix %s/%d can not be " "redistributed, no unique ls_id found.", inet_ntoa(kr->prefix), kr->prefixlen); - RB_REMOVE(asext_tree, &ast, an); + RBT_REMOVE(asext_tree, &ast, an); free(an); return; } @@ -1294,7 +1295,7 @@ rde_asext_put(struct kroute *kr) lsa = orig_asext_lsa(kr, an->ls_id, MAX_AGE); lsa_merge(nbrself, lsa, v); - RB_REMOVE(asext_tree, &ast, an); + RBT_REMOVE(asext_tree, &ast, an); free(an); } @@ -1303,9 +1304,9 @@ rde_asext_free(void) { struct asext_node *an, *nan; - for (an = RB_MIN(asext_tree, &ast); an != NULL; an = nan) { - nan = RB_NEXT(asext_tree, &ast, an); - RB_REMOVE(asext_tree, &ast, an); + for (an = RBT_MIN(asext_tree, &ast); an != NULL; an = nan) { + nan = RBT_NEXT(asext_tree, an); + RBT_REMOVE(asext_tree, &ast, an); free(an); } } Index: usr.sbin/ospfd/rde.h =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/rde.h,v retrieving revision 1.39 diff -u -p -r1.39 rde.h --- usr.sbin/ospfd/rde.h 14 Mar 2015 02:22:09 -0000 1.39 +++ usr.sbin/ospfd/rde.h 21 Jun 2017 00:00:38 -0000 @@ -35,7 +35,7 @@ struct v_nexthop { TAILQ_HEAD(v_nexthead, v_nexthop); struct vertex { - RB_ENTRY(vertex) entry; + RBT_ENTRY(vertex) entry; TAILQ_ENTRY(vertex) cand; struct v_nexthead nexthop; struct event ev; @@ -86,7 +86,7 @@ struct rt_nexthop { }; struct rt_node { - RB_ENTRY(rt_node) entry; + RBT_ENTRY(rt_node) entry; TAILQ_HEAD(,rt_nexthop) nexthop; struct in_addr prefix; struct in_addr area; @@ -127,7 +127,7 @@ struct lsa *orig_sum_lsa(struct rt_node /* rde_lsdb.c */ void lsa_init(struct lsa_tree *); -int lsa_compare(struct vertex *, struct vertex *); +int lsa_compare(const struct vertex *, const struct vertex *); void vertex_free(struct vertex *); void vertex_nexthop_clear(struct vertex *); void vertex_nexthop_add(struct vertex *, struct vertex *, @@ -166,7 +166,7 @@ void stop_spf_timer(struct ospfd_conf void start_spf_holdtimer(struct ospfd_conf *); void rt_init(void); -int rt_compare(struct rt_node *, struct rt_node *); +int rt_compare(const struct rt_node *, const struct rt_node *); struct rt_node *rt_find(in_addr_t, u_int8_t, enum dst_type); int rt_insert(struct rt_node *); int rt_remove(struct rt_node *); @@ -174,6 +174,6 @@ void rt_clear(void); void rt_dump(struct in_addr, pid_t, u_int8_t); struct rt_node *rt_lookup(enum dst_type, in_addr_t); -RB_PROTOTYPE(lsa_tree, vertex, entry, lsa_compare) +RBT_PROTOTYPE(lsa_tree, vertex, entry, lsa_compare); #endif /* _RDE_H_ */ Index: usr.sbin/ospfd/rde_lsdb.c =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/rde_lsdb.c,v retrieving revision 1.50 diff -u -p -r1.50 rde_lsdb.c --- usr.sbin/ospfd/rde_lsdb.c 22 Nov 2015 13:09:10 -0000 1.50 +++ usr.sbin/ospfd/rde_lsdb.c 21 Jun 2017 00:00:38 -0000 @@ -36,16 +36,16 @@ void lsa_timeout(int, short, void *); void lsa_refresh(struct vertex *); int lsa_equal(struct lsa *, struct lsa *); -RB_GENERATE(lsa_tree, vertex, entry, lsa_compare) +RBT_GENERATE(lsa_tree, vertex, entry, lsa_compare); void lsa_init(struct lsa_tree *t) { - RB_INIT(t); + RBT_INIT(lsa_tree, t); } int -lsa_compare(struct vertex *a, struct vertex *b) +lsa_compare(const struct vertex *a, const struct vertex *b) { if (a->type < b->type) return (-1); @@ -95,7 +95,7 @@ vertex_get(struct lsa *lsa, struct rde_n void vertex_free(struct vertex *v) { - RB_REMOVE(lsa_tree, v->lsa_tree, v); + RBT_REMOVE(lsa_tree, v->lsa_tree, v); (void)evtimer_del(&v->ev); vertex_nexthop_clear(v); @@ -393,7 +393,7 @@ lsa_add(struct rde_nbr *nbr, struct lsa tree = &nbr->area->lsa_tree; new = vertex_get(lsa, nbr, tree); - old = RB_INSERT(lsa_tree, tree, new); + old = RBT_INSERT(lsa_tree, tree, new); if (old != NULL) { if (old->deleted && evtimer_pending(&old->ev, &tv)) { @@ -403,7 +403,7 @@ lsa_add(struct rde_nbr *nbr, struct lsa /* remove old LSA and insert new LSA with delay */ vertex_free(old); - RB_INSERT(lsa_tree, tree, new); + RBT_INSERT(lsa_tree, tree, new); new->deleted = 1; if (evtimer_add(&new->ev, &res) != 0) @@ -417,7 +417,7 @@ lsa_add(struct rde_nbr *nbr, struct lsa start_spf_timer(); } vertex_free(old); - RB_INSERT(lsa_tree, tree, new); + RBT_INSERT(lsa_tree, tree, new); } else { if (lsa->hdr.type != LSA_TYPE_EXTERNAL && lsa->hdr.type != LSA_TYPE_AS_OPAQ) @@ -519,7 +519,7 @@ lsa_find_tree(struct lsa_tree *tree, u_i key.adv_rtr = ntohl(adv_rtr); key.type = type; - v = RB_FIND(lsa_tree, tree, &key); + v = RBT_FIND(lsa_tree, tree, &key); /* LSA that are deleted are not findable */ if (v && v->deleted) @@ -538,7 +538,7 @@ lsa_find_net(struct area *area, u_int32_ struct vertex *v; /* XXX speed me up */ - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { if (v->lsa->hdr.type == LSA_TYPE_NETWORK && v->lsa->hdr.ls_id == ls_id) { /* LSA that are deleted are not findable */ @@ -573,7 +573,7 @@ lsa_snap(struct rde_nbr *nbr) struct vertex *v; do { - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { if (v->deleted) continue; switch (v->type) { @@ -609,7 +609,7 @@ lsa_dump(struct lsa_tree *tree, int imsg { struct vertex *v; - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { if (v->deleted) continue; lsa_age(v); @@ -788,8 +788,8 @@ lsa_remove_invalid_sums(struct area *are struct vertex *v, *nv; /* XXX speed me up */ - for (v = RB_MIN(lsa_tree, tree); v != NULL; v = nv) { - nv = RB_NEXT(lsa_tree, tree, v); + for (v = RBT_MIN(lsa_tree, tree); v != NULL; v = nv) { + nv = RBT_NEXT(lsa_tree, v); if ((v->type == LSA_TYPE_SUM_NETWORK || v->type == LSA_TYPE_SUM_ROUTER) && v->self && v->cost == LS_INFINITY && Index: usr.sbin/ospfd/rde_spf.c =================================================================== RCS file: /cvs/src/usr.sbin/ospfd/rde_spf.c,v retrieving revision 1.76 diff -u -p -r1.76 rde_spf.c --- usr.sbin/ospfd/rde_spf.c 22 Nov 2015 13:09:10 -0000 1.76 +++ usr.sbin/ospfd/rde_spf.c 21 Jun 2017 00:00:38 -0000 @@ -31,9 +31,9 @@ extern struct ospfd_conf *rdeconf; TAILQ_HEAD(, vertex) cand_list; -RB_HEAD(rt_tree, rt_node) rt; -RB_PROTOTYPE(rt_tree, rt_node, entry, rt_compare) -RB_GENERATE(rt_tree, rt_node, entry, rt_compare) +RBT_HEAD(rt_tree, rt_node) rt; +RBT_PROTOTYPE(rt_tree, rt_node, entry, rt_compare); +RBT_GENERATE(rt_tree, rt_node, entry, rt_compare); struct vertex *spf_root = NULL; void calc_nexthop(struct vertex *, struct vertex *, @@ -361,7 +361,7 @@ spf_tree_clr(struct area *area) struct lsa_tree *tree = &area->lsa_tree; struct vertex *v; - RB_FOREACH(v, lsa_tree, tree) { + RBT_FOREACH(v, lsa_tree, tree) { v->cost = LS_INFINITY; vertex_nexthop_clear(v); } @@ -529,7 +529,7 @@ spf_timer(int fd, short event, void *arg spf_calc(area); /* calculate route table */ - RB_FOREACH(v, lsa_tree, &area->lsa_tree) { + RBT_FOREACH(v, lsa_tree, &area->lsa_tree) { rt_calc(v, area, conf); } @@ -539,11 +539,11 @@ spf_timer(int fd, short event, void *arg /* calculate as-external routes, first invalidate them */ rt_invalidate(NULL); - RB_FOREACH(v, lsa_tree, &asext_tree) { + RBT_FOREACH(v, lsa_tree, &asext_tree) { asext_calc(v); } - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { LIST_FOREACH(area, &conf->area_list, entry) rde_summary_update(r, area); @@ -633,11 +633,11 @@ start_spf_holdtimer(struct ospfd_conf *c void rt_init(void) { - RB_INIT(&rt); + RBT_INIT(rt_tree, &rt); } int -rt_compare(struct rt_node *a, struct rt_node *b) +rt_compare(const struct rt_node *a, const struct rt_node *b) { if (ntohl(a->prefix.s_addr) < ntohl(b->prefix.s_addr)) return (-1); @@ -663,13 +663,13 @@ rt_find(in_addr_t prefix, u_int8_t prefi s.prefixlen = prefixlen; s.d_type = d_type; - return (RB_FIND(rt_tree, &rt, &s)); + return (RBT_FIND(rt_tree, &rt, &s)); } int rt_insert(struct rt_node *r) { - if (RB_INSERT(rt_tree, &rt, r) != NULL) { + if (RBT_INSERT(rt_tree, &rt, r) != NULL) { log_warnx("rt_insert failed for %s/%u", inet_ntoa(r->prefix), r->prefixlen); free(r); @@ -682,7 +682,7 @@ rt_insert(struct rt_node *r) int rt_remove(struct rt_node *r) { - if (RB_REMOVE(rt_tree, &rt, r) == NULL) { + if (RBT_REMOVE(rt_tree, &rt, r) == NULL) { log_warnx("rt_remove failed for %s/%u", inet_ntoa(r->prefix), r->prefixlen); return (-1); @@ -699,8 +699,8 @@ rt_invalidate(struct area *area) struct rt_node *r, *nr; struct rt_nexthop *rn, *nrn; - for (r = RB_MIN(rt_tree, &rt); r != NULL; r = nr) { - nr = RB_NEXT(rt_tree, &rt, r); + for (r = RBT_MIN(rt_tree, &rt); r != NULL; r = nr) { + nr = RBT_NEXT(rt_tree, r); if (area == NULL) { /* look only at as_ext routes */ if (r->p_type != PT_TYPE1_EXT && @@ -786,7 +786,7 @@ rt_clear(void) { struct rt_node *r; - while ((r = RB_MIN(rt_tree, &rt)) != NULL) + while ((r = RBT_MIN(rt_tree, &rt)) != NULL) rt_remove(r); } @@ -800,7 +800,7 @@ rt_dump(struct in_addr area, pid_t pid, clock_gettime(CLOCK_MONOTONIC, &now); - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { if (r->invalid) continue; Index: usr.sbin/procmap/procmap.c =================================================================== RCS file: /cvs/src/usr.sbin/procmap/procmap.c,v retrieving revision 1.63 diff -u -p -r1.63 procmap.c --- usr.sbin/procmap/procmap.c 16 Sep 2016 04:45:35 -0000 1.63 +++ usr.sbin/procmap/procmap.c 21 Jun 2017 00:00:39 -0000 @@ -580,10 +580,10 @@ load_vm_map_entries(kvm_t *kd, struct vm /* RBTs point at rb_entries inside nodes */ ld = load_vm_map_entries(kd, RBT_LEFT(uvm_map_addr, result), result); - result->daddrs.addr_entry.rbt_left = &ld->daddrs.addr_entry; + RBT_SET_LEFT(uvm_map_addr, result, ld); ld = load_vm_map_entries(kd, RBT_RIGHT(uvm_map_addr, result), result); - result->daddrs.addr_entry.rbt_right = &ld->daddrs.addr_entry; - result->daddrs.addr_entry.rbt_parent = &parent->daddrs.addr_entry; + RBT_SET_RIGHT(uvm_map_addr, result, ld); + RBT_SET_PARENT(uvm_map_addr, result, parent); return result; } Index: usr.sbin/rebound/rebound.c =================================================================== RCS file: /cvs/src/usr.sbin/rebound/rebound.c,v retrieving revision 1.84 diff -u -p -r1.84 rebound.c --- usr.sbin/rebound/rebound.c 31 May 2017 04:52:11 -0000 1.84 +++ usr.sbin/rebound/rebound.c 21 Jun 2017 00:00:39 -0000 @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -76,7 +77,7 @@ struct dnspacket { */ struct dnscache { TAILQ_ENTRY(dnscache) fifo; - RB_ENTRY(dnscache) cachenode; + RBT_ENTRY(dnscache) cachenode; struct dnspacket *req; size_t reqlen; struct dnspacket *resp; @@ -84,8 +85,8 @@ struct dnscache { struct timespec ts; }; static TAILQ_HEAD(, dnscache) cachefifo; -static RB_HEAD(cachetree, dnscache) cachetree; -RB_PROTOTYPE_STATIC(cachetree, dnscache, cachenode, cachecmp) +static RBT_HEAD(cachetree, dnscache) cachetree; +RBT_PROTOTYPE(cachetree, dnscache, cachenode, cachecmp); static int cachecount; static int cachemax; @@ -154,13 +155,13 @@ logerr(const char *msg, ...) } static int -cachecmp(struct dnscache *c1, struct dnscache *c2) +cachecmp(const struct dnscache *c1, const struct dnscache *c2) { if (c1->reqlen == c2->reqlen) return memcmp(c1->req, c2->req, c1->reqlen); return c1->reqlen < c2->reqlen ? -1 : 1; } -RB_GENERATE_STATIC(cachetree, dnscache, cachenode, cachecmp) +RBT_GENERATE(cachetree, dnscache, cachenode, cachecmp); static void lowercase(unsigned char *s) @@ -211,7 +212,7 @@ cachelookup(struct dnspacket *dnsreq, si key.reqlen = reqlen; key.req = dnsreq; - hit = RB_FIND(cachetree, &cachetree, &key); + hit = RBT_FIND(cachetree, &cachetree, &key); if (hit) cachehits += 1; @@ -246,7 +247,7 @@ static void freecacheent(struct dnscache *ent) { cachecount -= 1; - RB_REMOVE(cachetree, &cachetree, ent); + RBT_REMOVE(cachetree, &cachetree, ent); TAILQ_REMOVE(&cachefifo, ent, fifo); free(ent->req); free(ent->resp); @@ -433,7 +434,7 @@ sendreply(struct request *req) * other requests made at the same time. if we lose, abort. * if anything else goes wrong, though, we need to reverse. */ - if (RB_INSERT(cachetree, &cachetree, ent)) + if (RBT_INSERT(cachetree, &cachetree, ent)) return; ttl = minttl(resp, r); if (ttl == -1) @@ -442,7 +443,7 @@ sendreply(struct request *req) ent->ts.tv_sec += MINIMUM(ttl, 300); ent->resp = malloc(r); if (!ent->resp) { - RB_REMOVE(cachetree, &cachetree, ent); + RBT_REMOVE(cachetree, &cachetree, ent); return; } memcpy(ent->resp, buf, r); @@ -585,7 +586,7 @@ workerinit(void) TAILQ_INIT(&reqfifo); TAILQ_INIT(&cachefifo); - RB_INIT(&cachetree); + RBT_INIT(cachetree, &cachetree); if (!(pwd = getpwnam("_rebound"))) logerr("getpwnam failed"); Index: usr.sbin/relayd/relay_http.c =================================================================== RCS file: /cvs/src/usr.sbin/relayd/relay_http.c,v retrieving revision 1.66 diff -u -p -r1.66 relay_http.c --- usr.sbin/relayd/relay_http.c 28 May 2017 10:39:15 -0000 1.66 +++ usr.sbin/relayd/relay_http.c 21 Jun 2017 00:00:39 -0000 @@ -117,7 +117,7 @@ relay_httpdesc_init(struct ctl_relay_eve if ((desc = calloc(1, sizeof(*desc))) == NULL) return (-1); - RB_INIT(&desc->http_headers); + RBT_INIT(kvtree, &desc->http_headers); cre->desc = desc; return (0); @@ -1208,7 +1208,7 @@ relay_writeheader_http(struct ctl_relay_ struct kv *hdr, *kv; struct http_descriptor *desc = (struct http_descriptor *)cre->desc; - RB_FOREACH(hdr, kvtree, &desc->http_headers) { + RBT_FOREACH(hdr, kvtree, &desc->http_headers) { if (relay_writeheader_kv(dst, hdr) == -1) return (-1); TAILQ_FOREACH(kv, &hdr->kv_children, kv_entry) { Index: usr.sbin/relayd/relayd.c =================================================================== RCS file: /cvs/src/usr.sbin/relayd/relayd.c,v retrieving revision 1.169 diff -u -p -r1.169 relayd.c --- usr.sbin/relayd/relayd.c 31 May 2017 04:14:34 -0000 1.169 +++ usr.sbin/relayd/relayd.c 21 Jun 2017 00:00:39 -0000 @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -617,7 +618,7 @@ kv_add(struct kvtree *keys, char *key, c goto fail; TAILQ_INIT(&kv->kv_children); - if ((oldkv = RB_INSERT(kvtree, keys, kv)) != NULL) { + if ((oldkv = RBT_INSERT(kvtree, keys, kv)) != NULL) { /* * return error if the key should occur only once, * or add it to a list attached to the key's node. @@ -684,7 +685,7 @@ kv_delete(struct kvtree *keys, struct kv { struct kv *ckv; - RB_REMOVE(kvtree, keys, kv); + RBT_REMOVE(kvtree, keys, kv); /* Remove all children */ while ((ckv = TAILQ_FIRST(&kv->kv_children)) != NULL) { @@ -721,7 +722,7 @@ kv_purge(struct kvtree *keys) { struct kv *kv; - while ((kv = RB_MIN(kvtree, keys)) != NULL) + while ((kv = RBT_MIN(kvtree, keys)) != NULL) kv_delete(keys, kv); } @@ -801,25 +802,25 @@ kv_find(struct kvtree *keys, struct kv * if (kv->kv_flags & KV_FLAG_GLOBBING) { /* Test header key using shell globbing rules */ key = kv->kv_key == NULL ? "" : kv->kv_key; - RB_FOREACH(match, kvtree, keys) { + RBT_FOREACH(match, kvtree, keys) { if (fnmatch(key, match->kv_key, FNM_CASEFOLD) == 0) break; } } else { /* Fast tree-based lookup only works without globbing */ - match = RB_FIND(kvtree, keys, kv); + match = RBT_FIND(kvtree, keys, kv); } return (match); } int -kv_cmp(struct kv *a, struct kv *b) +kv_cmp(const struct kv *a, const struct kv *b) { return (strcasecmp(a->kv_key, b->kv_key)); } -RB_GENERATE(kvtree, kv, kv_node, kv_cmp); +RBT_GENERATE(kvtree, kv, kv_node, kv_cmp); int rule_add(struct protocol *proto, struct relay_rule *rule, const char *rulefile) Index: usr.sbin/relayd/relayd.h =================================================================== RCS file: /cvs/src/usr.sbin/relayd/relayd.h,v retrieving revision 1.240 diff -u -p -r1.240 relayd.h --- usr.sbin/relayd/relayd.h 27 May 2017 08:33:25 -0000 1.240 +++ usr.sbin/relayd/relayd.h 21 Jun 2017 00:00:39 -0000 @@ -301,7 +301,7 @@ enum digest_type { }; TAILQ_HEAD(kvlist, kv); -RB_HEAD(kvtree, kv); +RBT_HEAD(kvtree, kv); struct kv { char *kv_key; @@ -320,7 +320,7 @@ struct kv { struct kv *kv_parent; TAILQ_ENTRY(kv) kv_entry; - RB_ENTRY(kv) kv_node; + RBT_ENTRY(kv) kv_node; /* A few pointers used by the rule actions */ struct kv *kv_match; @@ -1306,7 +1306,7 @@ void relay_log(struct rsession *, char int kv_log(struct rsession *, struct kv *, u_int16_t, enum direction); struct kv *kv_find(struct kvtree *, struct kv *); -int kv_cmp(struct kv *, struct kv *); +int kv_cmp(const struct kv *, const struct kv *); int rule_add(struct protocol *, struct relay_rule *, const char *); void rule_delete(struct relay_rules *, struct relay_rule *); @@ -1314,7 +1314,7 @@ void rule_free(struct relay_rule *); struct relay_rule *rule_inherit(struct relay_rule *); void rule_settable(struct relay_rules *, struct relay_table *); -RB_PROTOTYPE(kvtree, kv, kv_node, kv_cmp); +RBT_PROTOTYPE(kvtree, kv, kv_node, kv_cmp); /* carp.c */ int carp_demote_init(char *, int); Index: usr.sbin/ripd/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/ripd/kroute.c,v retrieving revision 1.31 diff -u -p -r1.31 kroute.c --- usr.sbin/ripd/kroute.c 27 Sep 2015 17:32:36 -0000 1.31 +++ usr.sbin/ripd/kroute.c 21 Jun 2017 00:00:39 -0000 @@ -33,6 +33,7 @@ #include #include #include +#include #include #include @@ -50,18 +51,18 @@ struct { } kr_state; struct kroute_node { - RB_ENTRY(kroute_node) entry; + RBT_ENTRY(kroute_node) entry; struct kroute r; }; struct kif_node { - RB_ENTRY(kif_node) entry; + RBT_ENTRY(kif_node) entry; struct kif k; }; void kr_redistribute(int, struct kroute *); -int kroute_compare(struct kroute_node *, struct kroute_node *); -int kif_compare(struct kif_node *, struct kif_node *); +int kroute_compare(const struct kroute_node *, const struct kroute_node *); +int kif_compare(const struct kif_node *, const struct kif_node *); int kr_change_fib(struct kroute_node *, struct kroute *, int); struct kroute_node *kroute_find(in_addr_t, in_addr_t, u_int8_t); @@ -88,18 +89,18 @@ int dispatch_rtmsg(void); int fetchtable(void); int fetchifs(int); -RB_HEAD(kroute_tree, kroute_node) krt; -RB_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare) -RB_GENERATE(kroute_tree, kroute_node, entry, kroute_compare) - -RB_HEAD(kif_tree, kif_node) kit; -RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) -RB_GENERATE(kif_tree, kif_node, entry, kif_compare) +RBT_HEAD(kroute_tree, kroute_node) krt; +RBT_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare); +RBT_GENERATE(kroute_tree, kroute_node, entry, kroute_compare); + +RBT_HEAD(kif_tree, kif_node) kit; +RBT_PROTOTYPE(kif_tree, kif_node, entry, kif_compare); +RBT_GENERATE(kif_tree, kif_node, entry, kif_compare); int kif_init(void) { - RB_INIT(&kit); + RBT_INIT(kif_tree, &kit); if (fetchifs(0) == -1) return (-1); @@ -140,7 +141,7 @@ kr_init(int fs, u_int rdomain) kr_state.pid = getpid(); kr_state.rtseq = 1; - RB_INIT(&krt); + RBT_INIT(kroute_tree, &krt); if (fetchtable() == -1) return (-1); @@ -247,7 +248,7 @@ kr_fib_couple(void) kr_state.fib_sync = 1; - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (kr->r.priority == RTP_RIP) send_rtmsg(kr_state.fd, RTM_ADD, &kr->r); @@ -262,7 +263,7 @@ kr_fib_decouple(void) if (kr_state.fib_sync == 0) /* already decoupled */ return; - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (kr->r.priority == RTP_RIP) send_rtmsg(kr_state.fd, RTM_DELETE, &kr->r); @@ -292,7 +293,7 @@ kr_show_route(struct imsg *imsg) return; } memcpy(&flags, imsg->data, sizeof(flags)); - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (!flags || kr->r.flags & flags) { main_imsg_compose_ripe(IMSG_CTL_KROUTE, imsg->hdr.pid, &kr->r, sizeof(kr->r)); @@ -324,7 +325,7 @@ kr_ifinfo(char *ifname, pid_t pid) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (ifname == NULL || !strcmp(ifname, kif->k.ifname)) { main_imsg_compose_ripe(IMSG_CTL_IFINFO, pid, &kif->k, sizeof(kif->k)); @@ -382,7 +383,7 @@ dont_redistribute: /* rb-tree compare */ int -kroute_compare(struct kroute_node *a, struct kroute_node *b) +kroute_compare(const struct kroute_node *a, const struct kroute_node *b) { if (ntohl(a->r.prefix.s_addr) < ntohl(b->r.prefix.s_addr)) return (-1); @@ -405,7 +406,7 @@ kroute_compare(struct kroute_node *a, st } int -kif_compare(struct kif_node *a, struct kif_node *b) +kif_compare(const struct kif_node *a, const struct kif_node *b) { return (b->k.ifindex - a->k.ifindex); } @@ -420,15 +421,15 @@ kroute_find(in_addr_t prefix, in_addr_t s.r.netmask.s_addr = netmask; s.r.priority = prio; - kn = RB_FIND(kroute_tree, &krt, &s); + kn = RBT_FIND(kroute_tree, &krt, &s); if (kn && prio == RTP_ANY) { - tmp = RB_PREV(kroute_tree, &krt, kn); + tmp = RBT_PREV(kroute_tree, kn); while (tmp) { if (kroute_compare(&s, tmp) == 0) kn = tmp; else break; - tmp = RB_PREV(kroute_tree, &krt, kn); + tmp = RBT_PREV(kroute_tree, kn); } } @@ -438,7 +439,7 @@ kroute_find(in_addr_t prefix, in_addr_t int kroute_insert(struct kroute_node *kr) { - if (RB_INSERT(kroute_tree, &krt, kr) != NULL) { + if (RBT_INSERT(kroute_tree, &krt, kr) != NULL) { log_warnx("kroute_insert failed for %s/%u", inet_ntoa(kr->r.prefix), mask2prefixlen(kr->r.netmask.s_addr)); @@ -465,7 +466,7 @@ kroute_insert(struct kroute_node *kr) int kroute_remove(struct kroute_node *kr) { - if (RB_REMOVE(kroute_tree, &krt, kr) == NULL) { + if (RBT_REMOVE(kroute_tree, &krt, kr) == NULL) { log_warnx("kroute_remove failed for %s/%u", inet_ntoa(kr->r.prefix), mask2prefixlen(kr->r.netmask.s_addr)); @@ -484,7 +485,7 @@ kroute_clear(void) { struct kroute_node *kr; - while ((kr = RB_MIN(kroute_tree, &krt)) != NULL) + while ((kr = RBT_MIN(kroute_tree, &krt)) != NULL) kroute_remove(kr); } @@ -496,7 +497,7 @@ kif_find(int ifindex) bzero(&s, sizeof(s)); s.k.ifindex = ifindex; - return (RB_FIND(kif_tree, &kit, &s)); + return (RBT_FIND(kif_tree, &kit, &s)); } struct kif * @@ -504,7 +505,7 @@ kif_findname(char *ifname) { struct kif_node *kif; - RB_FOREACH(kif, kif_tree, &kit) + RBT_FOREACH(kif, kif_tree, &kit) if (!strcmp(ifname, kif->k.ifname)) return (&kif->k); @@ -514,8 +515,8 @@ kif_findname(char *ifname) int kif_insert(struct kif_node *kif) { - if (RB_INSERT(kif_tree, &kit, kif) != NULL) { - log_warnx("RB_INSERT(kif_tree, &kit, kif)"); + if (RBT_INSERT(kif_tree, &kit, kif) != NULL) { + log_warnx("RBT_INSERT(kif_tree, &kit, kif)"); free(kif); return (-1); } @@ -526,8 +527,8 @@ kif_insert(struct kif_node *kif) int kif_remove(struct kif_node *kif) { - if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { - log_warnx("RB_REMOVE(kif_tree, &kit, kif)"); + if (RBT_REMOVE(kif_tree, &kit, kif) == NULL) { + log_warnx("RBT_REMOVE(kif_tree, &kit, kif)"); return (-1); } @@ -540,7 +541,7 @@ kif_clear(void) { struct kif_node *kif; - while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + while ((kif = RBT_MIN(kif_tree, &kit)) != NULL) kif_remove(kif); } @@ -591,7 +592,7 @@ protect_lo(void) kr->r.netmask.s_addr = htonl(IN_CLASSA_NET); kr->r.flags = F_KERNEL|F_CONNECTED; - if (RB_INSERT(kroute_tree, &krt, kr) != NULL) + if (RBT_INSERT(kroute_tree, &krt, kr) != NULL) free(kr); /* kernel route already there, no problem */ return (0); @@ -679,7 +680,7 @@ if_change(u_short ifindex, int flags, st main_imsg_compose_ripe(IMSG_IFINFO, 0, &kif->k, sizeof(kif->k)); /* update redistribute list */ - RB_FOREACH(kr, kroute_tree, &krt) + RBT_FOREACH(kr, kroute_tree, &krt) if (kr->r.ifindex == ifindex) { if (reachable) kr->r.flags &= ~F_DOWN; Index: usr.sbin/ripd/rde.h =================================================================== RCS file: /cvs/src/usr.sbin/ripd/rde.h,v retrieving revision 1.4 diff -u -p -r1.4 rde.h --- usr.sbin/ripd/rde.h 24 Oct 2007 20:38:03 -0000 1.4 +++ usr.sbin/ripd/rde.h 21 Jun 2017 00:00:39 -0000 @@ -28,7 +28,7 @@ #include struct rt_node { - RB_ENTRY(rt_node) entry; + RBT_ENTRY(rt_node) entry; struct event timeout_timer; struct event garbage_timer; struct in_addr prefix; @@ -48,7 +48,7 @@ int rde_imsg_compose_ripe(int, u_int32 /* rde_rib.c */ void rt_init(void); -int rt_compare(struct rt_node *, struct rt_node *); +int rt_compare(const struct rt_node *, const struct rt_node *); struct rt_node *rt_find(in_addr_t, in_addr_t); struct rt_node *rt_new_kr(struct kroute *); struct rt_node *rt_new_rr(struct rip_route *, u_int8_t); Index: usr.sbin/ripd/rde_rib.c =================================================================== RCS file: /cvs/src/usr.sbin/ripd/rde_rib.c,v retrieving revision 1.5 diff -u -p -r1.5 rde_rib.c --- usr.sbin/ripd/rde_rib.c 24 Oct 2007 20:38:03 -0000 1.5 +++ usr.sbin/ripd/rde_rib.c 21 Jun 2017 00:00:39 -0000 @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -38,9 +39,9 @@ #include "rde.h" extern struct ripd_conf *rdeconf; -RB_HEAD(rt_tree, rt_node) rt; -RB_PROTOTYPE(rt_tree, rt_node, entry, rt_compare) -RB_GENERATE(rt_tree, rt_node, entry, rt_compare) +RBT_HEAD(rt_tree, rt_node) rt; +RBT_PROTOTYPE(rt_tree, rt_node, entry, rt_compare); +RBT_GENERATE(rt_tree, rt_node, entry, rt_compare); void route_action_timeout(int, short, void *); void route_action_garbage(int, short, void *); @@ -116,11 +117,11 @@ route_reset_timers(struct rt_node *r) void rt_init(void) { - RB_INIT(&rt); + RBT_INIT(rt_tree, &rt); } int -rt_compare(struct rt_node *a, struct rt_node *b) +rt_compare(const struct rt_node *a, const struct rt_node *b) { if (ntohl(a->prefix.s_addr) < ntohl(b->prefix.s_addr)) return (-1); @@ -142,7 +143,7 @@ rt_find(in_addr_t prefix, in_addr_t netm s.prefix.s_addr = prefix; s.netmask.s_addr = netmask; - return (RB_FIND(rt_tree, &rt, &s)); + return (RBT_FIND(rt_tree, &rt, &s)); } struct rt_node * @@ -190,7 +191,7 @@ rt_new_rr(struct rip_route *e, u_int8_t int rt_insert(struct rt_node *r) { - if (RB_INSERT(rt_tree, &rt, r) != NULL) { + if (RBT_INSERT(rt_tree, &rt, r) != NULL) { log_warnx("rt_insert failed for %s/%u", inet_ntoa(r->prefix), mask2prefixlen(r->netmask.s_addr)); free(r); @@ -203,7 +204,7 @@ rt_insert(struct rt_node *r) int rt_remove(struct rt_node *r) { - if (RB_REMOVE(rt_tree, &rt, r) == NULL) { + if (RBT_REMOVE(rt_tree, &rt, r) == NULL) { log_warnx("rt_remove failed for %s/%u", inet_ntoa(r->prefix), mask2prefixlen(r->netmask.s_addr)); return (-1); @@ -221,7 +222,7 @@ rt_snap(u_int32_t peerid) bzero(&rr, sizeof(rr)); - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { rr.address = r->prefix; rr.mask = r->netmask; rr.nexthop = r->nexthop; @@ -239,7 +240,7 @@ rt_dump(pid_t pid) struct rt_node *r; static struct ctl_rt rtctl; - RB_FOREACH(r, rt_tree, &rt) { + RBT_FOREACH(r, rt_tree, &rt) { rtctl.prefix.s_addr = r->prefix.s_addr; rtctl.netmask.s_addr = r->netmask.s_addr; rtctl.nexthop.s_addr = r->nexthop.s_addr; @@ -267,6 +268,6 @@ rt_clear(void) { struct rt_node *r; - while ((r = RB_MIN(rt_tree, &rt)) != NULL) + while ((r = RBT_MIN(rt_tree, &rt)) != NULL) rt_remove(r); } Index: usr.sbin/smtpd/aliases.c =================================================================== RCS file: /cvs/src/usr.sbin/smtpd/aliases.c,v retrieving revision 1.71 diff -u -p -r1.71 aliases.c --- usr.sbin/smtpd/aliases.c 31 Aug 2016 10:18:08 -0000 1.71 +++ usr.sbin/smtpd/aliases.c 21 Jun 2017 00:00:39 -0000 @@ -72,7 +72,7 @@ aliases_get(struct expand *expand, const expand: /* foreach node in table_alias expandtree, we merge */ nbaliases = 0; - RB_FOREACH(xn, expandtree, &lk.expand->tree) { + RBT_FOREACH(xn, expandtree, &lk.expand->tree) { if (xn->type == EXPAND_INCLUDE) nbaliases += aliases_expand_include(expand, xn->u.buffer); @@ -183,7 +183,7 @@ aliases_virtual_get(struct expand *expan expand: /* foreach node in table_virtual expand, we merge */ nbaliases = 0; - RB_FOREACH(xn, expandtree, &lk.expand->tree) { + RBT_FOREACH(xn, expandtree, &lk.expand->tree) { if (xn->type == EXPAND_INCLUDE) nbaliases += aliases_expand_include(expand, xn->u.buffer); Index: usr.sbin/smtpd/expand.c =================================================================== RCS file: /cvs/src/usr.sbin/smtpd/expand.c,v retrieving revision 1.29 diff -u -p -r1.29 expand.c --- usr.sbin/smtpd/expand.c 28 Dec 2015 22:08:30 -0000 1.29 +++ usr.sbin/smtpd/expand.c 21 Jun 2017 00:00:39 -0000 @@ -28,6 +28,7 @@ #include #include #include +#include #include #include "smtpd.h" @@ -38,7 +39,7 @@ static const char *expandnode_info(struc struct expandnode * expand_lookup(struct expand *expand, struct expandnode *key) { - return RB_FIND(expandtree, &expand->tree, key); + return RBT_FIND(expandtree, &expand->tree, key); } int @@ -48,7 +49,7 @@ expand_to_text(struct expand *expand, ch buf[0] = '\0'; - RB_FOREACH(xn, expandtree, &expand->tree) { + RBT_FOREACH(xn, expandtree, &expand->tree) { if (buf[0]) (void)strlcat(buf, ", ", sz); if (strlcat(buf, expandnode_to_text(xn), sz) >= sz) @@ -90,7 +91,7 @@ expand_insert(struct expand *expand, str xn->depth = xn->parent->depth + 1; else xn->depth = 0; - RB_INSERT(expandtree, &expand->tree, xn); + RBT_INSERT(expandtree, &expand->tree, xn); if (expand->queue) TAILQ_INSERT_TAIL(expand->queue, xn, tq_entry); expand->nb_nodes++; @@ -107,8 +108,8 @@ expand_clear(struct expand *expand) while ((xn = TAILQ_FIRST(expand->queue))) TAILQ_REMOVE(expand->queue, xn, tq_entry); - while ((xn = RB_ROOT(&expand->tree)) != NULL) { - RB_REMOVE(expandtree, &expand->tree, xn); + while ((xn = RBT_ROOT(expandtree, &expand->tree)) != NULL) { + RBT_REMOVE(expandtree, &expand->tree, xn); free(xn); } } @@ -123,7 +124,7 @@ expand_free(struct expand *expand) } int -expand_cmp(struct expandnode *e1, struct expandnode *e2) +expand_cmp(const struct expandnode *e1, const struct expandnode *e2) { struct expandnode *p1, *p2; int r; @@ -326,4 +327,4 @@ expandnode_info(struct expandnode *e) return buffer; } -RB_GENERATE(expandtree, expandnode, entry, expand_cmp); +RBT_GENERATE(expandtree, expandnode, entry, expand_cmp); Index: usr.sbin/smtpd/lka_session.c =================================================================== RCS file: /cvs/src/usr.sbin/smtpd/lka_session.c,v retrieving revision 1.81 diff -u -p -r1.81 lka_session.c --- usr.sbin/smtpd/lka_session.c 26 May 2017 21:30:00 -0000 1.81 +++ usr.sbin/smtpd/lka_session.c 21 Jun 2017 00:00:39 -0000 @@ -83,7 +83,7 @@ lka_session(uint64_t id, struct envelope lks = xcalloc(1, sizeof(*lks), "lka_session"); lks->id = id; - RB_INIT(&lks->expand.tree); + RBT_INIT(expandtree, &lks->expand.tree); TAILQ_INIT(&lks->deliverylist); tree_xset(&sessions, lks->id, lks); Index: usr.sbin/smtpd/smtpd.h =================================================================== RCS file: /cvs/src/usr.sbin/smtpd/smtpd.h,v retrieving revision 1.532 diff -u -p -r1.532 smtpd.h --- usr.sbin/smtpd/smtpd.h 26 May 2017 21:30:00 -0000 1.532 +++ usr.sbin/smtpd/smtpd.h 21 Jun 2017 00:00:39 -0000 @@ -457,7 +457,7 @@ enum expand_type { }; struct expandnode { - RB_ENTRY(expandnode) entry; + RBT_ENTRY(expandnode) entry; TAILQ_ENTRY(expandnode) tq_entry; enum expand_type type; int sameuser; @@ -479,7 +479,7 @@ struct expandnode { }; struct expand { - RB_HEAD(expandtree, expandnode) tree; + RBT_HEAD(expandtree, expandnode) tree; TAILQ_HEAD(xnodes, expandnode) *queue; int alias; size_t nb_nodes; @@ -1187,14 +1187,14 @@ int envelope_dump_buffer(const struct en /* expand.c */ -int expand_cmp(struct expandnode *, struct expandnode *); +int expand_cmp(const struct expandnode *, const struct expandnode *); void expand_insert(struct expand *, struct expandnode *); struct expandnode *expand_lookup(struct expand *, struct expandnode *); void expand_clear(struct expand *); void expand_free(struct expand *); int expand_line(struct expand *, const char *, int); int expand_to_text(struct expand *, char *, size_t); -RB_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); +RBT_PROTOTYPE(expandtree, expandnode, nodes, expand_cmp); /* filter.c */ Index: usr.sbin/smtpd/stat_ramstat.c =================================================================== RCS file: /cvs/src/usr.sbin/smtpd/stat_ramstat.c,v retrieving revision 1.10 diff -u -p -r1.10 stat_ramstat.c --- usr.sbin/smtpd/stat_ramstat.c 20 Jan 2015 17:37:54 -0000 1.10 +++ usr.sbin/smtpd/stat_ramstat.c 21 Jun 2017 00:00:39 -0000 @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -40,12 +41,13 @@ static void ramstat_set(const char *, co static int ramstat_iter(void **, char **, struct stat_value *); struct ramstat_entry { - RB_ENTRY(ramstat_entry) entry; + RBT_ENTRY(ramstat_entry) + entry; char key[STAT_KEY_SIZE]; struct stat_value value; }; -RB_HEAD(stats_tree, ramstat_entry) stats; -RB_PROTOTYPE(stats_tree, ramstat_entry, entry, ramstat_entry_cmp); +RBT_HEAD(stats_tree, ramstat_entry) stats; +RBT_PROTOTYPE(stats_tree, ramstat_entry, entry, ramstat_entry_cmp); struct stat_backend stat_backend_ramstat = { ramstat_init, @@ -61,7 +63,7 @@ ramstat_init(void) { log_trace(TRACE_STAT, "ramstat: init"); - RB_INIT(&stats); + RBT_INIT(stats_tree, &stats); /* ramstat_set() should be called for each key we want * to have displayed by smtpctl show stats at startup. @@ -82,11 +84,11 @@ ramstat_increment(const char *name, size log_trace(TRACE_STAT, "ramstat: increment: %s", name); (void)strlcpy(lk.key, name, sizeof (lk.key)); - np = RB_FIND(stats_tree, &stats, &lk); + np = RBT_FIND(stats_tree, &stats, &lk); if (np == NULL) { np = xcalloc(1, sizeof *np, "ramstat_increment"); (void)strlcpy(np->key, name, sizeof (np->key)); - RB_INSERT(stats_tree, &stats, np); + RBT_INSERT(stats_tree, &stats, np); } log_trace(TRACE_STAT, "ramstat: %s (%p): %zd -> %zd", name, name, np->value.u.counter, np->value.u.counter + val); @@ -100,11 +102,11 @@ ramstat_decrement(const char *name, size log_trace(TRACE_STAT, "ramstat: decrement: %s", name); (void)strlcpy(lk.key, name, sizeof (lk.key)); - np = RB_FIND(stats_tree, &stats, &lk); + np = RBT_FIND(stats_tree, &stats, &lk); if (np == NULL) { np = xcalloc(1, sizeof *np, "ramstat_decrement"); (void)strlcpy(np->key, name, sizeof (np->key)); - RB_INSERT(stats_tree, &stats, np); + RBT_INSERT(stats_tree, &stats, np); } log_trace(TRACE_STAT, "ramstat: %s (%p): %zd -> %zd", name, name, np->value.u.counter, np->value.u.counter - val); @@ -118,11 +120,11 @@ ramstat_set(const char *name, const stru log_trace(TRACE_STAT, "ramstat: set: %s", name); (void)strlcpy(lk.key, name, sizeof (lk.key)); - np = RB_FIND(stats_tree, &stats, &lk); + np = RBT_FIND(stats_tree, &stats, &lk); if (np == NULL) { np = xcalloc(1, sizeof *np, "ramstat_set"); (void)strlcpy(np->key, name, sizeof (np->key)); - RB_INSERT(stats_tree, &stats, np); + RBT_INSERT(stats_tree, &stats, np); } log_trace(TRACE_STAT, "ramstat: %s: n/a -> n/a", name); np->value = *val; @@ -134,13 +136,13 @@ ramstat_iter(void **iter, char **name, s struct ramstat_entry *np; log_trace(TRACE_STAT, "ramstat: iter"); - if (RB_EMPTY(&stats)) + if (RBT_EMPTY(stats_tree, &stats)) return 0; if (*iter == NULL) - np = RB_MIN(stats_tree, &stats); + np = RBT_MIN(stats_tree, &stats); else - np = RB_NEXT(stats_tree, &stats, *iter); + np = RBT_NEXT(stats_tree, *iter); *iter = np; if (np == NULL) @@ -153,9 +155,10 @@ ramstat_iter(void **iter, char **name, s static int -ramstat_entry_cmp(struct ramstat_entry *e1, struct ramstat_entry *e2) +ramstat_entry_cmp(const struct ramstat_entry *e1, + const struct ramstat_entry *e2) { return strcmp(e1->key, e2->key); } -RB_GENERATE(stats_tree, ramstat_entry, entry, ramstat_entry_cmp); +RBT_GENERATE(stats_tree, ramstat_entry, entry, ramstat_entry_cmp); Index: usr.sbin/snmpd/ber.c =================================================================== RCS file: /cvs/src/usr.sbin/snmpd/ber.c,v retrieving revision 1.31 diff -u -p -r1.31 ber.c --- usr.sbin/snmpd/ber.c 5 Mar 2016 03:31:36 -0000 1.31 +++ usr.sbin/snmpd/ber.c 21 Jun 2017 00:00:39 -0000 @@ -1298,7 +1298,7 @@ ber_read(struct ber *ber, void *buf, siz } int -ber_oid_cmp(struct ber_oid *a, struct ber_oid *b) +ber_oid_cmp(const struct ber_oid *a, const struct ber_oid *b) { size_t i; for (i = 0; i < BER_MAX_OID_LEN; i++) { Index: usr.sbin/snmpd/ber.h =================================================================== RCS file: /cvs/src/usr.sbin/snmpd/ber.h,v retrieving revision 1.9 diff -u -p -r1.9 ber.h --- usr.sbin/snmpd/ber.h 1 Oct 2013 12:41:47 -0000 1.9 +++ usr.sbin/snmpd/ber.h 21 Jun 2017 00:00:39 -0000 @@ -135,7 +135,8 @@ void ber_set_application(struct ber * void ber_set_writecallback(struct ber_element *, void (*)(void *, size_t), void *); void ber_free(struct ber *); -int ber_oid_cmp(struct ber_oid *, struct ber_oid *); +int ber_oid_cmp(const struct ber_oid *, + const struct ber_oid *); __END_DECLS Index: usr.sbin/snmpd/kroute.c =================================================================== RCS file: /cvs/src/usr.sbin/snmpd/kroute.c,v retrieving revision 1.34 diff -u -p -r1.34 kroute.c --- usr.sbin/snmpd/kroute.c 28 Oct 2016 08:01:53 -0000 1.34 +++ usr.sbin/snmpd/kroute.c 21 Jun 2017 00:00:39 -0000 @@ -57,27 +57,29 @@ struct { } kr_state; struct kroute_node { - RB_ENTRY(kroute_node) entry; + RBT_ENTRY(kroute_node) entry; struct kroute r; struct kroute_node *next; }; struct kroute6_node { - RB_ENTRY(kroute6_node) entry; + RBT_ENTRY(kroute6_node) entry; struct kroute6 r; struct kroute6_node *next; }; struct kif_node { - RB_ENTRY(kif_node) entry; + RBT_ENTRY(kif_node) entry; TAILQ_HEAD(, kif_addr) addrs; TAILQ_HEAD(, kif_arp) arps; struct kif k; }; -int kroute_compare(struct kroute_node *, struct kroute_node *); -int kroute6_compare(struct kroute6_node *, struct kroute6_node *); -int kif_compare(struct kif_node *, struct kif_node *); +int kroute_compare(const struct kroute_node *, + const struct kroute_node *); +int kroute6_compare(const struct kroute6_node *, + const struct kroute6_node *); +int kif_compare(const struct kif_node *, const struct kif_node *); void ktable_init(void); int ktable_new(u_int, u_int); @@ -113,7 +115,8 @@ void kif_clear(void); struct kif *kif_update(u_short, int, struct if_data *, struct sockaddr_dl *); -int ka_compare(struct kif_addr *, struct kif_addr *); +int ka_compare(const struct kif_addr *, + const struct kif_addr *); void ka_insert(u_short, struct kif_addr *); struct kif_addr *ka_find(struct sockaddr *); int ka_remove(struct kif_addr *); @@ -139,19 +142,19 @@ int rtmsg_process(char *, int); int dispatch_rtmsg_addr(struct ktable *, struct rt_msghdr *, struct sockaddr *[RTAX_MAX]); -RB_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare) -RB_GENERATE(kroute_tree, kroute_node, entry, kroute_compare) +RBT_PROTOTYPE(kroute_tree, kroute_node, entry, kroute_compare); +RBT_GENERATE(kroute_tree, kroute_node, entry, kroute_compare); -RB_PROTOTYPE(kroute6_tree, kroute6_node, entry, kroute6_compare) -RB_GENERATE(kroute6_tree, kroute6_node, entry, kroute6_compare) +RBT_PROTOTYPE(kroute6_tree, kroute6_node, entry, kroute6_compare); +RBT_GENERATE(kroute6_tree, kroute6_node, entry, kroute6_compare); -RB_HEAD(kif_tree, kif_node) kit; -RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare) -RB_GENERATE(kif_tree, kif_node, entry, kif_compare) - -RB_HEAD(ka_tree, kif_addr) kat; -RB_PROTOTYPE(ka_tree, kif_addr, node, ka_compare) -RB_GENERATE(ka_tree, kif_addr, node, ka_compare) +RBT_HEAD(kif_tree, kif_node) kit; +RBT_PROTOTYPE(kif_tree, kif_node, entry, kif_compare); +RBT_GENERATE(kif_tree, kif_node, entry, kif_compare); + +RBT_HEAD(ka_tree, kif_addr) kat; +RBT_PROTOTYPE(ka_tree, kif_addr, node, ka_compare); +RBT_GENERATE(ka_tree, kif_addr, node, ka_compare); void kr_init(void) @@ -193,8 +196,8 @@ kr_init(void) sizeof(tid)) == -1) log_warn("%s: ROUTE_TABLEFILTER", __func__); - RB_INIT(&kit); - RB_INIT(&kat); + RBT_INIT(kif_tree, &kit); + RBT_INIT(ka_tree, &kat); if (fetchifs(0) == -1) fatalx("kr_init: fetchifs"); @@ -248,8 +251,8 @@ ktable_new(u_int rtableid, u_int rdomid) } /* initialize structure ... */ - RB_INIT(&kt->krt); - RB_INIT(&kt->krt6); + RBT_INIT(kroute_tree, &kt->krt); + RBT_INIT(kroute6_tree, &kt->krt6); kt->rtableid = rtableid; kt->rdomain = rdomid; @@ -375,7 +378,7 @@ kr_routenumber(void) /* rb-tree compare */ int -kroute_compare(struct kroute_node *a, struct kroute_node *b) +kroute_compare(const struct kroute_node *a, const struct kroute_node *b) { if (ntohl(a->r.prefix.s_addr) < ntohl(b->r.prefix.s_addr)) return (-1); @@ -397,7 +400,7 @@ kroute_compare(struct kroute_node *a, st } int -kroute6_compare(struct kroute6_node *a, struct kroute6_node *b) +kroute6_compare(const struct kroute6_node *a, const struct kroute6_node *b) { int i; @@ -424,13 +427,13 @@ kroute6_compare(struct kroute6_node *a, } int -kif_compare(struct kif_node *a, struct kif_node *b) +kif_compare(const struct kif_node *a, const struct kif_node *b) { return (a->k.if_index - b->k.if_index); } int -ka_compare(struct kif_addr *a, struct kif_addr *b) +ka_compare(const struct kif_addr *a, const struct kif_addr *b) { if (a->addr.sa.sa_family < b->addr.sa.sa_family) return (-1); @@ -451,15 +454,15 @@ kroute_find(struct ktable *kt, in_addr_t s.r.prefixlen = prefixlen; s.r.priority = prio; - kn = RB_FIND(kroute_tree, &kt->krt, &s); + kn = RBT_FIND(kroute_tree, &kt->krt, &s); if (kn && prio == RTP_ANY) { - tmp = RB_PREV(kroute_tree, &kt->krt, kn); + tmp = RBT_PREV(kroute_tree, kn); while (tmp) { if (kroute_compare(&s, tmp) == 0) kn = tmp; else break; - tmp = RB_PREV(kroute_tree, &kt->krt, kn); + tmp = RBT_PREV(kroute_tree, kn); } } return (kn); @@ -490,7 +493,7 @@ kroute_insert(struct ktable *kt, struct { struct kroute_node *krm; - if ((krm = RB_INSERT(kroute_tree, &kt->krt, kr)) != NULL) { + if ((krm = RBT_INSERT(kroute_tree, &kt->krt, kr)) != NULL) { /* multipath route, add at end of list */ while (krm->next != NULL) krm = krm->next; @@ -507,7 +510,7 @@ kroute_remove(struct ktable *kt, struct { struct kroute_node *krm; - if ((krm = RB_FIND(kroute_tree, &kt->krt, kr)) == NULL) { + if ((krm = RBT_FIND(kroute_tree, &kt->krt, kr)) == NULL) { log_warnx("%s: failed to find %s/%u", __func__, inet_ntoa(kr->r.prefix), kr->r.prefixlen); return (-1); @@ -515,13 +518,13 @@ kroute_remove(struct ktable *kt, struct if (krm == kr) { /* head element */ - if (RB_REMOVE(kroute_tree, &kt->krt, kr) == NULL) { + if (RBT_REMOVE(kroute_tree, &kt->krt, kr) == NULL) { log_warnx("%s: failed for %s/%u", __func__, inet_ntoa(kr->r.prefix), kr->r.prefixlen); return (-1); } if (kr->next != NULL) { - if (RB_INSERT(kroute_tree, &kt->krt, kr->next) + if (RBT_INSERT(kroute_tree, &kt->krt, kr->next) != NULL) { log_warnx("%s: failed to add %s/%u", __func__, inet_ntoa(kr->r.prefix), kr->r.prefixlen); @@ -550,7 +553,7 @@ kroute_clear(struct ktable *kt) { struct kroute_node *kr; - while ((kr = RB_MIN(kroute_tree, &kt->krt)) != NULL) + while ((kr = RBT_MIN(kroute_tree, &kt->krt)) != NULL) kroute_remove(kt, kr); } @@ -565,15 +568,15 @@ kroute6_find(struct ktable *kt, const st s.r.prefixlen = prefixlen; s.r.priority = prio; - kn6 = RB_FIND(kroute6_tree, &kt->krt6, &s); + kn6 = RBT_FIND(kroute6_tree, &kt->krt6, &s); if (kn6 && prio == RTP_ANY) { - tmp = RB_PREV(kroute6_tree, &kt->krt6, kn6); + tmp = RBT_PREV(kroute6_tree, kn6); while (tmp) { if (kroute6_compare(&s, tmp) == 0) kn6 = tmp; else break; - tmp = RB_PREV(kroute6_tree, &kt->krt6, kn6); + tmp = RBT_PREV(kroute6_tree, kn6); } } return (kn6); @@ -604,7 +607,7 @@ kroute6_insert(struct ktable *kt, struct { struct kroute6_node *krm; - if ((krm = RB_INSERT(kroute6_tree, &kt->krt6, kr)) != NULL) { + if ((krm = RBT_INSERT(kroute6_tree, &kt->krt6, kr)) != NULL) { /* multipath route, add at end of list */ while (krm->next != NULL) krm = krm->next; @@ -621,7 +624,7 @@ kroute6_remove(struct ktable *kt, struct { struct kroute6_node *krm; - if ((krm = RB_FIND(kroute6_tree, &kt->krt6, kr)) == NULL) { + if ((krm = RBT_FIND(kroute6_tree, &kt->krt6, kr)) == NULL) { log_warnx("%s: failed for %s/%u", __func__, log_in6addr(&kr->r.prefix), kr->r.prefixlen); return (-1); @@ -629,13 +632,13 @@ kroute6_remove(struct ktable *kt, struct if (krm == kr) { /* head element */ - if (RB_REMOVE(kroute6_tree, &kt->krt6, kr) == NULL) { + if (RBT_REMOVE(kroute6_tree, &kt->krt6, kr) == NULL) { log_warnx("%s: failed for %s/%u", __func__, log_in6addr(&kr->r.prefix), kr->r.prefixlen); return (-1); } if (kr->next != NULL) { - if (RB_INSERT(kroute6_tree, &kt->krt6, kr->next) != + if (RBT_INSERT(kroute6_tree, &kt->krt6, kr->next) != NULL) { log_warnx("%s: failed to add %s/%u", __func__, log_in6addr(&kr->r.prefix), @@ -666,7 +669,7 @@ kroute6_clear(struct ktable *kt) { struct kroute6_node *kr; - while ((kr = RB_MIN(kroute6_tree, &kt->krt6)) != NULL) + while ((kr = RBT_MIN(kroute6_tree, &kt->krt6)) != NULL) kroute6_remove(kt, kr); } @@ -715,7 +718,7 @@ karp_find(struct sockaddr *sa, u_short i * want to look for the address on all available * interfaces. */ - RB_FOREACH(kn, kif_tree, &kit) { + RBT_FOREACH(kn, kif_tree, &kit) { if ((ka = karp_search(kn, &s)) != NULL) break; } @@ -789,12 +792,12 @@ kif_find(u_short if_index) struct kif_node s; if (if_index == 0) - return (RB_MIN(kif_tree, &kit)); + return (RBT_MIN(kif_tree, &kit)); bzero(&s, sizeof(s)); s.k.if_index = if_index; - return (RB_FIND(kif_tree, &kit, &s)); + return (RBT_FIND(kif_tree, &kit, &s)); } struct kif * @@ -817,7 +820,7 @@ kr_getnextif(u_short if_index) if ((kn = kif_find(if_index)) == NULL) return (NULL); if (if_index) - kn = RB_NEXT(kif_tree, &kit, kn); + kn = RBT_NEXT(kif_tree, kn); if (kn == NULL) return (NULL); @@ -836,8 +839,8 @@ kif_insert(u_short if_index) TAILQ_INIT(&kif->addrs); TAILQ_INIT(&kif->arps); - if (RB_INSERT(kif_tree, &kit, kif) != NULL) - fatalx("kif_insert: RB_INSERT"); + if (RBT_INSERT(kif_tree, &kit, kif) != NULL) + fatalx("kif_insert: RBT_INSERT"); kr_state.ks_nkif++; kr_state.ks_iflastchange = smi_getticks(); @@ -851,8 +854,8 @@ kif_remove(struct kif_node *kif) struct kif_addr *ka; struct kif_arp *kr; - if (RB_REMOVE(kif_tree, &kit, kif) == NULL) { - log_warnx("%s: RB_REMOVE failed", __func__); + if (RBT_REMOVE(kif_tree, &kit, kif) == NULL) { + log_warnx("%s: RBT_REMOVE failed", __func__); return (-1); } @@ -876,7 +879,7 @@ kif_clear(void) { struct kif_node *kif; - while ((kif = RB_MIN(kif_tree, &kit)) != NULL) + while ((kif = RBT_MIN(kif_tree, &kit)) != NULL) kif_remove(kif); kr_state.ks_nkif = 0; kr_state.ks_iflastchange = smi_getticks(); @@ -928,7 +931,7 @@ ka_insert(u_short if_index, struct kif_a return; ka->if_index = if_index; - RB_INSERT(ka_tree, &kat, ka); + RBT_INSERT(ka_tree, &kat, ka); } struct kif_addr * @@ -937,16 +940,16 @@ ka_find(struct sockaddr *sa) struct kif_addr ka; if (sa == NULL) - return (RB_MIN(ka_tree, &kat)); + return (RBT_MIN(ka_tree, &kat)); bzero(&ka.addr, sizeof(ka.addr)); bcopy(sa, &ka.addr.sa, sa->sa_len); - return (RB_FIND(ka_tree, &kat, &ka)); + return (RBT_FIND(ka_tree, &kat, &ka)); } int ka_remove(struct kif_addr *ka) { - RB_REMOVE(ka_tree, &kat, ka); + RBT_REMOVE(ka_tree, &kat, ka); free(ka); return (0); } @@ -965,7 +968,7 @@ kr_getnextaddr(struct sockaddr *sa) if ((ka = ka_find(sa)) == NULL) return (NULL); if (sa) - ka = RB_NEXT(ka_tree, &kat, ka); + ka = RBT_NEXT(ka_tree, ka); return (ka); } @@ -1676,7 +1679,7 @@ kroute_first(void) if ((kt = ktable_get(0)) == NULL) return (NULL); - kn = RB_MIN(kroute_tree, &kt->krt); + kn = RBT_MIN(kroute_tree, &kt->krt); return (&kn->r); } @@ -1690,7 +1693,7 @@ kroute_getaddr(in_addr_t prefix, u_int8_ return (NULL); kn = kroute_find(kt, prefix, prefixlen, prio); if (kn != NULL && next) - kn = RB_NEXT(kroute_tree, &kt->krt, kn); + kn = RBT_NEXT(kroute_tree, kn); if (kn != NULL) return (&kn->r); else Index: usr.sbin/snmpd/smi.c =================================================================== RCS file: /cvs/src/usr.sbin/snmpd/smi.c,v retrieving revision 1.20 diff -u -p -r1.20 smi.c --- usr.sbin/snmpd/smi.c 28 Oct 2016 08:01:53 -0000 1.20 +++ usr.sbin/snmpd/smi.c 21 Jun 2017 00:00:39 -0000 @@ -49,12 +49,12 @@ #define MINIMUM(a, b) (((a) < (b)) ? (a) : (b)) -RB_HEAD(oidtree, oid); -RB_PROTOTYPE(oidtree, oid, o_element, smi_oid_cmp); +RBT_HEAD(oidtree, oid); +RBT_PROTOTYPE(oidtree, oid, o_element, smi_oid_cmp); struct oidtree smi_oidtree; -RB_HEAD(keytree, oid); -RB_PROTOTYPE(keytree, oid, o_keyword, smi_key_cmp); +RBT_HEAD(keytree, oid); +RBT_PROTOTYPE(keytree, oid, o_keyword, smi_key_cmp); struct keytree smi_keytree; u_long @@ -114,7 +114,7 @@ smi_oid2string(struct ber_oid *o, char * if (lookup && skip > i) continue; if (lookup && - (value = RB_FIND(oidtree, &smi_oidtree, &key)) != NULL) + (value = RBT_FIND(oidtree, &smi_oidtree, &key)) != NULL) snprintf(str, sizeof(str), "%s", value->o_name); else snprintf(str, sizeof(str), "%d", key.o_oid[i]); @@ -169,9 +169,9 @@ smi_delete(struct oid *oid) bzero(&key, sizeof(key)); bcopy(&oid->o_id, &key.o_id, sizeof(struct ber_oid)); - if ((value = RB_FIND(oidtree, &smi_oidtree, &key)) != NULL && + if ((value = RBT_FIND(oidtree, &smi_oidtree, &key)) != NULL && value == oid) - RB_REMOVE(oidtree, &smi_oidtree, value); + RBT_REMOVE(oidtree, &smi_oidtree, value); free(oid->o_data); if (oid->o_flags & OID_DYNAMIC) { @@ -190,11 +190,11 @@ smi_insert(struct oid *oid) bzero(&key, sizeof(key)); bcopy(&oid->o_id, &key.o_id, sizeof(struct ber_oid)); - value = RB_FIND(oidtree, &smi_oidtree, &key); + value = RBT_FIND(oidtree, &smi_oidtree, &key); if (value != NULL) return (-1); - RB_INSERT(oidtree, &smi_oidtree, oid); + RBT_INSERT(oidtree, &smi_oidtree, oid); return (0); } @@ -210,11 +210,11 @@ smi_mibtree(struct oid *oids) if (oid->o_name != NULL) { if ((oid->o_flags & OID_TABLE) && oid->o_get == NULL) fatalx("smi_mibtree: invalid MIB table"); - RB_INSERT(oidtree, &smi_oidtree, oid); - RB_INSERT(keytree, &smi_keytree, oid); + RBT_INSERT(oidtree, &smi_oidtree, oid); + RBT_INSERT(keytree, &smi_keytree, oid); continue; } - decl = RB_FIND(oidtree, &smi_oidtree, oid); + decl = RBT_FIND(oidtree, &smi_oidtree, oid); if (decl == NULL) fatalx("smi_mibtree: undeclared MIB"); decl->o_flags = oid->o_flags; @@ -230,7 +230,7 @@ int smi_init(void) { /* Initialize the Structure of Managed Information (SMI) */ - RB_INIT(&smi_oidtree); + RBT_INIT(oidtree, &smi_oidtree); mib_init(); return (0); } @@ -238,7 +238,7 @@ smi_init(void) struct oid * smi_find(struct oid *oid) { - return (RB_FIND(oidtree, &smi_oidtree, oid)); + return (RBT_FIND(oidtree, &smi_oidtree, oid)); } struct oid * @@ -248,13 +248,13 @@ smi_findkey(char *name) if (name == NULL) return (NULL); oid.o_name = name; - return (RB_FIND(keytree, &smi_keytree, &oid)); + return (RBT_FIND(keytree, &smi_keytree, &oid)); } struct oid * smi_next(struct oid *oid) { - return (RB_NEXT(oidtree, &smi_oidtree, oid)); + return (RBT_NEXT(oidtree, oid)); } struct oid * @@ -265,14 +265,14 @@ smi_foreach(struct oid *oid, u_int flags * for specific OID flags. */ if (oid == NULL) { - oid = RB_MIN(oidtree, &smi_oidtree); + oid = RBT_MIN(oidtree, &smi_oidtree); if (oid == NULL) return (NULL); if (flags == 0 || (oid->o_flags & flags)) return (oid); } for (;;) { - oid = RB_NEXT(oidtree, &smi_oidtree, oid); + oid = RBT_NEXT(oidtree, oid); if (oid == NULL) break; if (flags == 0 || (oid->o_flags & flags)) @@ -559,7 +559,7 @@ smi_application(struct ber_element *elm) } int -smi_oid_cmp(struct oid *a, struct oid *b) +smi_oid_cmp(const struct oid *a, const struct oid *b) { size_t i; @@ -581,14 +581,14 @@ smi_oid_cmp(struct oid *a, struct oid *b return (a->o_oidlen - b->o_oidlen); } -RB_GENERATE(oidtree, oid, o_element, smi_oid_cmp); +RBT_GENERATE(oidtree, oid, o_element, smi_oid_cmp); int -smi_key_cmp(struct oid *a, struct oid *b) +smi_key_cmp(const struct oid *a, const struct oid *b) { if (a->o_name == NULL || b->o_name == NULL) return (-1); return (strcasecmp(a->o_name, b->o_name)); } -RB_GENERATE(keytree, oid, o_keyword, smi_key_cmp); +RBT_GENERATE(keytree, oid, o_keyword, smi_key_cmp); Index: usr.sbin/snmpd/snmpd.h =================================================================== RCS file: /cvs/src/usr.sbin/snmpd/snmpd.h,v retrieving revision 1.75 diff -u -p -r1.75 snmpd.h --- usr.sbin/snmpd/snmpd.h 21 Apr 2017 13:50:23 -0000 1.75 +++ usr.sbin/snmpd/snmpd.h 21 Jun 2017 00:00:39 -0000 @@ -32,6 +32,7 @@ #include #include +#include #include #include "ber.h" @@ -197,8 +198,8 @@ struct privsep_fd { struct kroute_node; struct kroute6_node; -RB_HEAD(kroute_tree, kroute_node); -RB_HEAD(kroute6_tree, kroute6_node); +RBT_HEAD(kroute_tree, kroute_node); +RBT_HEAD(kroute6_tree, kroute6_node); struct ktable { struct kroute_tree krt; @@ -242,7 +243,7 @@ struct kif_addr { union kaddr dstbrd; TAILQ_ENTRY(kif_addr) entry; - RB_ENTRY(kif_addr) node; + RBT_ENTRY(kif_addr) node; }; struct kif_arp { @@ -316,8 +317,8 @@ struct oid { struct ctl_conn *o_session; - RB_ENTRY(oid) o_element; - RB_ENTRY(oid) o_keyword; + RBT_ENTRY(oid) o_element; + RBT_ENTRY(oid) o_keyword; TAILQ_ENTRY(oid) o_list; }; TAILQ_HEAD(oidlist, oid); @@ -600,9 +601,9 @@ struct trapcmd { int cmd_argc; char **cmd_argv; - RB_ENTRY(trapcmd) cmd_entry; + RBT_ENTRY(trapcmd) cmd_entry; }; -RB_HEAD(trapcmd_tree, trapcmd); +RBT_HEAD(trapcmd_tree, trapcmd); extern struct trapcmd_tree trapcmd_tree; extern struct snmpd *snmpd_env; @@ -729,8 +730,8 @@ char *smi_oid2string(struct ber_oid *, int smi_string2oid(const char *, struct ber_oid *); void smi_delete(struct oid *); int smi_insert(struct oid *); -int smi_oid_cmp(struct oid *, struct oid *); -int smi_key_cmp(struct oid *, struct oid *); +int smi_oid_cmp(const struct oid *, const struct oid *); +int smi_key_cmp(const struct oid *, const struct oid *); unsigned long smi_application(struct ber_element *); void smi_debug_elements(struct ber_element *); char *smi_print_element(struct ber_element *); Index: usr.sbin/snmpd/traphandler.c =================================================================== RCS file: /cvs/src/usr.sbin/snmpd/traphandler.c,v retrieving revision 1.8 diff -u -p -r1.8 traphandler.c --- usr.sbin/snmpd/traphandler.c 9 Jan 2017 14:49:22 -0000 1.8 +++ usr.sbin/snmpd/traphandler.c 21 Jun 2017 00:00:39 -0000 @@ -55,16 +55,16 @@ int traphandler_parse(char *, size_t, s struct ber_element **, u_int *, struct ber_oid *); void traphandler_v1translate(struct ber_oid *, u_int, u_int); -int trapcmd_cmp(struct trapcmd *, struct trapcmd *); +int trapcmd_cmp(const struct trapcmd *, const struct trapcmd *); void trapcmd_exec(struct trapcmd *, struct sockaddr *, struct ber_element *, char *, u_int); char *traphandler_hostname(struct sockaddr *, int); -RB_PROTOTYPE(trapcmd_tree, trapcmd, cmd_entry, trapcmd_cmp) -RB_GENERATE(trapcmd_tree, trapcmd, cmd_entry, trapcmd_cmp) +RBT_PROTOTYPE(trapcmd_tree, trapcmd, cmd_entry, trapcmd_cmp); +RBT_GENERATE(trapcmd_tree, trapcmd, cmd_entry, trapcmd_cmp); -struct trapcmd_tree trapcmd_tree = RB_INITIALIZER(&trapcmd_tree); +struct trapcmd_tree trapcmd_tree = RBT_INITIALIZER(trapcmd_tree); static struct privsep_proc procs[] = { { "parent", PROC_PARENT, traphandler_dispatch_parent } @@ -456,21 +456,23 @@ trapcmd_lookup(struct ber_oid *oid) bzero(&key, sizeof(key)); key.cmd_oid = oid; - if ((res = RB_FIND(trapcmd_tree, &trapcmd_tree, &key)) == NULL) + if ((res = RBT_FIND(trapcmd_tree, &trapcmd_tree, &key)) == NULL) res = key.cmd_maybe; return (res); } int -trapcmd_cmp(struct trapcmd *cmd1, struct trapcmd *cmd2) +trapcmd_cmp(const struct trapcmd *cmd1, const struct trapcmd *cmd2) { + struct trapcmd *cmd; int ret; ret = ber_oid_cmp(cmd2->cmd_oid, cmd1->cmd_oid); switch (ret) { case 2: + cmd = (struct trapcmd *)cmd1; /* XXX */ /* cmd1 is a child of cmd2 */ - cmd1->cmd_maybe = cmd2; + cmd->cmd_maybe = cmd2; return (1); default: return (ret); @@ -481,13 +483,13 @@ trapcmd_cmp(struct trapcmd *cmd1, struct int trapcmd_add(struct trapcmd *cmd) { - return (RB_INSERT(trapcmd_tree, &trapcmd_tree, cmd) != NULL); + return (RBT_INSERT(trapcmd_tree, &trapcmd_tree, cmd) != NULL); } void trapcmd_free(struct trapcmd *cmd) { - RB_REMOVE(trapcmd_tree, &trapcmd_tree, cmd); + RBT_REMOVE(trapcmd_tree, &trapcmd_tree, cmd); free(cmd->cmd_argv); free(cmd->cmd_oid); free(cmd); Index: usr.sbin/switchd/switch.c =================================================================== RCS file: /cvs/src/usr.sbin/switchd/switch.c,v retrieving revision 1.3 diff -u -p -r1.3 switch.c --- usr.sbin/switchd/switch.c 18 Sep 2016 13:17:40 -0000 1.3 +++ usr.sbin/switchd/switch.c 21 Jun 2017 00:00:39 -0000 @@ -24,6 +24,7 @@ #include #include +#include #include #include #include @@ -33,14 +34,15 @@ void switch_timer(struct switchd *, void *); static __inline int - switch_cmp(struct switch_control *, struct switch_control *); + switch_cmp(const struct switch_control *, + const struct switch_control *); static __inline int - switch_maccmp(struct macaddr *, struct macaddr *); + switch_maccmp(const struct macaddr *, const struct macaddr *); void switch_init(struct switchd *sc) { - RB_INIT(&sc->sc_switches); + RBT_INIT(switch_head, &sc->sc_switches); } int @@ -56,7 +58,7 @@ switch_dispatch_control(int fd, struct p case IMSG_CTL_SHOW_SUM: IMSG_SIZE_CHECK(imsg, &fd); - RB_FOREACH(sw, switch_head, &sc->sc_switches) { + RBT_FOREACH(sw, switch_head, &sc->sc_switches) { iov[0].iov_base = imsg->data; iov[0].iov_len = IMSG_DATA_SIZE(imsg); iov[1].iov_base = sw; @@ -65,7 +67,7 @@ switch_dispatch_control(int fd, struct p proc_composev(ps, PROC_CONTROL, IMSG_CTL_SWITCH, iov, 2); - RB_FOREACH(mac, macaddr_head, &sw->sw_addrcache) { + RBT_FOREACH(mac, macaddr_head, &sw->sw_addrcache) { iov[0].iov_base = imsg->data; iov[0].iov_len = IMSG_DATA_SIZE(imsg); iov[1].iov_base = mac; @@ -94,7 +96,7 @@ switch_get(struct switch_connection *con memcpy(&key.sw_addr, &con->con_peer, sizeof(key.sw_addr)); - con->con_switch = RB_FIND(switch_head, &sc->sc_switches, &key); + con->con_switch = RBT_FIND(switch_head, &sc->sc_switches, &key); return (con->con_switch); } @@ -114,10 +116,10 @@ switch_add(struct switch_connection *con memcpy(&sw->sw_addr, &con->con_peer, sizeof(sw->sw_addr)); sw->sw_id = ++id; - RB_INIT(&sw->sw_addrcache); + RBT_INIT(macaddr_head, &sw->sw_addrcache); if ((oldsw = - RB_INSERT(switch_head, &sc->sc_switches, sw)) != NULL) { + RBT_INSERT(switch_head, &sc->sc_switches, sw)) != NULL) { free(sw); sw = oldsw; } else { @@ -139,13 +141,13 @@ switch_timer(struct switchd *sc, void *a getmonotime(&tv); - for (mac = RB_MIN(macaddr_head, &sw->sw_addrcache); + for (mac = RBT_MIN(macaddr_head, &sw->sw_addrcache); mac != NULL; mac = next) { - next = RB_NEXT(macaddr_head, &sw->sw_addrcache, mac); + next = RBT_NEXT(macaddr_head, mac); /* Simple monotonic timeout */ if ((tv.tv_sec - mac->mac_age) >= sc->sc_cache_timeout) { - RB_REMOVE(macaddr_head, &sw->sw_addrcache, mac); + RBT_REMOVE(macaddr_head, &sw->sw_addrcache, mac); sw->sw_cachesize--; free(mac); cnt++; @@ -168,14 +170,14 @@ switch_remove(struct switchd *sc, struct timer_del(sc, &sw->sw_timer); - for (mac = RB_MIN(macaddr_head, &sw->sw_addrcache); + for (mac = RBT_MIN(macaddr_head, &sw->sw_addrcache); mac != NULL; mac = next) { - next = RB_NEXT(macaddr_head, &sw->sw_addrcache, mac); - RB_REMOVE(macaddr_head, &sw->sw_addrcache, mac); + next = RBT_NEXT(macaddr_head, mac); + RBT_REMOVE(macaddr_head, &sw->sw_addrcache, mac); sw->sw_cachesize--; free(mac); } - RB_REMOVE(switch_head, &sc->sc_switches, sw); + RBT_REMOVE(switch_head, &sc->sc_switches, sw); log_debug("%s: switch %u removed", __func__, sw->sw_id); @@ -200,7 +202,7 @@ switch_learn(struct switchd *sc, struct memcpy(&mac->mac_addr, ea, sizeof(mac->mac_addr)); - if (RB_INSERT(macaddr_head, &sw->sw_addrcache, mac) != NULL) + if (RBT_INSERT(macaddr_head, &sw->sw_addrcache, mac) != NULL) fatalx("cache corrupted"); sw->sw_cachesize++; @@ -221,16 +223,16 @@ switch_cached(struct switch_control *sw, { struct macaddr key; memcpy(&key.mac_addr, ea, sizeof(key.mac_addr)); - return (RB_FIND(macaddr_head, &sw->sw_addrcache, &key)); + return (RBT_FIND(macaddr_head, &sw->sw_addrcache, &key)); } static __inline int -switch_cmp(struct switch_control *a, struct switch_control *b) +switch_cmp(const struct switch_control *a, const struct switch_control *b) { int diff = 0; - diff = sockaddr_cmp((struct sockaddr *)&a->sw_addr, - (struct sockaddr *)&b->sw_addr, 128); + diff = sockaddr_cmp((const struct sockaddr *)&a->sw_addr, + (const struct sockaddr *)&b->sw_addr, 128); if (!diff) diff = socket_getport(&a->sw_addr) - socket_getport(&b->sw_addr); @@ -239,10 +241,10 @@ switch_cmp(struct switch_control *a, str } static __inline int -switch_maccmp(struct macaddr *a, struct macaddr *b) +switch_maccmp(const struct macaddr *a, const struct macaddr *b) { return (memcmp(a->mac_addr, b->mac_addr, sizeof(a->mac_addr))); } -RB_GENERATE(switch_head, switch_control, sw_entry, switch_cmp); -RB_GENERATE(macaddr_head, macaddr, mac_entry, switch_maccmp); +RBT_GENERATE(switch_head, switch_control, sw_entry, switch_cmp); +RBT_GENERATE(macaddr_head, macaddr, mac_entry, switch_maccmp); Index: usr.sbin/switchd/switchd.h =================================================================== RCS file: /cvs/src/usr.sbin/switchd/switchd.h,v retrieving revision 1.28 diff -u -p -r1.28 switchd.h --- usr.sbin/switchd/switchd.h 22 Dec 2016 15:31:43 -0000 1.28 +++ usr.sbin/switchd/switchd.h 21 Jun 2017 00:00:39 -0000 @@ -54,9 +54,9 @@ struct macaddr { uint8_t mac_addr[ETHER_ADDR_LEN]; uint32_t mac_port; time_t mac_age; - RB_ENTRY(macaddr) mac_entry; + RBT_ENTRY(macaddr) mac_entry; }; -RB_HEAD(macaddr_head, macaddr); +RBT_HEAD(macaddr_head, macaddr); struct switch_control { unsigned int sw_id; @@ -64,9 +64,9 @@ struct switch_control { struct macaddr_head sw_addrcache; struct timer sw_timer; unsigned int sw_cachesize; - RB_ENTRY(switch_control) sw_entry; + RBT_ENTRY(switch_control) sw_entry; }; -RB_HEAD(switch_head, switch_control); +RBT_HEAD(switch_head, switch_control); struct switch_table { TAILQ_ENTRY(switch_table) st_entry; @@ -227,8 +227,8 @@ struct switch_control struct macaddr *switch_learn(struct switchd *, struct switch_control *, uint8_t *, uint32_t); struct macaddr *switch_cached(struct switch_control *, uint8_t *); -RB_PROTOTYPE(switch_head, switch_control, sw_entry, switch_cmp); -RB_PROTOTYPE(macaddr_head, macaddr, mac_entry, switch_maccmp); +RBT_PROTOTYPE(switch_head, switch_control, sw_entry, switch_cmp); +RBT_PROTOTYPE(macaddr_head, macaddr, mac_entry, switch_maccmp); /* timer.c */ void timer_set(struct switchd *, struct timer *, @@ -240,9 +240,10 @@ void timer_del(struct switchd *, struc void socket_set_blockmode(int, enum blockmodes); int accept4_reserve(int, struct sockaddr *, socklen_t *, int, int, volatile int *); -in_port_t socket_getport(struct sockaddr_storage *); +in_port_t socket_getport(const struct sockaddr_storage *); int socket_setport(struct sockaddr_storage *, in_port_t); -int sockaddr_cmp(struct sockaddr *, struct sockaddr *, int); +int sockaddr_cmp(const struct sockaddr *, + const struct sockaddr *, int); struct in6_addr *prefixlen2mask6(uint8_t, uint32_t *); uint32_t prefixlen2mask(uint8_t); const char *print_host(struct sockaddr_storage *, char *, size_t); Index: usr.sbin/switchd/util.c =================================================================== RCS file: /cvs/src/usr.sbin/switchd/util.c,v retrieving revision 1.6 diff -u -p -r1.6 util.c --- usr.sbin/switchd/util.c 9 Jan 2017 14:49:22 -0000 1.6 +++ usr.sbin/switchd/util.c 21 Jun 2017 00:00:39 -0000 @@ -74,13 +74,13 @@ accept4_reserve(int sockfd, struct socka } in_port_t -socket_getport(struct sockaddr_storage *ss) +socket_getport(const struct sockaddr_storage *ss) { switch (ss->ss_family) { case AF_INET: - return (ntohs(((struct sockaddr_in *)ss)->sin_port)); + return (ntohs(((const struct sockaddr_in *)ss)->sin_port)); case AF_INET6: - return (ntohs(((struct sockaddr_in6 *)ss)->sin6_port)); + return (ntohs(((const struct sockaddr_in6 *)ss)->sin6_port)); default: return (0); } @@ -108,11 +108,11 @@ socket_setport(struct sockaddr_storage * } int -sockaddr_cmp(struct sockaddr *a, struct sockaddr *b, int prefixlen) +sockaddr_cmp(const struct sockaddr *a, const struct sockaddr *b, int prefixlen) { - struct sockaddr_in *a4, *b4; - struct sockaddr_in6 *a6, *b6; - struct sockaddr_un *au, *bu; + const struct sockaddr_in *a4, *b4; + const struct sockaddr_in6 *a6, *b6; + const struct sockaddr_un *au, *bu; uint32_t av[4], bv[4], mv[4]; if (a->sa_family == AF_UNSPEC || b->sa_family == AF_UNSPEC) @@ -127,8 +127,8 @@ sockaddr_cmp(struct sockaddr *a, struct switch (a->sa_family) { case AF_INET: - a4 = (struct sockaddr_in *)a; - b4 = (struct sockaddr_in *)b; + a4 = (const struct sockaddr_in *)a; + b4 = (const struct sockaddr_in *)b; av[0] = a4->sin_addr.s_addr; bv[0] = b4->sin_addr.s_addr; @@ -141,8 +141,8 @@ sockaddr_cmp(struct sockaddr *a, struct return (-1); break; case AF_INET6: - a6 = (struct sockaddr_in6 *)a; - b6 = (struct sockaddr_in6 *)b; + a6 = (const struct sockaddr_in6 *)a; + b6 = (const struct sockaddr_in6 *)b; memcpy(&av, &a6->sin6_addr.s6_addr, 16); memcpy(&bv, &b6->sin6_addr.s6_addr, 16); @@ -167,8 +167,8 @@ sockaddr_cmp(struct sockaddr *a, struct return (-1); break; case AF_UNIX: - au = (struct sockaddr_un *)a; - bu = (struct sockaddr_un *)b; + au = (const struct sockaddr_un *)a; + bu = (const struct sockaddr_un *)b; return (strcmp(au->sun_path, bu->sun_path)); } Index: usr.sbin/ypldap/entries.c =================================================================== RCS file: /cvs/src/usr.sbin/ypldap/entries.c,v retrieving revision 1.3 diff -u -p -r1.3 entries.c --- usr.sbin/ypldap/entries.c 16 Jan 2015 06:40:22 -0000 1.3 +++ usr.sbin/ypldap/entries.c 21 Jun 2017 00:00:39 -0000 @@ -63,7 +63,7 @@ flatten_entries(struct env *env) } endp = linep; - RB_FOREACH(ue, user_name_tree, env->sc_user_names) { + RBT_FOREACH(ue, user_name_tree, env->sc_user_names) { /* * we convert the first nul back to a column, * copy the string and then convert it back to a nul. @@ -99,7 +99,7 @@ flatten_entries(struct env *env) fatal("out of memory"); } endp = linep; - RB_FOREACH(ge, group_name_tree, env->sc_group_names) { + RBT_FOREACH(ge, group_name_tree, env->sc_group_names) { /* * we convert the first nul back to a column, * copy the string and then convert it back to a nul. @@ -118,30 +118,30 @@ flatten_entries(struct env *env) } int -userent_name_cmp(struct userent *ue1, struct userent *ue2) +userent_name_cmp(const struct userent *ue1, const struct userent *ue2) { return (strcmp(ue1->ue_line, ue2->ue_line)); } int -userent_uid_cmp(struct userent *ue1, struct userent *ue2) +userent_uid_cmp(const struct userent *ue1, const struct userent *ue2) { return (ue1->ue_uid - ue2->ue_uid); } int -groupent_name_cmp(struct groupent *ge1, struct groupent *ge2) +groupent_name_cmp(const struct groupent *ge1, const struct groupent *ge2) { return (strcmp(ge1->ge_line, ge2->ge_line)); } int -groupent_gid_cmp(struct groupent *ge1, struct groupent *ge2) +groupent_gid_cmp(const struct groupent *ge1, const struct groupent *ge2) { return (ge1->ge_gid - ge2->ge_gid); } -RB_GENERATE(user_name_tree, userent, ue_name_node, userent_name_cmp); -RB_GENERATE(user_uid_tree, userent, ue_uid_node, userent_uid_cmp); -RB_GENERATE(group_name_tree, groupent, ge_name_node, groupent_name_cmp); -RB_GENERATE(group_gid_tree, groupent, ge_gid_node, groupent_gid_cmp); +RBT_GENERATE(user_name_tree, userent, ue_name_node, userent_name_cmp); +RBT_GENERATE(user_uid_tree, userent, ue_uid_node, userent_uid_cmp); +RBT_GENERATE(group_name_tree, groupent, ge_name_node, groupent_name_cmp); +RBT_GENERATE(group_gid_tree, groupent, ge_gid_node, groupent_gid_cmp); Index: usr.sbin/ypldap/yp.c =================================================================== RCS file: /cvs/src/usr.sbin/ypldap/yp.c,v retrieving revision 1.18 diff -u -p -r1.18 yp.c --- usr.sbin/ypldap/yp.c 29 Nov 2016 17:15:27 -0000 1.18 +++ usr.sbin/ypldap/yp.c 21 Jun 2017 00:00:39 -0000 @@ -348,7 +348,7 @@ ypproc_match_2_svc(ypreq_key *arg, struc if (strcmp(arg->map, "passwd.byname") == 0 || strcmp(arg->map, "master.passwd.byname") == 0) { ukey.ue_line = key; - if ((ue = RB_FIND(user_name_tree, env->sc_user_names, + if ((ue = RBT_FIND(user_name_tree, env->sc_user_names, &ukey)) == NULL) { res.stat = YP_NOKEY; return (&res); @@ -364,7 +364,7 @@ ypproc_match_2_svc(ypreq_key *arg, struc return (&res); } - if ((ue = RB_FIND(user_uid_tree, &env->sc_user_uids, + if ((ue = RBT_FIND(user_uid_tree, &env->sc_user_uids, &ukey)) == NULL) { res.stat = YP_NOKEY; return (&res); @@ -378,7 +378,7 @@ ypproc_match_2_svc(ypreq_key *arg, struc res.stat = YP_BADARGS; return (&res); } - if ((ge = RB_FIND(group_gid_tree, &env->sc_group_gids, + if ((ge = RBT_FIND(group_gid_tree, &env->sc_group_gids, &gkey)) == NULL) { res.stat = YP_NOKEY; return (&res); @@ -388,7 +388,7 @@ ypproc_match_2_svc(ypreq_key *arg, struc return (&res); } else if (strcmp(arg->map, "group.byname") == 0) { gkey.ge_line = key; - if ((ge = RB_FIND(group_name_tree, env->sc_group_names, + if ((ge = RBT_FIND(group_name_tree, env->sc_group_names, &gkey)) == NULL) { res.stat = YP_NOKEY; return (&res); @@ -427,7 +427,7 @@ ypproc_match_2_svc(ypreq_key *arg, struc return (&res); } - if ((ue = RB_FIND(user_uid_tree, &env->sc_user_uids, + if ((ue = RBT_FIND(user_uid_tree, &env->sc_user_uids, &ukey)) == NULL) { res.stat = YP_NOKEY; return (&res); @@ -490,7 +490,7 @@ ypproc_next_2_svc(ypreq_key *arg, struct (void)strncpy(key, arg->key.keydat_val, arg->key.keydat_len); ukey.ue_line = key; - if ((ue = RB_FIND(user_name_tree, env->sc_user_names, + if ((ue = RBT_FIND(user_name_tree, env->sc_user_names, &ukey)) == NULL) { /* * canacar's trick: @@ -500,15 +500,14 @@ ypproc_next_2_svc(ypreq_key *arg, struct * lexicographical order, hence insert the search key * and look up the next field, then remove it again. */ - RB_INSERT(user_name_tree, env->sc_user_names, &ukey); - if ((ue = RB_NEXT(user_name_tree, &env->sc_user_names, - &ukey)) == NULL) { - RB_REMOVE(user_name_tree, env->sc_user_names, + RBT_INSERT(user_name_tree, env->sc_user_names, &ukey); + if ((ue = RBT_NEXT(user_name_tree, &ukey)) == NULL) { + RBT_REMOVE(user_name_tree, env->sc_user_names, &ukey); res.stat = YP_NOKEY; return (&res); } - RB_REMOVE(user_name_tree, env->sc_user_names, &ukey); + RBT_REMOVE(user_name_tree, env->sc_user_names, &ukey); } line = ue->ue_line + (strlen(ue->ue_line) + 1); line = line + (strlen(line) + 1); @@ -522,20 +521,19 @@ ypproc_next_2_svc(ypreq_key *arg, struct arg->key.keydat_len); gkey.ge_line = key; - if ((ge = RB_FIND(group_name_tree, env->sc_group_names, + if ((ge = RBT_FIND(group_name_tree, env->sc_group_names, &gkey)) == NULL) { /* * canacar's trick reloaded. */ - RB_INSERT(group_name_tree, env->sc_group_names, &gkey); - if ((ge = RB_NEXT(group_name_tree, &env->sc_group_names, - &gkey)) == NULL) { - RB_REMOVE(group_name_tree, env->sc_group_names, + RBT_INSERT(group_name_tree, env->sc_group_names, &gkey); + if ((ge = RBT_NEXT(group_name_tree, &gkey)) == NULL) { + RBT_REMOVE(group_name_tree, env->sc_group_names, &gkey); res.stat = YP_NOKEY; return (&res); } - RB_REMOVE(group_name_tree, env->sc_group_names, &gkey); + RBT_REMOVE(group_name_tree, env->sc_group_names, &gkey); } line = ge->ge_line + (strlen(ge->ge_line) + 1); Index: usr.sbin/ypldap/ypldap.c =================================================================== RCS file: /cvs/src/usr.sbin/ypldap/ypldap.c,v retrieving revision 1.21 diff -u -p -r1.21 ypldap.c --- usr.sbin/ypldap/ypldap.c 20 Jan 2017 12:39:36 -0000 1.21 +++ usr.sbin/ypldap/ypldap.c 21 Jun 2017 00:00:39 -0000 @@ -134,8 +134,8 @@ main_start_update(struct env *env) (env->sc_group_names_t = calloc(1, sizeof(*env->sc_group_names_t))) == NULL) fatal(NULL); - RB_INIT(env->sc_user_names_t); - RB_INIT(env->sc_group_names_t); + RBT_INIT(user_name_tree, env->sc_user_names_t); + RBT_INIT(group_name_tree, env->sc_group_names_t); } /* @@ -151,8 +151,8 @@ main_trash_update(struct env *env) env->update_trashed = 1; - while ((ue = RB_ROOT(env->sc_user_names_t)) != NULL) { - RB_REMOVE(user_name_tree, + while ((ue = RBT_ROOT(user_name_tree, env->sc_user_names_t)) != NULL) { + RBT_REMOVE(user_name_tree, env->sc_user_names_t, ue); free(ue->ue_line); free(ue->ue_netid_line); @@ -160,9 +160,9 @@ main_trash_update(struct env *env) } free(env->sc_user_names_t); env->sc_user_names_t = NULL; - while ((ge = RB_ROOT(env->sc_group_names_t)) + while ((ge = RBT_ROOT(group_name_tree, env->sc_group_names_t)) != NULL) { - RB_REMOVE(group_name_tree, + RBT_REMOVE(group_name_tree, env->sc_group_names_t, ge); free(ge->ge_line); free(ge); @@ -183,7 +183,7 @@ main_create_user_groups(struct env *env) const char *errstr = NULL; size_t len; - RB_FOREACH(ue, user_name_tree, env->sc_user_names_t) { + RBT_FOREACH(ue, user_name_tree, env->sc_user_names_t) { bp = cp = ue->ue_line; /* name */ @@ -219,7 +219,7 @@ main_create_user_groups(struct env *env) ue->ue_gid = pw_gid; } - RB_FOREACH(ge, group_name_tree, env->sc_group_names_t) { + RBT_FOREACH(ge, group_name_tree, env->sc_group_names_t) { bp = cp = ge->ge_line; /* name */ @@ -239,7 +239,7 @@ main_create_user_groups(struct env *env) if (!(cp = strsep(&bp, ","))) break; ukey.ue_line = cp; - if ((ue = RB_FIND(user_name_tree, env->sc_user_names_t, + if ((ue = RBT_FIND(user_name_tree, env->sc_user_names_t, &ukey)) == NULL) { /* User not found */ log_warnx("main: unknown user %s in group %s\n", @@ -300,8 +300,8 @@ main_end_update(struct env *env) /* * clean previous tree. */ - while ((ue = RB_ROOT(env->sc_user_names)) != NULL) { - RB_REMOVE(user_name_tree, env->sc_user_names, + while ((ue = RBT_ROOT(user_name_tree, env->sc_user_names)) != NULL) { + RBT_REMOVE(user_name_tree, env->sc_user_names, ue); free(ue->ue_netid_line); free(ue); @@ -313,8 +313,8 @@ main_end_update(struct env *env) env->sc_user_lines = NULL; env->sc_user_names_t = NULL; - while ((ge = RB_ROOT(env->sc_group_names)) != NULL) { - RB_REMOVE(group_name_tree, + while ((ge = RBT_ROOT(group_name_tree, env->sc_group_names)) != NULL) { + RBT_REMOVE(group_name_tree, env->sc_group_names, ge); free(ge); } @@ -333,13 +333,13 @@ main_end_update(struct env *env) */ make_uids: - RB_INIT(&env->sc_user_uids); - RB_INIT(&env->sc_group_gids); - RB_FOREACH(ue, user_name_tree, env->sc_user_names) - RB_INSERT(user_uid_tree, + RBT_INIT(user_uid_tree, &env->sc_user_uids); + RBT_INIT(group_gid_tree, &env->sc_group_gids); + RBT_FOREACH(ue, user_name_tree, env->sc_user_names) + RBT_INSERT(user_uid_tree, &env->sc_user_uids, ue); - RB_FOREACH(ge, group_name_tree, env->sc_group_names) - RB_INSERT(group_gid_tree, + RBT_FOREACH(ge, group_name_tree, env->sc_group_names) + RBT_INSERT(group_gid_tree, &env->sc_group_gids, ge); } @@ -400,7 +400,7 @@ main_dispatch_client(int fd, short event ue->ue_uid = ir.ir_key.ik_uid; len = strlen(ue->ue_line) + 1; ue->ue_line[strcspn(ue->ue_line, ":")] = '\0'; - if (RB_INSERT(user_name_tree, env->sc_user_names_t, + if (RBT_INSERT(user_name_tree, env->sc_user_names_t, ue) != NULL) { /* dup */ free(ue->ue_line); free(ue); @@ -426,7 +426,7 @@ main_dispatch_client(int fd, short event ge->ge_gid = ir.ir_key.ik_gid; len = strlen(ge->ge_line) + 1; ge->ge_line[strcspn(ge->ge_line, ":")] = '\0'; - if (RB_INSERT(group_name_tree, env->sc_group_names_t, + if (RBT_INSERT(group_name_tree, env->sc_group_names_t, ge) != NULL) { /* dup */ free(ge->ge_line); free(ge); @@ -544,8 +544,8 @@ main(int argc, char *argv[]) if (argc) usage(); - RB_INIT(&env.sc_user_uids); - RB_INIT(&env.sc_group_gids); + RBT_INIT(user_uid_tree, &env.sc_user_uids); + RBT_INIT(group_gid_tree, &env.sc_group_gids); if (parse_config(&env, conffile, opts)) exit(1); Index: usr.sbin/ypldap/ypldap.h =================================================================== RCS file: /cvs/src/usr.sbin/ypldap/ypldap.h,v retrieving revision 1.19 diff -u -p -r1.19 ypldap.h --- usr.sbin/ypldap/ypldap.h 30 May 2017 09:33:31 -0000 1.19 +++ usr.sbin/ypldap/ypldap.h 21 Jun 2017 00:00:39 -0000 @@ -59,8 +59,8 @@ static const char * const log_procnames[ }; struct userent { - RB_ENTRY(userent) ue_name_node; - RB_ENTRY(userent) ue_uid_node; + RBT_ENTRY(userent) ue_name_node; + RBT_ENTRY(userent) ue_uid_node; uid_t ue_uid; char *ue_line; char *ue_netid_line; @@ -68,8 +68,8 @@ struct userent { }; struct groupent { - RB_ENTRY(groupent) ge_name_node; - RB_ENTRY(groupent) ge_gid_node; + RBT_ENTRY(groupent) ge_name_node; + RBT_ENTRY(groupent) ge_gid_node; gid_t ge_gid; char *ge_line; }; @@ -169,10 +169,13 @@ struct env { struct imsgev *sc_iev; struct imsgev *sc_iev_dns; - RB_HEAD(user_name_tree,userent) *sc_user_names; - RB_HEAD(user_uid_tree,userent) sc_user_uids; - RB_HEAD(group_name_tree,groupent)*sc_group_names; - RB_HEAD(group_gid_tree,groupent) sc_group_gids; + RBT_HEAD(user_name_tree,userent) + *sc_user_names; + RBT_HEAD(user_uid_tree,userent) sc_user_uids; + RBT_HEAD(group_name_tree,groupent) + *sc_group_names; + RBT_HEAD(group_gid_tree,groupent) + sc_group_gids; struct user_name_tree *sc_user_names_t; struct group_name_tree *sc_group_names_t; size_t sc_user_line_len; @@ -211,14 +214,18 @@ int imsg_compose_event(struct imsgev /* entries.c */ void flatten_entries(struct env *); -int userent_name_cmp(struct userent *, struct userent *); -int userent_uid_cmp(struct userent *, struct userent *); -int groupent_name_cmp(struct groupent *, struct groupent *); -int groupent_gid_cmp(struct groupent *, struct groupent *); -RB_PROTOTYPE( user_name_tree, userent, ue_name_node, userent_name_cmp); -RB_PROTOTYPE( user_uid_tree, userent, ue_uid_node, userent_uid_cmp); -RB_PROTOTYPE( group_name_tree, groupent, ge_name_node, groupent_name_cmp); -RB_PROTOTYPE( group_gid_tree, groupent, ge_gid_node, groupent_gid_cmp); +int userent_name_cmp(const struct userent *, + const struct userent *); +int userent_uid_cmp(const struct userent *, + const struct userent *); +int groupent_name_cmp(const struct groupent *, + const struct groupent *); +int groupent_gid_cmp(const struct groupent *, + const struct groupent *); +RBT_PROTOTYPE( user_name_tree, userent, ue_name_node, userent_name_cmp); +RBT_PROTOTYPE( user_uid_tree, userent, ue_uid_node, userent_uid_cmp); +RBT_PROTOTYPE( group_name_tree, groupent, ge_name_node, groupent_name_cmp); +RBT_PROTOTYPE( group_gid_tree, groupent, ge_gid_node, groupent_gid_cmp); /* yp.c */ void yp_init(struct env *);