I did switch to memset from bzero and from bcopy to memcpy whenever I
touched the code but now I just decided to change all users of bcopy(),
bzero() and bcmp() to use memcpy(), memset() and memcmp().

None of the bcopy() users had overlapping memory regions so memcpy()
should be fine.

-- 
:wq Claudio

Index: usr.sbin/bgpctl/bgpctl.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpctl/bgpctl.c,v
retrieving revision 1.281
diff -u -p -r1.281 bgpctl.c
--- usr.sbin/bgpctl/bgpctl.c    28 Jul 2022 10:40:25 -0000      1.281
+++ usr.sbin/bgpctl/bgpctl.c    17 Aug 2022 13:56:57 -0000
@@ -131,7 +131,7 @@ main(int argc, char *argv[])
                if (pledge("stdio", NULL) == -1)
                        err(1, "pledge");
 
-               bzero(&ribreq, sizeof(ribreq));
+               memset(&ribreq, 0, sizeof(ribreq));
                if (res->as.type != AS_UNDEF)
                        ribreq.as = res->as;
                if (res->addr.aid) {
@@ -160,7 +160,7 @@ main(int argc, char *argv[])
        if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
                err(1, "control_init: socket");
 
-       bzero(&sa_un, sizeof(sa_un));
+       memset(&sa_un, 0, sizeof(sa_un));
        sa_un.sun_family = AF_UNIX;
        if (strlcpy(sa_un.sun_path, sockname, sizeof(sa_un.sun_path)) >=
            sizeof(sa_un.sun_path))
@@ -235,7 +235,7 @@ main(int argc, char *argv[])
                            NULL, 0);
                break;
        case SHOW_RIB:
-               bzero(&ribreq, sizeof(ribreq));
+               memset(&ribreq, 0, sizeof(ribreq));
                type = IMSG_CTL_SHOW_RIB;
                if (res->addr.aid) {
                        ribreq.prefix = res->addr;
@@ -310,7 +310,7 @@ main(int argc, char *argv[])
                break;
        case NETWORK_ADD:
        case NETWORK_REMOVE:
-               bzero(&net, sizeof(net));
+               memset(&net, 0, sizeof(net));
                net.prefix = res->addr;
                net.prefixlen = res->prefixlen;
                net.rd = res->rd;
@@ -333,14 +333,14 @@ main(int argc, char *argv[])
                done = 1;
                break;
        case NETWORK_SHOW:
-               bzero(&ribreq, sizeof(ribreq));
+               memset(&ribreq, 0, sizeof(ribreq));
                ribreq.aid = res->aid;
                strlcpy(ribreq.rib, res->rib, sizeof(ribreq.rib));
                imsg_compose(ibuf, IMSG_CTL_SHOW_NETWORK, 0, 0, -1,
                    &ribreq, sizeof(ribreq));
                break;
        case NETWORK_MRT:
-               bzero(&ribreq, sizeof(ribreq));
+               memset(&ribreq, 0, sizeof(ribreq));
                if (res->as.type != AS_UNDEF)
                        ribreq.as = res->as;
                if (res->addr.aid) {
@@ -1076,7 +1076,7 @@ network_bulk(struct parse_result *res)
                        /* Stop processing after a comment */
                        if (*b == '#')
                                break;
-                       bzero(&net, sizeof(net));
+                       memset(&net, 0, sizeof(net));
                        if (parse_prefix(b, strlen(b), &h, &len) != 1)
                                errx(1, "bad prefix: %s", b);
                        net.prefix = h;
@@ -1145,7 +1145,7 @@ show_mrt_dump(struct mrt_rib *mr, struct
 
        for (i = 0; i < mr->nentries; i++) {
                mre = &mr->entries[i];
-               bzero(&ctl, sizeof(ctl));
+               memset(&ctl, 0, sizeof(ctl));
                ctl.prefix = mr->prefix;
                ctl.prefixlen = mr->prefixlen;
                if (mre->originated <= now)
@@ -1228,7 +1228,7 @@ network_mrt_dump(struct mrt_rib *mr, str
        now = time(NULL);
        for (i = 0; i < mr->nentries; i++) {
                mre = &mr->entries[i];
-               bzero(&ctl, sizeof(ctl));
+               memset(&ctl, 0, sizeof(ctl));
                ctl.prefix = mr->prefix;
                ctl.prefixlen = mr->prefixlen;
                if (mre->originated <= now)
@@ -1269,7 +1269,7 @@ network_mrt_dump(struct mrt_rib *mr, str
                    !match_aspath(mre->aspath, mre->aspath_len, &req->as))
                        continue;
 
-               bzero(&net, sizeof(net));
+               memset(&net, 0, sizeof(net));
                net.prefix = ctl.prefix;
                net.prefixlen = ctl.prefixlen;
                net.type = NETWORK_MRTCLONE;
Index: usr.sbin/bgpctl/mrtparser.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpctl/mrtparser.c,v
retrieving revision 1.17
diff -u -p -r1.17 mrtparser.c
--- usr.sbin/bgpctl/mrtparser.c 6 Feb 2022 09:52:32 -0000       1.17
+++ usr.sbin/bgpctl/mrtparser.c 17 Aug 2022 13:56:57 -0000
@@ -58,7 +58,7 @@ mrt_read_msg(int fd, struct mrt_hdr *hdr
 {
        void *buf;
 
-       bzero(hdr, sizeof(*hdr));
+       memset(hdr, 0, sizeof(*hdr));
        if (mrt_read_buf(fd, hdr, sizeof(*hdr)) != sizeof(*hdr))
                return (NULL);
 
Index: usr.sbin/bgpctl/parser.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpctl/parser.c,v
retrieving revision 1.113
diff -u -p -r1.113 parser.c
--- usr.sbin/bgpctl/parser.c    22 Jun 2022 12:27:46 -0000      1.113
+++ usr.sbin/bgpctl/parser.c    17 Aug 2022 13:56:57 -0000
@@ -506,7 +506,7 @@ parse(int argc, char *argv[])
        const struct token      *table = t_main;
        const struct token      *match;
 
-       bzero(&res, sizeof(res));
+       memset(&res, 0, sizeof(res));
        res.rtableid = getrtable();
        TAILQ_INIT(&res.set);
 
@@ -907,8 +907,8 @@ parse_addr(const char *word, struct bgpd
        if (word == NULL)
                return (0);
 
-       bzero(addr, sizeof(struct bgpd_addr));
-       bzero(&ina, sizeof(ina));
+       memset(addr, 0, sizeof(struct bgpd_addr));
+       memset(&ina, 0, sizeof(ina));
 
        if (inet_net_pton(AF_INET, word, &ina, sizeof(ina)) != -1) {
                addr->aid = AID_INET;
@@ -916,7 +916,7 @@ parse_addr(const char *word, struct bgpd
                return (1);
        }
 
-       bzero(&hints, sizeof(hints));
+       memset(&hints, 0, sizeof(hints));
        hints.ai_family = AF_INET6;
        hints.ai_socktype = SOCK_DGRAM; /*dummy*/
        hints.ai_flags = AI_NUMERICHOST;
@@ -940,7 +940,7 @@ parse_prefix(const char *word, size_t wo
        if (word == NULL)
                return (0);
 
-       bzero(addr, sizeof(struct bgpd_addr));
+       memset(addr, 0, sizeof(struct bgpd_addr));
 
        if ((p = strrchr(word, '/')) != NULL) {
                size_t plen = strlen(p);
Index: usr.sbin/bgpd/bgpd.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/bgpd.c,v
retrieving revision 1.253
diff -u -p -r1.253 bgpd.c
--- usr.sbin/bgpd/bgpd.c        28 Jul 2022 13:11:48 -0000      1.253
+++ usr.sbin/bgpd/bgpd.c        17 Aug 2022 13:56:57 -0000
@@ -321,7 +321,7 @@ BROKEN      if (pledge("stdio rpath wpath cpa
                        pfd = newp;
                        pfd_elms = PFD_CONNECT_START + connect_cnt;
                }
-               bzero(pfd, sizeof(struct pollfd) * pfd_elms);
+               memset(pfd, 0, sizeof(struct pollfd) * pfd_elms);
 
                timeout = mrt_timeout(conf->mrt);
 
Index: usr.sbin/bgpd/carp.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/carp.c,v
retrieving revision 1.10
diff -u -p -r1.10 carp.c
--- usr.sbin/bgpd/carp.c        8 Aug 2019 20:06:29 -0000       1.10
+++ usr.sbin/bgpd/carp.c        17 Aug 2022 13:56:57 -0000
@@ -113,7 +113,7 @@ carp_demote_get(char *group)
                return (-1);
        }
 
-       bzero(&ifgr, sizeof(ifgr));
+       memset(&ifgr, 0, sizeof(ifgr));
        strlcpy(ifgr.ifgr_name, group, sizeof(ifgr.ifgr_name));
 
        if (ioctl(s, SIOCGIFGATTR, (caddr_t)&ifgr) == -1) {
@@ -167,7 +167,7 @@ carp_demote_ioctl(char *group, int demot
                return (-1);
        }
 
-       bzero(&ifgr, sizeof(ifgr));
+       memset(&ifgr, 0, sizeof(ifgr));
        strlcpy(ifgr.ifgr_name, group, sizeof(ifgr.ifgr_name));
        ifgr.ifgr_attrib.ifg_carp_demoted = demote;
 
Index: usr.sbin/bgpd/config.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/config.c,v
retrieving revision 1.103
diff -u -p -r1.103 config.c
--- usr.sbin/bgpd/config.c      20 Jul 2022 12:43:27 -0000      1.103
+++ usr.sbin/bgpd/config.c      17 Aug 2022 13:56:57 -0000
@@ -409,7 +409,7 @@ host(const char *s, struct bgpd_addr *h,
                p[0] = '\0';
        }
 
-       bzero(h, sizeof(*h));
+       memset(h, 0, sizeof(*h));
 
        if (host_ip(ps, h, len) == 0) {
                free(ps);
@@ -429,7 +429,7 @@ host_ip(const char *s, struct bgpd_addr 
        struct addrinfo          hints, *res;
        int                      bits;
 
-       bzero(&hints, sizeof(hints));
+       memset(&hints, 0, sizeof(hints));
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = SOCK_DGRAM; /*dummy*/
        hints.ai_flags = AI_NUMERICHOST;
Index: usr.sbin/bgpd/control.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/control.c,v
retrieving revision 1.107
diff -u -p -r1.107 control.c
--- usr.sbin/bgpd/control.c     28 Jul 2022 13:11:48 -0000      1.107
+++ usr.sbin/bgpd/control.c     17 Aug 2022 13:56:57 -0000
@@ -45,7 +45,7 @@ control_check(char *path)
        struct sockaddr_un       sa_un;
        int                      fd;
 
-       bzero(&sa_un, sizeof(sa_un));
+       memset(&sa_un, 0, sizeof(sa_un));
        sa_un.sun_family = AF_UNIX;
        strlcpy(sa_un.sun_path, path, sizeof(sa_un.sun_path));
 
@@ -78,7 +78,7 @@ control_init(int restricted, char *path)
                return (-1);
        }
 
-       bzero(&sa_un, sizeof(sa_un));
+       memset(&sa_un, 0, sizeof(sa_un));
        sa_un.sun_family = AF_UNIX;
        if (strlcpy(sa_un.sun_path, path, sizeof(sa_un.sun_path)) >=
            sizeof(sa_un.sun_path)) {
Index: usr.sbin/bgpd/kroute.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/kroute.c,v
retrieving revision 1.291
diff -u -p -r1.291 kroute.c
--- usr.sbin/bgpd/kroute.c      17 Aug 2022 10:54:52 -0000      1.291
+++ usr.sbin/bgpd/kroute.c      17 Aug 2022 13:56:57 -0000
@@ -272,7 +272,7 @@ ktable_new(u_int rtableid, u_int rdomid,
                }
                krt = xkrt;
                krt_size = rtableid + 1;
-               bzero((char *)krt + oldsize,
+               memset((char *)krt + oldsize, 0,
                    krt_size * sizeof(struct ktable *) - oldsize);
        }
 
@@ -512,7 +512,7 @@ kr6_change(struct ktable *kt, struct kro
 
        /* for blackhole and reject routes nexthop needs to be ::1 */
        if (kf->flags & (F_BLACKHOLE|F_REJECT))
-               bcopy(&lo6, &kf->nexthop.v6, sizeof(kf->nexthop.v6));
+               memcpy(&kf->nexthop.v6, &lo6, sizeof(kf->nexthop.v6));
        /* nexthop to loopback -> ignore silently */
        else if (IN6_IS_ADDR_LOOPBACK(&kf->nexthop.v6))
                return (0);
@@ -618,7 +618,7 @@ krVPN6_change(struct ktable *kt, struct 
 
        /* for blackhole and reject routes nexthop needs to be ::1 */
        if (kf->flags & (F_BLACKHOLE|F_REJECT))
-               bcopy(&lo6, &kf->nexthop.v6, sizeof(kf->nexthop.v6));
+               memcpy(&kf->nexthop.v6, &lo6, sizeof(kf->nexthop.v6));
 
        if ((kr6 = kroute6_find(kt, &kf->prefix, kf->prefixlen,
            kf->priority)) == NULL) {
@@ -840,7 +840,7 @@ kr_show_interface(struct kif *kif)
        static struct ctl_show_interface iface;
        uint64_t ifms_type;
 
-       bzero(&iface, sizeof(iface));
+       memset(&iface, 0, sizeof(iface));
        strlcpy(iface.ifname, kif->ifname, sizeof(iface.ifname));
 
        snprintf(iface.linkstate, sizeof(iface.linkstate),
@@ -957,7 +957,7 @@ kr_show_route(struct imsg *imsg)
                        break;
                }
                RB_FOREACH(h, knexthop_tree, KT2KNT(kt)) {
-                       bzero(&snh, sizeof(snh));
+                       memset(&snh, 0, sizeof(snh));
                        memcpy(&snh.addr, &h->nexthop, sizeof(snh.addr));
                        if (h->kroute != NULL) {
                                switch (h->nexthop.aid) {
@@ -1081,7 +1081,7 @@ kr_net_redist_del(struct ktable *kt, str
 {
        struct kredist_node *r, node;
 
-       bzero(&node, sizeof(node));
+       memset(&node, 0, sizeof(node));
        node.prefix = net->prefix;
        node.prefixlen = net->prefixlen;
        node.rd = net->rd;
@@ -1214,7 +1214,7 @@ kr_redistribute(int type, struct ktable 
        uint32_t                 a;
        int                      loflag = 0;
 
-       bzero(&net, sizeof(net));
+       memset(&net, 0, sizeof(net));
        net.prefix = kf->prefix;
        net.prefixlen = kf->prefixlen;
        net.rtlabel = rtlabel_name2id(kf->label);
@@ -1382,7 +1382,7 @@ kr_tofull(struct kroute *kr)
 {
        static struct kroute_full       kf;
 
-       bzero(&kf, sizeof(kf));
+       memset(&kf, 0, sizeof(kf));
 
        kf.prefix.aid = AID_INET;
        kf.prefix.v4.s_addr = kr->prefix.s_addr;
@@ -1403,7 +1403,7 @@ kr6_tofull(struct kroute6 *kr6)
 {
        static struct kroute_full       kf;
 
-       bzero(&kf, sizeof(kf));
+       memset(&kf, 0, sizeof(kf));
 
        kf.prefix.aid = AID_INET6;
        kf.prefix.v6 = kr6->prefix;
@@ -1952,7 +1952,7 @@ knexthop_find(struct ktable *kt, struct 
 {
        struct knexthop s;
 
-       bzero(&s, sizeof(s));
+       memset(&s, 0, sizeof(s));
        memcpy(&s.nexthop, addr, sizeof(s.nexthop));
 
        return (RB_FIND(knexthop_tree, KT2KNT(kt), &s));
@@ -1995,7 +1995,7 @@ kif_find(int ifindex)
 {
        struct kif      s;
 
-       bzero(&s, sizeof(s));
+       memset(&s, 0, sizeof(s));
        s.ifindex = ifindex;
 
        return (RB_FIND(kif_tree, &kit, &s));
@@ -2592,8 +2592,8 @@ get_mpe_config(const char *name, u_int *
        if (s == -1)
                return (-1);
 
-       bzero(&shim, sizeof(shim));
-       bzero(&ifr, sizeof(ifr));
+       memset(&shim, 0, sizeof(shim));
+       memset(&ifr, 0, sizeof(ifr));
        strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
        ifr.ifr_data = (caddr_t)&shim;
 
@@ -2639,7 +2639,7 @@ send_rtmsg(int fd, int action, struct kt
                return (0);
 
        /* initialize header */
-       bzero(&hdr, sizeof(hdr));
+       memset(&hdr, 0, sizeof(hdr));
        hdr.rtm_version = RTM_VERSION;
        hdr.rtm_type = action;
        hdr.rtm_tableid = kt->rtableid;
@@ -2656,7 +2656,7 @@ send_rtmsg(int fd, int action, struct kt
        iov[iovcnt].iov_base = &hdr;
        iov[iovcnt++].iov_len = sizeof(hdr);
 
-       bzero(&prefix, sizeof(prefix));
+       memset(&prefix, 0, sizeof(prefix));
        sa = addr2sa(&kf->prefix, 0, &salen);
        sa->sa_len = salen;
 #ifdef __KAME__
@@ -2680,7 +2680,7 @@ send_rtmsg(int fd, int action, struct kt
 
        /* XXX can we even have no nexthop ??? */
        if (kf->nexthop.aid != AID_UNSPEC) {
-               bzero(&nexthop, sizeof(nexthop));
+               memset(&nexthop, 0, sizeof(nexthop));
                sa = addr2sa(&kf->nexthop, 0, &salen);
                sa->sa_len = salen;
 #ifdef __KAME__
@@ -2704,11 +2704,11 @@ send_rtmsg(int fd, int action, struct kt
                iov[iovcnt++].iov_len = ROUNDUP(salen);
        }
 
-       bzero(&netmask, sizeof(netmask));
+       memset(&netmask, 0, sizeof(netmask));
        memset(&netmask.v6, 0xff, sizeof(netmask.v6));
        netmask.aid = kf->prefix.aid;
        applymask(&netmask, &netmask, kf->prefixlen);
-       bzero(&mask, sizeof(mask));
+       memset(&mask, 0, sizeof(mask));
        sa = addr2sa(&netmask, 0, &salen);
        sa->sa_len = salen;
        memcpy(&mask, sa, salen);
@@ -2721,7 +2721,7 @@ send_rtmsg(int fd, int action, struct kt
 
        if (kf->flags & F_MPLS) {
                /* need to force interface for mpe(4) routes */
-               bzero(&ifp, sizeof(ifp));
+               memset(&ifp, 0, sizeof(ifp));
                dl = (struct sockaddr_dl *)&ifp;
                salen = sizeof(*dl);
                dl->sdl_len = salen;
@@ -2734,7 +2734,7 @@ send_rtmsg(int fd, int action, struct kt
                iov[iovcnt].iov_base = &ifp;
                iov[iovcnt++].iov_len = ROUNDUP(salen);
 
-               bzero(&mpls, sizeof(mpls));
+               memset(&mpls, 0, sizeof(mpls));
                mp = (struct sockaddr_mpls *)&mpls;
                salen = sizeof(*mp);
                mp->smpls_len = salen;
@@ -2753,7 +2753,7 @@ send_rtmsg(int fd, int action, struct kt
        }
 
        if (kf->label[0] != '\0') {
-               bzero(&label, sizeof(label));
+               memset(&label, 0, sizeof(label));
                la = (struct sockaddr_rtlabel *)&label;
                salen = sizeof(struct sockaddr_rtlabel);
                label.ss_len = salen;
Index: usr.sbin/bgpd/mrt.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/mrt.c,v
retrieving revision 1.108
diff -u -p -r1.108 mrt.c
--- usr.sbin/bgpd/mrt.c 28 Jul 2022 13:11:48 -0000      1.108
+++ usr.sbin/bgpd/mrt.c 17 Aug 2022 13:56:57 -0000
@@ -449,7 +449,7 @@ mrt_dump_entry_mp(struct mrt *mrt, struc
 
        n = prefix_nexthop(p);
        if (n == NULL) {
-               bzero(&nexthop, sizeof(struct bgpd_addr));
+               memset(&nexthop, 0, sizeof(struct bgpd_addr));
                nexthop.aid = addr.aid;
                nh = &nexthop;
        } else
@@ -543,7 +543,7 @@ mrt_dump_entry(struct mrt *mrt, struct p
 
        nexthop = prefix_nexthop(p);
        if (nexthop == NULL) {
-               bzero(&addr, sizeof(struct bgpd_addr));
+               memset(&addr, 0, sizeof(struct bgpd_addr));
                addr.aid = p->pt->aid;
                nh = &addr;
        } else
@@ -645,7 +645,7 @@ mrt_dump_entry_v2_rib(struct rib_entry *
 
                nexthop = prefix_nexthop(p);
                if (nexthop == NULL) {
-                       bzero(&addr, sizeof(struct bgpd_addr));
+                       memset(&addr, 0, sizeof(struct bgpd_addr));
                        addr.aid = re->prefix->aid;
                        nh = &addr;
                } else
Index: usr.sbin/bgpd/parse.y
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/parse.y,v
retrieving revision 1.434
diff -u -p -r1.434 parse.y
--- usr.sbin/bgpd/parse.y       28 Jul 2022 13:11:49 -0000      1.434
+++ usr.sbin/bgpd/parse.y       17 Aug 2022 13:56:57 -0000
@@ -1949,10 +1949,10 @@ espah           : ESP           { $$ = 1; }
                ;
 
 encspec                : /* nada */    {
-                       bzero(&$$, sizeof($$));
+                       memset(&$$, 0, sizeof($$));
                }
                | STRING STRING {
-                       bzero(&$$, sizeof($$));
+                       memset(&$$, 0, sizeof($$));
                        if (!strcmp($1, "3des") || !strcmp($1, "3des-cbc")) {
                                $$.enc_alg = AUTH_EALG_3DESCBC;
                                $$.enc_key_len = 21; /* XXX verify */
@@ -1990,7 +1990,7 @@ filterrule        : action quick filter_rib_h d
                        struct filter_rule       r;
                        struct filter_rib_l      *rb, *rbnext;
 
-                       bzero(&r, sizeof(r));
+                       memset(&r, 0, sizeof(r));
                        r.action = $1;
                        r.quick = $2;
                        r.dir = $4;
@@ -2317,10 +2317,10 @@ filter_as       : as4number_any         {
                ;
 
 filter_match_h : /* empty */                   {
-                       bzero(&$$, sizeof($$));
+                       memset(&$$, 0, sizeof($$));
                }
                | {
-                       bzero(&fmopts, sizeof(fmopts));
+                       memset(&fmopts, 0, sizeof(fmopts));
                }
                    filter_match                {
                        memcpy(&$$, &fmopts, sizeof($$));
@@ -2568,15 +2568,15 @@ filter_elm      : filter_prefix_h       {
                }
                ;
 
-prefixlenop    : /* empty */                   { bzero(&$$, sizeof($$)); }
+prefixlenop    : /* empty */                   { memset(&$$, 0, sizeof($$)); }
                | LONGER                                {
-                       bzero(&$$, sizeof($$));
+                       memset(&$$, 0, sizeof($$));
                        $$.op = OP_RANGE;
                        $$.len_min = -1;
                        $$.len_max = -1;
                }
                | MAXLEN NUMBER                         {
-                       bzero(&$$, sizeof($$));
+                       memset(&$$, 0, sizeof($$));
                        if ($2 < 0 || $2 > 128) {
                                yyerror("prefixlen must be >= 0 and <= 128");
                                YYERROR;
@@ -2589,7 +2589,7 @@ prefixlenop       : /* empty */                   { 
bzero(&$$,
                | PREFIXLEN unaryop NUMBER              {
                        int min, max;
 
-                       bzero(&$$, sizeof($$));
+                       memset(&$$, 0, sizeof($$));
                        if ($3 < 0 || $3 > 128) {
                                yyerror("prefixlen must be >= 0 and <= 128");
                                YYERROR;
@@ -2630,7 +2630,7 @@ prefixlenop       : /* empty */                   { 
bzero(&$$,
                        $$.len_max = max;
                }
                | PREFIXLEN NUMBER binaryop NUMBER      {
-                       bzero(&$$, sizeof($$));
+                       memset(&$$, 0, sizeof($$));
                        if ($2 < 0 || $2 > 128 || $4 < 0 || $4 > 128) {
                                yyerror("prefixlen must be < 128");
                                YYERROR;
Index: usr.sbin/bgpd/pfkey.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/pfkey.c,v
retrieving revision 1.66
diff -u -p -r1.66 pfkey.c
--- usr.sbin/bgpd/pfkey.c       28 Jul 2022 13:11:50 -0000      1.66
+++ usr.sbin/bgpd/pfkey.c       17 Aug 2022 13:56:57 -0000
@@ -91,8 +91,8 @@ pfkey_send(int sd, uint8_t satype, uint8
                pid = getpid();
 
        /* we need clean sockaddr... no ports set */
-       bzero(&ssrc, sizeof(ssrc));
-       bzero(&smask, sizeof(smask));
+       memset(&ssrc, 0, sizeof(ssrc));
+       memset(&smask, 0, sizeof(smask));
        if ((saptr = addr2sa(src, 0, &salen))) {
                memcpy(&ssrc, saptr, salen);
                ssrc.ss_len = salen;
@@ -114,8 +114,8 @@ pfkey_send(int sd, uint8_t satype, uint8
        smask.ss_family = ssrc.ss_family;
        smask.ss_len = ssrc.ss_len;
 
-       bzero(&sdst, sizeof(sdst));
-       bzero(&dmask, sizeof(dmask));
+       memset(&sdst, 0, sizeof(sdst));
+       memset(&dmask, 0, sizeof(dmask));
        if ((saptr = addr2sa(dst, 0, &salen))) {
                memcpy(&sdst, saptr, salen);
                sdst.ss_len = salen;
@@ -137,7 +137,7 @@ pfkey_send(int sd, uint8_t satype, uint8
        dmask.ss_family = sdst.ss_family;
        dmask.ss_len = sdst.ss_len;
 
-       bzero(&smsg, sizeof(smsg));
+       memset(&smsg, 0, sizeof(smsg));
        smsg.sadb_msg_version = PF_KEY_V2;
        smsg.sadb_msg_seq = ++sadb_msg_seq;
        smsg.sadb_msg_pid = pid;
@@ -147,7 +147,7 @@ pfkey_send(int sd, uint8_t satype, uint8
 
        switch (mtype) {
        case SADB_GETSPI:
-               bzero(&sa_spirange, sizeof(sa_spirange));
+               memset(&sa_spirange, 0, sizeof(sa_spirange));
                sa_spirange.sadb_spirange_exttype = SADB_EXT_SPIRANGE;
                sa_spirange.sadb_spirange_len = sizeof(sa_spirange) / 8;
                sa_spirange.sadb_spirange_min = 0x100;
@@ -157,7 +157,7 @@ pfkey_send(int sd, uint8_t satype, uint8
        case SADB_ADD:
        case SADB_UPDATE:
        case SADB_DELETE:
-               bzero(&sa, sizeof(sa));
+               memset(&sa, 0, sizeof(sa));
                sa.sadb_sa_exttype = SADB_EXT_SA;
                sa.sadb_sa_len = sizeof(sa) / 8;
                sa.sadb_sa_replay = 0;
@@ -166,13 +166,13 @@ pfkey_send(int sd, uint8_t satype, uint8
                break;
        case SADB_X_ADDFLOW:
        case SADB_X_DELFLOW:
-               bzero(&sa_flowtype, sizeof(sa_flowtype));
+               memset(&sa_flowtype, 0, sizeof(sa_flowtype));
                sa_flowtype.sadb_protocol_exttype = SADB_X_EXT_FLOW_TYPE;
                sa_flowtype.sadb_protocol_len = sizeof(sa_flowtype) / 8;
                sa_flowtype.sadb_protocol_direction = dir;
                sa_flowtype.sadb_protocol_proto = SADB_X_FLOW_TYPE_REQUIRE;
 
-               bzero(&sa_protocol, sizeof(sa_protocol));
+               memset(&sa_protocol, 0, sizeof(sa_protocol));
                sa_protocol.sadb_protocol_exttype = SADB_X_EXT_PROTOCOL;
                sa_protocol.sadb_protocol_len = sizeof(sa_protocol) / 8;
                sa_protocol.sadb_protocol_direction = 0;
@@ -180,11 +180,11 @@ pfkey_send(int sd, uint8_t satype, uint8
                break;
        }
 
-       bzero(&sa_src, sizeof(sa_src));
+       memset(&sa_src, 0, sizeof(sa_src));
        sa_src.sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
        sa_src.sadb_address_len = (sizeof(sa_src) + ROUNDUP(ssrc.ss_len)) / 8;
 
-       bzero(&sa_dst, sizeof(sa_dst));
+       memset(&sa_dst, 0, sizeof(sa_dst));
        sa_dst.sadb_address_exttype = SADB_EXT_ADDRESS_DST;
        sa_dst.sadb_address_len = (sizeof(sa_dst) + ROUNDUP(sdst.ss_len)) / 8;
 
@@ -194,13 +194,13 @@ pfkey_send(int sd, uint8_t satype, uint8
        switch (mtype) {
        case SADB_ADD:
        case SADB_UPDATE:
-               bzero(&sa_akey, sizeof(sa_akey));
+               memset(&sa_akey, 0, sizeof(sa_akey));
                sa_akey.sadb_key_exttype = SADB_EXT_KEY_AUTH;
                sa_akey.sadb_key_len = (sizeof(sa_akey) +
                    ((alen + 7) / 8) * 8) / 8;
                sa_akey.sadb_key_bits = 8 * alen;
 
-               bzero(&sa_ekey, sizeof(sa_ekey));
+               memset(&sa_ekey, 0, sizeof(sa_ekey));
                sa_ekey.sadb_key_exttype = SADB_EXT_KEY_ENCRYPT;
                sa_ekey.sadb_key_len = (sizeof(sa_ekey) +
                    ((elen + 7) / 8) * 8) / 8;
@@ -225,7 +225,7 @@ pfkey_send(int sd, uint8_t satype, uint8
                sa_src.sadb_address_exttype = SADB_X_EXT_SRC_FLOW;
                sa_dst.sadb_address_exttype = SADB_X_EXT_DST_FLOW;
 
-               bzero(&smask, sizeof(smask));
+               memset(&smask, 0, sizeof(smask));
                switch (src->aid) {
                case AID_INET:
                        smask.ss_len = sizeof(struct sockaddr_in);
@@ -252,7 +252,7 @@ pfkey_send(int sd, uint8_t satype, uint8
                        }
                        break;
                }
-               bzero(&dmask, sizeof(dmask));
+               memset(&dmask, 0, sizeof(dmask));
                switch (dst->aid) {
                case AID_INET:
                        dmask.ss_len = sizeof(struct sockaddr_in);
@@ -280,12 +280,12 @@ pfkey_send(int sd, uint8_t satype, uint8
                        break;
                }
 
-               bzero(&sa_smask, sizeof(sa_smask));
+               memset(&sa_smask, 0, sizeof(sa_smask));
                sa_smask.sadb_address_exttype = SADB_X_EXT_SRC_MASK;
                sa_smask.sadb_address_len =
                    (sizeof(sa_smask) + ROUNDUP(smask.ss_len)) / 8;
 
-               bzero(&sa_dmask, sizeof(sa_dmask));
+               memset(&sa_dmask, 0, sizeof(sa_dmask));
                sa_dmask.sadb_address_exttype = SADB_X_EXT_DST_MASK;
                sa_dmask.sadb_address_len =
                    (sizeof(sa_dmask) + ROUNDUP(dmask.ss_len)) / 8;
@@ -432,7 +432,7 @@ pfkey_read(int sd, struct sadb_msg *h)
        if (hdr.sadb_msg_seq == sadb_msg_seq &&
            hdr.sadb_msg_pid == pid) {
                if (h)
-                       bcopy(&hdr, h, sizeof(hdr));
+                       memcpy(h, &hdr, sizeof(hdr));
                return (0);
        }
 
Index: usr.sbin/bgpd/pftable.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/pftable.c,v
retrieving revision 1.16
diff -u -p -r1.16 pftable.c
--- usr.sbin/bgpd/pftable.c     6 Feb 2022 09:51:19 -0000       1.16
+++ usr.sbin/bgpd/pftable.c     17 Aug 2022 13:56:57 -0000
@@ -66,7 +66,7 @@ pftable_change(struct pf_table *pft)
        if (devpf == -1 && ((devpf = open("/dev/pf", O_RDWR|O_CLOEXEC)) == -1))
                fatal("open(/dev/pf)");
 
-       bzero(&tio, sizeof(tio));
+       memset(&tio, 0, sizeof(tio));
        strlcpy(tio.pfrio_table.pfrt_name, pft->name,
            sizeof(tio.pfrio_table.pfrt_name));
        tio.pfrio_buffer = pft->worklist;
@@ -93,7 +93,7 @@ pftable_clear(const char *name)
        if (devpf == -1 && ((devpf = open("/dev/pf", O_RDWR|O_CLOEXEC)) == -1))
                fatal("open(/dev/pf)");
 
-       bzero(&tio, sizeof(tio));
+       memset(&tio, 0, sizeof(tio));
        strlcpy(tio.pfrio_table.pfrt_name, name,
            sizeof(tio.pfrio_table.pfrt_name));
 
@@ -114,7 +114,7 @@ pftable_exists(const char *name)
        if (devpf == -1 && ((devpf = open("/dev/pf", O_RDWR|O_CLOEXEC)) == -1))
                fatal("open(/dev/pf)");
 
-       bzero(&tio, sizeof(tio));
+       memset(&tio, 0, sizeof(tio));
        strlcpy(tio.pfrio_table.pfrt_name, name,
            sizeof(tio.pfrio_table.pfrt_name));
        tio.pfrio_buffer = &dummy;
@@ -215,7 +215,7 @@ pftable_add_work(const char *table, stru
        pft->worklist = tmp;
        pfa = &pft->worklist[pft->naddrs];
 
-       bzero(pfa, sizeof(*pfa));
+       memset(pfa, 0, sizeof(*pfa));
        memcpy(&pfa->pfra_u, &addr->ba, (len + 7U) / 8);
        pfa->pfra_af = aid2af(addr->aid);
        pfa->pfra_net = len;
Index: usr.sbin/bgpd/rde.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/rde.c,v
retrieving revision 1.563
diff -u -p -r1.563 rde.c
--- usr.sbin/bgpd/rde.c 16 Aug 2022 08:14:58 -0000      1.563
+++ usr.sbin/bgpd/rde.c 17 Aug 2022 13:56:57 -0000
@@ -230,7 +230,7 @@ rde_main(int debug, int verbose)
                        pfd_elms = PFD_PIPE_COUNT + rde_mrt_cnt;
                }
                timeout = -1;
-               bzero(pfd, sizeof(struct pollfd) * pfd_elms);
+               memset(pfd, 0, sizeof(struct pollfd) * pfd_elms);
 
                set_pollfd(&pfd[PFD_PIPE_MAIN], ibuf_main);
                set_pollfd(&pfd[PFD_PIPE_SESSION], ibuf_se);
@@ -425,7 +425,7 @@ rde_dispatch_imsg_session(struct imsgbuf
                        if (imsg.hdr.len - IMSG_HEADER_SIZE <
                            sizeof(csr)) {
                                log_warnx("rde_dispatch: wrong imsg len");
-                               bzero(&netconf_s, sizeof(netconf_s));
+                               memset(&netconf_s, 0, sizeof(netconf_s));
                                break;
                        }
                        aslen = imsg.hdr.len - IMSG_HEADER_SIZE - sizeof(csr);
@@ -454,7 +454,7 @@ rde_dispatch_imsg_session(struct imsgbuf
                                log_warnx("rde_dispatch: bad network "
                                    "attribute");
                                rde_filterstate_clean(&netconf_state);
-                               bzero(&netconf_s, sizeof(netconf_s));
+                               memset(&netconf_s, 0, sizeof(netconf_s));
                                break;
                        }
                        break;
@@ -1239,7 +1239,7 @@ rde_update_dispatch(struct rde_peer *pee
                }
        }
 
-       bzero(&mpa, sizeof(mpa));
+       memset(&mpa, 0, sizeof(mpa));
        rde_filterstate_prep(&state, NULL, NULL, NULL, 0);
        if (attrpath_len != 0) { /* 0 = no NLRI information in this message */
                /* parse path attributes */
@@ -1857,7 +1857,7 @@ bad_flags:
                        goto bad_list;
                a->flags |= F_ATTR_NEXTHOP;
 
-               bzero(&nexthop, sizeof(nexthop));
+               memset(&nexthop, 0, sizeof(nexthop));
                nexthop.aid = AID_INET;
                UPD_READ(&nexthop.v4.s_addr, p, plen, 4);
                /*
@@ -2212,7 +2212,7 @@ rde_get_mp_nexthop(u_char *data, uint16_
        if (nhlen > len)
                return (-1);
 
-       bzero(&nexthop, sizeof(nexthop));
+       memset(&nexthop, 0, sizeof(nexthop));
        nexthop.aid = aid;
        switch (aid) {
        case AID_INET6:
@@ -3048,7 +3048,7 @@ rde_send_kroute(struct rib *rib, struct 
                p = new;
        }
 
-       bzero(&kf, sizeof(kf));
+       memset(&kf, 0, sizeof(kf));
        pt_getaddr(p->pt, &kf.prefix);
        kf.prefixlen = p->pt->prefixlen;
        if (type == IMSG_KROUTE_CHANGE) {
@@ -3158,7 +3158,7 @@ rde_update_queue_runner(void)
                        /* now bgp path attributes unless it is the EoR mark */
                        if (up_is_eor(peer, AID_INET)) {
                                eor = 1;
-                               bzero(queue_buf + wpos, 2);
+                               memset(queue_buf + wpos, 0, 2);
                                wpos += 2;
                        } else {
                                r = up_dump_attrnlri(queue_buf + wpos,
@@ -3293,7 +3293,7 @@ rde_pftable_send(uint16_t id, struct pt_
        if (rde_quit)
                return;
 
-       bzero(&pfm, sizeof(pfm));
+       memset(&pfm, 0, sizeof(pfm));
        strlcpy(pfm.pftable, pftable_id2name(id), sizeof(pfm.pftable));
        pt_getaddr(pt, &pfm.addr);
        pfm.len = pt->prefixlen;
@@ -4006,7 +4006,7 @@ rde_peer_send_eor(struct rde_peer *peer,
        if (aid == AID_INET) {
                u_char null[4];
 
-               bzero(&null, 4);
+               memset(&null, 0, 4);
                if (imsg_compose(ibuf_se, IMSG_UPDATE, peer->conf.id,
                    0, -1, &null, 4) == -1)
                        fatal("imsg_compose error while sending EoR");
@@ -4018,14 +4018,14 @@ rde_peer_send_eor(struct rde_peer *peer,
                        fatalx("peer_send_eor: bad AID");
 
                i = 0;  /* v4 withdrawn len */
-               bcopy(&i, &buf[0], sizeof(i));
+               memcpy(&buf[0], &i, sizeof(i));
                i = htons(6);   /* path attr len */
-               bcopy(&i, &buf[2], sizeof(i));
+               memcpy(&buf[2], &i, sizeof(i));
                buf[4] = ATTR_OPTIONAL;
                buf[5] = ATTR_MP_UNREACH_NLRI;
                buf[6] = 3;     /* withdrawn len */
                i = htons(afi);
-               bcopy(&i, &buf[7], sizeof(i));
+               memcpy(&buf[7], &i, sizeof(i));
                buf[9] = safi;
 
                if (imsg_compose(ibuf_se, IMSG_UPDATE, peer->conf.id,
Index: usr.sbin/bgpd/rde_peer.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/rde_peer.c,v
retrieving revision 1.20
diff -u -p -r1.20 rde_peer.c
--- usr.sbin/bgpd/rde_peer.c    28 Jul 2022 13:11:51 -0000      1.20
+++ usr.sbin/bgpd/rde_peer.c    17 Aug 2022 13:56:57 -0000
@@ -99,7 +99,7 @@ peer_init(uint32_t hashsize)
 
        peertable.peer_hashmask = hs - 1;
 
-       bzero(&pc, sizeof(pc));
+       memset(&pc, 0, sizeof(pc));
        snprintf(pc.descr, sizeof(pc.descr), "LOCAL");
        pc.id = PEER_ID_SELF;
 
Index: usr.sbin/bgpd/rde_prefix.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/rde_prefix.c,v
retrieving revision 1.41
diff -u -p -r1.41 rde_prefix.c
--- usr.sbin/bgpd/rde_prefix.c  25 Feb 2022 12:56:12 -0000      1.41
+++ usr.sbin/bgpd/rde_prefix.c  17 Aug 2022 13:56:57 -0000
@@ -72,7 +72,7 @@ pt_shutdown(void)
 void
 pt_getaddr(struct pt_entry *pte, struct bgpd_addr *addr)
 {
-       bzero(addr, sizeof(struct bgpd_addr));
+       memset(addr, 0, sizeof(struct bgpd_addr));
        addr->aid = pte->aid;
        switch (addr->aid) {
        case AID_INET:
@@ -113,7 +113,7 @@ pt_fill(struct bgpd_addr *prefix, int pr
 
        switch (prefix->aid) {
        case AID_INET:
-               bzero(&pte4, sizeof(pte4));
+               memset(&pte4, 0, sizeof(pte4));
                pte4.aid = prefix->aid;
                if (prefixlen > 32)
                        fatalx("pt_fill: bad IPv4 prefixlen");
@@ -121,7 +121,7 @@ pt_fill(struct bgpd_addr *prefix, int pr
                pte4.prefixlen = prefixlen;
                return ((struct pt_entry *)&pte4);
        case AID_INET6:
-               bzero(&pte6, sizeof(pte6));
+               memset(&pte6, 0, sizeof(pte6));
                pte6.aid = prefix->aid;
                if (prefixlen > 128)
                        fatalx("pt_fill: bad IPv6 prefixlen");
@@ -129,7 +129,7 @@ pt_fill(struct bgpd_addr *prefix, int pr
                pte6.prefixlen = prefixlen;
                return ((struct pt_entry *)&pte6);
        case AID_VPN_IPv4:
-               bzero(&pte_vpn4, sizeof(pte_vpn4));
+               memset(&pte_vpn4, 0, sizeof(pte_vpn4));
                pte_vpn4.aid = prefix->aid;
                if (prefixlen > 32)
                        fatalx("pt_fill: bad IPv4 prefixlen");
Index: usr.sbin/bgpd/rde_update.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/rde_update.c,v
retrieving revision 1.145
diff -u -p -r1.145 rde_update.c
--- usr.sbin/bgpd/rde_update.c  11 Jul 2022 17:08:21 -0000      1.145
+++ usr.sbin/bgpd/rde_update.c  17 Aug 2022 13:56:57 -0000
@@ -392,7 +392,7 @@ up_generate_default(struct filter_head *
         */
        /* rde_apply_set(asp, peerself, peerself, set, af); */
 
-       bzero(&addr, sizeof(addr));
+       memset(&addr, 0, sizeof(addr));
        addr.aid = aid;
        p = prefix_adjout_lookup(peer, &addr, 0);
 
@@ -898,7 +898,7 @@ up_dump_mp_unreach(u_char *buf, int len,
        memcpy(attrbuf + 2, &attr_len, sizeof(attr_len));
 
        /* write length fields */
-       bzero(buf, sizeof(uint16_t));   /* withdrawn routes len */
+       memset(buf, 0, sizeof(uint16_t));       /* withdrawn routes len */
        attr_len = htons(wpos - 4);
        memcpy(buf + 2, &attr_len, sizeof(attr_len));
 
@@ -934,7 +934,7 @@ up_dump_attrnlri(u_char *buf, int len, s
                 * an invalid bgp update.
                 */
 done:
-               bzero(buf, 2);
+               memset(buf, 0, 2);
                return (2);
        }
 
@@ -998,7 +998,7 @@ up_generate_mp_reach(u_char *buf, int le
                tmp = htons(tmp);
                memcpy(attrbuf, &tmp, sizeof(tmp));
                attrbuf[3] = sizeof(uint64_t) + sizeof(struct in_addr);
-               bzero(attrbuf + 4, sizeof(uint64_t));
+               memset(attrbuf + 4, 0, sizeof(uint64_t));
                attrbuf[16] = 0; /* Reserved must be 0 */
 
                /* write nexthop */
@@ -1016,7 +1016,7 @@ up_generate_mp_reach(u_char *buf, int le
                tmp = htons(tmp);
                memcpy(attrbuf, &tmp, sizeof(tmp));
                attrbuf[3] = sizeof(uint64_t) + sizeof(struct in6_addr);
-               bzero(attrbuf + 4, sizeof(uint64_t));
+               memset(attrbuf + 4, 0, sizeof(uint64_t));
                attrbuf[28] = 0; /* Reserved must be 0 */
 
                /* write nexthop */
@@ -1080,7 +1080,7 @@ up_dump_mp_reach(u_char *buf, int len, s
        wpos += r;
 
        /* write length fields */
-       bzero(buf, sizeof(uint16_t));   /* withdrawn routes len */
+       memset(buf, 0, sizeof(uint16_t));       /* withdrawn routes len */
        attr_len = htons(wpos - 4);
        memcpy(buf + 2, &attr_len, sizeof(attr_len));
 
Index: usr.sbin/bgpd/rtr.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/rtr.c,v
retrieving revision 1.5
diff -u -p -r1.5 rtr.c
--- usr.sbin/bgpd/rtr.c 20 Jan 2022 18:06:20 -0000      1.5
+++ usr.sbin/bgpd/rtr.c 17 Aug 2022 13:56:57 -0000
@@ -158,7 +158,7 @@ rtr_main(int debug, int verbose)
                if (timeout == -1)
                        fatalx("roa-set expire timer no longer runnning");
 
-               bzero(pfd, sizeof(struct pollfd) * pfd_elms);
+               memset(pfd, 0, sizeof(struct pollfd) * pfd_elms);
 
                set_pollfd(&pfd[PFD_PIPE_MAIN], ibuf_main);
                set_pollfd(&pfd[PFD_PIPE_RDE], ibuf_rde);
Index: usr.sbin/bgpd/session.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/session.c,v
retrieving revision 1.432
diff -u -p -r1.432 session.c
--- usr.sbin/bgpd/session.c     28 Jul 2022 13:11:51 -0000      1.432
+++ usr.sbin/bgpd/session.c     17 Aug 2022 13:56:57 -0000
@@ -336,7 +336,7 @@ session_main(int debug, int verbose)
                        pfd_elms = new_cnt;
                }
 
-               bzero(pfd, sizeof(struct pollfd) * pfd_elms);
+               memset(pfd, 0, sizeof(struct pollfd) * pfd_elms);
 
                set_pollfd(&pfd[PFD_PIPE_MAIN], ibuf_main);
                set_pollfd(&pfd[PFD_PIPE_ROUTE], ibuf_rde);
@@ -892,7 +892,7 @@ change_state(struct peer *peer, enum ses
                free(peer->rbuf);
                peer->rbuf = NULL;
                peer->rpending = 0;
-               bzero(&peer->capa.peer, sizeof(peer->capa.peer));
+               memset(&peer->capa.peer, 0, sizeof(peer->capa.peer));
                if (!peer->template)
                        imsg_compose(ibuf_main, IMSG_PFKEY_RELOAD,
                            peer->conf.id, 0, -1, NULL, 0);
@@ -938,7 +938,7 @@ change_state(struct peer *peer, enum ses
                        timer_stop(&peer->timers, Timer_IdleHoldReset);
                        session_close_connection(peer);
                        msgbuf_clear(&peer->wbuf);
-                       bzero(&peer->capa.peer, sizeof(peer->capa.peer));
+                       memset(&peer->capa.peer, 0, sizeof(peer->capa.peer));
                }
                break;
        case STATE_ACTIVE:
@@ -1300,7 +1300,7 @@ session_tcp_established(struct peer *pee
 void
 session_capa_ann_none(struct peer *peer)
 {
-       bzero(&peer->capa.ann, sizeof(peer->capa.ann));
+       memset(&peer->capa.ann, 0, sizeof(peer->capa.ann));
 }
 
 int
@@ -3296,7 +3296,7 @@ la_cmp(struct listen_addr *a, struct lis
        case AF_INET6:
                in6_a = (struct sockaddr_in6 *)&a->sa;
                in6_b = (struct sockaddr_in6 *)&b->sa;
-               if (bcmp(&in6_a->sin6_addr, &in6_b->sin6_addr,
+               if (memcmp(&in6_a->sin6_addr, &in6_b->sin6_addr,
                    sizeof(struct in6_addr)))
                        return (1);
                if (in6_a->sin6_port != in6_b->sin6_port)
@@ -3457,7 +3457,7 @@ session_match_mask(struct peer *p, struc
 void
 session_down(struct peer *peer)
 {
-       bzero(&peer->capa.neg, sizeof(peer->capa.neg));
+       memset(&peer->capa.neg, 0, sizeof(peer->capa.neg));
        peer->stats.last_updown = getmonotime();
        /*
         * session_down is called in the exit code path so check
Index: usr.sbin/bgpd/util.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpd/util.c,v
retrieving revision 1.70
diff -u -p -r1.70 util.c
--- usr.sbin/bgpd/util.c        19 Jul 2022 13:03:09 -0000      1.70
+++ usr.sbin/bgpd/util.c        17 Aug 2022 13:56:57 -0000
@@ -60,7 +60,7 @@ log_in6addr(const struct in6_addr *addr)
 {
        struct sockaddr_in6     sa_in6;
 
-       bzero(&sa_in6, sizeof(sa_in6));
+       memset(&sa_in6, 0, sizeof(sa_in6));
        sa_in6.sin6_family = AF_INET6;
        memcpy(&sa_in6.sin6_addr, addr, sizeof(sa_in6.sin6_addr));
 
@@ -531,7 +531,7 @@ nlri_get_prefix(u_char *p, uint16_t len,
        pfxlen = *p++;
        len--;
 
-       bzero(prefix, sizeof(struct bgpd_addr));
+       memset(prefix, 0, sizeof(struct bgpd_addr));
        prefix->aid = AID_INET;
        *prefixlen = pfxlen;
 
@@ -557,7 +557,7 @@ nlri_get_prefix6(u_char *p, uint16_t len
        pfxlen = *p++;
        len--;
 
-       bzero(prefix, sizeof(struct bgpd_addr));
+       memset(prefix, 0, sizeof(struct bgpd_addr));
        prefix->aid = AID_INET6;
        *prefixlen = pfxlen;
 
@@ -585,7 +585,7 @@ nlri_get_vpn4(u_char *p, uint16_t len, s
        p += 1;
        plen = 1;
 
-       bzero(prefix, sizeof(struct bgpd_addr));
+       memset(prefix, 0, sizeof(struct bgpd_addr));
 
        /* label stack */
        do {
@@ -796,7 +796,7 @@ inet6applymask(struct in6_addr *dest, co
        struct in6_addr mask;
        int             i;
 
-       bzero(&mask, sizeof(mask));
+       memset(&mask, 0, sizeof(mask));
        for (i = 0; i < prefixlen / 8; i++)
                mask.s6_addr[i] = 0xff;
        i = prefixlen % 8;
@@ -898,7 +898,7 @@ addr2sa(const struct bgpd_addr *addr, ui
        if (addr == NULL || addr->aid == AID_UNSPEC)
                return (NULL);
 
-       bzero(&ss, sizeof(ss));
+       memset(&ss, 0, sizeof(ss));
        switch (addr->aid) {
        case AID_INET:
        case AID_VPN_IPv4:
@@ -927,7 +927,7 @@ sa2addr(struct sockaddr *sa, struct bgpd
        struct sockaddr_in              *sa_in = (struct sockaddr_in *)sa;
        struct sockaddr_in6             *sa_in6 = (struct sockaddr_in6 *)sa;
 
-       bzero(addr, sizeof(*addr));
+       memset(addr, 0, sizeof(*addr));
        switch (sa->sa_family) {
        case AF_INET:
                addr->aid = AID_INET;

Reply via email to