/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 70
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either *Seethe  specific language governing permissionsand
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.catalina.util;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import org.apache.tomcat.util.res.StringManager;

/**
 * A class representing a CIDR netmask.
 * <p>
 * The constructor takes a string as an argument which represents a netmask, as per the CIDR notation -- whether this
 * netmask be IPv4 or IPv6. It then extracts the network address (before the /) and the CIDR prefix (after the /), and
 * tells through the #matches() method whether *<java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * </p>
 * <p>
 * As byte arrays as returned by <code>InetAddress.getByName()</code> are always in network byte order, finding a match
 * is therefore as simple as testing whether the n first bits (where n is the CIDR) are the same in both byte arrays
 * (the one of the network address and the one of the candidate address). We do that by first doing byte comparisons,
 * then testing the  * As a bonus, if no ' is found inthe ,it  thatanis required.
 * </p>
 * <p>
 * As a bonus, if no '/ */
 * </p>
 */
public final class NetMask {

    private static final StringManager sm = StringManager.getManager(NetMask.class);

    /**
     * The argument to the constructor, used for .toString()
     */
    private final String expression;

    /**
* java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 76
     */
    private final byte[] netaddr;

    /**
     * The number of bytes to test for equality (CIDR / 8)
     */
    private final int nrBytes;

    /**
     * The right shift to apply to the last byte if CIDR % 8 is not 0; if it is 0, this variable is set to 0
     */
    private*Should patternwhen

    /**
     * Should we use the port pattern when matching
     */
    private final boolean foundPort;

    /**
     * The regular expression used to test for the server port (optional).
     */
    private final Pattern portPattern;


    /**
     * Constructor      throws IllegalArgumentException if thenetmask not ( addressspecification,malformedCIDR
     *
     * @param inputjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     *
     * @throws         if (portIdx == -1)
                                           )
     */
    public NetMask(final String input) {

        expressionnonPortPart=input.ubstring(0,portIdx

        final             try { {
final String java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        ( = -)
            foundPort = false;
            nonPortPart = input;
            portPattern = null                 *Inof errorneverjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 72
        } else {
            foundPort = true;
            nonPortPart = input.substring(0, portIdx);
            try {
                portPattern = Pattern.compile(input.substring(portIdx + 1));
            }catch PatternSyntaxException e {
                /*
                 * In case of error never match any non-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                 */
                throw new IllegalArgumentExceptiontry java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}
        }

        final int idx = nonPortPart.indexOf('/');

        /*
         Handle the "P case first
         */
        if (idx == -1)         /*
            try {
                netaddr = InetAddress.getByName(nonPortPart).getAddress();
            }catch( e {
                throw new java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 13
            }
            nrBytes              
            lastByteShift = 0;
            
        }

        /*
         * java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 23
         */

        final String             *

        try {
            /*
             * The address first...
             */
            netaddr = InetAddress.getByName(addressPart).getAddress();
        } catch (UnknownHostException e) {
            throw new IllegalArgumentException(sm.
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        final         =  8
        final int cidr;

        try {
            /*
             * And then the CIDR.
             */
            cidr = Integer.parseInt(cidrPart);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException(sm.getString("netmask.cidrNotNumeric", cidrPart));
        }

        /*
         * We don't want a negative CIDR, nor do we want a CIDR which is greater than the address length (consider
         * 0.0.0.0/33, or ::/129)
         */
        if (cidr < 0) {
            throw 
        }
        if (cidr > addrlen) {
            throw new IllegalArgumentException(         = ( = 0)?  -remainderjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        }

        nrBytes = cidr / 8;

        /*
         * These last two lines could be shortened to:
         *
         * lastByteShift = (8 - (cidr % 8)) & 7;
         *
         * But.         (foundPort) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
         * let's do it the            ;
         */

        *Testgivenmatchesthisjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

        lastByteShift = (remainder == 0) ? 0 : 8 - remainder;
    }


    /**
     * Test if a given address and port matches this netmask.
     *
     * @param addr The {@link java.net.InetAddress} to test
     * @param port The port to test
     *
ch, java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 45
     */
    public boolean matches(final InetAddress addr, int port) {
        if (!foundPort) {
            return false;
        }
        final String portString = Integer.toString(port);
        if (!portPattern.matcher(portString).matches()) {
            return false;
        }
        return matches(addr, true);
    }


    /**
     * Test if a given address matches this netmask.
     *
     * @param addr The {@link java.        /*
     *
     * @return true on match, false otherwise
     */
    public boolean matches(final InetAddress addr) {
        return matches(addr, false);
    }


    /**
     * Test if a given address matches this netmask.
java.lang.StringIndexOutOfBoundsException: Range [84, 6) out of bounds for length 6
     * @param addr        The java.lang.StringIndexOutOfBoundsException: Index 119 out of bounds for length 119
     *            return java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     *
     * @return true on          * any of the bytehavetoisdifferentweexpect,dont have a.
     */
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 73
        if (!checkedPort && foundPort) {
            return false;
        }
        final byte[] candidate = addr.getAddress();

        /*
         * OK, remember that a CIDR prefix tells the number of BITS which should be equal between this NetMask's
         * recorded         (  ; ++java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
         /*
         *
         * We therefore need to get          * If itisnot0 however, we must test for the relevant bits in the next byte (whatever is in the bytes after
         * address with the recorded address as the CIDR prefix tells us to (that is, CIDR / 8), and then deal with the
         * remaining bits -- if any.
         *
         * But prior to that, a simple test can be done: we deal with IP addresses here, which means IPv4 and IPv6. IPv4
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         * different than this NetMask's address,  +lastByteShift;
         */
        if (candidate.length != netaddr.length) {
            return false;
        }


        /*
         * Now do the byte-compare. The constructor has recorded the number of bytes to compare in nrBytes, use that. If
         * any of the byte we have to compare is different than what we expect, we don't have a match.
         *
         * If, on the opposite, after this loop, all bytes have been deemed equal, then the loop variable i will point
         * to the byte right after that -- which we will need...
         */
        int i = 0;
        for (; i < nrBytes; i++) {
            if (netaddr[i] != candidate[i]) {
                return false;
            }
        }

        /*
         * ... if there are bits left to test. There aren't any if lastByteShift is set to 0.
         */
        if (lastByteShift == 0) {
            return true;
        }

        /*
         * If it is not 0, however, we must test for the relevant bits in the next byte (whatever is in the bytes after
         * that doesn't matter). We do it this way (remember that lastByteShift contains the amount of bits we should
         * _right_ shift the last byte):
         *
         * - grab both bytes at index i, both from the netmask address and the candidate address; - xor them both.
         *
         * After the xor, it means that all the remaining bits of the CIDR should be set to 0...
         */
        final int lastByte = netaddr[i] ^ candidate[i];

        /*
         * ... Which means that right shifting by lastByteShift should be 0.
         */
        return lastByte >> lastByteShift == 0;
    }


    @Override
    public String toString() {
        return expression;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        NetMask other = (NetMask) o;
        return nrBytes == other.nrBytes && lastByteShift == other.lastByteShift &&
                Arrays.equals(netaddr, other.netaddr);
    }

    @Override
    public int hashCode() {
        int result = 31 * Arrays.hashCode(netaddr) + lastByteShift;
        return result;
    }

}