/*******************************************************************************
* Copyright (c) 2005, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Chris Aniszczyk (IBM Corp.) - Fixed NPE
*******************************************************************************/
package org.eclipse.update.internal.core;
import org.eclipse.update.core.IUpdateConstants;
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.osgi.util.NLS;
import org.eclipse.update.core.*;
import org.eclipse.update.core.model.InstallAbortedException;
import org.eclipse.update.internal.core.connection.ConnectionFactory;
import org.eclipse.update.internal.core.connection.IResponse;
import org.osgi.framework.Bundle;
import org.osgi.framework.Constants;
import org.osgi.service.packageadmin.PackageAdmin;
/**
*
*/
public class UpdateManagerUtils {
private static boolean OS_UNIX = org.eclipse.osgi.service.environment.Constants.OS_HPUX
.equals(Platform.getOS())
|| org.eclipse.osgi.service.environment.Constants.OS_AIX
.equals(Platform.getOS())
|| org.eclipse.osgi.service.environment.Constants.OS_LINUX
.equals(Platform.getOS())
|| org.eclipse.osgi.service.environment.Constants.OS_SOLARIS
.equals(Platform.getOS())
|| org.eclipse.osgi.service.environment.Constants.OS_MACOSX
.equals(Platform.getOS());
private static FragmentEntry[] noFragments = new FragmentEntry[0];
private static Map table;
static {
table = new HashMap();
table.put("compatible", new Integer(IUpdateConstants.RULE_COMPATIBLE)); //$NON-NLS-1$
table.put("perfect", new Integer(IUpdateConstants.RULE_PERFECT)); //$NON-NLS-1$
table.put("equivalent", new Integer(IUpdateConstants.RULE_EQUIVALENT)); //$NON-NLS-1$
table.put("greaterOrEqual", new Integer(IUpdateConstants.RULE_GREATER_OR_EQUAL)); //$NON-NLS-1$
}
// manage URL to File
private static Map urlFileMap;
private static Map localFileFragmentMap;
private static Stack bufferPool;
private static final int BUFFER_SIZE = 4096; // 4kbytes
private static final int INCREMENT_SIZE = 10240; // 10kbytes
/**
* return the urlString if it is a absolute URL
* otherwise, return the default URL if the urlString is null
* The defaultURL may point ot a file, create a file URL then
* if the urlString or the default URL are relatives, prepend the rootURL to it
*/
public static URL getURL(URL rootURL, String urlString, String defaultURL) throws MalformedURLException {
URL url = null;
// if no URL , provide Default
if (urlString == null || urlString.trim().equals("")) { //$NON-NLS-1$
// no URL, no default, return right now...
if (defaultURL == null || defaultURL.trim().equals("")) //$NON-NLS-1$
return null;
else
urlString = defaultURL;
}
// URL can be relative or absolute
if (urlString.startsWith("/") && urlString.length() > 1) //$NON-NLS-1$
urlString = urlString.substring(1);
try {
url = new URL(urlString);
} catch (MalformedURLException e) {
// the url is not an absolute URL
// try relative
url = new URL(rootURL, urlString);
}
return url;
}
/**
* return a relative String to rootURL
* if url contains rootURL so
* new URL(rootURL, resultString) == url
*
*/
public static String getURLAsString(URL rootURL, URL url) {
String result = null;
if (rootURL == null) {
return (url == null) ? null : url.toString();
}
// if no URL , return null
if (url != null) {
result = url.toExternalForm();
if (rootURL.getHost() != null && !rootURL.getHost().equals(url.getHost()))
return result;
if (rootURL.getProtocol() != null && !rootURL.getProtocol().equals(url.getProtocol()))
return result;
if (rootURL.getPort() != url.getPort())
return result;
String rootURLFileString = rootURL.getFile();
rootURLFileString = rootURLFileString.replace(File.separatorChar, '/');
if (!rootURLFileString.endsWith("/")) { //$NON-NLS-1$
int index = rootURLFileString.lastIndexOf('/');
if (index != -1) {
rootURLFileString = rootURLFileString.substring(0, index);
}
}
String urlFileString = url.getFile();
if (urlFileString.startsWith(rootURLFileString)) {
result = urlFileString.substring(rootURLFileString.length());
result = result.replace(File.separatorChar, '/');
} else {
// we need to check the following
// file:/C:/ and file:C:/
if ("file".equalsIgnoreCase(url.getProtocol())) { //$NON-NLS-1$
File rootFile = new File(rootURLFileString);
File urlFile = new File(urlFileString);
File relativePath = urlFile;
while (relativePath != null && !rootFile.equals(relativePath.getParentFile())) {
relativePath = relativePath.getParentFile();
}
if (relativePath == null) {
UpdateCore.warn("Cannot calculate relative path"); //$NON-NLS-1$
return url.toString();
} else {
String relativeRootString = relativePath.getParentFile().getAbsolutePath();
String fullString = urlFile.getAbsolutePath();
if (!fullString.startsWith(relativeRootString)) {
UpdateCore.warn("Full path:" + fullString + " does not start with " + relativeRootString); //$NON-NLS-1$ //$NON-NLS-2$
return url.toString();
} else {
String returnString = fullString.substring(relativeRootString.length() + 1);
if (urlFile.isDirectory())
returnString += File.separator;
// we lost the last slash when tranforming in File
returnString = returnString.replace(File.separatorChar, '/');
return returnString;
}
}
} else {
result = url.toString();
}
}
}
return result;
}
/**
* returns a translated String
*/
public static String getResourceString(String infoURL, ResourceBundle bundle) {
String result = null;
if (infoURL != null) {
result = Platform.getResourceString(UpdateCore.getPlugin().getBundle(), infoURL, bundle);
}
return result;
}
/**
*
*/
public static URL copyToLocal(InputStream sourceContentReferenceStream, String localName, InstallMonitor monitor) throws MalformedURLException, IOException, InstallAbortedException {
URL result = null;
// create the Dir if they do not exist
// get the path from the File to resolve File.separator..
// do not use the String as it may contain URL like separator
File localFile = new File(localName);
int index = localFile.getPath().lastIndexOf(File.separator);
if (index != -1) {
File dir = new File(localFile.getPath().substring(0, index));
if (!dir.exists())
dir.mkdirs();
}
// transfer the content of the File
if (!localFile.isDirectory()) {
OutputStream localContentReferenceStream = new FileOutputStream(localFile);
try {
Utilities.copy(sourceContentReferenceStream, localContentReferenceStream, monitor);
} finally {
try {
localContentReferenceStream.close();
} catch (IOException e){}
}
}
result = localFile.toURL();
return result;
}
/*
* [20305] need to slam permissions for executable libs on some
* platforms. This is a temporary fix
*/
public static void checkPermissions(ContentReference ref, String filePath) {
if (ref.getPermission() != 0) {
UpdateCore.warn("Change permission for " + filePath + " to " + ref.getPermission()); //$NON-NLS-1$ //$NON-NLS-2$
// FIXME: change the code to use JNI
}
if (filePath != null && OS_UNIX && ref.getPermission() != 0) {
// add execute permission on shared libraries 20305
// do not remove write permission 20896
// chmod a+x *.sl
try {
Process pr = Runtime.getRuntime().exec(new String[] { "chmod", "a+x", filePath }); //$NON-NLS-1$ //$NON-NLS-2$
Thread chmodOutput = new StreamConsumer(pr.getInputStream());
chmodOutput.setName("chmod output reader"); //$NON-NLS-1$
chmodOutput.start();
Thread chmodError = new StreamConsumer(pr.getErrorStream());
chmodError.setName("chmod error reader"); //$NON-NLS-1$
chmodError.start();
} catch (IOException ioe) {
}
}
}
/**
* Returns a random file name for the local system
* attempt to conserve the extension if there is a '.' in the path
* and no File.Seperator after the '.'
*
* \a\b\c.txt -> c987659385.txt
* c.txt -> c3854763.txt
* c -> c953867549
*/
public static String getLocalRandomIdentifier(String remotePath, Date date) {
int dotIndex = remotePath.lastIndexOf("."); //$NON-NLS-1$
int fileIndex = remotePath.lastIndexOf(File.separator);
// if there is a separator after the dot
// do not consider it as an extension
String ext = (dotIndex != -1 && fileIndex < dotIndex) ? remotePath.substring(dotIndex) : ""; //$NON-NLS-1$
// the name is the string between the separator and the dot
// if there is no separator, it is the string up to the dot
// if there is no dot, go to the end of the string
if (fileIndex == -1)
fileIndex = 0;
if (dotIndex == -1)
dotIndex = remotePath.length();
// if I have a separator and no dot: /a/b/c -> c
// if my separator is the last /a/b/c/, fileIndex and dotIndex are the same, so it will return the default temp name
String name = (fileIndex < dotIndex) ? remotePath.substring(fileIndex, dotIndex) : "Eclipse_Update_TMP_"; //$NON-NLS-1$
String result = name + date.getTime() + ext;
return result;
}
/**
* remove a file or directory from the file system.
* used to clean up install
*/
public static void removeFromFileSystem(File file) {
if (!file.exists() || !file.canWrite())
return;
if (file.isDirectory()) {
String[] files = file.list();
if (files != null) // be careful since file.list() can return null
for (int i = 0; i < files.length; ++i)
removeFromFileSystem(new File(file, files[i]));
}
if (!file.delete()) {
String msg = NLS.bind(Messages.UpdateManagerUtils_UnableToRemoveFile, (new String[] { file.getAbsolutePath() }));
UpdateCore.log(msg, new Exception());
}
}
/**
* remove all the empty directories recursively
* used to clean up install
*/
public static void removeEmptyDirectoriesFromFileSystem(File file) {
if (!file.isDirectory())
return;
String[] files = file.list();
if (files != null) { // be careful since file.list() can return null
for (int i = 0; i < files.length; ++i) {
removeEmptyDirectoriesFromFileSystem(new File(file, files[i]));
}
}
if (!file.delete()) {
String msg = NLS.bind(Messages.UpdateManagerUtils_UnableToRemoveFile, (new String[] { file.getAbsolutePath() }));
UpdateCore.log(msg, new Exception());
}
}
/**
* Returns the plugin entries that are in source array and
* not in target array
*/
public static IPluginEntry[] diff(IPluginEntry[] sourceArray, IPluginEntry[] targetArray) { // No pluginEntry to Install, return Nothing to instal
if (sourceArray == null || sourceArray.length == 0) {
return new IPluginEntry[0];
} // No pluginEntry installed, Install them all
if (targetArray == null || targetArray.length == 0) {
return sourceArray;
} // if a IPluginEntry from sourceArray is NOT in
// targetArray, add it to the list
List list1 = Arrays.asList(targetArray);
List result = new ArrayList(0);
for (int i = 0; i < sourceArray.length; i++) {
if (!list1.contains(sourceArray[i]))
result.add(sourceArray[i]);
}
IPluginEntry[] resultEntry = new IPluginEntry[result.size()];
if (result.size() > 0)
result.toArray(resultEntry);
return resultEntry;
}
/**
*
*/
public static URL asDirectoryURL(URL url) throws MalformedURLException {
//url = URLEncoder.encode(url);
String path = url.getFile();
if (!path.endsWith("/")) { //$NON-NLS-1$
int index = path.lastIndexOf('/');
if (index != -1)
path = path.substring(0, index + 1);
// ignore any ref in original URL
url = new URL(url.getProtocol(), url.getHost(), url.getPort(), path);
}
return url;
}
/*
* Compares two URL for equality
* Return false if one of them is null
*/
public static boolean sameURL(URL url1, URL url2) {
if (url1 == null || url2 == null)
return false;
if (url1 == url2)
return true;
if (url1.equals(url2))
return true;
// check if URL are file: URL as we may
// have 2 URL pointing to the same featureReference
// but with different representation
// (i.e. file:/C;/ and file:C:/)
if (!"file".equalsIgnoreCase(url1.getProtocol())) //$NON-NLS-1$
return false;
if (!"file".equalsIgnoreCase(url2.getProtocol())) //$NON-NLS-1$
return false;
File file1 = getFileFor(url1);//new File(url1.getFile());
File file2 = getFileFor(url2);
if (file1 == null)
return false;
return (file1.equals(file2));
}
/*
* Method getFileFor.
* @param url1
* @return File
*/
private static File getFileFor(URL url1) {
if (urlFileMap == null) urlFileMap = new HashMap();
if (urlFileMap.get(url1)!=null) return (File)urlFileMap.get(url1);
File newFile = new File(url1.getFile());
urlFileMap.put(url1,newFile);
return newFile;
}
/*
* returns the list of FeatureReference that are parent of
* the Feature or an empty array if no parent found.
* @param onlyOptional if set to <code>true</code> only return parents that consider the feature optional
* @param child
* @param possiblesParent
*/
public static IFeatureReference[] getParentFeatures(IFeature childFeature, IFeatureReference[] possiblesParent, boolean onlyOptional) throws CoreException {
if (childFeature == null)
return new IFeatureReference[0];
List parentList = new ArrayList();
IIncludedFeatureReference[] children = null;
IFeature compareFeature = null;
for (int i = 0; i < possiblesParent.length; i++) {
try {
IFeature possibleParentFeature = possiblesParent[i].getFeature(null);
if (possibleParentFeature != null) {
children = possibleParentFeature.getIncludedFeatureReferences();
for (int j = 0; j < children.length; j++) {
try {
compareFeature = children[j].getFeature(null);
} catch (CoreException e) {
UpdateCore.warn("", e); //$NON-NLS-1$
}
if (childFeature.equals(compareFeature)) {
if (onlyOptional) {
if (UpdateManagerUtils.isOptional(children[j])) {
parentList.add(possiblesParent[i]);
} else {
UpdateCore.warn("Feature :" + children[j] + " not optional. Not included in parents list."); //$NON-NLS-1$ //$NON-NLS-2$
}
} else {
parentList.add(possiblesParent[i]);
}
}
}
}
} catch (CoreException e) {
UpdateCore.warn("", e); //$NON-NLS-1$
}
}
IFeatureReference[] parents = new IFeatureReference[0];
if (parentList.size() > 0) {
parents = new IFeatureReference[parentList.size()];
parentList.toArray(parents);
}
return parents;
}
/*
* If the return code of the HTTP connection is not 200 (OK)
* thow an IO exception
*
*/
public static void checkConnectionResult(IResponse response,URL url) throws IOException {
// did the server return an error code ?
int result = response.getStatusCode();
if (result != UpdateCore.HTTP_OK) {
String serverMsg = response.getStatusMessage();
response.close();
throw new FatalIOException(NLS.bind(Messages.ContentReference_HttpNok, (new Object[] { new Integer(result), serverMsg, url })));
}
}
public static class StreamConsumer extends Thread {
InputStream is;
byte[] buf;
public StreamConsumer(InputStream inputStream) {
super();
this.setDaemon(true);
this.is = inputStream;
buf = new byte[512];
}
public void run() {
try {
int n = 0;
while (n >= 0)
n = is.read(buf);
} catch (IOException ioe) {
}
}
}
/**
* Return the optional children to install
* The optional features to install may not all be direct children
* of the feature.
* Also include non-optional features
*
* @param children all the nested features
* @param optionalfeatures optional features to install
* @return IFeatureReference[]
*/
public static IFeatureReference[] optionalChildrenToInstall(IFeatureReference[] children, IFeatureReference[] optionalfeatures) {
List optionalChildrenToInstall = new ArrayList();
for (int i = 0; i < children.length; i++) {
IFeatureReference optionalFeature = children[i];
if (!UpdateManagerUtils.isOptional(optionalFeature)) {
optionalChildrenToInstall.add(optionalFeature);
} else {
for (int j = 0; j < optionalfeatures.length; j++) {
if (optionalFeature.equals(optionalfeatures[j])) {
optionalChildrenToInstall.add(optionalFeature);
break;
}
}
}
}
IFeatureReference[] result = new IFeatureReference[optionalChildrenToInstall.size()];
if (optionalChildrenToInstall.size() > 0) {
optionalChildrenToInstall.toArray(result);
}
return result;
}
/**
* returns the mapping of matching rules
* the default returns perfect
*
* @since 2.0.2
*/
public static int getMatchingRule(String rule) {
if (rule == null)
return IUpdateConstants.RULE_COMPATIBLE;
final Integer integer = (Integer) table.get(rule);
if (integer == null)
return IUpdateConstants.RULE_PERFECT;
int ruleInt = integer.intValue();
if (ruleInt == IUpdateConstants.RULE_NONE)
return IUpdateConstants.RULE_PERFECT;
return ruleInt;
}
/**
* returns the mapping of matching id rules
* the default returns perfect
*
* @since 2.0.2
*/
public static int getMatchingIdRule(String rule) {
if (rule == null)
return IUpdateConstants.RULE_COMPATIBLE;
if (rule!=null && rule.equalsIgnoreCase("prefix")) //$NON-NLS-1$
return IUpdateConstants.RULE_PREFIX;
return IUpdateConstants.RULE_PERFECT;
}
/**
* Method isOptional.
* @param featureReference
* @return boolean
*/
public static boolean isOptional(IFeatureReference featureReference) {
if (featureReference==null) return false;
if (featureReference instanceof IIncludedFeatureReference){
return ((IIncludedFeatureReference)featureReference).isOptional();
}
return false;
}
/**
*
*/
public static boolean isValidEnvironment(IPlatformEnvironment candidate) {
if (candidate==null) return false;
String os = candidate.getOS();
String ws = candidate.getWS();
String arch = candidate.getOSArch();
String nl = candidate.getNL();
if (os!=null && !isMatching(os, SiteManager.getOS())) return false;
if (ws!=null && !isMatching(ws, SiteManager.getWS())) return false;
if (arch!=null && !isMatching(arch, SiteManager.getOSArch())) return false;
if (nl!=null && !isMatchingLocale(nl, SiteManager.getNL())) return false;
return true;
}
/* Original code - commented out to provide a replacement as per bug 98387
private static boolean isMatching(String candidateValues, String siteValues) {
if (siteValues==null) return false;
if ("*".equals(candidateValues)) return true; //$NON-NLS-1$
if ("".equals(candidateValues)) return true; //$NON-NLS-1$
siteValues = siteValues.toUpperCase();
StringTokenizer stok = new StringTokenizer(candidateValues, ","); //$NON-NLS-1$
while (stok.hasMoreTokens()) {
String token = stok.nextToken().toUpperCase();
if (siteValues.indexOf(token)!=-1) return true;
}
return false;
}
*/
/*
* Fixed bug 98387
*/
private static boolean isMatching(String candidateValues, String siteValues) {
if (siteValues==null) return false;
if ("*".equals(candidateValues)) return true; //$NON-NLS-1$
if ("".equals(candidateValues)) return true; //$NON-NLS-1$
StringTokenizer siteTokens = new StringTokenizer(siteValues, ","); //$NON-NLS-1$
//$NON-NLS-1$
while(siteTokens.hasMoreTokens()) {
StringTokenizer candidateTokens = new StringTokenizer
(candidateValues, ","); //$NON-NLS-1$
String siteValue = siteTokens.nextToken();
while (candidateTokens.hasMoreTokens()) {
if (siteValue.equalsIgnoreCase
(candidateTokens.nextToken())) return true;
}
}
return false;
}
/**
*
*/
private static boolean isMatchingLocale(String candidateValues, String locale) {
if (locale==null) return false;
if ("*".equals(candidateValues)) return true; //$NON-NLS-1$
if ("".equals(candidateValues)) return true; //$NON-NLS-1$
locale = locale.toUpperCase();
candidateValues = candidateValues.toUpperCase();
StringTokenizer stok = new StringTokenizer(candidateValues, ","); //$NON-NLS-1$
while (stok.hasMoreTokens()) {
String candidate = stok.nextToken();
if (locale.indexOf(candidate) == 0)
return true;
if (candidate.indexOf(locale) == 0)
return true;
}
return false;
}
/*
*
*/
private static void appendEscapedChar(StringBuffer buffer, char c) {
String replacement = getReplacement(c);
if (replacement != null) {
buffer.append('&');
buffer.append(replacement);
buffer.append(';');
} else {
if ((c >= ' ' && c <= 0x7E) || c == '\n' || c == '\r' || c == '\t') {
buffer.append(c);
} else {
buffer.append("&#"); //$NON-NLS-1$
buffer.append(Integer.toString(c));
buffer.append(';');
}
}
}
/*
*
*/
public static String xmlSafe(String s) {
StringBuffer result = new StringBuffer(s.length() + 10);
for (int i = 0; i < s.length(); ++i)
appendEscapedChar(result, s.charAt(i));
return result.toString();
}
/*
*
*/
private static String getReplacement(char c) {
// Encode special XML characters into the equivalent character references.
// These five are defined by default for all XML documents.
switch (c) {
case '<' :
return "lt"; //$NON-NLS-1$
case '>' :
return "gt"; //$NON-NLS-1$
case '"' :
return "quot"; //$NON-NLS-1$
case '\'' :
return "apos"; //$NON-NLS-1$
case '&' :
return "amp"; //$NON-NLS-1$
}
return null;
}
public static boolean isSameTimestamp(URL url, long timestamp) {
try {
if (UpdateCore.getPlugin().getUpdateSession().isVisited(url)) {
return true;
}
URL resolvedURL = URLEncoder.encode(url);
IResponse response = ConnectionFactory.get(resolvedURL);
long remoteLastModified = response.getLastModified();
// 2 seconds tolerance, as some OS's may round up the time stamp
// to the closest second. For safety, we make it 2 seconds.
return Math.abs(remoteLastModified - timestamp)/1000 <= 2;
} catch (MalformedURLException e) {
return false;
} catch (IOException e) {
return false;
}
}
/**
* The file is associated with a lookup key.
* @param key optional lookup key, or <code>null</code>.
* @param temp the local working file
*/
public synchronized static void mapLocalFileFragment(String key, FileFragment temp) {
// create file association
if (key != null) {
if (localFileFragmentMap == null)
localFileFragmentMap = new HashMap();
localFileFragmentMap.put(key, temp);
}
}
/**
* The file is associated with a lookup key.
* @param key optional lookup key, or <code>null</code>.
*/
public synchronized static void unMapLocalFileFragment(String key) {
// remove file association
if (key != null && localFileFragmentMap !=null) {
localFileFragmentMap.remove(key);
}
}
/**
* Returns a previously cached local file (in temporary area) matching the
* specified key.
*
* @param key lookup key
* @return cached file, or <code>null</code>.
*/
public static synchronized FileFragment lookupLocalFileFragment(String key) {
if (localFileFragmentMap == null)
return null;
return (FileFragment) localFileFragmentMap.get(key);
}
/**
* Copies specified input stream to the output stream. Neither stream
* is closed as part of this operation.
*
* @param is input stream
* @param os output stream
* @param monitor progress monitor
* @param expectedLength - if > 0, the number of bytes from InputStream will be verified
* @@return the offset in the input stream where copying stopped. Returns -1 if end of input stream is reached.
* @since 2.0
*/
public static long copy(InputStream is, OutputStream os, InstallMonitor monitor, long expectedLength) {
byte[] buf = getBuffer();
long offset=0;
try {
int len = is.read(buf);
int nextIncrement = 0;
while (len != -1) {
os.write(buf, 0, len);
offset += len;
if (monitor != null) {
nextIncrement += len;
// update monitor periodically
if (nextIncrement >= INCREMENT_SIZE){
monitor.incrementCount(nextIncrement);
nextIncrement = 0;
}
if (monitor.isCanceled()) {
return offset;
}
}
if (expectedLength > 0 && offset == expectedLength) {
// everything read do not return offset, otherwise trying
// to read again from this offset will result in HTTP 416
break;
}
len = is.read(buf);
}
if (nextIncrement > 0 && monitor != null)
monitor.incrementCount(nextIncrement);
if(expectedLength>0 && offset!=expectedLength)
throw new IOException(NLS.bind(Messages.UpdateManagerUtils_inputStreamEnded, (new String[] { String.valueOf(offset), String.valueOf(expectedLength) })));
return -1;
} catch(IOException e){
// Log the actual error, as this is no longer
// passed up the calling stack
UpdateCore.log(Messages.UpdateManagerUtils_copy + offset, e);
return offset;
} finally {
freeBuffer(buf);
}
}
private static synchronized byte[] getBuffer() {
if (bufferPool == null) {
return new byte[BUFFER_SIZE];
}
try {
return (byte[]) bufferPool.pop();
} catch (EmptyStackException e) {
return new byte[BUFFER_SIZE];
}
}
private static synchronized void freeBuffer(byte[] buf) {
if (bufferPool == null)
bufferPool = new Stack();
bufferPool.push(buf);
}
/**
* Returns a list of fragments. Zero length if no fragments.
* @param bundle the bundle to get fragments for
*/
public static FragmentEntry[] getFragments(Bundle bundle) {
PackageAdmin pkgAdmin = UpdateCore.getPlugin().getPackageAdmin();
Bundle[] fragmentBundles = pkgAdmin.getFragments(bundle);
if (fragmentBundles == null)
return noFragments;
FragmentEntry[] fragments = new FragmentEntry[fragmentBundles.length];
for (int i = 0; i < fragments.length; i++) {
fragments[i] = new FragmentEntry((String) fragmentBundles[i]
.getHeaders().get(Constants.BUNDLE_SYMBOLICNAME),
(String) fragmentBundles[i].getHeaders().get(
Constants.BUNDLE_VERSION), Platform
.getResourceString(fragmentBundles[i],
(String) fragmentBundles[i].getHeaders()
.get(Constants.BUNDLE_VERSION)),
fragmentBundles[i].getLocation());
}
return fragments;
}
public static String getWritableXMLString(String value) {
StringBuffer buf = new StringBuffer();
if(value == null)
return buf.toString();
for (int i = 0; i < value.length(); i++) {
char c = value.charAt(i);
switch (c) {
case '&' :
buf.append("&"); //$NON-NLS-1$
break;
case '<' :
buf.append("<"); //$NON-NLS-1$
break;
case '>' :
buf.append(">"); //$NON-NLS-1$
break;
case '\'' :
buf.append("'"); //$NON-NLS-1$
break;
case '\"' :
buf.append("""); //$NON-NLS-1$
break;
case 0x00 :
buf.append(" "); //$NON-NLS-1$
break;
default :
buf.append(c);
break;
}
}
return buf.toString();
}
public static LiteFeature[] getLightFeatures(ExtendedSite site) {
URL fullDigestURL;
try {
fullDigestURL = getFullDigestURL( site, Locale.getDefault().getCountry(), Locale.getDefault().getLanguage());
} catch (MalformedURLException e) {
UpdateCore.log("Could not access digest on the site: " + e.getMessage(), null); //$NON-NLS-1$
return null;
}
Digest digest = new Digest( fullDigestURL);
try {
LiteFeature[] features = (LiteFeature[])digest.parseDigest();
for(int i = 0; i < features.length; i++) {
features[i].setSite(site);
}
return features;
} catch(Exception e){
UpdateCore.log("Digest could not be parsed:" + e.getMessage(), null); //$NON-NLS-1$
return null;
}
}
private static URL getFullDigestURL(ExtendedSite site, String country, String language) throws MalformedURLException {
String digestURL = (site.getDigestURL().endsWith("/")? site.getDigestURL(): site.getDigestURL() + "/"); //$NON-NLS-1$ //$NON-NLS-2$
if (digestURL.indexOf("://") == -1) { //$NON-NLS-1$
String siteURL = site.getLocationURL().toExternalForm();
if (siteURL.endsWith(Site.SITE_XML)) {
siteURL = siteURL.substring(0, siteURL.length() - Site.SITE_XML.length());
}
if (digestURL.equals("/")) { //$NON-NLS-1$
digestURL = siteURL;
} else {
if (digestURL.startsWith("/")) { //$NON-NLS-1$
digestURL = digestURL.substring(1, digestURL.length());
}
digestURL = siteURL + digestURL;
}
}
digestURL += "digest"; //$NON-NLS-1$
if ( isLocalSupported(site, country, language)) {
return new URL(digestURL + "_" + language + "_" + country + ".zip"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
if ( isLangaugeSupported(site, language)) {
return new URL(digestURL + "_" + language + ".zip"); //$NON-NLS-1$ //$NON-NLS-2$
}
return new URL(digestURL + ".zip"); //$NON-NLS-1$
}
private static boolean isLangaugeSupported(ExtendedSite site, String language) {
String[] availableLanguages = site.getAvailableLocals();
if ((availableLanguages == null) || (availableLanguages.length == 0)) {
return false;
}
for(int i = 0; i < availableLanguages.length; i++) {
if (availableLanguages[i].equals(language)) {
return true;
}
}
return false;
}
private static boolean isLocalSupported(ExtendedSite site, String country, String language) {
String localeCode = language + "_" + country; //$NON-NLS-1$
String[] availableLocals = site.getAvailableLocals();
if ((availableLocals == null) || (availableLocals.length == 0)) {
return false;
}
for(int i = 0; i < availableLocals.length; i++) {
if (availableLocals[i].equals(localeCode)) {
return true;
}
}
return false;
}
}