*     Check for bad requests for 127.x.x.x and requests for multicast
  *     addresses.  If this is one such, delete it.
  */
-       if (LOOPBACK(tip) || MULTICAST(tip))
+       if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
                goto out;
 
 /*
 
 
        oif = sk->sk_bound_dev_if;
        saddr = inet->saddr;
-       if (MULTICAST(usin->sin_addr.s_addr)) {
+       if (ipv4_is_multicast(usin->sin_addr.s_addr)) {
                if (!oif)
                        oif = inet->mc_index;
                if (!saddr)
 
                in_dev_hold(in_dev);
                ifa->ifa_dev = in_dev;
        }
-       if (LOOPBACK(ifa->ifa_local))
+       if (ipv4_is_loopback(ifa->ifa_local))
                ifa->ifa_scope = RT_SCOPE_HOST;
        return inet_insert_ifa(ifa);
 }
 {
        int rc = -1;    /* Something else, probably a multicast. */
 
-       if (ZERONET(addr))
+       if (ipv4_is_zeronet(addr))
                rc = 0;
        else {
                __u32 haddr = ntohl(addr);
 
        unsigned ret = RTN_BROADCAST;
        struct fib_table *local_table;
 
-       if (ZERONET(addr) || BADCLASS(addr))
+       if (ipv4_is_zeronet(addr) || ipv4_is_badclass(addr))
                return RTN_BROADCAST;
-       if (MULTICAST(addr))
+       if (ipv4_is_multicast(addr))
                return RTN_MULTICAST;
 
 #ifdef CONFIG_IP_MULTIPLE_TABLES
        if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
                fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 
-       if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
+       if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
            (prefix != addr || ifa->ifa_prefixlen < 32)) {
                fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
                          RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
 
        int ifindex;
        int count = 0;
 
-       if (!MULTICAST(addr))
+       if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
        rtnl_lock();
        int leavegroup = 0;
        int i, j, rv;
 
-       if (!MULTICAST(addr))
+       if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
        rtnl_lock();
        struct ip_sf_socklist *newpsl, *psl;
        int leavegroup = 0;
 
-       if (!MULTICAST(addr))
+       if (!ipv4_is_multicast(addr))
                return -EINVAL;
        if (msf->imsf_fmode != MCAST_INCLUDE &&
            msf->imsf_fmode != MCAST_EXCLUDE)
        struct inet_sock *inet = inet_sk(sk);
        struct ip_sf_socklist *psl;
 
-       if (!MULTICAST(addr))
+       if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
        rtnl_lock();
        if (psin->sin_family != AF_INET)
                return -EINVAL;
        addr = psin->sin_addr.s_addr;
-       if (!MULTICAST(addr))
+       if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
        rtnl_lock();
        struct ip_sf_socklist *psl;
        int i;
 
-       if (!MULTICAST(loc_addr))
+       if (!ipv4_is_multicast(loc_addr))
                return 1;
 
        for (pmc=inet->mc_list; pmc; pmc=pmc->next) {
 
        }
        for (t = tunnels_l[h1]; t; t = t->next) {
                if (local == t->parms.iph.saddr ||
-                    (local == t->parms.iph.daddr && MULTICAST(local))) {
+                    (local == t->parms.iph.daddr &&
+                     ipv4_is_multicast(local))) {
                        if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
                                return t;
                }
 
        if (local)
                prio |= 1;
-       if (remote && !MULTICAST(remote)) {
+       if (remote && !ipv4_is_multicast(remote)) {
                prio |= 2;
                h ^= HASH(remote);
        }
 
        read_lock(&ipgre_lock);
        t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((__be32*)p) + (grehlen>>2) - 1) : 0);
-       if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
+       if (t == NULL || t->parms.iph.daddr == 0 ||
+           ipv4_is_multicast(t->parms.iph.daddr))
                goto out;
 
        if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
                skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
                skb->pkt_type = PACKET_HOST;
 #ifdef CONFIG_NET_IPGRE_BROADCAST
-               if (MULTICAST(iph->daddr)) {
+               if (ipv4_is_multicast(iph->daddr)) {
                        /* Looped back packet, drop it! */
                        if (((struct rtable*)skb->dst)->fl.iif == 0)
                                goto drop;
                struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
 
                if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
-                       if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
+                       if ((tunnel->parms.iph.daddr &&
+                            !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
                            rt6->rt6i_dst.plen == 128) {
                                rt6->rt6i_flags |= RTF_MODIFIED;
                                skb->dst->metrics[RTAX_MTU-1] = mtu;
 
                                t = netdev_priv(dev);
 
-                               if (MULTICAST(p.iph.daddr))
+                               if (ipv4_is_multicast(p.iph.daddr))
                                        nflags = IFF_BROADCAST;
                                else if (p.iph.daddr)
                                        nflags = IFF_POINTOPOINT;
                memcpy(&iph->daddr, daddr, 4);
                return t->hlen;
        }
-       if (iph->daddr && !MULTICAST(iph->daddr))
+       if (iph->daddr && !ipv4_is_multicast(iph->daddr))
                return t->hlen;
 
        return -t->hlen;
 {
        struct ip_tunnel *t = netdev_priv(dev);
 
-       if (MULTICAST(t->parms.iph.daddr)) {
+       if (ipv4_is_multicast(t->parms.iph.daddr)) {
                struct flowi fl = { .oif = t->parms.link,
                                    .nl_u = { .ip4_u =
                                              { .daddr = t->parms.iph.daddr,
 static int ipgre_close(struct net_device *dev)
 {
        struct ip_tunnel *t = netdev_priv(dev);
-       if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
+       if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
                struct in_device *in_dev = inetdev_by_index(t->mlink);
                if (in_dev) {
                        ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 
        if (iph->daddr) {
 #ifdef CONFIG_NET_IPGRE_BROADCAST
-               if (MULTICAST(iph->daddr)) {
+               if (ipv4_is_multicast(iph->daddr)) {
                        if (!iph->saddr)
                                return -EINVAL;
                        dev->flags = IFF_BROADCAST;
 
                return 0;
        }
 
-       if (!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
+       if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
                return -EINVAL;
 
        c=ipmr_cache_alloc();
           b. packet is not a NULL-REGISTER
           c. packet is not truncated
         */
-       if (!MULTICAST(encap->daddr) ||
+       if (!ipv4_is_multicast(encap->daddr) ||
            encap->tot_len == 0 ||
            ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
                goto drop;
        /* check if the inner packet is destined to mcast group */
        encap = (struct iphdr *)(skb_transport_header(skb) +
                                 sizeof(struct pimreghdr));
-       if (!MULTICAST(encap->daddr) ||
+       if (!ipv4_is_multicast(encap->daddr) ||
            encap->tot_len == 0 ||
            ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
                goto drop;
 
        if (msg->msg_flags & MSG_DONTROUTE)
                tos |= RTO_ONLINK;
 
-       if (MULTICAST(daddr)) {
+       if (ipv4_is_multicast(daddr)) {
                if (!ipc.oif)
                        ipc.oif = inet->mc_index;
                if (!saddr)
 
                return;
 
        if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev)
-           || MULTICAST(new_gw) || BADCLASS(new_gw) || ZERONET(new_gw))
+           || ipv4_is_multicast(new_gw) || ipv4_is_badclass(new_gw)
+           || ipv4_is_zeronet(new_gw))
                goto reject_redirect;
 
        if (!IN_DEV_SHARED_MEDIA(in_dev)) {
        if (in_dev == NULL)
                return -EINVAL;
 
-       if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr) ||
-           skb->protocol != htons(ETH_P_IP))
+       if (ipv4_is_multicast(saddr) || ipv4_is_badclass(saddr) ||
+           ipv4_is_loopback(saddr) || skb->protocol != htons(ETH_P_IP))
                goto e_inval;
 
-       if (ZERONET(saddr)) {
-               if (!LOCAL_MCAST(daddr))
+       if (ipv4_is_zeronet(saddr)) {
+               if (!ipv4_is_local_multicast(daddr))
                        goto e_inval;
                spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
        } else if (fib_validate_source(saddr, 0, tos, 0,
        }
 
 #ifdef CONFIG_IP_MROUTE
-       if (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
+       if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
                rth->u.dst.input = ip_mr_input;
 #endif
        RT_CACHE_STAT_INC(in_slow_mc);
           by fib_lookup.
         */
 
-       if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr))
+       if (ipv4_is_multicast(saddr) || ipv4_is_badclass(saddr) ||
+           ipv4_is_loopback(saddr))
                goto martian_source;
 
        if (daddr == htonl(0xFFFFFFFF) || (saddr == 0 && daddr == 0))
        /* Accept zero addresses only to limited broadcast;
         * I even do not know to fix it or not. Waiting for complains :-)
         */
-       if (ZERONET(saddr))
+       if (ipv4_is_zeronet(saddr))
                goto martian_source;
 
-       if (BADCLASS(daddr) || ZERONET(daddr) || LOOPBACK(daddr))
+       if (ipv4_is_badclass(daddr) || ipv4_is_zeronet(daddr) ||
+           ipv4_is_loopback(daddr))
                goto martian_destination;
 
        /*
        if (skb->protocol != htons(ETH_P_IP))
                goto e_inval;
 
-       if (ZERONET(saddr))
+       if (ipv4_is_zeronet(saddr))
                spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
        else {
                err = fib_validate_source(saddr, 0, tos, 0, dev, &spec_dst,
           Note, that multicast routers are not affected, because
           route cache entry is created eventually.
         */
-       if (MULTICAST(daddr)) {
+       if (ipv4_is_multicast(daddr)) {
                struct in_device *in_dev;
 
                rcu_read_lock();
                                ip_hdr(skb)->protocol);
                        if (our
 #ifdef CONFIG_IP_MROUTE
-                           || (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
+                           || (!ipv4_is_local_multicast(daddr) &&
+                               IN_DEV_MFORWARD(in_dev))
 #endif
                            ) {
                                rcu_read_unlock();
        u32 tos = RT_FL_TOS(oldflp);
        int err = 0;
 
-       if (LOOPBACK(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
+       if (ipv4_is_loopback(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
                return -EINVAL;
 
        if (fl->fl4_dst == htonl(0xFFFFFFFF))
                res->type = RTN_BROADCAST;
-       else if (MULTICAST(fl->fl4_dst))
+       else if (ipv4_is_multicast(fl->fl4_dst))
                res->type = RTN_MULTICAST;
-       else if (BADCLASS(fl->fl4_dst) || ZERONET(fl->fl4_dst))
+       else if (ipv4_is_badclass(fl->fl4_dst) || ipv4_is_zeronet(fl->fl4_dst))
                return -EINVAL;
 
        if (dev_out->flags & IFF_LOOPBACK)
 #ifdef CONFIG_IP_MROUTE
                if (res->type == RTN_MULTICAST) {
                        if (IN_DEV_MFORWARD(in_dev) &&
-                           !LOCAL_MCAST(oldflp->fl4_dst)) {
+                           !ipv4_is_local_multicast(oldflp->fl4_dst)) {
                                rth->u.dst.input = ip_mr_input;
                                rth->u.dst.output = ip_mc_output;
                        }
 
        if (oldflp->fl4_src) {
                err = -EINVAL;
-               if (MULTICAST(oldflp->fl4_src) ||
-                   BADCLASS(oldflp->fl4_src) ||
-                   ZERONET(oldflp->fl4_src))
+               if (ipv4_is_multicast(oldflp->fl4_src) ||
+                   ipv4_is_badclass(oldflp->fl4_src) ||
+                   ipv4_is_zeronet(oldflp->fl4_src))
                        goto out;
 
                /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
                 */
 
                if (oldflp->oif == 0
-                   && (MULTICAST(oldflp->fl4_dst) || oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
+                   && (ipv4_is_multicast(oldflp->fl4_dst) ||
+                       oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
                        /* Special hack: user can direct multicasts
                           and limited broadcast via necessary interface
                           without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
                        goto out;       /* Wrong error code */
                }
 
-               if (LOCAL_MCAST(oldflp->fl4_dst) || oldflp->fl4_dst == htonl(0xFFFFFFFF)) {
+               if (ipv4_is_local_multicast(oldflp->fl4_dst) ||
+                   oldflp->fl4_dst == htonl(0xFFFFFFFF)) {
                        if (!fl.fl4_src)
                                fl.fl4_src = inet_select_addr(dev_out, 0,
                                                              RT_SCOPE_LINK);
                        goto make_route;
                }
                if (!fl.fl4_src) {
-                       if (MULTICAST(oldflp->fl4_dst))
+                       if (ipv4_is_multicast(oldflp->fl4_dst))
                                fl.fl4_src = inet_select_addr(dev_out, 0,
                                                              fl.fl4_scope);
                        else if (!oldflp->fl4_dst)
 #ifdef CONFIG_IP_MROUTE
                __be32 dst = rt->rt_dst;
 
-               if (MULTICAST(dst) && !LOCAL_MCAST(dst) &&
+               if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
                    IPV4_DEVCONF_ALL(&init_net, MC_FORWARDING)) {
                        int err = ipmr_get_route(skb, r, nowait);
                        if (err <= 0) {
 
                connected = 0;
        }
 
-       if (MULTICAST(daddr)) {
+       if (ipv4_is_multicast(daddr)) {
                if (!ipc.oif)
                        ipc.oif = inet->mc_index;
                if (!saddr)