public SocketPermission(String host,
    String action) 
{
     
        Boolean tmp = java.security.AccessController.doPrivileged(
                new sun.security.action.GetBooleanAction("trustProxy"));
        trustProxy = tmp.booleanValue();
        super(getHost(host));
        // name initialized to getHost(host); NPE detected in getHost()
        init(getName(), getMask(action));
}

Creates a new SocketPermission object with the specified actions. The host is expressed as a DNS name, or as a numerical IP address. Optionally, a port or a portrange may be supplied (separated from the DNS name or IP address by a colon).

To specify the local machine, use "localhost" as the host. Also note: An empty host String ("") is equivalent to "localhost".

The actions parameter contains a comma-separated list of the actions granted for the specified host (and port(s)). Possible actions are "connect", "listen", "accept", "resolve", or any combination of those. "resolve" is automatically added when any of the other three are specified.

Examples of SocketPermission instantiation are the following:

nr = new SocketPermission("www.catalog.com", "connect");
nr = new SocketPermission("www.sun.com:80", "connect");
nr = new SocketPermission("*.sun.com", "connect");
nr = new SocketPermission("*.edu", "resolve");
nr = new SocketPermission("204.160.241.0", "connect");
nr = new SocketPermission("localhost:1024-65535", "listen");
nr = new SocketPermission("204.160.241.0:1024-65535", "connect");

Parameters:

host - the hostname or IPaddress of the computer, optionally including a colon followed by a port or port range.

action - the action string.

 SocketPermission(String host,
    int mask) 
{
        super(getHost(host));
        // name initialized to getHost(host); NPE detected in getHost()
        init(getName(), mask);
}

 public boolean equals(Object obj) 
{
        if (obj == this)
            return true;
        if (! (obj instanceof SocketPermission))
            return false;
        SocketPermission that = (SocketPermission) obj;
        //this is (overly?) complex!!!
        // check the mask first
        if (this.mask != that.mask) return false;
        if ((that.mask & RESOLVE) != that.mask) {
            // now check the port range...
            if ((this.portrange[0] != that.portrange[0]) ||
                (this.portrange[1] != that.portrange[1])) {
                return false;
            }
        }
        // short cut. This catches:
        //  "crypto" equal to "crypto", or
        // "1.2.3.4" equal to "1.2.3.4.", or
        //  "*.edu" equal to "*.edu", but it
        //  does not catch "crypto" equal to
        // "crypto.eng.sun.com".
        if (this.getName().equalsIgnoreCase(that.getName())) {
            return true;
        }
        // we now attempt to get the Canonical (FQDN) name and
        // compare that. If this fails, about all we can do is return
        // false.
        try {
            this.getCanonName();
            that.getCanonName();
        } catch (UnknownHostException uhe) {
            return false;
        }
        if (this.invalid || that.invalid)
            return false;
        if (this.cname != null) {
            return this.cname.equalsIgnoreCase(that.cname);
        }
        return false;
}

Checks two SocketPermission objects for equality.

 public String getActions() 
{
        if (actions == null)
            actions = getActions(this.mask);
        return actions;
}

Returns the canonical string representation of the actions. Always returns present actions in the following order: connect, listen, accept, resolve.

  void getCanonName() throws UnknownHostException 
{
        if (cname != null || invalid) return;
        // attempt to get the canonical name
        try {
            // first get the IP addresses if we don't have them yet
            // this is because we need the IP address to then get
            // FQDN.
            if (addresses == null) {
                getIP();
            }
            // we have to do this check, otherwise we might not
            // get the fully qualified domain name
            if (init_with_ip) {
                cname = addresses[0].getHostName(false).toLowerCase();
            } else {
             cname = InetAddress.getByName(addresses[0].getHostAddress()).
                                              getHostName(false).toLowerCase();
            }
        } catch (UnknownHostException uhe) {
            invalid = true;
            throw uhe;
        }
}

attempt to get the fully qualified domain name

  void getIP() throws UnknownHostException 
{
        if (addresses != null || wildcard || invalid) return;
        try {
            // now get all the IP addresses
            String host;
            if (getName().charAt(0) == '[") {
                // Literal IPv6 address
                host = getName().substring(1, getName().indexOf(']"));
            } else {
                int i = getName().indexOf(":");
                if (i == -1)
                    host = getName();
                else {
                    host = getName().substring(0,i);
                }
            }
            addresses =
                new InetAddress[] {InetAddress.getAllByName0(host, false)[0]};
        } catch (UnknownHostException uhe) {
            invalid = true;
            throw uhe;
        }  catch (IndexOutOfBoundsException iobe) {
            invalid = true;
            throw new UnknownHostException(getName());
        }
}

get IP addresses. Sets invalid to true if we can't get them.

 int getMask() 
{
        return mask;
}

Return the current action mask.

 public int hashCode() 
{
        /*
         * If this SocketPermission was initialized with an IP address
         * or a wildcard, use getName().hashCode(), otherwise use
         * the hashCode() of the host name returned from
         * java.net.InetAddress.getHostName method.
         */
        if (init_with_ip || wildcard) {
            return this.getName().hashCode();
        }
        try {
            getCanonName();
        } catch (UnknownHostException uhe) {
        }
        if (invalid || cname == null)
            return this.getName().hashCode();
        else
            return this.cname.hashCode();
}

Returns the hash code value for this object.

 public boolean implies(Permission p) 
{
        int i,j;
        if (!(p instanceof SocketPermission))
            return false;
        if (p == this)
            return true;
        SocketPermission that = (SocketPermission) p;
        return ((this.mask & that.mask) == that.mask) &&
                                        impliesIgnoreMask(that);
}

Checks if this socket permission object "implies" the specified permission.

More specifically, this method first ensures that all of the following are true (and returns false if any of them are not):

• p is an instanceof SocketPermission,

• p's actions are a proper subset of this object's actions, and

• p's port range is included in this port range. Note: port range is ignored when p only contains the action, 'resolve'.

Then implies checks each of the following, in order, and for each returns true if the stated condition is true:
• If this object was initialized with a single IP address and one of p's IP addresses is equal to this object's IP address.

• If this object is a wildcard domain (such as *.sun.com), and p's canonical name (the name without any preceding *) ends with this object's canonical host name. For example, *.sun.com implies *.eng.sun.com..

• If this object was not initialized with a single IP address, and one of this object's IP addresses equals one of p's IP addresses.

• If this canonical name equals p's canonical name.

If none of the above are true, implies returns false.

 boolean impliesIgnoreMask(SocketPermission that) 
{
        int i,j;
        if ((that.mask & RESOLVE) != that.mask) {
            // check port range
            if ((that.portrange[0] <  this.portrange[0]) ||
                    (that.portrange[1]  > this.portrange[1])) {
                    return false;
            }
        }
        // allow a "*" wildcard to always match anything
        if (this.wildcard && "".equals(this.cname))
            return true;
        // return if either one of these NetPerm objects are invalid...
        if (this.invalid || that.invalid) {
            return (trustProxy ? inProxyWeTrust(that) : false);
        }
        if (this.getName().equalsIgnoreCase(that.getName())) {
            return true;
        }
        try {
            if (this.init_with_ip) { // we only check IP addresses
                if (that.wildcard)
                    return false;
                if (that.init_with_ip) {
                    return (this.addresses[0].equals(that.addresses[0]));
                } else {
                    if (that.addresses == null) {
                        that.getIP();
                    }
                    for (i=0; i <  that.addresses.length; i++) {
                        if (this.addresses[0].equals(that.addresses[i]))
                            return true;
                    }
                }
                // since "this" was initialized with an IP address, we
                // don't check any other cases
                return false;
            }
            // check and see if we have any wildcards...
            if (this.wildcard || that.wildcard) {
                // if they are both wildcards, return true iff
                // that's cname ends with this cname (i.e., *.sun.com
                // implies *.eng.sun.com)
                if (this.wildcard && that.wildcard)
                    return (that.cname.endsWith(this.cname));
                // a non-wildcard can't imply a wildcard
                if (that.wildcard)
                    return false;
                // this is a wildcard, lets see if that's cname ends with
                // it...
                if (that.cname == null) {
                    that.getCanonName();
                }
                return (that.cname.endsWith(this.cname));
            }
            // comapare IP addresses
            if (this.addresses == null) {
                this.getIP();
            }
            if (that.addresses == null) {
                that.getIP();
            }
            for (j = 0; j <  this.addresses.length; j++) {
                for (i=0; i <  that.addresses.length; i++) {
                    if (this.addresses[j].equals(that.addresses[i]))
                        return true;
                }
            }
            // XXX: if all else fails, compare hostnames?
            // Do we really want this?
            if (this.cname == null) {
                this.getCanonName();
            }
            if (that.cname == null) {
                that.getCanonName();
            }
            return (this.cname.equalsIgnoreCase(that.cname));
        } catch (UnknownHostException uhe) {
            if (trustProxy)
                return inProxyWeTrust(that);
        }
        // make sure the first thing that is done here is to return
        // false. If not, uncomment the return false in the above catch.
        return false;
}

Checks if the incoming Permission's action are a proper subset of the this object's actions.

Check, in the following order:

• Checks that "p" is an instanceof a SocketPermission
• Checks that "p"'s actions are a proper subset of the current object's actions.
• Checks that "p"'s port range is included in this port range
• If this object was initialized with an IP address, checks that one of "p"'s IP addresses is equal to this object's IP address.
• If either object is a wildcard domain (i.e., "*.sun.com"), attempt to match based on the wildcard.
• If this object was not initialized with an IP address, attempt to find a match based on the IP addresses in both objects.
• Attempt to match on the canonical hostnames of both objects.

 public PermissionCollection newPermissionCollection() 
{
        return new SocketPermissionCollection();
}

Returns a new PermissionCollection object for storing SocketPermission objects.

SocketPermission objects must be stored in a manner that allows them to be inserted into the collection in any order, but that also enables the PermissionCollection implies method to be implemented in an efficient (and consistent) manner.