[SM-4760] Add activation-api 2.0.1 bundle
diff --git a/activation-api-2.0.1/pom.xml b/activation-api-2.0.1/pom.xml
new file mode 100644
index 0000000..0094028
--- /dev/null
+++ b/activation-api-2.0.1/pom.xml
@@ -0,0 +1,207 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <!--
+
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.servicemix.specs</groupId>
+ <artifactId>specs-pom</artifactId>
+ <version>2</version>
+ <relativePath>../specs-pom/pom.xml</relativePath>
+ </parent>
+
+ <groupId>org.apache.servicemix.specs</groupId>
+ <artifactId>org.apache.servicemix.specs.activation-api-2.0.1</artifactId>
+ <packaging>bundle</packaging>
+ <version>2.0.1_1-SNAPSHOT</version>
+ <name>Apache ServiceMix :: Specs :: Activation API 2.0.1</name>
+
+ <scm>
+ <connection>scm:git:https://gitbox.apache.org/repos/asf/servicemix-specs.git</connection>
+ <developerConnection>scm:git:https://gitbox.apache.org/repos/asf/servicemix-specs.git</developerConnection>
+ <url>https://gitbox.apache.org/repos/asf?p=servicemix-specs.git</url>
+ </scm>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.servicemix.specs</groupId>
+ <artifactId>org.apache.servicemix.specs.locator</artifactId>
+ <version>2.10</version>
+ </dependency>
+ <dependency>
+ <groupId>jakarta.activation</groupId>
+ <artifactId>jakarta.activation-api</artifactId>
+ <version>2.0.1</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>org.osgi.core</artifactId>
+ <version>1.4.0</version>
+ <scope>provided</scope>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <inherited>true</inherited>
+ <configuration>
+ <compilerArgument>-Xbootclasspath/p:${settings.localRepository}/org/apache/geronimo/specs/geronimo-activation_1.1_spec/1.1/geronimo-activation_1.1_spec-1.1.jar</compilerArgument>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <configuration>
+ <instructions>
+ <Bundle-SymbolicName>${project.artifactId}</Bundle-SymbolicName>
+ <Bundle-Description>${project.description}</Bundle-Description>
+ <Export-Package>
+ javax.activation*;version=2.0.1;-split-package:=merge-first;-noimport:=true,
+ jakarta.activation*;version=2.0.1;-split-package:=merge-first;-noimport:=true
+ </Export-Package>
+ <Import-Package>
+ *,
+ !org.apache.servicemix.specs.activation
+ </Import-Package>
+ <Private-Package>
+ org.apache.servicemix.specs.locator;-split-package:=merge-first,
+ org.apache.servicemix.specs.activation;-split-package:=merge-first
+ </Private-Package>
+ <Bundle-Activator>org.apache.servicemix.specs.activation.Activator</Bundle-Activator>
+ <Implementation-Title>Apache ServiceMix</Implementation-Title>
+ <Implementation-Version>${project.version}</Implementation-Version>
+ </instructions>
+ <unpackBundle>true</unpackBundle>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-shade-plugin</artifactId>
+ <executions>
+ <execution>
+ <phase>package</phase>
+ <goals>
+ <goal>shade</goal>
+ </goals>
+ <configuration>
+ <artifactSet>
+ <includes>
+ <include>jakarta.activation:jakarta.activation-api</include>
+ <include>org.apache.servicemix.specs:org.apache.servicemix.specs.locator</include>
+ <include>${project.groupId}:${project.artifactId}</include>
+ </includes>
+ </artifactSet>
+ <filters>
+ <filter>
+ <artifact>jakarta.activation:jakarta.activation-api</artifact>
+ <excludes>
+ <exclude>javax/**</exclude>
+ </excludes>
+ </filter>
+ <filter>
+ <artifact>org.apache.servicemix.specs:org.apache.servicemix.specs.locator</artifact>
+ <excludes>
+ <exclude>org/**</exclude>
+ </excludes>
+ </filter>
+ </filters>
+ <createSourcesJar>${createSourcesJar}</createSourcesJar>
+ <promoteTransitiveDependencies>true</promoteTransitiveDependencies>
+ <createDependencyReducedPom>true</createDependencyReducedPom>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+
+ <profiles>
+ <profile>
+ <id>deploy</id>
+ <properties>
+ <createSourcesJar>true</createSourcesJar>
+ </properties>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-source-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>attach-sources</id>
+ <phase>process-classes</phase>
+ <goals>
+ <goal>jar</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>unpack-sources</id>
+ <phase>generate-sources</phase>
+ <goals>
+ <goal>unpack</goal>
+ </goals>
+ <configuration>
+ <artifactItems>
+ <artifactItem>
+ <groupId>org.apache.servicemix.specs</groupId>
+ <artifactId>org.apache.servicemix.specs.locator</artifactId>
+ <classifier>sources</classifier>
+ </artifactItem>
+ </artifactItems>
+ <outputDirectory>${project.build.directory}/sources</outputDirectory>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>package</id>
+ <phase>package</phase>
+ <goals>
+ <goal>jar</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <minmemory>128m</minmemory>
+ <maxmemory>512m</maxmemory>
+ <sourcepath>${project.build.directory}/sources</sourcepath>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ </profiles>
+
+</project>
diff --git a/activation-api-2.0.1/src/main/java/javax/activation/DataHandler.java b/activation-api-2.0.1/src/main/java/javax/activation/DataHandler.java
new file mode 100644
index 0000000..b4b4bcf
--- /dev/null
+++ b/activation-api-2.0.1/src/main/java/javax/activation/DataHandler.java
@@ -0,0 +1,305 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package javax.activation;
+
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PipedInputStream;
+import java.io.PipedOutputStream;
+import java.net.URL;
+
+public class DataHandler implements Transferable {
+ private final DataSource ds;
+ private final DataFlavor flavor;
+
+ private CommandMap commandMap;
+ private DataContentHandler dch;
+
+ public DataHandler(DataSource ds) {
+ this.ds = ds;
+ this.flavor = new ActivationDataFlavor(ds.getContentType(), null);
+ }
+
+ public DataHandler(Object data, String type) {
+ this.ds = new ObjectDataSource(data, type);
+ this.flavor = new ActivationDataFlavor(data.getClass(), null);
+ }
+
+ public DataHandler(URL url) {
+ this.ds = new URLDataSource(url);
+ this.flavor = new ActivationDataFlavor(ds.getContentType(), null);
+ }
+
+ public DataSource getDataSource() {
+ return ds;
+ }
+
+ public String getName() {
+ return ds.getName();
+ }
+
+ public String getContentType() {
+ return ds.getContentType();
+ }
+
+ public InputStream getInputStream() throws IOException {
+ return ds.getInputStream();
+ }
+
+ public void writeTo(OutputStream os) throws IOException {
+ if (ds instanceof ObjectDataSource) {
+ ObjectDataSource ods = (ObjectDataSource) ds;
+ DataContentHandler dch = getDataContentHandler();
+ if (dch == null) {
+ throw new UnsupportedDataTypeException(ods.mimeType);
+ }
+ dch.writeTo(ods.data, ods.mimeType, os);
+ } else {
+ byte[] buffer = new byte[1024];
+ InputStream is = getInputStream();
+ try {
+ int count;
+ while ((count = is.read(buffer)) != -1) {
+ os.write(buffer, 0, count);
+ }
+ } finally {
+ is.close();
+ }
+ }
+ }
+
+ public OutputStream getOutputStream() throws IOException {
+ return ds.getOutputStream();
+ }
+
+ public synchronized DataFlavor[] getTransferDataFlavors() {
+ return getDataContentHandler().getTransferDataFlavors();
+ }
+
+ public boolean isDataFlavorSupported(DataFlavor flavor) {
+ DataFlavor[] flavors = getTransferDataFlavors();
+ for (int i = 0; i < flavors.length; i++) {
+ DataFlavor dataFlavor = flavors[i];
+ if (dataFlavor.equals(flavor)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+ DataContentHandler dch = getDataContentHandler();
+ if (dch != null) {
+ return dch.getTransferData(flavor, ds);
+ } else if (this.flavor.match(flavor)) {
+ if (ds instanceof ObjectDataSource) {
+ return ((ObjectDataSource) ds).data;
+ } else {
+ return ds.getInputStream();
+ }
+ } else {
+ throw new UnsupportedFlavorException(flavor);
+ }
+ }
+
+ public CommandInfo[] getPreferredCommands() {
+ return getCommandMap().getPreferredCommands(ds.getContentType());
+ }
+
+ public CommandInfo[] getAllCommands() {
+ return getCommandMap().getAllCommands(ds.getContentType());
+ }
+
+ public CommandInfo getCommand(String cmdName) {
+ return getCommandMap().getCommand(ds.getContentType(), cmdName);
+ }
+
+ public Object getContent() throws IOException {
+ if (ds instanceof ObjectDataSource) {
+ return ((ObjectDataSource) ds).data;
+ } else {
+ DataContentHandler dch = getDataContentHandler();
+ if (dch != null) {
+ return dch.getContent(ds);
+ } else {
+ return ds.getInputStream();
+ }
+ }
+ }
+
+ public Object getBean(CommandInfo cmdinfo) {
+ try {
+ return cmdinfo.getCommandObject(this, this.getClass().getClassLoader());
+ } catch (IOException e) {
+ return null;
+ } catch (ClassNotFoundException e) {
+ return null;
+ }
+ }
+
+ /**
+ * A local implementation of DataSouce used to wrap an Object and mime-type.
+ */
+ private class ObjectDataSource implements DataSource {
+ private final Object data;
+ private final String mimeType;
+
+ public ObjectDataSource(Object data, String mimeType) {
+ this.data = data;
+ this.mimeType = mimeType;
+ }
+
+ public String getName() {
+ return null;
+ }
+
+ public String getContentType() {
+ return mimeType;
+ }
+
+ public InputStream getInputStream() throws IOException {
+ final DataContentHandler dch = getDataContentHandler();
+ if (dch == null) {
+ throw new UnsupportedDataTypeException(mimeType);
+ }
+ final PipedInputStream is = new PipedInputStream();
+ final PipedOutputStream os = new PipedOutputStream(is);
+ Thread thread = new Thread("DataHandler Pipe Pump") {
+ public void run() {
+ try {
+ try {
+ dch.writeTo(data, mimeType, os);
+ } finally {
+ os.close();
+ }
+ } catch (IOException e) {
+ // ignore, per spec - doh!
+ }
+ }
+ };
+ thread.start();
+ return is;
+ }
+
+ public OutputStream getOutputStream() throws IOException {
+ return null;
+ }
+ }
+
+ public synchronized void setCommandMap(CommandMap commandMap) {
+ this.commandMap = commandMap;
+ this.dch = null;
+ }
+
+ private synchronized CommandMap getCommandMap() {
+ return commandMap != null ? commandMap : CommandMap.getDefaultCommandMap();
+ }
+
+ /**
+ * Search for a DataContentHandler for our mime type.
+ * The search is performed by first checking if a global factory has been set using
+ * {@link #setDataContentHandlerFactory(DataContentHandlerFactory)};
+ * if found then it is called to attempt to create a handler.
+ * If this attempt fails, we then call the command map set using {@link #setCommandMap(CommandMap)}
+ * (or if that has not been set, the default map returned by {@link CommandMap#getDefaultCommandMap()})
+ * to create the handler.
+ *
+ * The resulting handler is cached until the global factory is changed.
+ *
+ * @return
+ */
+ private synchronized DataContentHandler getDataContentHandler() {
+ DataContentHandlerFactory localFactory;
+ synchronized (DataHandler.class) {
+ if (factory != originalFactory) {
+ // setDCHF was called - clear our cached copy of the DCH and DCHF
+ dch = null;
+ originalFactory = factory;
+ }
+ localFactory = originalFactory;
+ }
+ if (dch == null) {
+ // get the main mime-type portion of the content.
+ String mimeType = getMimeType(ds.getContentType());
+ if (localFactory != null) {
+ dch = localFactory.createDataContentHandler(mimeType);
+ }
+ if (dch == null) {
+ dch = getCommandMap().createDataContentHandler(mimeType);
+ }
+ }
+ return dch;
+ }
+
+ /**
+ * Retrieve the base MIME type from a content type. This parses
+ * the type into its base components, stripping off any parameter
+ * information.
+ *
+ * @param contentType
+ * The content type string.
+ *
+ * @return The MIME type identifier portion of the content type.
+ */
+ private String getMimeType(String contentType) {
+ try {
+ MimeType mimeType = new MimeType(contentType);
+ return mimeType.getBaseType();
+ } catch (MimeTypeParseException e) {
+ }
+ return contentType;
+ }
+
+ /**
+ * This is used to check if the DataContentHandlerFactory has been changed.
+ * This is not specified behaviour but this check is required to make this work like the RI.
+ */
+ private DataContentHandlerFactory originalFactory;
+
+ {
+ synchronized (DataHandler.class) {
+ originalFactory = factory;
+ }
+ }
+
+ private static DataContentHandlerFactory factory;
+
+ /**
+ * Set the DataContentHandlerFactory to use.
+ * If this method has already been called then an Error is raised.
+ *
+ * @param newFactory the new factory
+ * @throws SecurityException if the caller does not have "SetFactory" RuntimePermission
+ */
+ public static synchronized void setDataContentHandlerFactory(DataContentHandlerFactory newFactory) {
+ if (factory != null) {
+ throw new Error("javax.activation.DataHandler.setDataContentHandlerFactory has already been defined");
+ }
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkSetFactory();
+ }
+ factory = newFactory;
+ }
+}
diff --git a/activation-api-2.0.1/src/main/java/javax/activation/MailcapCommandMap.java b/activation-api-2.0.1/src/main/java/javax/activation/MailcapCommandMap.java
new file mode 100644
index 0000000..536083f
--- /dev/null
+++ b/activation-api-2.0.1/src/main/java/javax/activation/MailcapCommandMap.java
@@ -0,0 +1,515 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package javax.activation;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.net.URL;
+import java.security.Security;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class MailcapCommandMap extends CommandMap {
+ /**
+ * A string that holds all the special chars.
+ */
+ private static final String TSPECIALS = "()<>@,;:/[]?=\\\"";
+ private final Map mimeTypes = new HashMap();
+ private final Map preferredCommands = new HashMap();
+ private final Map allCommands = new HashMap();
+ // the unparsed commands from the mailcap file.
+ private final Map nativeCommands = new HashMap();
+ // commands identified as fallbacks...these are used last, and also used as wildcards.
+ private final Map fallbackCommands = new HashMap();
+ private URL url;
+
+ public MailcapCommandMap() {
+ ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
+ // process /META-INF/mailcap.default
+ try {
+ InputStream is = MailcapCommandMap.class.getResourceAsStream("/META-INF/mailcap.default");
+ if (is != null) {
+ try {
+ parseMailcap(is);
+ } finally {
+ is.close();
+ }
+ }
+ } catch (IOException e) {
+ // ignore
+ }
+
+ // process /META-INF/mailcap resources
+ try {
+ Enumeration e = contextLoader.getResources("META-INF/mailcap");
+ while (e.hasMoreElements()) {
+ url = ((URL) e.nextElement());
+ try {
+ InputStream is = url.openStream();
+ try {
+ parseMailcap(is);
+ } finally {
+ is.close();
+ }
+ } catch (IOException e1) {
+ continue;
+ }
+ }
+ } catch (SecurityException e) {
+ // ignore
+ } catch (IOException e) {
+ // ignore
+ }
+
+ // process ${java.home}/lib/mailcap
+ try {
+ File file = new File(System.getProperty("java.home"), "lib/mailcap");
+ InputStream is = new FileInputStream(file);
+ try {
+ parseMailcap(is);
+ } finally {
+ is.close();
+ }
+ } catch (SecurityException e) {
+ // ignore
+ } catch (IOException e) {
+ // ignore
+ }
+
+ // process ${user.home}/lib/mailcap
+ try {
+ File file = new File(System.getProperty("user.home"), ".mailcap");
+ InputStream is = new FileInputStream(file);
+ try {
+ parseMailcap(is);
+ } finally {
+ is.close();
+ }
+ } catch (SecurityException e) {
+ // ignore
+ } catch (IOException e) {
+ // ignore
+ }
+ }
+
+ public MailcapCommandMap(String fileName) throws IOException {
+ this();
+ FileReader reader = new FileReader(fileName);
+ try {
+ parseMailcap(reader);
+ } finally {
+ reader.close();
+ }
+ }
+
+ public MailcapCommandMap(InputStream is) {
+ this();
+ parseMailcap(is);
+ }
+
+ private void parseMailcap(InputStream is) {
+ try {
+ parseMailcap(new InputStreamReader(is));
+ } catch (IOException e) {
+ // spec API means all we can do is swallow this
+ }
+ }
+
+ void parseMailcap(Reader reader) throws IOException {
+ BufferedReader br = new BufferedReader(reader);
+ String line;
+ while ((line = br.readLine()) != null) {
+ addMailcap(line);
+ }
+ }
+
+ public synchronized void addMailcap(String mail_cap) {
+ int index = 0;
+ // skip leading whitespace
+ index = skipSpace(mail_cap, index);
+ if (index == mail_cap.length() || mail_cap.charAt(index) == '#') {
+ return;
+ }
+
+ // get primary type
+ int start = index;
+ index = getToken(mail_cap, index);
+ if (start == index) {
+ return;
+ }
+ String mimeType = mail_cap.substring(start, index);
+
+ // skip any spaces after the primary type
+ index = skipSpace(mail_cap, index);
+ if (index == mail_cap.length() || mail_cap.charAt(index) == '#') {
+ return;
+ }
+
+ // get sub-type
+ if (mail_cap.charAt(index) == '/') {
+ index = skipSpace(mail_cap, ++index);
+ start = index;
+ index = getToken(mail_cap, index);
+ mimeType = mimeType + '/' + mail_cap.substring(start, index);
+ } else {
+
+ mimeType = mimeType + "/*";
+ }
+
+ // we record all mappings using the lowercase version.
+ mimeType = mimeType.toLowerCase();
+
+ // skip spaces after mime type
+ index = skipSpace(mail_cap, index);
+
+ // expect a ';' to terminate field 1
+ if (index == mail_cap.length() || mail_cap.charAt(index) != ';') {
+ return;
+ }
+ // ok, we've parsed the mime text field, now parse the view field. If there's something
+ // there, then we add this to the native text.
+ index = skipSpace(mail_cap, index + 1);
+ // if the next encountered text is not a ";", then we have a view. This gets added to the
+ // native list.
+ if (index == mail_cap.length() || mail_cap.charAt(index) != ';') {
+ ArrayList nativeCommandList = (ArrayList)nativeCommands.get(mimeType);
+
+ // if this is the first for this mimetype, create a holder
+ if (nativeCommandList == null) {
+ nativeCommandList = new ArrayList();
+ nativeCommands.put(mimeType, nativeCommandList);
+ }
+
+ // now add this as an entry in the list.
+ nativeCommandList.add(mail_cap);
+ // now skip forward to the next field marker, if any
+ index = getMText(mail_cap, index);
+ }
+
+ // we don't know which list this will be added to until we finish parsing, as there
+ // can be an x-java-fallback-entry parameter that moves this to the fallback list.
+ List commandList = new ArrayList();
+ // but by default, this is not a fallback.
+ boolean fallback = false;
+
+ int fieldNumber = 0;
+
+ // parse fields
+ while (index < mail_cap.length() && mail_cap.charAt(index) == ';') {
+ index = skipSpace(mail_cap, index + 1);
+ start = index;
+ index = getToken(mail_cap, index);
+ String fieldName = mail_cap.substring(start, index).toLowerCase();
+ index = skipSpace(mail_cap, index);
+ if (index < mail_cap.length() && mail_cap.charAt(index) == '=') {
+ index = skipSpace(mail_cap, index + 1);
+ start = index;
+ index = getMText(mail_cap, index);
+ String value = mail_cap.substring(start, index);
+ index = skipSpace(mail_cap, index);
+ if (fieldName.startsWith("x-java-") && fieldName.length() > 7) {
+ String command = fieldName.substring(7);
+ value = value.trim();
+ if (command.equals("fallback-entry")) {
+ if (value.equals("true")) {
+ fallback = true;
+ }
+ }
+ else {
+ // create a CommandInfo item and add it the accumulator
+ CommandInfo info = new CommandInfo(command, value);
+ commandList.add(info);
+ }
+ }
+ }
+ }
+ addCommands(mimeType, commandList, fallback);
+ }
+
+ /**
+ * Add a parsed list of commands to the appropriate command list.
+ *
+ * @param mimeType The mimeType name this is added under.
+ * @param commands A List containing the command information.
+ * @param fallback The target list identifier.
+ */
+ protected void addCommands(String mimeType, List commands, boolean fallback) {
+ // add this to the mimeType set
+ mimeTypes.put(mimeType, mimeType);
+ // the target list changes based on the type of entry.
+ Map target = fallback ? fallbackCommands : preferredCommands;
+
+ // now process
+ for (Iterator i = commands.iterator(); i.hasNext();) {
+ CommandInfo info = (CommandInfo)i.next();
+ addCommand(target, mimeType, info);
+ // if this is not a fallback position, then this to the allcommands list.
+ if (!fallback) {
+ List cmdList = (List) allCommands.get(mimeType);
+ if (cmdList == null) {
+ cmdList = new ArrayList();
+ allCommands.put(mimeType, cmdList);
+ }
+ cmdList.add(info);
+ }
+ }
+ }
+
+
+ /**
+ * Add a command to a target command list (preferred or fallback).
+ *
+ * @param commandList
+ * The target command list.
+ * @param mimeType The MIME type the command is associated with.
+ * @param command The command information.
+ */
+ protected void addCommand(Map commandList, String mimeType, CommandInfo command) {
+
+ Map commands = (Map) commandList.get(mimeType);
+ if (commands == null) {
+ commands = new HashMap();
+ commandList.put(mimeType, commands);
+ }
+ commands.put(command.getCommandName(), command);
+ }
+
+
+ private int skipSpace(String s, int index) {
+ while (index < s.length() && Character.isWhitespace(s.charAt(index))) {
+ index++;
+ }
+ return index;
+ }
+
+ private int getToken(String s, int index) {
+ while (index < s.length() && s.charAt(index) != '#' && !isSpecialCharacter(s.charAt(index))) {
+ index++;
+ }
+ return index;
+ }
+
+ private int getMText(String s, int index) {
+ while (index < s.length()) {
+ char c = s.charAt(index);
+ if (c == '#' || c == ';' || Character.isISOControl(c)) {
+ return index;
+ }
+ if (c == '\\') {
+ index++;
+ if (index == s.length()) {
+ return index;
+ }
+ }
+ index++;
+ }
+ return index;
+ }
+
+ public synchronized CommandInfo[] getPreferredCommands(String mimeType) {
+ // get the mimetype as a lowercase version.
+ mimeType = mimeType.toLowerCase();
+
+ Map commands = (Map) preferredCommands.get(mimeType);
+ if (commands == null) {
+ commands = (Map) preferredCommands.get(getWildcardMimeType(mimeType));
+ }
+
+ Map fallbackCommands = getFallbackCommands(mimeType);
+
+ // if we have fall backs, then we need to merge this stuff.
+ if (fallbackCommands != null) {
+ // if there's no command list, we can just use this as the master list.
+ if (commands == null) {
+ commands = fallbackCommands;
+ }
+ else {
+ // merge the two lists. The ones in the commands list will take precedence.
+ commands = mergeCommandMaps(commands, fallbackCommands);
+ }
+ }
+
+ // now convert this into an array result.
+ if (commands == null) {
+ return new CommandInfo[0];
+ }
+ return (CommandInfo[]) commands.values().toArray(new CommandInfo[commands.size()]);
+ }
+
+ private Map getFallbackCommands(String mimeType) {
+ Map commands = (Map) fallbackCommands.get(mimeType);
+
+ // now we also need to search this as if it was a wildcard. If we get a wildcard hit,
+ // we have to merge the two lists.
+ Map wildcardCommands = (Map)fallbackCommands.get(getWildcardMimeType(mimeType));
+ // no wildcard version
+ if (wildcardCommands == null) {
+ return commands;
+ }
+ // we need to merge these.
+ return mergeCommandMaps(commands, wildcardCommands);
+ }
+
+
+ private Map mergeCommandMaps(Map main, Map fallback) {
+ // create a cloned copy of the second map. We're going to use a PutAll operation to
+ // overwrite any duplicates.
+ Map result = new HashMap(fallback);
+ result.putAll(main);
+
+ return result;
+ }
+
+ public synchronized CommandInfo[] getAllCommands(String mimeType) {
+ mimeType = mimeType.toLowerCase();
+ List exactCommands = (List) allCommands.get(mimeType);
+ if (exactCommands == null) {
+ exactCommands = Collections.EMPTY_LIST;
+ }
+ List wildCommands = (List) allCommands.get(getWildcardMimeType(mimeType));
+ if (wildCommands == null) {
+ wildCommands = Collections.EMPTY_LIST;
+ }
+
+ Map fallbackCommands = getFallbackCommands(mimeType);
+ if (fallbackCommands == null) {
+ fallbackCommands = Collections.EMPTY_MAP;
+ }
+
+
+ CommandInfo[] result = new CommandInfo[exactCommands.size() + wildCommands.size() + fallbackCommands.size()];
+ int j = 0;
+ for (int i = 0; i < exactCommands.size(); i++) {
+ result[j++] = (CommandInfo) exactCommands.get(i);
+ }
+ for (int i = 0; i < wildCommands.size(); i++) {
+ result[j++] = (CommandInfo) wildCommands.get(i);
+ }
+
+ for (Iterator i = fallbackCommands.keySet().iterator(); i.hasNext();) {
+ result[j++] = (CommandInfo) fallbackCommands.get((String)i.next());
+ }
+ return result;
+ }
+
+ public synchronized CommandInfo getCommand(String mimeType, String cmdName) {
+ mimeType = mimeType.toLowerCase();
+ // strip any parameters from the supplied mimeType
+ int i = mimeType.indexOf(';');
+ if (i != -1) {
+ mimeType = mimeType.substring(0, i).trim();
+ }
+ cmdName = cmdName.toLowerCase();
+
+ // search for an exact match
+ Map commands = (Map) preferredCommands.get(mimeType);
+ if (commands == null || commands.get(cmdName) == null) {
+ // then a wild card match
+ commands = (Map) preferredCommands.get(getWildcardMimeType(mimeType));
+ if (commands == null || commands.get(cmdName) == null) {
+ // then fallback searches, both standard and wild card.
+ commands = (Map) fallbackCommands.get(mimeType);
+ if (commands == null || commands.get(cmdName) == null) {
+ commands = (Map) fallbackCommands.get(getWildcardMimeType(mimeType));
+ }
+ if (commands == null) {
+ return null;
+ }
+ }
+ }
+ return (CommandInfo) commands.get(cmdName);
+ }
+
+ private String getWildcardMimeType(String mimeType) {
+ int i = mimeType.indexOf('/');
+ if (i == -1) {
+ return mimeType + "/*";
+ } else {
+ return mimeType.substring(0, i + 1) + "*";
+ }
+ }
+
+ public synchronized DataContentHandler createDataContentHandler(String mimeType) {
+
+ CommandInfo info = getCommand(mimeType, "content-handler");
+ if (info == null) {
+ return null;
+ }
+
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+ if (cl == null) {
+ cl = getClass().getClassLoader();
+ }
+ try {
+ return (DataContentHandler) cl.loadClass(info.getCommandClass()).newInstance();
+ } catch (ClassNotFoundException e) {
+ return null;
+ } catch (IllegalAccessException e) {
+ return null;
+ } catch (InstantiationException e) {
+ return null;
+ }
+ }
+
+ /**
+ * Get all MIME types known to this command map.
+ *
+ * @return A String array of the MIME type names.
+ */
+ public synchronized String[] getMimeTypes() {
+ ArrayList types = new ArrayList(mimeTypes.values());
+ return (String[])types.toArray(new String[types.size()]);
+ }
+
+ /**
+ * Return the list of raw command strings parsed
+ * from the mailcap files for a given mimeType.
+ *
+ * @param mimeType The target mime type
+ *
+ * @return A String array of the raw command strings. Returns
+ * an empty array if the mimetype is not currently known.
+ */
+ public synchronized String[] getNativeCommands(String mimeType) {
+ ArrayList commands = (ArrayList)nativeCommands.get(mimeType.toLowerCase());
+ if (commands == null) {
+ return new String[0];
+ }
+ return (String[])commands.toArray(new String[commands.size()]);
+ }
+
+ private boolean isSpecialCharacter(char c) {
+ return Character.isWhitespace(c) || Character.isISOControl(c) || TSPECIALS.indexOf(c) != -1;
+ }
+}
diff --git a/activation-api-2.0.1/src/main/java/javax/activation/MimetypesFileTypeMap.java b/activation-api-2.0.1/src/main/java/javax/activation/MimetypesFileTypeMap.java
new file mode 100644
index 0000000..bf8836a
--- /dev/null
+++ b/activation-api-2.0.1/src/main/java/javax/activation/MimetypesFileTypeMap.java
@@ -0,0 +1,203 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package javax.activation;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.FileReader;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.StringReader;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.StringTokenizer;
+import java.util.Enumeration;
+import java.net.URL;
+
+/**
+ * @version $Rev: 467742 $ $Date: 2006-10-25 21:30:38 +0200 (Wed, 25 Oct 2006) $
+ */
+public class MimetypesFileTypeMap extends FileTypeMap {
+ private static final String DEFAULT_TYPE = "application/octet-stream";
+
+ private final Map types = new HashMap();
+
+ public MimetypesFileTypeMap() {
+ // defaults from /META-INF/mimetypes.default
+ try {
+ InputStream is = MimetypesFileTypeMap.class.getResourceAsStream("/META-INF/mimetypes.default");
+ if (is != null) {
+ try {
+ loadStream(is);
+ } finally {
+ is.close();
+ }
+ }
+ } catch (IOException e) {
+ // ignore
+ }
+
+ // defaults from resources called /META-INF/mime.types
+ try {
+ ClassLoader cl = MimetypesFileTypeMap.class.getClassLoader();
+ if (cl != null) {
+ Enumeration e = cl.getResources("/META-INF/mime.types");
+ while (e.hasMoreElements()) {
+ URL url = (URL)e.nextElement();
+ try {
+ InputStream is = url.openStream();
+ try {
+ loadStream(is);
+ } finally {
+ is.close();
+ }
+ } catch (IOException e1) {
+ continue;
+ }
+ }
+ }
+ } catch (SecurityException e) {
+ // ignore
+ } catch (IOException e) {
+ // ignore
+ }
+
+ // defaults from ${java.home}/lib/mime.types
+ try {
+ File file = new File(System.getProperty("java.home"), "lib/mime.types");
+ InputStream is = new FileInputStream(file);
+ try {
+ loadStream(is);
+ } finally {
+ is.close();
+ }
+ } catch (SecurityException e) {
+ // ignore
+ } catch (FileNotFoundException e) {
+ // ignore
+ } catch (IOException e) {
+ // ignore
+ }
+
+ // defaults from ${user.home}/.mime.types
+ try {
+ File file = new File(System.getProperty("user.home"), ".mime.types");
+ InputStream is = new FileInputStream(file);
+ try {
+ loadStream(is);
+ } finally {
+ is.close();
+ }
+ } catch (SecurityException e) {
+ // ignore
+ } catch (FileNotFoundException e) {
+ // ignore
+ } catch (IOException e) {
+ // ignore
+ }
+ }
+
+ public MimetypesFileTypeMap(String mimeTypeFileName) throws IOException {
+ this();
+ BufferedReader reader = new BufferedReader(new FileReader(mimeTypeFileName));
+ try {
+ String line;
+ while ((line = reader.readLine()) != null) {
+ addMimeTypesOneLine(line);
+ }
+ reader.close();
+ } catch (IOException e) {
+ try {
+ reader.close();
+ } catch (IOException e1) {
+ // ignore to allow original cause through
+ }
+ throw e;
+ }
+ }
+
+ public MimetypesFileTypeMap(InputStream is) {
+ this();
+ try {
+ loadStream(is);
+ } catch (IOException e) {
+ // ignore as the spec's signature says we can't throw IOException - doh!
+ }
+ }
+
+ private void loadStream(InputStream is) throws IOException {
+ BufferedReader reader = new BufferedReader(new InputStreamReader(is));
+ String line;
+ while ((line = reader.readLine()) != null) {
+ addMimeTypesOneLine(line);
+ }
+ }
+
+ private synchronized void addMimeTypesOneLine(String mime_types) {
+ int hashPos = mime_types.indexOf('#');
+ if (hashPos != -1) {
+ mime_types = mime_types.substring(0, hashPos);
+ }
+ StringTokenizer tok = new StringTokenizer(mime_types);
+ if (!tok.hasMoreTokens()) {
+ return;
+ }
+ String contentType = tok.nextToken();
+ while (tok.hasMoreTokens()) {
+ String fileType = tok.nextToken();
+ types.put(fileType, contentType);
+ }
+ }
+
+ public synchronized void addMimeTypes(String mime_types) {
+ BufferedReader reader = new BufferedReader(new StringReader(mime_types));
+ try {
+ String line;
+ while ((line = reader.readLine()) != null) {
+ addMimeTypesOneLine(line);
+ }
+ reader.close();
+ } catch (IOException e) {
+ try {
+ reader.close();
+ } catch (IOException e1) {
+ e1.printStackTrace();
+ }
+ }
+ }
+
+
+ public String getContentType(File f) {
+ return getContentType(f.getName());
+ }
+
+ public synchronized String getContentType(String filename) {
+ int index = filename.lastIndexOf('.');
+ if (index == -1 || index == filename.length()-1) {
+ return DEFAULT_TYPE;
+ }
+ String fileType = filename.substring(index + 1);
+ String contentType = (String) types.get(fileType);
+ return contentType == null ? DEFAULT_TYPE : contentType;
+ }
+}
diff --git a/activation-api-2.0.1/src/main/java/org/apache/servicemix/specs/activation/Activator.java b/activation-api-2.0.1/src/main/java/org/apache/servicemix/specs/activation/Activator.java
new file mode 100644
index 0000000..fc2643f
--- /dev/null
+++ b/activation-api-2.0.1/src/main/java/org/apache/servicemix/specs/activation/Activator.java
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.servicemix.specs.activation;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.activation.CommandMap;
+import javax.activation.DataContentHandler;
+
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+
+/**
+ * A bundle activator for activation framework
+ */
+public class Activator extends org.apache.servicemix.specs.locator.Activator {
+
+ private Map<Long, MailCap> mailcaps = new ConcurrentHashMap<Long, MailCap>();
+
+ @Override
+ public void start(BundleContext bundleContext) throws Exception {
+ super.start(bundleContext);
+ }
+
+ @Override
+ public void stop(BundleContext bundleContext) throws Exception {
+ super.stop(bundleContext);
+ CommandMap.setDefaultCommandMap(null);
+ }
+
+ @Override
+ protected void register(Bundle bundle) {
+ debugPrintln("checking bundle " + bundle.getBundleId());
+ URL url = bundle.getResource("/META-INF/mailcap");
+ if (url != null) {
+ debugPrintln("found mailcap at " + url);
+
+ try {
+ final Class<?> clazz = bundle
+ .loadClass("javax.activation.DataContentHandler");
+ if (!clazz.isAssignableFrom(DataContentHandler.class)) {
+ debugPrintln("incompatible DataContentHandler class in bundle "
+ + bundle.getBundleId());
+ return;
+ }
+ } catch (ClassNotFoundException e) {
+ // ignored
+ }
+
+ try {
+ mailcaps.put(bundle.getBundleId(), new MailCap(bundle, url));
+ } catch (IOException ex) {
+ // ignored
+ }
+ rebuildCommandMap();
+ }
+ }
+
+ @Override
+ protected void unregister(long bundleId) {
+ MailCap mailcap = mailcaps.remove(bundleId);
+ if (mailcap != null ){
+ debugPrintln("removing mailcap for bundle " + mailcap.bundle.getBundleId());
+ rebuildCommandMap();
+ }
+ }
+
+ private void rebuildCommandMap() {
+ ClassLoader tccl = Thread.currentThread().getContextClassLoader();
+ try {
+ Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+ OsgiMailcapCommandMap commandMap = new OsgiMailcapCommandMap();
+ for (MailCap mailcap : mailcaps.values()) {
+ for (String line : mailcap.lines) {
+ commandMap.addMailcap(line, mailcap.bundle);
+ }
+ }
+ CommandMap.setDefaultCommandMap(commandMap);
+ } finally {
+ Thread.currentThread().setContextClassLoader(tccl);
+ }
+ }
+
+ private static class MailCap {
+ Bundle bundle;
+ List<String> lines;
+
+ private MailCap(Bundle bundle, URL url) throws IOException {
+ this.bundle = bundle;
+ this.lines = new ArrayList<String>();
+ InputStream is = url.openStream();
+ try {
+ BufferedReader br = new BufferedReader(new InputStreamReader(is));
+ String line;
+ while ((line = br.readLine()) != null) {
+ lines.add(line);
+ }
+ } finally {
+ is.close();
+ }
+ }
+ }
+
+}
diff --git a/activation-api-2.0.1/src/main/java/org/apache/servicemix/specs/activation/OsgiMailcapCommandMap.java b/activation-api-2.0.1/src/main/java/org/apache/servicemix/specs/activation/OsgiMailcapCommandMap.java
new file mode 100644
index 0000000..a914247
--- /dev/null
+++ b/activation-api-2.0.1/src/main/java/org/apache/servicemix/specs/activation/OsgiMailcapCommandMap.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.servicemix.specs.activation;
+
+import java.util.Map;
+import java.util.HashMap;
+
+import javax.activation.MailcapCommandMap;
+import javax.activation.CommandInfo;
+import javax.activation.DataContentHandler;
+
+import org.osgi.framework.Bundle;
+
+/**
+ * An OSGi enabled MailcapCommandMap
+ */
+public class OsgiMailcapCommandMap extends MailcapCommandMap {
+
+ private Bundle currentBundle;
+ private Map<CommandInfo, Bundle> bundles = new HashMap<CommandInfo, Bundle>();
+
+ public void addMailcap(String line, Bundle bundle) {
+ currentBundle = bundle;
+ addMailcap(line);
+ }
+
+ protected void addCommand(Map commandList, String mimeType, CommandInfo command) {
+ super.addCommand(commandList, mimeType, command);
+ if (currentBundle != null) {
+ bundles.put(command, currentBundle);
+ }
+ }
+
+ @Override
+ public DataContentHandler createDataContentHandler(String mimeType) {
+ CommandInfo info = getCommand(mimeType, "content-handler");
+ if (info == null) {
+ return null;
+ }
+
+ Bundle bundle = bundles.get(info);
+ if (bundle != null) {
+ try {
+ return (DataContentHandler) bundle.loadClass(info.getCommandClass()).newInstance();
+ } catch (ClassNotFoundException e) {
+ return null;
+ } catch (IllegalAccessException e) {
+ return null;
+ } catch (InstantiationException e) {
+ return null;
+ }
+ }
+
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+ if (cl == null) {
+ cl = getClass().getClassLoader();
+ }
+ try {
+ return (DataContentHandler) cl.loadClass(info.getCommandClass()).newInstance();
+ } catch (ClassNotFoundException e) {
+ return null;
+ } catch (IllegalAccessException e) {
+ return null;
+ } catch (InstantiationException e) {
+ return null;
+ }
+ }
+}
