/** 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())); }
public static URL container(String resource, ClassLoader cl) { final URL resUrl = cl.getResource(resource); if (resUrl == null) { throw new IllegalArgumentException("Resource not found: " + resource); } final StringBuilder url = new StringBuilder(resUrl.toExternalForm()); try { if ("jar".equalsIgnoreCase(resUrl.getProtocol())) { url.delete(0, 4).delete(url.indexOf(resource) - 2, url.length()); } else if ("file".equalsIgnoreCase(resUrl.getProtocol())) { url.delete(url.indexOf(resource), url.length()); } else { throw new UnsupportedOperationException( "Cannot get container for resource [" + resource + "]. Unsupported URL protocol [" + resUrl.getProtocol() + "]."); } return new URL(url.toString()); } catch (MalformedURLException e) { throw new UnsupportedOperationException( "Cannot get container for resource [" + resource + "]. Malformed URL [" + url + "]."); } }
private List<String> searchDependencyEngineConfigFiles( String prefixPackageName, Class<?> contentLoaderClass) { List<String> fileNames = new ArrayList<String>(); Enumeration<?> enumFiles = findConfigFileUrls(prefixPackageName, contentLoaderClass); while (enumFiles != null && enumFiles.hasMoreElements()) { URL url = (URL) enumFiles.nextElement(); if (url == null || url.getFile() == null || url.getFile().length() <= 1) continue; String fileName = getFileName(url.getPath()); if (url.getProtocol() != null && url.getProtocol().equalsIgnoreCase("jar")) { String elementInJar = getJarFileEntryName(url.getPath()); JarFile jarFile = openJar(url); List<JarEntry> entries = Collections.list(jarFile.entries()); for (JarEntry entry : entries) { String entryName = entry.getName(); if (entryName.startsWith(elementInJar)) { if (!entry.isDirectory() && entryName.matches(dependencyEngineConfigFileRegex)) { fileNames.add(fileName + "!" + "/" + entry.toString()); } } } } else { List<String> list = searchDependencyEngineConfigFiles(new File(fileName)); if (list != null && list.size() > 0) { fileNames.addAll(list); } } } return fileNames; }
private String sendPop(Transaction tx) { RequestBody requestBody = RequestBody.create(MediaType.parse("application/bitcoin-pop"), tx.toBytes()); URL url; try { url = new URL(popRequest.getP()); if (!"http".equals(url.getProtocol()) && !"https".equals(url.getProtocol())) { return "Invalid Url, expected protocol http or https: " + popRequest.getP(); } } catch (MalformedURLException e) { return "Invalid Url: " + popRequest.getP(); } Request request = new Request.Builder().url(url).post(requestBody).build(); OkHttpClient httpClient = new OkHttpClient(); if (_mbwManager.getTorMode() == ServerEndpointType.Types.ONLY_TOR && _mbwManager.getTorManager() != null) { httpClient = _mbwManager.getTorManager().setupClient(httpClient); } try { Response response = httpClient.newCall(request).execute(); if (response.isSuccessful()) { return response.body().string(); } else { return "Error occurred: " + response.code(); } } catch (IOException e) { return "Cannot communicate with server: " + e.getMessage(); } }
public Map<String, URL> getResourcesMap(String uri) throws IOException { String basePath = path + uri; Map<String, URL> resources = new HashMap<String, URL>(); if (!basePath.endsWith("/")) { basePath += "/"; } Enumeration<URL> urls = getResources(basePath); while (urls.hasMoreElements()) { URL location = urls.nextElement(); try { if (location.getProtocol().equals("jar")) { readJarEntries(location, basePath, resources); } else if (location.getProtocol().equals("file")) { readDirectoryEntries(location, resources); } } catch (Exception e) { } } return resources; }
@Override public boolean onPreferenceChange(Preference preference, Object value) { String stringValue = value.toString(); if (preference instanceof ListPreference) { ListPreference listPreference = (ListPreference) preference; int index = listPreference.findIndexOfValue(stringValue); preference.setSummary(index >= 0 ? listPreference.getEntries()[index] : null); } else { preference.setSummary(stringValue); } // detect errors if (preference.getKey().equals("sos_uri")) { try { URL url = new URL(value.toString()); if (!url.getProtocol().equals("http") && !url.getProtocol().equals("https")) throw new Exception("SOS URL must be HTTP or HTTPS"); } catch (Exception e) { AlertDialog.Builder dlgAlert = new AlertDialog.Builder(preference.getContext()); dlgAlert.setMessage("Invalid SOS URL"); dlgAlert.setTitle(e.getMessage()); dlgAlert.setPositiveButton("OK", null); dlgAlert.setCancelable(true); dlgAlert.create().show(); } } return true; }
/** * This is something of a hack. Velocity loads files relative to the property * VelocityEngine.FILE_RESOURCE_LOADER_PATH. So if we can find the template ourselves then we can * infer what the property value should be so that velocity works ok. */ private void inferVelocityLoaderPath(VelocityEngine ve) throws IOException { String defaultPath = (String) ve.getProperty(VelocityEngine.FILE_RESOURCE_LOADER_PATH); if (null == defaultPath || StringUtils.isEmpty(defaultPath)) { URL url = IOUtils.getResourceAsUrl(MuleDocPostRenderer.DEFAULT_MULE_TEMPLATE, getClass()); if (FILE.equals(url.getProtocol())) { String path = FileUtils.getResourcePath(MuleDocPostRenderer.DEFAULT_MULE_TEMPLATE, getClass()); if (!StringUtils.isEmpty(path)) { File fullPath = new File(path); File target = new File(MuleDocPostRenderer.DEFAULT_MULE_TEMPLATE); // drop trailing files until we are at the relative parent while (null != target && !StringUtils.isEmpty(target.getPath())) { env.log(fullPath.getPath() + " - " + target.getPath()); target = target.getParentFile(); fullPath = fullPath.getParentFile(); } path = fullPath.getPath(); if (path.endsWith("!")) { path = path + File.separator; } getEnv().log(VelocityEngine.FILE_RESOURCE_LOADER_PATH + " = " + path); ve.setProperty(VelocityEngine.FILE_RESOURCE_LOADER_PATH, path); } } else if (JAR.equals(url.getProtocol())) { env.log(url.toString()); ve.setProperty(VelocityEngine.RESOURCE_LOADER, "class"); ve.setProperty(MAGIC_VELOCITY_RESOURCE_LOADER, ClasspathResourceLoader.class.getName()); } } }
/** * Open FBS file identified by {@link #fbsURL}. The stream is positioned at the entry point * described by <code>entryPoint</code>. * * @param entryPoint entry point information. * @return a newly created FBS input stream on success, <code>null</code> if any error occured and * the FBS stream is not opened. * @throws java.io.IOException if an I/O exception occurs. */ private FbsInputStream openFbsFile(FbsEntryPoint entry) throws IOException { System.err.println("Entering FBS at " + entry.timestamp + " ms"); // Make sure the protocol is HTTP. if (!fbkURL.getProtocol().equalsIgnoreCase("http") || !fbsURL.getProtocol().equalsIgnoreCase("http")) { System.err.println("Indexed access requires HTTP protocol in URLs"); return null; } // Seek to the keyframe. InputStream is = openHttpByteRange(fbkURL, entry.key_fpos, entry.key_size); if (is == null) { return null; } // Load keyframe data from the .fbk file, prepend RFB initialization data. DataInputStream data = new DataInputStream(is); byte[] keyData = new byte[rfbInitData.length + (int) entry.key_size]; System.arraycopy(rfbInitData, 0, keyData, 0, rfbInitData.length); data.readFully(keyData, rfbInitData.length, (int) entry.key_size); data.close(); // Open the FBS stream. is = openHttpByteRange(fbsURL, entry.fbs_fpos, -1); if (is == null) { return null; } return new FbsInputStream(is, entry.timestamp, keyData, entry.fbs_skip); }
/** * @param he hiperlik Event. * @see * javax.help.plaf.basic.BasicContentViewerUI#hyperlinkUpdate(javax.swing.event.HyperlinkEvent) */ @Override public void hyperlinkUpdate(final HyperlinkEvent he) { if (he.getEventType() == HyperlinkEvent.EventType.ACTIVATED) { URL u = he.getURL(); if ("mailto".equalsIgnoreCase(u.getProtocol()) || "http".equalsIgnoreCase(u.getProtocol()) || "ftp".equalsIgnoreCase(u.getProtocol())) { Desktop desktop = null; if (Desktop.isDesktopSupported()) { desktop = Desktop.getDesktop(); if (desktop.isSupported(Desktop.Action.BROWSE)) { try { desktop.browse(u.toURI()); } catch (MalformedURLException e1) { DialogUtils.showGeneralErrorDialog( new Frame(), "MalformedURLException", "Invalid URL."); } catch (IOException e1) { DialogUtils.showGeneralErrorDialog(new Frame(), "IOException", "Resource not found."); } catch (URISyntaxException uriSyntaxEx) { DialogUtils.showGeneralErrorDialog(new Frame(), "URISyntaxException", "Invalid URI."); } } } } else { super.hyperlinkUpdate(he); } } }
protected String[] listResources() throws IOException, URISyntaxException { String[] files = new String[0]; URL dirURL = ClassLoader.getSystemResource(schemaPath); FilenameFilter fileFilter = new FilenameFilter() { @Override public boolean accept(File dir, String name) { return ((name.lastIndexOf('.') > -1) && (".xml".equalsIgnoreCase(name.substring(name.lastIndexOf('.'))))); } }; if (dirURL == null) { throw new FileNotFoundException(schemaPath); } if (dirURL.getProtocol().equals("file")) { files = listFileResources(dirURL, schemaPath, fileFilter); } if (dirURL.getProtocol().equals("jar")) { files = listJarResources(dirURL, fileFilter); } return files; }
public static File toFile(final URL url) { if ("jar".equals(url.getProtocol())) { try { final String spec = url.getFile(); int separator = spec.indexOf('!'); /* * REMIND: we don't handle nested JAR URLs */ if (separator == -1) throw new MalformedURLException("no ! found in jar url spec:" + spec); return toFile(new URL(spec.substring(0, separator++))); } catch (MalformedURLException e) { throw new IllegalStateException(e); } } else if ("file".equals(url.getProtocol())) { String path = decode(url.getFile()); if (path.endsWith("!")) { path = path.substring(0, path.length() - 1); } return new File(path); } else { throw new IllegalArgumentException("Unsupported URL scheme: " + url.toExternalForm()); } }
/** * Generate the signature base that is used to produce the signature * * @param url The full url that needs to be signed including its non OAuth url parameters * @param httpMethod The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc) * @param parameters * @param normalizedUrl * @param normalizedRequestParameters * @return */ private String generateSignatureBase( URL url, String httpMethod, List<QParameter> parameters, StringBuffer normalizedUrl, StringBuffer normalizedRequestParameters) { Collections.sort(parameters); normalizedUrl.append(url.getProtocol()); normalizedUrl.append("://"); normalizedUrl.append(url.getHost()); if ((url.getProtocol().equals("http") || url.getProtocol().equals("https")) && url.getPort() != -1) { normalizedUrl.append(":"); normalizedUrl.append(url.getPort()); } normalizedUrl.append(url.getPath()); normalizedRequestParameters.append(formEncodeParameters(parameters)); StringBuffer signatureBase = new StringBuffer(); signatureBase.append(httpMethod.toUpperCase()); signatureBase.append("&"); signatureBase.append(encode(normalizedUrl.toString())); signatureBase.append("&"); signatureBase.append(encode(normalizedRequestParameters.toString())); return signatureBase.toString(); }
/** * to send Head request to the server to check for content type and content size * * @param current_url * @return */ public boolean is_valid_file(String current_url) throws IOException { // System.out.print("[Output from log4j] Checking validity for url +" + current_url); // create and send HEAD request // // // // System.out.println("[Output from log4j] before head request + " + current_url); this.response_headers = crawler_client.fetch_head_response_url(current_url); // // // // System.out.println("[Output from log4j] after head request + " + // response_headers.size()); // // // // System.out.println("[Output from log4j] After fetching response header in // is_valid_file"); // base case - no response headers recieved from the server if (this.response_headers == null) return false; // check for location header if (this.response_headers.containsKey("location")) { this.is_reloc = true; String re_loc = this.response_headers.get("location"); if (re_loc.startsWith("/")) { URL url_obj = new URL(current_url); String path = url_obj.getPath(); String abs_reloc; if (path.endsWith(".xml") || path.endsWith(".html") || path.endsWith("htm")) path = path.substring(0, path.lastIndexOf("/")); if (path.endsWith("/")) abs_reloc = url_obj.getProtocol() + "://" + url_obj.getHost() + path.substring(0, path.length() - 1) + re_loc; else abs_reloc = url_obj.getProtocol() + "://" + url_obj.getHost() + path + re_loc; System.err.println("[Output from log4j] Found Relocation url +" + abs_reloc); WebURLQueue queue = new WebURLQueue(); queue.addToQueue(abs_reloc); return false; } else { WebURLQueue queue = new WebURLQueue(); queue.addToQueue(re_loc); return false; } } // if content type is not present in response header if (!(this.response_headers.containsKey("content-type"))) return false; // check valid content types this.content_type = this.response_headers.get("content-type"); // if valid content type if (!content_type.equals("text/xml") && !content_type.equals("text/html") && !content_type.endsWith("+xml") && !content_type.equals("application/xml")) return false; // // // // System.out.println("[Output from log4j] Chheck till Content type"); // check content-length exists if (this.response_headers.containsKey("content-length")) { this.content_length = Double.parseDouble(this.response_headers.get("content-length")); // checking allowed content-length for the document if (this.content_length > (XPathCrawler.maxsize_doc * 1024 * 1024)) return false; } // // // // System.out.println("[Output from log4j] Chheck till Content Length"); return true; }
@Override protected URLConnection openConnection(URL u) throws IOException { String path = u.getPath().substring(1); String refr = u.getRef(); StringBuilder test = new StringBuilder(path); if (refr != null && refr.length() > 0) { test.append(".part."); for (int i = 0; i < refr.length() - 1; i++) { test.append("0"); } test.append("1"); } URL local = Thread.currentThread().getContextClassLoader().getResource(test.toString()); String base = local.toExternalForm(); int end = base.length() - test.length(); base = base.substring(0, end); if ("file".equals(local.getProtocol())) { return new XcfFileConnection(new URL(base), u); } else if ("jar".equals(local.getProtocol())) { return new XcfJarConnection(new URL(base), u); } else { throw new IOException("base protocol[" + local.getProtocol() + "] isn't supported"); } }
private JarURLConnection openJarURLConnection(final URL url) throws IOException { final URL checkedUrl; if ("zip".equals(url.getProtocol())) { // WebLogic returns URL with "zip" protocol, returning a // weblogic.utils.zip.ZipURLConnection when opened // Easy fix is to convert this URL to jar URL checkedUrl = new URL(url.toExternalForm().replace("zip:/", "jar:file:/")); } else { checkedUrl = url; } URLConnection urlConnection = checkedUrl.openConnection(); // GlassFish 4.1.1 is providing a URLConnection of type: // http://svn.apache.org/viewvc/felix/trunk/framework/src/main/java/org/ // apache/felix/framework/URLHandlersBundleURLConnection.java?view=markup // Which does _not_ extend JarURLConnection. // This bit of reflection allows us to call the getLocalURL method which // actually returns a URL to a jar file. if (checkedUrl.getProtocol().startsWith("bundle")) { try { final Method m = urlConnection.getClass().getDeclaredMethod("getLocalURL"); if (!m.isAccessible()) { m.setAccessible(true); } final URL jarUrl = (URL) m.invoke(urlConnection); urlConnection = jarUrl.openConnection(); } catch (Exception ex) { throw new AssertionError("Couldn't read jar file URL from bundle: " + ex); } } if (urlConnection instanceof JarURLConnection) { return (JarURLConnection) urlConnection; } else { throw new AssertionError("Unknown URLConnection type: " + urlConnection.getClass().getName()); } }
private InputStream retrieveConfigurationFileFromRemoteRepository() throws Exception { if (configFileURL.getProtocol().startsWith("http")) { HttpGet httpGet = new HttpGet(configFileURL.toURI()); DefaultHttpClient client = new DefaultHttpClient(); configureProxy(client); HttpResponse httpResponse = client.execute(httpGet); switch (httpResponse.getStatusLine().getStatusCode()) { case 200: log.debug("Connected to repository! Getting available Stacks"); break; case 404: log.error("Failed! (Config file not found: " + configFileURL + ")"); return null; default: log.error( "Failed! (server returned status code: " + httpResponse.getStatusLine().getStatusCode()); return null; } return httpResponse.getEntity().getContent(); } else if (configFileURL.getProtocol().startsWith("file")) { return new FileInputStream(new File(configFileURL.toURI())); } return null; }
/** * Encodes illegal characters in the specified URL's path, query string and anchor according to * the URL encoding rules observed in real browsers. * * <p>For example, this method changes <tt>"http://first/?a=b c"</tt> to * <tt>"http://first/?a=b%20c"</tt>. * * @param url the URL to encode * @param minimalQueryEncoding whether or not to perform minimal query encoding, like IE does * @param charset the charset * @return the encoded URL */ public static URL encodeUrl( final URL url, final boolean minimalQueryEncoding, final String charset) { final String p = url.getProtocol(); if ("javascript".equalsIgnoreCase(p) || "about".equalsIgnoreCase(p) || "data".equalsIgnoreCase(p)) { // Special exception. return url; } try { String path = url.getPath(); if (path != null) { path = encode(path, PATH_ALLOWED_CHARS, "UTF-8"); } String query = url.getQuery(); if (query != null) { if (minimalQueryEncoding) { query = org.apache.commons.lang3.StringUtils.replace(query, " ", "%20"); } else { query = encode(query, QUERY_ALLOWED_CHARS, charset); } } String anchor = url.getRef(); if (anchor != null) { anchor = encode(anchor, ANCHOR_ALLOWED_CHARS, "UTF-8"); } return createNewUrl(url.getProtocol(), url.getHost(), url.getPort(), path, anchor, query); } catch (final MalformedURLException e) { // Impossible... I think. throw new RuntimeException(e); } }
/** * Comparison that does not consider Ref. * * @param url1 the url1 * @param url2 the url2 * @return true, if successful */ public static boolean sameNoRefURL(URL url1, URL url2) { return Objects.equals(url1.getHost(), url2.getHost()) && Objects.equals(url1.getProtocol(), url2.getProtocol()) && (url1.getPort() == url2.getPort()) && Objects.equals(url1.getFile(), url2.getFile()) && Objects.equals(url1.getUserInfo(), url2.getUserInfo()); }
private void addPluginArtifact(Set<URI> artifactsPath) { // for Maven 2.x, the actual artifact isn't in the list.... need to try and find it URL url = getClass().getResource(getClass().getSimpleName() + ".class"); try { if ("jar".equals(url.getProtocol())) { String s = url.getPath(); if (s.contains("!")) { s = s.substring(0, s.indexOf('!')); url = new URL(s); } } URI uri = new URI(url.getProtocol(), null, url.getPath(), null, null); if (uri.getSchemeSpecificPart().endsWith(".class")) { String s = uri.toString(); s = s.substring(0, s.length() - 6 - getClass().getName().length()); uri = new URI(s); } File file = new File(uri); if (file.exists()) { artifactsPath.add(file.toURI()); } } catch (Exception ex) { // ex.printStackTrace(); } }
public static URL removeRef(URL url) throws MalformedURLException { int port = url.getPort(); if (port == 80 && url.getProtocol().equalsIgnoreCase("http")) port = -1; else if (port == 443 && url.getProtocol().equalsIgnoreCase("https")) port = -1; URL u = new URL(url.getProtocol(), url.getHost(), port, url.getFile()); return u; }
public static Transport getTransportForURL(URL url) { Transport retVal = null; if (url.getProtocol().equals("http")) { retVal = new HTTPTransport(); } else if (url.getProtocol().equals("https")) { retVal = new HTTPTransport(); } return retVal; }
/** A couple quick checks on the url */ public static final boolean isPostGIS(URL url) { if (url == null) { return false; } return url.getProtocol().toLowerCase().equals("postgis") || url.getProtocol().toLowerCase().equals("postgis.jdbc") || //$NON-NLS-1$ //$NON-NLS-2$ url.getProtocol().toLowerCase().equals("jdbc.postgis"); // $NON-NLS-1$ }
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(); } } }
/** Convenience method for setPage(String) */ @Override public void setPage(URL url) { if ("file".equals(url.getProtocol()) || "jar".equals(url.getProtocol())) { // Creating file by url.toString() and using file.getName() preserves anchors File file = new File(url.toString()); setPage(file.getName(), JabRef.class); } else { // open all external URLs externally JabRef.jrf.openBrowser(url.toString()); } }
/* this code is workaround for subtle bug/feature in JDK1.3.1 and 1.4, related to loading applets behind proxy */ protected PermissionCollection getPermissions(CodeSource codesource) { PermissionCollection sysPerms = null; Policy policy = (Policy) AccessController.doPrivileged( new PrivilegedAction() { public Object run() { return Policy.getPolicy(); } }); if (policy != null) sysPerms = policy.getPermissions(new CodeSource(null, null)); else sysPerms = new Permissions(); final PermissionCollection perms = sysPerms; if (base != null && base.getHost() != null) perms.add(new SocketPermission(base.getHost() + ":1-", "accept,connect,resolve")); URL url = codesource.getLocation(); if (url.getProtocol().equals("file")) { String path = url.getFile().replace('/', File.separatorChar); if (!path.endsWith(File.separator)) { int endIndex = path.lastIndexOf(File.separatorChar); if (endIndex != -1) { path = path.substring(0, endIndex + 1) + "-"; perms.add(new FilePermission(path, "read")); } } perms.add(new SocketPermission("localhost", "connect,accept")); AccessController.doPrivileged( new PrivilegedAction() { public Object run() { try { String host = InetAddress.getLocalHost().getHostName(); perms.add(new SocketPermission(host, "connect,accept")); } catch (UnknownHostException uhe) { } return null; } }); if (base.getProtocol().equals("file")) { String bpath = base.getFile().replace('/', File.separatorChar); if (bpath.endsWith(File.separator)) { bpath += "-"; } perms.add(new FilePermission(bpath, "read")); } } // for (Enumeration e=perms.elements();e.hasMoreElements();) // System.err.println("p="+e.nextElement()); return perms; }
public static List<GenerationTarget> getTargets() { if (m_targets != null) { return m_targets; } m_targets = new ArrayList<GenerationTarget>(); URL location = getClassLocation(); if (location == null) return m_targets; if (location.getProtocol().equals("file")) { String encoded = location.getFile(); File classFileLocation = null; try { String decoded = URLDecoder.decode(encoded, "UTF-8"); // important classFileLocation = new File(decoded); } catch (UnsupportedEncodingException ex) { ex.printStackTrace(); } // end try if (classFileLocation != null) { File root = classFileLocation; String classname = GenerationTarget.class.getName(); int levels = countNbChars(classname, '.'); // iterate to the root for (int i = 0; i < levels; i++) { root = root.getParentFile(); } // end while scanFolder(classFileLocation.getParentFile(), root, m_targets); } } else if (location.getProtocol().equals("jar")) { String jarname = location.toExternalForm(); int index = jarname.indexOf(".jar!"); if (index > -1) jarname = jarname.substring(0, index + 4); index = jarname.indexOf("jar:"); if (index > -1) { jarname = jarname.substring(4); } index = jarname.indexOf("file:/"); if (index > -1) { jarname = jarname.substring(6); } index = jarname.indexOf("file:"); if (index > -1) { jarname = jarname.substring(5); } scanJar(new File(jarname), new File(System.getProperty("java.io.tmpdir")), m_targets); } return m_targets; }
/** * Whether the requested redirect URI "matches" the specified redirect URI. For a URL, this * implementation tests if the user requested redirect starts with the registered redirect, so it * would have the same host and root path if it is an HTTP URL. * * <p>For other (non-URL) cases, such as for some implicit clients, the redirect_uri must be an * exact match. * * @param requestedRedirect The requested redirect URI. * @param redirectUri The registered redirect URI. * @return Whether the requested redirect URI "matches" the specified redirect URI. */ protected boolean redirectMatches(String requestedRedirect, String redirectUri) { try { URL req = new URL(requestedRedirect); URL reg = new URL(redirectUri); if (reg.getProtocol().equals(req.getProtocol()) && reg.getHost().equals(req.getHost())) { return requestedRedirect.startsWith(redirectUri); } } catch (MalformedURLException e) { } return requestedRedirect.equals(redirectUri); }
public static String convertHref(URL baseURL, String href) { if (href == null) return href; if (href.startsWith("/")) return baseURL.getProtocol() + "://" + baseURL.getHost() + href; if (!href.startsWith("http://")) return baseURL.getProtocol() + "://" + baseURL.getHost() + "/" + baseURL.getPath() + "/" + href; return href; }
/** * 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; }
public URLConnection openConnection(URL url) throws IOException { if (expectedUrl == null) { throw new IllegalStateException("expectedUrl was not set"); } // the caller copied the URL reusing a stream handler from a previous call if (!expectedUrl.equals(url)) { // the new url is supposed to be within our context, so it must have a jar protocol if (!url.getProtocol().equals("jar")) { throw new IllegalArgumentException("Unsupported protocol " + url.getProtocol()); } // split the path at "!/" into the file part and entry part String path = url.getPath(); String[] chunks = path.split("!/", 2); // if we only got only one chunk, it didn't contain the required "!/" delimiter if (chunks.length == 1) { throw new MalformedURLException("Url does not contain a '!' character: " + url); } String file = chunks[0]; String entryPath = chunks[1]; // this handler only supports jars on the local file system if (!file.startsWith("file:")) { // let the system handler deal with this return new URL(url.toExternalForm()).openConnection(); } file = file.substring("file:".length()); // again the new url is supposed to be within our context so it must reference the same jar // file if (!jarFile.getName().equals(file)) { // let the system handler deal with this return new URL(url.toExternalForm()).openConnection(); } // get the entry JarEntry newEntry = jarFile.getJarEntry(entryPath); if (newEntry == null) { throw new FileNotFoundException("Entry not found: " + url); } return new JarFileUrlConnection(url, jarFile, newEntry); } return new JarFileUrlConnection(url, jarFile, jarEntry); }