[NETFILTER]: Remove redundant parentheses/braces

Removes redundant parentheses and braces (And add one pair in a
xt_tcpudp.c macro).

Signed-off-by: Jan Engelhardt <jengelh@gmx.de>
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c b/net/ipv4/netfilter/ipt_CLUSTERIP.c
index 2de7ae0180aa0e777916449741f97826f229dac7..5de13b44b1ca8942181657ae727b55ab94174711 100644 (file)
--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
+++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
@@ -122,9 +122,8 @@ __clusterip_config_find(__be32 clusterip)
        list_for_each(pos, &clusterip_configs) {
                struct clusterip_config *c = list_entry(pos,
                                        struct clusterip_config, list);
-               if (c->clusterip == clusterip) {
+               if (c->clusterip == clusterip)
                        return c;
-               }
        }
 
        return NULL;
@@ -155,9 +154,8 @@ clusterip_config_init_nodelist(struct clusterip_config *c,
 {
        int n;
 
-       for (n = 0; n < i->num_local_nodes; n++) {
+       for (n = 0; n < i->num_local_nodes; n++)
                set_bit(i->local_nodes[n] - 1, &c->local_nodes);
-       }
 }
 
 static struct clusterip_config *
@@ -255,10 +253,9 @@ clusterip_hashfn(const struct sk_buff *skb,
                dport = ports[1];
                break;
        default:
-               if (net_ratelimit()) {
+               if (net_ratelimit())
                        printk(KERN_NOTICE "CLUSTERIP: unknown protocol `%u'\n",
                                iph->protocol);
-               }
                sport = dport = 0;
        }
 
@@ -286,7 +283,7 @@ clusterip_hashfn(const struct sk_buff *skb,
        }
 
        /* node numbers are 1..n, not 0..n */
-       return ((hashval % config->num_total_nodes)+1);
+       return (hashval % config->num_total_nodes) + 1;
 }
 
 static inline int

diff --git a/net/ipv4/netfilter/ipt_ECN.c b/net/ipv4/netfilter/ipt_ECN.c
index 02367012fc7474e392266ca501ae7de4083781a4..a647c1db86ddc5d45a93f20e5dc5e4cb60f3013a 100644 (file)
--- a/net/ipv4/netfilter/ipt_ECN.c
+++ b/net/ipv4/netfilter/ipt_ECN.c
@@ -58,8 +58,8 @@ set_ect_tcp(struct sk_buff **pskb, const struct ipt_ECN_info *einfo)
 
        if ((!(einfo->operation & IPT_ECN_OP_SET_ECE) ||
             tcph->ece == einfo->proto.tcp.ece) &&
-           ((!(einfo->operation & IPT_ECN_OP_SET_CWR) ||
-            tcph->cwr == einfo->proto.tcp.cwr)))
+           (!(einfo->operation & IPT_ECN_OP_SET_CWR) ||
+            tcph->cwr == einfo->proto.tcp.cwr))
                return true;
 
        if (!skb_make_writable(pskb, ip_hdrlen(*pskb) + sizeof(*tcph)))

diff --git a/net/ipv4/netfilter/ipt_TTL.c b/net/ipv4/netfilter/ipt_TTL.c
index f53f2c4ca4a1c0f15f0bf3688220b72af1872d59..737830b68adeb92c7e53039f1c3a2b37c43b9588 100644 (file)
--- a/net/ipv4/netfilter/ipt_TTL.c
+++ b/net/ipv4/netfilter/ipt_TTL.c
@@ -75,7 +75,7 @@ static bool ipt_ttl_checkentry(const char *tablename,
                        info->mode);
                return false;
        }
-       if ((info->mode != IPT_TTL_SET) && (info->ttl == 0))
+       if (info->mode != IPT_TTL_SET && info->ttl == 0)
                return false;
        return true;
 }

diff --git a/net/ipv4/netfilter/ipt_ULOG.c b/net/ipv4/netfilter/ipt_ULOG.c
index 282eb00fc471c8c8ab4335110c2e60cfa93b3f03..5b25ca688784bec4a6821edd6efbedf52472ee99 100644 (file)
--- a/net/ipv4/netfilter/ipt_ULOG.c
+++ b/net/ipv4/netfilter/ipt_ULOG.c
@@ -179,12 +179,10 @@ static void ipt_ulog_packet(unsigned int hooknum,
        unsigned int groupnum = ffs(loginfo->nl_group) - 1;
 
        /* calculate the size of the skb needed */
-       if ((loginfo->copy_range == 0) ||
-           (loginfo->copy_range > skb->len)) {
+       if (loginfo->copy_range == 0 || loginfo->copy_range > skb->len)
                copy_len = skb->len;
-       } else {
+       else
                copy_len = loginfo->copy_range;
-       }
 
        size = NLMSG_SPACE(sizeof(*pm) + copy_len);
 
@@ -257,9 +255,8 @@ static void ipt_ulog_packet(unsigned int hooknum,
                BUG();
 
        /* check if we are building multi-part messages */
-       if (ub->qlen > 1) {
+       if (ub->qlen > 1)
                ub->lastnlh->nlmsg_flags |= NLM_F_MULTI;
-       }
 
        ub->lastnlh = nlh;
 

diff --git a/net/ipv4/netfilter/ipt_iprange.c b/net/ipv4/netfilter/ipt_iprange.c
index b266d98aac8ccbdba1697e06dde3e8745dd766c5..854281c6200880cd41d7e75ad806bc4c54ecf9eb 100644 (file)
--- a/net/ipv4/netfilter/ipt_iprange.c
+++ b/net/ipv4/netfilter/ipt_iprange.c
@@ -35,8 +35,8 @@ match(const struct sk_buff *skb,
        const struct iphdr *iph = ip_hdr(skb);
 
        if (info->flags & IPRANGE_SRC) {
-               if (((ntohl(iph->saddr) < ntohl(info->src.min_ip))
-                         || (ntohl(iph->saddr) > ntohl(info->src.max_ip)))
+               if ((ntohl(iph->saddr) < ntohl(info->src.min_ip)
+                         || ntohl(iph->saddr) > ntohl(info->src.max_ip))
                         ^ !!(info->flags & IPRANGE_SRC_INV)) {
                        DEBUGP("src IP %u.%u.%u.%u NOT in range %s"
                               "%u.%u.%u.%u-%u.%u.%u.%u\n",
@@ -48,8 +48,8 @@ match(const struct sk_buff *skb,
                }
        }
        if (info->flags & IPRANGE_DST) {
-               if (((ntohl(iph->daddr) < ntohl(info->dst.min_ip))
-                         || (ntohl(iph->daddr) > ntohl(info->dst.max_ip)))
+               if ((ntohl(iph->daddr) < ntohl(info->dst.min_ip)
+                         || ntohl(iph->daddr) > ntohl(info->dst.max_ip))
                         ^ !!(info->flags & IPRANGE_DST_INV)) {
                        DEBUGP("dst IP %u.%u.%u.%u NOT in range %s"
                               "%u.%u.%u.%u-%u.%u.%u.%u\n",

diff --git a/net/ipv4/netfilter/ipt_recent.c b/net/ipv4/netfilter/ipt_recent.c
index d03e6a6eb767705564a72cefbb8177c2eac4e3ad..68f7181e412d6336f8b6c4861f9b26b63716c4cd 100644 (file)
--- a/net/ipv4/netfilter/ipt_recent.c
+++ b/net/ipv4/netfilter/ipt_recent.c
@@ -163,10 +163,9 @@ static void recent_table_flush(struct recent_table *t)
        struct recent_entry *e, *next;
        unsigned int i;
 
-       for (i = 0; i < ip_list_hash_size; i++) {
+       for (i = 0; i < ip_list_hash_size; i++)
                list_for_each_entry_safe(e, next, &t->iphash[i], list)
                        recent_entry_remove(t, e);
-       }
 }
 
 static bool
@@ -329,12 +328,10 @@ static void *recent_seq_start(struct seq_file *seq, loff_t *pos)
 
        spin_lock_bh(&recent_lock);
 
-       for (st->bucket = 0; st->bucket < ip_list_hash_size; st->bucket++) {
-               list_for_each_entry(e, &t->iphash[st->bucket], list) {
+       for (st->bucket = 0; st->bucket < ip_list_hash_size; st->bucket++)
+               list_for_each_entry(e, &t->iphash[st->bucket], list)
                        if (p-- == 0)
                                return e;
-               }
-       }
        return NULL;
 }
 

diff --git a/net/ipv4/netfilter/ipt_ttl.c b/net/ipv4/netfilter/ipt_ttl.c
index 82fe4ea8ab791534a819356c87d7eb086d26b897..59a644db4d74b961560934b36d8e90b79190d78a 100644 (file)
--- a/net/ipv4/netfilter/ipt_ttl.c
+++ b/net/ipv4/netfilter/ipt_ttl.c
@@ -28,17 +28,13 @@ static bool match(const struct sk_buff *skb,
 
        switch (info->mode) {
                case IPT_TTL_EQ:
-                       return (ttl == info->ttl);
-                       break;
+                       return ttl == info->ttl;
                case IPT_TTL_NE:
-                       return (!(ttl == info->ttl));
-                       break;
+                       return ttl != info->ttl;
                case IPT_TTL_LT:
-                       return (ttl < info->ttl);
-                       break;
+                       return ttl < info->ttl;
                case IPT_TTL_GT:
-                       return (ttl > info->ttl);
-                       break;
+                       return ttl > info->ttl;
                default:
                        printk(KERN_WARNING "ipt_ttl: unknown mode %d\n",
                                info->mode);

diff --git a/net/ipv6/netfilter/ip6t_HL.c b/net/ipv6/netfilter/ip6t_HL.c
index 20047ff5492f580dfcce2ec075faf1bf86676aed..33c4cb8a5c4383d7e48444e90e5e6692a0e0b86f 100644 (file)
--- a/net/ipv6/netfilter/ip6t_HL.c
+++ b/net/ipv6/netfilter/ip6t_HL.c
@@ -71,7 +71,7 @@ static bool ip6t_hl_checkentry(const char *tablename,
                        info->mode);
                return false;
        }
-       if ((info->mode != IP6T_HL_SET) && (info->hop_limit == 0)) {
+       if (info->mode != IP6T_HL_SET && info->hop_limit == 0) {
                printk(KERN_WARNING "ip6t_HL: increment/decrement doesn't "
                        "make sense with value 0\n");
                return false;

diff --git a/net/ipv6/netfilter/ip6t_REJECT.c b/net/ipv6/netfilter/ip6t_REJECT.c
index 4df07f0adf1d2e54dc09497eda08ff4c9412d62d..0fa1f2cf9fba5664b2882ec0159f44ffda0936cb 100644 (file)
--- a/net/ipv6/netfilter/ip6t_REJECT.c
+++ b/net/ipv6/netfilter/ip6t_REJECT.c
@@ -69,7 +69,7 @@ static void send_reset(struct sk_buff *oldskb)
        otcplen = oldskb->len - tcphoff;
 
        /* IP header checks: fragment, too short. */
-       if ((proto != IPPROTO_TCP) || (otcplen < sizeof(struct tcphdr))) {
+       if (proto != IPPROTO_TCP || otcplen < sizeof(struct tcphdr)) {
                DEBUGP("ip6t_REJECT: proto(%d) != IPPROTO_TCP, or too short. otcplen = %d\n",
                        proto, otcplen);
                return;

diff --git a/net/ipv6/netfilter/ip6t_ah.c b/net/ipv6/netfilter/ip6t_ah.c
index b4b1d282761c7c7ee6136cd505181c592dbe0401..fbf3d7748dc20e92c9794b9ef71fa5bf929c52dc 100644 (file)
--- a/net/ipv6/netfilter/ip6t_ah.c
+++ b/net/ipv6/netfilter/ip6t_ah.c
@@ -78,9 +78,9 @@ match(const struct sk_buff *skb,
        DEBUGP("SPI %u %08X\n", ntohl(ah->spi), ntohl(ah->spi));
 
        DEBUGP("IPv6 AH spi %02X ",
-              (spi_match(ahinfo->spis[0], ahinfo->spis[1],
-                         ntohl(ah->spi),
-                         !!(ahinfo->invflags & IP6T_AH_INV_SPI))));
+              spi_match(ahinfo->spis[0], ahinfo->spis[1],
+                        ntohl(ah->spi),
+                        !!(ahinfo->invflags & IP6T_AH_INV_SPI)));
        DEBUGP("len %02X %04X %02X ",
               ahinfo->hdrlen, hdrlen,
               (!ahinfo->hdrlen ||
@@ -92,9 +92,9 @@ match(const struct sk_buff *skb,
 
        return (ah != NULL)
               &&
-              (spi_match(ahinfo->spis[0], ahinfo->spis[1],
-                         ntohl(ah->spi),
-                         !!(ahinfo->invflags & IP6T_AH_INV_SPI)))
+              spi_match(ahinfo->spis[0], ahinfo->spis[1],
+                        ntohl(ah->spi),
+                        !!(ahinfo->invflags & IP6T_AH_INV_SPI))
               &&
               (!ahinfo->hdrlen ||
                (ahinfo->hdrlen == hdrlen) ^

diff --git a/net/ipv6/netfilter/ip6t_eui64.c b/net/ipv6/netfilter/ip6t_eui64.c
index bebb12a1d0e6b93106839f6acadd6d35e71e71c2..2af99fc6bdc936448eb6540f3639b71128943208 100644 (file)
--- a/net/ipv6/netfilter/ip6t_eui64.c
+++ b/net/ipv6/netfilter/ip6t_eui64.c
@@ -33,7 +33,7 @@ match(const struct sk_buff *skb,
        int i = 0;
 
        if (!(skb_mac_header(skb) >= skb->head &&
-             (skb_mac_header(skb) + ETH_HLEN) <= skb->data) &&
+             skb_mac_header(skb) + ETH_HLEN <= skb->data) &&
            offset != 0) {
                *hotdrop = true;
                return false;
@@ -50,8 +50,8 @@ match(const struct sk_buff *skb,
                        eui64[0] |= 0x02;
 
                        i = 0;
-                       while ((ipv6_hdr(skb)->saddr.s6_addr[8 + i] == eui64[i])
-                              && (i < 8))
+                       while (ipv6_hdr(skb)->saddr.s6_addr[8 + i] == eui64[i]
+                              && i < 8)
                                i++;
 
                        if (i == 8)

diff --git a/net/ipv6/netfilter/ip6t_frag.c b/net/ipv6/netfilter/ip6t_frag.c
index e0e416bb284a9527466a4bcdbb53a0afe513cdc9..65482af711dea98485d53c1622157ee11c065a7f 100644 (file)
--- a/net/ipv6/netfilter/ip6t_frag.c
+++ b/net/ipv6/netfilter/ip6t_frag.c
@@ -77,35 +77,35 @@ match(const struct sk_buff *skb,
               ntohl(fh->identification));
 
        DEBUGP("IPv6 FRAG id %02X ",
-              (id_match(fraginfo->ids[0], fraginfo->ids[1],
+              id_match(fraginfo->ids[0], fraginfo->ids[1],
                         ntohl(fh->identification),
-                        !!(fraginfo->invflags & IP6T_FRAG_INV_IDS))));
+                        !!(fraginfo->invflags & IP6T_FRAG_INV_IDS)));
        DEBUGP("res %02X %02X%04X %02X ",
-              (fraginfo->flags & IP6T_FRAG_RES), fh->reserved,
+              fraginfo->flags & IP6T_FRAG_RES, fh->reserved,
               ntohs(fh->frag_off) & 0x6,
               !((fraginfo->flags & IP6T_FRAG_RES)
                 && (fh->reserved || (ntohs(fh->frag_off) & 0x06))));
        DEBUGP("first %02X %02X %02X ",
-              (fraginfo->flags & IP6T_FRAG_FST),
+              fraginfo->flags & IP6T_FRAG_FST,
               ntohs(fh->frag_off) & ~0x7,
               !((fraginfo->flags & IP6T_FRAG_FST)
                 && (ntohs(fh->frag_off) & ~0x7)));
        DEBUGP("mf %02X %02X %02X ",
-              (fraginfo->flags & IP6T_FRAG_MF),
+              fraginfo->flags & IP6T_FRAG_MF,
               ntohs(fh->frag_off) & IP6_MF,
               !((fraginfo->flags & IP6T_FRAG_MF)
                 && !((ntohs(fh->frag_off) & IP6_MF))));
        DEBUGP("last %02X %02X %02X\n",
-              (fraginfo->flags & IP6T_FRAG_NMF),
+              fraginfo->flags & IP6T_FRAG_NMF,
               ntohs(fh->frag_off) & IP6_MF,
               !((fraginfo->flags & IP6T_FRAG_NMF)
                 && (ntohs(fh->frag_off) & IP6_MF)));
 
        return (fh != NULL)
               &&
-              (id_match(fraginfo->ids[0], fraginfo->ids[1],
-                        ntohl(fh->identification),
-                        !!(fraginfo->invflags & IP6T_FRAG_INV_IDS)))
+              id_match(fraginfo->ids[0], fraginfo->ids[1],
+                       ntohl(fh->identification),
+                       !!(fraginfo->invflags & IP6T_FRAG_INV_IDS))
               &&
               !((fraginfo->flags & IP6T_FRAG_RES)
                 && (fh->reserved || (ntohs(fh->frag_off) & 0x6)))

diff --git a/net/ipv6/netfilter/ip6t_hbh.c b/net/ipv6/netfilter/ip6t_hbh.c
index bbd2615ad2e1ef73e193b61efb99850028b6a256..8eecac14ddaa9da7107ab05ada358c534b77ccfd 100644 (file)
--- a/net/ipv6/netfilter/ip6t_hbh.c
+++ b/net/ipv6/netfilter/ip6t_hbh.c
@@ -160,7 +160,7 @@ match(const struct sk_buff *skb,
                        DEBUGP("len%04X \n", optlen);
 
                        if ((ptr > skb->len - optlen || hdrlen < optlen) &&
-                           (temp < optinfo->optsnr - 1)) {
+                           temp < optinfo->optsnr - 1) {
                                DEBUGP("new pointer is too large! \n");
                                break;
                        }

diff --git a/net/ipv6/netfilter/ip6t_hl.c b/net/ipv6/netfilter/ip6t_hl.c
index b933e84a06a446f9fe98b67b96e7ef40656de71e..ddee088f5f10e16c36bf9d31e5a1495ed662888a 100644 (file)
--- a/net/ipv6/netfilter/ip6t_hl.c
+++ b/net/ipv6/netfilter/ip6t_hl.c
@@ -29,16 +29,16 @@ static bool match(const struct sk_buff *skb,
 
        switch (info->mode) {
                case IP6T_HL_EQ:
-                       return (ip6h->hop_limit == info->hop_limit);
+                       return ip6h->hop_limit == info->hop_limit;
                        break;
                case IP6T_HL_NE:
-                       return (!(ip6h->hop_limit == info->hop_limit));
+                       return ip6h->hop_limit != info->hop_limit;
                        break;
                case IP6T_HL_LT:
-                       return (ip6h->hop_limit < info->hop_limit);
+                       return ip6h->hop_limit < info->hop_limit;
                        break;
                case IP6T_HL_GT:
-                       return (ip6h->hop_limit > info->hop_limit);
+                       return ip6h->hop_limit > info->hop_limit;
                        break;
                default:
                        printk(KERN_WARNING "ip6t_hl: unknown mode %d\n",

diff --git a/net/ipv6/netfilter/ip6t_ipv6header.c b/net/ipv6/netfilter/ip6t_ipv6header.c
index 5ba6ef0f1b1b2fab51ae56f4c600e10e22006e10..ca020ce1c4a3ac2f422e46e96bddca2f8d4f9166 100644 (file)
--- a/net/ipv6/netfilter/ip6t_ipv6header.c
+++ b/net/ipv6/netfilter/ip6t_ipv6header.c
@@ -74,9 +74,9 @@ ipv6header_match(const struct sk_buff *skb,
                BUG_ON(hp == NULL);
 
                /* Calculate the header length */
-               if (nexthdr == NEXTHDR_FRAGMENT) {
+               if (nexthdr == NEXTHDR_FRAGMENT)
                        hdrlen = 8;
-               } else if (nexthdr == NEXTHDR_AUTH)
+               else if (nexthdr == NEXTHDR_AUTH)
                        hdrlen = (hp->hdrlen + 2) << 2;
                else
                        hdrlen = ipv6_optlen(hp);
@@ -110,7 +110,7 @@ ipv6header_match(const struct sk_buff *skb,
                        break;
        }
 
-       if ((nexthdr != NEXTHDR_NONE) && (nexthdr != NEXTHDR_ESP))
+       if (nexthdr != NEXTHDR_NONE && nexthdr != NEXTHDR_ESP)
                temp |= MASK_PROTO;
 
        if (info->modeflag)

diff --git a/net/ipv6/netfilter/ip6t_owner.c b/net/ipv6/netfilter/ip6t_owner.c
index 8cb6c94b4a20aa85922efdc3a8add4ec54832946..d2bf3204aeac29cb952e239d3eff27902e357693 100644 (file)
--- a/net/ipv6/netfilter/ip6t_owner.c
+++ b/net/ipv6/netfilter/ip6t_owner.c
@@ -38,17 +38,15 @@ match(const struct sk_buff *skb,
        if (!skb->sk || !skb->sk->sk_socket || !skb->sk->sk_socket->file)
                return false;
 
-       if (info->match & IP6T_OWNER_UID) {
+       if (info->match & IP6T_OWNER_UID)
                if ((skb->sk->sk_socket->file->f_uid != info->uid) ^
                    !!(info->invert & IP6T_OWNER_UID))
                        return false;
-       }
 
-       if (info->match & IP6T_OWNER_GID) {
+       if (info->match & IP6T_OWNER_GID)
                if ((skb->sk->sk_socket->file->f_gid != info->gid) ^
                    !!(info->invert & IP6T_OWNER_GID))
                        return false;
-       }
 
        return true;
 }

diff --git a/net/ipv6/netfilter/ip6t_rt.c b/net/ipv6/netfilter/ip6t_rt.c
index bc5ff4b1af3943435ab752603ef9794cc7143aa5..f86fdcdd8cb81a91011810eb11b59e9acd4dbc1d 100644 (file)
--- a/net/ipv6/netfilter/ip6t_rt.c
+++ b/net/ipv6/netfilter/ip6t_rt.c
@@ -87,9 +87,9 @@ match(const struct sk_buff *skb,
        DEBUGP("SGS_LEFT %u %02X\n", rh->segments_left, rh->segments_left);
 
        DEBUGP("IPv6 RT segsleft %02X ",
-              (segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
-                              rh->segments_left,
-                              !!(rtinfo->invflags & IP6T_RT_INV_SGS))));
+              segsleft_match(rtinfo->segsleft[0], rtinfo->segsleft[1],
+                             rh->segments_left,
+                             !!(rtinfo->invflags & IP6T_RT_INV_SGS)));
        DEBUGP("type %02X %02X %02X ",
               rtinfo->rt_type, rh->type,
               (!(rtinfo->flags & IP6T_RT_TYP) ||
@@ -97,11 +97,11 @@ match(const struct sk_buff *skb,
                 !!(rtinfo->invflags & IP6T_RT_INV_TYP))));
        DEBUGP("len %02X %04X %02X ",
               rtinfo->hdrlen, hdrlen,
-              (!(rtinfo->flags & IP6T_RT_LEN) ||
+              !(rtinfo->flags & IP6T_RT_LEN) ||
                ((rtinfo->hdrlen == hdrlen) ^
-                !!(rtinfo->invflags & IP6T_RT_INV_LEN))));
+                !!(rtinfo->invflags & IP6T_RT_INV_LEN)));
        DEBUGP("res %02X %02X %02X ",
-              (rtinfo->flags & IP6T_RT_RES),
+              rtinfo->flags & IP6T_RT_RES,
               ((const struct rt0_hdr *)rh)->reserved,
               !((rtinfo->flags & IP6T_RT_RES) &&
                 (((const struct rt0_hdr *)rh)->reserved)));
@@ -188,8 +188,8 @@ match(const struct sk_buff *skb,
                                        break;
                        }
                        DEBUGP("temp=%d #%d\n", temp, rtinfo->addrnr);
-                       if ((temp == rtinfo->addrnr) &&
-                           (temp == (unsigned int)((hdrlen - 8) / 16)))
+                       if (temp == rtinfo->addrnr &&
+                           temp == (unsigned int)((hdrlen - 8) / 16))
                                return ret;
                        else
                                return false;

diff --git a/net/netfilter/xt_DSCP.c b/net/netfilter/xt_DSCP.c
index 2d779f6902dc430cd92df4c3a783973f042eb6a0..ed6b524064f0bf4b5319924c85779d961801cc9d 100644 (file)
--- a/net/netfilter/xt_DSCP.c
+++ b/net/netfilter/xt_DSCP.c
@@ -74,7 +74,7 @@ static bool checkentry(const char *tablename,
 {
        const u_int8_t dscp = ((struct xt_DSCP_info *)targinfo)->dscp;
 
-       if ((dscp > XT_DSCP_MAX)) {
+       if (dscp > XT_DSCP_MAX) {
                printk(KERN_WARNING "DSCP: dscp %x out of range\n", dscp);
                return false;
        }

diff --git a/net/netfilter/xt_TCPMSS.c b/net/netfilter/xt_TCPMSS.c
index 075051acb55457839df02eb8fe7fa326db3fac3b..6ae6df993aa20db6b2fd34165fdf82699b657a49 100644 (file)
--- a/net/netfilter/xt_TCPMSS.c
+++ b/net/netfilter/xt_TCPMSS.c
@@ -93,7 +93,7 @@ tcpmss_mangle_packet(struct sk_buff **pskb,
                                return 0;
 
                        opt[i+2] = (newmss & 0xff00) >> 8;
-                       opt[i+3] = (newmss & 0x00ff);
+                       opt[i+3] = newmss & 0x00ff;
 
                        nf_proto_csum_replace2(&tcph->check, *pskb,
                                               htons(oldmss), htons(newmss), 0);
@@ -126,7 +126,7 @@ tcpmss_mangle_packet(struct sk_buff **pskb,
        opt[0] = TCPOPT_MSS;
        opt[1] = TCPOLEN_MSS;
        opt[2] = (newmss & 0xff00) >> 8;
-       opt[3] = (newmss & 0x00ff);
+       opt[3] = newmss & 0x00ff;
 
        nf_proto_csum_replace4(&tcph->check, *pskb, 0, *((__be32 *)opt), 0);
 

diff --git a/net/netfilter/xt_connbytes.c b/net/netfilter/xt_connbytes.c
index 99c246e45c42b6b80fb6d29e6a9b6c81d78eb56e..d9b2e75fbab290d149de8da829e52dce0ddb889d 100644 (file)
--- a/net/netfilter/xt_connbytes.c
+++ b/net/netfilter/xt_connbytes.c
@@ -90,9 +90,9 @@ match(const struct sk_buff *skb,
        }
 
        if (sinfo->count.to)
-               return (what <= sinfo->count.to && what >= sinfo->count.from);
+               return what <= sinfo->count.to && what >= sinfo->count.from;
        else
-               return (what >= sinfo->count.from);
+               return what >= sinfo->count.from;
 }
 
 static bool check(const char *tablename,

diff --git a/net/netfilter/xt_connmark.c b/net/netfilter/xt_connmark.c
index 71f3c1a5d5e555bb80fb8b4d24d5bf60c1185c73..3a6e16d4edcdf27387324cb7dc3cfa84e62bd8b9 100644 (file)
--- a/net/netfilter/xt_connmark.c
+++ b/net/netfilter/xt_connmark.c
@@ -48,7 +48,7 @@ match(const struct sk_buff *skb,
        if (!ct)
                return false;
 
-       return (((ct->mark) & info->mask) == info->mark) ^ info->invert;
+       return ((ct->mark & info->mask) == info->mark) ^ info->invert;
 }
 
 static bool

diff --git a/net/netfilter/xt_dccp.c b/net/netfilter/xt_dccp.c
index 1b77c5bcb348c3180c844513d6d8120a2e5dea57..f07a68d445ca0ab8e279268b100213463a3aea1b 100644 (file)
--- a/net/netfilter/xt_dccp.c
+++ b/net/netfilter/xt_dccp.c
@@ -81,7 +81,7 @@ dccp_find_option(u_int8_t option,
 static inline bool
 match_types(const struct dccp_hdr *dh, u_int16_t typemask)
 {
-       return (typemask & (1 << dh->dccph_type));
+       return typemask & (1 << dh->dccph_type);
 }
 
 static inline bool
@@ -113,11 +113,11 @@ match(const struct sk_buff *skb,
                return false;
        }
 
-       return  DCCHECK(((ntohs(dh->dccph_sport) >= info->spts[0])
-                       && (ntohs(dh->dccph_sport) <= info->spts[1])),
+       return  DCCHECK(ntohs(dh->dccph_sport) >= info->spts[0]
+                       && ntohs(dh->dccph_sport) <= info->spts[1],
                        XT_DCCP_SRC_PORTS, info->flags, info->invflags)
-               && DCCHECK(((ntohs(dh->dccph_dport) >= info->dpts[0])
-                       && (ntohs(dh->dccph_dport) <= info->dpts[1])),
+               && DCCHECK(ntohs(dh->dccph_dport) >= info->dpts[0]
+                       && ntohs(dh->dccph_dport) <= info->dpts[1],
                        XT_DCCP_DEST_PORTS, info->flags, info->invflags)
                && DCCHECK(match_types(dh, info->typemask),
                           XT_DCCP_TYPE, info->flags, info->invflags)

diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index deb5890aa3ac1a3f5332bdbea44d6a31beaf30c4..094da6e066b8c8965137c8ba280c5d7dac502605 100644 (file)
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -239,7 +239,7 @@ static bool select_all(const struct xt_hashlimit_htable *ht,
 static bool select_gc(const struct xt_hashlimit_htable *ht,
                      const struct dsthash_ent *he)
 {
-       return (jiffies >= he->expires);
+       return jiffies >= he->expires;
 }
 
 static void htable_selective_cleanup(struct xt_hashlimit_htable *ht,

diff --git a/net/netfilter/xt_length.c b/net/netfilter/xt_length.c
index 57bcfacde5941ede1b2a30fcaec8398a898d035e..ea4880bd31ea3811e7842a8b07980446ad1929a4 100644 (file)
--- a/net/netfilter/xt_length.c
+++ b/net/netfilter/xt_length.c
@@ -47,8 +47,8 @@ match6(const struct sk_buff *skb,
        bool *hotdrop)
 {
        const struct xt_length_info *info = matchinfo;
-       const u_int16_t pktlen = (ntohs(ipv6_hdr(skb)->payload_len) +
-                                 sizeof(struct ipv6hdr));
+       const u_int16_t pktlen = ntohs(ipv6_hdr(skb)->payload_len) +
+                                sizeof(struct ipv6hdr);
 
        return (pktlen >= info->min && pktlen <= info->max) ^ info->invert;
 }

diff --git a/net/netfilter/xt_mac.c b/net/netfilter/xt_mac.c
index 86022027dd639176cec2fac82cdd212edc8a8e71..28ec08e7511ba4cdc9c53d6d5e9f247ce9858add 100644 (file)
--- a/net/netfilter/xt_mac.c
+++ b/net/netfilter/xt_mac.c
@@ -37,11 +37,11 @@ match(const struct sk_buff *skb,
     const struct xt_mac_info *info = matchinfo;
 
     /* Is mac pointer valid? */
-    return (skb_mac_header(skb) >= skb->head &&
-           (skb_mac_header(skb) + ETH_HLEN) <= skb->data
-           /* If so, compare... */
-           && ((!compare_ether_addr(eth_hdr(skb)->h_source, info->srcaddr))
-               ^ info->invert));
+    return skb_mac_header(skb) >= skb->head &&
+          skb_mac_header(skb) + ETH_HLEN <= skb->data
+          /* If so, compare... */
+          && ((!compare_ether_addr(eth_hdr(skb)->h_source, info->srcaddr))
+               ^ info->invert);
 }
 
 static struct xt_match xt_mac_match[] = {

diff --git a/net/netfilter/xt_pkttype.c b/net/netfilter/xt_pkttype.c
index 63239727bc22467368efab410ec361980edb4756..e4c420b5713bb6244c58b8575a5fb106dd94f084 100644 (file)
--- a/net/netfilter/xt_pkttype.c
+++ b/net/netfilter/xt_pkttype.c
@@ -34,9 +34,9 @@ static bool match(const struct sk_buff *skb,
        const struct xt_pkttype_info *info = matchinfo;
 
        if (skb->pkt_type == PACKET_LOOPBACK)
-               type = (MULTICAST(ip_hdr(skb)->daddr)
+               type = MULTICAST(ip_hdr(skb)->daddr)
                        ? PACKET_MULTICAST
-                       : PACKET_BROADCAST);
+                       : PACKET_BROADCAST;
        else
                type = skb->pkt_type;
 

diff --git a/net/netfilter/xt_sctp.c b/net/netfilter/xt_sctp.c
index 22df338b393459c4e6e196250c50c1fc88c9d9ed..fefc846188f366b09952bbc9db54f714746a6b9c 100644 (file)
--- a/net/netfilter/xt_sctp.c
+++ b/net/netfilter/xt_sctp.c
@@ -31,11 +31,9 @@ match_flags(const struct xt_sctp_flag_info *flag_info,
 {
        int i;
 
-       for (i = 0; i < flag_count; i++) {
-               if (flag_info[i].chunktype == chunktype) {
+       for (i = 0; i < flag_count; i++)
+               if (flag_info[i].chunktype == chunktype)
                        return (chunkflags & flag_info[i].flag_mask) == flag_info[i].flag;
-               }
-       }
 
        return true;
 }
@@ -56,9 +54,8 @@ match_packet(const struct sk_buff *skb,
        int i = 0;
 #endif
 
-       if (chunk_match_type == SCTP_CHUNK_MATCH_ALL) {
+       if (chunk_match_type == SCTP_CHUNK_MATCH_ALL)
                SCTP_CHUNKMAP_COPY(chunkmapcopy, chunkmap);
-       }
 
        do {
                sch = skb_header_pointer(skb, offset, sizeof(_sch), &_sch);
@@ -86,16 +83,14 @@ match_packet(const struct sk_buff *skb,
 
                        case SCTP_CHUNK_MATCH_ALL:
                                if (match_flags(flag_info, flag_count,
-                                       sch->type, sch->flags)) {
+                                   sch->type, sch->flags))
                                        SCTP_CHUNKMAP_CLEAR(chunkmapcopy, sch->type);
-                               }
                                break;
 
                        case SCTP_CHUNK_MATCH_ONLY:
                                if (!match_flags(flag_info, flag_count,
-                                       sch->type, sch->flags)) {
+                                   sch->type, sch->flags))
                                        return false;
-                               }
                                break;
                        }
                } else {
@@ -145,11 +140,11 @@ match(const struct sk_buff *skb,
        }
        duprintf("spt: %d\tdpt: %d\n", ntohs(sh->source), ntohs(sh->dest));
 
-       return  SCCHECK(((ntohs(sh->source) >= info->spts[0])
-                       && (ntohs(sh->source) <= info->spts[1])),
+       return  SCCHECK(ntohs(sh->source) >= info->spts[0]
+                       && ntohs(sh->source) <= info->spts[1],
                        XT_SCTP_SRC_PORTS, info->flags, info->invflags)
-               && SCCHECK(((ntohs(sh->dest) >= info->dpts[0])
-                       && (ntohs(sh->dest) <= info->dpts[1])),
+               && SCCHECK(ntohs(sh->dest) >= info->dpts[0]
+                       && ntohs(sh->dest) <= info->dpts[1],
                        XT_SCTP_DEST_PORTS, info->flags, info->invflags)
                && SCCHECK(match_packet(skb, protoff + sizeof (sctp_sctphdr_t),
                                        info->chunkmap, info->chunk_match_type,

diff --git a/net/netfilter/xt_tcpudp.c b/net/netfilter/xt_tcpudp.c
index 0dd3022cc79afb88ba3278c884bdf7950d85660d..5cb345aeeca8de5a96713b2550ebb502ead9c95f 100644 (file)
--- a/net/netfilter/xt_tcpudp.c
+++ b/net/netfilter/xt_tcpudp.c
@@ -95,7 +95,7 @@ tcp_match(const struct sk_buff *skb,
                return false;
        }
 
-#define FWINVTCP(bool,invflg) ((bool) ^ !!(tcpinfo->invflags & invflg))
+#define FWINVTCP(bool, invflg) ((bool) ^ !!(tcpinfo->invflags & (invflg)))
 
        th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
        if (th == NULL) {