/** Check if an URL is relative to another URL. */
public static boolean relativeURL(URL url1, URL url2) {
return ((url1.getProtocol() == null && url2.getProtocol() == null)
|| url1.getProtocol().equals(url2.getProtocol()))
&& ((url1.getAuthority() == null && url2.getAuthority() == null)
|| url1.getAuthority().equals(url2.getAuthority()))
&& ((url1.getPath() == null && url2.getPath() == null)
|| url2.getPath().startsWith(url1.getPath()));
}
private T requestInfo(URI baseUrl, RenderingContext context)
throws IOException, URISyntaxException, ParserConfigurationException, SAXException {
URL url = loader.createURL(baseUrl, context);
GetMethod method = null;
try {
final InputStream stream;
if ((url.getProtocol().equals("http") || url.getProtocol().equals("https"))
&& context.getConfig().localHostForwardIsFrom(url.getHost())) {
String scheme = url.getProtocol();
final String host = url.getHost();
if (url.getProtocol().equals("https")
&& context.getConfig().localHostForwardIsHttps2http()) {
scheme = "http";
}
URL localUrl = new URL(scheme, "localhost", url.getPort(), url.getFile());
HttpURLConnection connexion = (HttpURLConnection) localUrl.openConnection();
connexion.setRequestProperty("Host", host);
for (Map.Entry<String, String> entry : context.getHeaders().entrySet()) {
connexion.setRequestProperty(entry.getKey(), entry.getValue());
}
stream = connexion.getInputStream();
} else {
method = new GetMethod(url.toString());
for (Map.Entry<String, String> entry : context.getHeaders().entrySet()) {
method.setRequestHeader(entry.getKey(), entry.getValue());
}
context.getConfig().getHttpClient(baseUrl).executeMethod(method);
int code = method.getStatusCode();
if (code < 200 || code >= 300) {
throw new IOException(
"Error "
+ code
+ " while reading the Capabilities from "
+ url
+ ": "
+ method.getStatusText());
}
stream = method.getResponseBodyAsStream();
}
final T result;
try {
result = loader.parseInfo(stream);
} finally {
stream.close();
}
return result;
} finally {
if (method != null) {
method.releaseConnection();
}
}
}
/**
* Enumerates the resouces in a give package name. This works even if the resources are loaded
* from a jar file!
*
* <p>Adapted from code by mikewse on the java.sun.com message boards.
* http://forum.java.sun.com/thread.jsp?forum=22&thread=30984
*
* @param packageName The package to enumerate
* @return A Set of Strings for each resouce in the package.
*/
public static Set getResoucesInPackage(String packageName) throws IOException {
String localPackageName;
if (packageName.endsWith("/")) {
localPackageName = packageName;
} else {
localPackageName = packageName + '/';
}
Enumeration dirEnum = ClassLoader.getSystemResources(localPackageName);
Set names = new HashSet();
// Loop CLASSPATH directories
while (dirEnum.hasMoreElements()) {
URL resUrl = (URL) dirEnum.nextElement();
// Pointing to filesystem directory
if (resUrl.getProtocol().equals("file")) {
File dir = new File(resUrl.getFile());
File[] files = dir.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
File file = files[i];
if (file.isDirectory()) continue;
names.add(localPackageName + file.getName());
}
}
// Pointing to Jar file
} else if (resUrl.getProtocol().equals("jar")) {
JarURLConnection jconn = (JarURLConnection) resUrl.openConnection();
JarFile jfile = jconn.getJarFile();
Enumeration entryEnum = jfile.entries();
while (entryEnum.hasMoreElements()) {
JarEntry entry = (JarEntry) entryEnum.nextElement();
String entryName = entry.getName();
// Exclude our own directory
if (entryName.equals(localPackageName)) continue;
String parentDirName = entryName.substring(0, entryName.lastIndexOf('/') + 1);
if (!parentDirName.equals(localPackageName)) continue;
names.add(entryName);
}
} else {
// Invalid classpath entry
}
}
return names;
}
private boolean processURL(URL url, String baseDir, StatusWindow status) throws IOException {
if (processedLinks.contains(url)) {
return false;
} else {
processedLinks.add(url);
}
URLConnection connection = url.openConnection();
InputStream in = new BufferedInputStream(connection.getInputStream());
ArrayList list = processPage(in, baseDir, url);
if ((status != null) && (list.size() > 0)) {
status.setMaximum(list.size());
}
for (int i = 0; i < list.size(); i++) {
if (status != null) {
status.setMessage(Utils.trimFileName(list.get(i).toString(), 40), i);
}
if ((!((String) list.get(i)).startsWith("RUN"))
&& (!((String) list.get(i)).startsWith("SAVE"))
&& (!((String) list.get(i)).startsWith("LOAD"))) {
processURL(
new URL(url.getProtocol(), url.getHost(), url.getPort(), (String) list.get(i)),
baseDir,
status);
}
}
in.close();
return true;
}
public Set<String> listResources(String subdir) {
try {
Set<String> result = new HashSet<String>();
if (resourceURL != null) {
String protocol = resourceURL.getProtocol();
if (protocol.equals("jar")) {
String resPath = resourceURL.getPath();
int pling = resPath.lastIndexOf("!");
URL jarURL = new URL(resPath.substring(0, pling));
String resDirInJar = resPath.substring(pling + 2);
String prefix = resDirInJar + subdir + "/";
// System.out.printf("BaseMod.listResources: looking for names starting with %s\n",
// prefix);
JarFile jar = new JarFile(new File(jarURL.toURI()));
Enumeration<JarEntry> entries = jar.entries();
while (entries.hasMoreElements()) {
String name = entries.nextElement().getName();
if (name.startsWith(prefix) && !name.endsWith("/") && !name.contains("/.")) {
// System.out.printf("BaseMod.listResources: name = %s\n", name);
result.add(name.substring(prefix.length()));
}
}
} else throw new RuntimeException("Resource URL protocol " + protocol + " not supported");
}
return result;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* ** Gets the 'protocol' specification in the URI ** @return The 'protocol' specification in the
* URL, or null if unable to determine protocol
*/
public String getProtocol() {
try {
URL url = new URL(this.getURI());
return url.getProtocol();
} catch (MalformedURLException mue) {
return null;
}
}
protected void addPathFile(final File pathComponent) throws IOException {
if (!this.pathComponents.contains(pathComponent)) {
this.pathComponents.addElement(pathComponent);
}
if (pathComponent.isDirectory()) {
return;
}
final String absPathPlusTimeAndLength =
pathComponent.getAbsolutePath()
+ pathComponent.lastModified()
+ "-"
+ pathComponent.length();
String classpath = AntClassLoader.pathMap.get(absPathPlusTimeAndLength);
if (classpath == null) {
JarFile jarFile = null;
try {
jarFile = new JarFile(pathComponent);
final Manifest manifest = jarFile.getManifest();
if (manifest == null) {
return;
}
classpath = manifest.getMainAttributes().getValue(Attributes.Name.CLASS_PATH);
} finally {
if (jarFile != null) {
jarFile.close();
}
}
if (classpath == null) {
classpath = "";
}
AntClassLoader.pathMap.put(absPathPlusTimeAndLength, classpath);
}
if (!"".equals(classpath)) {
final URL baseURL = AntClassLoader.FILE_UTILS.getFileURL(pathComponent);
final StringTokenizer st = new StringTokenizer(classpath);
while (st.hasMoreTokens()) {
final String classpathElement = st.nextToken();
final URL libraryURL = new URL(baseURL, classpathElement);
if (!libraryURL.getProtocol().equals("file")) {
this.log(
"Skipping jar library "
+ classpathElement
+ " since only relative URLs are supported by this"
+ " loader",
3);
} else {
final String decodedPath = Locator.decodeUri(libraryURL.getFile());
final File libraryFile = new File(decodedPath);
if (!libraryFile.exists() || this.isInPath(libraryFile)) {
continue;
}
this.addPathFile(libraryFile);
}
}
}
}
// Strip off everything unneeded
private String getBaseUrl(String pUrl, String pServletPath) {
String sUrl;
try {
URL url = new URL(pUrl);
String host = getIpIfPossible(url.getHost());
sUrl = new URL(url.getProtocol(), host, url.getPort(), pServletPath).toExternalForm();
} catch (MalformedURLException exp) {
sUrl = plainReplacement(pUrl, pServletPath);
}
return sUrl;
}
public void setAuthenticationOutcome(String realm, URL tracker, boolean success) {
try {
this_mon.enter();
setAuthenticationOutcome(
realm, tracker.getProtocol(), tracker.getHost(), tracker.getPort(), success);
} finally {
this_mon.exit();
}
}
public PasswordAuthentication getAuthentication(String realm, URL tracker) {
try {
this_mon.enter();
return (getAuthentication(
realm, tracker.getProtocol(), tracker.getHost(), tracker.getPort()));
} finally {
this_mon.exit();
}
}
String srvUrlStem(String host) {
if (host == null) {
return null;
}
StringBuilder sb = new StringBuilder();
sb.append(reqURL.getProtocol());
sb.append("://");
sb.append(host);
sb.append(':');
sb.append(reqURL.getPort());
return sb.toString();
}
/** tries to determine the file name from getSourceURI */
public static void saveModel(Model m, RDFSerializer s)
throws FileNotFoundException, IOException, ModelException, SerializationException {
// URI to filename
URL url = null;
try {
url = new URL(m.getSourceURI());
} catch (Exception any) {
throw new ModelException("RDFUtil: cannot determine model file name: " + m.getSourceURI());
}
if ("file".equals(url.getProtocol()))
saveModel(m, url.getFile().replace('/', File.separatorChar), s);
else
throw new ModelException("RDFUtil: cannot save to non-file model URI: " + m.getSourceURI());
}
private static String[] findStandardMBeans(URL codeBase) throws Exception {
Set<String> names;
if (codeBase.getProtocol().equalsIgnoreCase("file") && codeBase.toString().endsWith("/"))
names = findStandardMBeansFromDir(codeBase);
else names = findStandardMBeansFromJar(codeBase);
Set<String> standardMBeanNames = new TreeSet<String>();
for (String name : names) {
if (name.endsWith("MBean")) {
String prefix = name.substring(0, name.length() - 5);
if (names.contains(prefix)) standardMBeanNames.add(prefix);
}
}
return standardMBeanNames.toArray(new String[0]);
}
private void createConnection() throws IOException {
String effectiveUrl = URLUtils.appendParametersToQueryString(url, querystringParams);
if (connection == null) {
System.setProperty("http.keepAlive", connectionKeepAlive ? "true" : "false");
// connection = (HttpURLConnection) new URL(effectiveUrl).openConnection();
URL url = new URL(effectiveUrl);
if (url.getProtocol().toLowerCase().equals("https")) {
trustAllHosts();
HttpsURLConnection https = (HttpsURLConnection) url.openConnection();
https.setHostnameVerifier(DO_NOT_VERIFY);
connection = https;
} else {
connection = (HttpURLConnection) url.openConnection();
}
}
}
/** ** Sets the 'port' */
public boolean setPort(int _port) {
String uri = this.getURI();
if ((_port > 0) && URIArg.isAbsoluteURL(uri)) {
try {
URL oldURI = new URL(uri);
String proto = oldURI.getProtocol();
String host = oldURI.getHost();
int port = _port;
String file = oldURI.getFile();
URL newURI = new URL(proto, host, port, file);
this._setURI(newURI.toString());
return true;
} catch (MalformedURLException mue) {
// error
}
}
return false;
}
/**
* Get the last modification date of a URL.
*
* @return last modified timestamp "as is"
*/
public static long getLastModified(URL url) throws IOException {
if ("file".equals(url.getProtocol())) {
// Optimize file: access. Also, this prevents throwing an exception if the file doesn't exist
// as we try to close the stream below.
return new File(URLDecoder.decode(url.getFile(), STANDARD_PARAMETER_ENCODING)).lastModified();
} else {
// Use URLConnection
final URLConnection urlConnection = url.openConnection();
if (urlConnection instanceof HttpURLConnection)
((HttpURLConnection) urlConnection).setRequestMethod("HEAD");
try {
return getLastModified(urlConnection);
} finally {
final InputStream is = urlConnection.getInputStream();
if (is != null) is.close();
}
}
}
private void downloadImage(final MercatorTextureTile tile, String mimeType) throws Exception {
// System.out.println(tile.getPath());
final URL resourceURL = tile.getResourceURL(mimeType);
Retriever retriever;
String protocol = resourceURL.getProtocol();
if ("http".equalsIgnoreCase(protocol)) {
retriever = new HTTPRetriever(resourceURL, new HttpRetrievalPostProcessor(tile));
} else {
String message =
Logging.getMessage("layers.TextureLayer.UnknownRetrievalProtocol", resourceURL);
throw new RuntimeException(message);
}
retriever.setConnectTimeout(10000);
retriever.setReadTimeout(20000);
retriever.call();
}
static void loadDescriptorsFromClassPath(
@NotNull List<IdeaPluginDescriptorImpl> result, @Nullable StartupProgress progress) {
Collection<URL> urls = getClassLoaderUrls();
String platformPrefix = System.getProperty(PlatformUtilsCore.PLATFORM_PREFIX_KEY);
int i = 0;
for (URL url : urls) {
i++;
if ("file".equals(url.getProtocol())) {
File file = new File(decodeUrl(url.getFile()));
IdeaPluginDescriptorImpl platformPluginDescriptor = null;
if (platformPrefix != null) {
platformPluginDescriptor = loadDescriptor(file, platformPrefix + "Plugin.xml");
if (platformPluginDescriptor != null && !result.contains(platformPluginDescriptor)) {
platformPluginDescriptor.setUseCoreClassLoader(true);
result.add(platformPluginDescriptor);
}
}
IdeaPluginDescriptorImpl pluginDescriptor = loadDescriptor(file, PLUGIN_XML);
if (platformPrefix != null
&& pluginDescriptor != null
&& pluginDescriptor.getName().equals(SPECIAL_IDEA_PLUGIN)) {
continue;
}
if (pluginDescriptor != null && !result.contains(pluginDescriptor)) {
if (platformPluginDescriptor != null) {
// if we found a regular plugin.xml in the same .jar/root as a platform-prefixed
// descriptor, use the core loader for it too
pluginDescriptor.setUseCoreClassLoader(true);
}
result.add(pluginDescriptor);
if (progress != null) {
progress.showProgress(
"Plugin loaded: " + pluginDescriptor.getName(),
PLUGINS_PROGRESS_MAX_VALUE * ((float) i / urls.size()));
}
}
}
}
}
public static URL adjustURLForHosting(URL url_in) {
if (isHosting(url_in)) {
String url = url_in.getProtocol() + "://";
if (bind_ip.length() < 7) {
url += "127.0.0.1";
} else {
url += bind_ip;
}
int port = url_in.getPort();
if (port != -1) {
url += ":" + url_in.getPort();
}
url += url_in.getPath();
String query = url_in.getQuery();
if (query != null) {
url += "?" + query;
}
try {
return (new URL(url));
} catch (MalformedURLException e) {
Debug.printStackTrace(e);
}
}
return (url_in);
}
/**
* mapUrlToFileLocation() is the method used to resolve urls into file names. This maps a given
* url to a file location, using the au top directory as the base. It creates directories which
* mirror the html string, so 'http://www.journal.org/issue1/index.html' would be cached in the
* file: <rootLocation>/www.journal.org/http/issue1/index.html
*
* @param rootLocation the top directory for ArchivalUnit this URL is in
* @param urlStr the url to translate
* @return the url file location
* @throws java.net.MalformedURLException
*/
public static String mapUrlToFileLocation(String rootLocation, String urlStr)
throws MalformedURLException {
int totalLength = rootLocation.length() + urlStr.length();
URL url = new URL(urlStr);
StringBuilder buffer = new StringBuilder(totalLength);
buffer.append(rootLocation);
if (!rootLocation.endsWith(File.separator)) {
buffer.append(File.separator);
}
buffer.append(url.getHost().toLowerCase());
int port = url.getPort();
if (port != -1) {
buffer.append(PORT_SEPARATOR);
buffer.append(port);
}
buffer.append(File.separator);
buffer.append(url.getProtocol());
if (RepositoryManager.isEnableLongComponents()) {
String escapedPath =
escapePath(
StringUtil.replaceString(url.getPath(), UrlUtil.URL_PATH_SEPARATOR, File.separator));
String query = url.getQuery();
if (query != null) {
escapedPath = escapedPath + "?" + escapeQuery(query);
}
String encodedPath = RepositoryNodeImpl.encodeUrl(escapedPath);
// encodeUrl strips leading / from path
buffer.append(File.separator);
buffer.append(encodedPath);
} else {
buffer.append(
escapePath(
StringUtil.replaceString(url.getPath(), UrlUtil.URL_PATH_SEPARATOR, File.separator)));
String query = url.getQuery();
if (query != null) {
buffer.append("?");
buffer.append(escapeQuery(query));
}
}
return buffer.toString();
}
/**
* Discover WS device on the local network with specified filter
*
* @param regexpProtocol url protocol matching regexp like "^http$", might be empty ""
* @param regexpPath url path matching regexp like "onvif", might be empty ""
* @return list of unique device urls filtered
*/
public static Collection<URL> discoverWsDevicesAsUrls(String regexpProtocol, String regexpPath) {
final Collection<URL> urls =
new TreeSet<>(
new Comparator<URL>() {
public int compare(URL o1, URL o2) {
return o1.toString().compareTo(o2.toString());
}
});
for (String key : discoverWsDevices()) {
try {
final URL url = new URL(key);
boolean ok = true;
if (regexpProtocol.length() > 0 && !url.getProtocol().matches(regexpProtocol)) ok = false;
if (regexpPath.length() > 0 && !url.getPath().matches(regexpPath)) ok = false;
if (ok) urls.add(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
return urls;
}
private boolean isFile(URL ret) {
return ret != null && ret.getProtocol().equals("file");
}
@SuppressWarnings({"HardCodedStringLiteral"})
@Nullable
public static IdeaPluginDescriptorImpl loadDescriptor(
final File file, @NonNls final String fileName) {
IdeaPluginDescriptorImpl descriptor = null;
if (file.isDirectory()) {
descriptor = loadDescriptorFromDir(file, fileName);
if (descriptor == null) {
File libDir = new File(file, "lib");
if (!libDir.isDirectory()) {
return null;
}
final File[] files = libDir.listFiles();
if (files == null || files.length == 0) {
return null;
}
Arrays.sort(
files,
new Comparator<File>() {
@Override
public int compare(File o1, File o2) {
if (o2.getName().startsWith(file.getName())) return Integer.MAX_VALUE;
if (o1.getName().startsWith(file.getName())) return -Integer.MAX_VALUE;
if (o2.getName().startsWith("resources")) return -Integer.MAX_VALUE;
if (o1.getName().startsWith("resources")) return Integer.MAX_VALUE;
return 0;
}
});
for (final File f : files) {
if (FileUtil.isJarOrZip(f)) {
descriptor = loadDescriptorFromJar(f, fileName);
if (descriptor != null) {
descriptor.setPath(file);
break;
}
// getLogger().warn("Cannot load descriptor from " + f.getName() + "");
} else if (f.isDirectory()) {
IdeaPluginDescriptorImpl descriptor1 = loadDescriptorFromDir(f, fileName);
if (descriptor1 != null) {
if (descriptor != null) {
getLogger()
.info("Cannot load " + file + " because two or more plugin.xml's detected");
return null;
}
descriptor = descriptor1;
descriptor.setPath(file);
}
}
}
}
} else if (StringUtil.endsWithIgnoreCase(file.getName(), ".jar") && file.exists()) {
descriptor = loadDescriptorFromJar(file, fileName);
}
if (descriptor != null && !descriptor.getOptionalConfigs().isEmpty()) {
final Map<PluginId, IdeaPluginDescriptorImpl> descriptors =
new HashMap<PluginId, IdeaPluginDescriptorImpl>(descriptor.getOptionalConfigs().size());
for (Map.Entry<PluginId, String> entry : descriptor.getOptionalConfigs().entrySet()) {
String optionalDescriptorName = entry.getValue();
assert !Comparing.equal(fileName, optionalDescriptorName)
: "recursive dependency: " + fileName;
IdeaPluginDescriptorImpl optionalDescriptor = loadDescriptor(file, optionalDescriptorName);
if (optionalDescriptor == null && !FileUtil.isJarOrZip(file)) {
for (URL url : getClassLoaderUrls()) {
if ("file".equals(url.getProtocol())) {
optionalDescriptor =
loadDescriptor(new File(decodeUrl(url.getFile())), optionalDescriptorName);
if (optionalDescriptor != null) {
break;
}
}
}
}
if (optionalDescriptor != null) {
descriptors.put(entry.getKey(), optionalDescriptor);
} else {
getLogger().info("Cannot find optional descriptor " + optionalDescriptorName);
}
}
descriptor.setOptionalDescriptors(descriptors);
}
return descriptor;
}
private static boolean isFileURL(URL url) {
return url.getProtocol().equalsIgnoreCase("file");
}