Java tutorial
/* * RHQ Management Platform * Copyright (C) 2005-2009 Red Hat, Inc. * All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License, version 2, as * published by the Free Software Foundation, and/or the GNU Lesser * General Public License, version 2.1, also as published by the Free * Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License and the GNU Lesser General Public License * for more details. * * You should have received a copy of the GNU General Public License * and the GNU Lesser General Public License along with this program; * if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ package org.rhq.plugins.apache.util; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.ArrayList; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.rhq.plugins.apache.parser.ApacheDirective; import org.rhq.plugins.apache.parser.ApacheDirectiveTree; /** * Utility class to extract various HTTP addresses from Augeas loaded Apache configuration. * * @author Lukas Krejci */ public enum HttpdAddressUtility { APACHE_1_3 { public List<Address> getAllMainServerAddresses(ApacheDirectiveTree ag, boolean substituteWildcards) { try { List<ApacheDirective> ports = ag.search("/Port"); List<ApacheDirective> bindAddresses = ag.search("/BindAddress"); List<ApacheDirective> listens = ag.search("/Listen"); String port = "80"; //this is the default in apache 1.3 String bindAddress = null; List<Address> addresses = new ArrayList<Address>(); if (ports.size() > 0) { List<String> values = ports.get(0).getValues(); if (values.size() > 0) port = values.get(0); } if (bindAddresses.size() > 0) { List<String> values = bindAddresses.get(0).getValues(); if (values.size() > 0) bindAddress = values.get(0); } //listen directives take precedence over port/bindaddress combo if (listens.size() > 0) { for (ApacheDirective l : listens) { addresses.add(parseListen(l.getValues().get(0))); } } else { addresses.add(new Address(bindAddress, Integer.parseInt(port))); } for (Address address : addresses) { if (!address.isPortDefined()) { address.port = 80; } if (substituteWildcards) { substituteWildcards(ag, address); } } return addresses; } catch (Exception e) { log.warn("Failed to obtain main server address.", e); return null; } } }, APACHE_2_x { public List<Address> getAllMainServerAddresses(ApacheDirectiveTree ag, boolean substituteWildcards) { try { List<Address> ret = new ArrayList<Address>(); for (ApacheDirective n : ag.search("/Listen")) { Address addr = parseListen(n.getValues().get(0)); if (substituteWildcards) { substituteWildcards(ag, addr); } ret.add(addr); } return ret; } catch (Exception e) { log.warn("Failed to obtain main server address.", e); return null; } } }; private static final Log log = LogFactory.getLog(HttpdAddressUtility.class); public static final String BOGUS_HOST_WITHOUT_FORWARD_DNS = "bogus_host_without_forward_dns"; public static final String BOGUS_HOST_WITHOUT_REVERSE_DNS = "bogus_host_without_reverse_dns"; public static HttpdAddressUtility get(String version) { return version.startsWith("1.") ? APACHE_1_3 : APACHE_2_x; } public static class Address { public String host; public int port = -1; public String scheme = "http"; public static final String WILDCARD = "*"; public static final String DEFAULT_HOST = "_default_"; public static final int PORT_WILDCARD_VALUE = 0; public static final int NO_PORT_SPECIFIED_VALUE = -1; public Address(String host, int port) { this.host = host; this.port = port; } public Address(String scheme, String host, int port) { this(host, port); this.scheme = scheme; } /** * A simple parser of the provided address into host and port * sections. * <p> * This is equivalent to calling {@link #parse(String, String)} with * the default scheme "http". * * @param address the address to parse * @return an instance of Address with host and port set accordingly */ public static Address parse(String address) { return parse(address, "http"); } /** * Parses given address into an Address object and assigns a default scheme if none * is present in the address itself. * * @param address the address to parse * @param defaultScheme the default scheme to apply or null if no scheme is required by default * @return the parsed address */ public static Address parse(String address, String defaultScheme) { String scheme = defaultScheme; int schemeSpecIdx = address.indexOf("://"); if (schemeSpecIdx >= 0) { scheme = address.substring(0, schemeSpecIdx); address = address.substring(schemeSpecIdx + "://".length()); } int lastColonIdx = address.lastIndexOf(':'); if (lastColonIdx == -1) { return new Address(scheme, address, NO_PORT_SPECIFIED_VALUE); } else { int lastRightBracketPos = address.lastIndexOf(']'); if (lastColonIdx > lastRightBracketPos) { String host = address.substring(0, lastColonIdx); String portSpec = address.substring(lastColonIdx + 1); int port = NO_PORT_SPECIFIED_VALUE; if (WILDCARD.equals(portSpec)) { port = PORT_WILDCARD_VALUE; } else { port = Integer.parseInt(portSpec); } return new Address(scheme, host, port); } else { //this is an IP6 address without a port spec return new Address(scheme, address, NO_PORT_SPECIFIED_VALUE); } } } public boolean isPortWildcard() { return port == PORT_WILDCARD_VALUE; } public boolean isPortDefined() { return port != NO_PORT_SPECIFIED_VALUE; } public boolean isHostWildcard() { return WILDCARD.equals(host); } public boolean isHostDefault() { return DEFAULT_HOST.equals(host); } @Override public int hashCode() { int hash = port; if (host != null) hash *= host.hashCode(); return hash; } @Override public boolean equals(Object other) { if (!(other instanceof Address)) return false; Address o = (Address) other; return safeEquals(host, o.host) && this.port == o.port; } /** * This differs from equals in the way that it considers wildcard values: * <ul> * <li>wildcard host matches any host * <li>default host matches default host * <li>wildcard port matches any port * <li>undefined port matches undefined port * </ul> * The addresses match if both address and port match. * * @param other the address to match * @param whether to match the scheme as well * @return true if the addresses match according to the rules described above, false otherwise */ public boolean matches(Address other, boolean matchSchemes) { if (matchSchemes && !safeEquals(scheme, other.scheme)) { return false; } if (!WILDCARD.equals(host) && !WILDCARD.equals(other.host) && !safeEquals(host, other.host)) { return false; } if (PORT_WILDCARD_VALUE != port && PORT_WILDCARD_VALUE != other.port && port != other.port) { return false; } return true; } @Override public String toString() { return toString(true, true); } public String toString(boolean includeScheme, boolean interpretWildcardPort) { StringBuilder bld = new StringBuilder(); if (includeScheme && scheme != null) { bld.append(scheme).append("://"); } if (host != null) { bld.append(host); if (port != NO_PORT_SPECIFIED_VALUE) { bld.append(":"); } } if (port != NO_PORT_SPECIFIED_VALUE) { if (port == PORT_WILDCARD_VALUE && interpretWildcardPort) { bld.append(WILDCARD); } else { bld.append(port); } } return bld.toString(); } private static boolean safeEquals(Object a, Object b) { return a == null ? b == null : a.equals(b); } } /** * This returns all the addresses the server listens on. * * @param ag the tree of the httpd configuration * @param substituteWildcards true if wildcard substitution should be made on host and port specs * @return the addresses or null on failure */ public abstract List<Address> getAllMainServerAddresses(ApacheDirectiveTree ag, boolean substituteWildcards); /** * This just constructs a first available address under which the server or one of its virtual hosts can be reached. * * @param ag the tree of the httpd configuration * @param limitToHost if non-null and different from {@link Address#DEFAULT_HOST} and {@link Address#WILDCARD}, * the sample address is looked for only for the given host * @param limitToPort if > 0, the sample address is looked for only for the given port * @return the address or null on failure */ public Address getMainServerSampleAddress(ApacheDirectiveTree ag, String limitToHost, int limitToPort) { List<Address> addressesToMatch = getAllMainServerAddresses(ag, false); if (addressesToMatch == null) { return null; } for (Address address : addressesToMatch) { if (isAddressConforming(address, limitToHost, limitToPort, false)) { substituteWildcards(ag, address); if (address.scheme == null) { address.scheme = "http"; } return address; } } return null; } /** * This constructs an address on which given virtual host can be accessed. * * @param ag the augeas tree of the httpd configuration * @param virtualHost the port or address:port of the virtual host * @param serverName the server name for the namebased virtual hosts (or null if the virtual host is ip based) * @param legacyWildcardHostHandling use the legacy handling of wildcard hosts. This should always be false unless you are calling this method * from the code generating the legacy resource keys during vhost upgrade * @return the address on which the virtual host can be accessed or null on error */ public Address getVirtualHostSampleAddress(ApacheDirectiveTree ag, String virtualHost, String serverName, boolean legacyWildcardHostHandling) { try { Address addr = Address.parse(virtualHost); if (addr.isHostDefault() || addr.isHostWildcard()) { Address serverAddr = null; if (legacyWildcardHostHandling) { serverAddr = getLocalhost(addr.port); } else { serverAddr = getMainServerSampleAddress(ag, null, addr.port); } if (serverAddr == null) return null; addr.host = serverAddr.host; } if (serverName != null) { updateWithServerName(addr, serverName); } return addr; } catch (Exception e) { log.warn("Failed to obtain virtual host address.", e); return null; } } public Address getHttpdInternalMainServerAddressRepresentation(ApacheDirectiveTree runtimeConfig) { Address ret = null; List<ApacheDirective> serverNames = runtimeConfig.search("/ServerName"); if (serverNames.size() == 0) { //no servername directive in the apache config ret = new Address(Address.WILDCARD, Address.NO_PORT_SPECIFIED_VALUE); try { ret.host = InetAddress.getLocalHost().getCanonicalHostName(); } catch (UnknownHostException e) { ret.host = "127.0.0.1"; } ret.port = 0; } else { String serverName = serverNames.get(serverNames.size() - 1).getValuesAsString(); ret = HttpdAddressUtility.Address.parse(serverName); if (!ret.isPortDefined()) { ret.port = 0; } } return ret; } public Address getHttpdInternalVirtualHostAddressRepresentation(ApacheDirectiveTree runtimeConfig, String virtualHost, String serverName) { Address ret = null; if (serverName != null) { ret = Address.parse(serverName); if (!ret.isPortDefined()) { ret.port = 0; } //servername is taken literally and no reverse dns lookup is made //if the servername host is an IP address. We're done here... } else { ret = Address.parse(virtualHost); if (!ret.isPortDefined() || ret.isPortWildcard() || ret.isHostDefault() || ret.isHostWildcard()) { Address mainAddress = getHttpdInternalMainServerAddressRepresentation(runtimeConfig); if (!ret.isPortDefined() || ret.isPortWildcard()) { ret.port = mainAddress.port; } if (ret.isHostDefault() || ret.isHostWildcard()) { ret.host = mainAddress.host; } } //if the vhost hostname is an IP address, a reverse dns lookup is attempted //to get the actual hostname. //the BOGUS* constants are what the apache actually uses to identify such //"error" conditions. try { InetAddress iAddr = InetAddress.getByName(ret.host); String reverseLookup = iAddr.getHostName(); if (iAddr.getHostAddress().equals(reverseLookup)) { ret.host = BOGUS_HOST_WITHOUT_REVERSE_DNS; } else { ret.host = reverseLookup; } } catch (UnknownHostException e) { ret.host = BOGUS_HOST_WITHOUT_FORWARD_DNS; //weird, as it seems, apache uses the port of the main server //with the unknown host even if the port was specified in the vhost //definition Address mainAddress = getHttpdInternalMainServerAddressRepresentation(runtimeConfig); ret.port = mainAddress.port; } } return ret; } public static Address parseListen(String listenValue) { Address ret = Address.parse(listenValue, null); if (!ret.isPortDefined()) { try { ret.port = Integer.parseInt(ret.host); } catch (NumberFormatException e) { return null; } ret.host = null; } return ret; } private static void substituteWildcards(ApacheDirectiveTree ag, Address address) { if (address.isPortWildcard()) { address.port = 80; } if (address.host == null || address.isHostDefault() || address.isHostWildcard()) { Address localhost = getLocalhost(address.port); address.host = localhost.host; } updateWithServerName(address, ag); } /** * Checks that given address represents a possibly wildcarded limitingHost and limitingPort values. * * @param listen the address to check * @param limitingHost the host to limit to. The null value or the {@link Address#DEFAULT_HOST} * or the {@link Address#WILDCARD} are not considered limiting * @param limitingPort the port to limit the address to. Values <= 0 are not considered limiting * @param snmpModuleCompatibleMode the snmp module represents both port 80 and port wildcard (*) as '0'. * If this flag is set to true, this method takes that into account. * @return */ public static boolean isAddressConforming(Address listen, String limitingHost, int limitingPort, boolean snmpModuleCompatibleMode) { if (Address.DEFAULT_HOST.equals(limitingHost) || Address.WILDCARD.equals(limitingHost)) { limitingHost = null; } boolean hostOk = limitingHost == null; boolean portOk = limitingPort <= 0; //listen.host == null means that server listens on all addresses if (!hostOk && (listen.host == null || limitingHost.equals(listen.host))) { hostOk = true; } int listenPort = listen.port; //this stupid 80 = 0 rule is to conform with snmp module //the problem is that snmp module represents both 80 and * port defs as 0, //so whatever we do, we might mismatch the vhost. But there's no working around that //but to modify the snmp module itself. if (snmpModuleCompatibleMode) { if (limitingPort == 80) { limitingPort = 0; } if (listenPort == 80) { listenPort = 0; } } if (!portOk && limitingPort == listenPort) { portOk = true; } return hostOk && portOk; } private static Address getLocalhost(int port) { try { return new Address(InetAddress.getLocalHost().getHostAddress(), port); } catch (UnknownHostException e) { //well, this is bad, we can't get address of the localhost. let's use the force... return new Address("127.0.0.1", port); } } private static void updateWithServerName(Address address, ApacheDirectiveTree config) { //check if there is a ServerName directive List<ApacheDirective> serverNameNodes = config.search("/ServerName"); //if there is a ServerName directive, check that the address //we're returning indeed corresponds to it. This might not //be the case if the server listens on more than one interfaces. if (serverNameNodes.size() > 0) { String serverName = serverNameNodes.get(0).getValuesAsString(); updateWithServerName(address, serverName); } } private static void updateWithServerName(Address address, String serverName) { //the configuration may be invalid and/or the hostname can be unresolvable. //we try to match the address with the servername first by IP address //but if that fails (i.e. the hostname couldn't be resolved to an IP) //we try to simply match the hostnames themselves. Address serverAddr = Address.parse(serverName); String ipFromServerName = null; String ipFromAddress = null; String hostFromServerName = null; String hostFromAddress = null; boolean lookupFailed = false; try { InetAddress addrFromServerName = InetAddress.getByName(serverAddr.host); ipFromServerName = addrFromServerName.getHostAddress(); hostFromServerName = addrFromServerName.getHostName(); } catch (UnknownHostException e) { ipFromServerName = serverAddr.host; hostFromServerName = serverAddr.host; lookupFailed = true; } try { InetAddress addrFromAddress = InetAddress.getByName(address.host); ipFromAddress = addrFromAddress.getHostAddress(); hostFromAddress = addrFromAddress.getHostName(); } catch (UnknownHostException e) { ipFromAddress = address.host; hostFromAddress = address.host; lookupFailed = true; } if (ipFromAddress.equals(ipFromServerName) || (lookupFailed && (hostFromAddress.equals(hostFromServerName)))) { address.scheme = serverAddr.scheme; address.host = serverAddr.host; } } }