cxf-core and cxf-rt-frontend-jaxrs changes since 3.4.3
diff --git a/tomee/tomee-plume-webapp/pom.xml b/tomee/tomee-plume-webapp/pom.xml
index 2e727e5..c49a4a1 100644
--- a/tomee/tomee-plume-webapp/pom.xml
+++ b/tomee/tomee-plume-webapp/pom.xml
@@ -551,10 +551,17 @@
<source>1.8</source>
<target>1.8</target>
<dependencies>
+ <dependency>org.apache.aries.blueprint:blueprint-parser:jar:1.6.0</dependency>
+ <dependency>org.apache.aries.blueprint:org.apache.aries.blueprint.api:jar:1.0.1</dependency>
+ <dependency>org.apache.aries.blueprint:org.apache.aries.blueprint.core:jar:1.10.2</dependency>
<dependency>org.apache.tomcat:tomcat-servlet-api:jar:10.0.4</dependency>
- <dependency>org.springframework:spring-core:jar:5.3.6</dependency>
- <dependency>org.springframework:spring-context:jar:5.3.6</dependency>
+ <dependency>org.osgi:org.osgi.core:jar:6.0.0</dependency>
+ <dependency>org.osgi:osgi.cmpn:jar:6.0.0</dependency>
+ <dependency>org.ow2.asm:asm:jar:9.1</dependency>
+ <dependency>org.springframework:spring-aop:jar:5.3.6</dependency>
<dependency>org.springframework:spring-beans:jar:5.3.6</dependency>
+ <dependency>org.springframework:spring-context:jar:5.3.6</dependency>
+ <dependency>org.springframework:spring-core:jar:5.3.6</dependency>
<dependency>org.springframework:spring-webmvc:jar:5.3.6</dependency>
</dependencies>
</configuration>
diff --git a/transform/src/patch/java/org/apache/cxf/annotations/Policy.java b/transform/src/patch/java/org/apache/cxf/annotations/Policy.java
new file mode 100644
index 0000000..a0d4a75
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/annotations/Policy.java
@@ -0,0 +1,80 @@
+/**
+ * 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.cxf.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Attaches a Policy to a service or method
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Inherited
+public @interface Policy {
+
+ String uri();
+
+ boolean includeInWSDL() default true;
+
+
+ /**
+ * The place to put the PolicyReference. The Default depends on the
+ * location of the annotation. On the method in the SEI, it would be
+ * the binding/operation, on the SEI, it would be the binding, on the
+ * service impl, the service element.
+ * @return location
+ */
+ Placement placement() default Placement.DEFAULT;
+
+ /**
+ * If Placement is PORT_TYPE_OPERATION_FAULT, or BINDING_OPERATION_FAULT,
+ * return the fault class associated with this documentation
+ * @return the fault class
+ */
+ Class<?> faultClass() default DEFAULT.class;
+
+ enum Placement {
+ DEFAULT,
+
+ PORT_TYPE,
+ PORT_TYPE_OPERATION,
+ PORT_TYPE_OPERATION_INPUT,
+ PORT_TYPE_OPERATION_OUTPUT,
+ PORT_TYPE_OPERATION_FAULT,
+
+ BINDING,
+ BINDING_OPERATION,
+ BINDING_OPERATION_INPUT,
+ BINDING_OPERATION_OUTPUT,
+ BINDING_OPERATION_FAULT,
+
+ SERVICE,
+ SERVICE_PORT,
+ }
+
+ final class DEFAULT { }
+}
+
diff --git a/transform/src/patch/java/org/apache/cxf/annotations/WSDLDocumentation.java b/transform/src/patch/java/org/apache/cxf/annotations/WSDLDocumentation.java
new file mode 100644
index 0000000..9116f1c
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/annotations/WSDLDocumentation.java
@@ -0,0 +1,88 @@
+/**
+ * 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.cxf.annotations;
+
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+/**
+ * Adds documentation nodes to the generated WSDL
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Inherited
+public @interface WSDLDocumentation {
+ /**
+ * The documentation to add
+ * @return documentation string
+ */
+ String value();
+
+ /**
+ * The place to put the documentation. The Default depends on the
+ * location of the annotation. On the method in the SEI, it would be
+ * the portType/operation, on the SEI, it would be the portType, on the
+ * service impl, the service element.
+ * @return location
+ */
+ Placement placement() default Placement.DEFAULT;
+
+ /**
+ * If Placement is FAULT_MESSAGE, PORT_FAULT, or BINDING_FAULT,
+ * return the fault class associated with this documentation
+ * @return the fault class
+ */
+ Class<?> faultClass() default DEFAULT.class;
+
+ enum Placement {
+ DEFAULT,
+ TOP,
+
+ INPUT_MESSAGE,
+ OUTPUT_MESSAGE,
+ FAULT_MESSAGE,
+
+ PORT_TYPE,
+ PORT_TYPE_OPERATION,
+ PORT_TYPE_OPERATION_INPUT,
+ PORT_TYPE_OPERATION_OUTPUT,
+ PORT_TYPE_OPERATION_FAULT,
+
+ BINDING,
+ BINDING_OPERATION,
+ BINDING_OPERATION_INPUT,
+ BINDING_OPERATION_OUTPUT,
+ BINDING_OPERATION_FAULT,
+
+ SERVICE,
+ SERVICE_PORT,
+
+ }
+
+
+ final class DEFAULT { }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/AttachmentDataSource.java b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentDataSource.java
new file mode 100644
index 0000000..6e4fa1a
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentDataSource.java
@@ -0,0 +1,107 @@
+/**
+ * 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.cxf.attachment;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import javax.activation.DataSource;
+
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.io.CacheSizeExceededException;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.message.Message;
+
+public class AttachmentDataSource implements DataSource {
+
+ private final String ct;
+ private CachedOutputStream cache;
+ private InputStream ins;
+ private DelegatingInputStream delegate;
+ private String name;
+
+ public AttachmentDataSource(String ctParam, InputStream inParam) {
+ this.ct = ctParam;
+ ins = inParam;
+ }
+
+ public boolean isCached() {
+ return cache != null;
+ }
+ public void cache(Message message) throws IOException {
+ if (cache == null) {
+ cache = new CachedOutputStream();
+ AttachmentUtil.setStreamedAttachmentProperties(message, cache);
+ try {
+ IOUtils.copyAndCloseInput(ins, cache);
+ cache.lockOutputStream();
+ if (delegate != null) {
+ delegate.setInputStream(cache.getInputStream());
+ }
+ } catch (CacheSizeExceededException | IOException cee) {
+ cache.close();
+ cache = null;
+ throw cee;
+ } finally {
+ ins = null;
+ }
+ }
+ }
+ public void hold(Message message) throws IOException {
+ cache(message);
+ cache.holdTempFile();
+ }
+ public void release() {
+ if (cache != null) {
+ cache.releaseTempFileHold();
+ }
+ }
+
+ public String getContentType() {
+ return ct;
+ }
+
+ public InputStream getInputStream() {
+ try {
+ if (cache != null) {
+ return cache.getInputStream();
+ }
+ if (delegate == null) {
+ delegate = new DelegatingInputStream(ins);
+ }
+ return delegate;
+ } catch (IOException e) {
+ return null;
+ }
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public OutputStream getOutputStream() throws IOException {
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/AttachmentDeserializer.java b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentDeserializer.java
new file mode 100644
index 0000000..55a1dcc
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentDeserializer.java
@@ -0,0 +1,462 @@
+/**
+ * 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.cxf.attachment;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.activation.DataSource;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.SystemPropertyAction;
+import org.apache.cxf.helpers.HttpHeaderHelper;
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.message.Attachment;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+
+public class AttachmentDeserializer {
+ public static final String ATTACHMENT_PART_HEADERS = AttachmentDeserializer.class.getName() + ".headers";
+
+ /**
+ * Allowed value is any instance of {@link File} or {@link String}.
+ */
+ public static final String ATTACHMENT_DIRECTORY = "attachment-directory";
+
+ /**
+ * The memory threshold of attachments. Allowed value is any instance of {@link Number} or {@link String}.
+ * The default is {@link AttachmentDeserializer#THRESHOLD}.
+ */
+ public static final String ATTACHMENT_MEMORY_THRESHOLD = "attachment-memory-threshold";
+
+ /**
+ * The maximum size of the attachment. Allowed value is any of {@link Number} or {@link String}.
+ */
+ public static final String ATTACHMENT_MAX_SIZE = "attachment-max-size";
+
+ /**
+ * The maximum number of attachments permitted in a message. The default is 50.
+ */
+ public static final String ATTACHMENT_MAX_COUNT = "attachment-max-count";
+
+ /**
+ * The maximum MIME Header Length. The default is 300.
+ */
+ public static final String ATTACHMENT_MAX_HEADER_SIZE = "attachment-max-header-size";
+ public static final int DEFAULT_MAX_HEADER_SIZE =
+ SystemPropertyAction.getInteger("org.apache.cxf.attachment-max-header-size", 300);
+
+ public static final int THRESHOLD = 1024 * 100; //100K (byte unit)
+
+ private static final Pattern CONTENT_TYPE_BOUNDARY_PATTERN = Pattern.compile("boundary=\"?([^\";]*)");
+
+ private static final Pattern INPUT_STREAM_BOUNDARY_PATTERN =
+ Pattern.compile("^--(\\S*)$", Pattern.MULTILINE);
+
+ private static final Logger LOG = LogUtils.getL7dLogger(AttachmentDeserializer.class);
+
+ private static final int PUSHBACK_AMOUNT = 2048;
+
+ private boolean lazyLoading = true;
+
+ private PushbackInputStream stream;
+ private int createCount;
+ private int closedCount;
+ private boolean closed;
+
+ private byte[] boundary;
+
+ private LazyAttachmentCollection attachments;
+
+ private Message message;
+
+ private InputStream body;
+
+ private Set<DelegatingInputStream> loaded = new HashSet<>();
+ private List<String> supportedTypes;
+
+ private int maxHeaderLength = DEFAULT_MAX_HEADER_SIZE;
+
+ public AttachmentDeserializer(Message message) {
+ this(message, Collections.singletonList("multipart/related"));
+ }
+
+ public AttachmentDeserializer(Message message, List<String> supportedTypes) {
+ this.message = message;
+ this.supportedTypes = supportedTypes;
+
+ // Get the maximum Header length from configuration
+ maxHeaderLength = MessageUtils.getContextualInteger(message, ATTACHMENT_MAX_HEADER_SIZE,
+ DEFAULT_MAX_HEADER_SIZE);
+ }
+
+ public void initializeAttachments() throws IOException {
+ initializeRootMessage();
+
+ Object maxCountProperty = message.getContextualProperty(AttachmentDeserializer.ATTACHMENT_MAX_COUNT);
+ int maxCount = 50;
+ if (maxCountProperty != null) {
+ if (maxCountProperty instanceof Integer) {
+ maxCount = (Integer)maxCountProperty;
+ } else {
+ maxCount = Integer.parseInt((String)maxCountProperty);
+ }
+ }
+
+ attachments = new LazyAttachmentCollection(this, maxCount);
+ message.setAttachments(attachments);
+ }
+
+ protected void initializeRootMessage() throws IOException {
+ String contentType = (String) message.get(Message.CONTENT_TYPE);
+
+ if (contentType == null) {
+ throw new IllegalStateException("Content-Type can not be empty!");
+ }
+
+ if (message.getContent(InputStream.class) == null) {
+ throw new IllegalStateException("An InputStream must be provided!");
+ }
+
+ if (AttachmentUtil.isTypeSupported(contentType.toLowerCase(), supportedTypes)) {
+ String boundaryString = findBoundaryFromContentType(contentType);
+ if (null == boundaryString) {
+ boundaryString = findBoundaryFromInputStream();
+ }
+ // If a boundary still wasn't found, throw an exception
+ if (null == boundaryString) {
+ throw new IOException("Couldn't determine the boundary from the message!");
+ }
+ boundary = boundaryString.getBytes(StandardCharsets.UTF_8);
+
+ stream = new PushbackInputStream(message.getContent(InputStream.class), PUSHBACK_AMOUNT);
+ if (!readTillFirstBoundary(stream, boundary)) {
+ throw new IOException("Couldn't find MIME boundary: " + boundaryString);
+ }
+
+ Map<String, List<String>> ih = loadPartHeaders(stream);
+ message.put(ATTACHMENT_PART_HEADERS, ih);
+ String val = AttachmentUtil.getHeader(ih, "Content-Type", "; ");
+ if (!StringUtils.isEmpty(val)) {
+ String cs = HttpHeaderHelper.findCharset(val);
+ if (!StringUtils.isEmpty(cs)) {
+ message.put(Message.ENCODING, HttpHeaderHelper.mapCharset(cs));
+ }
+ }
+ val = AttachmentUtil.getHeader(ih, "Content-Transfer-Encoding");
+
+ MimeBodyPartInputStream mmps = new MimeBodyPartInputStream(stream, boundary, PUSHBACK_AMOUNT);
+ InputStream ins = AttachmentUtil.decode(mmps, val);
+ if (ins != mmps) {
+ ih.remove("Content-Transfer-Encoding");
+ }
+ body = new DelegatingInputStream(ins, this);
+ createCount++;
+ message.setContent(InputStream.class, body);
+ }
+ }
+
+ private String findBoundaryFromContentType(String ct) {
+ // Use regex to get the boundary and return null if it's not found
+ Matcher m = CONTENT_TYPE_BOUNDARY_PATTERN.matcher(ct);
+ return m.find() ? "--" + m.group(1) : null;
+ }
+
+ private String findBoundaryFromInputStream() throws IOException {
+ InputStream is = message.getContent(InputStream.class);
+ //boundary should definitely be in the first 2K;
+ PushbackInputStream in = new PushbackInputStream(is, 4096);
+ byte[] buf = new byte[2048];
+ int i = in.read(buf);
+ int len = i;
+ while (i > 0 && len < buf.length) {
+ i = in.read(buf, len, buf.length - len);
+ if (i > 0) {
+ len += i;
+ }
+ }
+ String msg = IOUtils.newStringFromBytes(buf, 0, len);
+ in.unread(buf, 0, len);
+
+ // Reset the input stream since we'll need it again later
+ message.setContent(InputStream.class, in);
+
+ // Use regex to get the boundary and return null if it's not found
+ Matcher m = INPUT_STREAM_BOUNDARY_PATTERN.matcher(msg);
+ return m.find() ? "--" + m.group(1) : null;
+ }
+
+ public AttachmentImpl readNext() throws IOException {
+ // Cache any mime parts that are currently being streamed
+ cacheStreamedAttachments();
+ if (closed) {
+ return null;
+ }
+
+ int v = stream.read();
+ if (v == -1) {
+ return null;
+ }
+ stream.unread(v);
+
+ Map<String, List<String>> headers = loadPartHeaders(stream);
+ return (AttachmentImpl)createAttachment(headers);
+ }
+
+ private void cacheStreamedAttachments() throws IOException {
+ if (body instanceof DelegatingInputStream
+ && !((DelegatingInputStream) body).isClosed()) {
+
+ cache((DelegatingInputStream) body);
+ }
+
+ List<Attachment> atts = new ArrayList<>(attachments.getLoadedAttachments());
+ for (Attachment a : atts) {
+ DataSource s = a.getDataHandler().getDataSource();
+ if (s instanceof AttachmentDataSource) {
+ AttachmentDataSource ads = (AttachmentDataSource)s;
+ if (!ads.isCached()) {
+ ads.cache(message);
+ }
+ } else if (s.getInputStream() instanceof DelegatingInputStream) {
+ cache((DelegatingInputStream) s.getInputStream());
+ } else {
+ //assume a normal stream that is already cached
+ }
+ }
+ }
+
+ private void cache(DelegatingInputStream input) throws IOException {
+ if (loaded.contains(input)) {
+ return;
+ }
+ loaded.add(input);
+ InputStream origIn = input.getInputStream();
+ try (CachedOutputStream out = new CachedOutputStream()) {
+ AttachmentUtil.setStreamedAttachmentProperties(message, out);
+ IOUtils.copy(input, out);
+ input.setInputStream(out.getInputStream());
+ origIn.close();
+ }
+ }
+
+ /**
+ * Move the read pointer to the begining of the first part read till the end
+ * of first boundary
+ *
+ * @param pushbackInStream
+ * @param boundary
+ * @throws IOException
+ */
+ private static boolean readTillFirstBoundary(PushbackInputStream pushbackInStream,
+ byte[] boundary) throws IOException {
+
+ // work around a bug in PushBackInputStream where the buffer isn't
+ // initialized
+ // and available always returns 0.
+ int value = pushbackInStream.read();
+ pushbackInStream.unread(value);
+ while (value != -1) {
+ value = pushbackInStream.read();
+ if ((byte) value == boundary[0]) {
+ int boundaryIndex = 0;
+ while (value != -1 && (boundaryIndex < boundary.length) && ((byte) value == boundary[boundaryIndex])) {
+
+ value = pushbackInStream.read();
+ if (value == -1) {
+ throw new IOException("Unexpected End while searching for first Mime Boundary");
+ }
+ boundaryIndex++;
+ }
+ if (boundaryIndex == boundary.length) {
+ // boundary found, read the newline
+ if (value == 13) {
+ pushbackInStream.read();
+ }
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Create an Attachment from the MIME stream. If there is a previous attachment
+ * that is not read, cache that attachment.
+ *
+ * @throws IOException
+ */
+ private Attachment createAttachment(Map<String, List<String>> headers) throws IOException {
+ InputStream partStream =
+ new DelegatingInputStream(new MimeBodyPartInputStream(stream, boundary, PUSHBACK_AMOUNT),
+ this);
+ createCount++;
+
+ return AttachmentUtil.createAttachment(partStream, headers);
+ }
+
+ public boolean isLazyLoading() {
+ return lazyLoading;
+ }
+
+ public void setLazyLoading(boolean lazyLoading) {
+ this.lazyLoading = lazyLoading;
+ }
+
+ public void markClosed(DelegatingInputStream delegatingInputStream) throws IOException {
+ closedCount++;
+ if (closedCount == createCount && !attachments.hasNext(false)) {
+ int x = stream.read();
+ while (x != -1) {
+ x = stream.read();
+ }
+ stream.close();
+ closed = true;
+ }
+ }
+ /**
+ * Check for more attachment.
+ *
+ * @return whether there is more attachment or not. It will not deserialize the next attachment.
+ * @throws IOException
+ */
+ public boolean hasNext() throws IOException {
+ cacheStreamedAttachments();
+ if (closed) {
+ return false;
+ }
+
+ int v = stream.read();
+ if (v == -1) {
+ return false;
+ }
+ stream.unread(v);
+ return true;
+ }
+
+
+
+ private Map<String, List<String>> loadPartHeaders(InputStream in) throws IOException {
+ StringBuilder buffer = new StringBuilder(128);
+ StringBuilder b = new StringBuilder(128);
+ Map<String, List<String>> heads = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+
+ // loop until we hit the end or a null line
+ while (readLine(in, b)) {
+ // lines beginning with white space get special handling
+ char c = b.charAt(0);
+ if (c == ' ' || c == '\t') {
+ if (buffer.length() != 0) {
+ // preserve the line break and append the continuation
+ buffer.append("\r\n");
+ buffer.append(b);
+ }
+ } else {
+ // if we have a line pending in the buffer, flush it
+ if (buffer.length() > 0) {
+ addHeaderLine(heads, buffer);
+ buffer.setLength(0);
+ }
+ // add this to the accumulator
+ buffer.append(b);
+ }
+ }
+
+ // if we have a line pending in the buffer, flush it
+ if (buffer.length() > 0) {
+ addHeaderLine(heads, buffer);
+ }
+ return heads;
+ }
+
+ private boolean readLine(InputStream in, StringBuilder buffer) throws IOException {
+ if (buffer.length() != 0) {
+ buffer.setLength(0);
+ }
+ int c;
+
+ while ((c = in.read()) != -1) {
+ // a linefeed is a terminator, always.
+ if (c == '\n') {
+ break;
+ } else if (c == '\r') {
+ //just ignore the CR. The next character SHOULD be an NL. If not, we're
+ //just going to discard this
+ continue;
+ } else {
+ // just add to the buffer
+ buffer.append((char)c);
+ }
+
+ if (buffer.length() > maxHeaderLength) {
+ LOG.fine("The attachment header size has exceeded the configured parameter: " + maxHeaderLength);
+ throw new HeaderSizeExceededException();
+ }
+ }
+
+ // no characters found...this was either an eof or a null line.
+ return buffer.length() != 0;
+ }
+
+ private void addHeaderLine(Map<String, List<String>> heads, StringBuilder line) {
+ // null lines are a nop
+ final int size = line.length();
+ if (size == 0) {
+ return;
+ }
+ int separator = line.indexOf(":");
+ final String name;
+ String value = "";
+ if (separator == -1) {
+ name = line.toString().trim();
+ } else {
+ name = line.substring(0, separator);
+ // step past the separator. Now we need to remove any leading white space characters.
+ separator++;
+
+ while (separator < size) {
+ char ch = line.charAt(separator);
+ if (ch != ' ' && ch != '\t' && ch != '\r' && ch != '\n') {
+ break;
+ }
+ separator++;
+ }
+ value = line.substring(separator);
+ }
+ List<String> v = heads.computeIfAbsent(name, k -> new ArrayList<>(1));
+ v.add(value);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/AttachmentSerializer.java b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentSerializer.java
new file mode 100644
index 0000000..3e65de3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentSerializer.java
@@ -0,0 +1,345 @@
+/**
+ * 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.cxf.attachment;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.activation.DataHandler;
+
+import org.apache.cxf.common.util.Base64Utility;
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.message.Attachment;
+import org.apache.cxf.message.Message;
+
+
+
+
+public class AttachmentSerializer {
+ // http://tools.ietf.org/html/rfc2387
+ private static final String DEFAULT_MULTIPART_TYPE = "multipart/related";
+
+ private String contentTransferEncoding = AttachmentUtil.BINARY;
+
+ private Message message;
+ private String bodyBoundary;
+ private OutputStream out;
+ private String encoding;
+
+ private String multipartType;
+ private Map<String, List<String>> rootHeaders = Collections.emptyMap();
+ private boolean xop = true;
+ private boolean writeOptionalTypeParameters = true;
+
+
+ public AttachmentSerializer(Message messageParam) {
+ message = messageParam;
+ }
+
+ public AttachmentSerializer(Message messageParam,
+ String multipartType,
+ boolean writeOptionalTypeParameters,
+ Map<String, List<String>> headers) {
+ message = messageParam;
+ this.multipartType = multipartType;
+ this.writeOptionalTypeParameters = writeOptionalTypeParameters;
+ this.rootHeaders = headers;
+ }
+
+ /**
+ * Serialize the beginning of the attachment which includes the MIME
+ * beginning and headers for the root message.
+ */
+ public void writeProlog() throws IOException {
+ // Create boundary for body
+ bodyBoundary = AttachmentUtil.getUniqueBoundaryValue();
+
+ String bodyCt = (String) message.get(Message.CONTENT_TYPE);
+ String bodyCtParams = null;
+ String bodyCtParamsEscaped = null;
+ // split the bodyCt to its head that is the type and its properties so that we
+ // can insert the values at the right places based on the soap version and the mtom option
+ // bodyCt will be of the form
+ // soap11 -> text/xml
+ // soap12 -> application/soap+xml; action="urn:ihe:iti:2007:RetrieveDocumentSet"
+ if (bodyCt.indexOf(';') != -1) {
+ int pos = bodyCt.indexOf(';');
+ // get everything from the semi-colon
+ bodyCtParams = bodyCt.substring(pos);
+ bodyCtParamsEscaped = escapeQuotes(bodyCtParams);
+ // keep the type/subtype part in bodyCt
+ bodyCt = bodyCt.substring(0, pos);
+ }
+ // Set transport mime type
+ String requestMimeType = multipartType == null ? DEFAULT_MULTIPART_TYPE : multipartType;
+
+ StringBuilder ct = new StringBuilder(32);
+ ct.append(requestMimeType);
+
+ // having xop set to true implies multipart/related, but just in case...
+ boolean xopOrMultipartRelated = xop
+ || DEFAULT_MULTIPART_TYPE.equalsIgnoreCase(requestMimeType)
+ || DEFAULT_MULTIPART_TYPE.startsWith(requestMimeType);
+
+ // type is a required parameter for multipart/related only
+ if (xopOrMultipartRelated
+ && requestMimeType.indexOf("type=") == -1) {
+ if (xop) {
+ ct.append("; type=\"application/xop+xml\"");
+ } else {
+ ct.append("; type=\"").append(bodyCt).append('"');
+ }
+ }
+
+ // boundary
+ ct.append("; boundary=\"")
+ .append(bodyBoundary)
+ .append('"');
+
+ String rootContentId = getHeaderValue("Content-ID", AttachmentUtil.BODY_ATTACHMENT_ID);
+
+ // 'start' is a required parameter for XOP/MTOM, clearly defined
+ // for simpler multipart/related payloads but is not needed for
+ // multipart/mixed, multipart/form-data
+ if (xopOrMultipartRelated) {
+ ct.append("; start=\"<")
+ .append(checkAngleBrackets(rootContentId))
+ .append(">\"");
+ }
+
+ // start-info is a required parameter for XOP/MTOM, may be needed for
+ // other WS cases but is redundant in simpler multipart/related cases
+ // the parameters need to be included within the start-info's value in the escaped form
+ if (writeOptionalTypeParameters || xop) {
+ ct.append("; start-info=\"")
+ .append(bodyCt);
+ if (bodyCtParamsEscaped != null) {
+ ct.append(bodyCtParamsEscaped);
+ }
+ ct.append('"');
+ }
+
+
+ message.put(Message.CONTENT_TYPE, ct.toString());
+
+
+ // 2. write headers
+ out = message.getContent(OutputStream.class);
+ encoding = (String) message.get(Message.ENCODING);
+ if (encoding == null) {
+ encoding = StandardCharsets.UTF_8.name();
+ }
+ StringWriter writer = new StringWriter();
+ writer.write("\r\n");
+ writer.write("--");
+ writer.write(bodyBoundary);
+
+ StringBuilder mimeBodyCt = new StringBuilder();
+ String bodyType = getHeaderValue("Content-Type", null);
+ if (bodyType == null) {
+ mimeBodyCt.append(xop ? "application/xop+xml" : bodyCt)
+ .append("; charset=").append(encoding);
+ if (xop) {
+ mimeBodyCt.append("; type=\"").append(bodyCt);
+ if (bodyCtParamsEscaped != null) {
+ mimeBodyCt.append(bodyCtParamsEscaped);
+ }
+ mimeBodyCt.append('"');
+ } else if (bodyCtParams != null) {
+ mimeBodyCt.append(bodyCtParams);
+ }
+ } else {
+ mimeBodyCt.append(bodyType);
+ }
+
+ writeHeaders(mimeBodyCt.toString(), rootContentId, rootHeaders, writer);
+ out.write(writer.getBuffer().toString().getBytes(encoding));
+ }
+
+ private static String escapeQuotes(String s) {
+ return s.indexOf('"') != 0 ? s.replace("\"", "\\\"") : s;
+ }
+
+ public void setContentTransferEncoding(String cte) {
+ contentTransferEncoding = cte;
+ }
+
+ private String getHeaderValue(String name, String defaultValue) {
+ List<String> value = rootHeaders.get(name);
+ if (value == null || value.isEmpty()) {
+ return defaultValue;
+ }
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < value.size(); i++) {
+ sb.append(value.get(i));
+ if (i + 1 < value.size()) {
+ sb.append(',');
+ }
+ }
+ return sb.toString();
+ }
+
+ private void writeHeaders(String contentType, String attachmentId,
+ Map<String, List<String>> headers, Writer writer) throws IOException {
+ writer.write("\r\nContent-Type: ");
+ writer.write(contentType);
+ writer.write("\r\nContent-Transfer-Encoding: " + contentTransferEncoding + "\r\n");
+
+ if (attachmentId != null) {
+ attachmentId = checkAngleBrackets(attachmentId);
+ writer.write("Content-ID: <");
+ writer.write(URLDecoder.decode(attachmentId, StandardCharsets.UTF_8.name()));
+ writer.write(">\r\n");
+ }
+ // headers like Content-Disposition need to be serialized
+ for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
+ String name = entry.getKey();
+ if ("Content-Type".equalsIgnoreCase(name) || "Content-ID".equalsIgnoreCase(name)
+ || "Content-Transfer-Encoding".equalsIgnoreCase(name)) {
+ continue;
+ }
+ writer.write(name);
+ writer.write(": ");
+ List<String> values = entry.getValue();
+ for (int i = 0; i < values.size(); i++) {
+ writer.write(values.get(i));
+ if (i + 1 < values.size()) {
+ writer.write(",");
+ }
+ }
+ writer.write("\r\n");
+ }
+
+ writer.write("\r\n");
+ }
+
+ private static String checkAngleBrackets(String value) {
+ if (value.charAt(0) == '<' && value.charAt(value.length() - 1) == '>') {
+ return value.substring(1, value.length() - 1);
+ }
+ return value;
+ }
+
+ /**
+ * Write the end of the body boundary and any attachments included.
+ * @throws IOException
+ */
+ public void writeAttachments() throws IOException {
+ if (message.getAttachments() != null) {
+ for (Attachment a : message.getAttachments()) {
+ StringWriter writer = new StringWriter();
+ writer.write("\r\n--");
+ writer.write(bodyBoundary);
+
+ final Map<String, List<String>> headers;
+ Iterator<String> it = a.getHeaderNames();
+ if (it.hasNext()) {
+ headers = new LinkedHashMap<>();
+ while (it.hasNext()) {
+ String key = it.next();
+ headers.put(key, Collections.singletonList(a.getHeader(key)));
+ }
+ } else {
+ headers = Collections.emptyMap();
+ }
+
+
+ DataHandler handler = a.getDataHandler();
+ handler.setCommandMap(AttachmentUtil.getCommandMap());
+
+ writeHeaders(handler.getContentType(), a.getId(),
+ headers, writer);
+ out.write(writer.getBuffer().toString().getBytes(encoding));
+ if ("base64".equals(contentTransferEncoding)) {
+ try (InputStream inputStream = handler.getInputStream()) {
+ encodeBase64(inputStream, out, IOUtils.DEFAULT_BUFFER_SIZE);
+ }
+ } else {
+ handler.writeTo(out);
+ }
+ }
+ }
+ StringWriter writer = new StringWriter();
+ writer.write("\r\n--");
+ writer.write(bodyBoundary);
+ writer.write("--");
+ out.write(writer.getBuffer().toString().getBytes(encoding));
+ out.flush();
+ }
+
+ private int encodeBase64(InputStream input, OutputStream output, int bufferSize) throws IOException {
+ int avail = input.available();
+ if (avail > 262143) {
+ //must be divisible by 3
+ avail = 262143;
+ }
+ if (avail > bufferSize) {
+ bufferSize = avail;
+ }
+ final byte[] buffer = new byte[bufferSize];
+ int n = input.read(buffer);
+ int total = 0;
+ while (-1 != n) {
+ if (n == 0) {
+ throw new IOException("0 bytes read in violation of InputStream.read(byte[])");
+ }
+ //make sure n is divisible by 3
+ int left = n % 3;
+ n -= left;
+ if (n > 0) {
+ Base64Utility.encodeAndStream(buffer, 0, n, output);
+ total += n;
+ }
+ if (left != 0) {
+ for (int x = 0; x < left; ++x) {
+ buffer[x] = buffer[n + x];
+ }
+ n = input.read(buffer, left, buffer.length - left);
+ if (n == -1) {
+ // we've hit the end, but still have stuff left, write it out
+ Base64Utility.encodeAndStream(buffer, 0, left, output);
+ total += left;
+ }
+ } else {
+ n = input.read(buffer);
+ }
+ }
+ return total;
+ }
+
+ public boolean isXop() {
+ return xop;
+ }
+
+ public void setXop(boolean xop) {
+ this.xop = xop;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/AttachmentUtil.java b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentUtil.java
new file mode 100644
index 0000000..7c72f00
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/AttachmentUtil.java
@@ -0,0 +1,572 @@
+/**
+ * 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.cxf.attachment;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Logger;
+
+import javax.activation.CommandInfo;
+import javax.activation.CommandMap;
+import javax.activation.DataContentHandler;
+import javax.activation.DataHandler;
+import javax.activation.DataSource;
+import javax.activation.FileDataSource;
+import javax.activation.MailcapCommandMap;
+import javax.activation.URLDataSource;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.helpers.FileUtils;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.message.Attachment;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+
+public final class AttachmentUtil {
+ public static final String BODY_ATTACHMENT_ID = "root.message@cxf.apache.org";
+
+ static final String BINARY = "binary";
+
+ private static final Logger LOG = LogUtils.getL7dLogger(AttachmentUtil.class);
+
+ private static final AtomicInteger COUNTER = new AtomicInteger();
+ private static final String ATT_UUID = UUID.randomUUID().toString();
+
+ private static final Random BOUND_RANDOM = new Random();
+ private static final CommandMap DEFAULT_COMMAND_MAP = CommandMap.getDefaultCommandMap();
+ private static final MailcapCommandMap COMMAND_MAP = new EnhancedMailcapCommandMap();
+
+
+ static final class EnhancedMailcapCommandMap extends MailcapCommandMap {
+ @Override
+ public synchronized DataContentHandler createDataContentHandler(
+ String mimeType) {
+ DataContentHandler dch = super.createDataContentHandler(mimeType);
+ if (dch == null) {
+ dch = DEFAULT_COMMAND_MAP.createDataContentHandler(mimeType);
+ }
+ return dch;
+ }
+
+ @Override
+ public DataContentHandler createDataContentHandler(String mimeType,
+ DataSource ds) {
+ DataContentHandler dch = super.createDataContentHandler(mimeType);
+ if (dch == null) {
+ dch = DEFAULT_COMMAND_MAP.createDataContentHandler(mimeType, ds);
+ }
+ return dch;
+ }
+
+ @Override
+ public synchronized CommandInfo[] getAllCommands(String mimeType) {
+ CommandInfo[] commands = super.getAllCommands(mimeType);
+ CommandInfo[] defaultCommands = DEFAULT_COMMAND_MAP.getAllCommands(mimeType);
+ List<CommandInfo> cmdList = new ArrayList<>(Arrays.asList(commands));
+
+ // Add CommandInfo which does not exist in current command map.
+ for (CommandInfo defCmdInfo : defaultCommands) {
+ String defCmdName = defCmdInfo.getCommandName();
+ boolean cmdNameExist = false;
+ for (CommandInfo cmdInfo : commands) {
+ if (cmdInfo.getCommandName().equals(defCmdName)) {
+ cmdNameExist = true;
+ break;
+ }
+ }
+ if (!cmdNameExist) {
+ cmdList.add(defCmdInfo);
+ }
+ }
+
+ CommandInfo[] allCommandArray = new CommandInfo[0];
+ return cmdList.toArray(allCommandArray);
+ }
+
+ @Override
+ public synchronized CommandInfo getCommand(String mimeType, String cmdName) {
+ CommandInfo cmdInfo = super.getCommand(mimeType, cmdName);
+ if (cmdInfo == null) {
+ cmdInfo = DEFAULT_COMMAND_MAP.getCommand(mimeType, cmdName);
+ }
+ return cmdInfo;
+ }
+
+ /**
+ * Merge current mime types and default mime types.
+ */
+ @Override
+ public synchronized String[] getMimeTypes() {
+ String[] mimeTypes = super.getMimeTypes();
+ String[] defMimeTypes = DEFAULT_COMMAND_MAP.getMimeTypes();
+ Set<String> mimeTypeSet = new HashSet<>();
+ Collections.addAll(mimeTypeSet, mimeTypes);
+ Collections.addAll(mimeTypeSet, defMimeTypes);
+ String[] mimeArray = new String[0];
+ return mimeTypeSet.toArray(mimeArray);
+ }
+ }
+
+
+ private AttachmentUtil() {
+
+ }
+
+ static {
+ COMMAND_MAP.addMailcap("image/*;;x-java-content-handler="
+ + ImageDataContentHandler.class.getName());
+ }
+
+ public static CommandMap getCommandMap() {
+ return COMMAND_MAP;
+ }
+
+ public static boolean isMtomEnabled(Message message) {
+ return MessageUtils.getContextualBoolean(message, Message.MTOM_ENABLED, false);
+ }
+
+ public static void setStreamedAttachmentProperties(Message message, CachedOutputStream bos)
+ throws IOException {
+ Object directory = message.getContextualProperty(AttachmentDeserializer.ATTACHMENT_DIRECTORY);
+ if (directory != null) {
+ if (directory instanceof File) {
+ bos.setOutputDir((File) directory);
+ } else if (directory instanceof String) {
+ bos.setOutputDir(new File((String) directory));
+ } else {
+ throw new IOException("The value set as " + AttachmentDeserializer.ATTACHMENT_DIRECTORY
+ + " should be either an instance of File or String");
+ }
+ }
+
+ Object threshold = message.getContextualProperty(AttachmentDeserializer.ATTACHMENT_MEMORY_THRESHOLD);
+ if (threshold != null) {
+ if (threshold instanceof Number) {
+ long t = ((Number) threshold).longValue();
+ if (t >= 0) {
+ bos.setThreshold(t);
+ } else {
+ LOG.warning("Threshold value overflowed long. Setting default value!");
+ bos.setThreshold(AttachmentDeserializer.THRESHOLD);
+ }
+ } else if (threshold instanceof String) {
+ try {
+ bos.setThreshold(Long.parseLong((String) threshold));
+ } catch (NumberFormatException e) {
+ throw new IOException("Provided threshold String is not a number", e);
+ }
+ } else {
+ throw new IOException("The value set as " + AttachmentDeserializer.ATTACHMENT_MEMORY_THRESHOLD
+ + " should be either an instance of Number or String");
+ }
+ } else if (!CachedOutputStream.isThresholdSysPropSet()) {
+ // Use the default AttachmentDeserializer Threshold only if there is no system property defined
+ bos.setThreshold(AttachmentDeserializer.THRESHOLD);
+ }
+
+ Object maxSize = message.getContextualProperty(AttachmentDeserializer.ATTACHMENT_MAX_SIZE);
+ if (maxSize != null) {
+ if (maxSize instanceof Number) {
+ long size = ((Number) maxSize).longValue();
+ if (size >= 0) {
+ bos.setMaxSize(size);
+ } else {
+ LOG.warning("Max size value overflowed long. Do not set max size!");
+ }
+ } else if (maxSize instanceof String) {
+ try {
+ bos.setMaxSize(Long.parseLong((String) maxSize));
+ } catch (NumberFormatException e) {
+ throw new IOException("Provided threshold String is not a number", e);
+ }
+ } else {
+ throw new IOException("The value set as " + AttachmentDeserializer.ATTACHMENT_MAX_SIZE
+ + " should be either an instance of Number or String");
+ }
+ }
+ }
+
+ public static String createContentID(String ns) throws UnsupportedEncodingException {
+ // tend to change
+ String cid = "cxf.apache.org";
+ if (ns != null && !ns.isEmpty()) {
+ try {
+ URI uri = new URI(ns);
+ String host = uri.getHost();
+ if (host != null) {
+ cid = host;
+ } else {
+ cid = ns;
+ }
+ } catch (Exception e) {
+ cid = ns;
+ }
+ }
+ return ATT_UUID + '-' + Integer.toString(COUNTER.incrementAndGet()) + '@'
+ + URLEncoder.encode(cid, StandardCharsets.UTF_8.name());
+ }
+
+ public static String getUniqueBoundaryValue() {
+ //generate a random UUID.
+ //we don't need the cryptographically secure random uuid that
+ //UUID.randomUUID() will produce. Thus, use a faster
+ //pseudo-random thing
+ long leastSigBits;
+ long mostSigBits;
+ synchronized (BOUND_RANDOM) {
+ mostSigBits = BOUND_RANDOM.nextLong();
+ leastSigBits = BOUND_RANDOM.nextLong();
+ }
+
+ mostSigBits &= 0xFFFFFFFFFFFF0FFFL; //clear version
+ mostSigBits |= 0x0000000000004000L; //set version
+
+ leastSigBits &= 0x3FFFFFFFFFFFFFFFL; //clear the variant
+ leastSigBits |= 0x8000000000000000L; //set to IETF variant
+
+ UUID result = new UUID(mostSigBits, leastSigBits);
+
+ return "uuid:" + result.toString();
+ }
+
+ public static Map<String, DataHandler> getDHMap(final Collection<Attachment> attachments) {
+ Map<String, DataHandler> dataHandlers = null;
+ if (attachments != null) {
+ if (attachments instanceof LazyAttachmentCollection) {
+ dataHandlers = ((LazyAttachmentCollection)attachments).createDataHandlerMap();
+ } else {
+ dataHandlers = new DHMap(attachments);
+ }
+ }
+ return dataHandlers == null ? new LinkedHashMap<>() : dataHandlers;
+ }
+
+ static class DHMap extends AbstractMap<String, DataHandler> {
+ final Collection<Attachment> list;
+ DHMap(Collection<Attachment> l) {
+ list = l;
+ }
+ public Set<Map.Entry<String, DataHandler>> entrySet() {
+ return new AbstractSet<Map.Entry<String, DataHandler>>() {
+ @Override
+ public Iterator<Map.Entry<String, DataHandler>> iterator() {
+ final Iterator<Attachment> it = list.iterator();
+ return new Iterator<Map.Entry<String, DataHandler>>() {
+ public boolean hasNext() {
+ return it.hasNext();
+ }
+ public Map.Entry<String, DataHandler> next() {
+ final Attachment a = it.next();
+ return new Map.Entry<String, DataHandler>() {
+ @Override
+ public String getKey() {
+ return a.getId();
+ }
+
+ @Override
+ public DataHandler getValue() {
+ return a.getDataHandler();
+ }
+
+ @Override
+ public DataHandler setValue(DataHandler value) {
+ return null;
+ }
+ };
+ }
+ @Override
+ public void remove() {
+ it.remove();
+ }
+ };
+ }
+
+ @Override
+ public int size() {
+ return list.size();
+ }
+ };
+ }
+
+ @Override
+ public DataHandler put(String key, DataHandler value) {
+ Iterator<Attachment> i = list.iterator();
+ DataHandler ret = null;
+ while (i.hasNext()) {
+ Attachment a = i.next();
+ if (a.getId().equals(key)) {
+ i.remove();
+ ret = a.getDataHandler();
+ break;
+ }
+ }
+ list.add(new AttachmentImpl(key, value));
+ return ret;
+ }
+ }
+
+ public static String cleanContentId(String id) {
+ if (id != null) {
+ if (id.startsWith("<")) {
+ // strip <>
+ id = id.substring(1, id.length() - 1);
+ }
+ // strip cid:
+ if (id.startsWith("cid:")) {
+ id = id.substring(4);
+ }
+ // urldecode. Is this bad even without cid:? What does decode do with malformed %-signs, anyhow?
+ try {
+ id = URLDecoder.decode(id, StandardCharsets.UTF_8.name());
+ } catch (UnsupportedEncodingException e) {
+ //ignore, keep id as is
+ }
+ }
+ if (id == null) {
+ //no Content-ID, set cxf default ID
+ id = BODY_ATTACHMENT_ID;
+ }
+ return id;
+ }
+
+ static String getHeaderValue(List<String> v) {
+ if (v != null && !v.isEmpty()) {
+ return v.get(0);
+ }
+ return null;
+ }
+ static String getHeaderValue(List<String> v, String delim) {
+ if (v != null && !v.isEmpty()) {
+ return String.join(delim, v);
+ }
+ return null;
+ }
+ static String getHeader(Map<String, List<String>> headers, String h) {
+ return getHeaderValue(headers.get(h));
+ }
+ static String getHeader(Map<String, List<String>> headers, String h, String delim) {
+ return getHeaderValue(headers.get(h), delim);
+ }
+ public static Attachment createAttachment(InputStream stream, Map<String, List<String>> headers)
+ throws IOException {
+
+ String id = cleanContentId(getHeader(headers, "Content-ID"));
+
+ AttachmentImpl att = new AttachmentImpl(id);
+
+ final String ct = getHeader(headers, "Content-Type");
+ String cd = getHeader(headers, "Content-Disposition");
+ String fileName = getContentDispositionFileName(cd);
+
+ String encoding = null;
+
+ for (Map.Entry<String, List<String>> e : headers.entrySet()) {
+ String name = e.getKey();
+ if ("Content-Transfer-Encoding".equalsIgnoreCase(name)) {
+ encoding = getHeader(headers, name);
+ if (BINARY.equalsIgnoreCase(encoding)) {
+ att.setXOP(true);
+ }
+ }
+ att.setHeader(name, getHeaderValue(e.getValue()));
+ }
+ if (encoding == null) {
+ encoding = BINARY;
+ }
+ InputStream ins = decode(stream, encoding);
+ if (ins != stream) {
+ headers.remove("Content-Transfer-Encoding");
+ }
+ DataSource source = new AttachmentDataSource(ct, ins);
+ if (!StringUtils.isEmpty(fileName)) {
+ ((AttachmentDataSource)source).setName(FileUtils.stripPath(fileName));
+ }
+ att.setDataHandler(new DataHandler(source));
+ return att;
+ }
+
+ static String getContentDispositionFileName(String cd) {
+ if (StringUtils.isEmpty(cd)) {
+ return null;
+ }
+ ContentDisposition c = new ContentDisposition(cd);
+ String s = c.getParameter("filename");
+ if (s == null) {
+ s = c.getParameter("name");
+ }
+ return s;
+ }
+
+ public static InputStream decode(InputStream in, String encoding) throws IOException {
+ if (encoding == null) {
+ return in;
+ }
+ encoding = encoding.toLowerCase();
+
+ // some encodings are just pass-throughs, with no real decoding.
+ if (BINARY.equals(encoding)
+ || "7bit".equals(encoding)
+ || "8bit".equals(encoding)) {
+ return in;
+ } else if ("base64".equals(encoding)) {
+ return new Base64DecoderStream(in);
+ } else if ("quoted-printable".equals(encoding)) {
+ return new QuotedPrintableDecoderStream(in);
+ } else {
+ throw new IOException("Unknown encoding " + encoding);
+ }
+ }
+ public static boolean isTypeSupported(String contentType, List<String> types) {
+ if (contentType == null) {
+ return false;
+ }
+ contentType = contentType.toLowerCase();
+ for (String s : types) {
+ if (contentType.indexOf(s) != -1) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static Attachment createMtomAttachment(boolean isXop, String mimeType, String elementNS,
+ byte[] data, int offset, int length, int threshold) {
+ if (!isXop || length <= threshold) {
+ return null;
+ }
+ if (mimeType == null) {
+ mimeType = "application/octet-stream";
+ }
+
+ ByteDataSource source = new ByteDataSource(data, offset, length);
+ source.setContentType(mimeType);
+ DataHandler handler = new DataHandler(source);
+
+ String id;
+ try {
+ id = AttachmentUtil.createContentID(elementNS);
+ } catch (UnsupportedEncodingException e) {
+ throw new Fault(e);
+ }
+ AttachmentImpl att = new AttachmentImpl(id, handler);
+ att.setXOP(isXop);
+ return att;
+ }
+
+ public static Attachment createMtomAttachmentFromDH(
+ boolean isXop, DataHandler handler, String elementNS, int threshold) {
+ if (!isXop) {
+ return null;
+ }
+
+ // The following is just wrong. Even if the DataHandler has a stream, we should still
+ // apply the threshold.
+ try {
+ DataSource ds = handler.getDataSource();
+ if (ds instanceof FileDataSource) {
+ FileDataSource fds = (FileDataSource)ds;
+ File file = fds.getFile();
+ if (file.length() < threshold) {
+ return null;
+ }
+ } else if (ds.getClass().getName().endsWith("ObjectDataSource")) {
+ Object o = handler.getContent();
+ if (o instanceof String
+ && ((String)o).length() < threshold) {
+ return null;
+ } else if (o instanceof byte[] && ((byte[])o).length < threshold) {
+ return null;
+ }
+ }
+ } catch (IOException e1) {
+ // ignore, just do the normal attachment thing
+ }
+
+ String id;
+ try {
+ id = AttachmentUtil.createContentID(elementNS);
+ } catch (UnsupportedEncodingException e) {
+ throw new Fault(e);
+ }
+ AttachmentImpl att = new AttachmentImpl(id, handler);
+ if (!StringUtils.isEmpty(handler.getName())) {
+ //set Content-Disposition attachment header if filename isn't null
+ String file = handler.getName();
+ File f = new File(file);
+ if (f.exists() && f.isFile()) {
+ file = f.getName();
+ }
+ att.setHeader("Content-Disposition", "attachment;name=\"" + file + "\"");
+ }
+ att.setXOP(isXop);
+ return att;
+ }
+
+ public static DataSource getAttachmentDataSource(String contentId, Collection<Attachment> atts) {
+ // Is this right? - DD
+ if (contentId.startsWith("cid:")) {
+ try {
+ contentId = URLDecoder.decode(contentId.substring(4), StandardCharsets.UTF_8.name());
+ } catch (UnsupportedEncodingException ue) {
+ contentId = contentId.substring(4);
+ }
+ return loadDataSource(contentId, atts);
+ } else if (contentId.indexOf("://") == -1) {
+ return loadDataSource(contentId, atts);
+ } else {
+ try {
+ return new URLDataSource(new URL(contentId));
+ } catch (MalformedURLException e) {
+ throw new Fault(e);
+ }
+ }
+
+ }
+
+ private static DataSource loadDataSource(String contentId, Collection<Attachment> atts) {
+ return new LazyDataSource(contentId, atts);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/Base64DecoderStream.java b/transform/src/patch/java/org/apache/cxf/attachment/Base64DecoderStream.java
new file mode 100644
index 0000000..134553f
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/Base64DecoderStream.java
@@ -0,0 +1,196 @@
+/**
+ * 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.cxf.attachment;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.cxf.common.util.Base64Exception;
+import org.apache.cxf.common.util.Base64Utility;
+
+/**
+ * An implementation of a FilterInputStream that decodes the
+ * stream data in BASE64 encoding format. This version does the
+ * decoding "on the fly" rather than decoding a single block of
+ * data. Since this version is intended for use by the MimeUtilty class,
+ * it also handles line breaks in the encoded data.
+ */
+public class Base64DecoderStream extends FilterInputStream {
+
+ static final String MAIL_BASE64_IGNOREERRORS = "mail.mime.base64.ignoreerrors";
+
+ // number of decodeable units we'll try to process at one time. We'll attempt to read that much
+ // data from the input stream and decode in blocks.
+ static final int BUFFERED_UNITS = 2000;
+
+ // can be overridden by a system property.
+ protected boolean ignoreErrors;
+
+ // buffer for reading in chars for decoding (which can support larger bulk reads)
+ protected char[] encodedChars = new char[BUFFERED_UNITS * 4];
+ // a buffer for one decoding unit's worth of data (3 bytes).
+ protected byte[] decodedChars;
+ // count of characters in the buffer
+ protected int decodedCount;
+ // index of the next decoded character
+ protected int decodedIndex;
+
+
+ public Base64DecoderStream(InputStream in) {
+ super(in);
+ }
+
+ /**
+ * Test for the existance of decoded characters in our buffer
+ * of decoded data.
+ *
+ * @return True if we currently have buffered characters.
+ */
+ private boolean dataAvailable() {
+ return decodedCount != 0;
+ }
+
+ /**
+ * Decode a requested number of bytes of data into a buffer.
+ *
+ * @return true if we were able to obtain more data, false otherwise.
+ */
+ private boolean decodeStreamData() throws IOException {
+ decodedIndex = 0;
+
+ // fill up a data buffer with input data
+ int readCharacters = fillEncodedBuffer();
+
+ if (readCharacters > 0) {
+ try {
+ decodedChars = Base64Utility.decodeChunk(encodedChars, 0, readCharacters);
+ } catch (Base64Exception e) {
+ throw new IOException(e);
+ }
+ decodedCount = decodedChars.length;
+ return true;
+ }
+ return false;
+ }
+
+
+ /**
+ * Retrieve a single byte from the decoded characters buffer.
+ *
+ * @return The decoded character or -1 if there was an EOF condition.
+ */
+ private int getByte() throws IOException {
+ if (!dataAvailable() && !decodeStreamData()) {
+ return -1;
+ }
+ decodedCount--;
+ // we need to ensure this doesn't get sign extended
+ return decodedChars[decodedIndex++] & 0xff;
+ }
+
+ private int getBytes(byte[] data, int offset, int length) throws IOException {
+
+ int readCharacters = 0;
+ while (length > 0) {
+ // need data? Try to get some
+ if (!dataAvailable() && !decodeStreamData()) {
+ // if we can't get this, return a count of how much we did get (which may be -1).
+ return readCharacters > 0 ? readCharacters : -1;
+ }
+
+ // now copy some of the data from the decoded buffer to the target buffer
+ int copyCount = Math.min(decodedCount, length);
+ System.arraycopy(decodedChars, decodedIndex, data, offset, copyCount);
+ decodedIndex += copyCount;
+ decodedCount -= copyCount;
+ offset += copyCount;
+ length -= copyCount;
+ readCharacters += copyCount;
+ }
+ return readCharacters;
+ }
+
+
+ /**
+ * Fill our buffer of input characters for decoding from the
+ * stream. This will attempt read a full buffer, but will
+ * terminate on an EOF or read error. This will filter out
+ * non-Base64 encoding chars and will only return a valid
+ * multiple of 4 number of bytes.
+ *
+ * @return The count of characters read.
+ */
+ private int fillEncodedBuffer() throws IOException {
+ int readCharacters = 0;
+
+ while (true) {
+ // get the next character from the stream
+ int ch = in.read();
+ // did we hit an EOF condition?
+ if (ch == -1) {
+ // now check to see if this is normal, or potentially an error
+ // if we didn't get characters as a multiple of 4, we may need to complain about this.
+ if ((readCharacters % 4) != 0) {
+ throw new IOException("Base64 encoding error, data truncated: " + readCharacters + " "
+ + new String(encodedChars, 0, readCharacters));
+ }
+ // return the count.
+ return readCharacters;
+ } else if (Base64Utility.isValidBase64(ch)) {
+ // if this character is valid in a Base64 stream, copy it to the buffer.
+ encodedChars[readCharacters++] = (char)ch;
+ // if we've filled up the buffer, time to quit.
+ if (readCharacters >= encodedChars.length) {
+ return readCharacters;
+ }
+ }
+
+ // we're filtering out whitespace and CRLF characters, so just ignore these
+ }
+ }
+
+
+ // in order to function as a filter, these streams need to override the different
+ // read() signature.
+
+ @Override
+ public int read() throws IOException {
+ return getByte();
+ }
+
+
+ @Override
+ public int read(byte [] buffer, int offset, int length) throws IOException {
+ return getBytes(buffer, offset, length);
+ }
+
+
+ @Override
+ public boolean markSupported() {
+ return false;
+ }
+
+
+ @Override
+ public int available() throws IOException {
+ return ((in.available() / 4) * 3) + decodedCount;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/ContentDisposition.java b/transform/src/patch/java/org/apache/cxf/attachment/ContentDisposition.java
new file mode 100644
index 0000000..f9d4524
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/ContentDisposition.java
@@ -0,0 +1,144 @@
+/**
+ * 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.cxf.attachment;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ContentDisposition {
+ private static final String CD_HEADER_PARAMS_EXPRESSION =
+ "[\\w-]++( )?\\*?=( )?((\"[^\"]++\")|([^;]+))";
+ private static final Pattern CD_HEADER_PARAMS_PATTERN =
+ Pattern.compile(CD_HEADER_PARAMS_EXPRESSION);
+
+ private static final String CD_HEADER_EXT_PARAMS_EXPRESSION =
+ "(?i)(UTF-8|ISO-8859-1)''((?:%[0-9a-f]{2}|\\S)+)";
+ private static final Pattern CD_HEADER_EXT_PARAMS_PATTERN =
+ Pattern.compile(CD_HEADER_EXT_PARAMS_EXPRESSION);
+ private static final Pattern CODEPOINT_ENCODED_VALUE_PATTERN = Pattern.compile("&#[0-9]{4};|\\S");
+
+ private static final String FILE_NAME = "filename";
+
+ private String value;
+ private String type;
+ private Map<String, String> params = new LinkedHashMap<>();
+
+ public ContentDisposition(String value) {
+ this.value = value;
+
+ String tempValue = value;
+
+ int index = tempValue.indexOf(';');
+ if (index > 0 && (tempValue.indexOf('=') >= index)) {
+ type = tempValue.substring(0, index).trim();
+ tempValue = tempValue.substring(index + 1);
+ }
+
+ String extendedFilename = null;
+ Matcher m = CD_HEADER_PARAMS_PATTERN.matcher(tempValue);
+ while (m.find()) {
+ final String paramName;
+ String paramValue = "";
+
+ String groupValue = m.group().trim();
+ int eqIndex = groupValue.indexOf('=');
+ if (eqIndex > 0) {
+ paramName = groupValue.substring(0, eqIndex).trim();
+ if (eqIndex + 1 != groupValue.length()) {
+ paramValue = groupValue.substring(eqIndex + 1).trim().replace("\"", "");
+ }
+ } else {
+ paramName = groupValue;
+ }
+ // filename* looks like the only CD param that is human readable
+ // and worthy of the extended encoding support. Other parameters
+ // can be supported if needed, see the complete list below
+ /*
+ http://www.iana.org/assignments/cont-disp/cont-disp.xhtml#cont-disp-2
+
+ filename name to be used when creating file [RFC2183]
+ creation-date date when content was created [RFC2183]
+ modification-date date when content was last modified [RFC2183]
+ read-date date when content was last read [RFC2183]
+ size approximate size of content in octets [RFC2183]
+ name original field name in form [RFC2388]
+ voice type or use of audio content [RFC2421]
+ handling whether or not processing is required [RFC3204]
+ */
+ if ("filename*".equalsIgnoreCase(paramName)) {
+ // try to decode the value if it matches the spec
+ try {
+ Matcher matcher = CD_HEADER_EXT_PARAMS_PATTERN.matcher(paramValue);
+ if (matcher.matches()) {
+ String encodingScheme = matcher.group(1);
+ String encodedValue = matcher.group(2);
+ paramValue = Rfc5987Util.decode(encodedValue, encodingScheme);
+ extendedFilename = paramValue;
+ }
+ } catch (UnsupportedEncodingException e) {
+ // would be odd not to support UTF-8 or 8859-1
+ }
+ } else if (FILE_NAME.equalsIgnoreCase(paramName) && paramValue.contains("&#")) {
+ Matcher matcher = CODEPOINT_ENCODED_VALUE_PATTERN.matcher(paramValue);
+ StringBuilder sb = new StringBuilder();
+ while (matcher.find()) {
+ String matched = matcher.group();
+ if (matched.startsWith("&#")) {
+ int codePoint = Integer.parseInt(matched.substring(2, 6));
+ sb.append(Character.toChars(codePoint));
+ } else {
+ sb.append(matched.charAt(0));
+ }
+ }
+ if (sb.length() > 0) {
+ paramValue = sb.toString();
+ }
+ }
+ params.put(paramName.toLowerCase(), paramValue);
+ }
+ if (extendedFilename != null) {
+ params.put(FILE_NAME, extendedFilename);
+ }
+ }
+
+ public String getType() {
+ return type;
+ }
+
+ public String getFilename() {
+ return params.get(FILE_NAME);
+ }
+
+ public String getParameter(String name) {
+ return params.get(name);
+ }
+
+ public Map<String, String> getParameters() {
+ return Collections.unmodifiableMap(params);
+ }
+
+ public String toString() {
+ return value;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/LazyAttachmentCollection.java b/transform/src/patch/java/org/apache/cxf/attachment/LazyAttachmentCollection.java
new file mode 100644
index 0000000..8dd4ace
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/LazyAttachmentCollection.java
@@ -0,0 +1,362 @@
+/**
+ * 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.cxf.attachment;
+
+import java.io.IOException;
+import java.util.AbstractCollection;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.activation.DataHandler;
+
+import org.apache.cxf.message.Attachment;
+
+public class LazyAttachmentCollection
+ implements Collection<Attachment> {
+
+ private AttachmentDeserializer deserializer;
+ private final List<Attachment> attachments = new ArrayList<>();
+ private final int maxAttachmentCount;
+
+ public LazyAttachmentCollection(AttachmentDeserializer deserializer, int maxAttachmentCount) {
+ super();
+ this.deserializer = deserializer;
+ this.maxAttachmentCount = maxAttachmentCount;
+ }
+
+ public List<Attachment> getLoadedAttachments() {
+ return attachments;
+ }
+
+ private void loadAll() {
+ try {
+ Attachment a = deserializer.readNext();
+ int count = 0;
+ while (a != null) {
+ attachments.add(a);
+ count++;
+ if (count > maxAttachmentCount) {
+ throw new IOException("The message contains more attachments than are permitted");
+ }
+ a = deserializer.readNext();
+ }
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ /**
+ * Check for more attachments by attempting to deserialize the next attachment.
+ *
+ * @param shouldLoadNew if <i>false</i>, the "loaded attachments" List will not be changed.
+ * @return there is more attachment or not
+ * @throws IOException
+ */
+ public boolean hasNext(boolean shouldLoadNew) throws IOException {
+ if (shouldLoadNew) {
+ Attachment a = deserializer.readNext();
+ if (a != null) {
+ attachments.add(a);
+ return true;
+ }
+ return false;
+ }
+ return deserializer.hasNext();
+ }
+
+ public boolean hasNext() throws IOException {
+ return hasNext(true);
+ }
+ public Iterator<Attachment> iterator() {
+ return new Iterator<Attachment>() {
+ int current;
+ boolean removed;
+
+ public boolean hasNext() {
+ if (attachments.size() > current) {
+ return true;
+ }
+
+ // check if there is another attachment
+ try {
+ Attachment a = deserializer.readNext();
+ if (a == null) {
+ return false;
+ }
+ attachments.add(a);
+ return true;
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public Attachment next() {
+ Attachment a = attachments.get(current);
+ current++;
+ removed = false;
+ return a;
+ }
+
+ @Override
+ public void remove() {
+ if (removed) {
+ throw new IllegalStateException();
+ }
+ attachments.remove(--current);
+ removed = true;
+ }
+
+ };
+ }
+
+ public int size() {
+ loadAll();
+
+ return attachments.size();
+ }
+
+ public boolean add(Attachment arg0) {
+ return attachments.add(arg0);
+ }
+
+ public boolean addAll(Collection<? extends Attachment> arg0) {
+ return attachments.addAll(arg0);
+ }
+
+ public void clear() {
+ attachments.clear();
+ }
+
+ public boolean contains(Object arg0) {
+ return attachments.contains(arg0);
+ }
+
+ public boolean containsAll(Collection<?> arg0) {
+ return attachments.containsAll(arg0);
+ }
+
+ public boolean isEmpty() {
+ if (attachments.isEmpty()) {
+ return !iterator().hasNext();
+ }
+ return attachments.isEmpty();
+ }
+
+ public boolean remove(Object arg0) {
+ return attachments.remove(arg0);
+ }
+
+ public boolean removeAll(Collection<?> arg0) {
+ return attachments.removeAll(arg0);
+ }
+
+ public boolean retainAll(Collection<?> arg0) {
+ return attachments.retainAll(arg0);
+ }
+
+ public Object[] toArray() {
+ loadAll();
+
+ return attachments.toArray();
+ }
+
+ public <T> T[] toArray(T[] arg0) {
+ loadAll();
+
+ return attachments.toArray(arg0);
+ }
+
+ public Map<String, DataHandler> createDataHandlerMap() {
+ return new LazyAttachmentMap(this);
+ }
+
+ private static class LazyAttachmentMap implements Map<String, DataHandler> {
+ LazyAttachmentCollection collection;
+
+ LazyAttachmentMap(LazyAttachmentCollection c) {
+ collection = c;
+ }
+
+ public void clear() {
+ collection.clear();
+ }
+
+ public boolean containsKey(Object key) {
+ Iterator<Attachment> it = collection.iterator();
+ while (it.hasNext()) {
+ Attachment at = it.next();
+ if (key.equals(at.getId())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public boolean containsValue(Object value) {
+ Iterator<Attachment> it = collection.iterator();
+ while (it.hasNext()) {
+ Attachment at = it.next();
+ if (value.equals(at.getDataHandler())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public DataHandler get(Object key) {
+ Iterator<Attachment> it = collection.iterator();
+ while (it.hasNext()) {
+ Attachment at = it.next();
+ if (key.equals(at.getId())) {
+ return at.getDataHandler();
+ }
+ }
+ return null;
+ }
+
+ public boolean isEmpty() {
+ return collection.isEmpty();
+ }
+ public int size() {
+ return collection.size();
+ }
+
+ public DataHandler remove(Object key) {
+ Iterator<Attachment> it = collection.iterator();
+ while (it.hasNext()) {
+ Attachment at = it.next();
+ if (key.equals(at.getId())) {
+ collection.remove(at);
+ return at.getDataHandler();
+ }
+ }
+ return null;
+ }
+ public DataHandler put(String key, DataHandler value) {
+ Attachment at = new AttachmentImpl(key, value);
+ collection.add(at);
+ return value;
+ }
+
+ public void putAll(Map<? extends String, ? extends DataHandler> t) {
+ for (Map.Entry<? extends String, ? extends DataHandler> ent : t.entrySet()) {
+ put(ent.getKey(), ent.getValue());
+ }
+ }
+
+
+ public Set<Map.Entry<String, DataHandler>> entrySet() {
+ return new AbstractSet<Map.Entry<String, DataHandler>>() {
+ public Iterator<Map.Entry<String, DataHandler>> iterator() {
+ return new Iterator<Map.Entry<String, DataHandler>>() {
+ Iterator<Attachment> it = collection.iterator();
+ public boolean hasNext() {
+ return it.hasNext();
+ }
+ public Map.Entry<String, DataHandler> next() {
+ return new Map.Entry<String, DataHandler>() {
+ Attachment at = it.next();
+ public String getKey() {
+ return at.getId();
+ }
+ public DataHandler getValue() {
+ return at.getDataHandler();
+ }
+ public DataHandler setValue(DataHandler value) {
+ if (at instanceof AttachmentImpl) {
+ DataHandler h = at.getDataHandler();
+ ((AttachmentImpl)at).setDataHandler(value);
+ return h;
+ }
+ throw new UnsupportedOperationException();
+ }
+ };
+ }
+ @Override
+ public void remove() {
+ it.remove();
+ }
+ };
+ }
+ public int size() {
+ return collection.size();
+ }
+ };
+ }
+
+ public Set<String> keySet() {
+ return new AbstractSet<String>() {
+ public Iterator<String> iterator() {
+ return new Iterator<String>() {
+ Iterator<Attachment> it = collection.iterator();
+ public boolean hasNext() {
+ return it.hasNext();
+ }
+
+ public String next() {
+ return it.next().getId();
+ }
+
+ @Override
+ public void remove() {
+ it.remove();
+ }
+ };
+ }
+
+ public int size() {
+ return collection.size();
+ }
+ };
+ }
+
+
+ public Collection<DataHandler> values() {
+ return new AbstractCollection<DataHandler>() {
+ public Iterator<DataHandler> iterator() {
+ return new Iterator<DataHandler>() {
+ Iterator<Attachment> it = collection.iterator();
+ public boolean hasNext() {
+ return it.hasNext();
+ }
+ public DataHandler next() {
+ return it.next().getDataHandler();
+ }
+ @Override
+ public void remove() {
+ it.remove();
+ }
+ };
+ }
+
+ public int size() {
+ return collection.size();
+ }
+ };
+ }
+
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/attachment/MimeBodyPartInputStream.java b/transform/src/patch/java/org/apache/cxf/attachment/MimeBodyPartInputStream.java
new file mode 100644
index 0000000..ab80b89
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/attachment/MimeBodyPartInputStream.java
@@ -0,0 +1,275 @@
+/**
+ * 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.cxf.attachment;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+
+public class MimeBodyPartInputStream extends InputStream {
+
+ PushbackInputStream inStream;
+
+ boolean boundaryFound;
+ int pbAmount;
+ byte[] boundary;
+ byte[] boundaryBuffer;
+
+ private boolean closed;
+
+ public MimeBodyPartInputStream(PushbackInputStream inStreamParam,
+ byte[] boundaryParam,
+ int pbsize) {
+ super();
+ this.inStream = inStreamParam;
+ this.boundary = boundaryParam;
+ this.pbAmount = pbsize;
+ }
+
+ @Override
+ public int read(byte[] buf, int origOff, int origLen) throws IOException {
+ byte[] b = buf;
+ int off = origOff;
+ int len = origLen;
+ if (boundaryFound || closed) {
+ return -1;
+ }
+ if ((off < 0) || (off > b.length) || (len < 0)
+ || ((off + len) > b.length) || ((off + len) < 0)) {
+
+ throw new IndexOutOfBoundsException();
+ }
+ if (len == 0) {
+ return 0;
+ }
+ boolean bufferCreated = false;
+ if (len < boundary.length * 2) {
+ //buffer is too short to detect boundaries with it. We'll need to create a larger buffer
+ bufferCreated = true;
+ if (boundaryBuffer == null) {
+ boundaryBuffer = new byte[boundary.length * 2];
+ }
+ b = boundaryBuffer;
+ off = 0;
+ len = boundaryBuffer.length;
+ }
+ if (len > pbAmount) {
+ len = pbAmount; //can only pushback that much so make sure we can
+ }
+ int read = 0;
+ int idx = 0;
+ while (read >= 0 && idx < len && idx < (boundary.length * 2)) {
+ //make sure we read enough to detect the boundary
+ read = inStream.read(b, off + idx, len - idx);
+ if (read != -1) {
+ idx += read;
+ }
+ }
+ if (read == -1 && idx == 0) {
+ return -1;
+ }
+ len = idx;
+
+ int i = processBuffer(b, off, len);
+ if (bufferCreated && i > 0) {
+ // read more than we need, push it back
+ if (origLen >= i) {
+ System.arraycopy(b, 0, buf, origOff, i);
+ } else {
+ System.arraycopy(b, 0, buf, origOff, origLen);
+ inStream.unread(b, origLen, i - origLen);
+ i = origLen;
+ }
+ } else if (i == 0 && boundaryFound) {
+ return -1;
+ }
+
+ return i;
+ }
+
+ //Has Data after encountering CRLF
+ private boolean hasData(byte[] b, int initialPointer, int pointer, int off, int len)
+ throws IOException {
+ if (pointer < (off + len)) {
+ return true;
+ } else if (pointer >= 1000000000) {
+ inStream.unread(b, initialPointer, (off + len) - initialPointer);
+ return false;
+ } else {
+ int x = inStream.read();
+ if (x != -1) {
+ inStream.unread(x);
+ inStream.unread(b, initialPointer, (off + len) - initialPointer);
+ return false;
+ }
+ return true;
+ }
+ }
+
+ protected int processBuffer(byte[] buffer, int off, int len) throws IOException {
+ for (int i = off; i < (off + len); i++) {
+ boolean needUnread0d0a = false;
+ int value = buffer[i];
+ int initialI = i;
+ if (value == 13) {
+ if (!hasData(buffer, initialI, initialI + 1, off, len)) {
+ return initialI - off;
+ }
+ value = buffer[initialI + 1];
+ if (value != 10) {
+ continue;
+ }
+ if (!hasData(buffer, initialI, initialI + 2, off, len)) {
+ return initialI - off;
+ }
+ value = buffer[initialI + 2];
+ if ((byte) value != boundary[0]) {
+ i++;
+ continue;
+ }
+ needUnread0d0a = true;
+ i += 2; //i after this points to boundary[0] element
+ } else if (value != boundary[0]) {
+ continue;
+ }
+
+ int boundaryIndex = 0;
+ while ((boundaryIndex < boundary.length) && (value == boundary[boundaryIndex])) {
+ if (!hasData(buffer, initialI, i + 1, off, len)) {
+ return initialI - off;
+ }
+ value = buffer[++i];
+ boundaryIndex++;
+ }
+ if (boundaryIndex == boundary.length) {
+ // read the end of line character
+ if (initialI != off) {
+ i = 1000000000;
+ }
+ if (initialI - off != 0
+ && !hasData(buffer, initialI, i + 1, off, len)) {
+ return initialI - off;
+ }
+ boundaryFound = true;
+ int j = i + 1;
+ if (j < len && buffer[j] == 45 && value == 45) {
+ // Last mime boundary should have a succeeding "--"
+ // as we are on it, read the terminating CRLF
+ i += 2;
+ //last mime boundary
+ }
+
+ //boundary matched (may or may not be last mime boundary)
+ int processed = initialI - off;
+ if ((len - ((i - off) + 2)) > 0) {
+ inStream.unread(buffer, i + 2, len - (i + 2) + off);
+ }
+ return processed;
+ }
+
+ // Boundary not found. Restoring bytes skipped.
+ // write first skipped byte, push back the rest
+ if (value != -1) { //pushing back first byte of boundary
+ // Stream might have ended
+ i--;
+ }
+ if (needUnread0d0a) { //Pushing all, returning 13
+ i = i - boundaryIndex;
+ i--; //for 10
+// value = 13;
+ } else {
+ i = i - boundaryIndex;
+ i++;
+// value = boundary[0];
+ }
+ }
+ return len;
+ }
+
+ public int read() throws IOException {
+ boolean needUnread0d0a = false;
+ if (boundaryFound) {
+ return -1;
+ }
+
+ // read the next value from stream
+ int value = inStream.read();
+ // A problem occurred because all the mime parts tends to have a /r/n
+ // at the end. Making it hard to transform them to correct
+ // DataSources.
+ // This logic introduced to handle it
+ if (value == 13) {
+ value = inStream.read();
+ if (value != 10) {
+ inStream.unread(value);
+ return 13;
+ }
+ value = inStream.read();
+ if ((byte) value != boundary[0]) {
+ inStream.unread(value);
+ inStream.unread(10);
+ return 13;
+ }
+ needUnread0d0a = true;
+ } else if ((byte) value != boundary[0]) {
+ return value;
+ }
+ // read value is the first byte of the boundary. Start matching the
+ // next characters to find a boundary
+ int boundaryIndex = 0;
+ while ((boundaryIndex < boundary.length) && ((byte) value == boundary[boundaryIndex])) {
+ value = inStream.read();
+ boundaryIndex++;
+ }
+ if (boundaryIndex == boundary.length) {
+ // boundary found
+ boundaryFound = true;
+ int dashNext = inStream.read();
+ // read the end of line character
+ if (dashNext == 45 && value == 45) {
+ // Last mime boundary should have a succeeding "--"
+ // as we are on it, read the terminating CRLF
+ inStream.read();
+ inStream.read();
+ }
+ return -1;
+ }
+ // Boundary not found. Restoring bytes skipped.
+ // write first skipped byte, push back the rest
+ if (value != -1) {
+ // Stream might have ended
+ inStream.unread(value);
+ }
+ if (needUnread0d0a) {
+ inStream.unread(boundary, 0, boundaryIndex);
+ inStream.unread(10);
+ value = 13;
+ } else {
+ inStream.unread(boundary, 1, boundaryIndex - 1);
+ value = boundary[0];
+ }
+ return value;
+ }
+
+ @Override
+ public void close() throws IOException {
+ this.closed = true;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/CXFBusFactory.java b/transform/src/patch/java/org/apache/cxf/bus/CXFBusFactory.java
new file mode 100644
index 0000000..fb3a833
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/CXFBusFactory.java
@@ -0,0 +1,47 @@
+/**
+ * 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.cxf.bus;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.bus.extension.ExtensionManagerBus;
+
+public class CXFBusFactory extends BusFactory {
+
+ public Bus createBus() {
+ return createBus(new HashMap<>());
+ }
+
+ public Bus createBus(Map<Class<?>, Object> e) {
+ return createBus(e, new HashMap<>());
+ }
+
+ public Bus createBus(Map<Class<?>, Object> e, Map<String, Object> properties) {
+ ExtensionManagerBus bus = new ExtensionManagerBus(e, properties);
+ possiblySetDefaultBus(bus);
+ initializeBus(bus);
+ bus.initialize();
+ return bus;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/blueprint/BundleDelegatingClassLoader.java b/transform/src/patch/java/org/apache/cxf/bus/blueprint/BundleDelegatingClassLoader.java
new file mode 100644
index 0000000..ff957c2
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/blueprint/BundleDelegatingClassLoader.java
@@ -0,0 +1,134 @@
+/**
+ * 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.cxf.bus.blueprint;
+
+import java.io.IOException;
+import java.net.URL;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+
+import org.osgi.framework.Bundle;
+
+/**
+ * A ClassLoader delegating to a given OSGi bundle.
+ */
+public class BundleDelegatingClassLoader extends ClassLoader {
+
+ private final Bundle bundle;
+ private final ClassLoader classLoader;
+
+ public BundleDelegatingClassLoader(Bundle bundle) {
+ this(bundle, null);
+ }
+
+ public BundleDelegatingClassLoader(Bundle bundle, ClassLoader classLoader) {
+ this.bundle = bundle;
+ this.classLoader = classLoader;
+ }
+
+ @Override
+ protected Class<?> findClass(final String name) throws ClassNotFoundException {
+ try {
+ return AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>() {
+ public Class<?> run() throws ClassNotFoundException {
+ return bundle.loadClass(name);
+ }
+ });
+ } catch (PrivilegedActionException e) {
+ Exception cause = e.getException();
+
+ if (cause instanceof ClassNotFoundException) {
+ throw (ClassNotFoundException)cause;
+ }
+ throw (RuntimeException)cause;
+ }
+ }
+
+ @Override
+ protected URL findResource(final String name) {
+ URL resource = AccessController.doPrivileged(new PrivilegedAction<URL>() {
+ public URL run() {
+ return bundle.getResource(name);
+ }
+ });
+ if (classLoader != null && resource == null) {
+ resource = classLoader.getResource(name);
+ }
+ return resource;
+ }
+
+ @Override
+ protected Enumeration<URL> findResources(final String name) throws IOException {
+ Enumeration<URL> urls;
+ try {
+ urls = AccessController.doPrivileged(new PrivilegedExceptionAction<Enumeration<URL>>() {
+ public Enumeration<URL> run() throws IOException {
+ return bundle.getResources(name);
+ }
+
+ });
+ } catch (PrivilegedActionException e) {
+ Exception cause = e.getException();
+
+ if (cause instanceof IOException) {
+ throw (IOException)cause;
+ }
+ throw (RuntimeException)cause;
+ }
+
+ if (urls == null) {
+ urls = Collections.enumeration(new ArrayList<>());
+ }
+
+ return urls;
+ }
+
+ @Override
+ protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+ Class<?> clazz;
+ try {
+ clazz = findClass(name);
+ } catch (ClassNotFoundException cnfe) {
+ if (classLoader != null) {
+ try {
+ clazz = classLoader.loadClass(name);
+ } catch (ClassNotFoundException e) {
+ throw new ClassNotFoundException(name + " from bundle " + bundle.getBundleId()
+ + " (" + bundle.getSymbolicName() + ")", cnfe);
+ }
+ } else {
+ throw new ClassNotFoundException(name + " from bundle " + bundle.getBundleId()
+ + " (" + bundle.getSymbolicName() + ")", cnfe);
+ }
+ }
+ if (resolve) {
+ resolveClass(clazz);
+ }
+ return clazz;
+ }
+
+ public Bundle getBundle() {
+ return bundle;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/blueprint/BusDefinitionParser.java b/transform/src/patch/java/org/apache/cxf/bus/blueprint/BusDefinitionParser.java
new file mode 100644
index 0000000..baf83b7
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/blueprint/BusDefinitionParser.java
@@ -0,0 +1,72 @@
+/**
+ * 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.cxf.bus.blueprint;
+
+
+import org.w3c.dom.Element;
+
+import org.apache.aries.blueprint.ParserContext;
+import org.apache.aries.blueprint.mutable.MutableBeanMetadata;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.configuration.blueprint.AbstractBPBeanDefinitionParser;
+import org.osgi.service.blueprint.reflect.Metadata;
+
+public class BusDefinitionParser
+ extends AbstractBPBeanDefinitionParser {
+
+ public BusDefinitionParser() {
+ }
+
+ public Metadata parse(Element element, ParserContext context) {
+ String bname = element.hasAttribute("bus") ? element.getAttribute("bus") : "cxf";
+ String id = element.hasAttribute("id") ? element.getAttribute("id") : null;
+ MutableBeanMetadata cxfBean = getBus(context, bname);
+ parseAttributes(element, context, cxfBean);
+ parseChildElements(element, context, cxfBean);
+ context.getComponentDefinitionRegistry().removeComponentDefinition(bname);
+ if (!StringUtils.isEmpty(id)) {
+ cxfBean.addProperty("id", createValue(context, id));
+ }
+ return cxfBean;
+ }
+
+ @Override
+ protected void processBusAttribute(Element element, ParserContext ctx,
+ MutableBeanMetadata bean, String val) {
+ //nothing
+ }
+
+ @Override
+ protected boolean hasBusProperty() {
+ return false;
+ }
+
+
+ @Override
+ protected void mapElement(ParserContext ctx, MutableBeanMetadata bean, Element el, String name) {
+ if ("inInterceptors".equals(name) || "inFaultInterceptors".equals(name)
+ || "outInterceptors".equals(name) || "outFaultInterceptors".equals(name)
+ || "features".equals(name)) {
+ bean.addProperty(name, parseListData(ctx, bean, el));
+ } else if ("properties".equals(name)) {
+ bean.addProperty(name, parseMapData(ctx, bean, el));
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/blueprint/ConfigurerImpl.java b/transform/src/patch/java/org/apache/cxf/bus/blueprint/ConfigurerImpl.java
new file mode 100644
index 0000000..37f82fe
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/blueprint/ConfigurerImpl.java
@@ -0,0 +1,180 @@
+/**
+ * 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.cxf.bus.blueprint;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.aries.blueprint.services.ExtendedBlueprintContainer;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.configuration.Configurable;
+import org.apache.cxf.configuration.Configurer;
+import org.osgi.service.blueprint.container.BlueprintContainer;
+import org.osgi.service.blueprint.container.NoSuchComponentException;
+import org.osgi.service.blueprint.reflect.BeanMetadata;
+import org.osgi.service.blueprint.reflect.ComponentMetadata;
+
+/**
+ *
+ */
+public class ConfigurerImpl implements Configurer {
+ private static final Logger LOG = LogUtils.getL7dLogger(ConfigurerImpl.class);
+ BlueprintContainer container;
+
+ private final Map<String, List<MatcherHolder>> wildCardBeanDefinitions
+ = new TreeMap<>();
+
+ static class MatcherHolder implements Comparable<MatcherHolder> {
+ Matcher matcher;
+ String wildCardId;
+ MatcherHolder(String orig, Matcher matcher) {
+ wildCardId = orig;
+ this.matcher = matcher;
+ }
+ @Override
+ public int compareTo(MatcherHolder mh) {
+ int literalCharsLen1 = this.wildCardId.replace("*", "").length();
+ int literalCharsLen2 = mh.wildCardId.replace("*", "").length();
+ // The expression with more literal characters should end up on the top of the list
+ return Integer.compare(literalCharsLen1, literalCharsLen2) * -1;
+ }
+ }
+
+ public ConfigurerImpl(BlueprintContainer con) {
+ container = con;
+ initializeWildcardMap();
+ }
+ private boolean isWildcardBeanName(String bn) {
+ return bn.indexOf('*') != -1 || bn.indexOf('?') != -1
+ || (bn.indexOf('(') != -1 && bn.indexOf(')') != -1);
+ }
+
+ private void initializeWildcardMap() {
+ for (String s : container.getComponentIds()) {
+ if (isWildcardBeanName(s)) {
+ ComponentMetadata cmd = container.getComponentMetadata(s);
+ Class<?> cls = BlueprintBeanLocator.getClassForMetaData(container, cmd);
+ if (cls != null) {
+ final String cid = s.charAt(0) != '*' ? s
+ : "." + s.replaceAll("\\.", "\\."); //old wildcard
+ Matcher matcher = Pattern.compile(cid).matcher("");
+ List<MatcherHolder> m = wildCardBeanDefinitions.get(cls.getName());
+ if (m == null) {
+ m = new ArrayList<>();
+ wildCardBeanDefinitions.put(cls.getName(), m);
+ }
+ MatcherHolder holder = new MatcherHolder(s, matcher);
+ m.add(holder);
+ }
+ }
+ }
+ }
+
+ public void configureBean(Object beanInstance) {
+ configureBean(null, beanInstance, true);
+ }
+
+ public void configureBean(String bn, Object beanInstance) {
+ configureBean(bn, beanInstance, true);
+ }
+ public synchronized void configureBean(String bn, Object beanInstance, boolean checkWildcards) {
+ if (null == bn) {
+ bn = getBeanName(beanInstance);
+ }
+
+ if (null == bn) {
+ return;
+ }
+ if (checkWildcards) {
+ configureWithWildCard(bn, beanInstance);
+ }
+
+ if (container instanceof ExtendedBlueprintContainer) {
+ try {
+ final ComponentMetadata cm = container.getComponentMetadata(bn);
+ if (cm instanceof BeanMetadata) {
+ ((ExtendedBlueprintContainer)container).injectBeanInstance((BeanMetadata)cm, beanInstance);
+ }
+ } catch (NoSuchComponentException nsce) {
+ }
+ }
+ }
+
+ private void configureWithWildCard(String bn, Object beanInstance) {
+ if (!wildCardBeanDefinitions.isEmpty()) {
+ Class<?> clazz = beanInstance.getClass();
+ while (!Object.class.equals(clazz)) {
+ String className = clazz.getName();
+ List<MatcherHolder> matchers = wildCardBeanDefinitions.get(className);
+ if (matchers != null) {
+ for (MatcherHolder m : matchers) {
+ synchronized (m.matcher) {
+ m.matcher.reset(bn);
+ if (m.matcher.matches()) {
+ configureBean(m.wildCardId, beanInstance, false);
+ return;
+ }
+ }
+ }
+ }
+ clazz = clazz.getSuperclass();
+ }
+ }
+ }
+
+ protected String getBeanName(Object beanInstance) {
+ if (beanInstance instanceof Configurable) {
+ return ((Configurable)beanInstance).getBeanName();
+ }
+ String beanName = null;
+ Method m = null;
+ try {
+ m = beanInstance.getClass().getDeclaredMethod("getBeanName", (Class[])null);
+ } catch (NoSuchMethodException ex) {
+ try {
+ m = beanInstance.getClass().getMethod("getBeanName", (Class[])null);
+ } catch (NoSuchMethodException e) {
+ //ignore
+ }
+ }
+ if (m != null) {
+ try {
+ beanName = (String)(m.invoke(beanInstance));
+ } catch (Exception ex) {
+ LogUtils.log(LOG, Level.WARNING, "ERROR_DETERMINING_BEAN_NAME_EXC", ex);
+ }
+ }
+
+ if (null == beanName) {
+ LogUtils.log(LOG, Level.FINE, "COULD_NOT_DETERMINE_BEAN_NAME_MSG",
+ beanInstance.getClass().getName());
+ }
+
+ return beanName;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/extension/Extension.java b/transform/src/patch/java/org/apache/cxf/bus/extension/Extension.java
new file mode 100644
index 0000000..03f0dc6
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/extension/Extension.java
@@ -0,0 +1,291 @@
+/**
+ * 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.cxf.bus.extension;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.i18n.Message;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.StringUtils;
+
+public class Extension {
+ protected static final Logger LOG = LogUtils.getL7dLogger(Extension.class);
+
+ private static final String PROBLEM_CREATING_EXTENSION_CLASS = "PROBLEM_CREATING_EXTENSION_CLASS";
+
+ protected String className;
+ protected ClassLoader classloader;
+ protected volatile Class<?> clazz;
+ protected volatile Class<?> intf;
+ protected String interfaceName;
+ protected boolean deferred;
+ protected Collection<String> namespaces = new ArrayList<>();
+ protected Object[] args;
+ protected volatile Object obj;
+ protected boolean optional;
+ protected boolean notFound;
+
+
+ public Extension() {
+ }
+
+ public Extension(Class<?> cls, Class<?> inf) {
+ clazz = cls;
+ intf = inf;
+ interfaceName = inf.getName();
+ className = cls.getName();
+ classloader = cls.getClassLoader();
+ }
+ public Extension(Class<?> cls) {
+ clazz = cls;
+ className = cls.getName();
+ classloader = cls.getClassLoader();
+ }
+ public Extension(ClassLoader loader) {
+ classloader = loader;
+ }
+
+ public Extension(Extension ext) {
+ className = ext.className;
+ interfaceName = ext.interfaceName;
+ deferred = ext.deferred;
+ namespaces = ext.namespaces;
+ obj = ext.obj;
+ clazz = ext.clazz;
+ intf = ext.intf;
+ classloader = ext.classloader;
+ args = ext.args;
+ optional = ext.optional;
+ }
+
+ public void setOptional(boolean b) {
+ optional = b;
+ }
+ public boolean isOptional() {
+ return optional;
+ }
+
+ public String getName() {
+ return StringUtils.isEmpty(interfaceName) ? className : interfaceName;
+ }
+ public Object getLoadedObject() {
+ return obj;
+ }
+
+ public Extension cloneNoObject() {
+ Extension ext = new Extension(this);
+ ext.obj = null;
+ ext.clazz = null;
+ ext.intf = null;
+ return ext;
+ }
+
+ public String toString() {
+ StringBuilder buf = new StringBuilder(128);
+ buf.append("class: ");
+ buf.append(className);
+ buf.append(", interface: ");
+ buf.append(interfaceName);
+ buf.append(", deferred: ");
+ buf.append(deferred ? "true" : "false");
+ buf.append(", namespaces: (");
+ int n = 0;
+ for (String ns : namespaces) {
+ if (n > 0) {
+ buf.append(", ");
+ }
+ buf.append(ns);
+ n++;
+ }
+ buf.append(')');
+ return buf.toString();
+ }
+
+ public String getClassname() {
+ return className;
+ }
+
+ public void setClassname(String i) {
+ clazz = null;
+ notFound = false;
+ className = i;
+ }
+
+ public String getInterfaceName() {
+ return interfaceName;
+ }
+
+ public void setInterfaceName(String i) {
+ interfaceName = i;
+ notFound = false;
+ }
+
+ public boolean isDeferred() {
+ return deferred;
+ }
+
+ public void setDeferred(boolean d) {
+ deferred = d;
+ }
+
+ public Collection<String> getNamespaces() {
+ return namespaces;
+ }
+
+ public void setArgs(Object[] a) {
+ args = a;
+ }
+
+ protected Class<?> tryClass(String name, ClassLoader cl) {
+ Throwable origEx = null;
+ if (classloader != null) {
+ try {
+ return classloader.loadClass(name);
+ } catch (Throwable nex) {
+ //ignore, fall into the stuff below
+ //save the exception though as this is likely the important one
+ origEx = nex;
+ }
+ }
+ try {
+ return cl.loadClass(name);
+ } catch (Throwable ex) {
+ try {
+ // using the extension classloader as a fallback
+ return this.getClass().getClassLoader().loadClass(name);
+ } catch (Throwable nex) {
+ notFound = true;
+ if (!optional) {
+ throw new ExtensionException(new Message("PROBLEM_LOADING_EXTENSION_CLASS", LOG, name),
+ origEx != null ? origEx : ex);
+ }
+ }
+ }
+ return null;
+ }
+
+ public Class<?> getClassObject(ClassLoader cl) {
+ if (notFound) {
+ return null;
+ }
+ if (clazz != null) {
+ return clazz;
+ }
+ synchronized (this) {
+ if (clazz == null) {
+ clazz = tryClass(className, cl);
+ }
+ }
+ return clazz;
+ }
+ public Object load(ClassLoader cl, Bus b) {
+ if (obj != null) {
+ return obj;
+ }
+ Class<?> cls = getClassObject(cl);
+ try {
+ if (notFound) {
+ return null;
+ }
+ try {
+ //if there is a Bus constructor, use it.
+ if (b != null && args == null) {
+ Constructor<?> con = cls.getConstructor(Bus.class);
+ obj = con.newInstance(b);
+ return obj;
+ } else if (b != null && args != null) {
+ try {
+ obj = cls.getConstructor(Bus.class, Object[].class).newInstance(b, args);
+ } catch (NoSuchMethodException ex) { // no bus
+ obj = cls.getConstructor(Object[].class).newInstance(args);
+ }
+ return obj;
+ } else if (args != null) {
+ Constructor<?> con = cls.getConstructor(Object[].class);
+ obj = con.newInstance(args);
+ return obj;
+ }
+ } catch (InvocationTargetException ex) {
+ throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()),
+ ex.getCause());
+ } catch (InstantiationException | SecurityException ex) {
+ throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()), ex);
+ } catch (NoSuchMethodException e) {
+ //ignore
+ }
+ obj = cls.getConstructor().newInstance();
+ } catch (ExtensionException ex) {
+ notFound = true;
+ if (!optional) {
+ throw ex;
+ }
+ LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
+ } catch (InvocationTargetException ex) {
+ notFound = true;
+ if (!optional) {
+ throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()),
+ ex.getCause());
+ }
+ LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
+ } catch (NoSuchMethodException ex) {
+ notFound = true;
+ List<Object> a = new ArrayList<>();
+ if (b != null) {
+ a.add(b);
+ }
+ if (args != null) {
+ a.add(args);
+ }
+ if (!optional) {
+ throw new ExtensionException(new Message("PROBLEM_FINDING_CONSTRUCTOR", LOG,
+ cls.getName(), a), ex);
+ }
+ LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
+ } catch (Throwable e) {
+ notFound = true;
+ if (!optional) {
+ throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()), e);
+ }
+ LOG.log(Level.FINE, "Could not load optional extension " + getName(), e);
+ }
+ return obj;
+ }
+
+ public Class<?> loadInterface(ClassLoader cl) {
+ if (intf != null || notFound) {
+ return intf;
+ }
+ synchronized (this) {
+ if (intf == null) {
+ intf = tryClass(interfaceName, cl);
+ }
+ }
+ return intf;
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/extension/ExtensionManagerImpl.java b/transform/src/patch/java/org/apache/cxf/bus/extension/ExtensionManagerImpl.java
new file mode 100644
index 0000000..d4ce0be
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/extension/ExtensionManagerImpl.java
@@ -0,0 +1,381 @@
+/**
+ * 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.cxf.bus.extension;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.injection.ResourceInjector;
+import org.apache.cxf.configuration.ConfiguredBeanLocator;
+import org.apache.cxf.configuration.Configurer;
+import org.apache.cxf.resource.ObjectTypeResolver;
+import org.apache.cxf.resource.ResourceManager;
+import org.apache.cxf.resource.ResourceResolver;
+import org.apache.cxf.resource.SinglePropertyResolver;
+
+public class ExtensionManagerImpl implements ExtensionManager, ConfiguredBeanLocator {
+ public static final String EXTENSIONMANAGER_PROPERTY_NAME = "extensionManager";
+ public static final String ACTIVATION_NAMESPACES_PROPERTY_NAME = "activationNamespaces";
+ public static final String ACTIVATION_NAMESPACES_SETTER_METHOD_NAME = "setActivationNamespaces";
+ public static final String BUS_EXTENSION_RESOURCE = "META-INF/cxf/bus-extensions.txt";
+
+ private final ClassLoader loader;
+ private ResourceManager resourceManager;
+ private Map<String, Extension> all = new ConcurrentHashMap<>();
+ private List<Extension> ordered = new CopyOnWriteArrayList<>();
+ private final Map<Class<?>, Object> activated;
+ private final Bus bus;
+
+ public ExtensionManagerImpl(ClassLoader cl, Map<Class<?>, Object> initialExtensions,
+ ResourceManager rm, Bus b) {
+ this(new String[] {BUS_EXTENSION_RESOURCE},
+ cl, initialExtensions, rm, b);
+ }
+ public ExtensionManagerImpl(String resource,
+ ClassLoader cl,
+ Map<Class<?>, Object> initialExtensions,
+ ResourceManager rm,
+ Bus b) {
+ this(new String[] {resource}, cl, initialExtensions, rm, b);
+ }
+ public ExtensionManagerImpl(String[] resources,
+ ClassLoader cl,
+ Map<Class<?>, Object> initialExtensions,
+ ResourceManager rm,
+ Bus b) {
+
+ loader = cl;
+ bus = b;
+ activated = initialExtensions;
+ resourceManager = rm;
+
+ ResourceResolver extensionManagerResolver =
+ new SinglePropertyResolver(EXTENSIONMANAGER_PROPERTY_NAME, this);
+ resourceManager.addResourceResolver(extensionManagerResolver);
+ resourceManager.addResourceResolver(new ObjectTypeResolver(this));
+
+ load(resources);
+ for (Map.Entry<String, Extension> ext : ExtensionRegistry.getRegisteredExtensions().entrySet()) {
+ if (!all.containsKey(ext.getKey())) {
+ all.put(ext.getKey(), ext.getValue());
+ ordered.add(ext.getValue());
+ }
+ }
+ }
+
+ final void load(String[] resources) {
+ if (resources == null) {
+ return;
+ }
+ try {
+ for (String resource : resources) {
+ load(resource);
+ }
+ } catch (IOException ex) {
+ throw new ExtensionException(ex);
+ }
+ }
+ public void add(Extension ex) {
+ all.put(ex.getName(), ex);
+ ordered.add(ex);
+ }
+
+ public void initialize() {
+ for (Extension e : ordered) {
+ if (!e.isDeferred() && e.getLoadedObject() == null) {
+ loadAndRegister(e);
+ }
+ }
+ }
+
+ public void removeBeansOfNames(List<String> names) {
+ for (String s : names) {
+ Extension ex = all.remove(s);
+ if (ex != null) {
+ ordered.remove(ex);
+ }
+ }
+ }
+ public void activateAll() {
+ for (Extension e : ordered) {
+ if (e.getLoadedObject() == null) {
+ loadAndRegister(e);
+ }
+ }
+ }
+ public <T> void activateAllByType(Class<T> type) {
+ for (Extension e : ordered) {
+ if (e.getLoadedObject() == null) {
+ Class<?> cls = e.getClassObject(loader);
+ if (cls != null && type.isAssignableFrom(cls)) {
+ synchronized (e) {
+ loadAndRegister(e);
+ }
+ }
+ }
+ }
+ }
+
+ public boolean hasBeanOfName(String name) {
+ return all.containsKey(name);
+ }
+
+ final void load(String resource) throws IOException {
+ if (loader != getClass().getClassLoader()) {
+ load(resource, getClass().getClassLoader());
+ }
+ load(resource, loader);
+ }
+ final synchronized void load(String resource, ClassLoader l) throws IOException {
+
+ Enumeration<URL> urls = l.getResources(resource);
+
+ while (urls.hasMoreElements()) {
+ final URL url = urls.nextElement();
+ try (InputStream is = AccessController.doPrivileged(new PrivilegedExceptionAction<InputStream>() {
+ public InputStream run() throws Exception {
+ return url.openStream();
+ }
+ })) {
+ List<Extension> exts = new TextExtensionFragmentParser(loader).getExtensions(is);
+ for (Extension e : exts) {
+ if (loader != l) {
+ e.classloader = l;
+ }
+ if (!all.containsKey(e.getName())) {
+ all.put(e.getName(), e);
+ ordered.add(e);
+ }
+ }
+ } catch (PrivilegedActionException pae) {
+ throw (IOException)pae.getException();
+ }
+ }
+ }
+
+ final void loadAndRegister(Extension e) {
+ Class<?> cls;
+ if (null != e.getInterfaceName() && !"".equals(e.getInterfaceName())) {
+ cls = e.loadInterface(loader);
+ } else {
+ cls = e.getClassObject(loader);
+ }
+ if (null != activated && null != cls && null != activated.get(cls)) {
+ return;
+ }
+
+ synchronized (e) {
+ Object obj = e.load(loader, bus);
+ if (obj == null) {
+ return;
+ }
+
+ if (null != activated) {
+ Configurer configurer = (Configurer)(activated.get(Configurer.class));
+ if (null != configurer) {
+ configurer.configureBean(obj);
+ }
+ }
+
+ // let the object know for which namespaces it has been activated
+ ResourceResolver namespacesResolver = null;
+ if (null != e.getNamespaces()) {
+ namespacesResolver = new SinglePropertyResolver(ACTIVATION_NAMESPACES_PROPERTY_NAME,
+ e.getNamespaces());
+ resourceManager.addResourceResolver(namespacesResolver);
+ }
+
+ // Since we need to support spring2.5 by removing @Resource("activationNamespaces")
+ // Now we call the setActivationNamespaces method directly here
+ if (e.getNamespaces() != null && !e.getNamespaces().isEmpty()) {
+ invokeSetterActivationNSMethod(obj, e.getNamespaces());
+ }
+
+ ResourceInjector injector = new ResourceInjector(resourceManager);
+
+ try {
+ injector.inject(obj);
+ injector.construct(obj);
+ } finally {
+ if (null != namespacesResolver) {
+ resourceManager.removeResourceResolver(namespacesResolver);
+ }
+ }
+
+ if (null != activated) {
+ if (cls == null) {
+ cls = obj.getClass();
+ }
+ activated.put(cls, obj);
+ }
+ }
+ }
+
+ public <T> T getExtension(String name, Class<T> type) {
+ if (name == null) {
+ return null;
+ }
+ Extension e = all.get(name);
+ if (e != null) {
+ Class<?> cls = e.getClassObject(loader);
+ if (cls != null && type.isAssignableFrom(cls)) {
+ synchronized (e) {
+ if (e.getLoadedObject() == null) {
+ loadAndRegister(e);
+ }
+ return type.cast(e.getLoadedObject());
+ }
+ }
+ }
+ return null;
+ }
+
+ private void invokeSetterActivationNSMethod(Object target, Object value) {
+ Class<?> clazz = target.getClass();
+ String methodName = ACTIVATION_NAMESPACES_SETTER_METHOD_NAME;
+ while (clazz != Object.class) {
+ Method[] methods = clazz.getMethods();
+ for (int i = 0; i < methods.length; i++) {
+ Method method = methods[i];
+ Class<?>[] params = method.getParameterTypes();
+ if (method.getName().equals(methodName) && params.length == 1) {
+ Class<?> paramType = params[0];
+ if (paramType.isInstance(value)) {
+ try {
+ method.invoke(target, new Object[] {value});
+ } catch (Exception e) {
+ // do nothing here
+ }
+ return;
+ }
+ }
+ }
+ clazz = clazz.getSuperclass();
+ }
+ }
+ public List<String> getBeanNamesOfType(Class<?> type) {
+ List<String> ret = new LinkedList<>();
+ for (Extension ex : ordered) {
+ Class<?> cls = ex.getClassObject(loader);
+ if (cls != null && type.isAssignableFrom(cls)) {
+ synchronized (ex) {
+ ret.add(ex.getName());
+ }
+ }
+ }
+ return ret;
+ }
+ public <T> T getBeanOfType(String name, Class<T> type) {
+ if (name == null) {
+ return null;
+ }
+ Extension ex = all.get(name);
+ if (ex != null) {
+ if (ex.getLoadedObject() == null) {
+ loadAndRegister(ex);
+ }
+ return type.cast(ex.getLoadedObject());
+ }
+ return null;
+ }
+ public <T> Collection<? extends T> getBeansOfType(Class<T> type) {
+ List<T> ret = new LinkedList<>();
+ Extension ext = all.get(type.getName());
+ if (ext != null) {
+ Class<?> cls = ext.getClassObject(loader);
+ if (cls != null && type.isAssignableFrom(cls)) {
+ synchronized (ext) {
+ if (ext.getLoadedObject() == null) {
+ loadAndRegister(ext);
+ }
+ if (ext.getLoadedObject() != null) {
+ ret.add(type.cast(ext.getLoadedObject()));
+ }
+ }
+ }
+ }
+ for (Extension ex : ordered) {
+ if (ex != ext) {
+ Class<?> cls = ex.getClassObject(loader);
+ if (cls != null && type.isAssignableFrom(cls)) {
+ synchronized (ex) {
+ if (ex.getLoadedObject() == null) {
+ loadAndRegister(ex);
+ }
+ if (ex.getLoadedObject() != null) {
+ ret.add(type.cast(ex.getLoadedObject()));
+ }
+ }
+ }
+ }
+ }
+ return ret;
+ }
+ public <T> boolean loadBeansOfType(Class<T> type, BeanLoaderListener<T> listener) {
+ boolean loaded = false;
+ for (Extension ex : ordered) {
+ Class<?> cls = ex.getClassObject(loader);
+ if (cls != null
+ && type.isAssignableFrom(cls)) {
+ synchronized (ex) {
+ if (listener.loadBean(ex.getName(), cls.asSubclass(type))) {
+ if (ex.getLoadedObject() == null) {
+ loadAndRegister(ex);
+ }
+ if (listener.beanLoaded(ex.getName(), type.cast(ex.getLoadedObject()))) {
+ return true;
+ }
+ loaded = true;
+ }
+ }
+ }
+ }
+ return loaded;
+ }
+ public boolean hasConfiguredPropertyValue(String beanName, String propertyName, String value) {
+ if (beanName == null) {
+ return false;
+ }
+ Extension ex = all.get(beanName);
+ return ex != null && ex.getNamespaces() != null
+ && ex.getNamespaces().contains(value);
+ }
+ public void destroyBeans() {
+ for (Extension ex : ordered) {
+ if (ex.getLoadedObject() != null) {
+ ResourceInjector injector = new ResourceInjector(resourceManager);
+ injector.destroy(ex.getLoadedObject());
+ }
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/managers/ServiceContractResolverRegistryImpl.java b/transform/src/patch/java/org/apache/cxf/bus/managers/ServiceContractResolverRegistryImpl.java
new file mode 100644
index 0000000..a0f7af0
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/managers/ServiceContractResolverRegistryImpl.java
@@ -0,0 +1,113 @@
+/**
+ * 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.cxf.bus.managers;
+
+import java.net.URI;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.injection.NoJSR250Annotations;
+import org.apache.cxf.endpoint.ServiceContractResolver;
+import org.apache.cxf.endpoint.ServiceContractResolverRegistry;
+
+/**
+ * A simple contract resolver registry. It maintains a list of contract resolvers in an
+ * <code>ArrayList</code>.
+ */
+@NoJSR250Annotations(unlessNull = "bus")
+public class ServiceContractResolverRegistryImpl implements ServiceContractResolverRegistry {
+
+ private List<ServiceContractResolver> resolvers
+ = new CopyOnWriteArrayList<>();
+
+ public ServiceContractResolverRegistryImpl() {
+
+ }
+ public ServiceContractResolverRegistryImpl(Bus b) {
+ setBus(b);
+ }
+
+
+ /**
+ * Sets the bus with which the registry is associated.
+ *
+ * @param bus
+ */
+ public final void setBus(Bus bus) {
+ if (bus != null) {
+ bus.setExtension(this, ServiceContractResolverRegistry.class);
+ }
+ }
+
+ /**
+ * Calls each of the registered <code>ServiceContractResolver</code> instances
+ * to resolve the location of the service's contract. It returns the location
+ * from the first resolver that matches the QName to a location.
+ *
+ * @param qname QName to be resolved into a contract location
+ * @return URI representing the location of the contract
+ */
+ public URI getContractLocation(QName qname) {
+ for (ServiceContractResolver resolver : resolvers) {
+ URI contractLocation = resolver.getContractLocation(qname);
+ if (null != contractLocation) {
+ return contractLocation;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Tests if a resolver is alreadey registered with this registry.
+ *
+ * @param resolver the contract resolver for which to searche
+ * @return <code>true</code> if the resolver is registered
+ */
+ public boolean isRegistered(ServiceContractResolver resolver) {
+ return resolvers.contains(resolver);
+ }
+
+ /**
+ * Registers a contract resolver with this registry.
+ *
+ * @param resolver the contract resolver to register
+ */
+ public synchronized void register(ServiceContractResolver resolver) {
+ resolvers.add(resolver);
+ }
+
+ /**
+ * Removes a contract resolver from this registry.
+ *
+ * @param resolver the contract resolver to remove
+ */
+ public synchronized void unregister(ServiceContractResolver resolver) {
+ resolvers.remove(resolver);
+ }
+
+
+ protected List<ServiceContractResolver> getResolvers() {
+ return resolvers;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/osgi/CXFActivator.java b/transform/src/patch/java/org/apache/cxf/bus/osgi/CXFActivator.java
new file mode 100644
index 0000000..6504276
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/osgi/CXFActivator.java
@@ -0,0 +1,134 @@
+/**
+ * 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.cxf.bus.osgi;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.cxf.bus.blueprint.BlueprintNameSpaceHandlerFactory;
+import org.apache.cxf.bus.blueprint.NamespaceHandlerRegisterer;
+import org.apache.cxf.bus.extension.Extension;
+import org.apache.cxf.bus.extension.ExtensionRegistry;
+import org.apache.cxf.common.util.CollectionUtils;
+import org.apache.cxf.internal.CXFAPINamespaceHandler;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.Constants;
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.service.cm.ConfigurationAdmin;
+import org.osgi.service.cm.ManagedServiceFactory;
+import org.osgi.util.tracker.ServiceTracker;
+
+/**
+ * Is called in OSGi on start and stop of the cxf bundle.
+ * Manages
+ * - CXFBundleListener
+ * - Attaching ManagedWorkqueues to config admin service
+ * - OsgiBusListener
+ * - Blueprint namespaces
+ */
+public class CXFActivator implements BundleActivator {
+
+ private List<Extension> extensions;
+ private ManagedWorkQueueList workQueues;
+ private ServiceTracker<ConfigurationAdmin, ConfigurationAdmin> configAdminTracker;
+ private CXFExtensionBundleListener cxfBundleListener;
+ private ServiceRegistration<ManagedServiceFactory> workQueueServiceRegistration;
+
+
+
+ /** {@inheritDoc}*/
+ public void start(BundleContext context) throws Exception {
+ workQueues = new ManagedWorkQueueList();
+ cxfBundleListener = new CXFExtensionBundleListener(context.getBundle().getBundleId());
+ context.addBundleListener(cxfBundleListener);
+ cxfBundleListener.registerExistingBundles(context);
+
+ configAdminTracker = new ServiceTracker<>(context, ConfigurationAdmin.class, null);
+ configAdminTracker.open();
+ workQueues.setConfigAdminTracker(configAdminTracker);
+ workQueueServiceRegistration = registerManagedServiceFactory(context,
+ ManagedServiceFactory.class,
+ workQueues,
+ ManagedWorkQueueList.FACTORY_PID);
+
+ extensions = new ArrayList<>();
+ extensions.add(createOsgiBusListenerExtension(context));
+ extensions.add(createManagedWorkQueueListExtension(workQueues));
+ ExtensionRegistry.addExtensions(extensions);
+
+ BlueprintNameSpaceHandlerFactory factory = new BlueprintNameSpaceHandlerFactory() {
+
+ @Override
+ public Object createNamespaceHandler() {
+ return new CXFAPINamespaceHandler();
+ }
+ };
+ NamespaceHandlerRegisterer.register(context, factory,
+ "http://cxf.apache.org/blueprint/core",
+ "http://cxf.apache.org/configuration/beans",
+ "http://cxf.apache.org/configuration/parameterized-types",
+ "http://cxf.apache.org/configuration/security",
+ "http://schemas.xmlsoap.org/wsdl/",
+ "http://www.w3.org/2005/08/addressing",
+ "http://schemas.xmlsoap.org/ws/2004/08/addressing");
+
+ }
+
+ private <T> ServiceRegistration<T> registerManagedServiceFactory(BundleContext context,
+ Class<T> serviceClass,
+ T service,
+ String servicePid) {
+ return context.registerService(serviceClass, service,
+ CollectionUtils.singletonDictionary(Constants.SERVICE_PID, servicePid));
+ }
+
+ private Extension createOsgiBusListenerExtension(BundleContext context) {
+ Extension busListener = new Extension(OSGIBusListener.class);
+ busListener.setArgs(new Object[] {context});
+ return busListener;
+ }
+
+ private static Extension createManagedWorkQueueListExtension(final ManagedWorkQueueList workQueues) {
+ return new Extension(ManagedWorkQueueList.class) {
+
+ @Override
+ public Object getLoadedObject() {
+ return workQueues;
+ }
+
+ @Override
+ public Extension cloneNoObject() {
+ return this;
+ }
+ };
+ }
+
+ /** {@inheritDoc}*/
+ public void stop(BundleContext context) throws Exception {
+ context.removeBundleListener(cxfBundleListener);
+ cxfBundleListener.shutdown();
+ workQueues.shutDown();
+ workQueueServiceRegistration.unregister();
+ configAdminTracker.close();
+ ExtensionRegistry.removeExtensions(extensions);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java b/transform/src/patch/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java
new file mode 100644
index 0000000..ee9bb15
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java
@@ -0,0 +1,181 @@
+/**
+ * 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.cxf.bus.osgi;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.Logger;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.bus.extension.Extension;
+import org.apache.cxf.bus.extension.ExtensionException;
+import org.apache.cxf.bus.extension.ExtensionRegistry;
+import org.apache.cxf.bus.extension.TextExtensionFragmentParser;
+import org.apache.cxf.common.i18n.Message;
+import org.apache.cxf.common.logging.LogUtils;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.BundleEvent;
+import org.osgi.framework.ServiceReference;
+import org.osgi.framework.SynchronousBundleListener;
+
+public class CXFExtensionBundleListener implements SynchronousBundleListener {
+ private static final Logger LOG = LogUtils.getL7dLogger(CXFActivator.class);
+ private long id;
+ private ConcurrentMap<Long, List<OSGiExtension>> extensions
+ = new ConcurrentHashMap<>(16, 0.75f, 4);
+
+ public CXFExtensionBundleListener(long bundleId) {
+ this.id = bundleId;
+ }
+
+ public void registerExistingBundles(BundleContext context) {
+ for (Bundle bundle : context.getBundles()) {
+ if ((bundle.getState() == Bundle.RESOLVED
+ || bundle.getState() == Bundle.STARTING
+ || bundle.getState() == Bundle.ACTIVE
+ || bundle.getState() == Bundle.STOPPING)
+ && bundle.getBundleId() != context.getBundle().getBundleId()) {
+ register(bundle);
+ }
+ }
+ }
+
+ /** {@inheritDoc}*/
+ public void bundleChanged(BundleEvent event) {
+ if (event.getType() == BundleEvent.RESOLVED && id != event.getBundle().getBundleId()) {
+ register(event.getBundle());
+ } else if (event.getType() == BundleEvent.UNRESOLVED || event.getType() == BundleEvent.UNINSTALLED) {
+ unregister(event.getBundle().getBundleId());
+ }
+ }
+
+ protected void register(final Bundle bundle) {
+ Enumeration<?> e = bundle.findEntries("META-INF/cxf/", "bus-extensions.txt", false);
+ while (e != null && e.hasMoreElements()) {
+ List<Extension> orig = new TextExtensionFragmentParser(null).getExtensions((URL)e.nextElement());
+ addExtensions(bundle, orig);
+ }
+ }
+
+ private boolean addExtensions(final Bundle bundle, List<Extension> orig) {
+ if (orig.isEmpty()) {
+ return false;
+ }
+
+ List<String> names = new ArrayList<>(orig.size());
+ for (Extension ext : orig) {
+ names.add(ext.getName());
+ }
+ LOG.info("Adding the extensions from bundle " + bundle.getSymbolicName()
+ + " (" + bundle.getBundleId() + ") " + names);
+ List<OSGiExtension> list = extensions.get(bundle.getBundleId());
+ if (list == null) {
+ list = new CopyOnWriteArrayList<>();
+ List<OSGiExtension> preList = extensions.putIfAbsent(bundle.getBundleId(), list);
+ if (preList != null) {
+ list = preList;
+ }
+ }
+ for (Extension ext : orig) {
+ list.add(new OSGiExtension(ext, bundle));
+ }
+ ExtensionRegistry.addExtensions(list);
+ return !list.isEmpty();
+ }
+
+ protected void unregister(final long bundleId) {
+ List<OSGiExtension> list = extensions.remove(bundleId);
+ if (list != null) {
+ LOG.info("Removing the extensions for bundle " + bundleId);
+ ExtensionRegistry.removeExtensions(list);
+ }
+ }
+
+ public void shutdown() {
+ while (!extensions.isEmpty()) {
+ unregister(extensions.keySet().iterator().next());
+ }
+ }
+
+ public class OSGiExtension extends Extension {
+ final Bundle bundle;
+ Object serviceObject;
+ public OSGiExtension(Extension e, Bundle b) {
+ super(e);
+ bundle = b;
+ }
+
+ public void setServiceObject(Object o) {
+ serviceObject = o;
+ obj = o;
+ }
+
+ @Override
+ public Object load(ClassLoader cl, Bus b) {
+ if (interfaceName == null && bundle.getBundleContext() != null) {
+ ServiceReference<?> ref = bundle.getBundleContext().getServiceReference(className);
+ if (ref != null && ref.getBundle().getBundleId() == bundle.getBundleId()) {
+ Object o = bundle.getBundleContext().getService(ref);
+ serviceObject = o;
+ obj = o;
+ return obj;
+ }
+ }
+ return super.load(cl, b);
+ }
+
+ @Override
+ protected Class<?> tryClass(String name, ClassLoader cl) {
+ Class<?> c = null;
+ Throwable origExc = null;
+ try {
+ c = bundle.loadClass(className);
+ } catch (Throwable e) {
+ origExc = e;
+ }
+ if (c == null) {
+ try {
+ return super.tryClass(name, cl);
+ } catch (ExtensionException ee) {
+ if (origExc != null) {
+ throw new ExtensionException(new Message("PROBLEM_LOADING_EXTENSION_CLASS",
+ Extension.LOG, name),
+ origExc);
+ }
+ throw ee;
+ }
+ }
+ return c;
+ }
+
+ @Override
+ public Extension cloneNoObject() {
+ OSGiExtension ext = new OSGiExtension(this, bundle);
+ ext.obj = serviceObject;
+ return ext;
+ }
+
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/osgi/OSGIBusListener.java b/transform/src/patch/java/org/apache/cxf/bus/osgi/OSGIBusListener.java
new file mode 100644
index 0000000..aad270d
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/osgi/OSGIBusListener.java
@@ -0,0 +1,224 @@
+/**
+ * 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.cxf.bus.osgi;
+
+import java.util.Dictionary;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.bus.extension.ExtensionManagerImpl;
+import org.apache.cxf.buslifecycle.BusCreationListener;
+import org.apache.cxf.buslifecycle.BusLifeCycleListener;
+import org.apache.cxf.buslifecycle.BusLifeCycleManager;
+import org.apache.cxf.common.util.CollectionUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.configuration.ConfiguredBeanLocator;
+import org.apache.cxf.endpoint.ClientLifeCycleListener;
+import org.apache.cxf.endpoint.ClientLifeCycleManager;
+import org.apache.cxf.endpoint.ServerLifeCycleListener;
+import org.apache.cxf.endpoint.ServerLifeCycleManager;
+import org.apache.cxf.feature.Feature;
+import org.apache.cxf.workqueue.WorkQueueManager;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.Constants;
+import org.osgi.framework.InvalidSyntaxException;
+import org.osgi.framework.ServiceReference;
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.framework.Version;
+
+public class OSGIBusListener implements BusLifeCycleListener {
+ public static final String CONTEXT_SYMBOLIC_NAME_PROPERTY = "cxf.context.symbolicname";
+ public static final String CONTEXT_VERSION_PROPERTY = "cxf.context.version";
+ public static final String CONTEXT_NAME_PROPERTY = "cxf.bus.id";
+
+ private static final String SERVICE_PROPERTY_PRIVATE = "org.apache.cxf.bus.private.extension";
+ private static final String SERVICE_PROPERTY_RESTRICTED = "org.apache.cxf.bus.restricted.extension";
+ private static final String BUS_EXTENSION_BUNDLES_EXCLUDES = "bus.extension.bundles.excludes";
+ Bus bus;
+ ServiceRegistration<?> service;
+ BundleContext defaultContext;
+ private Pattern extensionBundlesExcludesPattern;
+
+ public OSGIBusListener(Bus b) {
+ this(b, null);
+ }
+ public OSGIBusListener(Bus b, Object[] args) {
+ bus = b;
+ if (args != null && args.length > 0
+ && args[0] instanceof BundleContext) {
+ defaultContext = (BundleContext)args[0];
+ }
+ String extExcludes = (String)bus.getProperty(BUS_EXTENSION_BUNDLES_EXCLUDES);
+ if (!StringUtils.isEmpty(extExcludes)) {
+ try {
+ extensionBundlesExcludesPattern = Pattern.compile(extExcludes);
+ } catch (IllegalArgumentException e) {
+ // ignore
+ }
+ }
+ BusLifeCycleManager manager = bus.getExtension(BusLifeCycleManager.class);
+ manager.registerLifeCycleListener(this);
+ registerConfiguredBeanLocator();
+ registerClientLifeCycleListeners();
+ registerServerLifecycleListeners();
+ registerBusFeatures();
+ sendBusCreatedToBusCreationListeners();
+
+ }
+ private void registerConfiguredBeanLocator() {
+ final ConfiguredBeanLocator cbl = bus.getExtension(ConfiguredBeanLocator.class);
+ if (cbl instanceof ExtensionManagerImpl) {
+ // wire in the OSGi things
+ bus.setExtension(new OSGiBeanLocator(cbl, defaultContext),
+ ConfiguredBeanLocator.class);
+ }
+ }
+
+ public void initComplete() {
+ ManagedWorkQueueList wqList = bus.getExtension(ManagedWorkQueueList.class);
+ if (wqList != null) {
+ WorkQueueManager manager = bus.getExtension(WorkQueueManager.class);
+ wqList.addAllToWorkQueueManager(manager);
+ }
+ registerBusAsService();
+ }
+
+
+ public void preShutdown() {
+ }
+
+ public void postShutdown() {
+ if (service != null) {
+ service.unregister();
+ service = null;
+ }
+ }
+
+ private static ServiceReference<?>[] getServiceReferences(BundleContext context, Class<?> serviceClass) {
+ ServiceReference<?>[] refs = null;
+ try {
+ refs = context.getServiceReferences(serviceClass.getName(), null);
+ } catch (InvalidSyntaxException e) {
+ // ignore
+ }
+ if (refs == null) {
+ refs = new ServiceReference<?>[]{};
+ }
+ return refs;
+ }
+
+ private void sendBusCreatedToBusCreationListeners() {
+ ServiceReference<?>[] refs = getServiceReferences(defaultContext, BusCreationListener.class);
+ for (ServiceReference<?> ref : refs) {
+ if (!isPrivate(ref) && !isExcluded(ref)) {
+ BusCreationListener listener = (BusCreationListener)defaultContext.getService(ref);
+ listener.busCreated(bus);
+ }
+ }
+ }
+
+ private void registerServerLifecycleListeners() {
+ ServiceReference<?>[] refs = getServiceReferences(defaultContext, ServerLifeCycleListener.class);
+ ServerLifeCycleManager clcm = bus.getExtension(ServerLifeCycleManager.class);
+ for (ServiceReference<?> ref : refs) {
+ if (!isPrivate(ref) && !isExcluded(ref)) {
+ ServerLifeCycleListener listener = (ServerLifeCycleListener)defaultContext.getService(ref);
+ clcm.registerListener(listener);
+ }
+ }
+ }
+ private void registerClientLifeCycleListeners() {
+ ServiceReference<?>[] refs = getServiceReferences(defaultContext, ClientLifeCycleListener.class);
+ ClientLifeCycleManager clcm = bus.getExtension(ClientLifeCycleManager.class);
+ for (ServiceReference<?> ref : refs) {
+ if (!isPrivate(ref) && !isExcluded(ref)) {
+ ClientLifeCycleListener listener = (ClientLifeCycleListener)defaultContext.getService(ref);
+ clcm.registerListener(listener);
+ }
+ }
+ }
+
+ private void registerBusFeatures() {
+ ServiceReference<?>[] refs = getServiceReferences(defaultContext, Feature.class);
+ for (ServiceReference<?> ref : refs) {
+ if (!isPrivate(ref) && !isExcluded(ref)) {
+ Feature feature = (Feature)defaultContext.getService(ref);
+ bus.getFeatures().add(feature);
+ }
+ }
+ }
+
+ private boolean isPrivate(ServiceReference<?> ref) {
+ Object o = ref.getProperty(SERVICE_PROPERTY_PRIVATE);
+
+ if (o == null) {
+ return false;
+ }
+
+ Boolean pvt = Boolean.FALSE;
+ if (o instanceof String) {
+ pvt = Boolean.parseBoolean((String)o);
+ } else if (o instanceof Boolean) {
+ pvt = (Boolean)o;
+ }
+ return pvt.booleanValue();
+ }
+
+ private boolean isExcluded(ServiceReference<?> ref) {
+ String o = (String)ref.getProperty(SERVICE_PROPERTY_RESTRICTED);
+ if (!StringUtils.isEmpty(o)) {
+ // if the service's restricted-regex is set, the service is excluded when the app not matching that regex
+ BundleContext app = bus.getExtension(BundleContext.class);
+ try {
+ if (app != null && !app.getBundle().getSymbolicName().matches(o)) {
+ return true;
+ }
+ } catch (IllegalArgumentException e) {
+ // ignore
+ }
+ }
+ // if the excludes-regex is set, the service is excluded when matching that regex.
+ return extensionBundlesExcludesPattern != null
+ && extensionBundlesExcludesPattern.matcher(ref.getBundle().getSymbolicName()).matches();
+ }
+
+ private Version getBundleVersion(Bundle bundle) {
+ Dictionary<?, ?> headers = bundle.getHeaders();
+ String version = (String) headers.get(Constants.BUNDLE_VERSION);
+ return (version != null) ? Version.parseVersion(version) : Version.emptyVersion;
+ }
+
+
+
+ private void registerBusAsService() {
+ BundleContext context = bus.getExtension(BundleContext.class);
+ if (context != null) {
+ Map<String, Object> props = new HashMap<>();
+ props.put(CONTEXT_SYMBOLIC_NAME_PROPERTY, context.getBundle().getSymbolicName());
+ props.put(CONTEXT_VERSION_PROPERTY, getBundleVersion(context.getBundle()));
+ props.put(CONTEXT_NAME_PROPERTY, bus.getId());
+
+ service = context.registerService(Bus.class.getName(), bus, CollectionUtils.toDictionary(props));
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/transform/src/patch/java/org/apache/cxf/bus/resource/ResourceManagerImpl.java b/transform/src/patch/java/org/apache/cxf/bus/resource/ResourceManagerImpl.java
new file mode 100644
index 0000000..99c6ee9
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/resource/ResourceManagerImpl.java
@@ -0,0 +1,85 @@
+/**
+ * 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.cxf.bus.resource;
+
+import java.util.List;
+
+import javax.annotation.Resource;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.injection.NoJSR250Annotations;
+import org.apache.cxf.configuration.ConfiguredBeanLocator;
+import org.apache.cxf.extension.BusExtension;
+import org.apache.cxf.resource.DefaultResourceManager;
+import org.apache.cxf.resource.ObjectTypeResolver;
+import org.apache.cxf.resource.ResourceManager;
+import org.apache.cxf.resource.ResourceResolver;
+
+@NoJSR250Annotations(unlessNull = "bus")
+public class ResourceManagerImpl extends DefaultResourceManager implements BusExtension {
+
+ private Bus bus;
+
+ public ResourceManagerImpl() {
+ }
+
+ public ResourceManagerImpl(Bus b) {
+ super();
+ setBus(b);
+ }
+
+ @Override
+ protected void onFirstResolve() {
+ super.onFirstResolve();
+ if (bus != null) {
+ ConfiguredBeanLocator locator = bus.getExtension(ConfiguredBeanLocator.class);
+ if (locator != null) {
+ this.addResourceResolvers(locator.getBeansOfType(ResourceResolver.class));
+ }
+ }
+ }
+
+ /**
+ * Set the list of resolvers for this resource manager.
+ * @param resolvers
+ */
+ public final void setResolvers(List<? extends ResourceResolver> resolvers) {
+ registeredResolvers.clear();
+ registeredResolvers.addAll(resolvers);
+ }
+
+ @Resource
+ public final void setBus(Bus b) {
+ if (bus != b) {
+ bus = b;
+ firstCalled = false;
+ super.addResourceResolver(new ObjectTypeResolver(bus));
+ if (null != bus) {
+ bus.setExtension(this, ResourceManager.class);
+ }
+ }
+ }
+
+ public Class<?> getRegistrationType() {
+ return ResourceManager.class;
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/spring/BusDefinitionParser.java b/transform/src/patch/java/org/apache/cxf/bus/spring/BusDefinitionParser.java
new file mode 100644
index 0000000..9d508b6
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/spring/BusDefinitionParser.java
@@ -0,0 +1,310 @@
+/**
+ * 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.cxf.bus.spring;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.w3c.dom.Element;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.injection.NoJSR250Annotations;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.configuration.spring.AbstractBeanDefinitionParser;
+import org.apache.cxf.configuration.spring.BusWiringType;
+import org.apache.cxf.feature.Feature;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.interceptor.AbstractBasicInterceptorProvider;
+import org.apache.cxf.interceptor.Interceptor;
+import org.apache.cxf.message.Message;
+import org.springframework.beans.PropertyValue;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+public class BusDefinitionParser extends AbstractBeanDefinitionParser {
+ private static AtomicInteger counter = new AtomicInteger(0);
+
+ public BusDefinitionParser() {
+ super();
+ setBeanClass(BusConfig.class);
+ }
+
+ @Override
+ protected void doParse(Element element, ParserContext ctx, BeanDefinitionBuilder bean) {
+ String bus = element.getAttribute("bus");
+ if (StringUtils.isEmpty(bus)) {
+ bus = element.getAttribute("name");
+ if (StringUtils.isEmpty(bus)) {
+ element.setAttribute("bus", bus);
+ }
+ }
+ element.removeAttribute("name");
+ if (StringUtils.isEmpty(bus)) {
+ bus = "cxf";
+ }
+ String id = element.getAttribute("id");
+ if (!StringUtils.isEmpty(id)) {
+ bean.addPropertyValue("id", id);
+ }
+
+ super.doParse(element, ctx, bean);
+
+ if (ctx.getRegistry().containsBeanDefinition(bus)) {
+ BeanDefinition def = ctx.getRegistry().getBeanDefinition(bus);
+ copyProps(bean, def);
+ bean.addConstructorArgValue(bus);
+ } else if (!"cxf".equals(bus)) {
+ bean.getRawBeanDefinition().setBeanClass(SpringBus.class);
+ bean.setDestroyMethodName("shutdown");
+ try {
+ element.setUserData("ID", bus, null);
+ bean.getRawBeanDefinition().getPropertyValues().removePropertyValue("bus");
+ } catch (Throwable t) {
+ //likely not DOM level 3, ignore
+ }
+ } else {
+ addBusWiringAttribute(bean, BusWiringType.PROPERTY, bus, ctx);
+ bean.getRawBeanDefinition().setAttribute(WIRE_BUS_CREATE,
+ resolveId(element, null, ctx));
+ bean.addConstructorArgValue(bus);
+ }
+ }
+
+ @Override
+ protected boolean processBusAttribute(Element element, ParserContext ctx,
+ BeanDefinitionBuilder bean,
+ String val) {
+ return false;
+ }
+
+ private void copyProps(BeanDefinitionBuilder src, BeanDefinition def) {
+ for (PropertyValue v : src.getBeanDefinition().getPropertyValues().getPropertyValues()) {
+ if (!"bus".equals(v.getName())) {
+ def.getPropertyValues().addPropertyValue(v.getName(), v.getValue());
+ }
+ src.getBeanDefinition().getPropertyValues().removePropertyValue(v);
+ }
+
+ }
+
+ @Override
+ protected void mapElement(ParserContext ctx,
+ BeanDefinitionBuilder bean,
+ Element e,
+ String name) {
+ if ("inInterceptors".equals(name) || "inFaultInterceptors".equals(name)
+ || "outInterceptors".equals(name) || "outFaultInterceptors".equals(name)
+ || "features".equals(name)) {
+ List<?> list = ctx.getDelegate().parseListElement(e, bean.getBeanDefinition());
+ bean.addPropertyValue(name, list);
+ } else if ("properties".equals(name)) {
+ Map<?, ?> map = ctx.getDelegate().parseMapElement(e, bean.getBeanDefinition());
+ bean.addPropertyValue("properties", map);
+ }
+ }
+ @Override
+ protected String resolveId(Element element, AbstractBeanDefinition definition,
+ ParserContext ctx) {
+ String bus = null;
+ try {
+ bus = (String)element.getUserData("ID");
+ } catch (Throwable t) {
+ //ignore
+ }
+ if (bus == null) {
+ bus = element.getAttribute("bus");
+ if (StringUtils.isEmpty(bus)) {
+ bus = element.getAttribute("name");
+ }
+ if (StringUtils.isEmpty(bus)) {
+ bus = Bus.DEFAULT_BUS_ID + ".config" + counter.getAndIncrement();
+ } else {
+ bus = bus + ".config";
+ }
+ try {
+ element.setUserData("ID", bus, null);
+ } catch (Throwable t) {
+ //maybe no DOM level 3, ignore, but, may have issues with the counter
+ }
+ }
+ return bus;
+ }
+
+ @NoJSR250Annotations
+ public static class BusConfig extends AbstractBasicInterceptorProvider
+ implements ApplicationContextAware {
+
+ Bus bus;
+ String busName;
+ String id;
+ Collection<Feature> features;
+ Map<String, Object> properties;
+
+ public BusConfig(String busName) {
+ this.busName = busName;
+ }
+
+ public void setBus(Bus bb) {
+ if (bus == bb) {
+ return;
+ }
+ if (properties != null) {
+ bb.setProperties(properties);
+ properties = null;
+ }
+ if (!getInInterceptors().isEmpty()) {
+ bb.getInInterceptors().addAll(getInInterceptors());
+ }
+ if (!getOutInterceptors().isEmpty()) {
+ bb.getOutInterceptors().addAll(getOutInterceptors());
+ }
+ if (!getInFaultInterceptors().isEmpty()) {
+ bb.getInFaultInterceptors().addAll(getInFaultInterceptors());
+ }
+ if (!getOutFaultInterceptors().isEmpty()) {
+ bb.getOutFaultInterceptors().addAll(getOutFaultInterceptors());
+ }
+ if (!StringUtils.isEmpty(id)) {
+ bb.setId(id);
+ }
+ if (features != null) {
+ bb.setFeatures(features);
+ features = null;
+ }
+ bus = bb;
+ }
+
+ public void setApplicationContext(ApplicationContext applicationContext) {
+ if (bus != null) {
+ return;
+ }
+ }
+
+ @Override
+ public List<Interceptor<? extends Message>> getOutFaultInterceptors() {
+ if (bus != null) {
+ return bus.getOutFaultInterceptors();
+ }
+ return super.getOutFaultInterceptors();
+ }
+
+ @Override
+ public List<Interceptor<? extends Message>> getInFaultInterceptors() {
+ if (bus != null) {
+ return bus.getInFaultInterceptors();
+ }
+ return super.getInFaultInterceptors();
+ }
+
+ @Override
+ public List<Interceptor<? extends Message>> getInInterceptors() {
+ if (bus != null) {
+ return bus.getInInterceptors();
+ }
+ return super.getInInterceptors();
+ }
+
+ @Override
+ public List<Interceptor<? extends Message>> getOutInterceptors() {
+ if (bus != null) {
+ return bus.getOutInterceptors();
+ }
+ return super.getOutInterceptors();
+ }
+
+ @Override
+ public void setInInterceptors(List<Interceptor<? extends Message>> interceptors) {
+ if (bus != null) {
+ bus.getInInterceptors().addAll(interceptors);
+ } else {
+ super.setInInterceptors(interceptors);
+ }
+ }
+
+ @Override
+ public void setInFaultInterceptors(List<Interceptor<? extends Message>> interceptors) {
+ if (bus != null) {
+ bus.getInFaultInterceptors().addAll(interceptors);
+ } else {
+ super.setInFaultInterceptors(interceptors);
+ }
+ }
+
+ @Override
+ public void setOutInterceptors(List<Interceptor<? extends Message>> interceptors) {
+ if (bus != null) {
+ bus.getOutInterceptors().addAll(interceptors);
+ } else {
+ super.setOutInterceptors(interceptors);
+ }
+ }
+
+ @Override
+ public void setOutFaultInterceptors(List<Interceptor<? extends Message>> interceptors) {
+ if (bus != null) {
+ bus.getOutFaultInterceptors().addAll(interceptors);
+ } else {
+ super.setOutFaultInterceptors(interceptors);
+ }
+ }
+
+ public Collection<Feature> getFeatures() {
+ if (bus != null) {
+ return bus.getFeatures();
+ }
+ return features;
+ }
+
+ public void setFeatures(Collection<? extends Feature> features) {
+ if (bus != null) {
+ bus.setFeatures(features);
+ } else {
+ this.features = CastUtils.cast(features);
+ }
+
+ }
+
+ public Map<String, Object> getProperties() {
+ if (bus != null) {
+ return bus.getProperties();
+ }
+ return properties;
+ }
+ public void setProperties(Map<String, Object> s) {
+ if (bus != null) {
+ bus.setProperties(s);
+ } else {
+ this.properties = s;
+ }
+ }
+
+ public void setId(String s) {
+ id = s;
+ }
+
+
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/spring/BusEntityResolver.java b/transform/src/patch/java/org/apache/cxf/bus/spring/BusEntityResolver.java
new file mode 100644
index 0000000..1e95e28
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/spring/BusEntityResolver.java
@@ -0,0 +1,94 @@
+/**
+ * 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.cxf.bus.spring;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.springframework.beans.factory.xml.DelegatingEntityResolver;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.support.PropertiesLoaderUtils;
+import org.springframework.util.CollectionUtils;
+
+/**
+ *
+ */
+public class BusEntityResolver extends DelegatingEntityResolver {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(BusEntityResolver.class);
+
+ private EntityResolver dtdResolver;
+ private EntityResolver schemaResolver;
+ private Map<String, String> schemaMappings;
+ private ClassLoader classLoader;
+
+ public BusEntityResolver(ClassLoader loader, EntityResolver dr, EntityResolver sr) {
+ super(dr, sr);
+ classLoader = loader;
+ dtdResolver = dr;
+ schemaResolver = sr;
+
+ try {
+ Properties mappings = PropertiesLoaderUtils.loadAllProperties("META-INF/spring.schemas",
+ classLoader);
+ schemaMappings = new ConcurrentHashMap<>(mappings.size());
+ CollectionUtils.mergePropertiesIntoMap(mappings, schemaMappings);
+ } catch (IOException e) {
+ //ignore
+ }
+ }
+
+ @Override
+ public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
+ InputSource source = super.resolveEntity(publicId, systemId);
+ if (null == source && null != systemId) {
+ // try the schema and dtd resolver in turn, ignoring the suffix in publicId
+ LOG.log(Level.FINE, "Attempting to resolve systemId {0}", systemId);
+ source = schemaResolver.resolveEntity(publicId, systemId);
+ if (null == source) {
+ source = dtdResolver.resolveEntity(publicId, systemId);
+ }
+ }
+
+ if (null == source) {
+ return null;
+ }
+
+ String resourceLocation = schemaMappings.get(systemId);
+ if (resourceLocation != null && publicId == null) {
+ Resource resource = new ClassPathResource(resourceLocation, classLoader);
+ if (resource.exists()) {
+ source.setPublicId(systemId);
+ source.setSystemId(resource.getURL().toString());
+ }
+ }
+ return source;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/spring/BusExtensionPostProcessor.java b/transform/src/patch/java/org/apache/cxf/bus/spring/BusExtensionPostProcessor.java
new file mode 100644
index 0000000..9389be6
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/spring/BusExtensionPostProcessor.java
@@ -0,0 +1,71 @@
+/**
+ * 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.cxf.bus.spring;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.injection.NoJSR250Annotations;
+import org.apache.cxf.extension.BusExtension;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.core.Ordered;
+
+@NoJSR250Annotations
+public class BusExtensionPostProcessor implements BeanPostProcessor, ApplicationContextAware, Ordered {
+
+ private Bus bus;
+ private ApplicationContext context;
+
+ public void setApplicationContext(ApplicationContext ctx) {
+ context = ctx;
+ }
+
+ public int getOrder() {
+ return 1001;
+ }
+
+
+ @Override
+ public Object postProcessAfterInitialization(Object bean, String beanId) {
+ return bean;
+ }
+
+ @Override
+ public Object postProcessBeforeInitialization(Object bean, String beanId) {
+ if (bean instanceof BusExtension && null != getBus()) {
+ Class<? extends Object> cls = ((BusExtension)bean).getRegistrationType();
+ registerExt(bean, cls);
+ } else if (bean instanceof Bus && Bus.DEFAULT_BUS_ID.equals(beanId)) {
+ bus = (Bus)bean;
+ }
+ return bean;
+ }
+ private <T> void registerExt(Object bean, Class<T> cls) {
+ getBus().setExtension(cls.cast(bean), cls);
+ }
+
+ private Bus getBus() {
+ if (bus == null) {
+ bus = (Bus)context.getBean(Bus.DEFAULT_BUS_ID);
+ }
+ return bus;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/spring/Jsr250BeanPostProcessor.java b/transform/src/patch/java/org/apache/cxf/bus/spring/Jsr250BeanPostProcessor.java
new file mode 100644
index 0000000..1fb0746
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/spring/Jsr250BeanPostProcessor.java
@@ -0,0 +1,164 @@
+/**
+ * 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.cxf.bus.spring;
+
+
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.injection.ResourceInjector;
+import org.apache.cxf.resource.ResourceManager;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.core.Ordered;
+
+public class Jsr250BeanPostProcessor
+ implements DestructionAwareBeanPostProcessor, Ordered, ApplicationContextAware {
+
+ private ResourceManager resourceManager;
+ private ApplicationContext context;
+
+ private boolean isProcessing = true;
+ //private int count;
+ //private int count2;
+
+ Jsr250BeanPostProcessor() {
+ }
+
+ public void setApplicationContext(ApplicationContext applicationContext) {
+ context = applicationContext;
+ try {
+ Class<?> cls = Class
+ .forName("org.springframework.context.annotation.CommonAnnotationBeanPostProcessor");
+ isProcessing = context.getBeanNamesForType(cls, true, false).length == 0;
+ } catch (ClassNotFoundException e) {
+ isProcessing = true;
+ }
+ }
+
+ public int getOrder() {
+ return 1010;
+ }
+
+ private boolean injectable(Object bean, String beanId) {
+ return !"cxf".equals(beanId) && ResourceInjector.processable(bean.getClass(), bean);
+ }
+ private ResourceManager getResourceManager(Object bean) {
+ if (resourceManager == null) {
+ boolean temp = isProcessing;
+ isProcessing = false;
+ if (bean instanceof ResourceManager) {
+ resourceManager = (ResourceManager)bean;
+ resourceManager.addResourceResolver(new BusApplicationContextResourceResolver(context));
+ } else if (bean instanceof Bus) {
+ Bus b = (Bus)bean;
+ ResourceManager m = b.getExtension(ResourceManager.class);
+ if (m != null) {
+ resourceManager = m;
+ if (!(b instanceof SpringBus)) {
+ resourceManager
+ .addResourceResolver(new BusApplicationContextResourceResolver(context));
+ }
+ }
+ } else {
+ ResourceManager m = null;
+ Bus b = null;
+ try {
+ m = (ResourceManager)context.getBean(ResourceManager.class.getName());
+ } catch (NoSuchBeanDefinitionException t) {
+ //ignore - no resource manager
+ }
+ if (m == null) {
+ b = (Bus)context.getBean("cxf");
+ m = b.getExtension(ResourceManager.class);
+ }
+ if (m != null) {
+ resourceManager = m;
+ if (!(b instanceof SpringBus)) {
+ resourceManager
+ .addResourceResolver(new BusApplicationContextResourceResolver(context));
+ }
+ }
+ }
+ isProcessing = temp;
+ }
+ return resourceManager;
+ }
+
+ @Override
+ public Object postProcessAfterInitialization(Object bean, String beanId) {
+ if (!isProcessing) {
+ if (resourceManager == null && bean instanceof ResourceManager) {
+ resourceManager = (ResourceManager)bean;
+ resourceManager.addResourceResolver(new BusApplicationContextResourceResolver(context));
+ }
+ return bean;
+ }
+ if (bean != null
+ && injectable(bean, beanId)) {
+ new ResourceInjector(getResourceManager(bean)).construct(bean);
+ }
+ return bean;
+ }
+
+ @Override
+ public Object postProcessBeforeInitialization(Object bean, String beanId) {
+ if (!isProcessing) {
+ return bean;
+ }
+ if (bean instanceof Bus) {
+ getResourceManager(bean);
+ }
+ /*
+ if (bean.getClass().getName().contains("Corb")) {
+ Thread.dumpStack();
+ }
+ */
+
+ if (bean != null
+ && injectable(bean, beanId)) {
+ new ResourceInjector(getResourceManager(bean)).inject(bean);
+ /*
+ System.out.println("p :" + (++count) + ": " + bean.getClass().getName() + " " + beanId);
+ } else if (bean != null) {
+ System.out.println("np: " + (++count2)
+ + ": " + bean.getClass().getName() + " " + beanId);
+ */
+ }
+ return bean;
+ }
+
+ public void postProcessBeforeDestruction(Object bean, String beanId) {
+ if (!isProcessing) {
+ return;
+ }
+ if (bean != null
+ && injectable(bean, beanId)) {
+ new ResourceInjector(getResourceManager(bean)).destroy(bean);
+ }
+ }
+
+ @Override
+ public boolean requiresDestruction(Object bean) {
+ return isProcessing;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/spring/NamespaceHandler.java b/transform/src/patch/java/org/apache/cxf/bus/spring/NamespaceHandler.java
new file mode 100644
index 0000000..9211ea8
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/spring/NamespaceHandler.java
@@ -0,0 +1,57 @@
+/**
+ * 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.cxf.bus.spring;
+
+import org.w3c.dom.Element;
+
+import org.apache.cxf.configuration.spring.SimpleBeanDefinitionParser;
+import org.apache.cxf.feature.FastInfosetFeature;
+import org.apache.cxf.workqueue.AutomaticWorkQueueImpl;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
+import org.springframework.beans.factory.xml.ParserContext;
+
+public class NamespaceHandler extends NamespaceHandlerSupport {
+ @SuppressWarnings("deprecation")
+ public void init() {
+ registerBeanDefinitionParser("bus",
+ new BusDefinitionParser());
+ registerBeanDefinitionParser("logging",
+ new SimpleBeanDefinitionParser(org.apache.cxf.feature.LoggingFeature.class));
+ registerBeanDefinitionParser("fastinfoset",
+ new SimpleBeanDefinitionParser(FastInfosetFeature.class));
+
+ registerBeanDefinitionParser("workqueue",
+ new SimpleBeanDefinitionParser(AutomaticWorkQueueImpl.class) {
+
+ @Override
+ protected void processNameAttribute(Element element,
+ ParserContext ctx,
+ BeanDefinitionBuilder bean,
+ String val) {
+ bean.addPropertyValue("name", val);
+ element.removeAttribute("name");
+ if (!element.hasAttribute("id")) {
+ element.setAttribute("id", "cxf.workqueue." + val);
+ }
+
+ }
+ });
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/bus/spring/SpringBus.java b/transform/src/patch/java/org/apache/cxf/bus/spring/SpringBus.java
new file mode 100644
index 0000000..6616c8e
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/bus/spring/SpringBus.java
@@ -0,0 +1,142 @@
+/**
+ * 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.cxf.bus.spring;
+
+import org.apache.cxf.bus.extension.ExtensionManagerBus;
+import org.apache.cxf.configuration.ConfiguredBeanLocator;
+import org.apache.cxf.configuration.Configurer;
+import org.apache.cxf.configuration.spring.ConfigurerImpl;
+import org.apache.cxf.resource.ResourceManager;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.ApplicationEvent;
+import org.springframework.context.ApplicationListener;
+import org.springframework.context.event.ContextClosedEvent;
+import org.springframework.context.event.ContextRefreshedEvent;
+import org.springframework.context.support.AbstractApplicationContext;
+
+/**
+ *
+ */
+public class SpringBus extends ExtensionManagerBus
+ implements ApplicationContextAware {
+
+ AbstractApplicationContext ctx;
+ boolean closeContext;
+
+ public SpringBus() {
+ }
+
+ public void setBusConfig(BusDefinitionParser.BusConfig bc) {
+ bc.setBus(this);
+ }
+
+ /** {@inheritDoc}*/
+ public void setApplicationContext(ApplicationContext applicationContext) {
+ ctx = (AbstractApplicationContext)applicationContext;
+ @SuppressWarnings("rawtypes")
+ ApplicationListener listener = new ApplicationListener() {
+ public void onApplicationEvent(ApplicationEvent event) {
+ SpringBus.this.onApplicationEvent(event);
+ }
+ };
+ ctx.addApplicationListener(listener);
+ ApplicationContext ac = applicationContext.getParent();
+ while (ac != null) {
+ if (ac instanceof AbstractApplicationContext) {
+ ((AbstractApplicationContext)ac).addApplicationListener(listener);
+ }
+ ac = ac.getParent();
+ }
+
+ // set the classLoader extension with the application context classLoader
+ setExtension(applicationContext.getClassLoader(), ClassLoader.class);
+
+ setExtension(new ConfigurerImpl(applicationContext), Configurer.class);
+
+ ResourceManager m = getExtension(ResourceManager.class);
+ m.addResourceResolver(new BusApplicationContextResourceResolver(applicationContext));
+
+ setExtension(applicationContext, ApplicationContext.class);
+ ConfiguredBeanLocator loc = getExtension(ConfiguredBeanLocator.class);
+ if (!(loc instanceof SpringBeanLocator)) {
+ setExtension(new SpringBeanLocator(applicationContext, this), ConfiguredBeanLocator.class);
+ }
+ if (getState() != BusState.RUNNING) {
+ initialize();
+ }
+ }
+
+ public void onApplicationEvent(ApplicationEvent event) {
+ if (ctx == null) {
+ return;
+ }
+ boolean doIt = false;
+ ApplicationContext ac = ctx;
+ while (ac != null) {
+ if (event.getSource() == ac) {
+ doIt = true;
+ break;
+ }
+ ac = ac.getParent();
+ }
+ if (doIt) {
+ if (event instanceof ContextRefreshedEvent) {
+ if (getState() != BusState.RUNNING) {
+ initialize();
+ }
+ } else if (event instanceof ContextClosedEvent && getState() == BusState.RUNNING) {
+ // The bus could be create by using SpringBusFactory.createBus("/cxf.xml");
+ // Just to make sure the shutdown is called rightly
+ shutdown();
+ }
+ }
+ }
+
+ @Override
+ public void destroyBeans() {
+ if (closeContext) {
+ ctx.close();
+ }
+ super.destroyBeans();
+ }
+
+ @Override
+ public String getId() {
+ if (id == null) {
+ try {
+ Class<?> clsbc = Class.forName("org.osgi.framework.BundleContext");
+ Class<?> clsb = Class.forName("org.osgi.framework.Bundle");
+ Object o = getExtension(clsbc);
+ Object o2 = clsbc.getMethod("getBundle").invoke(o);
+ String s = (String)clsb.getMethod("getSymbolicName").invoke(o2);
+ id = s + '-' + DEFAULT_BUS_ID + Integer.toString(this.hashCode());
+ } catch (Throwable t) {
+ id = super.getId();
+ }
+ }
+ return id;
+ }
+
+ public void setCloseContext(boolean b) {
+ closeContext = b;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/catalog/CatalogXmlSchemaURIResolver.java b/transform/src/patch/java/org/apache/cxf/catalog/CatalogXmlSchemaURIResolver.java
new file mode 100644
index 0000000..15a3ce2
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/catalog/CatalogXmlSchemaURIResolver.java
@@ -0,0 +1,102 @@
+/**
+ * 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.cxf.catalog;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.xml.sax.InputSource;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.resource.ExtendedURIResolver;
+import org.apache.cxf.transport.TransportURIResolver;
+import org.apache.ws.commons.schema.XmlSchemaException;
+import org.apache.ws.commons.schema.resolver.URIResolver;
+
+/**
+ * Resolves URIs using Apache Commons Resolver API.
+ */
+public class CatalogXmlSchemaURIResolver implements URIResolver {
+
+ private ExtendedURIResolver resolver;
+ private Bus bus;
+ private Map<String, String> resolved = new HashMap<>();
+
+ public CatalogXmlSchemaURIResolver(Bus bus) {
+ this.resolver = new TransportURIResolver(bus);
+ this.bus = bus;
+ }
+
+ public Map<String, String> getResolvedMap() {
+ return resolved;
+ }
+
+ public InputSource resolveEntity(String targetNamespace, String schemaLocation, String baseUri) {
+ final String resolvedSchemaLocation;
+ OASISCatalogManager catalogResolver = OASISCatalogManager.getCatalogManager(bus);
+ try {
+ resolvedSchemaLocation = new OASISCatalogManagerHelper().resolve(catalogResolver,
+ schemaLocation, baseUri);
+ } catch (Exception e) {
+ throw new RuntimeException("Catalog resolution failed", e);
+ }
+
+ final InputSource in;
+ if (resolvedSchemaLocation == null) {
+ in = this.resolver.resolve(schemaLocation, baseUri);
+ } else {
+ resolved.put(schemaLocation, resolvedSchemaLocation);
+ in = this.resolver.resolve(resolvedSchemaLocation, baseUri);
+ }
+
+ // If we return null, a NPE is raised in SchemaBuilder.
+ // If we return new InputSource(), a XmlSchemaException is raised
+ // but without any nice error message. So let's just throw a nice error here.
+ if (in == null) {
+ throw new XmlSchemaException("Unable to locate imported document "
+ + "at '" + schemaLocation + "'"
+ + (baseUri == null
+ ? "."
+ : ", relative to '" + baseUri + "'."));
+ } else if (in.getByteStream() != null
+ && !(in.getByteStream() instanceof ByteArrayInputStream)) {
+ //workaround bug in XmlSchema - XmlSchema is not closing the InputStreams
+ //that are returned for imports. Thus, with a lot of services starting up
+ //or a lot of schemas imported or similar, it's easy to run out of
+ //file handles. We'll just load the file into a byte[] and return that.
+ try {
+ InputStream ins = IOUtils.loadIntoBAIS(in.getByteStream());
+ in.setByteStream(ins);
+ } catch (IOException e) {
+ throw new XmlSchemaException("Unable to load imported document "
+ + "at '" + schemaLocation + "'"
+ + (baseUri == null
+ ? "."
+ : ", relative to '" + baseUri + "'."),
+ e);
+ }
+ }
+
+ return in;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/i18n/Exception.java b/transform/src/patch/java/org/apache/cxf/common/i18n/Exception.java
new file mode 100644
index 0000000..fcb38ad
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/i18n/Exception.java
@@ -0,0 +1,58 @@
+/**
+ * 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.cxf.common.i18n;
+
+
+
+public class Exception extends java.lang.Exception {
+
+ private static final long serialVersionUID = 1L;
+
+ private final Message message;
+
+ public Exception(Message msg) {
+ message = msg;
+ }
+
+ public Exception(Message msg, Throwable t) {
+ super(t);
+ message = msg;
+ }
+
+ public Exception(Throwable cause) {
+ super(cause);
+ message = null;
+ }
+
+ public String getCode() {
+ if (null != message) {
+ return message.getCode();
+ }
+ return null;
+ }
+
+ @Override
+ public String getMessage() {
+ if (null != message) {
+ return message.toString();
+ }
+ return null;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/i18n/Message.java b/transform/src/patch/java/org/apache/cxf/common/i18n/Message.java
new file mode 100644
index 0000000..d1a65c8
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/i18n/Message.java
@@ -0,0 +1,91 @@
+/**
+ * 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.cxf.common.i18n;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import java.util.logging.Logger;
+
+public class Message implements Serializable {
+ private static final long serialVersionUID = 42L;
+
+ transient String code;
+ transient Object[] parameters;
+ transient ResourceBundle bundle;
+
+ /**
+ * Constructor.
+ *
+ * @param key the message catalog (resource bundle) key
+ * @param logger a logger with an associated resource bundle
+ * @param params the message substitution parameters
+ */
+ public Message(String key, Logger logger, Object...params) {
+ this(key, logger.getResourceBundle(), params);
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param key the message catalog (resource bundle) key
+ * @param catalog the resource bundle
+ * @param params the message substitution parameters
+ */
+ public Message(String key, ResourceBundle catalog, Object...params) {
+ code = key;
+ bundle = catalog;
+ parameters = params;
+ }
+
+ public String toString() {
+ final String fmt;
+ try {
+ if (null == bundle) {
+ return code;
+ }
+ fmt = bundle.getString(code);
+ } catch (MissingResourceException ex) {
+ return code;
+ }
+ return MessageFormat.format(fmt, parameters);
+ }
+
+ public String getCode() {
+ return code;
+ }
+
+ public Object[] getParameters() {
+ return parameters;
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out)
+ throws IOException {
+ out.writeUTF(toString());
+ }
+ private void readObject(java.io.ObjectInputStream in)
+ throws IOException, ClassNotFoundException {
+ code = in.readUTF();
+ bundle = null;
+ parameters = null;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/i18n/UncheckedException.java b/transform/src/patch/java/org/apache/cxf/common/i18n/UncheckedException.java
new file mode 100644
index 0000000..ea15fd7
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/i18n/UncheckedException.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.cxf.common.i18n;
+
+import java.util.ResourceBundle;
+import java.util.logging.Logger;
+
+
+
+public class UncheckedException extends java.lang.RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ protected final Message message;
+
+ public UncheckedException(Message msg) {
+ message = msg;
+ }
+
+ public UncheckedException(Message msg, Throwable t) {
+ super(t);
+ message = msg;
+ }
+
+ public UncheckedException(Throwable cause) {
+ super(cause);
+ message = null;
+ }
+
+ public UncheckedException(Logger log, String msg, Object ... params) {
+ message = new org.apache.cxf.common.i18n.Message(msg,
+ log,
+ params);
+ }
+ public UncheckedException(ResourceBundle bundle, String msg, Object ... params) {
+ message = new org.apache.cxf.common.i18n.Message(msg,
+ bundle,
+ params);
+ }
+ public UncheckedException(Logger log, String msg, Throwable t, Object ... params) {
+ super(t);
+ message = new org.apache.cxf.common.i18n.Message(msg,
+ log,
+ params);
+ }
+ public UncheckedException(ResourceBundle bundle, String msg, Throwable t, Object ... params) {
+ super(t);
+ message = new org.apache.cxf.common.i18n.Message(msg,
+ bundle,
+ params);
+ }
+
+ public String getCode() {
+ if (null != message) {
+ return message.getCode();
+ }
+ return null;
+ }
+
+ @Override
+ public String getMessage() {
+ if (null != message) {
+ return message.toString();
+ }
+ return null;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/injection/ResourceInjector.java b/transform/src/patch/java/org/apache/cxf/common/injection/ResourceInjector.java
new file mode 100644
index 0000000..9c420ce
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/injection/ResourceInjector.java
@@ -0,0 +1,446 @@
+/**
+ * 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.cxf.common.injection;
+
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.annotation.Resource;
+import javax.annotation.Resources;
+
+
+import org.apache.cxf.common.annotation.AbstractAnnotationVisitor;
+import org.apache.cxf.common.annotation.AnnotationProcessor;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ClassHelper;
+import org.apache.cxf.common.util.ReflectionUtil;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.resource.ResourceManager;
+import org.apache.cxf.resource.ResourceResolver;
+
+
+/**
+ * injects references specified using @Resource annotation
+ *
+ */
+public class ResourceInjector extends AbstractAnnotationVisitor {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(ResourceInjector.class);
+ private static final List<Class<? extends Annotation>> ANNOTATIONS = new ArrayList<>();
+
+ static {
+ ANNOTATIONS.add(Resource.class);
+ ANNOTATIONS.add(Resources.class);
+ }
+
+
+ private final ResourceManager resourceManager;
+ private final List<ResourceResolver> resourceResolvers;
+
+ public ResourceInjector(ResourceManager resMgr) {
+ this(resMgr, resMgr == null ? null : resMgr.getResourceResolvers());
+ }
+
+ public ResourceInjector(ResourceManager resMgr, List<ResourceResolver> resolvers) {
+ super(ANNOTATIONS);
+ resourceManager = resMgr;
+ resourceResolvers = resolvers;
+ }
+
+ private static Field getField(Class<?> cls, String name) {
+ if (cls == null) {
+ return null;
+ }
+ try {
+ Field f = ReflectionUtil.getDeclaredField(cls, name);
+ if (f == null) {
+ f = getField(cls.getSuperclass(), name);
+ }
+ return f;
+ } catch (Exception ex) {
+ return getField(cls.getSuperclass(), name);
+ }
+ }
+
+ public static boolean processable(Class<?> cls, Object o) {
+ if (cls.getName().startsWith("java.")
+ || cls.getName().startsWith("javax.")) {
+ return false;
+ }
+ NoJSR250Annotations njsr = cls.getAnnotation(NoJSR250Annotations.class);
+ if (njsr != null) {
+ for (String s : njsr.unlessNull()) {
+ try {
+ Field f = getField(cls, s);
+ ReflectionUtil.setAccessible(f);
+ if (f.get(o) == null) {
+ return true;
+ }
+ } catch (Exception ex) {
+ return true;
+ }
+ }
+ return false;
+ }
+ return true;
+ }
+
+ public void inject(Object o) {
+ inject(o, o.getClass());
+ }
+
+ public void inject(Object o, Class<?> claz) {
+ if (processable(claz, o)) {
+ AnnotationProcessor processor = new AnnotationProcessor(o);
+ processor.accept(this, claz);
+ }
+ }
+
+ public void construct(Object o) {
+ setTarget(o);
+ if (processable(targetClass, o)) {
+ invokePostConstruct();
+ }
+ }
+ public void construct(Object o, Class<?> cls) {
+ setTarget(o, cls);
+ if (processable(targetClass, o)) {
+ invokePostConstruct();
+ }
+ }
+
+
+ public void destroy(Object o) {
+ setTarget(o);
+ if (processable(targetClass, o)) {
+ invokePreDestroy();
+ }
+ }
+
+
+ // Implementation of org.apache.cxf.common.annotation.AnnotationVisitor
+
+ @Override
+ public final void visitClass(final Class<?> clz, final Annotation annotation) { //NOPMD
+
+ assert annotation instanceof Resource || annotation instanceof Resources : annotation;
+
+ if (annotation instanceof Resource) {
+ injectResourceClassLevel((Resource)annotation);
+ } else if (annotation instanceof Resources) {
+ Resources resources = (Resources)annotation;
+ for (Resource resource : resources.value()) {
+ injectResourceClassLevel(resource);
+ }
+ }
+
+ }
+
+ private void injectResourceClassLevel(Resource res) {
+ if (res.name() == null || "".equals(res.name())) {
+ LOG.log(Level.INFO, "RESOURCE_NAME_NOT_SPECIFIED", target.getClass().getName());
+ return;
+ }
+
+ Object resource;
+ // first find a setter that matches this resource
+ Method setter = findSetterForResource(res);
+ if (setter != null) {
+ Class<?> type = getResourceType(res, setter);
+ resource = resolveResource(res.name(), type);
+ if (resource == null) {
+ LOG.log(Level.INFO, "RESOURCE_RESOLVE_FAILED");
+ return;
+ }
+
+ invokeSetter(setter, resource);
+ return;
+ }
+
+ Field field = findFieldForResource(res);
+ if (field != null) {
+ Class<?> type = getResourceType(res, field);
+ resource = resolveResource(res.name(), type);
+ if (resource == null) {
+ LOG.log(Level.INFO, "RESOURCE_RESOLVE_FAILED");
+ return;
+ }
+ injectField(field, resource);
+ return;
+ }
+ LOG.log(Level.SEVERE, "NO_SETTER_OR_FIELD_FOR_RESOURCE", getTarget().getClass().getName());
+ }
+
+ public final void visitField(final Field field, final Annotation annotation) {
+
+ assert annotation instanceof Resource : annotation;
+
+ Resource res = (Resource)annotation;
+
+ String name = getFieldNameForResource(res, field);
+ Class<?> type = getResourceType(res, field);
+
+ Object resource = resolveResource(name, type);
+ if (resource == null
+ && "".equals(res.name())) {
+ resource = resolveResource(null, type);
+ }
+ if (resource != null) {
+ injectField(field, resource);
+ } else {
+ LOG.log(Level.INFO, "RESOURCE_RESOLVE_FAILED", name);
+ }
+ }
+
+ public final void visitMethod(final Method method, final Annotation annotation) {
+
+ assert annotation instanceof Resource : annotation;
+
+ Resource res = (Resource)annotation;
+
+ String resourceName = getResourceName(res, method);
+ Class<?> clz = getResourceType(res, method);
+
+ Object resource = resolveResource(resourceName, clz);
+ if (resource == null
+ && "".equals(res.name())) {
+ resource = resolveResource(null, clz);
+ }
+ if (resource != null) {
+ invokeSetter(method, resource);
+ } else {
+ LOG.log(Level.FINE, "RESOURCE_RESOLVE_FAILED", new Object[] {resourceName, clz});
+ }
+ }
+
+ private Field findFieldForResource(Resource res) {
+ assert target != null;
+ assert res.name() != null;
+
+ for (Field field : target.getClass().getFields()) {
+ if (field.getName().equals(res.name())) {
+ return field;
+ }
+ }
+
+ for (Field field : target.getClass().getDeclaredFields()) {
+ if (field.getName().equals(res.name())) {
+ return field;
+ }
+ }
+ return null;
+ }
+
+
+ private Method findSetterForResource(Resource res) {
+ assert target != null;
+
+ String setterName = resourceNameToSetter(res.name());
+ Method setterMethod = null;
+
+ for (Method method : getTarget().getClass().getMethods()) {
+ if (setterName.equals(method.getName())) {
+ setterMethod = method;
+ break;
+ }
+ }
+
+ if (setterMethod != null && setterMethod.getParameterTypes().length != 1) {
+ LOG.log(Level.WARNING, "SETTER_INJECTION_WITH_INCORRECT_TYPE", setterMethod);
+ }
+ return setterMethod;
+ }
+
+ private static String resourceNameToSetter(String resName) {
+ return "set" + StringUtils.capitalize(resName);
+ }
+
+ private void invokeSetter(Method method, Object resource) {
+ try {
+ ReflectionUtil.setAccessible(method);
+ if (method.getDeclaringClass().isAssignableFrom(getTarget().getClass())) {
+ method.invoke(getTarget(), resource);
+ } else { // deal with the proxy setter method
+ Method targetMethod = getTarget().getClass().getMethod(method.getName(),
+ method.getParameterTypes());
+ targetMethod.invoke(getTarget(), resource);
+ }
+ } catch (IllegalAccessException e) {
+ LOG.log(Level.SEVERE, "INJECTION_SETTER_NOT_VISIBLE", method);
+ } catch (InvocationTargetException | SecurityException e) {
+ LogUtils.log(LOG, Level.SEVERE, "INJECTION_SETTER_RAISED_EXCEPTION", e, method);
+ } catch (NoSuchMethodException e) {
+ LOG.log(Level.SEVERE, "INJECTION_SETTER_METHOD_NOT_FOUND", new Object[] {method.getName()});
+ }
+ }
+
+ private String getResourceName(Resource res, Method method) {
+ assert method != null;
+ assert res != null;
+ assert method.getName().startsWith("set") : method;
+
+ if (res.name() == null || res.name().isEmpty()) {
+ String name = method.getName().substring(3);
+ name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
+ return method.getDeclaringClass().getCanonicalName() + '/' + name;
+ }
+ return res.name();
+ }
+
+
+
+ private void injectField(Field field, Object resource) {
+ assert field != null;
+ assert resource != null;
+
+ boolean accessible = field.isAccessible();
+ try {
+ if (field.getType().isAssignableFrom(resource.getClass())) {
+ ReflectionUtil.setAccessible(field);
+ field.set(ClassHelper.getRealObject(getTarget()), resource);
+ }
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ LOG.severe("FAILED_TO_INJECT_FIELD");
+ } finally {
+ ReflectionUtil.setAccessible(field, accessible);
+ }
+ }
+
+
+ public void invokePostConstruct() {
+
+ boolean accessible = false;
+ for (Method method : getPostConstructMethods()) {
+ PostConstruct pc = method.getAnnotation(PostConstruct.class);
+ if (pc != null) {
+ try {
+ ReflectionUtil.setAccessible(method);
+ method.invoke(target);
+ } catch (IllegalAccessException e) {
+ LOG.log(Level.WARNING, "INJECTION_COMPLETE_NOT_VISIBLE", method);
+ } catch (InvocationTargetException e) {
+ LOG.log(Level.WARNING, "INJECTION_COMPLETE_THREW_EXCEPTION", e);
+ } finally {
+ ReflectionUtil.setAccessible(method, accessible);
+ }
+ }
+ }
+ }
+
+ public void invokePreDestroy() {
+
+ boolean accessible = false;
+ for (Method method : getPreDestroyMethods()) {
+ PreDestroy pd = method.getAnnotation(PreDestroy.class);
+ if (pd != null) {
+ try {
+ ReflectionUtil.setAccessible(method);
+ method.invoke(target);
+ } catch (IllegalAccessException e) {
+ LOG.log(Level.WARNING, "PRE_DESTROY_NOT_VISIBLE", method);
+ } catch (InvocationTargetException e) {
+ LOG.log(Level.WARNING, "PRE_DESTROY_THREW_EXCEPTION", e);
+ } finally {
+ ReflectionUtil.setAccessible(method, accessible);
+ }
+ }
+ }
+ }
+
+
+ private Collection<Method> getPostConstructMethods() {
+ return getAnnotatedMethods(PostConstruct.class);
+ }
+
+ private Collection<Method> getPreDestroyMethods() {
+ return getAnnotatedMethods(PreDestroy.class);
+ }
+
+ private Collection<Method> getAnnotatedMethods(Class<? extends Annotation> acls) {
+
+ Collection<Method> methods = new LinkedList<>();
+ addAnnotatedMethods(acls, getTarget().getClass().getMethods(), methods);
+ addAnnotatedMethods(acls, ReflectionUtil.getDeclaredMethods(getTarget().getClass()), methods);
+ if (getTargetClass() != getTarget().getClass()) {
+ addAnnotatedMethods(acls, getTargetClass().getMethods(), methods);
+ addAnnotatedMethods(acls, ReflectionUtil.getDeclaredMethods(getTargetClass()), methods);
+ }
+ return methods;
+ }
+
+ private void addAnnotatedMethods(Class<? extends Annotation> acls, Method[] methods,
+ Collection<Method> annotatedMethods) {
+ for (Method method : methods) {
+ if (method.getAnnotation(acls) != null
+ && !annotatedMethods.contains(method)) {
+ annotatedMethods.add(method);
+ }
+ }
+ }
+
+
+ /**
+ * making this protected to keep pmd happy
+ */
+ protected Class<?> getResourceType(Resource res, Field field) {
+ assert res != null;
+ Class<?> type = res.type();
+ if (res.type() == null || Object.class == res.type()) {
+ type = field.getType();
+ }
+ return type;
+ }
+
+
+ private Class<?> getResourceType(Resource res, Method method) {
+ return res.type() != null && !Object.class.equals(res.type())
+ ? res.type()
+ : method.getParameterTypes()[0];
+ }
+
+
+ private String getFieldNameForResource(Resource res, Field field) {
+ assert res != null;
+ if (res.name() == null || "".equals(res.name())) {
+ return field.getDeclaringClass().getCanonicalName() + "/" + field.getName();
+ }
+ return res.name();
+ }
+
+ private Object resolveResource(String resourceName, Class<?> type) {
+ if (resourceManager == null) {
+ return null;
+ }
+ return resourceManager.resolveResource(resourceName, type, resourceResolvers);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/jaxb/JAXBUtils.java b/transform/src/patch/java/org/apache/cxf/common/jaxb/JAXBUtils.java
new file mode 100644
index 0000000..f018e2a
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/jaxb/JAXBUtils.java
@@ -0,0 +1,1180 @@
+/**
+ * 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.cxf.common.jaxb;
+
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.StandardCharsets;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.PropertyException;
+import javax.xml.bind.SchemaOutputResolver;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.attachment.AttachmentMarshaller;
+import javax.xml.bind.attachment.AttachmentUnmarshaller;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.spi.ClassLoaderService;
+import org.apache.cxf.common.util.CachedClass;
+import org.apache.cxf.common.util.PackageUtils;
+import org.apache.cxf.common.util.ProxyHelper;
+import org.apache.cxf.common.util.ReflectionInvokationHandler;
+import org.apache.cxf.common.util.ReflectionInvokationHandler.WrapReturn;
+import org.apache.cxf.common.util.ReflectionUtil;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.SystemPropertyAction;
+import org.apache.cxf.common.xmlschema.SchemaCollection;
+import org.apache.cxf.helpers.JavaUtils;
+
+public final class JAXBUtils {
+ public static final String JAXB_URI = "http://java.sun.com/xml/ns/jaxb";
+
+ private static final Logger LOG = LogUtils.getL7dLogger(JAXBUtils.class);
+
+ public enum IdentifierType {
+ CLASS,
+ INTERFACE,
+ GETTER,
+ SETTER,
+ VARIABLE,
+ CONSTANT
+ };
+
+ private static final char[] XML_NAME_PUNCTUATION_CHARS = new char[] {
+ /* hyphen */ '\u002D',
+ /* period */ '\u002E',
+ /* colon */'\u003A',
+ /* dot */ '\u00B7',
+ /* greek ano teleia */ '\u0387',
+ /* arabic end of ayah */ '\u06DD',
+ /* arabic start of rub el hizb */'\u06DE',
+ /* underscore */ '\u005F',
+ };
+
+ private static final String XML_NAME_PUNCTUATION_STRING = new String(XML_NAME_PUNCTUATION_CHARS);
+
+ private static final Map<String, String> BUILTIN_DATATYPES_MAP;
+ private static final Map<String, Class<?>> HOLDER_TYPES_MAP;
+ private static ClassLoader jaxbXjcLoader;
+ private static volatile Optional<Object> jaxbMinimumEscapeHandler;
+ private static volatile Optional<Object> jaxbNoEscapeHandler;
+
+ static {
+ BUILTIN_DATATYPES_MAP = new HashMap<>();
+ BUILTIN_DATATYPES_MAP.put("string", "java.lang.String");
+ BUILTIN_DATATYPES_MAP.put("integer", "java.math.BigInteger");
+ BUILTIN_DATATYPES_MAP.put("int", "int");
+ BUILTIN_DATATYPES_MAP.put("long", "long");
+ BUILTIN_DATATYPES_MAP.put("short", "short");
+ BUILTIN_DATATYPES_MAP.put("decimal", "java.math.BigDecimal");
+ BUILTIN_DATATYPES_MAP.put("float", "float");
+ BUILTIN_DATATYPES_MAP.put("double", "double");
+ BUILTIN_DATATYPES_MAP.put("boolean", "boolean");
+ BUILTIN_DATATYPES_MAP.put("byte", "byte");
+ BUILTIN_DATATYPES_MAP.put("QName", "javax.xml.namespace.QName");
+ BUILTIN_DATATYPES_MAP.put("dateTime", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("base64Binary", "byte[]");
+ BUILTIN_DATATYPES_MAP.put("hexBinary", "byte[]");
+ BUILTIN_DATATYPES_MAP.put("unsignedInt", "long");
+ BUILTIN_DATATYPES_MAP.put("unsignedShort", "short");
+ BUILTIN_DATATYPES_MAP.put("unsignedByte", "byte");
+ BUILTIN_DATATYPES_MAP.put("time", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("date", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gYear", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gYearMonth", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gMonth", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gMonthDay", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gDay", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("duration", "javax.xml.datatype.Duration");
+ BUILTIN_DATATYPES_MAP.put("NOTATION", "javax.xml.namespace.QName");
+
+ HOLDER_TYPES_MAP = new HashMap<>();
+ HOLDER_TYPES_MAP.put("int", java.lang.Integer.class);
+ HOLDER_TYPES_MAP.put("long", java.lang.Long.class);
+ HOLDER_TYPES_MAP.put("short", java.lang.Short.class);
+ HOLDER_TYPES_MAP.put("float", java.lang.Float.class);
+ HOLDER_TYPES_MAP.put("double", java.lang.Double.class);
+ HOLDER_TYPES_MAP.put("boolean", java.lang.Boolean.class);
+ HOLDER_TYPES_MAP.put("byte", java.lang.Byte.class);
+ }
+
+
+ /**
+ * prevents instantiation
+ *
+ */
+ private JAXBUtils() {
+ }
+
+ public static void closeUnmarshaller(Unmarshaller u) {
+ if (u instanceof Closeable) {
+ //need to do this to clear the ThreadLocal cache
+ //see https://java.net/jira/browse/JAXB-1000
+
+ try {
+ ((Closeable)u).close();
+ } catch (IOException e) {
+ //ignore
+ }
+ }
+ }
+ public static Object unmarshall(JAXBContext c, Element e) throws JAXBException {
+ Unmarshaller u = c.createUnmarshaller();
+ try {
+ u.setEventHandler(null);
+ return u.unmarshal(e);
+ } finally {
+ closeUnmarshaller(u);
+ }
+ }
+ public static <T> JAXBElement<T> unmarshall(JAXBContext c, Element e, Class<T> cls) throws JAXBException {
+ Unmarshaller u = c.createUnmarshaller();
+ try {
+ u.setEventHandler(null);
+ return u.unmarshal(e, cls);
+ } finally {
+ closeUnmarshaller(u);
+ }
+ }
+ public static Object unmarshall(JAXBContext c, Source s) throws JAXBException {
+ Unmarshaller u = c.createUnmarshaller();
+ try {
+ u.setEventHandler(null);
+ return u.unmarshal(s);
+ } finally {
+ closeUnmarshaller(u);
+ }
+ }
+ public static <T> JAXBElement<T> unmarshall(JAXBContext c,
+ XMLStreamReader reader,
+ Class<T> cls) throws JAXBException {
+ Unmarshaller u = c.createUnmarshaller();
+ try {
+ u.setEventHandler(null);
+ return u.unmarshal(reader, cls);
+ } finally {
+ closeUnmarshaller(u);
+ }
+ }
+ public static Object unmarshall(JAXBContext c,
+ XMLStreamReader reader) throws JAXBException {
+ Unmarshaller u = c.createUnmarshaller();
+ try {
+ u.setEventHandler(null);
+ return u.unmarshal(reader);
+ } finally {
+ closeUnmarshaller(u);
+ }
+ }
+
+ public static String builtInTypeToJavaType(String type) {
+ return BUILTIN_DATATYPES_MAP.get(type);
+ }
+
+ public static Class<?> holderClass(String type) {
+ return HOLDER_TYPES_MAP.get(type);
+ }
+
+ /**
+ * Checks if the specified word is a Java keyword (as defined in JavaUtils).
+ *
+ * @param word the word to check.
+ * @return true if the word is a keyword.
+ * @see org.apache.cxf.helpers.JavaUtils
+ */
+ protected static boolean isJavaKeyword(String word) {
+ return JavaUtils.isJavaKeyword(word);
+ }
+
+ /**
+ * Generates a Java package name from a URI according to the
+ * algorithm outlined in JAXB 2.0.
+ *
+ * @param namespaceURI the namespace URI.
+ * @return the package name.
+ */
+ public static String namespaceURIToPackage(String namespaceURI) {
+ try {
+ return nameSpaceURIToPackage(new URI(namespaceURI));
+ } catch (URISyntaxException ex) {
+ return null;
+ }
+ }
+
+ /**
+ * Generates a Java package name from a URI according to the
+ * algorithm outlined in Appendix D of JAXB (2.0+).
+ *
+ * @param uri the namespace URI.
+ * @return the package name.
+ */
+ public static String nameSpaceURIToPackage(URI uri) {
+
+ StringBuilder packageName = new StringBuilder();
+ String authority = uri.getAuthority();
+ String scheme = uri.getScheme();
+ if (authority == null && "urn".equals(scheme)) {
+ authority = uri.getSchemeSpecificPart();
+ }
+
+ if (null != authority && !"".equals(authority)) {
+ if ("urn".equals(scheme)) {
+ packageName.append(authority);
+ /* JAXB 2.2 D.5.1, Rule #5 */
+ for (int i = 0; i < packageName.length(); i++) {
+ if (packageName.charAt(i) == '-') {
+ packageName.setCharAt(i, '.');
+ }
+ }
+ authority = packageName.toString();
+ packageName.setLength(0);
+
+ StringTokenizer st = new StringTokenizer(authority, ":");
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken();
+ if (packageName.length() > 0) {
+ packageName.insert(0, '.');
+ packageName.insert(0, normalizePackageNamePart(token));
+ } else {
+ packageName.insert(0, token);
+ }
+ }
+ authority = packageName.toString();
+ packageName.setLength(0);
+
+ }
+
+ StringTokenizer st = new StringTokenizer(authority, ".");
+ if (st.hasMoreTokens()) {
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken();
+ if (packageName.length() == 0) {
+ if ("www".equals(token)) {
+ continue;
+ }
+ } else {
+ packageName.insert(0, '.');
+ }
+ packageName.insert(0, normalizePackageNamePart(token));
+ }
+ }
+
+ if (!("http".equalsIgnoreCase(scheme) || "urn".equalsIgnoreCase(scheme))) {
+ packageName.insert(0, '.');
+ packageName.insert(0, normalizePackageNamePart(scheme));
+ }
+
+ }
+
+ String path = uri.getPath();
+ if (path == null) {
+ path = "";
+ }
+ /* JAXB 2.2 D.5.1 Rule 2 - remove trailing .??, .???, or .html only. */
+ int index = path.lastIndexOf('.');
+ if (index < 0) {
+ index = path.length();
+ } else {
+ String ending = path.substring(index + 1);
+ if (ending.length() < 2 || (ending.length() > 3
+ && !"html".equalsIgnoreCase(ending))) {
+ index = path.length();
+ }
+ }
+ StringTokenizer st = new StringTokenizer(path.substring(0, index), "/");
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken();
+ if (packageName.length() > 0) {
+ packageName.append('.');
+ }
+ packageName.append(normalizePackageNamePart(token));
+ }
+ return packageName.toString();
+ }
+
+ private static String normalizePackageNamePart(String name) {
+ StringBuilder sname = new StringBuilder(name.toLowerCase());
+
+ for (int i = 0; i < sname.length(); i++) {
+ sname.setCharAt(i, Character.toLowerCase(sname.charAt(i)));
+ }
+
+ for (int i = 0; i < sname.length(); i++) {
+ if (!Character.isJavaIdentifierPart(sname.charAt(i))) {
+ sname.setCharAt(i, '_');
+ }
+ }
+
+ if (isJavaKeyword(sname.toString())) {
+ sname.insert(0, '_');
+ }
+
+ if (!Character.isJavaIdentifierStart(sname.charAt(0))) {
+ sname.insert(0, '_');
+ }
+
+ return sname.toString();
+ }
+
+
+ /**
+ * Converts an XML name to a Java identifier according to the mapping
+ * algorithm outlined in the JAXB specification
+ *
+ * @param name the XML name
+ * @return the Java identifier
+ */
+ public static String nameToIdentifier(String name, IdentifierType type) {
+
+ if (null == name || name.length() == 0) {
+ return name;
+ }
+
+ // algorithm will not change an XML name that is already a legal and
+ // conventional (!) Java class, method, or constant identifier
+
+ StringBuilder buf = new StringBuilder(name);
+ boolean hasUnderscore = false;
+ boolean legalIdentifier = Character.isJavaIdentifierStart(buf.charAt(0));
+
+ for (int i = 1; i < name.length() && legalIdentifier; i++) {
+ legalIdentifier &= Character.isJavaIdentifierPart(buf.charAt(i));
+ hasUnderscore |= '_' == buf.charAt(i);
+ }
+
+ boolean conventionalIdentifier = isConventionalIdentifier(buf, type);
+ if (legalIdentifier && conventionalIdentifier) {
+ if (JAXBUtils.isJavaKeyword(name) && type == IdentifierType.VARIABLE) {
+ name = normalizePackageNamePart(name);
+ }
+ if (!hasUnderscore || IdentifierType.CLASS != type) {
+ return name;
+ }
+ }
+
+ // split into words
+
+ List<String> words = new ArrayList<>();
+
+ StringTokenizer st = new StringTokenizer(name, XML_NAME_PUNCTUATION_STRING);
+ while (st.hasMoreTokens()) {
+ words.add(st.nextToken());
+ }
+
+ for (int i = 0; i < words.size(); i++) {
+ splitWord(words, i);
+ }
+
+ return makeConventionalIdentifier(words, type);
+ }
+
+ private static void splitWord(List<String> words, int listIndex) {
+ String word = words.get(listIndex);
+ if (word.length() <= 1) {
+ return;
+ }
+ int index = listIndex + 1;
+ StringBuilder sword = new StringBuilder(word);
+ int first = 0;
+ char firstChar = sword.charAt(first);
+ if (Character.isLowerCase(firstChar)) {
+ sword.setCharAt(first, Character.toUpperCase(firstChar));
+ }
+ int i = 1;
+
+ while (i < sword.length()) {
+ if (Character.isDigit(firstChar)) {
+ while (i < sword.length() && Character.isDigit(sword.charAt(i))) {
+ i++;
+ }
+ } else if (isCasedLetter(firstChar)) {
+ boolean previousIsLower = Character.isLowerCase(firstChar);
+ while (i < sword.length() && isCasedLetter(sword.charAt(i))) {
+ if (Character.isUpperCase(sword.charAt(i)) && previousIsLower) {
+ break;
+ }
+ previousIsLower = Character.isLowerCase(sword.charAt(i));
+ i++;
+ }
+ } else {
+ // first must be a mark or an uncased letter
+ while (i < sword.length() && (isMark(sword.charAt(i)) || !isCasedLetter(sword.charAt(i)))) {
+ i++;
+ }
+ }
+
+ // characters from first to i are all either
+ // * digits
+ // * upper or lower case letters, with only the first one an upper
+ // * uncased letters or marks
+
+
+ String newWord = sword.substring(first, i);
+ words.add(index, newWord);
+ index++;
+ if (i >= sword.length()) {
+ break;
+ }
+ first = i;
+ firstChar = sword.charAt(first);
+ }
+
+ if (index > (listIndex + 1)) {
+ words.remove(listIndex);
+ }
+ }
+
+ private static boolean isMark(char c) {
+ return Character.isJavaIdentifierPart(c) && !Character.isLetter(c) && !Character.isDigit(c);
+ }
+
+ private static boolean isCasedLetter(char c) {
+ return Character.isUpperCase(c) || Character.isLowerCase(c);
+ }
+
+ private static boolean isConventionalIdentifier(StringBuilder buf, IdentifierType type) {
+ if (null == buf || buf.length() == 0) {
+ return false;
+ }
+ final boolean result;
+ if (IdentifierType.CONSTANT == type) {
+ for (int i = 0; i < buf.length(); i++) {
+ if (Character.isLowerCase(buf.charAt(i))) {
+ return false;
+ }
+ }
+ result = true;
+ } else if (IdentifierType.VARIABLE == type) {
+ result = Character.isLowerCase(buf.charAt(0));
+ } else {
+ int pos = 3;
+ if (IdentifierType.GETTER == type
+ && !(buf.length() >= pos
+ && "get".equals(buf.subSequence(0, 3)))) {
+ return false;
+ } else if (IdentifierType.SETTER == type
+ && !(buf.length() >= pos && "set".equals(buf.subSequence(0, 3)))) {
+ return false;
+ } else {
+ pos = 0;
+ }
+ result = Character.isUpperCase(buf.charAt(pos));
+ }
+ return result;
+ }
+
+ private static String makeConventionalIdentifier(List<String> words, IdentifierType type) {
+ StringBuilder buf = new StringBuilder();
+ boolean firstWord = true;
+ if (IdentifierType.GETTER == type) {
+ buf.append("get");
+ } else if (IdentifierType.SETTER == type) {
+ buf.append("set");
+ }
+ for (String w : words) {
+ int l = buf.length();
+ if (l > 0 && IdentifierType.CONSTANT == type) {
+ buf.append('_');
+ l++;
+ }
+ buf.append(w);
+ if (IdentifierType.CONSTANT == type) {
+ for (int i = l; i < buf.length(); i++) {
+ if (Character.isLowerCase(buf.charAt(i))) {
+ buf.setCharAt(i, Character.toUpperCase(buf.charAt(i)));
+ }
+ }
+ } else if (IdentifierType.VARIABLE == type) {
+ if (firstWord && Character.isUpperCase(buf.charAt(l))) {
+ buf.setCharAt(l, Character.toLowerCase(buf.charAt(l)));
+ }
+ } else {
+ if (firstWord && Character.isLowerCase(buf.charAt(l))) {
+ buf.setCharAt(l, Character.toUpperCase(buf.charAt(l)));
+ }
+ }
+ firstWord = false;
+ }
+ return buf.toString();
+ }
+
+ public static Class<?> getValidClass(Class<?> cls) {
+ if (cls.isEnum() || cls.isArray()) {
+ return cls;
+ }
+
+ if (cls == Object.class || cls == String.class || cls.isPrimitive() || cls.isAnnotation()
+ || "javax.xml.ws.Holder".equals(cls.getName())) {
+ return null;
+ } else if (cls.isInterface()
+ || "javax.xml.ws.wsaddressing.W3CEndpointReference".equals(cls.getName())) {
+ return cls;
+ }
+
+ Constructor<?> cons = ReflectionUtil.getDeclaredConstructor(cls);
+ if (cons == null) {
+ cons = ReflectionUtil.getConstructor(cls);
+ if (cons == null) {
+ return null;
+ }
+ }
+ return cls;
+ }
+
+ private static synchronized ClassLoader getXJCClassLoader() {
+ if (jaxbXjcLoader == null) {
+ try {
+ Class.forName("com.sun.tools.internal.xjc.api.XJC");
+ jaxbXjcLoader = ClassLoader.getSystemClassLoader();
+ } catch (Exception t2) {
+ //couldn't find either, probably cause tools.jar isn't on
+ //the classpath. Let's see if we can find the tools jar
+ String s = SystemPropertyAction.getProperty("java.home");
+ if (!StringUtils.isEmpty(s)) {
+ File home = new File(s);
+ File jar = new File(home, "lib/tools.jar");
+ if (!jar.exists()) {
+ jar = new File(home, "../lib/tools.jar");
+ }
+ if (jar.exists()) {
+ try {
+ jaxbXjcLoader = new URLClassLoader(new URL[] {jar.toURI().toURL()});
+ Class.forName("com.sun.tools.internal.xjc.api.XJC", false, jaxbXjcLoader);
+ } catch (Exception e) {
+ jaxbXjcLoader = null;
+ }
+ }
+ }
+ }
+ }
+ return jaxbXjcLoader;
+ }
+
+ public static Object setNamespaceMapper(Bus bus, final Map<String, String> nspref,
+ Marshaller marshaller) throws PropertyException {
+ ClassLoaderService classLoaderService = bus.getExtension(ClassLoaderService.class);
+ Object mapper = classLoaderService.createNamespaceWrapperInstance(marshaller.getClass(), nspref);
+ if (mapper != null) {
+ if (marshaller.getClass().getName().contains(".internal.")) {
+ marshaller.setProperty("com.sun.xml.internal.bind.namespacePrefixMapper",
+ mapper);
+ } else if (marshaller.getClass().getName().contains("com.sun")) {
+ marshaller.setProperty("com.sun.xml.bind.namespacePrefixMapper",
+ mapper);
+ } else if (marshaller.getClass().getName().contains("eclipse")) {
+ marshaller.setProperty("eclipselink.namespace-prefix-mapper",
+ mapper);
+ }
+ }
+ return mapper;
+ }
+ public static BridgeWrapper createBridge(Set<Class<?>> ctxClasses,
+ QName qname,
+ Class<?> refcls,
+ Annotation[] anns) throws JAXBException {
+ try {
+ Class<?> cls;
+ Class<?> refClass;
+ String pkg = "com.sun.xml.bind.";
+ try {
+ cls = Class.forName("com.sun.xml.bind.api.JAXBRIContext");
+ refClass = Class.forName(pkg + "api.TypeReference");
+ } catch (ClassNotFoundException e) {
+ cls = Class.forName("com.sun.xml.internal.bind.api.JAXBRIContext", true, getXJCClassLoader());
+ pkg = "com.sun.xml.internal.bind.";
+ refClass = Class.forName(pkg + "api.TypeReference", true, getXJCClassLoader());
+ }
+ Object ref = refClass.getConstructor(QName.class,
+ Type.class,
+ anns.getClass()).newInstance(qname, refcls, anns);
+ List<Object> typeRefs = new ArrayList<>();
+ typeRefs.add(ref);
+ List<Class<?>> clses = new ArrayList<>(ctxClasses);
+ clses.add(refClass.getField("type").get(ref).getClass());
+ if (!refcls.isInterface()) {
+ clses.add(refcls);
+ }
+
+ Object ctx = null;
+ for (Method m : cls.getDeclaredMethods()) {
+ if ("newInstance".equals(m.getName())
+ && m.getParameterTypes().length == 6) {
+ ctx = m.invoke(null, clses.toArray(new Class<?>[0]),
+ typeRefs, null, null, true, null);
+
+ }
+ }
+
+ if (ctx == null) {
+ throw new JAXBException("No ctx found");
+ }
+
+ Object bridge = ctx.getClass().getMethod("createBridge", refClass).invoke(ctx, ref);
+ return ReflectionInvokationHandler.createProxyWrapper(bridge,
+ BridgeWrapper.class);
+ } catch (Exception ex) {
+ throw new JAXBException(ex);
+ }
+ }
+ public interface BridgeWrapper {
+
+ Object unmarshal(XMLStreamReader source, AttachmentUnmarshaller am) throws JAXBException;
+
+ Object unmarshal(InputStream source) throws JAXBException;
+
+ Object unmarshal(Node source, AttachmentUnmarshaller am) throws JAXBException;
+
+ void marshal(Object elValue, XMLStreamWriter source, AttachmentMarshaller m) throws JAXBException;
+
+ void marshal(Object elValue, StreamResult s1) throws JAXBException;
+
+ void marshal(Object elValue, Node source, AttachmentMarshaller am) throws JAXBException;
+ }
+
+
+ public static SchemaCompiler createSchemaCompiler() throws JAXBException {
+ try {
+ Class<?> cls;
+ Object sc;
+ try {
+ cls = Class.forName("com.sun.tools.xjc.api.XJC");
+ sc = cls.getMethod("createSchemaCompiler").invoke(null);
+ } catch (Throwable e) {
+ cls = Class.forName("com.sun.tools.internal.xjc.api.XJC", true, getXJCClassLoader());
+ sc = cls.getMethod("createSchemaCompiler").invoke(null);
+ }
+
+ return ReflectionInvokationHandler.createProxyWrapper(sc,
+ SchemaCompiler.class);
+ } catch (Exception ex) {
+ throw new JAXBException(ex);
+ }
+ }
+
+ public static SchemaCompiler createSchemaCompilerWithDefaultAllocator(Set<String> allocatorSet) {
+
+ try {
+ SchemaCompiler compiler = JAXBUtils.createSchemaCompiler();
+ Object allocator = ReflectionInvokationHandler
+ .createProxyWrapper(new DefaultClassNameAllocator(allocatorSet),
+ JAXBUtils.getParamClass(compiler, "setClassNameAllocator"));
+
+ compiler.setClassNameAllocator(allocator);
+ return compiler;
+ } catch (JAXBException e1) {
+ throw new IllegalStateException("Unable to create schema compiler", e1);
+ }
+
+ }
+
+ public static void logGeneratedClassNames(Logger logger, JCodeModel codeModel) {
+ if (!logger.isLoggable(Level.FINE)) {
+ return;
+ }
+
+ StringBuilder sb = new StringBuilder();
+ boolean first = true;
+ for (Iterator<JPackage> itr = codeModel.packages(); itr.hasNext();) {
+ JPackage package1 = itr.next();
+
+ for (Iterator<JDefinedClass> citr = package1.classes(); citr.hasNext();) {
+ if (!first) {
+ sb.append(", ");
+ } else {
+ first = false;
+ }
+ sb.append(citr.next().fullName());
+ }
+ }
+
+ logger.log(Level.FINE, "Created classes: " + sb.toString());
+ }
+
+ public static List<String> getGeneratedClassNames(JCodeModel codeModel) {
+ List<String> classes = new ArrayList<>();
+ for (Iterator<JPackage> itr = codeModel.packages(); itr.hasNext();) {
+ JPackage package1 = itr.next();
+
+ for (Iterator<JDefinedClass> citr = package1.classes(); citr.hasNext();) {
+ classes.add(citr.next().fullName());
+ }
+ }
+ return classes;
+ }
+ public static Object createFileCodeWriter(File f) throws JAXBException {
+ return createFileCodeWriter(f, StandardCharsets.UTF_8.name());
+ }
+ public static Object createFileCodeWriter(File f, String encoding) throws JAXBException {
+ try {
+ Class<?> cls;
+ try {
+ cls = Class.forName("com.sun.codemodel.writer.FileCodeWriter");
+ } catch (ClassNotFoundException e) {
+ cls = Class.forName("com.sun.codemodel.internal.writer.FileCodeWriter",
+ true, getXJCClassLoader());
+ }
+ if (encoding != null) {
+ try {
+ return cls.getConstructor(File.class, String.class)
+ .newInstance(f, encoding);
+ } catch (Exception ex) {
+ // try a single argument constructor
+ }
+ }
+ return cls.getConstructor(File.class).newInstance(f);
+ } catch (Exception ex) {
+ throw new JAXBException(ex);
+ }
+ }
+
+ public static Class<?> getParamClass(SchemaCompiler sc, String method) {
+ Object o = ((ReflectionInvokationHandler)Proxy.getInvocationHandler(sc)).getTarget();
+ for (Method m : o.getClass().getMethods()) {
+ if (m.getName().equals(method) && m.getParameterTypes().length == 1) {
+ return m.getParameterTypes()[0];
+ }
+ }
+ return null;
+ }
+
+
+ public static List<DOMResult> generateJaxbSchemas(
+ JAXBContext context, final Map<String, DOMResult> builtIns) throws IOException {
+ final List<DOMResult> results = new ArrayList<>();
+
+ context.generateSchema(new SchemaOutputResolver() {
+ @Override
+ public Result createOutput(String ns, String file) throws IOException {
+ DOMResult result = new DOMResult();
+
+ if (builtIns.containsKey(ns)) {
+ DOMResult dr = builtIns.get(ns);
+ result.setSystemId(dr.getSystemId());
+ results.add(dr);
+ return result;
+ }
+ result.setSystemId(file);
+ results.add(result);
+ return result;
+ }
+ });
+ return results;
+ }
+
+ public static String getPackageNamespace(Class<?> cls) {
+ Package p = cls.getPackage();
+ if (p != null) {
+ javax.xml.bind.annotation.XmlSchema schemaAnn =
+ p.getAnnotation(javax.xml.bind.annotation.XmlSchema.class);
+ if (schemaAnn != null) {
+ return schemaAnn.namespace();
+ }
+ }
+ return null;
+ }
+
+ public static void scanPackages(Set<Class<?>> classes,
+ Map<Package, CachedClass> objectFactoryCache) {
+ scanPackages(classes, null, objectFactoryCache);
+ }
+ public static void scanPackages(Set<Class<?>> classes,
+ Class<?>[] extraClass,
+ Map<Package, CachedClass> objectFactoryCache) {
+
+ // add user extra class into jaxb context
+ if (extraClass != null && extraClass.length > 0) {
+ for (Class<?> clz : extraClass) {
+ classes.add(clz);
+ }
+ }
+
+ // try and read any jaxb.index files that are with the other classes.
+ // This should
+ // allow loading of extra classes (such as subclasses for inheritance
+ // reasons)
+ // that are in the same package. Also check for ObjectFactory classes
+ Map<String, InputStream> packages = new HashMap<>();
+ Map<String, ClassLoader> packageLoaders = new HashMap<>();
+ Set<Class<?>> objectFactories = new HashSet<>();
+ for (Class<?> jcls : classes) {
+ String pkgName = PackageUtils.getPackageName(jcls);
+ if (!packages.containsKey(pkgName)) {
+ Package pkg = jcls.getPackage();
+
+ packages.put(pkgName, jcls.getResourceAsStream("jaxb.index"));
+ packageLoaders.put(pkgName, getClassLoader(jcls));
+ String objectFactoryClassName = pkgName + "." + "ObjectFactory";
+ Class<?> ofactory = null;
+ CachedClass cachedFactory = null;
+ if (pkg != null && objectFactoryCache != null) {
+ synchronized (objectFactoryCache) {
+ cachedFactory = objectFactoryCache.get(pkg);
+ }
+ }
+ if (cachedFactory != null) {
+ ofactory = cachedFactory.getCachedClass();
+ }
+ if (ofactory == null) {
+ try {
+ ofactory = Class.forName(objectFactoryClassName, false, getClassLoader(jcls));
+ objectFactories.add(ofactory);
+ addToObjectFactoryCache(pkg, ofactory, objectFactoryCache);
+ } catch (ClassNotFoundException e) {
+ addToObjectFactoryCache(pkg, null, objectFactoryCache);
+ }
+ } else {
+ objectFactories.add(ofactory);
+ }
+ }
+ }
+ for (Map.Entry<String, InputStream> entry : packages.entrySet()) {
+ if (entry.getValue() != null) {
+ try (BufferedReader reader = new BufferedReader(
+ new InputStreamReader(entry.getValue(), StandardCharsets.UTF_8))) {
+ String pkg = entry.getKey();
+ ClassLoader loader = packageLoaders.get(pkg);
+ if (!StringUtils.isEmpty(pkg)) {
+ pkg += ".";
+ }
+
+ String line = reader.readLine();
+ while (line != null) {
+ line = line.trim();
+ if (line.indexOf('#') != -1) {
+ line = line.substring(0, line.indexOf('#'));
+ }
+ if (!StringUtils.isEmpty(line)) {
+ try {
+ Class<?> ncls = Class.forName(pkg + line, false, loader);
+ classes.add(ncls);
+ } catch (Exception e) {
+ // ignore
+ }
+ }
+ line = reader.readLine();
+ }
+ } catch (IOException e) {
+ // ignore
+ } finally {
+ try {
+ entry.getValue().close();
+ } catch (IOException e) {
+ // ignore
+ }
+ }
+ }
+ }
+ classes.addAll(objectFactories);
+ }
+
+ private static ClassLoader getClassLoader(final Class<?> clazz) {
+ final SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
+ @Override
+ public ClassLoader run() {
+ return clazz.getClassLoader();
+ }
+ });
+ }
+ return clazz.getClassLoader();
+ }
+
+ private static void addToObjectFactoryCache(Package objectFactoryPkg,
+ Class<?> ofactory,
+ Map<Package, CachedClass> objectFactoryCache) {
+ if (objectFactoryPkg == null || objectFactoryCache == null) {
+ return;
+ }
+ synchronized (objectFactoryCache) {
+ objectFactoryCache.put(objectFactoryPkg,
+ new CachedClass(ofactory));
+ }
+ }
+
+ public static class DefaultClassNameAllocator {
+ private final Set<String> typesClassNames;
+
+ public DefaultClassNameAllocator() {
+ this(new HashSet<>());
+ }
+
+ public DefaultClassNameAllocator(Set<String> set) {
+ typesClassNames = set;
+ }
+
+ public String assignClassName(String packageName, String className) {
+ String fullClassName = className;
+ String fullPckClass = packageName + "." + fullClassName;
+ int cnt = 0;
+ while (typesClassNames.contains(fullPckClass)) {
+ cnt++;
+ fullClassName = className + cnt;
+ fullPckClass = packageName + "." + fullClassName;
+ }
+ typesClassNames.add(fullPckClass);
+ return fullClassName;
+ }
+
+ }
+
+ public interface SchemaCompiler {
+ void setEntityResolver(EntityResolver entityResolver);
+
+ void setErrorListener(Object elForRun);
+
+ void setClassNameAllocator(Object allocator);
+
+ @WrapReturn(S2JJAXBModel.class)
+ S2JJAXBModel bind();
+
+ void parseSchema(InputSource source);
+
+ void parseSchema(String key, Element el);
+ void parseSchema(String key, XMLStreamReader el);
+
+ @WrapReturn(Options.class)
+ Options getOptions();
+ }
+ public interface S2JJAXBModel {
+
+ @WrapReturn(JCodeModel.class)
+ JCodeModel generateCode(Object object, Object elForRun);
+
+ @WrapReturn(Mapping.class)
+ Mapping get(QName qn);
+
+ @WrapReturn(TypeAndAnnotation.class)
+ TypeAndAnnotation getJavaType(QName typeQName);
+ }
+ public interface Mapping {
+ @WrapReturn(TypeAndAnnotation.class)
+ TypeAndAnnotation getType();
+ }
+ public interface TypeAndAnnotation {
+ @WrapReturn(JType.class)
+ JType getTypeClass();
+ }
+ public interface JType {
+ boolean isArray();
+
+ @WrapReturn(JType.class)
+ JType elementType();
+
+ boolean isPrimitive();
+
+ String binaryName();
+
+ String fullName();
+
+ String name();
+
+ @WrapReturn(value = JType.class, iterator = true)
+ Iterator<JType> classes();
+ }
+ public interface Options {
+
+ void addGrammar(InputSource is);
+
+ void addBindFile(InputSource is);
+
+ void parseArguments(String[] args);
+
+ String getBuildID();
+ }
+ public interface JCodeModel {
+
+ void build(Object writer) throws IOException;
+
+ @WrapReturn(value = JPackage.class, iterator = true)
+ Iterator<JPackage> packages();
+ }
+ public interface JPackage {
+
+ String name();
+
+ @WrapReturn(value = JDefinedClass.class, iterator = true)
+ Iterator<JDefinedClass> classes();
+ }
+ public interface JDefinedClass {
+ String name();
+
+ String fullName();
+ }
+
+ public static boolean isJAXB22() {
+ Target t = XmlElement.class.getAnnotation(Target.class);
+ //JAXB 2.2 allows XmlElement on params.
+ for (ElementType et : t.value()) {
+ if (et == ElementType.PARAMETER) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static JAXBContextProxy createJAXBContextProxy(final JAXBContext ctx) {
+ return createJAXBContextProxy(ctx, null, null);
+ }
+ public static JAXBContextProxy createJAXBContextProxy(final JAXBContext ctx,
+ final SchemaCollection collection,
+ final String defaultNs) {
+ if (ctx.getClass().getName().contains("com.sun.")
+ || collection == null) {
+ return ReflectionInvokationHandler.createProxyWrapper(ctx, JAXBContextProxy.class);
+ }
+ return new SchemaCollectionContextProxy(ctx, collection, defaultNs);
+ }
+ public static JAXBBeanInfo getBeanInfo(JAXBContextProxy context, Class<?> cls) {
+ Object o = context.getBeanInfo(cls);
+ if (o == null) {
+ return null;
+ }
+ if (o instanceof JAXBBeanInfo) {
+ return (JAXBBeanInfo)o;
+ }
+ return ReflectionInvokationHandler.createProxyWrapper(o, JAXBBeanInfo.class);
+ }
+
+ private static String getPostfix(Class<?> cls) {
+ String className = cls.getName();
+ if (className.contains("com.sun.xml.internal")
+ || className.contains("eclipse")) {
+ //eclipse moxy accepts sun package CharacterEscapeHandler
+ return ".internal";
+ } else if (className.contains("com.sun.xml.bind")
+ || className.startsWith("com.ibm.xml")) {
+ return "";
+ }
+ return null;
+ }
+
+ public static void setMinimumEscapeHandler(Marshaller marshaller) {
+ if (jaxbMinimumEscapeHandler == null) {
+ jaxbMinimumEscapeHandler = Optional.ofNullable(createMininumEscapeHandler(marshaller.getClass()));
+ }
+ jaxbMinimumEscapeHandler.ifPresent(p -> setEscapeHandler(marshaller, p));
+ }
+
+ public static void setNoEscapeHandler(final Marshaller marshaller) {
+ if (jaxbNoEscapeHandler == null) {
+ jaxbNoEscapeHandler = Optional.ofNullable(createNoEscapeHandler(marshaller.getClass()));
+ }
+ jaxbNoEscapeHandler.ifPresent(p -> setEscapeHandler(marshaller, p));
+ }
+
+ public static void setEscapeHandler(Marshaller marshaller, Object escapeHandler) {
+ try {
+ String postFix = getPostfix(marshaller.getClass());
+ if (postFix != null && escapeHandler != null) {
+ marshaller.setProperty("com.sun.xml" + postFix + ".bind.characterEscapeHandler", escapeHandler);
+ }
+ } catch (PropertyException e) {
+ LOG.log(Level.INFO, "Failed to set MinumEscapeHandler to jaxb marshaller", e);
+ }
+ }
+
+ public static Object createMininumEscapeHandler(Class<?> cls) {
+ return createEscapeHandler(cls, "MinimumEscapeHandler");
+ }
+
+ public static Object createNoEscapeHandler(Class<?> cls) {
+ return createEscapeHandler(cls, "NoEscapeHandler");
+ }
+
+ private static Object createEscapeHandler(Class<?> cls, String simpleClassName) {
+ try {
+ String postFix = getPostfix(cls);
+ if (postFix == null) {
+ LOG.log(Level.WARNING, "Failed to create" + simpleClassName + " for unknown jaxb class:"
+ + cls);
+ return null;
+ }
+ Class<?> handlerClass = ClassLoaderUtils.loadClass("com.sun.xml" + postFix
+ + ".bind.marshaller." + simpleClassName,
+ cls);
+ Class<?> handlerInterface = ClassLoaderUtils
+ .loadClass("com.sun.xml" + postFix + ".bind.marshaller.CharacterEscapeHandler",
+ cls);
+ Object targetHandler = ReflectionUtil.getDeclaredField(handlerClass, "theInstance").get(null);
+ return ProxyHelper.getProxy(cls.getClassLoader(),
+ new Class[] {handlerInterface},
+ new EscapeHandlerInvocationHandler(targetHandler));
+ } catch (Exception e) {
+ if ("NoEscapeHandler".equals(simpleClassName)) {
+ //this class doesn't exist in JAXB 2.2 so expected
+ LOG.log(Level.FINER, "Failed to create " + simpleClassName);
+ } else {
+ LOG.log(Level.INFO, "Failed to create " + simpleClassName);
+ }
+ }
+ return null;
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/logging/AbstractDelegatingLogger.java b/transform/src/patch/java/org/apache/cxf/common/logging/AbstractDelegatingLogger.java
new file mode 100644
index 0000000..dd3cbd5
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/logging/AbstractDelegatingLogger.java
@@ -0,0 +1,457 @@
+/**
+ * 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.cxf.common.logging;
+
+import java.util.Locale;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import java.util.logging.Filter;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+/**
+ * java.util.logging.Logger implementation delegating to another framework.
+ * All methods can be used except:
+ * setLevel
+ * addHandler / getHandlers
+ * setParent / getParent
+ * setUseParentHandlers / getUseParentHandlers
+ */
+public abstract class AbstractDelegatingLogger extends Logger {
+
+ protected AbstractDelegatingLogger(String name, String resourceBundleName) {
+ super(name, resourceBundleName);
+ }
+
+ @Override
+ public void log(LogRecord record) {
+ if (isLoggable(record.getLevel())) {
+ doLog(record);
+ }
+ }
+
+ @Override
+ public void log(Level level, String msg) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void log(Level level, String msg, Object param1) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ Object[] params = {param1 };
+ lr.setParameters(params);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void log(Level level, String msg, Object[] params) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setParameters(params);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void log(Level level, String msg, Throwable thrown) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setThrown(thrown);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void logp(Level level, String sourceClass, String sourceMethod, String msg) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object param1) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ Object[] params = {param1 };
+ lr.setParameters(params);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object[] params) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ lr.setParameters(params);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void logp(Level level, String sourceClass, String sourceMethod, String msg, Throwable thrown) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ lr.setThrown(thrown);
+ doLog(lr);
+ }
+ }
+
+
+ @Override
+ @Deprecated
+ public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ doLog(lr, bundleName);
+ }
+ }
+
+
+ @Override
+ @Deprecated
+ public void logrb(Level level, String sourceClass, String sourceMethod,
+ String bundleName, String msg, Object param1) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ Object[] params = {param1 };
+ lr.setParameters(params);
+ doLog(lr, bundleName);
+ }
+ }
+
+
+ @Override
+ @Deprecated
+ public void logrb(Level level, String sourceClass, String sourceMethod,
+ String bundleName, String msg, Object[] params) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ lr.setParameters(params);
+ doLog(lr, bundleName);
+ }
+ }
+
+ @Override
+ @Deprecated
+ public void logrb(Level level, String sourceClass, String sourceMethod,
+ String bundleName, String msg, Throwable thrown) {
+ if (isLoggable(level)) {
+ LogRecord lr = new LogRecord(level, msg);
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ lr.setThrown(thrown);
+ doLog(lr, bundleName);
+ }
+ }
+
+ @Override
+ public void entering(String sourceClass, String sourceMethod) {
+ if (isLoggable(Level.FINER)) {
+ logp(Level.FINER, sourceClass, sourceMethod, "ENTRY");
+ }
+ }
+
+ @Override
+ public void entering(String sourceClass, String sourceMethod, Object param1) {
+ if (isLoggable(Level.FINER)) {
+ Object[] params = {param1 };
+ logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", params);
+ }
+ }
+
+ @Override
+ public void entering(String sourceClass, String sourceMethod, Object[] params) {
+ if (isLoggable(Level.FINER)) {
+ String msg = "ENTRY";
+ if (params == null) {
+ logp(Level.FINER, sourceClass, sourceMethod, msg);
+ return;
+ }
+ StringBuilder builder = new StringBuilder(msg);
+ for (int i = 0; i < params.length; i++) {
+ builder.append(" {");
+ builder.append(Integer.toString(i));
+ builder.append('}');
+ }
+ logp(Level.FINER, sourceClass, sourceMethod, builder.toString(), params);
+ }
+ }
+
+ @Override
+ public void exiting(String sourceClass, String sourceMethod) {
+ if (isLoggable(Level.FINER)) {
+ logp(Level.FINER, sourceClass, sourceMethod, "RETURN");
+ }
+ }
+
+ @Override
+ public void exiting(String sourceClass, String sourceMethod, Object result) {
+ if (isLoggable(Level.FINER)) {
+ Object[] params = {result };
+ logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", params);
+ }
+ }
+
+ @Override
+ public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
+ if (isLoggable(Level.FINER)) {
+ LogRecord lr = new LogRecord(Level.FINER, "THROW");
+ lr.setSourceClassName(sourceClass);
+ lr.setSourceMethodName(sourceMethod);
+ lr.setThrown(thrown);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void severe(String msg) {
+ if (isLoggable(Level.SEVERE)) {
+ LogRecord lr = new LogRecord(Level.SEVERE, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void warning(String msg) {
+ if (isLoggable(Level.WARNING)) {
+ LogRecord lr = new LogRecord(Level.WARNING, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void info(String msg) {
+ if (isLoggable(Level.INFO)) {
+ LogRecord lr = new LogRecord(Level.INFO, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void config(String msg) {
+ if (isLoggable(Level.CONFIG)) {
+ LogRecord lr = new LogRecord(Level.CONFIG, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void fine(String msg) {
+ if (isLoggable(Level.FINE)) {
+ LogRecord lr = new LogRecord(Level.FINE, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void finer(String msg) {
+ if (isLoggable(Level.FINER)) {
+ LogRecord lr = new LogRecord(Level.FINER, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void finest(String msg) {
+ if (isLoggable(Level.FINEST)) {
+ LogRecord lr = new LogRecord(Level.FINEST, msg);
+ doLog(lr);
+ }
+ }
+
+ @Override
+ public void setLevel(Level newLevel) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public abstract Level getLevel();
+
+ @Override
+ public boolean isLoggable(Level level) {
+ Level l = getLevel();
+ return level.intValue() >= l.intValue() && l != Level.OFF;
+ }
+
+ protected boolean supportsHandlers() {
+ return false;
+ }
+
+ @Override
+ public synchronized void addHandler(Handler handler) {
+ if (supportsHandlers()) {
+ super.addHandler(handler);
+ return;
+ }
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public synchronized void removeHandler(Handler handler) {
+ if (supportsHandlers()) {
+ super.removeHandler(handler);
+ return;
+ }
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public synchronized Handler[] getHandlers() {
+ if (supportsHandlers()) {
+ return super.getHandlers();
+ }
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public synchronized void setUseParentHandlers(boolean useParentHandlers) {
+ if (supportsHandlers()) {
+ super.setUseParentHandlers(useParentHandlers);
+ return;
+ }
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public synchronized boolean getUseParentHandlers() {
+ if (supportsHandlers()) {
+ return super.getUseParentHandlers();
+ }
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Logger getParent() {
+ return null;
+ }
+
+ @Override
+ public void setParent(Logger parent) {
+ throw new UnsupportedOperationException();
+ }
+
+ protected void doLog(LogRecord lr) {
+ lr.setLoggerName(getName());
+ String rbname = getResourceBundleName();
+ if (rbname != null) {
+ lr.setResourceBundleName(rbname);
+ lr.setResourceBundle(getResourceBundle());
+ }
+ internalLog(lr);
+ }
+
+ protected void doLog(LogRecord lr, String rbname) {
+ lr.setLoggerName(getName());
+ if (rbname != null) {
+ lr.setResourceBundleName(rbname);
+ lr.setResourceBundle(loadResourceBundle(rbname));
+ }
+ internalLog(lr);
+ }
+
+ protected void internalLog(LogRecord record) {
+ Filter filter = getFilter();
+ if (filter != null && !filter.isLoggable(record)) {
+ return;
+ }
+ String msg = formatMessage(record);
+ internalLogFormatted(msg, record);
+ }
+
+ protected abstract void internalLogFormatted(String msg, LogRecord record);
+
+ protected String formatMessage(LogRecord record) {
+ String format = record.getMessage();
+ ResourceBundle catalog = record.getResourceBundle();
+ if (catalog != null) {
+ try {
+ format = catalog.getString(record.getMessage());
+ } catch (MissingResourceException ex) {
+ format = record.getMessage();
+ }
+ }
+ try {
+ Object[] parameters = record.getParameters();
+ if (parameters == null || parameters.length == 0) {
+ return format;
+ }
+ if (format.indexOf("{0") >= 0 || format.indexOf("{1") >= 0
+ || format.indexOf("{2") >= 0 || format.indexOf("{3") >= 0) {
+ return java.text.MessageFormat.format(format, parameters);
+ }
+ return format;
+ } catch (Exception ex) {
+ return format;
+ }
+ }
+
+ /**
+ * Load the specified resource bundle
+ *
+ * @param resourceBundleName
+ * the name of the resource bundle to load, cannot be null
+ * @return the loaded resource bundle.
+ * @throws java.util.MissingResourceException
+ * If the specified resource bundle can not be loaded.
+ */
+ static ResourceBundle loadResourceBundle(String resourceBundleName) {
+ // try context class loader to load the resource
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+ if (null != cl) {
+ try {
+ return ResourceBundle.getBundle(resourceBundleName, Locale.getDefault(), cl);
+ } catch (MissingResourceException e) {
+ // Failed to load using context classloader, ignore
+ }
+ }
+ // try system class loader to load the resource
+ cl = ClassLoader.getSystemClassLoader();
+ if (null != cl) {
+ try {
+ return ResourceBundle.getBundle(resourceBundleName, Locale.getDefault(), cl);
+ } catch (MissingResourceException e) {
+ // Failed to load using system classloader, ignore
+ }
+ }
+ return null;
+ }
+
+}
\ No newline at end of file
diff --git a/transform/src/patch/java/org/apache/cxf/common/logging/LogUtils.java b/transform/src/patch/java/org/apache/cxf/common/logging/LogUtils.java
new file mode 100644
index 0000000..09727e6
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/logging/LogUtils.java
@@ -0,0 +1,485 @@
+/**
+ * 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.cxf.common.logging;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.util.StringUtils;
+
+
+/**
+ * A container for static utility methods related to logging.
+ * By default, CXF logs to java.util.logging. An application can change this. To log to another system, the
+ * application must provide an object that extends {@link AbstractDelegatingLogger}, and advertise that class
+ * via one of the following mechanisms:
+ * <ul>
+ * <li>Create a file, in the classpath, named META-INF/cxf/org.apache.cxf.Logger.
+ * This file should contain the fully-qualified name
+ * of the class, with no comments, on a single line.</li>
+ * <li>Call {@link #setLoggerClass(Class)} with a Class<?> reference to the logger class.</li>
+ * </ul>
+ * CXF provides {@link Slf4jLogger} to use slf4j instead of java.util.logging.
+ */
+public final class LogUtils {
+ private static final String KEY = "org.apache.cxf.Logger";
+
+ private static final Object[] NO_PARAMETERS = new Object[0];
+
+
+ private static Class<?> loggerClass;
+
+ /**
+ * Prevents instantiation.
+ */
+ private LogUtils() {
+ }
+
+ static {
+ JDKBugHacks.doHacks();
+
+ try {
+
+ String cname = null;
+ try {
+ cname = AccessController.doPrivileged(new PrivilegedAction<String>() {
+ public String run() {
+ return System.getProperty(KEY);
+ }
+ });
+ } catch (Throwable t) {
+ //ignore - likely security exception or similar that won't allow
+ //access to the system properties. We'll continue with other methods
+ }
+ if (StringUtils.isEmpty(cname)) {
+ InputStream ins = Thread.currentThread().getContextClassLoader()
+ .getResourceAsStream("META-INF/cxf/" + KEY);
+ if (ins == null) {
+ ins = ClassLoader.getSystemResourceAsStream("META-INF/cxf/" + KEY);
+ }
+ if (ins != null) {
+ try (BufferedReader din = new BufferedReader(new InputStreamReader(ins))) {
+ cname = din.readLine();
+ }
+ }
+ }
+ if (StringUtils.isEmpty(cname)) {
+ try {
+ // This Class.forName likely will barf in OSGi, but it's OK
+ // as we'll just use j.u.l and pax-logging will pick it up fine
+ // If we don't call this and there isn't a slf4j impl avail,
+ // you get warnings printed to stderr about NOPLoggers and such
+ Class.forName("org.slf4j.impl.StaticLoggerBinder");
+ Class<?> cls = Class.forName("org.slf4j.LoggerFactory");
+ Class<?> fcls = cls.getMethod("getILoggerFactory").invoke(null).getClass();
+ String clsName = fcls.getName();
+ if (clsName.contains("NOPLogger")) {
+ //no real slf4j implementation, use j.u.l
+ cname = null;
+ } else if (clsName.contains("JDK14")
+ || clsName.contains("pax.logging")) {
+ //both of these we can use the appropriate j.u.l API's
+ //directly and have it work properly
+ cname = null;
+ } else {
+ // Either we cannot really detect where it's logging
+ // or we don't want to use a custom logger, so we'll
+ // go ahead and use the Slf4jLogger directly
+ cname = "org.apache.cxf.common.logging.Slf4jLogger";
+ }
+ } catch (Throwable t) {
+ //ignore - Slf4j not available
+ }
+ }
+ if (!StringUtils.isEmpty(cname)) {
+ try {
+ loggerClass = Class.forName(cname.trim(), true,
+ Thread.currentThread().getContextClassLoader());
+ } catch (Throwable ex) {
+ loggerClass = Class.forName(cname.trim());
+ }
+ getLogger(LogUtils.class).fine("Using " + loggerClass.getName() + " for logging.");
+ }
+ } catch (Throwable ex) {
+ //ignore - if we get here, some issue prevented the logger class from being loaded.
+ //maybe a ClassNotFound or NoClassDefFound or similar. Just use j.u.l
+ loggerClass = null;
+ }
+ }
+
+
+ /**
+ * Specify a logger class that inherits from {@link AbstractDelegatingLogger}.
+ * Enable users to use their own logger implementation.
+ */
+ public static void setLoggerClass(Class<? extends AbstractDelegatingLogger> cls) {
+ loggerClass = cls;
+ }
+
+
+ /**
+ * Get a Logger with the associated default resource bundle for the class.
+ *
+ * @param cls the Class to contain the Logger
+ * @return an appropriate Logger
+ */
+ public static Logger getLogger(Class<?> cls) {
+ return createLogger(cls, null, cls.getName());
+ }
+
+ /**
+ * Get a Logger with an associated resource bundle.
+ *
+ * @param cls the Class to contain the Logger
+ * @param resourcename the resource name
+ * @return an appropriate Logger
+ */
+ public static Logger getLogger(Class<?> cls, String resourcename) {
+ return createLogger(cls, resourcename, cls.getName());
+ }
+
+ /**
+ * Get a Logger with an associated resource bundle.
+ *
+ * @param cls the Class to contain the Logger (to find resources)
+ * @param resourcename the resource name
+ * @param loggerName the full name for the logger
+ * @return an appropriate Logger
+ */
+ public static Logger getLogger(Class<?> cls,
+ String resourcename,
+ String loggerName) {
+ return createLogger(cls, resourcename, loggerName);
+ }
+
+ /**
+ * Get a Logger with the associated default resource bundle for the class.
+ *
+ * @param cls the Class to contain the Logger
+ * @return an appropriate Logger
+ */
+ public static Logger getL7dLogger(Class<?> cls) {
+ return createLogger(cls, null, cls.getName());
+ }
+
+ /**
+ * Get a Logger with an associated resource bundle.
+ *
+ * @param cls the Class to contain the Logger
+ * @param resourcename the resource name
+ * @return an appropriate Logger
+ */
+ public static Logger getL7dLogger(Class<?> cls, String resourcename) {
+ return createLogger(cls, resourcename, cls.getName());
+ }
+
+ /**
+ * Get a Logger with an associated resource bundle.
+ *
+ * @param cls the Class to contain the Logger (to find resources)
+ * @param resourcename the resource name
+ * @param loggerName the full name for the logger
+ * @return an appropriate Logger
+ */
+ public static Logger getL7dLogger(Class<?> cls,
+ String resourcename,
+ String loggerName) {
+ return createLogger(cls, resourcename, loggerName);
+ }
+
+ /**
+ * Create a logger
+ */
+ protected static Logger createLogger(Class<?> cls,
+ String name,
+ String loggerName) {
+ ClassLoader orig = getContextClassLoader();
+ ClassLoader n = getClassLoader(cls);
+ if (n != null) {
+ setContextClassLoader(n);
+ }
+ String bundleName = name;
+ try {
+ ResourceBundle b = null;
+ if (bundleName == null) {
+ //grab the bundle prior to the call to Logger.getLogger(...) so the
+ //ResourceBundle can be loaded outside the big sync block that getLogger really is
+ bundleName = BundleUtils.getBundleName(cls);
+ try {
+ b = BundleUtils.getBundle(cls);
+ } catch (MissingResourceException rex) {
+ //ignore
+ }
+ } else {
+ bundleName = BundleUtils.getBundleName(cls, bundleName);
+ try {
+ b = BundleUtils.getBundle(cls, bundleName);
+ } catch (MissingResourceException rex) {
+ //ignore
+ }
+ }
+ if (b != null) {
+ b.getLocale();
+ }
+
+ if (loggerClass != null) {
+ try {
+ Constructor<?> cns = loggerClass.getConstructor(String.class, String.class);
+ if (name == null) {
+ try {
+ return (Logger) cns.newInstance(loggerName, bundleName);
+ } catch (InvocationTargetException ite) {
+ if (ite.getTargetException() instanceof MissingResourceException) {
+ return (Logger) cns.newInstance(loggerName, null);
+ }
+ throw ite;
+ }
+ }
+ try {
+ return (Logger) cns.newInstance(loggerName, bundleName);
+ } catch (InvocationTargetException ite) {
+ if (ite.getTargetException() instanceof MissingResourceException) {
+ throw (MissingResourceException)ite.getTargetException();
+ }
+ throw ite;
+ }
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ Logger logger;
+ try {
+ logger = Logger.getLogger(loggerName, bundleName); //NOPMD
+ } catch (IllegalArgumentException | MissingResourceException ex) {
+ //likely a mismatch on the bundle name, just return the default
+ logger = Logger.getLogger(loggerName); //NOPMD
+ }
+
+ return logger;
+ } finally {
+ if (n != orig) {
+ setContextClassLoader(orig);
+ }
+ }
+ }
+
+ private static void setContextClassLoader(final ClassLoader classLoader) {
+ final SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ AccessController.doPrivileged(new PrivilegedAction<Object>() {
+ public Object run() {
+ Thread.currentThread().setContextClassLoader(classLoader);
+ return null;
+ }
+ });
+ } else {
+ Thread.currentThread().setContextClassLoader(classLoader);
+ }
+ }
+
+ private static ClassLoader getContextClassLoader() {
+ final SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
+ public ClassLoader run() {
+ return Thread.currentThread().getContextClassLoader();
+ }
+ });
+ }
+ return Thread.currentThread().getContextClassLoader();
+ }
+
+ private static ClassLoader getClassLoader(final Class<?> clazz) {
+ final SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
+ public ClassLoader run() {
+ return clazz.getClassLoader();
+ }
+ });
+ }
+ return clazz.getClassLoader();
+ }
+
+ /**
+ * Allows both parameter substitution and a typed Throwable to be logged.
+ *
+ * @param logger the Logger the log to
+ * @param level the severity level
+ * @param message the log message
+ * @param throwable the Throwable to log
+ * @param parameter the parameter to substitute into message
+ */
+ public static void log(Logger logger,
+ Level level,
+ String message,
+ Throwable throwable,
+ Object parameter) {
+ if (logger.isLoggable(level)) {
+ final String formattedMessage =
+ MessageFormat.format(localize(logger, message), parameter);
+ doLog(logger, level, formattedMessage, throwable);
+ }
+ }
+
+ /**
+ * Allows both parameter substitution and a typed Throwable to be logged.
+ *
+ * @param logger the Logger the log to
+ * @param level the severity level
+ * @param message the log message
+ * @param throwable the Throwable to log
+ * @param parameters the parameters to substitute into message
+ */
+ public static void log(Logger logger,
+ Level level,
+ String message,
+ Throwable throwable,
+ Object... parameters) {
+ if (logger.isLoggable(level)) {
+ final String formattedMessage =
+ MessageFormat.format(localize(logger, message), parameters);
+ doLog(logger, level, formattedMessage, throwable);
+ }
+ }
+
+ /**
+ * Checks log level and logs
+ *
+ * @param logger the Logger the log to
+ * @param level the severity level
+ * @param message the log message
+ */
+ public static void log(Logger logger,
+ Level level,
+ String message) {
+ log(logger, level, message, NO_PARAMETERS);
+ }
+
+ /**
+ * Checks log level and logs
+ *
+ * @param logger the Logger the log to
+ * @param level the severity level
+ * @param message the log message
+ * @param throwable the Throwable to log
+ */
+ public static void log(Logger logger,
+ Level level,
+ String message,
+ Throwable throwable) {
+ log(logger, level, message, throwable, NO_PARAMETERS);
+ }
+
+ /**
+ * Checks log level and logs
+ *
+ * @param logger the Logger the log to
+ * @param level the severity level
+ * @param message the log message
+ * @param parameter the parameter to substitute into message
+ */
+ public static void log(Logger logger,
+ Level level,
+ String message,
+ Object parameter) {
+ log(logger, level, message, new Object[] {parameter});
+ }
+
+ /**
+ * Checks log level and logs
+ *
+ * @param logger the Logger the log to
+ * @param level the severity level
+ * @param message the log message
+ * @param parameters the parameters to substitute into message
+ */
+ public static void log(Logger logger,
+ Level level,
+ String message,
+ Object[] parameters) {
+ if (logger.isLoggable(level)) {
+ String msg = localize(logger, message);
+ try {
+ msg = MessageFormat.format(msg, parameters);
+ } catch (IllegalArgumentException ex) {
+ //ignore, log as is
+ }
+ doLog(logger, level, msg, null);
+ }
+ }
+
+ private static void doLog(Logger log, Level level, String msg, Throwable t) {
+ LogRecord record = new LogRecord(level, msg);
+
+ record.setLoggerName(log.getName());
+ record.setResourceBundleName(log.getResourceBundleName());
+ record.setResourceBundle(log.getResourceBundle());
+
+ if (t != null) {
+ record.setThrown(t);
+ }
+
+ //try to get the right class name/method name - just trace
+ //back the stack till we get out of this class
+ StackTraceElement[] stack = (new Throwable()).getStackTrace();
+ String cname = LogUtils.class.getName();
+ for (int x = 0; x < stack.length; x++) {
+ StackTraceElement frame = stack[x];
+ if (!frame.getClassName().equals(cname)) {
+ record.setSourceClassName(frame.getClassName());
+ record.setSourceMethodName(frame.getMethodName());
+ break;
+ }
+ }
+ log.log(record);
+ }
+
+ /**
+ * Retrieve localized message retrieved from a logger's resource
+ * bundle.
+ *
+ * @param logger the Logger
+ * @param message the message to be localized
+ */
+ private static String localize(Logger logger, String message) {
+ ResourceBundle bundle = logger.getResourceBundle();
+ try {
+ return bundle != null ? bundle.getString(message) : message;
+ } catch (MissingResourceException ex) {
+ //string not in the bundle
+ return message;
+ }
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/logging/RegexLoggingFilter.java b/transform/src/patch/java/org/apache/cxf/common/logging/RegexLoggingFilter.java
new file mode 100644
index 0000000..83178b9
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/logging/RegexLoggingFilter.java
@@ -0,0 +1,117 @@
+/**
+ * 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.cxf.common.logging;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class RegexLoggingFilter {
+
+ public static final String DEFAULT_REPLACEMENT = "*****";
+
+ private static class ReplaceRegEx {
+ private final Pattern pattern;
+ private final int group;
+ private final String replacement;
+
+ ReplaceRegEx(String pattern, int group, String replacement) {
+ this.pattern = Pattern.compile(pattern);
+ this.group = group;
+ this.replacement = replacement;
+ }
+
+ public CharSequence filter(CharSequence command) {
+ Matcher m = pattern.matcher(command);
+ int offset = 0;
+ while (m.find()) {
+ int origLen = command.length();
+ command = new StringBuilder(command)
+ .replace(m.start(group) + offset, m.end(group) + offset, replacement).toString();
+ offset += command.length() - origLen;
+ }
+ return command;
+ }
+ }
+
+ private String regPattern;
+ private int regGroup = 1;
+ private String regReplacement = DEFAULT_REPLACEMENT;
+
+ private List<ReplaceRegEx> regexs = new ArrayList<>();
+
+ public CharSequence filter(CharSequence command) {
+ if (regPattern != null) {
+ command = new ReplaceRegEx(regPattern, regGroup, regReplacement).filter(command);
+ }
+ for (ReplaceRegEx regex : regexs) {
+ command = regex.filter(command);
+ }
+ return command;
+ }
+
+ public void addRegEx(String pattern) {
+ addRegEx(pattern, 1);
+ }
+
+ public void addRegEx(String pattern, int group) {
+ addRegEx(pattern, group, DEFAULT_REPLACEMENT);
+ }
+
+ public void addRegEx(String pattern, int group, String replacement) {
+ regexs.add(new ReplaceRegEx(pattern, group, replacement));
+ }
+
+ public void addCommandOption(String option, String... commands) {
+ StringBuilder pattern = new StringBuilder("(");
+ for (String command : commands) {
+ if (pattern.length() > 1) {
+ pattern.append('|');
+ }
+ pattern.append(Pattern.quote(command));
+ }
+ pattern.append(") +.*?").append(Pattern.quote(option)).append(" +([^ ]+)");
+ regexs.add(new ReplaceRegEx(pattern.toString(), 2, DEFAULT_REPLACEMENT));
+ }
+
+ public String getPattern() {
+ return regPattern;
+ }
+
+ public void setPattern(String pattern) {
+ this.regPattern = pattern;
+ }
+
+ public String getReplacement() {
+ return regReplacement;
+ }
+
+ public void setReplacement(String replacement) {
+ this.regReplacement = replacement;
+ }
+
+ public int getGroup() {
+ return regGroup;
+ }
+
+ public void setGroup(int group) {
+ this.regGroup = group;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/spi/ClassGeneratorClassLoader.java b/transform/src/patch/java/org/apache/cxf/common/spi/ClassGeneratorClassLoader.java
new file mode 100644
index 0000000..5906c7a
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/spi/ClassGeneratorClassLoader.java
@@ -0,0 +1,153 @@
+/**
+ * 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.cxf.common.spi;
+
+import java.lang.ref.WeakReference;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.WeakIdentityHashMap;
+
+/** Class loader used to store and retrieve class generated during runtime to avoid class generation each time.
+ * inherited class use asmHelper to generate bytes and use @see #loadClass(String, Class<?>, byte[])
+ * or @see #loadClass(String, ClassLoader, byte[]) to store generated class.Class can be generated during buildtime.
+ * equivalent class is @see org.apache.cxf.common.spi.GeneratedClassClassLoader
+ * @author olivier dufour
+ */
+public class ClassGeneratorClassLoader {
+ protected static final Map<Class<?>, WeakReference<TypeHelperClassLoader>> CLASS_MAP
+ = new WeakIdentityHashMap<>();
+ protected static final Map<ClassLoader, WeakReference<TypeHelperClassLoader>> LOADER_MAP
+ = new WeakIdentityHashMap<>();
+ protected final Bus bus;
+
+ public ClassGeneratorClassLoader(final Bus bus) {
+ this.bus = bus == null ? BusFactory.getDefaultBus() : bus;
+ }
+
+ protected Class<?> loadClass(String className, Class<?> cls, byte[] bytes) {
+ GeneratedClassClassLoaderCapture capture = bus.getExtension(GeneratedClassClassLoaderCapture.class);
+ if (capture != null) {
+ capture.capture(className, bytes);
+ }
+ TypeHelperClassLoader loader = getOrCreateLoader(cls);
+ synchronized (loader) {
+ Class<?> clz = loader.lookupDefinedClass(className);
+ if (clz == null) {
+ return loader.defineClass(className, bytes);
+ }
+ return clz;
+ }
+ }
+ protected Class<?> loadClass(String className, ClassLoader l, byte[] bytes) {
+ GeneratedClassClassLoaderCapture capture = bus.getExtension(GeneratedClassClassLoaderCapture.class);
+ if (capture != null) {
+ capture.capture(className, bytes);
+ }
+ TypeHelperClassLoader loader = getOrCreateLoader(l);
+ synchronized (loader) {
+ Class<?> clz = loader.lookupDefinedClass(className);
+ if (clz == null) {
+ return loader.defineClass(className, bytes);
+ }
+ return clz;
+ }
+ }
+ protected Class<?> findClass(String className, Class<?> cls) {
+ return getOrCreateLoader(cls).lookupDefinedClass(className);
+ }
+
+ protected Class<?> findClass(String className, ClassLoader classLoader) {
+ return getOrCreateLoader(classLoader).lookupDefinedClass(className);
+ }
+
+ private static synchronized TypeHelperClassLoader getOrCreateLoader(Class<?> cls) {
+ WeakReference<TypeHelperClassLoader> ref = CLASS_MAP.get(cls);
+ TypeHelperClassLoader ret;
+ if (ref == null || ref.get() == null) {
+ ret = new TypeHelperClassLoader(cls.getClassLoader());
+ CLASS_MAP.put(cls, new WeakReference<>(ret));
+ } else {
+ ret = ref.get();
+ }
+ return ret;
+ }
+
+ private static synchronized TypeHelperClassLoader getOrCreateLoader(ClassLoader l) {
+ WeakReference<TypeHelperClassLoader> ref = LOADER_MAP.get(l);
+ TypeHelperClassLoader ret;
+ if (ref == null || ref.get() == null) {
+ ret = new TypeHelperClassLoader(l);
+ LOADER_MAP.put(l, new WeakReference<>(ret));
+ } else {
+ ret = ref.get();
+ }
+ return ret;
+ }
+
+ public static class TypeHelperClassLoader extends ClassLoader {
+ private final ConcurrentHashMap<String, Class<?>> defined = new ConcurrentHashMap<>();
+
+ TypeHelperClassLoader(ClassLoader parent) {
+ super(parent);
+ }
+
+ public Class<?> lookupDefinedClass(String name) {
+ return defined.get(StringUtils.slashesToPeriod(name));
+ }
+
+ @Override
+ protected Class<?> findClass(String name) throws ClassNotFoundException {
+ if (name.endsWith("package-info")) {
+ return getParent().loadClass(name);
+ }
+ return super.findClass(name);
+ }
+
+ public Class<?> defineClass(String name, byte[] bytes) {
+ Class<?> ret = defined.get(StringUtils.slashesToPeriod(name));
+ if (ret != null) {
+ return ret;
+ }
+ if (name.endsWith("package-info")) {
+ String s = name.substring(0, name.length() - 13);
+ Package p = super.getPackage(s);
+ if (p == null) {
+ definePackage(StringUtils.slashesToPeriod(s),
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null);
+ }
+ }
+
+ ret = defined.computeIfAbsent(StringUtils.slashesToPeriod(name),
+ key -> TypeHelperClassLoader.super.defineClass(key, bytes, 0, bytes.length));
+
+ return ret;
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/spi/NamespaceClassGenerator.java b/transform/src/patch/java/org/apache/cxf/common/spi/NamespaceClassGenerator.java
new file mode 100644
index 0000000..48c755b
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/spi/NamespaceClassGenerator.java
@@ -0,0 +1,450 @@
+/**
+ * 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.cxf.common.spi;
+
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ASMHelper;
+import org.apache.cxf.common.util.OpcodesProxy;
+
+public class NamespaceClassGenerator extends ClassGeneratorClassLoader implements NamespaceClassCreator {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(ClassGeneratorClassLoader.class);
+ private final ASMHelper helper;
+
+ public NamespaceClassGenerator(Bus bus) {
+ super(bus);
+ helper = bus.getExtension(ASMHelper.class);
+ }
+
+ @Override
+ public synchronized Class<?> createNamespaceWrapperClass(Class<?> mcls, Map<String, String> map) {
+ String postFix = "";
+
+ if (mcls.getName().contains("eclipse")) {
+ return createEclipseNamespaceMapper();
+ } else if (mcls.getName().contains(".internal")) {
+ postFix = "Internal";
+ } else if (mcls.getName().contains("com.sun")) {
+ postFix = "RI";
+ }
+
+ String className = "org.apache.cxf.jaxb.NamespaceMapper";
+ className += postFix;
+ Class<?> cls = findClass(className, NamespaceClassCreator.class);
+ Throwable t = null;
+ if (cls == null) {
+ try {
+ byte[] bts = createNamespaceWrapperInternal(postFix);
+ className = "org.apache.cxf.jaxb.NamespaceMapper" + postFix;
+ return loadClass(className, NamespaceClassCreator.class, bts);
+ } catch (RuntimeException ex) {
+ // continue
+ t = ex;
+ }
+ }
+ if (cls == null
+ && (!mcls.getName().contains(".internal.") && mcls.getName().contains("com.sun"))) {
+ try {
+ cls = ClassLoaderUtils.loadClass("org.apache.cxf.common.jaxb.NamespaceMapper",
+ NamespaceClassCreator.class);
+ } catch (Throwable ex2) {
+ // ignore
+ t = ex2;
+ }
+ }
+ LOG.log(Level.INFO, "Could not create a NamespaceMapper compatible with Marshaller class " + mcls.getName(), t);
+ return cls;
+ }
+
+ private Class<?> createEclipseNamespaceMapper() {
+ String className = "org.apache.cxf.jaxb.EclipseNamespaceMapper";
+ Class<?> cls = findClass(className, NamespaceClassCreator.class);
+ if (cls != null) {
+ return cls;
+ }
+ byte[] bts = doCreateEclipseNamespaceMapper();
+ //previous code use mcls instead of NamespaceClassGenerator.class
+ return loadClass(className, NamespaceClassCreator.class, bts);
+ }
+
+ /*
+ // This is the "prototype" for the ASM generated class below
+ public static class MapNamespacePrefixMapper2
+ extends org.eclipse.persistence.internal.oxm.record.namespaces.MapNamespacePrefixMapper {
+
+ String[] nsctxt;
+
+ public MapNamespacePrefixMapper2(Map<String, String> foo) {
+ super(foo);
+ }
+ public String[] getPreDeclaredNamespaceUris() {
+ String[] sup = super.getPreDeclaredNamespaceUris();
+ if (nsctxt == null) {
+ return sup;
+ }
+ List<String> s = new ArrayList<>(Arrays.asList(sup));
+ for (int x = 1; x < nsctxt.length; x = x + 2) {
+ s.remove(nsctxt[x]);
+ }
+ return s.toArray(new String[s.size()]);
+ }
+ public void setContextualNamespaceDecls(String[] f) {
+ nsctxt = f;
+ }
+ public String[] getContextualNamespaceDecls() {
+ return nsctxt;
+ }
+ }
+ */
+ //CHECKSTYLE:OFF
+ //bunch of really long ASM based methods that cannot be shortened easily
+ private byte[] doCreateEclipseNamespaceMapper() {
+ OpcodesProxy Opcodes = helper.getOpCodes();
+ String slashedName = "org/apache/cxf/jaxb/EclipseNamespaceMapper";
+ ASMHelper.ClassWriter cw = helper.createClassWriter();
+ if (cw == null) {
+ return null;
+ }
+ String superName = "org/eclipse/persistence/internal/oxm/record/namespaces/MapNamespacePrefixMapper";
+ ASMHelper.FieldVisitor fv;
+ ASMHelper.MethodVisitor mv;
+ cw.visit(Opcodes.V1_6,
+ Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER,
+ slashedName, null,
+ superName, null);
+
+ cw.visitSource("EclipseNamespaceMapper.java", null);
+
+ fv = cw.visitField(Opcodes.ACC_PRIVATE, "nsctxt", "[Ljava/lang/String;", null, null);
+ fv.visitEnd();
+
+
+ mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "(Ljava/util/Map;)V",
+ "(Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;)V", null);
+ mv.visitCode();
+ ASMHelper.Label l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL,
+ superName, "<init>", "(Ljava/util/Map;)V", false);
+ ASMHelper.Label l1 = helper.createLabel();
+ mv.visitLabel(l1);
+ mv.visitInsn(Opcodes.RETURN);
+ ASMHelper.Label l2 = helper.createLabel();
+ mv.visitLabel(l2);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+
+ mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "setContextualNamespaceDecls", "([Ljava/lang/String;)V",
+ null, null);
+ mv.visitCode();
+ l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(47, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitFieldInsn(Opcodes.PUTFIELD, slashedName, "nsctxt", "[Ljava/lang/String;");
+ l1 = helper.createLabel();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(48, l1);
+ mv.visitInsn(Opcodes.RETURN);
+ l2 = helper.createLabel();
+ mv.visitLabel(l2);
+ mv.visitLocalVariable("this", "L" + slashedName + ";", null, l0, l2, 0);
+ mv.visitLocalVariable("contextualNamespaceDecls", "[Ljava/lang/String;", null, l0, l2, 1);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "getContextualNamespaceDecls", "()[Ljava/lang/String;", null, null);
+ mv.visitCode();
+ l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(51, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, slashedName, "nsctxt", "[Ljava/lang/String;");
+ mv.visitInsn(Opcodes.ARETURN);
+ l1 = helper.createLabel();
+
+ mv.visitLabel(l1);
+ mv.visitLocalVariable("this", "L" + slashedName + ";", null, l0, l1, 0);
+
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+
+ mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "getPreDeclaredNamespaceUris", "()[Ljava/lang/String;", null, null);
+ mv.visitCode();
+ l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(1036, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL,
+ superName,
+ "getPreDeclaredNamespaceUris", "()[Ljava/lang/String;", false);
+ mv.visitVarInsn(Opcodes.ASTORE, 1);
+ l1 = helper.createLabel();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(1037, l1);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, slashedName, "nsctxt", "[Ljava/lang/String;");
+ l2 = helper.createLabel();
+ mv.visitJumpInsn(Opcodes.IFNONNULL, l2);
+ ASMHelper.Label l3 = helper.createLabel();
+ mv.visitLabel(l3);
+ mv.visitLineNumber(1038, l3);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitInsn(Opcodes.ARETURN);
+ mv.visitLabel(l2);
+ mv.visitLineNumber(1040, l2);
+ mv.visitFrame(Opcodes.F_APPEND, 1, new Object[] {"[Ljava/lang/String;"}, 0, null);
+ mv.visitTypeInsn(Opcodes.NEW, "java/util/ArrayList");
+ mv.visitInsn(Opcodes.DUP);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/util/Arrays", "asList",
+ "([Ljava/lang/Object;)Ljava/util/List;", false);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/util/ArrayList", "<init>",
+ "(Ljava/util/Collection;)V", false);
+ mv.visitVarInsn(Opcodes.ASTORE, 2);
+ ASMHelper.Label l4 = helper.createLabel();
+ mv.visitLabel(l4);
+ mv.visitLineNumber(1041, l4);
+ mv.visitInsn(Opcodes.ICONST_1);
+ mv.visitVarInsn(Opcodes.ISTORE, 3);
+ ASMHelper.Label l5 = helper.createLabel();
+ mv.visitLabel(l5);
+ ASMHelper.Label l6 = helper.createLabel();
+ mv.visitJumpInsn(Opcodes.GOTO, l6);
+ ASMHelper.Label l7 = helper.createLabel();
+ mv.visitLabel(l7);
+ mv.visitLineNumber(1042, l7);
+ mv.visitFrame(Opcodes.F_APPEND, 2, new Object[] {"java/util/List", Opcodes.INTEGER}, 0, null);
+ mv.visitVarInsn(Opcodes.ALOAD, 2);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, slashedName, "nsctxt", "[Ljava/lang/String;");
+ mv.visitVarInsn(Opcodes.ILOAD, 3);
+ mv.visitInsn(Opcodes.AALOAD);
+ mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/List", "remove", "(Ljava/lang/Object;)Z", true);
+ mv.visitInsn(Opcodes.POP);
+ ASMHelper.Label l8 = helper.createLabel();
+ mv.visitLabel(l8);
+ mv.visitLineNumber(1041, l8);
+ mv.visitIincInsn(3, 2);
+ mv.visitLabel(l6);
+ mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+ mv.visitVarInsn(Opcodes.ILOAD, 3);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD,
+ slashedName,
+ "nsctxt", "[Ljava/lang/String;");
+ mv.visitInsn(Opcodes.ARRAYLENGTH);
+ mv.visitJumpInsn(Opcodes.IF_ICMPLT, l7);
+ ASMHelper.Label l9 = helper.createLabel();
+ mv.visitLabel(l9);
+ mv.visitLineNumber(1044, l9);
+ mv.visitVarInsn(Opcodes.ALOAD, 2);
+ mv.visitVarInsn(Opcodes.ALOAD, 2);
+ mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/List", "size", "()I", true);
+ mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/String");
+ mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/List",
+ "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", true);
+ mv.visitTypeInsn(Opcodes.CHECKCAST, "[Ljava/lang/String;");
+ mv.visitInsn(Opcodes.ARETURN);
+ ASMHelper.Label l10 = helper.createLabel();
+ mv.visitLabel(l10);
+ mv.visitLocalVariable("this", "L" + slashedName + ";",
+ null, l0, l10, 0);
+ mv.visitLocalVariable("sup", "[Ljava/lang/String;", null, l1, l10, 1);
+ mv.visitLocalVariable("s", "Ljava/util/List;", "Ljava/util/List<Ljava/lang/String;>;", l4, l10, 2);
+ mv.visitLocalVariable("x", "I", null, l5, l9, 3);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ cw.visitEnd();
+
+ return cw.toByteArray();
+ }
+
+ private byte[] createNamespaceWrapperInternal(String postFix) {
+
+ String superName = "com/sun/xml/"
+ + ("RI".equals(postFix) ? "" : "internal/")
+ + "bind/marshaller/NamespacePrefixMapper";
+ String postFixedName = "org/apache/cxf/jaxb/NamespaceMapper" + postFix;
+ ASMHelper.ClassWriter cw = helper.createClassWriter();
+ if (cw == null) {
+ return null;
+ }
+ ASMHelper.FieldVisitor fv;
+ ASMHelper.MethodVisitor mv;
+ OpcodesProxy opcodes= helper.getOpCodes();
+ cw.visit(opcodes.V1_6,
+ opcodes.ACC_PUBLIC + opcodes.ACC_FINAL + opcodes.ACC_SUPER,
+ postFixedName, null,
+ superName, null);
+
+ cw.visitSource("NamespaceMapper.java", null);
+
+ fv = cw.visitField(opcodes.ACC_PRIVATE + opcodes.ACC_FINAL,
+ "nspref", "Ljava/util/Map;",
+ "Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;", null);
+ fv.visitEnd();
+
+ fv = cw.visitField(opcodes.ACC_PRIVATE, "nsctxt", "[Ljava/lang/String;", null, null);
+ fv.visitEnd();
+
+ fv = cw.visitField(opcodes.ACC_PRIVATE + opcodes.ACC_FINAL + opcodes.ACC_STATIC,
+ "EMPTY_STRING", "[Ljava/lang/String;", null, null);
+ fv.visitEnd();
+
+ mv = cw.visitMethod(opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
+ mv.visitCode();
+ ASMHelper.Label l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(30, l0);
+ mv.visitInsn(opcodes.ICONST_0);
+ mv.visitTypeInsn(opcodes.ANEWARRAY, "java/lang/String");
+ mv.visitFieldInsn(opcodes.PUTSTATIC, postFixedName, "EMPTY_STRING", "[Ljava/lang/String;");
+ mv.visitInsn(opcodes.RETURN);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ mv = cw.visitMethod(opcodes.ACC_PUBLIC, "<init>",
+ "(Ljava/util/Map;)V",
+ "(Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;)V", null);
+ mv.visitCode();
+ l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(32, l0);
+ mv.visitVarInsn(opcodes.ALOAD, 0);
+ mv.visitMethodInsn(opcodes.INVOKESPECIAL, superName, "<init>", "()V", false);
+ ASMHelper.Label l1 = helper.createLabel();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(29, l1);
+ mv.visitVarInsn(opcodes.ALOAD, 0);
+ mv.visitFieldInsn(opcodes.GETSTATIC, postFixedName, "EMPTY_STRING", "[Ljava/lang/String;");
+ mv.visitFieldInsn(opcodes.PUTFIELD, postFixedName, "nsctxt", "[Ljava/lang/String;");
+ ASMHelper.Label l2 = helper.createLabel();
+ mv.visitLabel(l2);
+ mv.visitLineNumber(33, l2);
+ mv.visitVarInsn(opcodes.ALOAD, 0);
+ mv.visitVarInsn(opcodes.ALOAD, 1);
+ mv.visitFieldInsn(opcodes.PUTFIELD, postFixedName, "nspref", "Ljava/util/Map;");
+ ASMHelper.Label l3 = helper.createLabel();
+ mv.visitLabel(l3);
+ mv.visitLineNumber(34, l3);
+ mv.visitInsn(opcodes.RETURN);
+ ASMHelper.Label l4 = helper.createLabel();
+ mv.visitLabel(l4);
+ mv.visitLocalVariable("this", "L" + postFixedName + ";", null, l0, l4, 0);
+ mv.visitLocalVariable("nspref",
+ "Ljava/util/Map;", "Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;",
+ l0, l4, 1);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ mv = cw.visitMethod(opcodes.ACC_PUBLIC, "getPreferredPrefix",
+ "(Ljava/lang/String;Ljava/lang/String;Z)Ljava/lang/String;",
+ null, null);
+ mv.visitCode();
+ l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(39, l0);
+ mv.visitVarInsn(opcodes.ALOAD, 0);
+ mv.visitFieldInsn(opcodes.GETFIELD, postFixedName, "nspref", "Ljava/util/Map;");
+ mv.visitVarInsn(opcodes.ALOAD, 1);
+ mv.visitMethodInsn(opcodes.INVOKEINTERFACE, "java/util/Map",
+ "get", "(Ljava/lang/Object;)Ljava/lang/Object;", true);
+ mv.visitTypeInsn(opcodes.CHECKCAST, "java/lang/String");
+ mv.visitVarInsn(opcodes.ASTORE, 4);
+ l1 = helper.createLabel();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(40, l1);
+ mv.visitVarInsn(opcodes.ALOAD, 4);
+ l2 = helper.createLabel();
+ mv.visitJumpInsn(opcodes.IFNULL, l2);
+ l3 = helper.createLabel();
+ mv.visitLabel(l3);
+ mv.visitLineNumber(41, l3);
+ mv.visitVarInsn(opcodes.ALOAD, 4);
+ mv.visitInsn(opcodes.ARETURN);
+ mv.visitLabel(l2);
+ mv.visitLineNumber(43, l2);
+ mv.visitFrame(opcodes.F_APPEND, 1, new Object[] {"java/lang/String"}, 0, null);
+ mv.visitVarInsn(opcodes.ALOAD, 2);
+ mv.visitInsn(opcodes.ARETURN);
+ l4 = helper.createLabel();
+ mv.visitLabel(l4);
+ mv.visitLocalVariable("this", "L" + postFixedName + ";", null, l0, l4, 0);
+ mv.visitLocalVariable("namespaceUri", "Ljava/lang/String;", null, l0, l4, 1);
+ mv.visitLocalVariable("suggestion", "Ljava/lang/String;", null, l0, l4, 2);
+ mv.visitLocalVariable("requirePrefix", "Z", null, l0, l4, 3);
+ mv.visitLocalVariable("prefix", "Ljava/lang/String;", null, l1, l4, 4);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ mv = cw.visitMethod(opcodes.ACC_PUBLIC, "setContextualNamespaceDecls", "([Ljava/lang/String;)V", null, null);
+ mv.visitCode();
+ l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(47, l0);
+ mv.visitVarInsn(opcodes.ALOAD, 0);
+ mv.visitVarInsn(opcodes.ALOAD, 1);
+ mv.visitFieldInsn(opcodes.PUTFIELD, postFixedName, "nsctxt", "[Ljava/lang/String;");
+ l1 = helper.createLabel();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(48, l1);
+ mv.visitInsn(opcodes.RETURN);
+ l2 = helper.createLabel();
+ mv.visitLabel(l2);
+ mv.visitLocalVariable("this", "L" + postFixedName + ";", null, l0, l2, 0);
+ mv.visitLocalVariable("contextualNamespaceDecls", "[Ljava/lang/String;", null, l0, l2, 1);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ mv = cw.visitMethod(opcodes.ACC_PUBLIC, "getContextualNamespaceDecls", "()[Ljava/lang/String;", null, null);
+ mv.visitCode();
+ l0 = helper.createLabel();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(51, l0);
+ mv.visitVarInsn(opcodes.ALOAD, 0);
+ mv.visitFieldInsn(opcodes.GETFIELD, postFixedName, "nsctxt", "[Ljava/lang/String;");
+ mv.visitInsn(opcodes.ARETURN);
+ l1 = helper.createLabel();
+
+ mv.visitLabel(l1);
+ mv.visitLocalVariable("this", "L" + postFixedName + ";", null, l0, l1, 0);
+
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ cw.visitEnd();
+
+ return cw.toByteArray();
+ }
+ //CHECKSTYLE:ON
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/ASMHelperImpl.java b/transform/src/patch/java/org/apache/cxf/common/util/ASMHelperImpl.java
new file mode 100644
index 0000000..cc01f14
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/ASMHelperImpl.java
@@ -0,0 +1,273 @@
+/**
+ * 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.cxf.common.util;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+
+
+public class ASMHelperImpl implements ASMHelper {
+ protected static final Map<Class<?>, String> PRIMITIVE_MAP = new HashMap<>();
+ protected static final Map<Class<?>, String> NONPRIMITIVE_MAP = new HashMap<>();
+ protected static final Map<Class<?>, Integer> PRIMITIVE_ZERO_MAP = new HashMap<>();
+
+ protected boolean badASM;
+ private Class<?> cwClass;
+
+ public ASMHelperImpl() {
+
+ }
+
+ static {
+ PRIMITIVE_MAP.put(Byte.TYPE, "B");
+ PRIMITIVE_MAP.put(Boolean.TYPE, "Z");
+ PRIMITIVE_MAP.put(Long.TYPE, "J");
+ PRIMITIVE_MAP.put(Integer.TYPE, "I");
+ PRIMITIVE_MAP.put(Short.TYPE, "S");
+ PRIMITIVE_MAP.put(Character.TYPE, "C");
+ PRIMITIVE_MAP.put(Float.TYPE, "F");
+ PRIMITIVE_MAP.put(Double.TYPE, "D");
+
+ NONPRIMITIVE_MAP.put(Byte.TYPE, Byte.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Boolean.TYPE, Boolean.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Long.TYPE, Long.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Integer.TYPE, Integer.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Short.TYPE, Short.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Character.TYPE, Character.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Float.TYPE, Float.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Double.TYPE, Double.class.getName().replaceAll("\\.", "/"));
+ }
+
+ private void tryClass(String s) {
+ if (cwClass == null) {
+ try {
+ Class<?> c2 = ClassLoaderUtils.loadClass(s, ASMHelperImpl.class);
+
+ //old versions don't have this, but we need it
+ Class<?> cls = ClassLoaderUtils.loadClass(c2.getPackage().getName() + ".MethodVisitor", c2);
+ cls.getMethod("visitFrame", Integer.TYPE, Integer.TYPE,
+ Object[].class, Integer.TYPE, Object[].class);
+ cwClass = c2;
+ } catch (Throwable t) {
+ //ignore
+ }
+ }
+ }
+ private Class<?> getASMClassWriterClass() {
+ //force this to make sure the proper OSGi import is generated
+ return org.objectweb.asm.ClassWriter.class;
+ }
+
+ public synchronized Class<?> getASMClass() throws ClassNotFoundException {
+ if (cwClass == null) {
+ //try the "real" asm first, then the others
+ tryClass("org.objectweb.asm.ClassWriter");
+ tryClass("org.apache.xbean.asm9.ClassWriter");
+ tryClass("org.apache.xbean.asm8.ClassWriter");
+ tryClass("org.apache.xbean.asm7.ClassWriter");
+ tryClass("org.apache.xbean.asm5.ClassWriter");
+ tryClass("org.apache.xbean.asm6.ClassWriter");
+ tryClass("org.apache.xbean.asm4.ClassWriter");
+ tryClass("org.apache.xbean.asm.ClassWriter");
+ tryClass("org.springframework.asm.ClassWriter");
+ if (cwClass == null) {
+ cwClass = getASMClassWriterClass();
+ }
+ }
+ return cwClass;
+ }
+ public OpcodesProxy getOpCodes() {
+ OpcodesProxy ops = new OpcodesProxy(this);
+ PRIMITIVE_ZERO_MAP.put(Byte.TYPE, ops.ICONST_0);
+ PRIMITIVE_ZERO_MAP.put(Boolean.TYPE, ops.ICONST_0);
+ PRIMITIVE_ZERO_MAP.put(Long.TYPE, ops.LCONST_0);
+ PRIMITIVE_ZERO_MAP.put(Integer.TYPE, ops.ICONST_0);
+ PRIMITIVE_ZERO_MAP.put(Short.TYPE, ops.ICONST_0);
+ PRIMITIVE_ZERO_MAP.put(Character.TYPE, ops.ICONST_0);
+ PRIMITIVE_ZERO_MAP.put(Float.TYPE, ops.FCONST_0);
+ PRIMITIVE_ZERO_MAP.put(Double.TYPE, ops.DCONST_0);
+ return ops;
+ }
+ public void setBadASM(boolean b) {
+ badASM = b;
+ }
+
+ public String getMethodSignature(Method m) {
+ StringBuilder buf = new StringBuilder("(");
+ for (Class<?> cl : m.getParameterTypes()) {
+ buf.append(getClassCode(cl));
+ }
+ buf.append(')');
+ buf.append(getClassCode(m.getReturnType()));
+
+ return buf.toString();
+ }
+
+ @Override
+ public String getNonPrimitive(Class<?> tp) {
+ return NONPRIMITIVE_MAP.get(tp);
+ }
+ @Override
+ public String getPrimitive(Class<?> tp) {
+ return PRIMITIVE_MAP.get(tp);
+ }
+
+
+
+
+ public String getClassCode(Class<?> cl) {
+ if (cl == Void.TYPE) {
+ return "V";
+ }
+ if (cl.isPrimitive()) {
+ return PRIMITIVE_MAP.get(cl);
+ }
+ if (cl.isArray()) {
+ return "[" + getClassCode(cl.getComponentType());
+ }
+ return "L" + StringUtils.periodToSlashes(cl.getName()) + ";";
+ }
+ public String getClassCode(java.lang.reflect.Type type) {
+ if (type instanceof Class) {
+ return getClassCode((Class<?>)type);
+ } else if (type instanceof GenericArrayType) {
+ GenericArrayType at = (GenericArrayType)type;
+ return "[" + getClassCode(at.getGenericComponentType());
+ } else if (type instanceof TypeVariable) {
+ TypeVariable<?> tv = (TypeVariable<?>)type;
+ java.lang.reflect.Type[] bounds = tv.getBounds();
+ if (bounds != null && bounds.length == 1) {
+ return getClassCode(bounds[0]);
+ }
+ throw new IllegalArgumentException("Unable to determine type for: " + tv);
+ } else if (type instanceof ParameterizedType) {
+ ParameterizedType pt = (ParameterizedType)type;
+ StringBuilder a = new StringBuilder(getClassCode(pt.getRawType()));
+ if (!pt.getRawType().equals(Enum.class)) {
+ a.setLength(a.length() - 1);
+ a.append('<');
+
+ for (java.lang.reflect.Type t : pt.getActualTypeArguments()) {
+ a.append(getClassCode(t));
+ }
+ a.append(">;");
+ }
+ return a.toString();
+ } else if (type instanceof WildcardType) {
+ WildcardType wt = (WildcardType)type;
+ StringBuilder a = new StringBuilder();
+ java.lang.reflect.Type[] lowBounds = wt.getLowerBounds();
+ java.lang.reflect.Type[] upBounds = wt.getUpperBounds();
+ for (java.lang.reflect.Type t : upBounds) {
+ a.append('+');
+ a.append(getClassCode(t));
+ }
+ for (java.lang.reflect.Type t : lowBounds) {
+ a.append('-');
+ a.append(getClassCode(t));
+ }
+ return a.toString();
+ }
+ return null;
+ }
+
+ public ClassWriter createClassWriter() {
+ Object newCw = null;
+ if (!badASM) {
+ if (cwClass == null) {
+ try {
+ cwClass = getASMClass();
+ } catch (Throwable error) {
+ badASM = true;
+ throw new RuntimeException("No ASM ClassWriterFound", error);
+ }
+ }
+ // ASM >= 3.x (since cxf is java 8 min we don't care of asm 1/2)
+ try {
+ Constructor<?> cons = cwClass.getConstructor(Integer.TYPE);
+ int i = cwClass.getField("COMPUTE_MAXS").getInt(null);
+ i |= cwClass.getField("COMPUTE_FRAMES").getInt(null);
+ newCw = cons.newInstance(Integer.valueOf(i));
+ } catch (Throwable e1) {
+ // ignore
+ }
+ }
+ if (newCw != null) {
+ return ReflectionInvokationHandler.createProxyWrapper(newCw, ClassWriter.class);
+ }
+ return null;
+ }
+
+
+ public ASMType getType(final String type) {
+ try {
+ final Class<?> cls = ClassLoaderUtils.loadClass(cwClass.getPackage().getName() + ".Type", cwClass);
+ final Method m = cls.getMethod("getType", String.class);
+ final Method m2 = cls.getMethod("getOpcode", Integer.TYPE);
+ @SuppressWarnings("unused")
+ ASMType t = new ASMType() {
+ Object tp = ReflectionUtil.setAccessible(m).invoke(null, type);
+ public Object getValue() {
+ return tp;
+ }
+ public Class<?> realType() {
+ return cls;
+ }
+ public int getOpcode(int ireturn) {
+ try {
+ return (Integer)ReflectionUtil.setAccessible(m2).invoke(tp, ireturn);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+ };
+ return t;
+ } catch (Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+ public Label createLabel() {
+ try {
+ final Class<?> cls = ClassLoaderUtils.loadClass(cwClass.getPackage().getName() + ".Label",
+ cwClass);
+ @SuppressWarnings("unused")
+ Label l = new Label() {
+ Object l = cls.newInstance();
+ public Object getValue() {
+ return l;
+ }
+ public Class<?> realType() {
+ return cls;
+ }
+ };
+ return l;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/Base64Utility.java b/transform/src/patch/java/org/apache/cxf/common/util/Base64Utility.java
new file mode 100644
index 0000000..043eba7
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/Base64Utility.java
@@ -0,0 +1,474 @@
+/**
+ * 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.cxf.common.util;
+
+/**
+ * Base64Utility - this static class provides useful base64
+ * encoding utilities.
+ */
+
+// Java imports
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.nio.CharBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.logging.Logger;
+
+import org.apache.cxf.common.i18n.Message;
+import org.apache.cxf.common.logging.LogUtils;
+
+
+/**
+ * This class converts to/from base64. The alternative conversions include:
+ *
+ * encode:
+ * byte[] into String
+ * byte[] into char[]
+ * byte[] into OutStream
+ * byte[] into Writer
+ * decode:
+ * char[] into byte[]
+ * String into byte[]
+ * char[] into OutStream
+ * String into OutStream
+ *
+ */
+public final class Base64Utility {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(Base64Utility.class);
+
+
+ // base 64 character set
+ //
+ private static final char[] BCS = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+ 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
+ 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
+ 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', '+', '/'
+ };
+
+ private static final char[] BCS_URL_SAFE = Arrays.copyOf(BCS, BCS.length);
+
+ // base 64 padding
+ private static final char PAD = '=';
+
+ // size of base 64 decode table
+ private static final int BDTSIZE = 128;
+
+ // base 64 decode table
+ private static final byte[] BDT = new byte[128];
+
+
+ private static final int PAD_SIZE0 = 1;
+ private static final int PAD_SIZE4 = 2;
+ private static final int PAD_SIZE8 = 3;
+
+ // class static initializer for building decode table
+ static {
+ for (int i = 0; i < BDTSIZE; i++) {
+ BDT[i] = Byte.MAX_VALUE;
+ }
+
+ for (int i = 0; i < BCS.length; i++) {
+ BDT[BCS[i]] = (byte)i;
+ }
+
+ BCS_URL_SAFE[62] = '-';
+ BCS_URL_SAFE[63] = '_';
+ }
+
+
+ private Base64Utility() {
+ //utility class, never constructed
+ }
+
+
+
+ /**
+ * The <code>decode_chunk</code> routine decodes a chunk of data
+ * into its native encoding.
+ *
+ * base64 encodes each 3 octets of data into 4 characters from a
+ * limited 64 character set. The 3 octets are joined to form
+ * 24 bits which are then split into 4 x 6bit values. Each 6 bit
+ * value is then used as an index into the 64 character table of
+ * base64 chars. If the total data length is not a 3 octet multiple
+ * the '=' char is used as padding for the final 4 char group,
+ * either 1 octet + '==' or 2 octets + '='.
+ *
+ * @param id The input data to be processed
+ * @param o The offset from which to begin processing
+ * @param l The length (bound) at which processing is to end
+ * @return The decoded data
+ * @exception Base64Exception Thrown is processing fails due to
+ * formatting exceptions in the encoded data
+ */
+ public static byte[] decodeChunk(char[] id,
+ int o,
+ int l)
+ throws Base64Exception {
+
+ if (id != null && id.length == 0 && l == 0) {
+ return new byte[0];
+ }
+
+ // Keep it simple - must be >= 4. Unpadded
+ // base64 data contain < 3 octets is invalid.
+ //
+ if ((l - o) < 4) {
+ return null;
+ }
+
+ char[] ib = new char[4];
+ int ibcount = 0;
+
+ // cryan. Calc the num of octets. Each 4 chars of base64 chars
+ // (representing 24 bits) encodes 3 octets.
+ //
+ int octetCount = 3 * (l / 4);
+
+ // Final 4 chars may contain 3 octets or padded to contain
+ // 1 or 2 octets.
+ //
+ if (id[l - 1] == PAD) {
+ // TT== means last 4 chars encode 8 bits (ie subtract 2)
+ // TTT= means last 4 chars encode 16 bits (ie subtract 1)
+ octetCount -= (id[l - 2] == PAD) ? 2 : 1;
+ }
+
+ byte[] ob = new byte[octetCount];
+ int obcount = 0;
+
+ for (int i = o; i < o + l && i < id.length; i++) {
+ if (id[i] == PAD
+ || id[i] < BDT.length
+ && BDT[id[i]] != Byte.MAX_VALUE) {
+
+ ib[ibcount++] = id[i];
+
+ // Decode each 4 char sequence.
+ //
+ if (ibcount == ib.length) {
+ ibcount = 0;
+ obcount += processEncodeme(ib, ob, obcount);
+ }
+ }
+ }
+
+ if (obcount != ob.length) {
+ byte []tmp = new byte[obcount];
+ System.arraycopy(ob, 0, tmp, 0, obcount);
+ ob = tmp;
+ }
+
+ return ob;
+ }
+
+ public static byte[] decode(String id) throws Base64Exception {
+ return decode(id, false);
+ }
+
+ public static byte[] decode(String id, boolean urlSafe) throws Base64Exception {
+ if (urlSafe) {
+ id = id.replace('-', '+').replace('_', '/');
+ switch (id.length() % 4) {
+ case 0:
+ break;
+ case 2:
+ id += "==";
+ break;
+ case 3:
+ id += "=";
+ break;
+ default:
+ throw new Base64Exception(new Message("BASE64_RUNTIME_EXCEPTION", LOG));
+ }
+ }
+ try {
+ char[] cd = id.toCharArray();
+ return decodeChunk(cd, 0, cd.length);
+ } catch (Exception e) {
+ LOG.warning("Invalid base64 encoded string : " + id);
+ throw new Base64Exception(new Message("BASE64_RUNTIME_EXCEPTION", LOG), e);
+ }
+ }
+
+ public static void decode(char[] id,
+ int o,
+ int l,
+ OutputStream ostream)
+ throws Base64Exception {
+
+ try {
+ ostream.write(decodeChunk(id, o, l));
+ } catch (Exception e) {
+ LOG.warning("Invalid base64 encoded string : " + new String(id));
+ throw new Base64Exception(new Message("BASE64_RUNTIME_EXCEPTION", LOG), e);
+ }
+ }
+
+ public static void decode(String id,
+ OutputStream ostream)
+ throws Base64Exception {
+
+ try {
+ char[] cd = id.toCharArray();
+ ostream.write(decodeChunk(cd, 0, cd.length));
+ } catch (IOException ioe) {
+ throw new Base64Exception(new Message("BASE64_DECODE_IOEXCEPTION", LOG), ioe);
+ } catch (Exception e) {
+ LOG.warning("Invalid base64 encoded string : " + id);
+ throw new Base64Exception(new Message("BASE64_RUNTIME_EXCEPTION", LOG), e);
+ }
+ }
+
+ // Returns base64 representation of specified byte array.
+ //
+ public static String encode(byte[] id) {
+ return encode(id, false);
+ }
+
+ public static String encode(byte[] id, boolean urlSafe) {
+ char[] cd = encodeChunk(id, 0, id.length);
+ return new String(cd, 0, cd.length);
+ }
+
+ // Returns base64 representation of specified byte array.
+ //
+ public static char[] encodeChunk(byte[] id,
+ int o,
+ int l) {
+ return encodeChunk(id, o, l, false);
+ }
+
+ public static char[] encodeChunk(byte[] id,
+ int o,
+ int l,
+ boolean urlSafe) {
+ if (id != null && id.length == 0 && l == 0) {
+ return new char[0];
+ } else if (l <= 0) {
+ return null;
+ }
+
+ char[] out;
+
+ // If not a multiple of 3 octets then a final padded 4 char
+ // slot is needed.
+ //
+ if (l % 3 == 0) {
+ out = new char[l / 3 * 4];
+ } else {
+ int finalLen = !urlSafe ? 4 : l % 3 == 1 ? 2 : 3;
+ out = new char[l / 3 * 4 + finalLen];
+ }
+
+ int rindex = o;
+ int windex = 0;
+ int rest = l;
+
+ final char[] base64Table = urlSafe ? BCS_URL_SAFE : BCS;
+ while (rest >= 3) {
+ int i = ((id[rindex] & 0xff) << 16)
+ + ((id[rindex + 1] & 0xff) << 8)
+ + (id[rindex + 2] & 0xff);
+
+ out[windex++] = base64Table[i >> 18];
+ out[windex++] = base64Table[(i >> 12) & 0x3f];
+ out[windex++] = base64Table[(i >> 6) & 0x3f];
+ out[windex++] = base64Table[i & 0x3f];
+ rindex += 3;
+ rest -= 3;
+ }
+
+ if (rest == 1) {
+ int i = id[rindex] & 0xff;
+ out[windex++] = base64Table[i >> 2];
+ out[windex++] = base64Table[(i << 4) & 0x3f];
+ if (!urlSafe) {
+ out[windex++] = PAD;
+ out[windex] = PAD;
+ }
+ } else if (rest == 2) {
+ int i = ((id[rindex] & 0xff) << 8) + (id[rindex + 1] & 0xff);
+ out[windex++] = base64Table[i >> 10];
+ out[windex++] = base64Table[(i >> 4) & 0x3f];
+ out[windex++] = base64Table[(i << 2) & 0x3f];
+ if (!urlSafe) {
+ out[windex] = PAD;
+ }
+ }
+ return out;
+ }
+
+ public static void encodeAndStream(byte[] id,
+ int o,
+ int l,
+ OutputStream os) throws IOException {
+ encodeAndStream(id, o, l, false, os);
+ }
+
+ public static void encodeAndStream(byte[] id,
+ int o,
+ int l,
+ boolean urlSafe,
+ OutputStream os) throws IOException {
+ if (l <= 0) {
+ return;
+ }
+
+ int rindex = o;
+ int rest = l;
+ final char[] base64Table = urlSafe ? BCS_URL_SAFE : BCS;
+
+ char[] chunk = new char[4];
+ while (rest >= 3) {
+ int i = ((id[rindex] & 0xff) << 16)
+ + ((id[rindex + 1] & 0xff) << 8)
+ + (id[rindex + 2] & 0xff);
+ chunk[0] = base64Table[i >> 18];
+ chunk[1] = base64Table[(i >> 12) & 0x3f];
+ chunk[2] = base64Table[(i >> 6) & 0x3f];
+ chunk[3] = base64Table[i & 0x3f];
+ writeCharArrayToStream(chunk, 4, os);
+ rindex += 3;
+ rest -= 3;
+ }
+ if (rest == 0) {
+ return;
+ }
+ if (rest == 1) {
+ int i = id[rindex] & 0xff;
+ chunk[0] = base64Table[i >> 2];
+ chunk[1] = base64Table[(i << 4) & 0x3f];
+ if (!urlSafe) {
+ chunk[2] = PAD;
+ chunk[3] = PAD;
+ }
+ } else if (rest == 2) {
+ int i = ((id[rindex] & 0xff) << 8) + (id[rindex + 1] & 0xff);
+ chunk[0] = base64Table[i >> 10];
+ chunk[1] = base64Table[(i >> 4) & 0x3f];
+ chunk[2] = base64Table[(i << 2) & 0x3f];
+ if (!urlSafe) {
+ chunk[3] = PAD;
+ }
+ }
+ int finalLenToWrite = !urlSafe ? 4 : rest == 1 ? 2 : 3;
+ writeCharArrayToStream(chunk, finalLenToWrite, os);
+ }
+
+ private static void writeCharArrayToStream(char[] chunk, int len, OutputStream os) throws IOException {
+ // may be we can just cast to byte when creating chunk[] earlier on
+ byte[] bytes = StandardCharsets.UTF_8.encode(CharBuffer.wrap(chunk, 0, len)).array();
+ os.write(bytes);
+ }
+
+ //
+ // Outputs base64 representation of the specified byte array
+ // to a byte stream.
+ //
+ public static void encodeChunk(byte[] id,
+ int o,
+ int l,
+ OutputStream ostream) throws Base64Exception {
+ try {
+ ostream.write(new String(encodeChunk(id, o, l)).getBytes());
+ } catch (IOException e) {
+ throw new Base64Exception(new Message("BASE64_ENCODE_IOEXCEPTION", LOG), e);
+ }
+ }
+
+ // Outputs base64 representation of the specified byte
+ // array to a character stream.
+ //
+ public static void encode(byte[] id,
+ int o,
+ int l,
+ Writer writer) throws Base64Exception {
+ try {
+ writer.write(encodeChunk(id, o, l));
+ } catch (IOException e) {
+ throw new Base64Exception(new Message("BASE64_ENCODE_WRITER_IOEXCEPTION", LOG), e);
+ }
+ }
+ //---- Private static methods --------------------------------------
+
+ /**
+ * The <code>process</code> routine processes an atomic base64
+ * unit of encoding (encodeme) into its native encoding. This class is
+ * used by decode routines to do the grunt work of decoding
+ * base64 encoded information
+ *
+ * @param ib Input character buffer of encoded bytes
+ * @param ob Output byte buffer of decoded bytes
+ * @param p Pointer to the encodeme of interest
+ * @return The decoded encodeme
+ * @exception Base64Exception Thrown is processing fails due to
+ * formatting exceptions in the encoded data
+ */
+ private static int processEncodeme(char[] ib,
+ byte[] ob,
+ int p)
+ throws Base64Exception {
+
+
+ int spad = PAD_SIZE8;
+ if (ib[3] == PAD) {
+ spad = PAD_SIZE4;
+ }
+ if (ib[2] == PAD) {
+ spad = PAD_SIZE0;
+ }
+
+ int b0 = BDT[ib[0]];
+ int b1 = BDT[ib[1]];
+ int b2 = BDT[ib[2]];
+ int b3 = BDT[ib[3]];
+
+ switch (spad) {
+ case PAD_SIZE0:
+ ob[p] = (byte)(b0 << 2 & 0xfc | b1 >> 4 & 0x3);
+ return PAD_SIZE0;
+ case PAD_SIZE4:
+ ob[p++] = (byte)(b0 << 2 & 0xfc | b1 >> 4 & 0x3);
+ ob[p] = (byte)(b1 << 4 & 0xf0 | b2 >> 2 & 0xf);
+ return PAD_SIZE4;
+ case PAD_SIZE8:
+ ob[p++] = (byte)(b0 << 2 & 0xfc | b1 >> 4 & 0x3);
+ ob[p++] = (byte)(b1 << 4 & 0xf0 | b2 >> 2 & 0xf);
+ ob[p] = (byte)(b2 << 6 & 0xc0 | b3 & 0x3f);
+ return PAD_SIZE8;
+ default:
+ // We should never get here
+ throw new IllegalStateException();
+ }
+ }
+
+ public static boolean isValidBase64(int ch) {
+ return ch == PAD || BDT[ch] != Byte.MAX_VALUE;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/CachedClass.java b/transform/src/patch/java/org/apache/cxf/common/util/CachedClass.java
new file mode 100644
index 0000000..fe2df06
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/CachedClass.java
@@ -0,0 +1,37 @@
+/**
+ * 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.cxf.common.util;
+
+import java.lang.ref.WeakReference;
+
+public class CachedClass {
+ private WeakReference<Class<?>> cachedClazz;
+
+ public CachedClass(Class<?> cachedClass) {
+ this.cachedClazz = new WeakReference<>(cachedClass);
+ }
+
+ public Class<?> getCachedClass() {
+ return cachedClazz == null ? null : cachedClazz.get();
+ }
+
+ public void setCachedClass(Class<?> cachedClass) {
+ this.cachedClazz = new WeakReference<>(cachedClass);
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/ClassHelper.java b/transform/src/patch/java/org/apache/cxf/common/util/ClassHelper.java
new file mode 100644
index 0000000..adec469
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/ClassHelper.java
@@ -0,0 +1,140 @@
+/**
+ * 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.cxf.common.util;
+
+
+import java.lang.reflect.Proxy;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+
+/**
+ *
+ */
+public class ClassHelper {
+
+ public static final String USE_DEFAULT_CLASS_HELPER = "org.apache.cxf.useDefaultClassHelpers";
+
+ static final ClassHelper HELPER;
+ static final ClassUnwrapper DEFAULT_UNWRAPPER;
+ static final ClassUnwrapper UNWRAPPER;
+
+ /**
+ * Default class unwrapper implementation which delegates to the ClassHelper
+ * internal methods.
+ *
+ */
+ private static class DefaultClassUnwrapper implements ClassUnwrapper {
+ private final ClassHelper helper;
+
+ DefaultClassUnwrapper(ClassHelper helper) {
+ this.helper = helper;
+ }
+
+ @Override
+ public Class<?> getRealClassFromClass(Class<?> clazz) {
+ return helper.getRealClassFromClassInternal(clazz);
+ }
+
+ @Override
+ public Class<?> getRealClass(Object o) {
+ return helper.getRealClassInternal(o);
+ }
+
+ @Override
+ public Object getRealObject(Object o) {
+ return helper.getRealObjectInternal(o);
+ }
+ }
+
+ static {
+ HELPER = new ClassHelper();
+ DEFAULT_UNWRAPPER = new DefaultClassUnwrapper(HELPER);
+ UNWRAPPER = getClassUnwrapper(DEFAULT_UNWRAPPER);
+ }
+
+ protected ClassHelper() {
+ }
+
+ private static ClassUnwrapper getClassUnwrapper(ClassUnwrapper defaultHelper) {
+ boolean useSpring = true;
+ String s = SystemPropertyAction.getPropertyOrNull("org.apache.cxf.useSpringClassHelpers");
+ if (!StringUtils.isEmpty(s)) {
+ useSpring = "1".equals(s) || Boolean.parseBoolean(s);
+ }
+ if (useSpring) {
+ try {
+ return new SpringClassUnwrapper();
+ } catch (Throwable ex) {
+ // ignore
+ }
+ }
+ return defaultHelper;
+ }
+
+ private Class<?> getRealClassInternal(Object o) {
+ return getRealObjectInternal(o).getClass();
+ }
+
+ private Class<?> getRealClassFromClassInternal(Class<?> cls) {
+ return cls;
+ }
+
+ private Object getRealObjectInternal(Object o) {
+ return o instanceof Proxy ? Proxy.getInvocationHandler(o) : o;
+ }
+
+ public static Class<?> getRealClass(Object o) {
+ return getRealClass(null, o);
+ }
+
+ public static Class<?> getRealClassFromClass(Class<?> cls) {
+ return getRealClassFromClass(null, cls);
+ }
+
+ public static Class<?> getRealClassFromClass(Bus bus, Class<?> cls) {
+ return getContextClassUnwrapper(getBus(bus)).getRealClassFromClass(cls);
+ }
+
+ public static Object getRealObject(Object o) {
+ return getContextClassUnwrapper(getBus(null)).getRealObject(o);
+ }
+
+ public static Class<?> getRealClass(Bus bus, Object o) {
+ return getContextClassUnwrapper(getBus(bus)).getRealClass(o);
+ }
+
+ private static ClassUnwrapper getContextClassUnwrapper(Bus bus) {
+ if (bus != null && bus.getProperty(ClassUnwrapper.class.getName()) != null) {
+ return (ClassUnwrapper) bus.getProperty(ClassUnwrapper.class.getName());
+ }
+
+ return (DEFAULT_UNWRAPPER == UNWRAPPER || checkUseDefaultClassHelper(bus)) ? DEFAULT_UNWRAPPER : UNWRAPPER;
+ }
+
+ private static Bus getBus(Bus bus) {
+ return bus == null ? BusFactory.getThreadDefaultBus() : bus;
+ }
+
+ private static boolean checkUseDefaultClassHelper(Bus bus) {
+ return bus != null && Boolean.TRUE.equals(bus.getProperty(USE_DEFAULT_CLASS_HELPER));
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/CollectionUtils.java b/transform/src/patch/java/org/apache/cxf/common/util/CollectionUtils.java
new file mode 100644
index 0000000..4e888c3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/CollectionUtils.java
@@ -0,0 +1,126 @@
+/**
+ * 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.cxf.common.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Dictionary;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Map;
+
+public final class CollectionUtils {
+ private CollectionUtils() {
+
+ }
+
+ public static <T> Collection<T> diff(Collection<T> c1, Collection<T> c2) {
+ if (c1 == null || c1.isEmpty() || c2 == null || c2.isEmpty()) {
+ return c1;
+ }
+ Collection<T> difference = new ArrayList<>();
+ for (T item : c1) {
+ if (!c2.contains(item)) {
+ difference.add(item);
+ }
+ }
+ return difference;
+ }
+
+ public static <T> boolean isEmpty(Collection<T> c) {
+ if (c != null && !c.isEmpty()) {
+ for (T item : c) {
+ if (item != null) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ public static <K, V> boolean isEmpty(Map<K, V> m) {
+ return m == null || m.isEmpty();
+ }
+
+ public static <S, T> Dictionary<S, T> singletonDictionary(S s, T t) {
+ return toDictionary(Collections.singletonMap(s, t));
+ }
+
+ public static <S, T> Dictionary<S, T> toDictionary(Map<S, T> map) {
+ return new MapToDictionary<>(map);
+ }
+
+ static class MapToDictionary<S, T> extends Dictionary<S, T> {
+ /**
+ * Map source.
+ **/
+ private final Map<S, T> map;
+
+ MapToDictionary(Map<S, T> map) {
+ this.map = map;
+ }
+
+
+ public Enumeration<T> elements() {
+ return map != null ? new IteratorToEnumeration<>(map.values().iterator()) : null;
+ }
+
+ public T get(Object key) {
+ return map != null ? map.get(key) : null;
+ }
+
+ public boolean isEmpty() {
+ return map == null || map.isEmpty();
+ }
+
+ public Enumeration<S> keys() {
+ return map != null ? new IteratorToEnumeration<>(map.keySet().iterator()) : null;
+ }
+
+ public T put(S key, T value) {
+ throw new UnsupportedOperationException();
+ }
+
+ public T remove(Object key) {
+ throw new UnsupportedOperationException();
+ }
+
+ public int size() {
+ return map != null ? map.size() : 0;
+ }
+
+ static class IteratorToEnumeration<X> implements Enumeration<X> {
+ private final Iterator<X> iter;
+
+ IteratorToEnumeration(Iterator<X> iter) {
+ this.iter = iter;
+ }
+
+ public boolean hasMoreElements() {
+ return iter != null && iter.hasNext();
+ }
+
+ public X nextElement() {
+ return iter != null ? iter.next() : null;
+ }
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/Compiler.java b/transform/src/patch/java/org/apache/cxf/common/util/Compiler.java
new file mode 100644
index 0000000..9d0c819
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/Compiler.java
@@ -0,0 +1,382 @@
+/**
+ * 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.cxf.common.util;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticListener;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaCompiler.CompilationTask;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+
+import org.apache.cxf.helpers.FileUtils;
+
+public class Compiler {
+ private long maxMemory = Runtime.getRuntime().maxMemory();
+ private boolean verbose;
+ private String target;
+ private String outputDir;
+ private String classPath;
+ private String encoding;
+ private boolean forceFork = Boolean.getBoolean(Compiler.class.getName() + "-fork");
+ private File classpathTmpFile;
+ private List<String> errors = new LinkedList<>();
+ private List<String> warnings = new LinkedList<>();
+
+ public Compiler() {
+ }
+
+ public List<String> getErrors() {
+ return errors;
+ }
+ public List<String> getWarnings() {
+ return warnings;
+ }
+
+ public void setMaxMemory(long l) {
+ maxMemory = l;
+ }
+ public void setVerbose(boolean b) {
+ verbose = b;
+ }
+ public void setTarget(String s) {
+ target = s;
+ }
+ public void setOutputDir(File s) {
+ if (s != null) {
+ outputDir = s.getAbsolutePath().replace(File.pathSeparatorChar, '/');
+ } else {
+ outputDir = null;
+ }
+ }
+ public void setOutputDir(String s) {
+ outputDir = s.replace(File.pathSeparatorChar, '/');
+ }
+ public void setClassPath(String s) {
+ classPath = StringUtils.isEmpty(s) ? null : s;
+ }
+
+ // https://issues.apache.org/jira/browse/CXF-8049
+ private String getSystemClassPath() {
+ String javaClasspath = SystemPropertyAction.getProperty("java.class.path");
+
+ if (!StringUtils.isEmpty(javaClasspath)) {
+ List<String> correctedEntries = new ArrayList<>();
+
+ String[] toks = javaClasspath.split(File.pathSeparator);
+
+ for (String tok: toks) {
+ // if any classpath entry contains a whitespace char,
+ // enclose the entry in double quotes
+ if (tok.matches(".*\\s+.*")) {
+ correctedEntries.add("\"" + tok + "\"");
+ } else {
+ correctedEntries.add(tok);
+ }
+ }
+
+ return String.join(File.pathSeparator, correctedEntries);
+ }
+
+ return javaClasspath;
+ }
+
+ protected void addArgs(List<String> list) {
+ if (!StringUtils.isEmpty(encoding)) {
+ list.add("-encoding");
+ list.add(encoding);
+ }
+ if (!StringUtils.isEmpty(target)) {
+ list.add("-target");
+ list.add(target);
+ list.add("-source");
+ list.add(target);
+ }
+
+ if (!StringUtils.isEmpty(outputDir)) {
+ list.add("-d");
+ list.add(outputDir);
+ }
+
+ if (StringUtils.isEmpty(classPath)) {
+ String javaClasspath = getSystemClassPath();
+ boolean classpathSetted = !StringUtils.isEmpty(javaClasspath);
+ if (!classpathSetted) {
+ File f = new File(getClass().getClassLoader().getResource(".").getFile());
+ f = new File(f, "../lib");
+ if (f.exists() && f.isDirectory()) {
+ list.add("-extdirs");
+ list.add(f.toString());
+ }
+ } else {
+ list.add("-classpath");
+ list.add(javaClasspath);
+ }
+ } else {
+ list.add("-classpath");
+ list.add(classPath);
+ }
+
+ }
+ public boolean compileFiles(File[] files) {
+ List<String> f = new ArrayList<>(files.length);
+ for (File file : files) {
+ f.add(file.getAbsolutePath());
+ }
+ return compileFiles(f.toArray(new String[0]));
+ }
+ public boolean compileFiles(List<File> files) {
+ List<String> f = new ArrayList<>(files.size());
+ for (File file : files) {
+ f.add(file.getAbsolutePath());
+ }
+ return compileFiles(f.toArray(new String[0]));
+ }
+ public boolean compileFiles(String[] files) {
+ String endorsed = SystemPropertyAction.getProperty("java.endorsed.dirs");
+ if (!forceFork) {
+ return useJava6Compiler(files);
+ }
+
+ List<String> list = new ArrayList<>();
+
+ // Start of honoring java.home for used javac
+ String fsep = File.separator;
+ String javacstr = "javac";
+ String platformjavacname = "javac";
+
+ if (SystemPropertyAction.getProperty("os.name").toLowerCase().indexOf("windows") > -1) {
+ platformjavacname = "javac.exe";
+ }
+
+ if (new File(SystemPropertyAction.getProperty("java.home") + fsep + platformjavacname).exists()) {
+ // check if java.home is jdk home
+ javacstr = SystemPropertyAction.getProperty("java.home") + fsep + platformjavacname;
+ } else if (new File(SystemPropertyAction.getProperty("java.home") + fsep + ".." + fsep + "bin" + fsep
+ + platformjavacname).exists()) {
+ // check if java.home is jre home
+ javacstr = SystemPropertyAction.getProperty("java.home") + fsep + ".." + fsep + "bin" + fsep
+ + platformjavacname;
+ } else if (new File(SystemPropertyAction.getProperty("java.home") + fsep + "bin" + fsep
+ + platformjavacname).exists()) {
+ //java9
+ javacstr = SystemPropertyAction.getProperty("java.home") + fsep + "bin" + fsep
+ + platformjavacname;
+ }
+ list.add(javacstr);
+ // End of honoring java.home for used javac
+
+ if (!StringUtils.isEmpty(endorsed)) {
+ list.add("-endorseddirs");
+ list.add(endorsed);
+ }
+
+ //fix for CXF-2081, set maximum heap of this VM to javac.
+ list.add("-J-Xmx" + maxMemory);
+
+ addArgs(list);
+ int classpathIdx = list.indexOf("-classpath");
+ String classpath = list.get(classpathIdx + 1);
+ checkLongClasspath(classpath, list, classpathIdx);
+ int idx = list.size();
+ Collections.addAll(list, files);
+
+ return internalCompile(list.toArray(new String[0]), idx);
+ }
+
+ protected boolean useJava6Compiler(String[] files) {
+ JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+ if (compiler == null) {
+ throw new IllegalStateException(
+ "No compiler detected, make sure you are running on top of a JDK instead of a JRE.");
+ }
+ StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
+ Iterable<? extends JavaFileObject> fileList = fileManager.getJavaFileObjectsFromStrings(Arrays
+ .asList(files));
+
+ return internalJava6Compile(compiler, wrapJavaFileManager(fileManager), setupDiagnosticListener(),
+ fileList);
+ }
+
+ protected JavaFileManager wrapJavaFileManager(StandardJavaFileManager standardJavaFileManger) {
+ return standardJavaFileManger;
+ }
+
+ protected DiagnosticListener<JavaFileObject> setupDiagnosticListener() {
+ return new DiagnosticListener<JavaFileObject>() {
+ public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
+ switch (diagnostic.getKind()) {
+ case ERROR:
+ errors.add(diagnostic.toString());
+ if (verbose) {
+ System.err.println(diagnostic.toString());
+ }
+ break;
+ case WARNING:
+ case MANDATORY_WARNING:
+ warnings.add(diagnostic.toString());
+ if (verbose) {
+ System.err.println(diagnostic.toString());
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ };
+ }
+
+ protected boolean internalJava6Compile(JavaCompiler compiler, JavaFileManager fileManager,
+ DiagnosticListener<JavaFileObject> listener,
+ Iterable<? extends JavaFileObject> fileList) {
+ List<String> args = new ArrayList<>();
+ addArgs(args);
+ CompilationTask task = compiler.getTask(null, fileManager, listener, args, null, fileList);
+ Boolean ret = task.call();
+ try {
+ fileManager.close();
+ } catch (IOException e) {
+ System.err.print("[ERROR] IOException during compiling.");
+ e.printStackTrace();
+ }
+ return ret;
+ }
+
+ public boolean internalCompile(String[] args, int sourceFileIndex) {
+ File tmpFile = null;
+ try {
+ final String[] cmdArray;
+ if (isLongCommandLines(args) && sourceFileIndex >= 0) {
+ tmpFile = FileUtils.createTempFile("cxf-compiler", null);
+ try (PrintWriter out = new PrintWriter(new FileWriter(tmpFile))) {
+ for (int i = sourceFileIndex; i < args.length; i++) {
+ if (args[i].indexOf(' ') > -1) {
+ args[i] = args[i].replace(File.separatorChar, '/');
+ //
+ // javac gives an error if you use forward slashes
+ // with package-info.java. Refer to:
+ // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6198196
+ //
+ if (args[i].indexOf("package-info.java") > -1
+ && SystemPropertyAction.getProperty("os.name")
+ .toLowerCase().indexOf("windows") > -1) {
+ out.println('"' + args[i].replaceAll("/", "\\\\\\\\") + '"');
+ } else {
+ out.println('"' + args[i] + '"');
+ }
+ } else {
+ out.println(args[i]);
+ }
+ }
+ out.flush();
+ }
+ cmdArray = new String[sourceFileIndex + 1];
+ System.arraycopy(args, 0, cmdArray, 0, sourceFileIndex);
+ cmdArray[sourceFileIndex] = "@" + tmpFile;
+ } else {
+ cmdArray = new String[args.length];
+ System.arraycopy(args, 0, cmdArray, 0, args.length);
+ }
+
+ if (SystemPropertyAction.getProperty("os.name").toLowerCase().indexOf("windows") > -1) {
+ for (int i = 0; i < cmdArray.length; i++) {
+ if (cmdArray[i].indexOf("package-info") == -1) {
+ cmdArray[i] = cmdArray[i].replace('\\', '/');
+ }
+ }
+ }
+
+ final Process p = Runtime.getRuntime().exec(cmdArray);
+
+ if (p.getErrorStream() != null) {
+ StreamPrinter errorStreamPrinter = new StreamPrinter(p.getErrorStream(), "", System.out);
+ errorStreamPrinter.start();
+ }
+
+ if (p.getInputStream() != null) {
+ StreamPrinter infoStreamPrinter = new StreamPrinter(p.getInputStream(), "[INFO]", System.out);
+ infoStreamPrinter.start();
+ }
+
+ return p.waitFor() == 0 ? true : false;
+ } catch (SecurityException e) {
+ System.err.println("[ERROR] SecurityException during exec() of compiler \"" + args[0] + "\".");
+ } catch (InterruptedException e) {
+ // ignore
+
+ } catch (IOException e) {
+ System.err.print("[ERROR] IOException during exec() of compiler \"" + args[0] + "\"");
+ System.err.println(". Check your path environment variable.");
+ } finally {
+ if (tmpFile != null && tmpFile.exists()) {
+ FileUtils.delete(tmpFile);
+ }
+ if (classpathTmpFile != null && classpathTmpFile.exists()) {
+ FileUtils.delete(classpathTmpFile);
+ }
+ }
+
+ return false;
+ }
+
+ private boolean isLongCommandLines(String[] args) {
+ StringBuilder strBuffer = new StringBuilder();
+ for (int i = 0; i < args.length; i++) {
+ strBuffer.append(args[i]);
+ }
+ return strBuffer.length() > 4096;
+ }
+
+ private boolean isLongClasspath(String classpath) {
+ return classpath.length() > 2048;
+ }
+
+ private void checkLongClasspath(String classpath, List<String> list, int classpathIdx) {
+ if (isLongClasspath(classpath)) {
+ try {
+ classpathTmpFile = FileUtils.createTempFile("cxf-compiler-classpath", null);
+ try (PrintWriter out = new PrintWriter(new FileWriter(classpathTmpFile))) {
+ out.println(classpath);
+ out.flush();
+ }
+ list.set(classpathIdx + 1, "@" + classpathTmpFile);
+ } catch (IOException e) {
+ System.err.print("[ERROR] can't write long classpath to @argfile");
+ }
+ }
+ }
+
+ public void setEncoding(String string) {
+ encoding = string;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/ModCountCopyOnWriteArrayList.java b/transform/src/patch/java/org/apache/cxf/common/util/ModCountCopyOnWriteArrayList.java
new file mode 100644
index 0000000..daa6407
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/ModCountCopyOnWriteArrayList.java
@@ -0,0 +1,156 @@
+/**
+ * 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.cxf.common.util;
+
+import java.util.Collection;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class ModCountCopyOnWriteArrayList<T> extends CopyOnWriteArrayList<T> {
+ private static final long serialVersionUID = 1783937035760941219L;
+ private AtomicInteger modCount = new AtomicInteger();
+
+ public ModCountCopyOnWriteArrayList() {
+ super();
+ }
+ public ModCountCopyOnWriteArrayList(Collection<? extends T> c) {
+ super(c);
+ if (c instanceof ModCountCopyOnWriteArrayList) {
+ modCount.set(((ModCountCopyOnWriteArrayList<?>)c).getModCount());
+ }
+ }
+
+ public int getModCount() {
+ return modCount.get();
+ }
+
+ public void setModCount(int i) {
+ modCount.set(i);
+ }
+
+ @Override
+ public void add(int index, T element) {
+ super.add(index, element);
+ modCount.incrementAndGet();
+ }
+
+ @Override
+ public boolean add(T element) {
+ if (super.add(element)) {
+ modCount.incrementAndGet();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean addAll(Collection<? extends T> c) {
+ if (super.addAll(c)) {
+ modCount.incrementAndGet();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean addAll(int index, Collection<? extends T> c) {
+ if (super.addAll(index, c)) {
+ modCount.incrementAndGet();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public int addAllAbsent(Collection<? extends T> c) {
+ int i = super.addAllAbsent(c);
+ if (i > 0) {
+ modCount.incrementAndGet();
+ }
+ return i;
+ }
+
+ @Override
+ public boolean addIfAbsent(T element) {
+ if (super.addIfAbsent(element)) {
+ modCount.incrementAndGet();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public void clear() {
+ super.clear();
+ modCount.incrementAndGet();
+ }
+
+ @Override
+ public T remove(int index) {
+ T t = super.remove(index);
+ if (t != null) {
+ modCount.incrementAndGet();
+ }
+ return t;
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ if (super.remove(o)) {
+ modCount.incrementAndGet();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean removeAll(Collection<?> c) {
+ if (super.removeAll(c)) {
+ modCount.incrementAndGet();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean retainAll(Collection<?> c) {
+ if (super.retainAll(c)) {
+ modCount.incrementAndGet();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return super.hashCode() + modCount.get();
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o instanceof ModCountCopyOnWriteArrayList) {
+ return super.equals(o) && modCount.get()
+ == ((ModCountCopyOnWriteArrayList<?>)o).getModCount();
+ }
+ return false;
+ }
+
+}
+
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/PackageUtils.java b/transform/src/patch/java/org/apache/cxf/common/util/PackageUtils.java
new file mode 100644
index 0000000..9d014c8
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/PackageUtils.java
@@ -0,0 +1,181 @@
+/**
+ * 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.cxf.common.util;
+
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import org.apache.cxf.helpers.JavaUtils;
+
+
+public final class PackageUtils {
+
+ private PackageUtils() {
+
+ }
+
+ static String getPackageName(String className) {
+ int pos = className.lastIndexOf('.');
+ if (pos != -1) {
+ return className.substring(0, pos);
+ }
+ return "";
+ }
+
+ public static String getPackageName(Class<?> clazz) {
+ String className = clazz.getName();
+ if (className.startsWith("[L")) {
+ className = className.substring(2);
+ }
+ return getPackageName(className);
+ }
+
+ public static String getSharedPackageName(List<Class<?>> classes) {
+ if (classes.isEmpty()) {
+ return "";
+ }
+ List<List<String>> lParts = new ArrayList<>(classes.size());
+ List<String> currentParts = new ArrayList<>();
+ for (Class<?> cls : classes) {
+ if (!Proxy.isProxyClass(cls)) {
+ lParts.add(Arrays.asList(getPackageName(cls).split("\\.")));
+ }
+ }
+ for (int i = 0; i < lParts.get(0).size(); i++) {
+ int j = 1;
+ for (; j < lParts.size(); j++) {
+ if (i > (lParts.get(j).size() - 1) || !lParts.get(j).get(i).equals(lParts.get(0).get(i))) {
+ break;
+ }
+ }
+ if (j == lParts.size()) {
+ currentParts.add(lParts.get(j - 1).get(i));
+ } else {
+ break;
+ }
+ }
+ return String.join(".", currentParts);
+ }
+
+ public static String parsePackageName(String namespace, String defaultPackageName) {
+ return (defaultPackageName != null && !defaultPackageName.trim().isEmpty())
+ ? defaultPackageName : getPackageNameByNameSpaceURI(namespace.trim());
+ }
+
+ public static String getPackageNameByNameSpaceURI(String nameSpaceURI) {
+ int idx = nameSpaceURI.indexOf(':');
+ boolean urnScheme = false;
+ if (idx >= 0) {
+ final String scheme = nameSpaceURI.substring(0, idx);
+ urnScheme = "urn".equalsIgnoreCase(scheme);
+ if ("http".equalsIgnoreCase(scheme) || urnScheme) {
+ nameSpaceURI = nameSpaceURI.substring(idx + (urnScheme ? 1 : 3)); //
+ }
+ }
+
+ List<String> tokens = tokenize(nameSpaceURI, "/:");
+ if (tokens.isEmpty()) {
+ return null;
+ }
+
+ if (tokens.size() > 1) {
+ String lastToken = tokens.get(tokens.size() - 1);
+ idx = lastToken.lastIndexOf('.');
+ if (idx > 0) {
+ lastToken = lastToken.replace('.', '_');
+ tokens.set(tokens.size() - 1, lastToken);
+ }
+ }
+
+ String domain = tokens.remove(0);
+ List<String> r = tokenize(domain, urnScheme ? ".-" : ".");
+ Collections.reverse(r);
+ if ("www".equalsIgnoreCase(r.get(r.size() - 1))) {
+ // remove leading www
+ r.remove(r.size() - 1);
+ }
+
+ // replace the domain name with tokenized items
+ tokens.addAll(0, r);
+
+ // iterate through the tokens and apply xml->java name algorithm
+ for (int i = 0; i < tokens.size(); i++) {
+
+ // get the token and remove illegal chars
+ String token = tokens.get(i);
+ token = removeIllegalIdentifierChars(token);
+
+ token = token.toLowerCase();
+
+ // this will check for reserved keywords
+ if (JavaUtils.isJavaKeyword(token)) {
+ token = '_' + token;
+ }
+
+ tokens.set(i, token);
+ }
+
+ // concat all the pieces and return it
+ return String.join(".", tokens);
+ }
+
+ private static List<String> tokenize(String str, String sep) {
+ StringTokenizer tokens = new StringTokenizer(str, sep);
+ List<String> r = new ArrayList<>();
+
+ while (tokens.hasMoreTokens()) {
+ r.add(tokens.nextToken());
+ }
+ return r;
+ }
+
+ private static String removeIllegalIdentifierChars(String token) {
+ StringBuilder newToken = new StringBuilder();
+ for (int i = 0; i < token.length(); i++) {
+ char c = token.charAt(i);
+
+ if (i == 0 && !Character.isJavaIdentifierStart(c)) {
+ // prefix an '_' if the first char is illegal
+ newToken.append('_').append(c);
+ } else if (!Character.isJavaIdentifierPart(c)) {
+ // replace the char with an '_' if it is illegal
+ newToken.append('_');
+ } else {
+ // add the legal char
+ newToken.append(c);
+ }
+ }
+ return newToken.toString();
+ }
+
+ public static String getNamespace(String packageName) {
+ if (packageName == null || packageName.isEmpty()) {
+ return null;
+ }
+ final List<String> parts = Arrays.asList(packageName.split("\\."));
+ Collections.reverse(parts);
+ return "http://" + String.join(".", parts) + '/';
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/ProxyClassLoader.java b/transform/src/patch/java/org/apache/cxf/common/util/ProxyClassLoader.java
new file mode 100644
index 0000000..073ca46
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/ProxyClassLoader.java
@@ -0,0 +1,89 @@
+/**
+ * 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.cxf.common.util;
+
+import java.net.URL;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Utility class loader that can be used to create proxies in cases where
+ * the the client classes are not visible to the loader of the
+ * service class.
+ */
+public class ProxyClassLoader extends ClassLoader {
+ private final Class<?>[] classes;
+ private final Set<ClassLoader> loaders = new HashSet<>();
+ private boolean checkSystem;
+
+ public ProxyClassLoader(ClassLoader parent) {
+ super(parent);
+ classes = null;
+ }
+
+ public ProxyClassLoader(ClassLoader parent, Class<?>[] cls) {
+ super(parent);
+ classes = cls;
+ }
+
+ public void addLoader(ClassLoader loader) {
+ if (loader == null) {
+ checkSystem = true;
+ } else {
+ loaders.add(loader);
+ }
+ }
+
+ @Override
+ public Class<?> findClass(String name) throws ClassNotFoundException {
+ if (classes != null) {
+ for (Class<?> c : classes) {
+ if (name.equals(c.getName())) {
+ return c;
+ }
+ }
+ }
+ for (ClassLoader loader : loaders) {
+ try {
+ return loader.loadClass(name);
+ } catch (ClassNotFoundException | NoClassDefFoundError cnfe) {
+ // Try next
+ }
+ }
+ if (checkSystem) {
+ try {
+ return getSystemClassLoader().loadClass(name);
+ } catch (ClassNotFoundException | NoClassDefFoundError cnfe) {
+ // Try next
+ }
+ }
+ throw new ClassNotFoundException(name);
+ }
+
+ @Override
+ public URL findResource(String name) {
+ for (ClassLoader loader : loaders) {
+ URL url = loader.getResource(name);
+ if (url != null) {
+ return url;
+ }
+ }
+ return null;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/ProxyHelper.java b/transform/src/patch/java/org/apache/cxf/common/util/ProxyHelper.java
new file mode 100644
index 0000000..380e2bb
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/ProxyHelper.java
@@ -0,0 +1,140 @@
+/**
+ * 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.cxf.common.util;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.logging.LogUtils;
+
+/**
+ *
+ */
+public class ProxyHelper {
+ static final ProxyHelper HELPER;
+ static {
+ ProxyHelper theHelper;
+ try {
+ theHelper = new CglibProxyHelper();
+ } catch (Throwable ex) {
+ theHelper = new ProxyHelper();
+ }
+ HELPER = theHelper;
+ }
+
+ private static final Logger LOG = LogUtils.getL7dLogger(ProxyHelper.class);
+
+ protected ProxyClassLoaderCache proxyClassLoaderCache =
+ new ProxyClassLoaderCache();
+
+
+ protected ProxyHelper() {
+ }
+
+ protected Object getProxyInternal(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) {
+ ClassLoader combinedLoader = getClassLoaderForInterfaces(loader, interfaces);
+ return Proxy.newProxyInstance(combinedLoader, interfaces, handler);
+ }
+
+ /**
+ * Return a classloader that can see all the given interfaces If the given loader can see all interfaces
+ * then it is used. If not then a combined classloader of all interface classloaders is returned.
+ *
+ * @param loader use supplied class loader
+ * @param interfaces
+ * @return classloader that sees all interfaces
+ */
+ private ClassLoader getClassLoaderForInterfaces(final ClassLoader loader, final Class<?>[] interfaces) {
+ if (canSeeAllInterfaces(loader, interfaces)) {
+ LOG.log(Level.FINE, "current classloader " + loader + " can see all interface");
+ return loader;
+ }
+ String sortedNameFromInterfaceArray = getSortedNameFromInterfaceArray(interfaces);
+ ClassLoader cachedLoader = proxyClassLoaderCache.getProxyClassLoader(loader, interfaces);
+ if (canSeeAllInterfaces(cachedLoader, interfaces)) {
+ LOG.log(Level.FINE, "find required loader from ProxyClassLoader cache with key"
+ + sortedNameFromInterfaceArray);
+ return cachedLoader;
+ } else {
+ LOG.log(Level.FINE, "find a loader from ProxyClassLoader cache with interfaces "
+ + sortedNameFromInterfaceArray
+ + " but can't see all interfaces");
+ for (Class<?> currentInterface : interfaces) {
+ String ifName = currentInterface.getName();
+
+ if (!ifName.startsWith("org.apache.cxf") && !ifName.startsWith("java")) {
+ // remove the stale ProxyClassLoader and recreate one
+ proxyClassLoaderCache.removeStaleProxyClassLoader(currentInterface);
+ cachedLoader = proxyClassLoaderCache.getProxyClassLoader(loader, interfaces);
+
+ }
+ }
+ }
+
+ return cachedLoader;
+ }
+
+ private String getSortedNameFromInterfaceArray(Class<?>[] interfaces) {
+ SortedArraySet<String> arraySet = new SortedArraySet<>();
+ for (Class<?> currentInterface : interfaces) {
+ arraySet.add(currentInterface.getName() + ClassLoaderUtils.getClassLoaderName(currentInterface));
+ }
+ return arraySet.toString();
+ }
+
+
+ private boolean canSeeAllInterfaces(ClassLoader loader, Class<?>[] interfaces) {
+ for (Class<?> currentInterface : interfaces) {
+ String ifName = currentInterface.getName();
+ try {
+ Class<?> ifClass = Class.forName(ifName, true, loader);
+ if (ifClass != currentInterface) {
+ return false;
+ }
+ //we need to check all the params/returns as well as the Proxy creation
+ //will try to create methods for all of this even if they aren't used
+ //by the client and not available in the clients classloader
+ for (Method m : ifClass.getMethods()) {
+ Class<?> returnType = m.getReturnType();
+ if (!returnType.isPrimitive()) {
+ Class.forName(returnType.getName(), true, loader);
+ }
+ for (Class<?> p : m.getParameterTypes()) {
+ if (!p.isPrimitive()) {
+ Class.forName(p.getName(), true, loader);
+ }
+ }
+ }
+ } catch (NoClassDefFoundError | ClassNotFoundException e) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static Object getProxy(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) {
+ return HELPER.getProxyInternal(loader, interfaces, handler);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/ReflectionInvokationHandler.java b/transform/src/patch/java/org/apache/cxf/common/util/ReflectionInvokationHandler.java
new file mode 100644
index 0000000..1b4d904
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/ReflectionInvokationHandler.java
@@ -0,0 +1,199 @@
+/**
+ * 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.cxf.common.util;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Iterator;
+
+/**
+ *
+ */
+public class ReflectionInvokationHandler implements InvocationHandler {
+ private Object target;
+
+ public ReflectionInvokationHandler(Object obj) {
+ target = obj;
+ }
+
+ public Object getTarget() {
+ return target;
+ }
+
+ /** {@inheritDoc}*/
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ WrapReturn wr = method.getAnnotation(WrapReturn.class);
+ final Class<?> targetClass = target.getClass();
+ final Class<?>[] parameterTypes = getParameterTypes(method, args);
+ try {
+ Method m;
+ try {
+ m = targetClass.getMethod(method.getName(), parameterTypes);
+ } catch (NoSuchMethodException nsme) {
+
+ boolean[] optionals = new boolean[method.getParameterTypes().length];
+ int i = 0;
+ int optionalNumber = 0;
+ for (final Annotation[] a : method.getParameterAnnotations()) {
+ optionals[i] = false;
+ for (final Annotation potential : a) {
+ if (Optional.class.equals(potential.annotationType())) {
+ optionals[i] = true;
+ optionalNumber++;
+ break;
+ }
+ }
+ i++;
+ }
+
+ Class<?>[] newParams = new Class<?>[args.length - optionalNumber];
+ Object[] newArgs = new Object[args.length - optionalNumber];
+ int argI = 0;
+ for (int j = 0; j < parameterTypes.length; j++) {
+ if (optionals[j]) {
+ continue;
+ }
+ newArgs[argI] = args[j];
+ newParams[argI] = parameterTypes[j];
+ argI++;
+ }
+ m = targetClass.getMethod(method.getName(), newParams);
+ args = newArgs;
+ }
+ ReflectionUtil.setAccessible(m);
+ return wrapReturn(wr, m.invoke(target, args));
+ } catch (InvocationTargetException e) {
+ throw e.getCause();
+ } catch (NoSuchMethodException e) {
+ for (Method m2 : targetClass.getMethods()) {
+ if (m2.getName().equals(method.getName())
+ && m2.getParameterTypes().length == method.getParameterTypes().length) {
+ boolean found = true;
+ for (int x = 0; x < m2.getParameterTypes().length; x++) {
+ if (args[x] != null
+ && !m2.getParameterTypes()[x].isInstance(args[x])) {
+ found = false;
+ }
+ }
+ if (found) {
+ ReflectionUtil.setAccessible(m2);
+ return wrapReturn(wr, m2.invoke(target, args));
+ }
+ }
+ }
+ throw e;
+ }
+ }
+ private Class<?>[] getParameterTypes(Method method, Object[] args) {
+ Class<?>[] types = method.getParameterTypes();
+ final Annotation[][] parAnnotations = method.getParameterAnnotations();
+ for (int x = 0; x < types.length; x++) {
+ UnwrapParam p = getUnwrapParam(parAnnotations[x]);
+ if (p != null) {
+ String s = p.methodName();
+ String tn = p.typeMethodName();
+ try {
+ Method m = args[x].getClass().getMethod(s);
+ if ("#default".equals(tn)) {
+ types[x] = m.getReturnType();
+ } else {
+ Method m2 = args[x].getClass().getMethod(tn);
+ types[x] = (Class<?>)ReflectionUtil.setAccessible(m2).invoke(args[x]);
+ }
+ args[x] = ReflectionUtil.setAccessible(m).invoke(args[x]);
+ } catch (Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+ }
+ return types;
+ }
+
+ private UnwrapParam getUnwrapParam(Annotation[] annotations) {
+ for (Annotation a : annotations) {
+ if (a instanceof UnwrapParam) {
+ return (UnwrapParam)a;
+ }
+ }
+ return null;
+ }
+
+ private static Object wrapReturn(WrapReturn wr, Object t) {
+ if (wr == null || t == null) {
+ return t;
+ }
+ if (wr.iterator()) {
+ return new WrapperIterator(wr.value(), (Iterator<?>)t);
+ }
+ return createProxyWrapper(t, wr.value());
+ }
+
+ public static <T> T createProxyWrapper(Object target, Class<T> inf) {
+ InvocationHandler h = new ReflectionInvokationHandler(target);
+ return inf.cast(Proxy.newProxyInstance(inf.getClassLoader(), new Class<?>[] {inf}, h));
+ }
+
+ @Target(ElementType.PARAMETER)
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface Optional {
+ }
+
+ @Target(ElementType.METHOD)
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface WrapReturn {
+ Class<?> value();
+ boolean iterator() default false;
+ }
+
+ @Target(ElementType.PARAMETER)
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface UnwrapParam {
+ String methodName() default "getValue";
+ String typeMethodName() default "#default";
+ }
+
+ private static class WrapperIterator implements Iterator<Object> {
+ Class<?> cls;
+ Iterator<?> internal;
+ WrapperIterator(Class<?> c, Iterator<?> it) {
+ internal = it;
+ cls = c;
+ }
+ public boolean hasNext() {
+ return internal.hasNext();
+ }
+ public Object next() {
+ Object obj = internal.next();
+ return createProxyWrapper(obj, cls);
+ }
+
+ @Override
+ public void remove() {
+ internal.remove();
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/SortedArraySet.java b/transform/src/patch/java/org/apache/cxf/common/util/SortedArraySet.java
new file mode 100644
index 0000000..9c2b139
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/SortedArraySet.java
@@ -0,0 +1,266 @@
+/**
+ * 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.cxf.common.util;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.SortedSet;
+import java.util.concurrent.atomic.AtomicReference;
+
+
+/**
+ * This class implements most of the <tt>Set</tt> interface, backed by a
+ * sorted Array. This makes iterators very fast, lookups are log(n), but
+ * adds are fairly expensive.
+ *
+ * This class is also threadsafe, but without synchronizations. Lookups
+ * and iterators will iterate over the state of the Set when the iterator
+ * was created.
+ *
+ * If no data is stored in the Set, it uses very little memory. The backing
+ * array is created on demand.
+ *
+ * This class is primarly useful for stuff that will be setup at startup, but
+ * then iterated over MANY times during runtime.
+ *
+ * @param <T>
+ */
+public final class SortedArraySet<T> implements SortedSet<T> {
+ final AtomicReference<T[]> data = new AtomicReference<>();
+
+ public void clear() {
+ data.set(null);
+ }
+
+ public boolean isEmpty() {
+ T[] tmp = data.get();
+ return tmp == null || tmp.length == 0;
+ }
+
+ public Iterator<T> iterator() {
+ return new SASIterator<>(data.get());
+ }
+
+ public int size() {
+ T[] tmp = data.get();
+ return tmp == null ? 0 : tmp.length;
+ }
+
+ @SuppressWarnings("unchecked")
+ private T[] newArray(int size) {
+ return (T[])new Object[size];
+ }
+
+ public boolean add(T o) {
+ if (!contains(o)) {
+ T[] tmp = data.get();
+ T[] tmp2;
+ if (tmp == null) {
+ tmp2 = newArray(1);
+ tmp2[0] = o;
+ } else {
+ tmp2 = newArray(tmp.length + 1);
+ System.arraycopy(tmp, 0, tmp2, 0, tmp.length);
+ tmp2[tmp2.length - 1] = o;
+ Arrays.sort(tmp2);
+ }
+
+ if (!data.compareAndSet(tmp, tmp2)) {
+ return add(o);
+ }
+ return true;
+ }
+ return false;
+ }
+ public boolean addAll(Collection<? extends T> c) {
+ boolean val = false;
+ for (T t : c) {
+ val |= add(t);
+ }
+ return val;
+ }
+ public boolean containsAll(Collection<?> c) {
+ boolean val = false;
+ for (Object t : c) {
+ val |= contains(t);
+ }
+ return val;
+ }
+
+ public boolean contains(Object o) {
+ T[] tmp = data.get();
+ if (tmp == null) {
+ return false;
+ }
+ return Arrays.binarySearch(tmp, o) >= 0;
+ }
+
+ public boolean removeAll(Collection<?> c) {
+ boolean val = false;
+ for (Object t : c) {
+ val |= remove(t);
+ }
+ return val;
+ }
+ public boolean retainAll(Collection<?> c) {
+ boolean val = false;
+ for (T t : this) {
+ if (!c.contains(t)) {
+ val |= remove(t);
+ }
+ }
+ return val;
+ }
+
+ public boolean remove(Object o) {
+ T[] tmp = data.get();
+
+ if (tmp == null) {
+ return false;
+ }
+ int idx = Arrays.binarySearch(tmp, o);
+ if (idx != -1) {
+ if (tmp.length == 1
+ && !data.compareAndSet(tmp, null)) {
+ return remove(o);
+ }
+ T[] tmp2 = newArray(tmp.length - 1);
+ System.arraycopy(tmp, 0, tmp2, 0, idx);
+ System.arraycopy(tmp, idx + 1, tmp2, idx, tmp.length - 1 - idx);
+ if (!data.compareAndSet(tmp, tmp2)) {
+ return remove(o);
+ }
+ return true;
+ }
+ return false;
+ }
+
+
+ public Object[] toArray() {
+ T[] tmp = data.get();
+ if (tmp == null) {
+ return new Object[0];
+ }
+ T[] tmp2 = newArray(tmp.length);
+ System.arraycopy(tmp, 0, tmp2, 0, tmp.length);
+ return tmp2;
+ }
+
+ @SuppressWarnings("unchecked")
+ public <X> X[] toArray(X[] a) {
+ T[] tmp = data.get();
+ if (tmp == null) {
+ if (a.length != 0) {
+ return (X[])java.lang.reflect.Array.
+ newInstance(a.getClass().getComponentType(), 0);
+ }
+ return a;
+ }
+
+ if (a.length < tmp.length) {
+ a = (X[])java.lang.reflect.Array.
+ newInstance(a.getClass().getComponentType(), tmp.length);
+ }
+ System.arraycopy(tmp, 0, a, 0, tmp.length);
+ if (a.length > tmp.length) {
+ a[tmp.length] = null;
+ }
+ return a;
+ }
+
+ @SuppressWarnings("unchecked")
+ public boolean equals(Object o) {
+ if (!(o instanceof SortedArraySet)) {
+ return false;
+ }
+ SortedArraySet<T> as = (SortedArraySet<T>)o;
+ return Arrays.equals(data.get(), as.data.get());
+ }
+ public String toString() {
+ return Arrays.toString(data.get());
+ }
+ public int hashCode() {
+ return Arrays.hashCode(data.get());
+ }
+
+
+ private class SASIterator<X> implements Iterator<X> {
+ final X[] data;
+ int idx;
+
+ SASIterator(X[] d) {
+ data = d;
+ }
+
+ public boolean hasNext() {
+ return data != null && idx != data.length;
+ }
+
+ public X next() {
+ if (data == null || idx == data.length) {
+ throw new NoSuchElementException();
+ }
+ return data[idx++];
+ }
+
+ @Override
+ public void remove() {
+ if (idx > 0) {
+ SortedArraySet.this.remove((Object)data[idx - 1]);
+ }
+ }
+ }
+
+
+ public Comparator<? super T> comparator() {
+ return null;
+ }
+
+ public T first() {
+ T[] tmp = data.get();
+ if (tmp == null || tmp.length == 0) {
+ return null;
+ }
+ return tmp[0];
+ }
+
+ public T last() {
+ T[] tmp = data.get();
+ if (tmp == null || tmp.length == 0) {
+ return null;
+ }
+ return tmp[tmp.length - 1];
+ }
+
+ public SortedSet<T> headSet(T toElement) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SortedSet<T> subSet(T fromElement, T toElement) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SortedSet<T> tailSet(T fromElement) {
+ throw new UnsupportedOperationException();
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/SpringClassUnwrapper.java b/transform/src/patch/java/org/apache/cxf/common/util/SpringClassUnwrapper.java
new file mode 100644
index 0000000..a196eb0
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/SpringClassUnwrapper.java
@@ -0,0 +1,111 @@
+/**
+ * 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.cxf.common.util;
+
+import org.springframework.aop.TargetSource;
+import org.springframework.aop.framework.Advised;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.util.ClassUtils;
+
+/**
+ *
+ */
+class SpringClassUnwrapper implements ClassUnwrapper {
+ SpringClassUnwrapper() throws ClassNotFoundException {
+ Class.forName("org.springframework.aop.support.AopUtils");
+ Class.forName("org.springframework.aop.framework.Advised");
+ }
+
+ @Override
+ public Class<?> getRealClassFromClass(Class<?> cls) {
+ if (ClassUtils.isCglibProxyClass(cls)) {
+ final Class<?> superclass = cls.getSuperclass();
+ // Lambda's generated class names also contain $$ which makes them trigger CGLIB
+ // proxy path. Adding more checks to handle this particular case.
+ if (superclass != null && (superclass != Object.class || wasCglibEnhanced(cls))) {
+ return getRealClassFromClass(superclass);
+ }
+ }
+ return cls;
+ }
+
+ @Override
+ public Object getRealObject(Object o) {
+ if (o instanceof Advised) {
+ try {
+
+ Advised advised = (Advised)o;
+ Object target = advised.getTargetSource().getTarget();
+ //could be a proxy of a proxy.....
+ return getRealObject(target);
+ } catch (Exception ex) {
+ // ignore
+ }
+ }
+ return o;
+ }
+
+ @Override
+ public Class<?> getRealClass(Object o) {
+ if (AopUtils.isAopProxy(o) && (o instanceof Advised)) {
+ Advised advised = (Advised)o;
+ try {
+ TargetSource targetSource = advised.getTargetSource();
+
+ final Object target;
+ try {
+ target = targetSource.getTarget();
+ } catch (BeanCreationException ex) {
+ // some scopes such as 'request' may not
+ // be active on the current thread yet
+ return getRealClassFromClass(targetSource.getTargetClass());
+ }
+
+ if (target == null) {
+ Class<?> targetClass = AopUtils.getTargetClass(o);
+ if (targetClass != null) {
+ return getRealClassFromClass(targetClass);
+ }
+ } else {
+ return getRealClass(target);
+ }
+ } catch (Exception ex) {
+ // ignore
+ }
+
+ } else if (ClassUtils.isCglibProxyClass(o.getClass())) {
+ return getRealClassFromClass(AopUtils.getTargetClass(o));
+ }
+
+ return o.getClass();
+ }
+
+ /**
+ * This additional check is not very reliable since CGLIB allows to
+ * supply own NamingPolicy implementations. However, it works with native
+ * CGLIB proxies ("byCGLIB$$") as well as Spring CGLIB proxies (by "BySpringCGLIB$$").
+ * More expensive approach is to use reflection and inspect the class declared methods,
+ * looking for CGLIB-specific ones like CGLIB$BIND_CALLBACKS.
+ */
+ private static boolean wasCglibEnhanced(Class<?> cls) {
+ return cls.getName().contains("CGLIB");
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/SpringClasspathScanner.java b/transform/src/patch/java/org/apache/cxf/common/util/SpringClasspathScanner.java
new file mode 100644
index 0000000..9113d77
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/SpringClasspathScanner.java
@@ -0,0 +1,202 @@
+/**
+ * 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.cxf.common.util;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
+import org.springframework.core.io.support.ResourcePatternResolver;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
+import org.springframework.core.type.classreading.MetadataReader;
+import org.springframework.core.type.classreading.MetadataReaderFactory;
+import org.springframework.util.ClassUtils;
+
+class SpringClasspathScanner extends ClasspathScanner {
+
+ private static final boolean IN_OSGI = isSpringInOsgi();
+
+
+ SpringClasspathScanner() throws Exception {
+ Class.forName("org.springframework.core.io.support.PathMatchingResourcePatternResolver");
+ Class.forName("org.springframework.core.type.classreading.CachingMetadataReaderFactory");
+ }
+ private static boolean isSpringInOsgi() {
+ try {
+ Class.forName("org.springframework.osgi.io.OsgiBundleResourcePatternResolver");
+ Class.forName("org.springframework.osgi.util.BundleDelegatingClassLoader");
+ return true;
+ } catch (Throwable ex) {
+ return false;
+ }
+ }
+
+ @Override
+ protected Map< Class< ? extends Annotation >, Collection< Class< ? > > > findClassesInternal(
+ Collection< String > basePackages,
+ List<Class< ? extends Annotation > > annotations,
+ ClassLoader loader)
+ throws IOException, ClassNotFoundException {
+
+ ResourcePatternResolver resolver = getResolver(loader);
+ MetadataReaderFactory factory = new CachingMetadataReaderFactory(resolver);
+
+ final Map< Class< ? extends Annotation >, Collection< Class< ? > > > classes =
+ new HashMap<>();
+ final Map< Class< ? extends Annotation >, Collection< String > > matchingInterfaces =
+ new HashMap<>();
+ final Map<String, String[]> nonMatchingClasses = new HashMap<>();
+
+ for (Class< ? extends Annotation > annotation: annotations) {
+ classes.put(annotation, new HashSet<>());
+ matchingInterfaces.put(annotation, new HashSet<>());
+ }
+
+ if (basePackages == null || basePackages.isEmpty()) {
+ return classes;
+ }
+
+ for (final String basePackage: basePackages) {
+ final boolean scanAllPackages = basePackage.equals(WILDCARD);
+ final String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ + (scanAllPackages ? "" : ClassUtils.convertClassNameToResourcePath(basePackage))
+ + ALL_CLASS_FILES;
+
+ final Resource[] resources = resolver.getResources(packageSearchPath);
+
+
+ for (final Resource resource: resources) {
+ final MetadataReader reader = factory.getMetadataReader(resource);
+ final AnnotationMetadata metadata = reader.getAnnotationMetadata();
+
+ if (scanAllPackages && shouldSkip(metadata.getClassName())) {
+ continue;
+ }
+
+ for (Class< ? extends Annotation > annotation: annotations) {
+ boolean concreteClass = !metadata.isInterface() && !metadata.isAbstract();
+ if (metadata.isAnnotated(annotation.getName())) {
+ if (concreteClass) {
+ classes.get(annotation).add(loadClass(metadata.getClassName(), loader));
+ } else {
+ matchingInterfaces.get(annotation).add(metadata.getClassName());
+ }
+ } else if (concreteClass && metadata.getInterfaceNames().length > 0) {
+ nonMatchingClasses.put(metadata.getClassName(), metadata.getInterfaceNames());
+ }
+ }
+ }
+ }
+ if (!nonMatchingClasses.isEmpty()) {
+ for (Map.Entry<Class<? extends Annotation>, Collection<String>> e1 : matchingInterfaces.entrySet()) {
+ for (Map.Entry<String, String[]> e2 : nonMatchingClasses.entrySet()) {
+ for (String intName : e2.getValue()) {
+ if (e1.getValue().contains(intName)) {
+ classes.get(e1.getKey()).add(loadClass(e2.getKey(), loader));
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ for (Map.Entry<Class<? extends Annotation>, Collection<String>> e : matchingInterfaces.entrySet()) {
+ if (classes.get(e.getKey()).isEmpty()) {
+ for (String intName : e.getValue()) {
+ classes.get(e.getKey()).add(loadClass(intName, loader));
+ }
+ }
+ }
+
+ return classes;
+ }
+
+ @Override
+ protected List<URL> findResourcesInternal(Collection<String> basePackages,
+ String extension,
+ ClassLoader loader)
+ throws IOException {
+ final List<URL> resourceURLs = new ArrayList<>();
+ if (basePackages == null || basePackages.isEmpty()) {
+ return resourceURLs;
+ }
+ ResourcePatternResolver resolver = getResolver(loader);
+
+ for (final String basePackage: basePackages) {
+ final boolean scanAllPackages = basePackage.equals(WILDCARD);
+
+ String theBasePackage = basePackage;
+ if (theBasePackage.startsWith(CLASSPATH_URL_SCHEME)) {
+ theBasePackage = theBasePackage.substring(CLASSPATH_URL_SCHEME.length());
+ }
+
+ final String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ + (scanAllPackages ? "" : basePackage.contains(WILDCARD) ? basePackage
+ : ClassUtils.convertClassNameToResourcePath(theBasePackage)) + ALL_FILES + "." + extension;
+
+ final Resource[] resources = resolver.getResources(packageSearchPath);
+ for (final Resource resource: resources) {
+ resourceURLs.add(resource.getURL());
+ }
+ }
+
+ return resourceURLs;
+ }
+
+ private ResourcePatternResolver getResolver(ClassLoader loader) {
+ ResourcePatternResolver resolver = null;
+
+ if (IN_OSGI) {
+ resolver = SpringOsgiUtil.getResolver(loader);
+ }
+ if (resolver == null) {
+ resolver = loader != null
+ ? new PathMatchingResourcePatternResolver(loader) : new PathMatchingResourcePatternResolver();
+ }
+ return resolver;
+ }
+
+ private boolean shouldSkip(final String classname) {
+ for (String packageToSkip: PACKAGES_TO_SKIP) {
+ if (classname.startsWith(packageToSkip)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private Class<?> loadClass(String className, ClassLoader loader)
+ throws ClassNotFoundException {
+ if (loader == null) {
+ return ClassLoaderUtils.loadClass(className, getClass());
+ }
+ return loader.loadClass(className);
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/StreamPrinter.java b/transform/src/patch/java/org/apache/cxf/common/util/StreamPrinter.java
new file mode 100644
index 0000000..fa88287
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/StreamPrinter.java
@@ -0,0 +1,63 @@
+/**
+ * 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.cxf.common.util;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+
+class StreamPrinter extends Thread {
+ private InputStream is;
+ private String msg;
+ private OutputStream os;
+
+ StreamPrinter(InputStream stream, String type, OutputStream redirect) {
+ is = stream;
+ msg = type;
+ os = redirect;
+ }
+
+ @Override
+ public void run() {
+ try {
+ PrintWriter pw = null;
+ if (os != null) {
+ pw = new PrintWriter(os);
+ }
+ InputStreamReader isr = new InputStreamReader(is);
+ BufferedReader br = new BufferedReader(isr);
+ String line = br.readLine();
+ while (line != null) {
+ if (pw != null) {
+ pw.println(msg + " " + line);
+ }
+ line = br.readLine();
+ }
+ if (pw != null) {
+ pw.flush();
+ }
+ } catch (IOException ioe) {
+ throw new RuntimeException(ioe);
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/util/URIParserUtil.java b/transform/src/patch/java/org/apache/cxf/common/util/URIParserUtil.java
new file mode 100644
index 0000000..462896f
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/util/URIParserUtil.java
@@ -0,0 +1,209 @@
+/**
+ * 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.cxf.common.util;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.StringTokenizer;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+
+public final class URIParserUtil {
+ private static final String EXCLUDED_CHARS = "<>\"{}|\\^`";
+
+ private URIParserUtil() {
+ // complete
+ }
+
+ private static boolean isExcluded(char ch) {
+ return ch <= 0x20 || ch >= 0x7F || EXCLUDED_CHARS.indexOf(ch) != -1;
+ }
+
+ public static URL[] pathToURLs(String path) {
+ StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
+ URL[] urls = new URL[st.countTokens()];
+ int count = 0;
+ while (st.hasMoreTokens()) {
+ File file = new File(st.nextToken());
+ URL url = null;
+ try {
+ url = file.toURI().toURL();
+ } catch (MalformedURLException e) {
+ e.printStackTrace();
+ }
+ if (url != null) {
+ urls[count++] = url;
+ }
+ }
+ if (urls.length != count) {
+ URL[] tmp = new URL[count];
+ System.arraycopy(urls, 0, tmp, 0, count);
+ urls = tmp;
+ }
+ return urls;
+ }
+
+ public static String escapeChars(String s) {
+ StringBuilder sb = new StringBuilder(s.length());
+
+ for (int x = 0; x < s.length(); x++) {
+ char ch = s.charAt(x);
+ if (isExcluded(ch)) {
+ byte[] bytes = Character.toString(ch).getBytes(StandardCharsets.UTF_8);
+ for (byte b : bytes) {
+ sb.append('%');
+ StringUtils.byteToHex(b, sb);
+ }
+ } else {
+ sb.append(ch);
+ }
+ }
+ return sb.toString();
+ }
+ public static String normalize(final String uri) {
+ URL url = null;
+ String result;
+ try {
+ url = new URL(uri);
+ result = escapeChars(url.toURI().normalize().toString().replace('\\', '/'));
+ } catch (MalformedURLException e1) {
+ try {
+ if (uri.startsWith("classpath:")) {
+ url = ClassLoaderUtils.getResource(uri.substring(10), URIParserUtil.class);
+ return url != null ? url.toExternalForm() : uri;
+ }
+ File file = new File(uri);
+ if (file.exists()) {
+ return file.toURI().normalize().toString();
+ }
+ final String f;
+ if (uri.indexOf(':') != -1 && !uri.startsWith("/")) {
+ f = "file:/" + uri;
+ } else {
+ f = "file:" + uri;
+ }
+ url = new URL(f);
+ return escapeChars(url.toString().replace("\\", "/"));
+ } catch (Exception e2) {
+ return escapeChars(uri.replace("\\", "/"));
+ }
+ } catch (URISyntaxException e) {
+ result = escapeChars(url.toString().replace("\\", "/"));
+ }
+ return result;
+ }
+
+ public static String getAbsoluteURI(final String arg) {
+ if (arg == null) {
+ return null;
+ }
+
+ try {
+ URI uri = new URI(arg);
+ if ("file".equalsIgnoreCase(uri.getScheme())) {
+ if (!uri.isOpaque()) {
+ return uri.normalize().toString();
+ }
+ return new File("").toURI().resolve(uri.getPath()).toString();
+ }
+ return normalize(arg);
+ } catch (Exception e2) {
+ return normalize(arg);
+ }
+ }
+
+ public static String relativize(String base, String toBeRelativized) throws URISyntaxException {
+ if (base == null || toBeRelativized == null) {
+ return null;
+ }
+ return relativize(new URI(base), new URI(toBeRelativized));
+ }
+
+ /**
+ * This is a custom implementation for doing what URI.relativize(URI uri) should be
+ * doing but is not actually doing when URI roots do not fully match.
+ * See http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6226081
+ *
+ * @param baseURI The base URI
+ * @param toBeRelativizedURI The URI to be relativized
+ * @return The string value of the URI you'd expect to get as result
+ * of calling baseURI.relativize(toBeRelativizedURI).
+ * null is returned if the parameters are null or are not
+ * both absolute or not absolute.
+ * @throws URISyntaxException
+ */
+ public static String relativize(URI baseURI, URI toBeRelativizedURI) throws URISyntaxException {
+ if (baseURI == null || toBeRelativizedURI == null) {
+ return null;
+ }
+ if (baseURI.isAbsolute() ^ toBeRelativizedURI.isAbsolute()) {
+ return null;
+ }
+ final String base = baseURI.getSchemeSpecificPart();
+ final String toBeRelativized = toBeRelativizedURI.getSchemeSpecificPart();
+ final int l1 = base.length();
+ final int l2 = toBeRelativized.length();
+ if (l1 == 0) {
+ return toBeRelativized;
+ }
+ int slashes = 0;
+ StringBuilder sb = new StringBuilder();
+ boolean differenceFound = false;
+ for (int i = 0; i < l1; i++) {
+ char c = base.charAt(i);
+ if (i < l2) {
+ if (!differenceFound && c == toBeRelativized.charAt(i)) {
+ sb.append(c);
+ } else {
+ differenceFound = true;
+ if (c == '/') {
+ slashes++;
+ }
+ }
+ } else {
+ if (c == '/') {
+ slashes++;
+ }
+ }
+ }
+ String rResolved = new URI(getRoot(sb.toString())).relativize(new URI(toBeRelativized)).toString();
+ StringBuilder relativizedPath = new StringBuilder();
+ for (int i = 0; i < slashes; i++) {
+ relativizedPath.append("../");
+ }
+ relativizedPath.append(rResolved);
+ return relativizedPath.toString();
+ }
+
+ private static String getRoot(String uri) {
+ int idx = uri.lastIndexOf('/');
+ if (idx == uri.length() - 1) {
+ return uri;
+ } else if (idx == -1) {
+ return "";
+ } else {
+ return uri.substring(0, idx + 1);
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/common/xmlschema/SchemaCollection.java b/transform/src/patch/java/org/apache/cxf/common/xmlschema/SchemaCollection.java
new file mode 100644
index 0000000..0f3a579
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/common/xmlschema/SchemaCollection.java
@@ -0,0 +1,389 @@
+/**
+ * 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.cxf.common.xmlschema;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.namespace.QName;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import org.apache.ws.commons.schema.XmlSchema;
+import org.apache.ws.commons.schema.XmlSchemaAll;
+import org.apache.ws.commons.schema.XmlSchemaAttribute;
+import org.apache.ws.commons.schema.XmlSchemaAttributeGroupRef;
+import org.apache.ws.commons.schema.XmlSchemaAttributeOrGroupRef;
+import org.apache.ws.commons.schema.XmlSchemaChoice;
+import org.apache.ws.commons.schema.XmlSchemaCollection;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentRestriction;
+import org.apache.ws.commons.schema.XmlSchemaComplexType;
+import org.apache.ws.commons.schema.XmlSchemaContent;
+import org.apache.ws.commons.schema.XmlSchemaContentModel;
+import org.apache.ws.commons.schema.XmlSchemaElement;
+import org.apache.ws.commons.schema.XmlSchemaParticle;
+import org.apache.ws.commons.schema.XmlSchemaSequence;
+import org.apache.ws.commons.schema.XmlSchemaSequenceMember;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentRestriction;
+import org.apache.ws.commons.schema.XmlSchemaType;
+import org.apache.ws.commons.schema.extensions.ExtensionRegistry;
+import org.apache.ws.commons.schema.resolver.URIResolver;
+import org.apache.ws.commons.schema.utils.NamespaceMap;
+import org.apache.ws.commons.schema.utils.NamespacePrefixList;
+import org.apache.ws.commons.schema.utils.XmlSchemaObjectBase;
+
+/**
+ * Wrapper class for XmlSchemaCollection that deals with various quirks and bugs.
+ */
+public class SchemaCollection {
+
+ private final XmlSchemaCollection xmlSchemaCollection;
+ private final Map<XmlSchema, Set<XmlSchemaType>> xmlTypesCheckedForCrossImportsPerSchema
+ = new HashMap<>();
+
+ public SchemaCollection() {
+ this(new XmlSchemaCollection());
+ }
+
+ public SchemaCollection(XmlSchemaCollection col) {
+ xmlSchemaCollection = col;
+ if (xmlSchemaCollection.getNamespaceContext() == null) {
+ // an empty prefix map avoids extra checks for null.
+ xmlSchemaCollection.setNamespaceContext(new NamespaceMap());
+ }
+ }
+
+ public XmlSchemaCollection getXmlSchemaCollection() {
+ return xmlSchemaCollection;
+ }
+
+ public boolean equals(Object obj) {
+ if (obj instanceof SchemaCollection) {
+ return xmlSchemaCollection.equals(((SchemaCollection)obj).xmlSchemaCollection);
+ } else if (obj instanceof XmlSchemaCollection) {
+ return xmlSchemaCollection.equals(obj);
+ }
+ return false;
+ }
+
+ public XmlSchemaElement getElementByQName(QName qname) {
+ return xmlSchemaCollection.getElementByQName(qname);
+ }
+
+ public XmlSchemaAttribute getAttributeByQName(QName qname) {
+ return xmlSchemaCollection.getAttributeByQName(qname);
+ }
+
+ public ExtensionRegistry getExtReg() {
+ return xmlSchemaCollection.getExtReg();
+ }
+
+ public NamespacePrefixList getNamespaceContext() {
+ return xmlSchemaCollection.getNamespaceContext();
+ }
+
+ public XmlSchemaType getTypeByQName(QName schemaTypeName) {
+ return xmlSchemaCollection.getTypeByQName(schemaTypeName);
+ }
+
+ public XmlSchema[] getXmlSchema(String systemId) {
+ return xmlSchemaCollection.getXmlSchema(systemId);
+ }
+
+ public XmlSchema[] getXmlSchemas() {
+ return xmlSchemaCollection.getXmlSchemas();
+ }
+
+ public int hashCode() {
+ return xmlSchemaCollection.hashCode();
+ }
+
+ public void init() {
+ xmlSchemaCollection.init();
+ }
+
+ public XmlSchema read(Element elem, String uri) {
+ return xmlSchemaCollection.read(elem, uri);
+ }
+
+ public XmlSchema read(Document d, String uri) {
+ return xmlSchemaCollection.read(d, uri);
+ }
+
+ public XmlSchema read(Element elem) {
+ return xmlSchemaCollection.read(elem);
+ }
+
+ public void setBaseUri(String baseUri) {
+ xmlSchemaCollection.setBaseUri(baseUri);
+ }
+
+ public void setExtReg(ExtensionRegistry extReg) {
+ xmlSchemaCollection.setExtReg(extReg);
+ }
+
+ public void setNamespaceContext(NamespacePrefixList namespaceContext) {
+ xmlSchemaCollection.setNamespaceContext(namespaceContext);
+ }
+
+ public void setSchemaResolver(URIResolver schemaResolver) {
+ xmlSchemaCollection.setSchemaResolver(schemaResolver);
+ }
+
+ /**
+ * This function is not part of the XmlSchema API. Who knows why?
+ *
+ * @param namespaceURI targetNamespace
+ * @return schema, or null.
+ */
+ public XmlSchema getSchemaByTargetNamespace(String namespaceURI) {
+ for (XmlSchema schema : xmlSchemaCollection.getXmlSchemas()) {
+ if (namespaceURI != null && namespaceURI.equals(schema.getTargetNamespace())
+ || namespaceURI == null && schema.getTargetNamespace() == null) {
+ return schema;
+ }
+ }
+ return null;
+ }
+
+ public XmlSchema getSchemaForElement(QName name) {
+ for (XmlSchema schema : xmlSchemaCollection.getXmlSchemas()) {
+ if (name.getNamespaceURI().equals(schema.getTargetNamespace())) {
+
+ if (schema.getElementByName(name.getLocalPart()) != null) {
+ return schema;
+ } else if (schema.getElementByName(name) != null) {
+ return schema;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Once upon a time, XmlSchema had a bug in the constructor used in this function. So this wrapper was
+ * created to hold a workaround.
+ *
+ * @param namespaceURI TNS for new schema.
+ * @return new schema
+ */
+
+ public XmlSchema newXmlSchemaInCollection(String namespaceURI) {
+ return new XmlSchema(namespaceURI, xmlSchemaCollection);
+ }
+
+ /**
+ * Validate that a qualified name points to some namespace in the schema.
+ *
+ * @param qname
+ */
+ public void validateQNameNamespace(QName qname) {
+ // astonishingly, xmlSchemaCollection has no accessor by target URL.
+ if ("".equals(qname.getNamespaceURI())) {
+ return; // references to the 'unqualified' namespace are OK even if there is no schema for it.
+ }
+ for (XmlSchema schema : xmlSchemaCollection.getXmlSchemas()) {
+ if (schema.getTargetNamespace().equals(qname.getNamespaceURI())) {
+ return;
+ }
+ }
+ throw new InvalidXmlSchemaReferenceException(qname + " refers to unknown namespace.");
+ }
+
+ public void validateElementName(QName referrer, QName elementQName) {
+ XmlSchemaElement element = xmlSchemaCollection.getElementByQName(elementQName);
+ if (element == null) {
+ throw new InvalidXmlSchemaReferenceException(referrer + " references non-existent element "
+ + elementQName);
+ }
+ }
+
+ public void validateTypeName(QName referrer, QName typeQName) {
+ XmlSchemaType type = xmlSchemaCollection.getTypeByQName(typeQName);
+ if (type == null) {
+ throw new InvalidXmlSchemaReferenceException(referrer + " references non-existent type "
+ + typeQName);
+ }
+ }
+
+ public void addCrossImports() {
+ /*
+ * We need to inventory all the cross-imports to see if any are missing.
+ */
+ for (XmlSchema schema : xmlSchemaCollection.getXmlSchemas()) {
+ addOneSchemaCrossImports(schema);
+ }
+ }
+
+ private void addOneSchemaCrossImports(XmlSchema schema) {
+ /*
+ * We need to visit all the top-level items.
+ */
+ for (XmlSchemaElement element : schema.getElements().values()) {
+ addElementCrossImportsElement(schema, element);
+ }
+ for (XmlSchemaAttribute attribute : schema.getAttributes().values()) {
+ XmlSchemaUtils.addImportIfNeeded(schema, attribute.getRef().getTargetQName());
+ XmlSchemaUtils.addImportIfNeeded(schema, attribute.getSchemaTypeName());
+ }
+ for (XmlSchemaType type : schema.getSchemaTypes().values()) {
+ addCrossImportsType(schema, type);
+ }
+ }
+
+ private void addElementCrossImportsElement(XmlSchema schema, XmlSchemaElement item) {
+ XmlSchemaElement element = item;
+ XmlSchemaUtils.addImportIfNeeded(schema, element.getRef().getTargetQName());
+ XmlSchemaUtils.addImportIfNeeded(schema, element.getSchemaTypeName());
+ // if there's an anonymous type, it might have element refs in it.
+ XmlSchemaType schemaType = element.getSchemaType();
+ if (!crossImportsAdded(schema, schemaType)) {
+ addCrossImportsType(schema, schemaType);
+ }
+ }
+
+ /**
+ * Determines whether the schema has already received (cross) imports for the schemaType
+ *
+ * @param schema
+ * @param schemaType
+ * @return false if cross imports for schemaType must still be added to schema
+ */
+ private boolean crossImportsAdded(XmlSchema schema, XmlSchemaType schemaType) {
+ boolean result = true;
+ if (schemaType != null) {
+ Set<XmlSchemaType> xmlTypesCheckedForCrossImports;
+ if (!xmlTypesCheckedForCrossImportsPerSchema.containsKey(schema)) {
+ xmlTypesCheckedForCrossImports = new HashSet<>();
+ xmlTypesCheckedForCrossImportsPerSchema.put(schema, xmlTypesCheckedForCrossImports);
+ } else {
+ xmlTypesCheckedForCrossImports = xmlTypesCheckedForCrossImportsPerSchema.get(schema);
+ }
+ if (!xmlTypesCheckedForCrossImports.contains(schemaType)) {
+ // cross imports for this schemaType have not yet been added
+ xmlTypesCheckedForCrossImports.add(schemaType);
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ private void addCrossImportsType(XmlSchema schema, XmlSchemaType schemaType) {
+ // the base type might cross schemas.
+ if (schemaType instanceof XmlSchemaComplexType) {
+ XmlSchemaComplexType complexType = (XmlSchemaComplexType)schemaType;
+ XmlSchemaUtils.addImportIfNeeded(schema, complexType.getBaseSchemaTypeName());
+ addCrossImports(schema, complexType.getContentModel());
+ addCrossImportsAttributeList(schema, complexType.getAttributes());
+ // could it be a choice or something else?
+
+ if (complexType.getParticle() instanceof XmlSchemaChoice) {
+ XmlSchemaChoice choice = (XmlSchemaChoice)complexType.getParticle();
+ addCrossImports(schema, choice);
+ } else if (complexType.getParticle() instanceof XmlSchemaAll) {
+ XmlSchemaAll all = (XmlSchemaAll)complexType.getParticle();
+ addCrossImports(schema, all);
+ } else if (complexType.getParticle() instanceof XmlSchemaSequence) {
+ XmlSchemaSequence sequence = (XmlSchemaSequence)complexType.getParticle();
+ addCrossImports(schema, sequence);
+ }
+ }
+ }
+ private void addCrossImports(XmlSchema schema, XmlSchemaAll all) {
+ for (XmlSchemaObjectBase seqMember : all.getItems()) {
+ if (seqMember instanceof XmlSchemaElement) {
+ addElementCrossImportsElement(schema, (XmlSchemaElement)seqMember);
+ }
+ }
+ }
+
+ private void addCrossImports(XmlSchema schema, XmlSchemaChoice choice) {
+ for (XmlSchemaObjectBase seqMember : choice.getItems()) {
+ if (seqMember instanceof XmlSchemaElement) {
+ addElementCrossImportsElement(schema, (XmlSchemaElement)seqMember);
+ }
+ }
+ }
+ private void addCrossImports(XmlSchema schema, XmlSchemaSequence sequence) {
+ for (XmlSchemaSequenceMember seqMember : sequence.getItems()) {
+ if (seqMember instanceof XmlSchemaElement) {
+ addElementCrossImportsElement(schema, (XmlSchemaElement)seqMember);
+ }
+ }
+ }
+
+ private void addCrossImportsAttributeList(XmlSchema schema, List<XmlSchemaAttributeOrGroupRef> list) {
+ for (XmlSchemaAttributeOrGroupRef attr : list) {
+ final QName ref;
+ if (attr instanceof XmlSchemaAttribute) {
+ ref = ((XmlSchemaAttribute)attr).getRef().getTargetQName();
+ } else {
+ XmlSchemaAttributeGroupRef groupRef = (XmlSchemaAttributeGroupRef)attr;
+ ref = groupRef.getRef().getTargetQName();
+ }
+
+ if (ref != null) {
+ XmlSchemaUtils.addImportIfNeeded(schema, ref);
+ }
+ }
+ }
+
+ private void addCrossImports(XmlSchema schema, XmlSchemaContentModel contentModel) {
+ if (contentModel == null) {
+ return;
+ }
+ XmlSchemaContent content = contentModel.getContent();
+ if (content == null) {
+ return;
+ }
+ if (content instanceof XmlSchemaComplexContentExtension) {
+ XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
+ XmlSchemaUtils.addImportIfNeeded(schema, extension.getBaseTypeName());
+ addCrossImportsAttributeList(schema, extension.getAttributes());
+ XmlSchemaParticle particle = extension.getParticle();
+ if (particle instanceof XmlSchemaSequence) {
+ addCrossImports(schema, (XmlSchemaSequence)particle);
+ } else if (particle instanceof XmlSchemaChoice) {
+ addCrossImports(schema, (XmlSchemaChoice)particle);
+ } else if (particle instanceof XmlSchemaAll) {
+ addCrossImports(schema, (XmlSchemaAll)particle);
+ }
+ } else if (content instanceof XmlSchemaComplexContentRestriction) {
+ XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)content;
+ XmlSchemaUtils.addImportIfNeeded(schema, restriction.getBaseTypeName());
+ addCrossImportsAttributeList(schema, restriction.getAttributes());
+ } else if (content instanceof XmlSchemaSimpleContentExtension) {
+ XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension)content;
+ XmlSchemaUtils.addImportIfNeeded(schema, extension.getBaseTypeName());
+ addCrossImportsAttributeList(schema, extension.getAttributes());
+ } else if (content instanceof XmlSchemaSimpleContentRestriction) {
+ XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content;
+ XmlSchemaUtils.addImportIfNeeded(schema, restriction.getBaseTypeName());
+ addCrossImportsAttributeList(schema, restriction.getAttributes());
+ }
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/configuration/jsse/MultiKeyPasswordKeyManager.java b/transform/src/patch/java/org/apache/cxf/configuration/jsse/MultiKeyPasswordKeyManager.java
new file mode 100644
index 0000000..6a1aee5
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/configuration/jsse/MultiKeyPasswordKeyManager.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.cxf.configuration.jsse;
+
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.Principal;
+import java.security.PrivateKey;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+
+import javax.net.ssl.X509KeyManager;
+
+public class MultiKeyPasswordKeyManager implements X509KeyManager {
+ private final KeyStore mKeyStore;
+ private final String mKeyAlias;
+ private final String mKeyPassword;
+
+ public MultiKeyPasswordKeyManager(KeyStore keystore, String keyAlias, String keyPassword) {
+ mKeyStore = keystore;
+ mKeyAlias = keyAlias;
+ mKeyPassword = keyPassword;
+ }
+
+ public String[] getClientAliases(String keyType, Principal[] issuers) {
+ return new String[] {
+ mKeyAlias
+ };
+ }
+
+ public String[] getServerAliases(String keyType, Principal[] issuers) {
+ return new String[] {
+ mKeyAlias
+ };
+ }
+ public X509Certificate[] getCertificateChain(String alias) {
+ final Certificate[] chain;
+ try {
+ chain = mKeyStore.getCertificateChain(alias);
+ } catch (KeyStoreException kse) {
+ throw new RuntimeException(kse);
+ }
+ final X509Certificate[] certChain = new X509Certificate[chain.length];
+ for (int i = 0; i < chain.length; i++) {
+ certChain[i] = (X509Certificate)chain[i];
+ }
+ return certChain;
+ }
+
+ public PrivateKey getPrivateKey(String alias) {
+ try {
+ return (PrivateKey)mKeyStore.getKey(alias, mKeyPassword.toCharArray());
+ } catch (GeneralSecurityException gse) {
+ throw new RuntimeException(gse);
+ }
+ }
+
+ public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {
+ return mKeyAlias;
+ }
+
+ public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
+ return mKeyAlias;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/configuration/jsse/TLSClientParameters.java b/transform/src/patch/java/org/apache/cxf/configuration/jsse/TLSClientParameters.java
new file mode 100644
index 0000000..3e0099a
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/configuration/jsse/TLSClientParameters.java
@@ -0,0 +1,258 @@
+/**
+ * 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.cxf.configuration.jsse;
+
+import java.util.List;
+import java.util.Objects;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * This class extends {@link TLSParameterBase} with client-specific
+ * SSL/TLS parameters.
+ *
+ */
+public class TLSClientParameters extends TLSParameterBase {
+ private boolean disableCNCheck;
+ private SSLSocketFactory sslSocketFactory;
+ private int sslCacheTimeout = 86400;
+ private boolean useHttpsURLConnectionDefaultSslSocketFactory;
+ private boolean useHttpsURLConnectionDefaultHostnameVerifier;
+ private HostnameVerifier hostnameVerifier;
+ private SSLContext sslContext;
+
+ /**
+ * Set custom HostnameVerifier
+ * @param verifier hostname verifier
+ */
+ public void setHostnameVerifier(HostnameVerifier verifier) {
+ hostnameVerifier = verifier;
+ }
+
+ /**
+ * Get custom HostnameVerifier
+ * @return hostname verifier
+ */
+ public HostnameVerifier getHostnameVerifier() {
+ return hostnameVerifier;
+ }
+ /**
+ * Set whether or not JSEE should omit checking if the host name
+ * specified in the URL matches that of the Common Name
+ * (CN) on the server's certificate. Default is false;
+ * this attribute should not be set to true during production use.
+ */
+ public void setDisableCNCheck(boolean disableCNCheck) {
+ this.disableCNCheck = disableCNCheck;
+ }
+
+ /**
+ * Returns whether or not JSSE omits checking if the
+ * host name specified in the URL matches that of the Common Name
+ * (CN) on the server's certificate.
+ */
+ public boolean isDisableCNCheck() {
+ return disableCNCheck;
+ }
+
+ /**
+ * This sets the SSLSocketFactory to use, causing all other properties of
+ * this bean (and its superclass) to get ignored (this takes precendence).
+ */
+ public final void setSSLSocketFactory(SSLSocketFactory factory) {
+ sslSocketFactory = factory;
+ }
+
+
+ /**
+ * Returns the SSLSocketFactory to be used, or null if none has been set.
+ */
+ public final SSLSocketFactory getSSLSocketFactory() {
+ return sslSocketFactory;
+ }
+
+ /**
+ * Returns the SSL cache timeout in seconds if it has been configured or the default value
+ */
+ public int getSslCacheTimeout() {
+ return sslCacheTimeout;
+ }
+
+ /**
+ * This sets the SSL Session Cache timeout value in seconds for client sessions handled by CXF
+ */
+ public void setSslCacheTimeout(int sslCacheTimeout) {
+ this.sslCacheTimeout = sslCacheTimeout;
+ }
+
+
+ /**
+ * Returns whether or not {@link javax.net.ssl.HttpsURLConnection#getDefaultSSLSocketFactory()} should be
+ * used to create https connections. If <code>true</code> , {@link #getJsseProvider()} ,
+ * {@link #getSecureSocketProtocol()}, {@link #getTrustManagers()}, {@link #getKeyManagers()},
+ * {@link #getSecureRandom()}, {@link #getCipherSuites()} and {@link #getCipherSuitesFilter()} are
+ * ignored.
+ */
+ public boolean isUseHttpsURLConnectionDefaultSslSocketFactory() {
+ return useHttpsURLConnectionDefaultSslSocketFactory;
+ }
+
+ /**
+ * Sets whether or not {@link javax.net.ssl.HttpsURLConnection#getDefaultSSLSocketFactory()} should be
+ * used to create https connections.
+ *
+ * @see #isUseHttpsURLConnectionDefaultSslSocketFactory()
+ */
+ public void setUseHttpsURLConnectionDefaultSslSocketFactory(
+ boolean useHttpsURLConnectionDefaultSslSocketFactory) {
+ this.useHttpsURLConnectionDefaultSslSocketFactory = useHttpsURLConnectionDefaultSslSocketFactory;
+ }
+
+ /**
+ * Returns whether or not {@link javax.net.ssl.HttpsURLConnection#getDefaultHostnameVerifier()} should be
+ * used to create https connections. If <code>true</code>, {@link #isDisableCNCheck()} is ignored.
+ */
+ public boolean isUseHttpsURLConnectionDefaultHostnameVerifier() {
+ return useHttpsURLConnectionDefaultHostnameVerifier;
+ }
+
+ /**
+ * Sets whether or not {@link javax.net.ssl.HttpsURLConnection#getDefaultHostnameVerifier()} should be
+ * used to create https connections.
+ *
+ * @see #isUseHttpsURLConnectionDefaultHostnameVerifier()
+ */
+ public void setUseHttpsURLConnectionDefaultHostnameVerifier(
+ boolean useHttpsURLConnectionDefaultHostnameVerifier) {
+ this.useHttpsURLConnectionDefaultHostnameVerifier = useHttpsURLConnectionDefaultHostnameVerifier;
+ }
+
+ public int hashCode() {
+ int hash = disableCNCheck ? 37 : 17;
+ if (sslSocketFactory != null) {
+ hash = hash * 41 + System.identityHashCode(sslSocketFactory);
+ }
+ if (sslContext != null) {
+ hash = hash * 41 + System.identityHashCode(sslContext);
+ }
+ hash = hash(hash, useHttpsURLConnectionDefaultSslSocketFactory);
+ hash = hash(hash, useHttpsURLConnectionDefaultHostnameVerifier);
+ hash = hash(hash, sslCacheTimeout);
+ hash = hash(hash, secureRandom);
+ hash = hash(hash, protocol);
+ hash = hash(hash, certAlias);
+ hash = hash(hash, provider);
+ for (String cs : ciphersuites) {
+ hash = hash(hash, cs);
+ }
+ hash = hash(hash, keyManagers);
+ hash = hash(hash, trustManagers);
+ if (cipherSuiteFilters != null) {
+ hash = hash(hash, cipherSuiteFilters.getInclude());
+ hash = hash(hash, cipherSuiteFilters.getExclude());
+ }
+ if (certConstraints != null) {
+ hash = hash(hash, certConstraints.getIssuerDNConstraints());
+ hash = hash(hash, certConstraints.getSubjectDNConstraints());
+ }
+ return hash;
+ }
+ private int hash(int i, Object o) {
+ if (o != null) {
+ return i * 37 + o.hashCode();
+ }
+ return i;
+ }
+ private int hash(int i, Object[] os) {
+ if (os == null) {
+ return i;
+ }
+ for (Object o : os) {
+ i = hash(i, o);
+ }
+ return i;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == this) {
+ return true;
+ }
+ if (o instanceof TLSClientParameters) {
+ TLSClientParameters that = (TLSClientParameters)o;
+ boolean eq = disableCNCheck == that.disableCNCheck;
+ eq &= sslSocketFactory == that.sslSocketFactory;
+ eq &= sslContext == that.sslContext;
+ eq &= useHttpsURLConnectionDefaultSslSocketFactory == that.useHttpsURLConnectionDefaultSslSocketFactory;
+ eq &= useHttpsURLConnectionDefaultHostnameVerifier == that.useHttpsURLConnectionDefaultHostnameVerifier;
+ eq &= sslCacheTimeout == that.sslCacheTimeout;
+ eq &= secureRandom == that.secureRandom;
+ eq &= Objects.equals(certAlias, that.certAlias);
+ eq &= Objects.equals(protocol, that.protocol);
+ eq &= Objects.equals(provider, that.provider);
+ eq &= equals(ciphersuites, that.ciphersuites);
+ eq &= Objects.deepEquals(keyManagers, that.keyManagers);
+ eq &= Objects.deepEquals(trustManagers, that.trustManagers);
+ if (cipherSuiteFilters != null) {
+ if (that.cipherSuiteFilters != null) {
+ eq &= equals(cipherSuiteFilters.getExclude(), that.cipherSuiteFilters.getExclude());
+ eq &= equals(cipherSuiteFilters.getInclude(), that.cipherSuiteFilters.getInclude());
+ } else {
+ eq = false;
+ }
+ } else {
+ eq &= that.cipherSuiteFilters == null;
+ }
+ if (certConstraints != null) {
+ if (that.certConstraints != null) {
+ eq &= Objects.equals(certConstraints.getIssuerDNConstraints(),
+ that.certConstraints.getIssuerDNConstraints());
+ eq &= Objects.equals(certConstraints.getSubjectDNConstraints(),
+ that.certConstraints.getSubjectDNConstraints());
+ } else {
+ eq = false;
+ }
+ } else {
+ eq &= that.certConstraints == null;
+ }
+ return eq;
+ }
+ return false;
+ }
+
+ private static boolean equals(final List<?> obj1, final List<?> obj2) {
+ return obj1.equals(obj2);
+ }
+
+ /**
+ * Get the SSLContext parameter to use (if it has been set)
+ */
+ public SSLContext getSslContext() {
+ return sslContext;
+ }
+
+ /**
+ * Set an SSLContext parameter to use to create https connections
+ */
+ public void setSslContext(SSLContext sslContext) {
+ this.sslContext = sslContext;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/configuration/jsse/TLSParameterJaxBUtils.java b/transform/src/patch/java/org/apache/cxf/configuration/jsse/TLSParameterJaxBUtils.java
new file mode 100644
index 0000000..bd16aa4
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/configuration/jsse/TLSParameterJaxBUtils.java
@@ -0,0 +1,420 @@
+/**
+ * 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.cxf.configuration.jsse;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Paths;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.PKIXBuilderParameters;
+import java.security.cert.X509CertSelector;
+import java.security.cert.X509Certificate;
+import java.util.Collection;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.net.ssl.CertPathTrustManagerParameters;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.security.auth.callback.CallbackHandler;
+import javax.security.auth.callback.PasswordCallback;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.configuration.security.CertStoreType;
+import org.apache.cxf.configuration.security.KeyManagersType;
+import org.apache.cxf.configuration.security.KeyStoreType;
+import org.apache.cxf.configuration.security.SecureRandomParameters;
+import org.apache.cxf.configuration.security.TrustManagersType;
+import org.apache.cxf.resource.ResourceManager;
+
+/**
+ * This class provides some functionality to convert the JAXB
+ * generated types in the security.xsd to the items needed
+ * to programatically configure the HTTPConduit and HTTPDestination
+ * with TLSClientParameters and TLSServerParameters respectively.
+ */
+public final class TLSParameterJaxBUtils {
+
+ private static final Logger LOG =
+ LogUtils.getL7dLogger(TLSParameterJaxBUtils.class);
+
+ private TLSParameterJaxBUtils() {
+ // empty
+ }
+ /**
+ * This method converts the JAXB generated type into a SecureRandom.
+ */
+ public static SecureRandom getSecureRandom(
+ SecureRandomParameters secureRandomParams
+ ) throws GeneralSecurityException {
+
+ SecureRandom secureRandom = null;
+ if (secureRandomParams != null) {
+ String secureRandomAlg =
+ secureRandomParams.getAlgorithm();
+ String randomProvider =
+ secureRandomParams.getProvider();
+ if (randomProvider != null) {
+ secureRandom = secureRandomAlg != null
+ ? SecureRandom.getInstance(
+ secureRandomAlg,
+ randomProvider)
+ : null;
+ } else {
+ secureRandom = secureRandomAlg != null
+ ? SecureRandom.getInstance(
+ secureRandomAlg)
+ : null;
+ }
+ }
+ return secureRandom;
+ }
+
+ public static KeyStore getKeyStore(KeyStoreType kst) throws GeneralSecurityException, IOException {
+ return getKeyStore(kst, false);
+ }
+
+ /**
+ * This method converts a JAXB generated KeyStoreType into a KeyStore.
+ */
+ public static KeyStore getKeyStore(KeyStoreType kst, boolean trustStore)
+ throws GeneralSecurityException,
+ IOException {
+
+ if (kst == null) {
+ return null;
+ }
+ final String type;
+ if (trustStore) {
+ type = SSLUtils.getTrustStoreType(kst.isSetType()
+ ? kst.getType() : null, LOG, KeyStore.getDefaultType());
+ } else {
+ type = SSLUtils.getKeystoreType(kst.isSetType()
+ ? kst.getType() : null, LOG, KeyStore.getDefaultType());
+ }
+
+ char[] password = kst.isSetPassword()
+ ? deobfuscate(kst.getPassword())
+ : null;
+ if (password == null) {
+ final String tmp;
+ if (trustStore) {
+ tmp = SSLUtils.getTruststorePassword(null, LOG);
+ } else {
+ tmp = SSLUtils.getKeystorePassword(null, LOG);
+ }
+ if (tmp != null) {
+ password = tmp.toCharArray();
+ }
+ }
+ final String provider;
+ if (trustStore) {
+ provider = SSLUtils.getTruststoreProvider(kst.isSetProvider() ? kst.getProvider() : null, LOG);
+ } else {
+ provider = SSLUtils.getKeystoreProvider(kst.isSetProvider() ? kst.getProvider() : null, LOG);
+ }
+ KeyStore keyStore = provider == null
+ ? KeyStore.getInstance(type)
+ : KeyStore.getInstance(type, provider);
+
+ if (kst.isSetFile()) {
+ try (InputStream kstInputStream = Files.newInputStream(Paths.get(kst.getFile()))) {
+ keyStore.load(kstInputStream, password);
+ }
+ } else if (kst.isSetResource()) {
+ final InputStream is = getResourceAsStream(kst.getResource());
+ if (is == null) {
+ final String msg =
+ "Could not load keystore resource " + kst.getResource();
+ LOG.severe(msg);
+ throw new IOException(msg);
+ }
+ keyStore.load(is, password);
+ } else if (kst.isSetUrl()) {
+ keyStore.load(new URL(kst.getUrl()).openStream(), password);
+ } else {
+ final String loc;
+ if (trustStore) {
+ loc = SSLUtils.getTruststore(null, LOG);
+ } else {
+ loc = SSLUtils.getKeystore(null, LOG);
+ }
+ if (loc != null) {
+ try (InputStream ins = Files.newInputStream(Paths.get(loc))) {
+ keyStore.load(ins, password);
+ } catch (NoSuchFileException ex) {
+ // Fall back to load the location as a stream
+ try (InputStream ins = getResourceAsStream(loc)) {
+ keyStore.load(ins, password);
+ }
+ }
+ }
+ }
+ return keyStore;
+ }
+
+ /**
+ * This method converts a JAXB generated CertStoreType into a KeyStore.
+ */
+ public static KeyStore getKeyStore(final CertStoreType pst)
+ throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException {
+
+ if (pst == null) {
+ return null;
+ }
+ String type;
+ if (pst.isSetType()) {
+ type = pst.getType();
+ } else {
+ type = KeyStore.getDefaultType();
+ }
+ if (pst.isSetFile()) {
+ InputStream is = Files.newInputStream(Paths.get(pst.getFile()));
+ return createTrustStore(is, type);
+ }
+ if (pst.isSetResource()) {
+ final InputStream is = getResourceAsStream(pst.getResource());
+ if (is == null) {
+ final String msg =
+ "Could not load truststore resource " + pst.getResource();
+ LOG.severe(msg);
+ throw new IOException(msg);
+ }
+ return createTrustStore(is, type);
+ }
+ if (pst.isSetUrl()) {
+ return createTrustStore(new URL(pst.getUrl()).openStream(), type);
+ }
+ throw new IllegalArgumentException("Could not create KeyStore based on information in CertStoreType");
+ }
+
+ private static InputStream getResourceAsStream(String resource) {
+ InputStream is = ClassLoaderUtils.getResourceAsStream(resource, TLSParameterJaxBUtils.class);
+ if (is == null) {
+ Bus bus = BusFactory.getThreadDefaultBus(true);
+ ResourceManager rm = bus.getExtension(ResourceManager.class);
+ if (rm != null) {
+ is = rm.getResourceAsStream(resource);
+ }
+ }
+ return is;
+ }
+
+ /**
+ * Create a KeyStore containing the trusted CA certificates contained
+ * in the supplied input stream.
+ */
+ private static KeyStore createTrustStore(final InputStream is, String type)
+ throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException {
+
+ final Collection<? extends Certificate> certs = loadCertificates(is);
+ final KeyStore keyStore =
+ KeyStore.getInstance(type);
+ keyStore.load(null, null);
+ for (Certificate cert : certs) {
+ final X509Certificate xcert = (X509Certificate) cert;
+ keyStore.setCertificateEntry(
+ xcert.getSubjectX500Principal().getName(),
+ cert
+ );
+ }
+ return keyStore;
+ }
+
+ /**
+ * load the certificates as X.509 certificates
+ */
+ private static Collection<? extends Certificate> loadCertificates(final InputStream is)
+ throws IOException, CertificateException {
+
+ final CertificateFactory factory = CertificateFactory.getInstance("X.509");
+ return factory.generateCertificates(is);
+ }
+
+ private static char[] deobfuscate(String s) {
+ // From the Jetty org.eclipse.jetty.http.security.Password class
+ if (!s.startsWith("OBF:")) {
+ return s.toCharArray();
+ }
+ s = s.substring(4);
+
+ char[] b = new char[s.length() / 2];
+ int l = 0;
+ for (int i = 0; i < s.length(); i += 4) {
+ String x = s.substring(i, i + 4);
+ int i0 = Integer.parseInt(x, 36);
+ int i1 = i0 / 256;
+ int i2 = i0 % 256;
+ b[l++] = (char) ((i1 + i2 - 254) / 2);
+ }
+
+ return new String(b, 0, l).toCharArray();
+ }
+
+ /**
+ * This method converts the JAXB KeyManagersType into a list of
+ * JSSE KeyManagers.
+ */
+ public static KeyManager[] getKeyManagers(KeyManagersType kmc)
+ throws GeneralSecurityException,
+ IOException {
+
+ KeyStore keyStore = getKeyStore(kmc.getKeyStore(), false);
+
+ String alg = kmc.isSetFactoryAlgorithm()
+ ? kmc.getFactoryAlgorithm()
+ : KeyManagerFactory.getDefaultAlgorithm();
+
+ char[] keyPass = getKeyPassword(kmc);
+
+ KeyManagerFactory fac =
+ kmc.isSetProvider()
+ ? KeyManagerFactory.getInstance(alg, kmc.getProvider())
+ : KeyManagerFactory.getInstance(alg);
+
+ fac.init(keyStore, keyPass);
+
+ return fac.getKeyManagers();
+ }
+
+ /**
+ * This method converts the JAXB KeyManagersType into a list of
+ * JSSE KeyManagers.
+ */
+ public static KeyManager[] getKeyManagers(KeyManagersType kmc, String alias)
+ throws GeneralSecurityException,
+ IOException {
+
+ KeyStore keyStore = getKeyStore(kmc.getKeyStore(), false);
+
+ String alg = kmc.isSetFactoryAlgorithm()
+ ? kmc.getFactoryAlgorithm()
+ : KeyManagerFactory.getDefaultAlgorithm();
+
+ char[] keyPass = getKeyPassword(kmc);
+
+ KeyManagerFactory fac =
+ kmc.isSetProvider()
+ ? KeyManagerFactory.getInstance(alg, kmc.getProvider())
+ : KeyManagerFactory.getInstance(alg);
+
+ try {
+ fac.init(keyStore, keyPass);
+
+ return fac.getKeyManagers();
+ } catch (java.security.UnrecoverableKeyException uke) {
+ //jsse has the restriction that different key in keystore
+ //cannot has different password, use MultiKeyPasswordKeyManager
+ //as fallback when this happen
+ MultiKeyPasswordKeyManager manager
+ = new MultiKeyPasswordKeyManager(keyStore, alias,
+ new String(keyPass));
+ return new KeyManager[]{manager};
+ }
+ }
+
+ private static char[] getKeyPassword(KeyManagersType kmc) {
+ char[] keyPass = kmc.isSetKeyPassword()
+ ? deobfuscate(kmc.getKeyPassword())
+ : null;
+
+ if (keyPass != null) {
+ return keyPass;
+ }
+
+ String callbackHandlerClass = kmc.getKeyPasswordCallbackHandler();
+ if (callbackHandlerClass == null) {
+ return null;
+ }
+ try {
+ final CallbackHandler ch = (CallbackHandler) ClassLoaderUtils
+ .loadClass(callbackHandlerClass, TLSParameterJaxBUtils.class).newInstance();
+ String prompt = kmc.getKeyStore().getFile();
+ if (prompt == null) {
+ prompt = kmc.getKeyStore().getResource();
+ }
+ PasswordCallback pwCb = new PasswordCallback(prompt, false);
+ PasswordCallback[] callbacks = new PasswordCallback[] {pwCb};
+ ch.handle(callbacks);
+ keyPass = callbacks[0].getPassword();
+ } catch (Exception e) {
+ LOG.log(Level.WARNING,
+ "Cannot load key password from callback handler: " + e.getMessage(), e);
+ }
+ return keyPass;
+ }
+
+ /**
+ * This method converts the JAXB TrustManagersType into a list of
+ * JSSE TrustManagers.
+ */
+ @Deprecated
+ public static TrustManager[] getTrustManagers(TrustManagersType tmc)
+ throws GeneralSecurityException,
+ IOException {
+ return getTrustManagers(tmc, false);
+ }
+
+ public static TrustManager[] getTrustManagers(TrustManagersType tmc, boolean enableRevocation)
+ throws GeneralSecurityException,
+ IOException {
+
+ final KeyStore keyStore =
+ tmc.isSetKeyStore()
+ ? getKeyStore(tmc.getKeyStore(), true)
+ : (tmc.isSetCertStore()
+ ? getKeyStore(tmc.getCertStore())
+ : null);
+
+ String alg = tmc.isSetFactoryAlgorithm()
+ ? tmc.getFactoryAlgorithm()
+ : TrustManagerFactory.getDefaultAlgorithm();
+
+ TrustManagerFactory fac =
+ tmc.isSetProvider()
+ ? TrustManagerFactory.getInstance(alg, tmc.getProvider())
+ : TrustManagerFactory.getInstance(alg);
+
+ if (enableRevocation) {
+ PKIXBuilderParameters param = new PKIXBuilderParameters(keyStore, new X509CertSelector());
+ param.setRevocationEnabled(true);
+
+ fac.init(new CertPathTrustManagerParameters(param));
+ } else {
+ fac.init(keyStore);
+ }
+
+ return fac.getTrustManagers();
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/configuration/spring/ConfigurerImpl.java b/transform/src/patch/java/org/apache/cxf/configuration/spring/ConfigurerImpl.java
new file mode 100644
index 0000000..d920936
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/configuration/spring/ConfigurerImpl.java
@@ -0,0 +1,288 @@
+/**
+ * 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.cxf.configuration.spring;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import org.apache.cxf.common.injection.NoJSR250Annotations;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.configuration.Configurable;
+import org.apache.cxf.configuration.Configurer;
+import org.apache.cxf.extension.BusExtension;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanFactory;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.wiring.BeanConfigurerSupport;
+import org.springframework.beans.factory.wiring.BeanWiringInfo;
+import org.springframework.beans.factory.wiring.BeanWiringInfoResolver;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.ConfigurableApplicationContext;
+
+@NoJSR250Annotations
+public class ConfigurerImpl extends BeanConfigurerSupport
+ implements Configurer, ApplicationContextAware, BusExtension {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(ConfigurerImpl.class);
+
+ private Set<ApplicationContext> appContexts;
+ private final Map<String, List<MatcherHolder>> wildCardBeanDefinitions = new TreeMap<>();
+ private BeanFactory beanFactory;
+
+ static class MatcherHolder implements Comparable<MatcherHolder> {
+ Matcher matcher;
+ String wildCardId;
+ MatcherHolder(String orig, Matcher matcher) {
+ wildCardId = orig;
+ this.matcher = matcher;
+ }
+
+ @Override
+ public int compareTo(MatcherHolder mh) {
+ int literalCharsLen1 = this.wildCardId.replace("*", "").length();
+ int literalCharsLen2 = mh.wildCardId.replace("*", "").length();
+ // The expression with more literal characters should end up on the top of the list
+ return Integer.compare(literalCharsLen1, literalCharsLen2) * -1;
+ }
+ }
+
+ public ConfigurerImpl() {
+ // complete
+ }
+
+ public ConfigurerImpl(ApplicationContext ac) {
+ setApplicationContext(ac);
+ }
+
+ @Override
+ public void setBeanFactory(BeanFactory beanFactory) {
+ this.beanFactory = beanFactory;
+ super.setBeanFactory(beanFactory);
+ }
+
+ private void initWildcardDefinitionMap() {
+ if (null != appContexts) {
+ for (ApplicationContext appContext : appContexts) {
+ for (String n : appContext.getBeanDefinitionNames()) {
+ if (isWildcardBeanName(n)) {
+ AutowireCapableBeanFactory bf = appContext.getAutowireCapableBeanFactory();
+ BeanDefinitionRegistry bdr = (BeanDefinitionRegistry) bf;
+ BeanDefinition bd = bdr.getBeanDefinition(n);
+ String className = bd.getBeanClassName();
+ if (null != className) {
+ final String name = n.charAt(0) != '*' ? n
+ : "." + n.replaceAll("\\.", "\\."); //old wildcard
+ try {
+ Matcher matcher = Pattern.compile(name).matcher("");
+ List<MatcherHolder> m = wildCardBeanDefinitions.get(className);
+ if (m == null) {
+ m = new ArrayList<>();
+ wildCardBeanDefinitions.put(className, m);
+ }
+ MatcherHolder holder = new MatcherHolder(n, matcher);
+ m.add(holder);
+ } catch (PatternSyntaxException npe) {
+ //not a valid patter, we'll ignore
+ }
+ } else {
+ LogUtils.log(LOG, Level.WARNING, "WILDCARD_BEAN_ID_WITH_NO_CLASS_MSG", n);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public void configureBean(Object beanInstance) {
+ configureBean(null, beanInstance, true);
+ }
+
+ public void configureBean(String bn, Object beanInstance) {
+ configureBean(bn, beanInstance, true);
+ }
+ public synchronized void configureBean(String bn, Object beanInstance, boolean checkWildcards) {
+
+ if (null == appContexts) {
+ return;
+ }
+
+ if (null == bn) {
+ bn = getBeanName(beanInstance);
+ if (null == bn) {
+ return;
+ }
+ }
+
+ if (checkWildcards) {
+ configureWithWildCard(bn, beanInstance);
+ }
+
+ final String beanName = bn;
+ setBeanWiringInfoResolver(new BeanWiringInfoResolver() {
+ public BeanWiringInfo resolveWiringInfo(Object instance) {
+ if (!beanName.isEmpty()) {
+ return new BeanWiringInfo(beanName);
+ }
+ return null;
+ }
+ });
+
+ for (ApplicationContext appContext : appContexts) {
+ if (appContext.containsBean(bn)) {
+ this.setBeanFactory(appContext.getAutowireCapableBeanFactory());
+ }
+ }
+
+ try {
+ //this will prevent a call into the AbstractBeanFactory.markBeanAsCreated(...)
+ //which saves ALL the names into a HashSet. For URL based configuration,
+ //this can leak memory
+ if (beanFactory instanceof AbstractBeanFactory) {
+ ((AbstractBeanFactory)beanFactory).getMergedBeanDefinition(bn);
+ }
+ super.configureBean(beanInstance);
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Successfully performed injection.");
+ }
+ } catch (NoSuchBeanDefinitionException ex) {
+ // users often wonder why the settings in their configuration files seem
+ // to have no effect - the most common cause is that they have been using
+ // incorrect bean ids
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.log(Level.FINE, "NO_MATCHING_BEAN_MSG", beanName);
+ }
+ }
+ }
+
+ private void configureWithWildCard(String bn, Object beanInstance) {
+ if (!wildCardBeanDefinitions.isEmpty()) {
+ Class<?> clazz = beanInstance.getClass();
+ while (!Object.class.equals(clazz)) {
+ String className = clazz.getName();
+ List<MatcherHolder> matchers = wildCardBeanDefinitions.get(className);
+ if (matchers != null) {
+ for (MatcherHolder m : matchers) {
+ synchronized (m.matcher) {
+ m.matcher.reset(bn);
+ if (m.matcher.matches()) {
+ configureBean(m.wildCardId, beanInstance, false);
+ return;
+ }
+ }
+ }
+ }
+ clazz = clazz.getSuperclass();
+ }
+ }
+ }
+
+ private boolean isWildcardBeanName(String bn) {
+ return bn.indexOf('*') != -1 || bn.indexOf('?') != -1
+ || (bn.indexOf('(') != -1 && bn.indexOf(')') != -1);
+ }
+
+ protected String getBeanName(Object beanInstance) {
+ if (beanInstance instanceof Configurable) {
+ return ((Configurable)beanInstance).getBeanName();
+ }
+ String beanName = null;
+ Method m = null;
+ try {
+ m = beanInstance.getClass().getDeclaredMethod("getBeanName", (Class[])null);
+ } catch (NoSuchMethodException ex) {
+ try {
+ m = beanInstance.getClass().getMethod("getBeanName", (Class[])null);
+ } catch (NoSuchMethodException e) {
+ //ignore
+ }
+ }
+ if (m != null) {
+ try {
+ beanName = (String)(m.invoke(beanInstance));
+ } catch (Exception ex) {
+ LogUtils.log(LOG, Level.WARNING, "ERROR_DETERMINING_BEAN_NAME_EXC", ex);
+ }
+ }
+
+ if (null == beanName) {
+ LogUtils.log(LOG, Level.FINE, "COULD_NOT_DETERMINE_BEAN_NAME_MSG",
+ beanInstance.getClass().getName());
+ }
+
+ return beanName;
+ }
+
+ public final void setApplicationContext(ApplicationContext ac) {
+ appContexts = new CopyOnWriteArraySet<>();
+ addApplicationContext(ac);
+ this.beanFactory = ac.getAutowireCapableBeanFactory();
+ super.setBeanFactory(this.beanFactory);
+ }
+
+ public final void addApplicationContext(ApplicationContext ac) {
+ if (!appContexts.contains(ac)) {
+ appContexts.add(ac);
+ List<ApplicationContext> inactiveApplicationContexts = new ArrayList<>();
+ Iterator<ApplicationContext> it = appContexts.iterator();
+ while (it.hasNext()) {
+ ApplicationContext c = it.next();
+ if (c instanceof ConfigurableApplicationContext
+ && !((ConfigurableApplicationContext)c).isActive()) {
+ inactiveApplicationContexts.add(c);
+ }
+ }
+ // Remove the inactive application context here can avoid the UnsupportedOperationException
+ for (ApplicationContext context : inactiveApplicationContexts) {
+ appContexts.remove(context);
+ }
+ initWildcardDefinitionMap();
+ }
+ }
+
+ @Override
+ public void destroy() {
+ super.destroy();
+ appContexts.clear();
+ }
+
+ public Class<?> getRegistrationType() {
+ return Configurer.class;
+ }
+
+ protected Set<ApplicationContext> getAppContexts() {
+ return appContexts;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/databinding/source/SourceDataBinding.java b/transform/src/patch/java/org/apache/cxf/databinding/source/SourceDataBinding.java
new file mode 100644
index 0000000..5321779
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/databinding/source/SourceDataBinding.java
@@ -0,0 +1,104 @@
+/**
+ * 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.cxf.databinding.source;
+
+
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.w3c.dom.Node;
+
+import org.apache.cxf.common.xmlschema.SchemaCollection;
+import org.apache.cxf.databinding.DataReader;
+import org.apache.cxf.databinding.DataWriter;
+import org.apache.cxf.service.Service;
+import org.apache.cxf.service.ServiceModelVisitor;
+import org.apache.cxf.service.model.MessagePartInfo;
+import org.apache.cxf.service.model.ServiceInfo;
+import org.apache.ws.commons.schema.constants.Constants;
+
+/**
+ * A simple databinding implementation which reads and writes Source objects.
+ */
+public class SourceDataBinding extends org.apache.cxf.databinding.AbstractDataBinding {
+
+ public static final String PREFERRED_FORMAT = "source-preferred-format";
+
+ final Class<?> preferred;
+
+ public SourceDataBinding() {
+ super();
+ preferred = null;
+ }
+ public SourceDataBinding(Class<?> pref) {
+ super();
+ preferred = pref;
+ }
+
+ public void initialize(Service service) {
+ for (ServiceInfo serviceInfo : service.getServiceInfos()) {
+ SchemaCollection schemaCollection = serviceInfo.getXmlSchemaCollection();
+ if (schemaCollection.getXmlSchemas().length > 1) {
+ // Schemas are already populated.
+ continue;
+ }
+ new ServiceModelVisitor(serviceInfo) {
+ @Override
+ public void begin(MessagePartInfo part) {
+ if (part.getTypeQName() != null || part.getElementQName() != null) {
+ return;
+ }
+ part.setTypeQName(Constants.XSD_ANYTYPE);
+ }
+ } .walk();
+ }
+ }
+
+
+ @SuppressWarnings("unchecked")
+ public <T> DataReader<T> createReader(Class<T> cls) {
+ if (cls == XMLStreamReader.class) {
+ return (DataReader<T>) new XMLStreamDataReader(preferred);
+ } else if (cls == Node.class) {
+ return (DataReader<T>) new NodeDataReader();
+ } else {
+ throw new UnsupportedOperationException("The type " + cls.getName() + " is not supported.");
+ }
+ }
+
+ public Class<?>[] getSupportedReaderFormats() {
+ return new Class<?>[] {XMLStreamReader.class, Node.class};
+ }
+
+ @SuppressWarnings("unchecked")
+ public <T> DataWriter<T> createWriter(Class<T> cls) {
+ if (cls == XMLStreamWriter.class) {
+ return (DataWriter<T>) new XMLStreamDataWriter();
+ } else if (cls == Node.class) {
+ return (DataWriter<T>) new NodeDataWriter();
+ }
+ throw new UnsupportedOperationException("The type " + cls.getName() + " is not supported.");
+ }
+
+ public Class<?>[] getSupportedWriterFormats() {
+ return new Class<?>[] {XMLStreamWriter.class, Node.class};
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/databinding/stax/StaxDataBinding.java b/transform/src/patch/java/org/apache/cxf/databinding/stax/StaxDataBinding.java
new file mode 100644
index 0000000..3cb836b
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/databinding/stax/StaxDataBinding.java
@@ -0,0 +1,187 @@
+/**
+ * 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.cxf.databinding.stax;
+
+import java.util.Collection;
+import java.util.logging.Logger;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.validation.Schema;
+
+import org.w3c.dom.Node;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.xmlschema.SchemaCollection;
+import org.apache.cxf.databinding.AbstractInterceptorProvidingDataBinding;
+import org.apache.cxf.databinding.DataReader;
+import org.apache.cxf.databinding.DataWriter;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.interceptor.StaxInEndingInterceptor;
+import org.apache.cxf.message.Attachment;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.service.Service;
+import org.apache.cxf.service.ServiceModelVisitor;
+import org.apache.cxf.service.model.MessagePartInfo;
+import org.apache.cxf.service.model.ServiceInfo;
+import org.apache.cxf.staxutils.StaxUtils;
+import org.apache.ws.commons.schema.constants.Constants;
+
+/**
+ * A simple databinding implementation which reads and writes Source objects.
+ * This will not work with the standard databinding interceptors.
+ */
+public class StaxDataBinding extends AbstractInterceptorProvidingDataBinding {
+
+ private XMLStreamDataReader xsrReader;
+ private XMLStreamDataWriter xswWriter;
+
+ public StaxDataBinding() {
+ super();
+ this.xsrReader = new XMLStreamDataReader();
+ this.xswWriter = new XMLStreamDataWriter();
+ inInterceptors.add(new StaxInEndingInterceptor(Phase.POST_INVOKE));
+ inFaultInterceptors.add(new StaxInEndingInterceptor(Phase.POST_INVOKE));
+
+ inInterceptors.add(RemoveStaxInEndingInterceptor.INSTANCE);
+ inFaultInterceptors.add(RemoveStaxInEndingInterceptor.INSTANCE);
+ }
+
+ static class RemoveStaxInEndingInterceptor extends AbstractPhaseInterceptor<Message> {
+ static final RemoveStaxInEndingInterceptor INSTANCE = new RemoveStaxInEndingInterceptor();
+
+ RemoveStaxInEndingInterceptor() {
+ super(Phase.PRE_INVOKE);
+ addBefore(StaxInEndingInterceptor.class.getName());
+ }
+
+ public void handleMessage(Message message) {
+ message.getInterceptorChain().remove(StaxInEndingInterceptor.INSTANCE);
+ }
+ }
+
+
+ public void initialize(Service service) {
+ for (ServiceInfo serviceInfo : service.getServiceInfos()) {
+ SchemaCollection schemaCollection = serviceInfo.getXmlSchemaCollection();
+ if (schemaCollection.getXmlSchemas().length > 1) {
+ // Schemas are already populated.
+ continue;
+ }
+ new ServiceModelVisitor(serviceInfo) {
+
+ @Override
+ public void begin(MessagePartInfo part) {
+ if (part.getTypeQName() != null || part.getElementQName() != null) {
+ return;
+ }
+ part.setTypeQName(Constants.XSD_ANYTYPE);
+ }
+ } .walk();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public <T> DataReader<T> createReader(Class<T> cls) {
+ if (cls == XMLStreamReader.class) {
+ return (DataReader<T>) xsrReader;
+ }
+ throw new UnsupportedOperationException("The type " + cls.getName() + " is not supported.");
+ }
+
+ public Class<?>[] getSupportedReaderFormats() {
+ return new Class<?>[] {XMLStreamReader.class};
+ }
+
+ @SuppressWarnings("unchecked")
+ public <T> DataWriter<T> createWriter(Class<T> cls) {
+ if (cls == XMLStreamWriter.class) {
+ return (DataWriter<T>) xswWriter;
+ }
+ throw new UnsupportedOperationException("The type " + cls.getName() + " is not supported.");
+ }
+
+ public Class<?>[] getSupportedWriterFormats() {
+ return new Class<?>[] {XMLStreamWriter.class, Node.class};
+ }
+
+ public static class XMLStreamDataReader implements DataReader<XMLStreamReader> {
+
+ public Object read(MessagePartInfo part, XMLStreamReader input) {
+ return read(null, input, part.getTypeClass());
+ }
+
+ public Object read(QName name, XMLStreamReader input, Class<?> type) {
+ return input;
+ }
+
+ public Object read(XMLStreamReader reader) {
+ return reader;
+ }
+
+ public void setSchema(Schema s) {
+ }
+
+ public void setAttachments(Collection<Attachment> attachments) {
+ }
+
+ public void setProperty(String prop, Object value) {
+ }
+ }
+
+ public static class XMLStreamDataWriter implements DataWriter<XMLStreamWriter> {
+ private static final Logger LOG = LogUtils.getL7dLogger(XMLStreamDataWriter.class);
+
+ public void write(Object obj, MessagePartInfo part, XMLStreamWriter output) {
+ write(obj, output);
+ }
+
+ public void write(Object obj, XMLStreamWriter writer) {
+ try {
+ if (obj instanceof XMLStreamReader) {
+ XMLStreamReader xmlStreamReader = (XMLStreamReader) obj;
+ StaxUtils.copy(xmlStreamReader, writer);
+ xmlStreamReader.close();
+ } else if (obj instanceof XMLStreamWriterCallback) {
+ ((XMLStreamWriterCallback) obj).write(writer);
+ } else {
+ throw new UnsupportedOperationException("Data types of "
+ + obj.getClass() + " are not supported.");
+ }
+ } catch (XMLStreamException e) {
+ throw new Fault("COULD_NOT_READ_XML_STREAM", LOG, e);
+ }
+ }
+
+ public void setSchema(Schema s) {
+ }
+
+ public void setAttachments(Collection<Attachment> attachments) {
+ }
+
+ public void setProperty(String key, Object value) {
+ }
+
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/endpoint/AbstractConduitSelector.java b/transform/src/patch/java/org/apache/cxf/endpoint/AbstractConduitSelector.java
new file mode 100644
index 0000000..250e523
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/endpoint/AbstractConduitSelector.java
@@ -0,0 +1,308 @@
+/**
+ * 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.cxf.endpoint;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.Logger;
+
+import org.apache.cxf.BusException;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.transport.Conduit;
+import org.apache.cxf.transport.ConduitInitiator;
+import org.apache.cxf.transport.ConduitInitiatorManager;
+import org.apache.cxf.transport.MessageObserver;
+import org.apache.cxf.ws.addressing.AttributedURIType;
+import org.apache.cxf.ws.addressing.EndpointReferenceType;
+
+
+/**
+ * Abstract base class holding logic common to any ConduitSelector
+ * that retrieves a Conduit from the ConduitInitiator.
+ */
+public abstract class AbstractConduitSelector implements ConduitSelector, Closeable {
+ public static final String CONDUIT_COMPARE_FULL_URL
+ = "org.apache.cxf.ConduitSelector.compareFullUrl";
+ protected static final String KEEP_CONDUIT_ALIVE = "KeepConduitAlive";
+
+
+ //collection of conduits that were created so we can close them all at the end
+ protected List<Conduit> conduits = new CopyOnWriteArrayList<>();
+
+
+ protected Endpoint endpoint;
+
+
+ public AbstractConduitSelector() {
+ }
+
+ /**
+ * Constructor, allowing a specific conduit to override normal selection.
+ *
+ * @param c specific conduit
+ */
+ public AbstractConduitSelector(Conduit c) {
+ if (c != null) {
+ conduits.add(c);
+ }
+ }
+
+ public void close() {
+ for (Conduit c : conduits) {
+ c.close();
+ }
+ conduits.clear();
+ }
+
+ protected void removeConduit(Conduit conduit) {
+ if (conduit != null) {
+ conduit.close();
+ conduits.remove(conduit);
+ }
+ }
+
+ /**
+ * Mechanics to actually get the Conduit from the ConduitInitiator
+ * if necessary.
+ *
+ * @param message the current Message
+ */
+ protected Conduit getSelectedConduit(Message message) {
+ Conduit c = findCompatibleConduit(message);
+ if (c == null) {
+ Exchange exchange = message.getExchange();
+ EndpointInfo ei = endpoint.getEndpointInfo();
+ String transportID = ei.getTransportId();
+ try {
+ ConduitInitiatorManager conduitInitiatorMgr = exchange.getBus()
+ .getExtension(ConduitInitiatorManager.class);
+ if (conduitInitiatorMgr != null) {
+ ConduitInitiator conduitInitiator =
+ conduitInitiatorMgr.getConduitInitiator(transportID);
+ if (conduitInitiator != null) {
+ c = createConduit(message, exchange, conduitInitiator);
+ } else {
+ getLogger().warning("ConduitInitiator not found: "
+ + ei.getAddress());
+ }
+ } else {
+ getLogger().warning("ConduitInitiatorManager not found");
+ }
+ } catch (BusException | IOException ex) {
+ throw new Fault(ex);
+ }
+ }
+ if (c != null && c.getTarget() != null && c.getTarget().getAddress() != null) {
+ replaceEndpointAddressPropertyIfNeeded(message, c.getTarget().getAddress().getValue(), c);
+ }
+ //the search for the conduit could cause extra properties to be reset/loaded.
+ message.resetContextCache();
+ message.put(Conduit.class, c);
+ return c;
+ }
+
+ protected Conduit createConduit(Message message, Exchange exchange, ConduitInitiator conduitInitiator)
+ throws IOException {
+ Conduit c;
+ synchronized (endpoint) {
+ if (!conduits.isEmpty()) {
+ c = findCompatibleConduit(message);
+ if (c != null) {
+ return c;
+ }
+ }
+ EndpointInfo ei = endpoint.getEndpointInfo();
+ String add = (String)message.get(Message.ENDPOINT_ADDRESS);
+ String basePath = (String)message.get(Message.BASE_PATH);
+ if (StringUtils.isEmpty(add)
+ || add.equals(ei.getAddress())) {
+ c = conduitInitiator.getConduit(ei, exchange.getBus());
+ replaceEndpointAddressPropertyIfNeeded(message, add, c);
+ } else {
+ EndpointReferenceType epr = new EndpointReferenceType();
+ AttributedURIType ad = new AttributedURIType();
+ ad.setValue(StringUtils.isEmpty(basePath) ? add : basePath);
+ epr.setAddress(ad);
+ c = conduitInitiator.getConduit(ei, epr, exchange.getBus());
+ }
+ MessageObserver observer =
+ exchange.get(MessageObserver.class);
+ if (observer != null) {
+ c.setMessageObserver(observer);
+ } else {
+ getLogger().warning("MessageObserver not found");
+ }
+ conduits.add(c);
+ }
+ return c;
+ }
+
+ // Some conduits may replace the endpoint address after it has already been prepared
+ // but before the invocation has been done (ex, org.apache.cxf.clustering.LoadDistributorTargetSelector)
+ // which may affect JAX-RS clients where actual endpoint address property may include additional path
+ // segments.
+ protected boolean replaceEndpointAddressPropertyIfNeeded(Message message,
+ String endpointAddress,
+ Conduit cond) {
+ return false;
+ }
+
+ /**
+ * @return the encapsulated Endpoint
+ */
+ public Endpoint getEndpoint() {
+ return endpoint;
+ }
+
+ /**
+ * @param ep the endpoint to encapsulate
+ */
+ public void setEndpoint(Endpoint ep) {
+ endpoint = ep;
+ }
+
+ /**
+ * Called on completion of the MEP for which the Conduit was required.
+ *
+ * @param exchange represents the completed MEP
+ */
+ public void complete(Exchange exchange) {
+ // Clients expecting explicit InputStream responses
+ // will need to keep low level conduits operating on InputStreams open
+ // and will be responsible for closing the streams
+
+ if (PropertyUtils.isTrue(exchange.get(KEEP_CONDUIT_ALIVE))) {
+ return;
+ }
+ try {
+ if (exchange.getInMessage() != null) {
+ Conduit c = exchange.getOutMessage().get(Conduit.class);
+ if (c == null) {
+ getSelectedConduit(exchange.getInMessage()).close(exchange.getInMessage());
+ } else {
+ c.close(exchange.getInMessage());
+ }
+ }
+ } catch (IOException e) {
+ //IGNORE
+ }
+ }
+ /**
+ * @return the logger to use
+ */
+ protected abstract Logger getLogger();
+
+ /**
+ * If address protocol was changed, conduit should be re-initialised
+ *
+ * @param message the current Message
+ */
+ protected Conduit findCompatibleConduit(Message message) {
+ Conduit c = message.get(Conduit.class);
+ if (c == null
+ && message.getExchange() != null
+ && message.getExchange().getOutMessage() != null
+ && message.getExchange().getOutMessage() != message) {
+ c = message.getExchange().getOutMessage().get(Conduit.class);
+ }
+ if (c != null) {
+ return c;
+ }
+ ContextualBooleanGetter cbg = new ContextualBooleanGetter(message);
+ for (Conduit c2 : conduits) {
+ if (c2.getTarget() == null
+ || c2.getTarget().getAddress() == null
+ || c2.getTarget().getAddress().getValue() == null) {
+ continue;
+ }
+ String conduitAddress = c2.getTarget().getAddress().getValue();
+
+ EndpointInfo ei = endpoint.getEndpointInfo();
+ String actualAddress = ei.getAddress();
+
+ String messageAddress = (String)message.get(Message.ENDPOINT_ADDRESS);
+ if (messageAddress != null) {
+ actualAddress = messageAddress;
+ }
+
+ if (matchAddresses(conduitAddress, actualAddress, cbg)) {
+ return c2;
+ }
+ }
+ for (Conduit c2 : conduits) {
+ if (c2.getTarget() == null
+ || c2.getTarget().getAddress() == null
+ || c2.getTarget().getAddress().getValue() == null) {
+ return c2;
+ }
+ }
+ return null;
+ }
+
+ private boolean matchAddresses(String conduitAddress, String actualAddress, ContextualBooleanGetter cbg) {
+ if (conduitAddress.length() == actualAddress.length()) {
+ //let's be optimistic and try full comparison first, regardless of CONDUIT_COMPARE_FULL_URL value,
+ //which can be expensive to fetch; as a matter of fact, anyway, if the addresses fully match,
+ //their hosts also match
+ if (conduitAddress.equalsIgnoreCase(actualAddress)) {
+ return true;
+ }
+ return !cbg.isFullComparison() && matchAddressSubstrings(conduitAddress, actualAddress);
+ }
+ return !cbg.isFullComparison() && matchAddressSubstrings(conduitAddress, actualAddress);
+ }
+
+ //smart address substring comparison that tries to avoid building and comparing substrings unless strictly required
+ private boolean matchAddressSubstrings(String conduitAddress, String actualAddress) {
+ int idx = conduitAddress.indexOf(':');
+ if (idx == actualAddress.indexOf(':')) {
+ if (idx <= 0) {
+ return true;
+ }
+ return conduitAddress.substring(0, idx).equalsIgnoreCase(actualAddress.substring(0, idx));
+ }
+ //no possible match as for sure the substrings before idx will be different
+ return false;
+ }
+
+ private static final class ContextualBooleanGetter {
+ private Boolean value;
+ private final Message message;
+
+ ContextualBooleanGetter(Message message) {
+ this.message = message;
+ }
+
+ public boolean isFullComparison() {
+ if (value == null) {
+ value = MessageUtils.getContextualBoolean(message, CONDUIT_COMPARE_FULL_URL, false);
+ }
+ return value;
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/endpoint/ClientCallback.java b/transform/src/patch/java/org/apache/cxf/endpoint/ClientCallback.java
new file mode 100644
index 0000000..467b5a8
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/endpoint/ClientCallback.java
@@ -0,0 +1,166 @@
+/**
+ * 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.cxf.endpoint;
+
+import java.util.Map;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.apache.cxf.message.Message;
+
+/**
+ * Asynchronous callback object for calls to {@link Client#invoke(ClientCallback, String, Object...)}
+ * and related functions.
+ *
+ * The default behavior of this expects the following pattern:
+ * <ol>
+ * <li>ClientCallback cb = new ClientCallback();<>
+ * <li>client.invoke(cb, "someMethod", ....);</li>
+ * <li>cb.wait();</li>
+ * <li>// CXF calls notify on the callback object when the operation is complete.</li>
+ * </ol>
+ */
+public class ClientCallback implements Future<Object[]> {
+ protected final CompletableFuture<Object[]> delegate = new CompletableFuture<>();
+ protected Map<String, Object> context;
+ protected boolean started;
+
+ public ClientCallback() {
+ }
+
+ /**
+ * Called when a message is first received prior to any actions
+ * being applied to the message. The InterceptorChain is setup so
+ * modifications to that can be done.
+ */
+ public void start(Message msg) {
+ started = true;
+ }
+
+ /**
+ * If the processing of the incoming message proceeds normally, this
+ * method is called with the response context values and the resulting objects.
+ *
+ * The default behavior just stores the objects and calls notifyAll to wake
+ * up threads waiting for the response.
+ *
+ * @param ctx
+ * @param res
+ */
+ public void handleResponse(Map<String, Object> ctx, Object[] res) {
+ context = ctx;
+ delegate.complete(res);
+
+ synchronized (this) {
+ notifyAll();
+ }
+ }
+
+ /**
+ * If processing of the incoming message results in an exception, this
+ * method is called with the resulting exception.
+ *
+ * The default behavior just stores the objects and calls notifyAll to wake
+ * up threads waiting for the response.
+ *
+ * @param ctx
+ * @param ex
+ */
+ public void handleException(Map<String, Object> ctx, Throwable ex) {
+ context = ctx;
+ delegate.completeExceptionally(ex);
+
+ synchronized (this) {
+ notifyAll();
+ }
+ }
+
+
+ public boolean cancel(boolean mayInterruptIfRunning) {
+ if (!started) {
+ delegate.cancel(mayInterruptIfRunning);
+
+ synchronized (this) {
+ notifyAll();
+ }
+
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * return the map of items returned from an operation.
+ * @return the response context
+ * @throws InterruptedException if the operation was cancelled.
+ * @throws ExecutionException if the operation resulted in a fault.
+ */
+ public Map<String, Object> getResponseContext() throws InterruptedException, ExecutionException {
+ synchronized (this) {
+ if (!delegate.isDone()) {
+ wait();
+ }
+ }
+ if (delegate.isCancelled()) {
+ throw new InterruptedException("Operation Cancelled");
+ }
+ if (delegate.isCompletedExceptionally()) {
+ delegate.get();
+ }
+ return context;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Object[] get() throws InterruptedException, ExecutionException {
+ try {
+ return delegate.get();
+ } catch (final CancellationException ex) {
+ // Preserving the exception raised by former implementation
+ throw new InterruptedException("Operation has been cancelled");
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Object[] get(long timeout, TimeUnit unit) throws InterruptedException,
+ ExecutionException, TimeoutException {
+ try {
+ return delegate.get(timeout, unit);
+ } catch (final CancellationException ex) {
+ // Preserving the exception raised by former implementation
+ throw new InterruptedException("Operation has been cancelled");
+ }
+ }
+
+ public boolean isCancelled() {
+ return delegate.isCancelled();
+ }
+
+ public boolean isDone() {
+ return delegate.isDone();
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/endpoint/ClientImpl.java b/transform/src/patch/java/org/apache/cxf/endpoint/ClientImpl.java
new file mode 100644
index 0000000..53d3a43
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/endpoint/ClientImpl.java
@@ -0,0 +1,1192 @@
+/**
+ * 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.cxf.endpoint;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.Serializable;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.namespace.QName;
+import javax.xml.ws.handler.MessageContext;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.binding.Binding;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.classloader.ClassLoaderUtils.ClassLoaderHolder;
+import org.apache.cxf.common.i18n.UncheckedException;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.interceptor.AbstractBasicInterceptorProvider;
+import org.apache.cxf.interceptor.ClientOutFaultObserver;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.interceptor.Interceptor;
+import org.apache.cxf.interceptor.InterceptorChain;
+import org.apache.cxf.interceptor.InterceptorProvider;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.ExchangeImpl;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageContentsList;
+import org.apache.cxf.message.MessageImpl;
+import org.apache.cxf.phase.PhaseChainCache;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+import org.apache.cxf.phase.PhaseManager;
+import org.apache.cxf.service.Service;
+import org.apache.cxf.service.model.BindingInfo;
+import org.apache.cxf.service.model.BindingMessageInfo;
+import org.apache.cxf.service.model.BindingOperationInfo;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.service.model.MessageInfo;
+import org.apache.cxf.service.model.ServiceInfo;
+import org.apache.cxf.transport.Conduit;
+import org.apache.cxf.transport.MessageObserver;
+import org.apache.cxf.workqueue.SynchronousExecutor;
+
+public class ClientImpl
+ extends AbstractBasicInterceptorProvider
+ implements Client, Retryable, MessageObserver {
+
+ public static final String THREAD_LOCAL_REQUEST_CONTEXT = "thread.local.request.context";
+ /**
+ * When a synchronous request/response invoke is done using an asynchronous transport mechanism,
+ * this is the timeout used for waiting for the response. Default is 60 seconds.
+ */
+ public static final String SYNC_TIMEOUT = "cxf.synchronous.timeout";
+
+ public static final String FINISHED = "exchange.finished";
+
+ private static final Logger LOG = LogUtils.getL7dLogger(ClientImpl.class);
+
+ protected Bus bus;
+ protected ConduitSelector conduitSelector;
+ protected ClientOutFaultObserver outFaultObserver;
+ protected int synchronousTimeout = 60000; // default 60 second timeout
+
+ protected PhaseChainCache outboundChainCache = new PhaseChainCache();
+ protected PhaseChainCache inboundChainCache = new PhaseChainCache();
+
+ protected Map<String, Object> currentRequestContext = new ConcurrentHashMap<>(8, 0.75f, 4);
+ protected Thread latestContextThread;
+ protected Map<Thread, EchoContext> requestContext
+ = Collections.synchronizedMap(new WeakHashMap<Thread, EchoContext>());
+
+ protected Map<Thread, ResponseContext> responseContext
+ = Collections.synchronizedMap(new WeakHashMap<Thread, ResponseContext>());
+
+ protected Executor executor;
+
+ public ClientImpl(Bus b, Endpoint e) {
+ this(b, e, (ConduitSelector)null);
+ }
+
+ public ClientImpl(Bus b, Endpoint e, Conduit c) {
+ this(b, e, new PreexistingConduitSelector(c));
+ }
+
+ public ClientImpl(Bus b, Endpoint e, ConduitSelector sc) {
+ bus = b;
+ outFaultObserver = new ClientOutFaultObserver(bus);
+ getConduitSelector(sc).setEndpoint(e);
+ notifyLifecycleManager();
+ }
+
+ /**
+ * Create a Client that uses a specific EndpointImpl.
+ * @param bus
+ * @param svc
+ * @param port
+ * @param endpointImplFactory
+ */
+ public ClientImpl(Bus bus, Service svc, QName port,
+ EndpointImplFactory endpointImplFactory) {
+ this.bus = bus;
+ outFaultObserver = new ClientOutFaultObserver(bus);
+ EndpointInfo epfo = findEndpoint(svc, port);
+
+ try {
+ if (endpointImplFactory != null) {
+ getConduitSelector().setEndpoint(endpointImplFactory.newEndpointImpl(bus, svc, epfo));
+ } else {
+ getConduitSelector().setEndpoint(new EndpointImpl(bus, svc, epfo));
+ }
+ } catch (EndpointException epex) {
+ throw new IllegalStateException("Unable to create endpoint: " + epex.getMessage(), epex);
+ }
+ notifyLifecycleManager();
+ }
+
+ public Bus getBus() {
+ return bus;
+ }
+
+ public void destroy() {
+ if (bus == null) {
+ return;
+ }
+ if (getEndpoint() != null) {
+ for (Closeable c : getEndpoint().getCleanupHooks()) {
+ try {
+ c.close();
+ } catch (IOException e) {
+ //ignore
+ }
+ }
+ }
+ ClientLifeCycleManager mgr = bus.getExtension(ClientLifeCycleManager.class);
+ if (null != mgr) {
+ mgr.clientDestroyed(this);
+ }
+
+ if (conduitSelector != null) {
+ if (conduitSelector instanceof Closeable) {
+ try {
+ ((Closeable)conduitSelector).close();
+ } catch (IOException e) {
+ //ignore, we're destroying anyway
+ }
+ } else {
+ getConduit().close();
+ }
+ }
+
+ bus = null;
+ conduitSelector = null;
+ outFaultObserver = null;
+ outboundChainCache = null;
+ inboundChainCache = null;
+
+ currentRequestContext = null;
+ requestContext.clear();
+ requestContext = null;
+ responseContext.clear();
+ responseContext = null;
+ executor = null;
+ }
+
+ private void notifyLifecycleManager() {
+ ClientLifeCycleManager mgr = bus.getExtension(ClientLifeCycleManager.class);
+ if (null != mgr) {
+ mgr.clientCreated(this);
+ }
+ }
+
+ private EndpointInfo findEndpoint(Service svc, QName port) {
+ if (port != null) {
+ EndpointInfo epfo = svc.getEndpointInfo(port);
+ if (epfo == null) {
+ throw new IllegalArgumentException("The service " + svc.getName()
+ + " does not have an endpoint " + port + ".");
+ }
+ return epfo;
+ }
+
+ for (ServiceInfo svcfo : svc.getServiceInfos()) {
+ for (EndpointInfo e : svcfo.getEndpoints()) {
+ BindingInfo bfo = e.getBinding();
+ String bid = bfo.getBindingId();
+ if ("http://schemas.xmlsoap.org/wsdl/soap/".equals(bid)
+ || "http://schemas.xmlsoap.org/wsdl/soap12/".equals(bid)) {
+ for (Object o : bfo.getExtensors().get()) {
+ try {
+ String s = (String)o.getClass().getMethod("getTransportURI").invoke(o);
+ if (s != null && s.endsWith("http")) {
+ return e;
+ }
+ } catch (Throwable t) {
+ //ignore
+ }
+ }
+ }
+ }
+ }
+ throw new UnsupportedOperationException(
+ "Only document-style SOAP 1.1 and 1.2 http are supported "
+ + "for auto-selection of endpoint; none were found.");
+ }
+
+ public Endpoint getEndpoint() {
+ return getConduitSelector().getEndpoint();
+ }
+
+ public void releaseThreadContexts() {
+ final Thread t = Thread.currentThread();
+ requestContext.remove(t);
+ responseContext.remove(t);
+ }
+
+ @Override
+ public Contexts getContexts() {
+ return new Contexts() {
+ @Override
+ public void close() throws Exception {
+ releaseThreadContexts();
+ }
+ @Override
+ public Map<String, Object> getRequestContext() {
+ return ClientImpl.this.getRequestContext();
+ }
+ @Override
+ public Map<String, Object> getResponseContext() {
+ return ClientImpl.this.getResponseContext();
+ }
+ };
+ }
+
+ public Map<String, Object> getRequestContext() {
+ if (isThreadLocalRequestContext()) {
+ final Thread t = Thread.currentThread();
+ requestContext.computeIfAbsent(t, k -> new EchoContext(currentRequestContext));
+ latestContextThread = t;
+ return requestContext.get(t);
+ }
+ return currentRequestContext;
+ }
+ public Map<String, Object> getResponseContext() {
+ if (!responseContext.containsKey(Thread.currentThread())) {
+ final Thread t = Thread.currentThread();
+ responseContext.put(t, new ResponseContext(responseContext));
+ }
+ return responseContext.get(Thread.currentThread());
+ }
+ protected Map<String, Object> setResponseContext(Map<String, Object> ctx) {
+ if (ctx instanceof ResponseContext) {
+ ResponseContext c = (ResponseContext)ctx;
+ responseContext.put(Thread.currentThread(), c);
+ return c;
+ }
+ ResponseContext c = new ResponseContext(ctx, responseContext);
+ responseContext.put(Thread.currentThread(), c);
+ return c;
+ }
+ public boolean isThreadLocalRequestContext() {
+ Object o = currentRequestContext.get(THREAD_LOCAL_REQUEST_CONTEXT);
+ if (o != null) {
+ final boolean local;
+ if (o instanceof Boolean) {
+ local = ((Boolean)o).booleanValue();
+ } else {
+ local = Boolean.parseBoolean(o.toString());
+ }
+ return local;
+ }
+ return false;
+ }
+ public void setThreadLocalRequestContext(boolean b) {
+ currentRequestContext.put(THREAD_LOCAL_REQUEST_CONTEXT, b);
+ }
+
+
+ public Object[] invoke(BindingOperationInfo oi, Object... params) throws Exception {
+ return invoke(oi, params, null);
+ }
+
+ public Object[] invoke(String operationName, Object... params) throws Exception {
+ QName q = new QName(getEndpoint().getService().getName().getNamespaceURI(), operationName);
+
+ return invoke(q, params);
+ }
+
+ public Object[] invoke(QName operationName, Object... params) throws Exception {
+ BindingOperationInfo op = getEndpoint().getEndpointInfo().getBinding().getOperation(operationName);
+ if (op == null) {
+ throw new UncheckedException(
+ new org.apache.cxf.common.i18n.Message("NO_OPERATION", LOG, operationName));
+ }
+
+ if (op.isUnwrappedCapable()) {
+ op = op.getUnwrappedOperation();
+ }
+
+ return invoke(op, params);
+ }
+
+ public Object[] invokeWrapped(String operationName, Object... params) throws Exception {
+ QName q = new QName(getEndpoint().getService().getName().getNamespaceURI(), operationName);
+
+ return invokeWrapped(q, params);
+ }
+
+ public Object[] invokeWrapped(QName operationName, Object... params) throws Exception {
+ BindingOperationInfo op = getEndpoint().getEndpointInfo().getBinding().getOperation(operationName);
+ if (op == null) {
+ throw new UncheckedException(
+ new org.apache.cxf.common.i18n.Message("NO_OPERATION", LOG, operationName));
+ }
+ return invoke(op, params);
+ }
+
+ public Object[] invoke(BindingOperationInfo oi,
+ Object[] params,
+ Exchange exchange) throws Exception {
+ Map<String, Object> context = new HashMap<>();
+ return invoke(oi, params, context, exchange);
+ }
+ public Object[] invoke(BindingOperationInfo oi,
+ Object[] params,
+ Map<String, Object> context) throws Exception {
+ return invoke(oi, params, context, (Exchange)null);
+ }
+
+ public void invoke(ClientCallback callback,
+ String operationName,
+ Object... params) throws Exception {
+ QName q = new QName(getEndpoint().getService().getName().getNamespaceURI(), operationName);
+ invoke(callback, q, params);
+ }
+
+ public void invoke(ClientCallback callback,
+ QName operationName,
+ Object... params) throws Exception {
+ BindingOperationInfo op = getEndpoint().getEndpointInfo().getBinding().getOperation(operationName);
+ if (op == null) {
+ throw new UncheckedException(
+ new org.apache.cxf.common.i18n.Message("NO_OPERATION", LOG, operationName));
+ }
+
+ if (op.isUnwrappedCapable()) {
+ op = op.getUnwrappedOperation();
+ }
+
+ invoke(callback, op, params);
+ }
+
+
+ public void invokeWrapped(ClientCallback callback,
+ String operationName,
+ Object... params)
+ throws Exception {
+ QName q = new QName(getEndpoint().getService().getName().getNamespaceURI(), operationName);
+ invokeWrapped(callback, q, params);
+ }
+
+ public void invokeWrapped(ClientCallback callback,
+ QName operationName,
+ Object... params)
+ throws Exception {
+ BindingOperationInfo op = getEndpoint().getEndpointInfo().getBinding().getOperation(operationName);
+ if (op == null) {
+ throw new UncheckedException(
+ new org.apache.cxf.common.i18n.Message("NO_OPERATION", LOG, operationName));
+ }
+ invoke(callback, op, params);
+ }
+
+
+ public void invoke(ClientCallback callback,
+ BindingOperationInfo oi,
+ Object... params) throws Exception {
+ invoke(callback, oi, params, null, null);
+ }
+
+ public void invoke(ClientCallback callback,
+ BindingOperationInfo oi,
+ Object[] params,
+ Map<String, Object> context) throws Exception {
+ invoke(callback, oi, params, context, null);
+ }
+
+ public void invoke(ClientCallback callback,
+ BindingOperationInfo oi,
+ Object[] params,
+ Exchange exchange) throws Exception {
+ invoke(callback, oi, params, null, exchange);
+ }
+
+ public void invoke(ClientCallback callback,
+ BindingOperationInfo oi,
+ Object[] params,
+ Map<String, Object> context,
+ Exchange exchange) throws Exception {
+ doInvoke(callback, oi, params, context, exchange);
+ }
+
+ public Object[] invoke(BindingOperationInfo oi,
+ Object[] params,
+ Map<String, Object> context,
+ Exchange exchange) throws Exception {
+ return doInvoke(null, oi, params, context, exchange);
+ }
+
+ private Object[] doInvoke(final ClientCallback callback,
+ BindingOperationInfo oi,
+ Object[] params,
+ Map<String, Object> context,
+ Exchange exchange) throws Exception {
+ Bus origBus = BusFactory.getAndSetThreadDefaultBus(bus);
+ ClassLoaderHolder origLoader = null;
+ Map<String, Object> resContext = null;
+ try {
+ ClassLoader loader = bus.getExtension(ClassLoader.class);
+ if (loader != null) {
+ origLoader = ClassLoaderUtils.setThreadContextClassloader(loader);
+ }
+ if (exchange == null) {
+ exchange = new ExchangeImpl();
+ }
+ exchange.setSynchronous(callback == null);
+ Endpoint endpoint = getEndpoint();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Invoke, operation info: " + oi + ", params: " + Arrays.toString(params));
+ }
+ Message message = endpoint.getBinding().createMessage();
+
+ // Make sure INVOCATION CONTEXT, REQUEST_CONTEXT and RESPONSE_CONTEXT are present
+ // on message
+ if (context == null) {
+ context = new HashMap<>();
+ }
+ Map<String, Object> reqContext = CastUtils.cast((Map<?, ?>)context.get(REQUEST_CONTEXT));
+ resContext = CastUtils.cast((Map<?, ?>)context.get(RESPONSE_CONTEXT));
+ if (reqContext == null) {
+ reqContext = new HashMap<>(getRequestContext());
+ context.put(REQUEST_CONTEXT, reqContext);
+ }
+ if (resContext == null) {
+ resContext = new ResponseContext(responseContext);
+ context.put(RESPONSE_CONTEXT, resContext);
+ }
+
+ message.put(Message.INVOCATION_CONTEXT, context);
+ setContext(reqContext, message);
+ exchange.putAll(reqContext);
+
+ setParameters(params, message);
+
+ if (null != oi) {
+ exchange.setOneWay(oi.getOutput() == null);
+ }
+
+ exchange.setOutMessage(message);
+ exchange.put(ClientCallback.class, callback);
+
+ setOutMessageProperties(message, oi);
+ setExchangeProperties(exchange, endpoint, oi);
+
+ PhaseInterceptorChain chain = setupInterceptorChain(endpoint);
+ message.setInterceptorChain(chain);
+ if (callback == null) {
+ chain.setFaultObserver(outFaultObserver);
+ } else {
+ // We need to wrap the outFaultObserver if the callback is not null
+ // calling the conduitSelector.complete to make sure the fail over feature works
+ chain.setFaultObserver(new MessageObserver() {
+ public void onMessage(Message message) {
+ Exception ex = message.getContent(Exception.class);
+ if (ex != null) {
+ completeExchange(message.getExchange());
+ if (message.getContent(Exception.class) == null) {
+ // handle the right response
+ Message inMsg = message.getExchange().getInMessage();
+ Map<String, Object> ctx = responseContext.get(Thread.currentThread());
+ List<Object> resList = CastUtils.cast(inMsg.getContent(List.class));
+ Object[] result = resList == null ? null : resList.toArray();
+ callback.handleResponse(ctx, result);
+ return;
+ }
+ }
+ outFaultObserver.onMessage(message);
+ }
+ });
+ }
+ prepareConduitSelector(message);
+
+ // add additional interceptors and such
+ modifyChain(chain, message, false);
+ try {
+ chain.doIntercept(message);
+ } catch (Fault fault) {
+ enrichFault(fault);
+ throw fault;
+ }
+
+ if (callback != null) {
+ return null;
+ }
+ return processResult(message, exchange, oi, resContext);
+ } finally {
+ //ensure ResponseContext has HTTP RESPONSE CODE
+ if (null != exchange) {
+ Integer responseCode = (Integer)exchange.get(Message.RESPONSE_CODE);
+ resContext.put(MessageContext.HTTP_RESPONSE_CODE, responseCode);
+ resContext.put(org.apache.cxf.message.Message.RESPONSE_CODE, responseCode);
+ setResponseContext(resContext);
+ }
+ if (origLoader != null) {
+ origLoader.reset();
+ }
+ if (origBus != bus) {
+ BusFactory.setThreadDefaultBus(origBus);
+ }
+ }
+ }
+
+ private void completeExchange(Exchange exchange) {
+ getConduitSelector().complete(exchange);
+ }
+
+ /**
+ * TODO This is SOAP specific code and should not be in cxf core
+ * @param fault
+ */
+ private void enrichFault(Fault fault) {
+ if (fault.getCause().getCause() instanceof IOException
+ || fault.getCause() instanceof IOException) {
+ String soap11NS = "http://schemas.xmlsoap.org/soap/envelope/";
+ String soap12NS = "http://www.w3.org/2003/05/soap-envelope";
+ QName faultCode = fault.getFaultCode();
+ //for SoapFault, if it's underlying cause is IOException,
+ //it means something like server is down or can't create
+ //connection, according to soap spec we should set fault as
+ //Server Fault
+ if (faultCode.getNamespaceURI().equals(
+ soap11NS)
+ && "Client".equals(faultCode.getLocalPart())) {
+ faultCode = new QName(soap11NS, "Server");
+ fault.setFaultCode(faultCode);
+ }
+ if (faultCode.getNamespaceURI().equals(
+ soap12NS)
+ && "Sender".equals(faultCode.getLocalPart())) {
+ faultCode = new QName(soap12NS, "Receiver");
+ fault.setFaultCode(faultCode);
+ }
+ }
+ }
+
+ protected Object[] processResult(Message message,
+ Exchange exchange,
+ BindingOperationInfo oi,
+ Map<String, Object> resContext) throws Exception {
+ Exception ex = null;
+ // Check to see if there is a Fault from the outgoing chain if it's an out Message
+ if (!message.get(Message.INBOUND_MESSAGE).equals(Boolean.TRUE)) {
+ ex = message.getContent(Exception.class);
+ }
+ boolean mepCompleteCalled = false;
+ if (ex != null) {
+ completeExchange(exchange);
+ mepCompleteCalled = true;
+ if (message.getContent(Exception.class) != null) {
+ throw ex;
+ }
+ }
+ ex = message.getExchange().get(Exception.class);
+ if (ex != null) {
+ if (!mepCompleteCalled) {
+ completeExchange(exchange);
+ }
+ throw ex;
+ }
+
+ //REVISIT
+ // - use a protocol neutral no-content marker instead of 202?
+ // - move the decoupled destination property name into api
+ Integer responseCode = (Integer)exchange.get(Message.RESPONSE_CODE);
+ if (null != responseCode && 202 == responseCode) {
+ Endpoint ep = exchange.getEndpoint();
+ if (null != ep && null != ep.getEndpointInfo() && null == ep.getEndpointInfo().
+ getProperty("org.apache.cxf.ws.addressing.MAPAggregator.decoupledDestination")) {
+ return null;
+ }
+ }
+
+ // Wait for a response if we need to
+ if (oi != null && !oi.getOperationInfo().isOneWay()) {
+ waitResponse(exchange);
+ }
+
+ // leave the input stream open for the caller
+ Boolean keepConduitAlive = (Boolean)exchange.get(Client.KEEP_CONDUIT_ALIVE);
+ if (keepConduitAlive == null || !keepConduitAlive) {
+ completeExchange(exchange);
+ }
+
+ // Grab the response objects if there are any
+ List<Object> resList = null;
+ Message inMsg = exchange.getInMessage();
+ if (inMsg != null) {
+ if (null != resContext) {
+ resContext.putAll(inMsg);
+ // remove the recursive reference if present
+ resContext.remove(Message.INVOCATION_CONTEXT);
+ setResponseContext(resContext);
+ }
+ resList = CastUtils.cast(inMsg.getContent(List.class));
+ }
+
+ // check for an incoming fault
+ ex = getException(exchange);
+
+ if (ex != null) {
+ throw ex;
+ }
+
+ if (resList == null
+ && oi != null && !oi.getOperationInfo().isOneWay()) {
+
+ BindingOperationInfo boi = oi;
+ if (boi.isUnwrapped()) {
+ boi = boi.getWrappedOperation();
+ }
+ if (!boi.getOutput().getMessageParts().isEmpty()) {
+ //we were supposed to get some output, but didn't.
+ throw new IllegalEmptyResponseException("Response message did not contain proper response data."
+ + " Expected: " + boi.getOutput().getMessageParts().get(0).getConcreteName());
+ }
+ }
+ if (resList != null) {
+ return resList.toArray();
+ }
+
+ return null;
+ }
+ protected Exception getException(Exchange exchange) {
+ if (exchange.getInFaultMessage() != null) {
+ return exchange.getInFaultMessage().getContent(Exception.class);
+ } else if (exchange.getOutFaultMessage() != null) {
+ return exchange.getOutFaultMessage().getContent(Exception.class);
+ } else if (exchange.getInMessage() != null) {
+ return exchange.getInMessage().getContent(Exception.class);
+ }
+ return null;
+ }
+
+ protected void setContext(Map<String, Object> ctx, Message message) {
+ if (ctx != null) {
+ message.putAll(ctx);
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("set requestContext to message be" + ctx);
+ }
+ }
+ }
+
+ protected void waitResponse(Exchange exchange) throws IOException {
+ synchronized (exchange) {
+ long remaining = synchronousTimeout;
+ Long o = PropertyUtils.getLong(exchange.getOutMessage(), SYNC_TIMEOUT);
+ if (o != null) {
+ remaining = o;
+ }
+ while (!Boolean.TRUE.equals(exchange.get(FINISHED)) && remaining > 0) {
+ long start = System.currentTimeMillis();
+ try {
+ exchange.wait(remaining);
+ } catch (InterruptedException ex) {
+ // ignore
+ }
+ long end = System.currentTimeMillis();
+ remaining -= (int)(end - start);
+ }
+ if (!Boolean.TRUE.equals(exchange.get(FINISHED))) {
+ LogUtils.log(LOG, Level.WARNING, "RESPONSE_TIMEOUT",
+ exchange.getBindingOperationInfo().getOperationInfo().getName().toString());
+ String msg = new org.apache.cxf.common.i18n.Message("RESPONSE_TIMEOUT", LOG, exchange
+ .getBindingOperationInfo().getOperationInfo().getName().toString()).toString();
+ throw new IOException(msg);
+ }
+ }
+ }
+
+ protected void setParameters(Object[] params, Message message) {
+ MessageContentsList contents = new MessageContentsList(params);
+ message.setContent(List.class, contents);
+ }
+
+ public void onMessage(Message message) {
+ if (bus == null) {
+ throw new IllegalStateException("Message received on a Client that has been closed or destroyed.");
+ }
+ Endpoint endpoint = message.getExchange().getEndpoint();
+ if (endpoint == null) {
+ // in this case correlation will occur outside the transport,
+ // however there's a possibility that the endpoint may have been
+ // rebased in the meantime, so that the response will be mediated
+ // via a set of in interceptors provided by a *different* endpoint
+ //
+ endpoint = getConduitSelector().getEndpoint();
+ message.getExchange().put(Endpoint.class, endpoint);
+ }
+ message = endpoint.getBinding().createMessage(message);
+ message.getExchange().setInMessage(message);
+ message.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
+ message.put(Message.INBOUND_MESSAGE, Boolean.TRUE);
+ PhaseManager pm = bus.getExtension(PhaseManager.class);
+
+ List<Interceptor<? extends Message>> i1 = bus.getInInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by bus: " + i1);
+ }
+ List<Interceptor<? extends Message>> i2 = getInInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by client: " + i2);
+ }
+ List<Interceptor<? extends Message>> i3 = endpoint.getInInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by endpoint: " + i3);
+ }
+ List<Interceptor<? extends Message>> i4 = endpoint.getBinding().getInInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by binding: " + i4);
+ }
+
+ PhaseInterceptorChain chain;
+ if (endpoint.getService().getDataBinding() instanceof InterceptorProvider) {
+ InterceptorProvider p = (InterceptorProvider)endpoint.getService().getDataBinding();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by databinding: " + p.getInInterceptors());
+ }
+ chain = inboundChainCache.get(pm.getInPhases(), i1, i2, i3, i4,
+ p.getInInterceptors());
+ } else {
+ chain = inboundChainCache.get(pm.getInPhases(), i1, i2, i3, i4);
+ }
+ message.setInterceptorChain(chain);
+
+ chain.setFaultObserver(outFaultObserver);
+ modifyChain(chain, message, true);
+ modifyChain(chain, message.getExchange().getOutMessage(), true);
+
+ Bus origBus = BusFactory.getAndSetThreadDefaultBus(bus);
+ // execute chain
+ ClientCallback callback = message.getExchange().get(ClientCallback.class);
+ try {
+ if (callback != null) {
+ if (callback.isCancelled()) {
+ completeExchange(message.getExchange());
+ return;
+ }
+ callback.start(message);
+ }
+
+ String startingAfterInterceptorID = (String) message.get(
+ InterceptorChain.STARTING_AFTER_INTERCEPTOR_ID);
+ String startingInterceptorID = (String) message.get(
+ InterceptorChain.STARTING_AT_INTERCEPTOR_ID);
+ if (startingAfterInterceptorID != null) {
+ chain.doInterceptStartingAfter(message, startingAfterInterceptorID);
+ } else if (startingInterceptorID != null) {
+ chain.doInterceptStartingAt(message, startingInterceptorID);
+ } else if (message.getContent(Exception.class) != null) {
+ outFaultObserver.onMessage(message);
+ } else {
+ callback = message.getExchange().get(ClientCallback.class);
+
+ if (callback != null && !isPartialResponse(message)) {
+ try {
+ chain.doIntercept(message);
+ } catch (Throwable error) {
+ //so that asyn callback handler get chance to
+ //handle non-runtime exceptions
+ message.getExchange().setInMessage(message);
+ Map<String, Object> resCtx = CastUtils
+ .cast((Map<?, ?>) message.getExchange()
+ .getOutMessage().get(
+ Message.INVOCATION_CONTEXT));
+ resCtx = CastUtils.cast((Map<?, ?>) resCtx
+ .get(RESPONSE_CONTEXT));
+ if (resCtx != null) {
+ setResponseContext(resCtx);
+ }
+ // remove callback so that it won't be invoked twice
+ callback = message.getExchange().remove(ClientCallback.class);
+ if (callback != null) {
+ callback.handleException(resCtx, error);
+ }
+ }
+ } else {
+ chain.doIntercept(message);
+ }
+
+ }
+
+ callback = message.getExchange().get(ClientCallback.class);
+ if (callback == null || isPartialResponse(message)) {
+ return;
+ }
+
+ // remove callback so that it won't be invoked twice
+ callback = message.getExchange().remove(ClientCallback.class);
+ if (callback != null) {
+ message.getExchange().setInMessage(message);
+ Map<String, Object> resCtx = CastUtils.cast((Map<?, ?>)message
+ .getExchange()
+ .getOutMessage()
+ .get(Message.INVOCATION_CONTEXT));
+ resCtx = CastUtils.cast((Map<?, ?>)resCtx.get(RESPONSE_CONTEXT));
+ if (resCtx != null && responseContext != null) {
+ setResponseContext(resCtx);
+ }
+ try {
+ Object[] obj = processResult(message, message.getExchange(),
+ null, resCtx);
+
+ callback.handleResponse(resCtx, obj);
+ } catch (Throwable ex) {
+ callback.handleException(resCtx, ex);
+ }
+ }
+ } finally {
+ if (origBus != bus) {
+ BusFactory.setThreadDefaultBus(origBus);
+ }
+ synchronized (message.getExchange()) {
+ if (!isPartialResponse(message)
+ || message.getContent(Exception.class) != null) {
+ message.getExchange().put(FINISHED, Boolean.TRUE);
+ message.getExchange().setInMessage(message);
+ message.getExchange().notifyAll();
+ }
+ }
+ }
+ }
+
+ public Conduit getConduit() {
+ Message message = new MessageImpl();
+ Exchange exchange = new ExchangeImpl();
+ message.setExchange(exchange);
+ message.putAll(getRequestContext());
+ setExchangeProperties(exchange, getEndpoint(), null);
+ return getConduitSelector().selectConduit(message);
+ }
+
+ protected void prepareConduitSelector(Message message) {
+ getConduitSelector().prepare(message);
+ message.getExchange().put(ConduitSelector.class, getConduitSelector());
+ }
+
+ protected void setOutMessageProperties(Message message, BindingOperationInfo boi) {
+ message.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
+ message.put(Message.INBOUND_MESSAGE, Boolean.FALSE);
+ if (null != boi) {
+ message.put(BindingMessageInfo.class, boi.getInput());
+ message.put(MessageInfo.class, boi.getOperationInfo().getInput());
+ }
+ }
+
+ protected void setExchangeProperties(Exchange exchange,
+ Endpoint endpoint,
+ BindingOperationInfo boi) {
+ if (endpoint != null) {
+ exchange.put(Endpoint.class, endpoint);
+ exchange.put(Service.class, endpoint.getService());
+ exchange.put(Binding.class, endpoint.getBinding());
+ }
+ if (boi != null) {
+ exchange.put(BindingOperationInfo.class, boi);
+ }
+
+ if (exchange.isSynchronous() || executor == null) {
+ exchange.put(MessageObserver.class, this);
+ } else {
+ exchange.put(Executor.class, executor);
+ exchange.put(MessageObserver.class, new MessageObserver() {
+ public void onMessage(final Message message) {
+ if (!message.getExchange()
+ .containsKey(Executor.class.getName() + ".USING_SPECIFIED")) {
+
+ executor.execute(new Runnable() {
+ public void run() {
+ ClientImpl.this.onMessage(message);
+ }
+ });
+ } else {
+ ClientImpl.this.onMessage(message);
+ }
+ }
+ });
+ }
+ exchange.put(Retryable.class, this);
+ exchange.put(Client.class, this);
+ exchange.put(Bus.class, bus);
+
+ if (endpoint != null) {
+ EndpointInfo endpointInfo = endpoint.getEndpointInfo();
+ if (boi != null) {
+ exchange.put(Message.WSDL_OPERATION, boi.getName());
+ }
+
+ QName serviceQName = endpointInfo.getService().getName();
+ exchange.put(Message.WSDL_SERVICE, serviceQName);
+
+ QName interfaceQName = endpointInfo.getService().getInterface().getName();
+ exchange.put(Message.WSDL_INTERFACE, interfaceQName);
+
+ QName portQName = endpointInfo.getName();
+ exchange.put(Message.WSDL_PORT, portQName);
+ URI wsdlDescription = endpointInfo.getProperty("URI", URI.class);
+ if (wsdlDescription == null) {
+ String address = endpointInfo.getAddress();
+ try {
+ wsdlDescription = new URI(address + "?wsdl");
+ } catch (URISyntaxException e) {
+ // do nothing
+ }
+ endpointInfo.setProperty("URI", wsdlDescription);
+ }
+ exchange.put(Message.WSDL_DESCRIPTION, wsdlDescription);
+ }
+ }
+
+ protected PhaseInterceptorChain setupInterceptorChain(Endpoint endpoint) {
+
+ PhaseManager pm = bus.getExtension(PhaseManager.class);
+
+ List<Interceptor<? extends Message>> i1 = bus.getOutInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by bus: " + i1);
+ }
+ List<Interceptor<? extends Message>> i2 = getOutInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by client: " + i2);
+ }
+ List<Interceptor<? extends Message>> i3 = endpoint.getOutInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by endpoint: " + i3);
+ }
+ List<Interceptor<? extends Message>> i4 = endpoint.getBinding().getOutInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by binding: " + i4);
+ }
+ List<Interceptor<? extends Message>> i5 = null;
+ if (endpoint.getService().getDataBinding() instanceof InterceptorProvider) {
+ i5 = ((InterceptorProvider)endpoint.getService().getDataBinding()).getOutInterceptors();
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Interceptors contributed by databinding: " + i5);
+ }
+ }
+ if (i5 != null) {
+ return outboundChainCache.get(pm.getOutPhases(), i1, i2, i3, i4, i5);
+ }
+ return outboundChainCache.get(pm.getOutPhases(), i1, i2, i3, i4);
+ }
+
+ protected void modifyChain(InterceptorChain chain, Message ctx, boolean in) {
+ if (ctx == null) {
+ return;
+ }
+ Collection<InterceptorProvider> providers
+ = CastUtils.cast((Collection<?>)ctx.get(Message.INTERCEPTOR_PROVIDERS));
+ if (providers != null) {
+ for (InterceptorProvider p : providers) {
+ if (in) {
+ chain.add(p.getInInterceptors());
+ } else {
+ chain.add(p.getOutInterceptors());
+ }
+ }
+ }
+ String key = in ? Message.IN_INTERCEPTORS : Message.OUT_INTERCEPTORS;
+ Collection<Interceptor<? extends Message>> is
+ = CastUtils.cast((Collection<?>)ctx.get(key));
+ if (is != null) {
+ chain.add(is);
+ }
+ }
+
+ protected void setEndpoint(Endpoint e) {
+ getConduitSelector().setEndpoint(e);
+ }
+
+ public int getSynchronousTimeout() {
+ return synchronousTimeout;
+ }
+
+ public void setSynchronousTimeout(int synchronousTimeout) {
+ this.synchronousTimeout = synchronousTimeout;
+ }
+
+ public final ConduitSelector getConduitSelector() {
+ return getConduitSelector(null);
+ }
+
+ protected final ConduitSelector getConduitSelector(
+ ConduitSelector override
+ ) {
+ if (null == conduitSelector) {
+ setConduitSelector(override);
+ }
+ return conduitSelector;
+ }
+
+ public final synchronized void setConduitSelector(ConduitSelector selector) {
+ conduitSelector = selector == null ? new UpfrontConduitSelector() : selector;
+ }
+
+ private boolean isPartialResponse(Message in) {
+ return Boolean.TRUE.equals(in.get(Message.PARTIAL_RESPONSE_MESSAGE));
+ }
+
+ @Override
+ public void close() throws Exception {
+ destroy();
+ }
+
+
+ public class EchoContext extends ConcurrentHashMap<String, Object> {
+ private static final long serialVersionUID = 1L;
+ public EchoContext(Map<String, Object> sharedMap) {
+ super(8, 0.75f, 4);
+ putAll(sharedMap);
+ }
+
+ public void reload() {
+ super.clear();
+ super.putAll(requestContext.get(latestContextThread));
+ }
+
+ @Override
+ public void clear() {
+ super.clear();
+ try {
+ for (Map.Entry<Thread, EchoContext> ent : requestContext.entrySet()) {
+ if (ent.getValue() == this) {
+ requestContext.remove(ent.getKey());
+ return;
+ }
+ }
+ } catch (Throwable t) {
+ //ignore
+ }
+ }
+ }
+
+ /**
+ * Class to handle the response contexts. The clear is overloaded to remove
+ * this context from the threadLocal caches in the ClientImpl
+ */
+ static class ResponseContext implements Map<String, Object>, Serializable {
+ private static final long serialVersionUID = 2L;
+ final Map<String, Object> wrapped;
+ final Map<Thread, ResponseContext> responseContext;
+
+ ResponseContext(Map<String, Object> origMap, Map<Thread, ResponseContext> rc) {
+ wrapped = origMap;
+ responseContext = rc;
+ }
+
+ ResponseContext(Map<Thread, ResponseContext> rc) {
+ wrapped = new HashMap<>();
+ responseContext = rc;
+ }
+
+ @Override
+ public void clear() {
+ wrapped.clear();
+ try {
+ for (Map.Entry<Thread, ResponseContext> ent : responseContext.entrySet()) {
+ if (ent.getValue() == this) {
+ responseContext.remove(ent.getKey());
+ return;
+ }
+ }
+ } catch (Throwable t) {
+ //ignore
+ }
+ }
+
+ @Override
+ public int size() {
+ return wrapped.size();
+ }
+ @Override
+ public boolean isEmpty() {
+ return wrapped.isEmpty();
+ }
+ @Override
+ public boolean containsKey(Object key) {
+ return wrapped.containsKey(key);
+ }
+ @Override
+ public boolean containsValue(Object value) {
+ return wrapped.containsKey(value);
+ }
+ @Override
+ public Object get(Object key) {
+ return wrapped.get(key);
+ }
+ @Override
+ public Object put(String key, Object value) {
+ return wrapped.put(key, value);
+ }
+ @Override
+ public Object remove(Object key) {
+ return wrapped.remove(key);
+ }
+ @Override
+ public void putAll(Map<? extends String, ? extends Object> m) {
+ wrapped.putAll(m);
+ }
+ @Override
+ public Set<String> keySet() {
+ return wrapped.keySet();
+ }
+ @Override
+ public Collection<Object> values() {
+ return wrapped.values();
+ }
+ @Override
+ public Set<Entry<String, Object>> entrySet() {
+ return wrapped.entrySet();
+ }
+ }
+
+ public void setExecutor(Executor executor) {
+ if (!SynchronousExecutor.isA(executor)) {
+ this.executor = executor;
+ }
+ }
+
+
+ public class IllegalEmptyResponseException extends IllegalStateException {
+ private static final long serialVersionUID = 1L;
+
+ public IllegalEmptyResponseException() {
+ super();
+ }
+
+ public IllegalEmptyResponseException(String message) {
+ super(message);
+ }
+
+ public IllegalEmptyResponseException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public IllegalEmptyResponseException(Throwable cause) {
+ super(cause);
+ }
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/endpoint/EndpointImpl.java b/transform/src/patch/java/org/apache/cxf/endpoint/EndpointImpl.java
new file mode 100644
index 0000000..340211b
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/endpoint/EndpointImpl.java
@@ -0,0 +1,220 @@
+/**
+ * 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.cxf.endpoint;
+
+import java.io.Closeable;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusException;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.binding.Binding;
+import org.apache.cxf.binding.BindingFactory;
+import org.apache.cxf.binding.BindingFactoryManager;
+import org.apache.cxf.common.i18n.Message;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.configuration.Configurable;
+import org.apache.cxf.feature.Feature;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.interceptor.AbstractAttributedInterceptorProvider;
+import org.apache.cxf.interceptor.ClientFaultConverter;
+import org.apache.cxf.interceptor.InFaultChainInitiatorObserver;
+import org.apache.cxf.interceptor.MessageSenderInterceptor;
+import org.apache.cxf.interceptor.OutFaultChainInitiatorObserver;
+import org.apache.cxf.service.Service;
+import org.apache.cxf.service.model.BindingInfo;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.transport.MessageObserver;
+
+public class EndpointImpl extends AbstractAttributedInterceptorProvider implements Endpoint, Configurable {
+
+ private static final long serialVersionUID = -7660560719050162091L;
+ private static final Logger LOG = LogUtils.getL7dLogger(EndpointImpl.class);
+ private static final ResourceBundle BUNDLE = LOG.getResourceBundle();
+
+ private Service service;
+ private Binding binding;
+ private EndpointInfo endpointInfo;
+ private Executor executor;
+ private Bus bus;
+ private MessageObserver inFaultObserver;
+ private MessageObserver outFaultObserver;
+ private List<Feature> activeFeatures;
+ private List<Closeable> cleanupHooks;
+
+ public EndpointImpl(Bus bus, Service s, QName endpointName) throws EndpointException {
+ this(bus, s, s.getEndpointInfo(endpointName));
+ }
+
+ public EndpointImpl(Bus bus, Service s, EndpointInfo ei) throws EndpointException {
+ if (ei == null) {
+ throw new NullPointerException("EndpointInfo can not be null!");
+ }
+
+ if (bus == null) {
+ this.bus = BusFactory.getThreadDefaultBus();
+ } else {
+ this.bus = bus;
+ }
+ service = s;
+ endpointInfo = ei;
+
+ createBinding(endpointInfo.getBinding());
+
+ inFaultObserver = new InFaultChainInitiatorObserver(bus);
+ outFaultObserver = new OutFaultChainInitiatorObserver(bus);
+
+ getInFaultInterceptors().add(new ClientFaultConverter());
+ getOutInterceptors().add(new MessageSenderInterceptor());
+ getOutFaultInterceptors().add(new MessageSenderInterceptor());
+ }
+
+ public String getBeanName() {
+ return endpointInfo.getName().toString() + ".endpoint";
+ }
+
+
+ public EndpointInfo getEndpointInfo() {
+ return endpointInfo;
+ }
+
+ public Service getService() {
+ return service;
+ }
+
+ public Binding getBinding() {
+ return binding;
+ }
+
+ public Executor getExecutor() {
+ return executor == null ? service.getExecutor() : executor;
+ }
+
+ public void setExecutor(Executor e) {
+ executor = e;
+ }
+
+ public Bus getBus() {
+ return bus;
+ }
+
+ public void setBus(Bus bus) {
+ this.bus = bus;
+ }
+
+ final void createBinding(BindingInfo bi) throws EndpointException {
+ if (null != bi) {
+ String namespace = bi.getBindingId();
+ try {
+ final BindingFactory bf = bus.getExtension(BindingFactoryManager.class).getBindingFactory(namespace);
+ if (null == bf) {
+ Message msg = new Message("NO_BINDING_FACTORY", BUNDLE, namespace);
+ throw new EndpointException(msg);
+ }
+ binding = bf.createBinding(bi);
+ } catch (BusException ex) {
+ throw new EndpointException(ex);
+ }
+ }
+ }
+
+
+ public MessageObserver getInFaultObserver() {
+ return inFaultObserver;
+ }
+
+ public MessageObserver getOutFaultObserver() {
+ return outFaultObserver;
+ }
+
+ public void setInFaultObserver(MessageObserver observer) {
+ inFaultObserver = observer;
+ }
+
+ public void setOutFaultObserver(MessageObserver observer) {
+ outFaultObserver = observer;
+
+ }
+
+ /**
+ * Utility method to make it easy to set properties from Spring.
+ *
+ * @param properties
+ */
+ public void setProperties(Map<String, Object> properties) {
+ this.putAll(properties);
+ }
+
+ /**
+ * @return the list of features <b>already</b> activated for this endpoint.
+ */
+ public List<Feature> getActiveFeatures() {
+ return activeFeatures;
+ }
+
+ /**
+ * @param features the list of features <b>already</b> activated for this endpoint.
+ */
+ public void initializeActiveFeatures(List<? extends Feature> features) {
+ activeFeatures = CastUtils.cast(features);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof EndpointImpl)) {
+ return false;
+ }
+
+ return super.equals(obj);
+ }
+
+ /**
+ * Returns the hashCode based on the EndpointInfo so that this object
+ * can be used as a map key.
+ */
+ @Override
+ public int hashCode() {
+ return endpointInfo.hashCode();
+ }
+
+ public synchronized void addCleanupHook(Closeable c) {
+ if (cleanupHooks == null) {
+ cleanupHooks = new CopyOnWriteArrayList<>();
+ }
+ cleanupHooks.add(c);
+ }
+ public List<Closeable> getCleanupHooks() {
+ if (cleanupHooks == null) {
+ return Collections.emptyList();
+ }
+ return cleanupHooks;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/endpoint/ServerImpl.java b/transform/src/patch/java/org/apache/cxf/endpoint/ServerImpl.java
new file mode 100644
index 0000000..c417cb6
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/endpoint/ServerImpl.java
@@ -0,0 +1,221 @@
+/**
+ * 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.cxf.endpoint;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.management.JMException;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusException;
+import org.apache.cxf.binding.BindingFactory;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.logging.RegexLoggingFilter;
+import org.apache.cxf.management.InstrumentationManager;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.transport.Destination;
+import org.apache.cxf.transport.DestinationFactory;
+import org.apache.cxf.transport.DestinationFactoryManager;
+import org.apache.cxf.transport.MessageObserver;
+import org.apache.cxf.transport.MultipleEndpointObserver;
+
+public class ServerImpl implements Server {
+ private static final Logger LOG = LogUtils.getL7dLogger(ServerImpl.class);
+
+ protected final Endpoint endpoint;
+ protected final Bus bus;
+ protected final BindingFactory bindingFactory;
+
+ private Destination destination;
+ private ServerRegistry serverRegistry;
+ private ServerLifeCycleManager slcMgr;
+ private InstrumentationManager iMgr;
+ private ManagedEndpoint mep;
+ private boolean stopped = true;
+ private boolean destroyDest = true;
+
+ public ServerImpl(Bus bus,
+ Endpoint endpoint,
+ DestinationFactory destinationFactory,
+ BindingFactory bindingFactory) throws BusException, IOException {
+ this.endpoint = endpoint;
+ this.bus = bus;
+ this.bindingFactory = bindingFactory;
+
+ initDestination(destinationFactory);
+ }
+
+ private void initDestination(DestinationFactory destinationFactory) throws BusException, IOException {
+ EndpointInfo ei = endpoint.getEndpointInfo();
+
+ //Treat local transport as a special case, transports loaded by transportId can be replaced
+ //by local transport when the publishing address is a local transport protocol.
+ //Of course its not an ideal situation here to use a hard-coded prefix. To be refactored.
+ if (destinationFactory == null) {
+ if (ei.getAddress() != null && ei.getAddress().indexOf("local://") != -1) {
+ destinationFactory = bus.getExtension(DestinationFactoryManager.class)
+ .getDestinationFactoryForUri(ei.getAddress());
+ }
+
+ if (destinationFactory == null) {
+ destinationFactory = bus.getExtension(DestinationFactoryManager.class)
+ .getDestinationFactory(ei.getTransportId());
+ }
+ }
+
+ destination = destinationFactory.getDestination(ei, bus);
+ String wantFilter = ei.getAddress();
+
+ if (wantFilter != null && wantFilter.startsWith("jms")) {
+ RegexLoggingFilter filter = new RegexLoggingFilter();
+ filter.setPattern("jms(.*?)password=+([^ ]+)");
+ filter.setGroup(2);
+ wantFilter = filter.filter(wantFilter).toString();
+ }
+ LOG.info("Setting the server's publish address to be " + wantFilter);
+ serverRegistry = bus.getExtension(ServerRegistry.class);
+
+ mep = new ManagedEndpoint(bus, endpoint, this);
+
+ slcMgr = bus.getExtension(ServerLifeCycleManager.class);
+ if (slcMgr != null) {
+ slcMgr.registerListener(mep);
+ }
+
+ iMgr = bus.getExtension(InstrumentationManager.class);
+ if (iMgr != null) {
+ try {
+ iMgr.register(mep);
+ } catch (JMException jmex) {
+ LOG.log(Level.WARNING, "Registering ManagedEndpoint failed.", jmex);
+ }
+ }
+ }
+
+ public Destination getDestination() {
+ return destination;
+ }
+
+ public void setDestination(Destination destination) {
+ this.destination = destination;
+ }
+
+ public void start() {
+ if (!stopped) {
+ return;
+ }
+ LOG.fine("Server is starting.");
+
+ try {
+ bindingFactory.addListener(destination, endpoint);
+ } catch (RuntimeException e) {
+ if (e.getMessage().contains("endpoint already registered on address")) {
+ //this destination is used by another endpoint with same endpoint address
+ //so shouldn't be destroyed by this server
+ this.destroyDest = false;
+ }
+ throw e;
+ }
+
+ // register the active server to run
+ if (null != serverRegistry) {
+ LOG.fine("register the server to serverRegistry ");
+ serverRegistry.register(this);
+ }
+ if (slcMgr == null) {
+ slcMgr = bus.getExtension(ServerLifeCycleManager.class);
+ if (slcMgr != null && mep != null) {
+ slcMgr.registerListener(mep);
+ }
+ }
+ if (slcMgr != null) {
+ slcMgr.startServer(this);
+ }
+ stopped = false;
+ }
+
+ public boolean isStopped() {
+ return stopped;
+ }
+ public boolean isStarted() {
+ return !stopped;
+ }
+
+ public void stop() {
+ if (stopped) {
+ return;
+ }
+
+ LOG.fine("Server is stopping.");
+
+ for (Closeable c : endpoint.getCleanupHooks()) {
+ try {
+ c.close();
+ } catch (IOException e) {
+ //ignore
+ }
+ }
+ if (slcMgr != null) {
+ slcMgr.stopServer(this);
+ }
+
+ MessageObserver mo = getDestination().getMessageObserver();
+ if (mo instanceof MultipleEndpointObserver) {
+ ((MultipleEndpointObserver)mo).getEndpoints().remove(endpoint);
+ if (((MultipleEndpointObserver)mo).getEndpoints().isEmpty()) {
+ getDestination().setMessageObserver(null);
+ }
+ } else {
+ getDestination().setMessageObserver(null);
+ }
+ stopped = true;
+ }
+
+ public void destroy() {
+ stop();
+ if (this.destroyDest) {
+ //we should shutdown the destination here
+ getDestination().shutdown();
+ }
+
+ if (null != serverRegistry) {
+ LOG.fine("unregister the server to serverRegistry ");
+ serverRegistry.unregister(this);
+ }
+
+ if (iMgr != null) {
+ try {
+ iMgr.unregister(mep);
+ } catch (JMException jmex) {
+ LOG.log(Level.WARNING, "Unregistering ManagedEndpoint failed.", jmex);
+ }
+ iMgr = null;
+ }
+
+ }
+
+ public Endpoint getEndpoint() {
+ return endpoint;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/feature/FastInfosetFeature.java b/transform/src/patch/java/org/apache/cxf/feature/FastInfosetFeature.java
new file mode 100644
index 0000000..daa4bd3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/feature/FastInfosetFeature.java
@@ -0,0 +1,110 @@
+/**
+ * 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.cxf.feature;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.injection.NoJSR250Annotations;
+import org.apache.cxf.interceptor.FIStaxInInterceptor;
+import org.apache.cxf.interceptor.FIStaxOutInterceptor;
+import org.apache.cxf.interceptor.InterceptorProvider;
+
+
+/**
+ * <pre>
+ * <![CDATA[
+ <jaxws:endpoint ...>
+ <jaxws:features>
+ <bean class="org.apache.cxf.feature.FastInfosetFeature"/>
+ </jaxws:features>
+ </jaxws:endpoint>
+ ]]>
+ </pre>
+ */
+@NoJSR250Annotations
+public class FastInfosetFeature extends DelegatingFeature<FastInfosetFeature.Portable> {
+ public FastInfosetFeature() {
+ super(new Portable());
+ }
+
+ public void setForce(boolean b) {
+ delegate.setForce(b);
+ }
+
+ public boolean getForce() {
+ return delegate.getForce();
+ }
+
+ public static class Portable implements AbstractPortableFeature {
+ boolean force;
+ private Integer serializerAttributeValueMapMemoryLimit;
+ private Integer serializerMinAttributeValueSize;
+ private Integer serializerMaxAttributeValueSize;
+ private Integer serializerCharacterContentChunkMapMemoryLimit;
+ private Integer serializerMinCharacterContentChunkSize;
+ private Integer serializerMaxCharacterContentChunkSize;
+
+ @Override
+ public void doInitializeProvider(InterceptorProvider provider, Bus bus) {
+
+ FIStaxInInterceptor in = new FIStaxInInterceptor();
+
+ FIStaxOutInterceptor out = new FIStaxOutInterceptor(force);
+ if (serializerAttributeValueMapMemoryLimit != null && serializerAttributeValueMapMemoryLimit > 0) {
+ out.setSerializerAttributeValueMapMemoryLimit(serializerAttributeValueMapMemoryLimit);
+ }
+ if (serializerMinAttributeValueSize != null && serializerMinAttributeValueSize > 0) {
+ out.setSerializerMinAttributeValueSize(serializerMinAttributeValueSize);
+ }
+ if (serializerMaxAttributeValueSize != null && serializerMaxAttributeValueSize > 0) {
+ out.setSerializerMaxAttributeValueSize(serializerMaxAttributeValueSize);
+ }
+ if (serializerCharacterContentChunkMapMemoryLimit != null
+ && serializerCharacterContentChunkMapMemoryLimit > 0) {
+ out.setSerializerCharacterContentChunkMapMemoryLimit(
+ serializerCharacterContentChunkMapMemoryLimit);
+ }
+ if (serializerMinCharacterContentChunkSize != null && serializerMinCharacterContentChunkSize > 0) {
+ out.setSerializerMinCharacterContentChunkSize(serializerMinCharacterContentChunkSize);
+ }
+ if (serializerMaxCharacterContentChunkSize != null && serializerMaxCharacterContentChunkSize > 0) {
+ out.setSerializerMaxCharacterContentChunkSize(serializerMaxCharacterContentChunkSize);
+ }
+
+ provider.getInInterceptors().add(in);
+ provider.getInFaultInterceptors().add(in);
+ provider.getOutInterceptors().add(out);
+ provider.getOutFaultInterceptors().add(out);
+ }
+
+ /**
+ * Set if FastInfoset is always used without negotiation
+ * @param b
+ */
+ public void setForce(boolean b) {
+ force = b;
+ }
+
+ /**
+ * Retrieve the value set with {@link #setForce(boolean)}.
+ */
+ public boolean getForce() {
+ return force;
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/feature/WrappedFeature.java b/transform/src/patch/java/org/apache/cxf/feature/WrappedFeature.java
new file mode 100644
index 0000000..2236a38
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/feature/WrappedFeature.java
@@ -0,0 +1,61 @@
+/**
+ * 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.cxf.feature;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.endpoint.Client;
+import org.apache.cxf.endpoint.Server;
+import org.apache.cxf.interceptor.InterceptorProvider;
+
+/**
+ * A Feature is something that is able to customize a Server, Client, or Bus, typically
+ * adding capabilities. For instance, there may be a LoggingFeature which configures
+ * one of the above to log each of their messages.
+ * <p>
+ * By default the initialize methods all delegate to initializeProvider(InterceptorProvider).
+ * If you're simply adding interceptors to a Server, Client, or Bus, this allows you to add
+ * them easily.
+ */
+public class WrappedFeature extends AbstractFeature {
+ final Feature wrapped;
+ public WrappedFeature(Feature f) {
+ wrapped = f;
+ }
+
+ @Override
+ public void initialize(Server server, Bus bus) {
+ wrapped.initialize(server, bus);
+ }
+
+ @Override
+ public void initialize(Client client, Bus bus) {
+ wrapped.initialize(client, bus);
+ }
+
+ @Override
+ public void initialize(InterceptorProvider interceptorProvider, Bus bus) {
+ wrapped.initialize(interceptorProvider, bus);
+ }
+
+ @Override
+ public void initialize(Bus bus) {
+ wrapped.initialize(bus);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/feature/transform/XSLTOutInterceptor.java b/transform/src/patch/java/org/apache/cxf/feature/transform/XSLTOutInterceptor.java
new file mode 100644
index 0000000..53605cc
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/feature/transform/XSLTOutInterceptor.java
@@ -0,0 +1,210 @@
+/**
+ * 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.cxf.feature.transform;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.util.logging.Logger;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.Templates;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.interceptor.AbstractOutDatabindingInterceptor;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.interceptor.StaxOutInterceptor;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.io.CachedOutputStreamCallback;
+import org.apache.cxf.io.CachedWriter;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.staxutils.DelegatingXMLStreamWriter;
+import org.apache.cxf.staxutils.StaxUtils;
+
+/** Class provides XSLT transformation of outgoing message.
+ * Actually it breaks streaming (can be fixed in further versions when XSLT engine supports XML stream)
+ */
+public class XSLTOutInterceptor extends AbstractXSLTInterceptor {
+ private static final Logger LOG = LogUtils.getL7dLogger(XSLTOutInterceptor.class);
+
+ public XSLTOutInterceptor(String xsltPath) {
+ super(Phase.PRE_STREAM, StaxOutInterceptor.class, null, xsltPath);
+ }
+
+ public XSLTOutInterceptor(String phase, Class<?> before, Class<?> after, String xsltPath) {
+ super(phase, before, after, xsltPath);
+ }
+
+ @Override
+ public void handleMessage(Message message) {
+ if (checkContextProperty(message)) {
+ return;
+ }
+
+ // 1. Try to get and transform XMLStreamWriter message content
+ XMLStreamWriter xWriter = message.getContent(XMLStreamWriter.class);
+ if (xWriter != null) {
+ transformXWriter(message, xWriter);
+ } else {
+ // 2. Try to get and transform OutputStream message content
+ OutputStream out = message.getContent(OutputStream.class);
+ if (out != null) {
+ transformOS(message, out);
+ } else {
+ // 3. Try to get and transform Writer message content (actually used for JMS TextMessage)
+ Writer writer = message.getContent(Writer.class);
+ if (writer != null) {
+ transformWriter(message, writer);
+ }
+ }
+ }
+ }
+
+ protected void transformXWriter(Message message, XMLStreamWriter xWriter) {
+ CachedWriter writer = new CachedWriter();
+ XMLStreamWriter delegate = StaxUtils.createXMLStreamWriter(writer);
+ XSLTStreamWriter wrapper = new XSLTStreamWriter(getXSLTTemplate(), writer, delegate, xWriter);
+ message.setContent(XMLStreamWriter.class, wrapper);
+ message.put(AbstractOutDatabindingInterceptor.DISABLE_OUTPUTSTREAM_OPTIMIZATION,
+ Boolean.TRUE);
+ }
+
+ protected void transformOS(Message message, OutputStream out) {
+ CachedOutputStream wrapper = new CachedOutputStream();
+ CachedOutputStreamCallback callback = new XSLTCachedOutputStreamCallback(getXSLTTemplate(), out);
+ wrapper.registerCallback(callback);
+ message.setContent(OutputStream.class, wrapper);
+ }
+
+ protected void transformWriter(Message message, Writer writer) {
+ XSLTCachedWriter wrapper = new XSLTCachedWriter(getXSLTTemplate(), writer);
+ message.setContent(Writer.class, wrapper);
+ }
+
+
+ public static class XSLTStreamWriter extends DelegatingXMLStreamWriter {
+ private final Templates xsltTemplate;
+ private final CachedWriter cachedWriter;
+ private final XMLStreamWriter origXWriter;
+
+ public XSLTStreamWriter(Templates xsltTemplate, CachedWriter cachedWriter,
+ XMLStreamWriter delegateXWriter, XMLStreamWriter origXWriter) {
+ super(delegateXWriter);
+ this.xsltTemplate = xsltTemplate;
+ this.cachedWriter = cachedWriter;
+ this.origXWriter = origXWriter;
+ }
+
+ @Override
+ public void close() {
+ Reader transformedReader = null;
+ try {
+ super.flush();
+ transformedReader = XSLTUtils.transform(xsltTemplate, cachedWriter.getReader());
+ StaxUtils.copy(new StreamSource(transformedReader), origXWriter);
+ } catch (XMLStreamException e) {
+ throw new Fault("STAX_COPY", LOG, e, e.getMessage());
+ } catch (IOException e) {
+ throw new Fault("GET_CACHED_INPUT_STREAM", LOG, e, e.getMessage());
+ } finally {
+ try {
+ if (transformedReader != null) {
+ transformedReader.close();
+ }
+ cachedWriter.close();
+ StaxUtils.close(origXWriter);
+ super.close();
+ } catch (Exception e) {
+ LOG.warning("Cannot close stream after transformation: " + e.getMessage());
+ }
+ }
+ }
+ }
+
+ public static class XSLTCachedOutputStreamCallback implements CachedOutputStreamCallback {
+ private final Templates xsltTemplate;
+ private final OutputStream origStream;
+
+ public XSLTCachedOutputStreamCallback(Templates xsltTemplate, OutputStream origStream) {
+ this.xsltTemplate = xsltTemplate;
+ this.origStream = origStream;
+ }
+
+ @Override
+ public void onFlush(CachedOutputStream wrapper) {
+ }
+
+ @Override
+ public void onClose(CachedOutputStream wrapper) {
+ InputStream transformedStream;
+ Exception exceptionOnClose = null;
+ try {
+ transformedStream = XSLTUtils.transform(xsltTemplate, wrapper.getInputStream());
+ IOUtils.copyAndCloseInput(transformedStream, origStream);
+ } catch (IOException e) {
+ throw new Fault("STREAM_COPY", LOG, e, e.getMessage());
+ } finally {
+ try {
+ origStream.close();
+ } catch (Exception e) {
+ exceptionOnClose = e;
+ }
+ }
+
+ if (exceptionOnClose == null) {
+ return;
+ }
+ throw new Fault(exceptionOnClose);
+ }
+ }
+
+ public static class XSLTCachedWriter extends CachedWriter {
+ private final Templates xsltTemplate;
+ private final Writer origWriter;
+
+ public XSLTCachedWriter(Templates xsltTemplate, Writer origWriter) {
+ this.xsltTemplate = xsltTemplate;
+ this.origWriter = origWriter;
+ }
+
+ @Override
+ protected void doClose() {
+ try {
+ final Reader transformedReader = XSLTUtils.transform(xsltTemplate, getReader());
+ IOUtils.copyAndCloseInput(transformedReader, origWriter, IOUtils.DEFAULT_BUFFER_SIZE);
+ } catch (IOException e) {
+ throw new Fault("READER_COPY", LOG, e, e.getMessage());
+ } finally {
+ try {
+ origWriter.close();
+ } catch (IOException e) {
+ LOG.warning("Cannot close stream after transformation: " + e.getMessage());
+ }
+ }
+ }
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/headers/Header.java b/transform/src/patch/java/org/apache/cxf/headers/Header.java
new file mode 100644
index 0000000..f933c14
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/headers/Header.java
@@ -0,0 +1,78 @@
+/**
+ * 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.cxf.headers;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.databinding.DataBinding;
+
+public class Header {
+ public enum Direction {
+ DIRECTION_IN,
+ DIRECTION_OUT,
+ DIRECTION_INOUT
+ }
+
+ public static final String HEADER_LIST = Header.class.getName() + ".list";
+
+
+ private DataBinding dataBinding;
+ private QName name;
+ private Object object;
+
+ private Direction direction = Header.Direction.DIRECTION_OUT;
+
+ public Header(QName q, Object o) {
+ this(q, o, null);
+ }
+
+ public Header(QName q, Object o, DataBinding b) {
+ object = o;
+ name = q;
+ dataBinding = b;
+ }
+
+ public DataBinding getDataBinding() {
+ return dataBinding;
+ }
+ public void setDataBinding(DataBinding dataBinding) {
+ this.dataBinding = dataBinding;
+ }
+ public QName getName() {
+ return name;
+ }
+ public void setName(QName name) {
+ this.name = name;
+ }
+ public Object getObject() {
+ return object;
+ }
+ public void setObject(Object object) {
+ this.object = object;
+ }
+
+ public void setDirection(Direction hdrDirection) {
+ this.direction = hdrDirection;
+ }
+
+ public Direction getDirection() {
+ return direction;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/helpers/DOMUtils.java b/transform/src/patch/java/org/apache/cxf/helpers/DOMUtils.java
new file mode 100644
index 0000000..37bde67
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/helpers/DOMUtils.java
@@ -0,0 +1,895 @@
+/**
+ * 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.cxf.helpers;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Comment;
+import org.w3c.dom.Document;
+import org.w3c.dom.DocumentFragment;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.Text;
+
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ReflectionUtil;
+import org.apache.cxf.common.util.StringUtils;
+
+/**
+ * Few simple utils to read DOM. This is originally from the Jakarta Commons Modeler.
+ */
+public final class DOMUtils {
+ private static boolean isJre9SAAJ;
+ private static final Map<ClassLoader, DocumentBuilder> DOCUMENT_BUILDERS
+ = Collections.synchronizedMap(new WeakHashMap<ClassLoader, DocumentBuilder>());
+ private static final String XMLNAMESPACE = "xmlns";
+ private static volatile Document emptyDocument;
+
+ private static final ClassValue<Method> GET_DOM_ELEMENTS_METHODS = new ClassValue<Method>() {
+ @Override
+ protected Method computeValue(Class<?> type) {
+ try {
+ return ReflectionUtil.getMethod(type, "getDomElement");
+ } catch (NoSuchMethodException e) {
+ //best effort to try, do nothing if NoSuchMethodException
+ return null;
+ }
+ }
+ };
+ private static final ClassValue<Field> GET_DOCUMENT_FRAGMENT_FIELDS = new ClassValue<Field>() {
+ @Override
+ protected Field computeValue(Class<?> type) {
+ return ReflectionUtil.getDeclaredField(type, "documentFragment");
+ }
+
+ };
+
+ static {
+ try {
+ Method[] methods = DOMUtils.class.getClassLoader().
+ loadClass("com.sun.xml.messaging.saaj.soap.SOAPDocumentImpl").getMethods();
+ for (Method method : methods) {
+ if ("register".equals(method.getName())) {
+ //this is the 1.4+ SAAJ impl
+ setJava9SAAJ(true);
+ break;
+ }
+ }
+ } catch (ClassNotFoundException cnfe) {
+ LogUtils.getL7dLogger(DOMUtils.class).finest(
+ "can't load class com.sun.xml.messaging.saaj.soap.SOAPDocumentImpl");
+
+ try {
+ Method[] methods = DOMUtils.class.getClassLoader().
+ loadClass("com.sun.xml.internal.messaging.saaj.soap.SOAPDocumentImpl").getMethods();
+ for (Method method : methods) {
+ if ("register".equals(method.getName())) {
+ //this is the SAAJ impl in JDK9
+ setJava9SAAJ(true);
+ break;
+ }
+ }
+ } catch (ClassNotFoundException cnfe1) {
+ LogUtils.getL7dLogger(DOMUtils.class).finest(
+ "can't load class com.sun.xml.internal.messaging.saaj.soap.SOAPDocumentImpl");
+ }
+ } catch (Throwable throwable) {
+ LogUtils.getL7dLogger(DOMUtils.class).finest(
+ "Other JDK vendor");
+ }
+ }
+
+ private DOMUtils() {
+ }
+
+ private static DocumentBuilder getDocumentBuilder() throws ParserConfigurationException {
+ ClassLoader loader = getContextClassLoader();
+ if (loader == null) {
+ loader = getClassLoader(DOMUtils.class);
+ }
+ if (loader == null) {
+ return createDocumentBuilder();
+ }
+ DocumentBuilder factory = DOCUMENT_BUILDERS.get(loader);
+ if (factory == null) {
+ factory = createDocumentBuilder();
+ DOCUMENT_BUILDERS.put(loader, factory);
+ }
+ return factory;
+ }
+
+ private static DocumentBuilder createDocumentBuilder() throws ParserConfigurationException {
+ DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
+ f.setNamespaceAware(true);
+ f.setFeature(javax.xml.XMLConstants.FEATURE_SECURE_PROCESSING, true);
+ f.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+ return f.newDocumentBuilder();
+ }
+
+ private static ClassLoader getContextClassLoader() {
+ final SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
+ public ClassLoader run() {
+ return Thread.currentThread().getContextClassLoader();
+ }
+ });
+ }
+ return Thread.currentThread().getContextClassLoader();
+ }
+
+ private static ClassLoader getClassLoader(final Class<?> clazz) {
+ final SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
+ public ClassLoader run() {
+ return clazz.getClassLoader();
+ }
+ });
+ }
+ return clazz.getClassLoader();
+ }
+
+ /**
+ * Creates a new Document object
+ * @throws ParserConfigurationException
+ */
+ public static Document newDocument() {
+ return createDocument();
+ }
+ public static Document createDocument() {
+ try {
+ return getDocumentBuilder().newDocument();
+ } catch (ParserConfigurationException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static synchronized Document createEmptyDocument() {
+ if (emptyDocument == null) {
+ emptyDocument = createDocument();
+
+ // uncomment this to see if anything is actually setting anything into the empty doc
+ /*
+ final Document doc = createDocument();
+ emptyDocument = (Document)org.apache.cxf.common.util.ProxyHelper.getProxy(
+ DOMUtils.class.getClassLoader(),
+ new Class<?>[] {Document.class},
+ new java.lang.reflect.InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ if (method.getName().contains("create")) {
+ return method.invoke(doc, args);
+ }
+ throw new IllegalStateException("Cannot modify factory document");
+ }
+ });
+ */
+ }
+ return emptyDocument;
+ }
+ /**
+ * Returns a static Document that should always be "empty". It's useful as a factory for
+ * for creating Elements and other nodes that will be traversed later and don't need to
+ * be attached into a document
+ * @return an empty document
+ */
+ public static Document getEmptyDocument() {
+ Document doc = emptyDocument;
+ if (doc == null) {
+ doc = createEmptyDocument();
+ }
+ return doc;
+ }
+
+
+ /**
+ * This function is much like getAttribute, but returns null, not "", for a nonexistent attribute.
+ *
+ * @param e
+ * @param attributeName
+ */
+ public static String getAttributeValueEmptyNull(Element e, String attributeName) {
+ Attr node = e.getAttributeNode(attributeName);
+ if (node == null) {
+ return null;
+ }
+ return node.getValue();
+ }
+
+ /**
+ * Get the text content of a node and all it's children or null if there is no text
+ */
+ public static String getAllContent(Node n) {
+ StringBuilder b = new StringBuilder();
+ getAllContent(n, b);
+ return b.toString();
+ }
+ private static void getAllContent(Node n, StringBuilder b) {
+ Node nd = n.getFirstChild();
+ while (nd != null) {
+ if (nd instanceof Text && !(nd instanceof Comment)) {
+ b.append(((Text)nd).getData());
+ } else {
+ getAllContent(nd, b);
+ }
+ nd = nd.getNextSibling();
+ }
+ }
+ /**
+ * Get the trimmed text content of a node or null if there is no text
+ */
+ public static String getContent(Node n) {
+ String s = getRawContent(n);
+ if (s != null) {
+ s = s.trim();
+ }
+ return s;
+ }
+
+ /**
+ * Get the raw text content of a node or null if there is no text
+ */
+ public static String getRawContent(Node n) {
+ if (n == null) {
+ return null;
+ }
+ StringBuilder b = null;
+ String s = null;
+ Node n1 = n.getFirstChild();
+ while (n1 != null) {
+ if (n1.getNodeType() == Node.TEXT_NODE || n1.getNodeType() == Node.CDATA_SECTION_NODE) {
+ if (b != null) {
+ b.append(((Text)n1).getNodeValue());
+ } else if (s == null) {
+ s = ((Text)n1).getNodeValue();
+ } else {
+ b = new StringBuilder(s).append(((Text)n1).getNodeValue());
+ s = null;
+ }
+ }
+ n1 = n1.getNextSibling();
+ }
+ if (b != null) {
+ return b.toString();
+ }
+ return s;
+ }
+
+ /**
+ * Get the first element child.
+ *
+ * @param parent lookup direct childs
+ * @param name name of the element. If null return the first element.
+ */
+ public static Node getChild(Node parent, String name) {
+ if (parent == null) {
+ return null;
+ }
+
+ Node first = parent.getFirstChild();
+ if (first == null) {
+ return null;
+ }
+
+ for (Node node = first; node != null; node = node.getNextSibling()) {
+
+ if (node.getNodeType() != Node.ELEMENT_NODE) {
+ continue;
+ }
+ if (name != null && name.equals(node.getNodeName())) {
+ return node;
+ }
+ if (name == null) {
+ return node;
+ }
+ }
+ return null;
+ }
+
+
+ public static boolean hasAttribute(Element element, String value) {
+ NamedNodeMap attributes = element.getAttributes();
+ for (int i = 0; i < attributes.getLength(); i++) {
+ Node node = attributes.item(i);
+ if (value.equals(node.getNodeValue())) {
+ return true;
+ }
+ }
+ return false;
+ }
+ public static String getAttribute(Node element, String attName) {
+ NamedNodeMap attrs = element.getAttributes();
+ if (attrs == null) {
+ return null;
+ }
+ Node attN = attrs.getNamedItem(attName);
+ if (attN == null) {
+ return null;
+ }
+ return attN.getNodeValue();
+ }
+
+ public static String getAttribute(Element element, QName attName) {
+ Attr attr;
+ if (StringUtils.isEmpty(attName.getNamespaceURI())) {
+ attr = element.getAttributeNode(attName.getLocalPart());
+ } else {
+ attr = element.getAttributeNodeNS(attName.getNamespaceURI(), attName.getLocalPart());
+ }
+ return attr == null ? null : attr.getValue();
+ }
+
+ public static void setAttribute(Node node, String attName, String val) {
+ NamedNodeMap attributes = node.getAttributes();
+ Node attNode = node.getOwnerDocument().createAttributeNS(null, attName);
+ attNode.setNodeValue(val);
+ attributes.setNamedItem(attNode);
+ }
+
+ public static void removeAttribute(Node node, String attName) {
+ NamedNodeMap attributes = node.getAttributes();
+ attributes.removeNamedItem(attName);
+ }
+
+ /**
+ * Set or replace the text value
+ */
+ public static void setText(Node node, String val) {
+ Node chld = DOMUtils.getChild(node, Node.TEXT_NODE);
+ if (chld == null) {
+ Node textN = node.getOwnerDocument().createTextNode(val);
+ node.appendChild(textN);
+ return;
+ }
+ // change the value
+ chld.setNodeValue(val);
+ }
+
+ /**
+ * Find the first direct child with a given attribute.
+ *
+ * @param parent
+ * @param elemName name of the element, or null for any
+ * @param attName attribute we're looking for
+ * @param attVal attribute value or null if we just want any
+ */
+ public static Element findChildWithAtt(Node parent, String elemName, String attName, String attVal) {
+
+ Element child = (Element)getChild(parent, Node.ELEMENT_NODE);
+ if (attVal == null) {
+ while (child != null && (elemName == null || elemName.equals(child.getNodeName()))
+ && DOMUtils.getAttribute(child, attName) != null) {
+ child = (Element)getNext(child, elemName, Node.ELEMENT_NODE);
+ }
+ } else {
+ while (child != null && (elemName == null || elemName.equals(child.getNodeName()))
+ && !attVal.equals(DOMUtils.getAttribute(child, attName))) {
+ child = (Element)getNext(child, elemName, Node.ELEMENT_NODE);
+ }
+ }
+ return child;
+ }
+
+ /**
+ * Get the first child's content ( ie it's included TEXT node ).
+ */
+ public static String getChildContent(Node parent, String name) {
+ Node first = parent.getFirstChild();
+ if (first == null) {
+ return null;
+ }
+ for (Node node = first; node != null; node = node.getNextSibling()) {
+
+ if (name.equals(node.getNodeName())) {
+ return getRawContent(node);
+ }
+ }
+ return null;
+ }
+
+ public static QName getElementQName(Element el) {
+ return new QName(el.getNamespaceURI(), el.getLocalName());
+ }
+
+ /**
+ * Creates a QName object based on the qualified name
+ * and using the Node as a base to lookup the namespace
+ * for the prefix
+ * @param qualifiedName
+ * @param node
+ */
+ public static QName createQName(String qualifiedName, Node node) {
+ if (qualifiedName == null) {
+ return null;
+ }
+
+ int index = qualifiedName.indexOf(':');
+
+ if (index == -1) {
+ return new QName(qualifiedName);
+ }
+
+ String prefix = qualifiedName.substring(0, index);
+ String localName = qualifiedName.substring(index + 1);
+ String ns = node.lookupNamespaceURI(prefix);
+
+ if (ns == null) {
+ throw new RuntimeException("Invalid QName in mapping: " + qualifiedName);
+ }
+
+ return new QName(ns, localName, prefix);
+ }
+
+ public static QName convertStringToQName(String expandedQName) {
+ return convertStringToQName(expandedQName, "");
+ }
+
+ public static QName convertStringToQName(String expandedQName, String prefix) {
+ int ind1 = expandedQName.indexOf('{');
+ if (ind1 != 0) {
+ return new QName(expandedQName);
+ }
+
+ int ind2 = expandedQName.indexOf('}');
+ if (ind2 <= ind1 + 1 || ind2 >= expandedQName.length() - 1) {
+ return null;
+ }
+ String ns = expandedQName.substring(ind1 + 1, ind2);
+ String localName = expandedQName.substring(ind2 + 1);
+ return new QName(ns, localName, prefix);
+ }
+ public static Set<QName> convertStringsToQNames(List<String> expandedQNames) {
+ Set<QName> dropElements = Collections.emptySet();
+ if (expandedQNames != null) {
+ dropElements = new LinkedHashSet<>(expandedQNames.size());
+ for (String val : expandedQNames) {
+ dropElements.add(convertStringToQName(val));
+ }
+ }
+ return dropElements;
+ }
+
+
+ /**
+ * Get the first direct child with a given type
+ */
+ public static Element getFirstElement(Node parent) {
+ Node n = parent.getFirstChild();
+ while (n != null && Node.ELEMENT_NODE != n.getNodeType()) {
+ n = n.getNextSibling();
+ }
+ if (n == null) {
+ return null;
+ }
+ return (Element)n;
+ }
+
+ public static Element getNextElement(Element el) {
+ Node nd = el.getNextSibling();
+ while (nd != null) {
+ if (nd.getNodeType() == Node.ELEMENT_NODE) {
+ return (Element)nd;
+ }
+ nd = nd.getNextSibling();
+ }
+ return null;
+ }
+
+ /**
+ * Return the first element child with the specified qualified name.
+ *
+ * @param parent
+ * @param q
+ */
+ public static Element getFirstChildWithName(Element parent, QName q) {
+ String ns = q.getNamespaceURI();
+ String lp = q.getLocalPart();
+ return getFirstChildWithName(parent, ns, lp);
+ }
+
+ /**
+ * Return the first element child with the specified qualified name.
+ *
+ * @param parent
+ * @param ns
+ * @param lp
+ */
+ public static Element getFirstChildWithName(Element parent, String ns, String lp) {
+ for (Node n = parent.getFirstChild(); n != null; n = n.getNextSibling()) {
+ if (n instanceof Element) {
+ Element e = (Element)n;
+ String ens = (e.getNamespaceURI() == null) ? "" : e.getNamespaceURI();
+ if (ns.equals(ens) && lp.equals(e.getLocalName())) {
+ return e;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Return child elements with specified name.
+ *
+ * @param parent
+ * @param ns
+ * @param localName
+ */
+ public static List<Element> getChildrenWithName(Element parent, String ns, String localName) {
+ List<Element> r = new ArrayList<>();
+ for (Node n = parent.getFirstChild(); n != null; n = n.getNextSibling()) {
+ if (n instanceof Element) {
+ Element e = (Element)n;
+ String eNs = (e.getNamespaceURI() == null) ? "" : e.getNamespaceURI();
+ if (ns.equals(eNs) && localName.equals(e.getLocalName())) {
+ r.add(e);
+ }
+ }
+ }
+ return r;
+ }
+
+ /**
+ * Returns all child elements with specified namespace.
+ *
+ * @param parent the element to search under
+ * @param ns the namespace to find elements in
+ * @return all child elements with specified namespace
+ */
+ public static List<Element> getChildrenWithNamespace(Element parent, String ns) {
+ List<Element> r = new ArrayList<>();
+ for (Node n = parent.getFirstChild(); n != null; n = n.getNextSibling()) {
+ if (n instanceof Element) {
+ Element e = (Element)n;
+ String eNs = (e.getNamespaceURI() == null) ? "" : e.getNamespaceURI();
+ if (ns.equals(eNs)) {
+ r.add(e);
+ }
+ }
+ }
+ return r;
+ }
+
+ /**
+ * Get the first child of the specified type.
+ *
+ * @param parent
+ * @param type
+ */
+ public static Node getChild(Node parent, int type) {
+ Node n = parent.getFirstChild();
+ while (n != null && type != n.getNodeType()) {
+ n = n.getNextSibling();
+ }
+ if (n == null) {
+ return null;
+ }
+ return n;
+ }
+
+ /**
+ * Get the next sibling with the same name and type
+ */
+ public static Node getNext(Node current) {
+ String name = current.getNodeName();
+ int type = current.getNodeType();
+ return getNext(current, name, type);
+ }
+
+ /**
+ * Return the next sibling with a given name and type
+ */
+ public static Node getNext(Node current, String name, int type) {
+ Node first = current.getNextSibling();
+ if (first == null) {
+ return null;
+ }
+
+ for (Node node = first; node != null; node = node.getNextSibling()) {
+
+ if (type >= 0 && node.getNodeType() != type) {
+ continue;
+ }
+
+ if (name == null) {
+ return node;
+ }
+ if (name.equals(node.getNodeName())) {
+ return node;
+ }
+ }
+ return null;
+ }
+
+ public static class NullResolver implements EntityResolver {
+ public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
+ return new InputSource(new StringReader(""));
+ }
+ }
+
+ public static String getPrefixRecursive(Element el, String ns) {
+ String prefix = getPrefix(el, ns);
+ if (prefix == null && el.getParentNode() instanceof Element) {
+ prefix = getPrefixRecursive((Element)el.getParentNode(), ns);
+ }
+ return prefix;
+ }
+
+ public static String getPrefix(Element el, String ns) {
+ NamedNodeMap atts = el.getAttributes();
+ for (int i = 0; i < atts.getLength(); i++) {
+ Node node = atts.item(i);
+ String name = node.getNodeName();
+ if (ns.equals(node.getNodeValue())
+ && (name != null && (XMLNAMESPACE.equals(name) || name.startsWith(XMLNAMESPACE + ":")))) {
+ return node.getLocalName();
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Get all prefixes defined, up to the root, for a namespace URI.
+ *
+ * @param element
+ * @param namespaceUri
+ * @param prefixes
+ */
+ public static void getPrefixesRecursive(Element element, String namespaceUri, List<String> prefixes) {
+ getPrefixes(element, namespaceUri, prefixes);
+ Node parent = element.getParentNode();
+ if (parent instanceof Element) {
+ getPrefixesRecursive((Element)parent, namespaceUri, prefixes);
+ }
+ }
+
+ /**
+ * Get all prefixes defined on this element for the specified namespace.
+ *
+ * @param element
+ * @param namespaceUri
+ * @param prefixes
+ */
+ public static void getPrefixes(Element element, String namespaceUri, List<String> prefixes) {
+ NamedNodeMap atts = element.getAttributes();
+ for (int i = 0; i < atts.getLength(); i++) {
+ Node node = atts.item(i);
+ String name = node.getNodeName();
+ if (namespaceUri.equals(node.getNodeValue())
+ && (name != null && (XMLNAMESPACE.equals(name) || name.startsWith(XMLNAMESPACE + ":")))) {
+ prefixes.add(node.getPrefix());
+ }
+ }
+ }
+
+ public static String createNamespace(Element el, String ns) {
+ String p = "ns1";
+ int i = 1;
+ while (getPrefix(el, ns) != null) {
+ p = "ns" + i;
+ i++;
+ }
+ addNamespacePrefix(el, ns, p);
+ return p;
+ }
+
+ /**
+ * Starting from a node, find the namespace declaration for a prefix. for a matching namespace
+ * declaration.
+ *
+ * @param node search up from here to search for namespace definitions
+ * @param searchPrefix the prefix we are searching for
+ * @return the namespace if found.
+ */
+ public static String getNamespace(Node node, String searchPrefix) {
+
+ Element el;
+ while (!(node instanceof Element)) {
+ node = node.getParentNode();
+ }
+ el = (Element)node;
+
+ NamedNodeMap atts = el.getAttributes();
+ for (int i = 0; i < atts.getLength(); i++) {
+ Node currentAttribute = atts.item(i);
+ String currentLocalName = currentAttribute.getLocalName();
+ String currentPrefix = currentAttribute.getPrefix();
+ if (searchPrefix.equals(currentLocalName) && XMLNAMESPACE.equals(currentPrefix)) {
+ return currentAttribute.getNodeValue();
+ } else if (StringUtils.isEmpty(searchPrefix) && XMLNAMESPACE.equals(currentLocalName)
+ && StringUtils.isEmpty(currentPrefix)) {
+ return currentAttribute.getNodeValue();
+ }
+ }
+
+ Node parent = el.getParentNode();
+ if (parent instanceof Element) {
+ return getNamespace(parent, searchPrefix);
+ }
+
+ return null;
+ }
+
+ public static List<Element> findAllElementsByTagNameNS(Element elem, String nameSpaceURI,
+ String localName) {
+ List<Element> ret = new LinkedList<>();
+ findAllElementsByTagNameNS(elem, nameSpaceURI, localName, ret);
+ return ret;
+ }
+
+ /**
+ * Try to get the DOM Node from the SAAJ Node with JAVA9 afterwards
+ * @param node The original node we need check
+ * @return The DOM node
+ */
+ public static Node getDomElement(Node node) {
+ if (node != null && isJava9SAAJ()) {
+ //java9plus hack
+ Method method = GET_DOM_ELEMENTS_METHODS.get(node.getClass());
+ if (method != null) {
+ try {
+ return (Node)ReflectionUtil.setAccessible(method).invoke(node);
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+ return node;
+ }
+
+ /**
+ * Try to get the DOM DocumentFragment from the SAAJ DocumentFragment with JAVA9 afterwards
+ * @param fragment The original documentFragment we need to check
+ * @return The DOM DocumentFragment
+ */
+ public static DocumentFragment getDomDocumentFragment(DocumentFragment fragment) {
+ if (fragment != null && isJava9SAAJ()) {
+ //java9 plus hack
+ Field f = GET_DOCUMENT_FRAGMENT_FIELDS.get(fragment.getClass());
+ if (f != null) {
+ return ReflectionUtil.accessDeclaredField(f, fragment, DocumentFragment.class);
+ }
+ }
+ return fragment;
+ }
+
+ private static void findAllElementsByTagNameNS(Element el, String nameSpaceURI, String localName,
+ List<Element> elementList) {
+
+ if (el.getNamespaceURI() != null && localName.equals(el.getLocalName())
+ && nameSpaceURI.contains(el.getNamespaceURI())) {
+ elementList.add(el);
+ }
+ Element elem = getFirstElement(el);
+ while (elem != null) {
+ findAllElementsByTagNameNS(elem, nameSpaceURI, localName, elementList);
+ elem = getNextElement(elem);
+ }
+ }
+
+ public static List<Element> findAllElementsByTagName(Element elem, String tagName) {
+ List<Element> ret = new LinkedList<>();
+ findAllElementsByTagName(elem, tagName, ret);
+ return ret;
+ }
+
+ private static void findAllElementsByTagName(Element el, String tagName, List<Element> elementList) {
+
+ if (tagName.equals(el.getTagName())) {
+ elementList.add(el);
+ }
+ Element elem = getFirstElement(el);
+ while (elem != null) {
+ findAllElementsByTagName(elem, tagName, elementList);
+ elem = getNextElement(elem);
+ }
+ }
+ public static boolean hasElementWithName(Element el, String nameSpaceURI, String localName) {
+ if (el.getNamespaceURI() != null && localName.equals(el.getLocalName())
+ && nameSpaceURI.contains(el.getNamespaceURI())) {
+ return true;
+ }
+ Element elem = getFirstElement(el);
+ while (elem != null) {
+ if (hasElementWithName(elem, nameSpaceURI, localName)) {
+ return true;
+ }
+ elem = getNextElement(elem);
+ }
+ return false;
+ }
+ public static boolean hasElementInNS(Element el, String namespace) {
+
+ if (namespace.equals(el.getNamespaceURI())) {
+ return true;
+ }
+ Element elem = getFirstElement(el);
+ while (elem != null) {
+ if (hasElementInNS(elem, namespace)) {
+ return true;
+ }
+ elem = getNextElement(elem);
+ }
+ return false;
+ }
+ /**
+ * Set a namespace/prefix on an element if it is not set already. First off, it searches for the element
+ * for the prefix associated with the specified namespace. If the prefix isn't null, then this is
+ * returned. Otherwise, it creates a new attribute using the namespace/prefix passed as parameters.
+ *
+ * @param element
+ * @param namespace
+ * @param prefix
+ * @return the prefix associated with the set namespace
+ */
+ public static String setNamespace(Element element, String namespace, String prefix) {
+ String pre = getPrefixRecursive(element, namespace);
+ if (pre != null) {
+ return pre;
+ }
+ element.setAttributeNS(XMLConstants.XMLNS_ATTRIBUTE_NS_URI, "xmlns:" + prefix, namespace);
+ return prefix;
+ }
+
+ /**
+ * Add a namespace prefix definition to an element.
+ *
+ * @param element
+ * @param namespaceUri
+ * @param prefix
+ */
+ public static void addNamespacePrefix(Element element, String namespaceUri, String prefix) {
+ element.setAttributeNS(XMLConstants.XMLNS_ATTRIBUTE_NS_URI, "xmlns:" + prefix, namespaceUri);
+ }
+
+ public static boolean isJava9SAAJ() {
+ return isJre9SAAJ;
+ }
+
+ private static void setJava9SAAJ(boolean isJava9SAAJ) {
+ DOMUtils.isJre9SAAJ = isJava9SAAJ;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/helpers/IOUtils.java b/transform/src/patch/java/org/apache/cxf/helpers/IOUtils.java
new file mode 100644
index 0000000..74af28d
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/helpers/IOUtils.java
@@ -0,0 +1,428 @@
+/**
+ * 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.cxf.helpers;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PushbackInputStream;
+import java.io.Reader;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+
+import org.apache.cxf.io.CopyingOutputStream;
+import org.apache.cxf.io.Transferable;
+
+public final class IOUtils {
+ public static final Charset UTF8_CHARSET = java.nio.charset.StandardCharsets.UTF_8;
+ public static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
+
+ private IOUtils() {
+
+ }
+
+ /**
+ * Checks if input stream is empty. If the standard InputStream means do not provide
+ * such details, the stream might be wrapped into PushbackInputStream and is going
+ * to be returned instead of original one.
+ * @param is input stream to check
+ * @return "null" if original input stream is empty, otherwise original stream or
+ * original stream wrapped into PushbackInputStream.
+ * @throws IOException
+ */
+ public static InputStream nullOrNotEmptyStream(InputStream is) throws IOException {
+ if (isEmpty(is)) {
+ return null;
+ } else if (!(is instanceof PushbackInputStream)) {
+ final byte[] bytes = new byte[1];
+
+ final PushbackInputStream pbStream = new PushbackInputStream(is);
+ boolean isEmpty = isEof(pbStream.read(bytes));
+
+ if (!isEmpty) {
+ pbStream.unread(bytes);
+ return pbStream;
+ }
+
+ return null;
+ }
+
+ return is;
+ }
+
+ public static boolean isEmpty(InputStream is) throws IOException {
+ if (is == null) {
+ return true;
+ }
+ try {
+ // if available is 0 it does not mean it is empty
+ if (is.available() > 0) {
+ return false;
+ }
+ } catch (IOException ioe) {
+ //Do nothing
+ }
+ final byte[] bytes = new byte[1];
+ if (is.markSupported()) {
+ is.mark(1);
+ try {
+ return isEof(is.read(bytes));
+ } finally {
+ is.reset();
+ }
+ }
+
+ if (!(is instanceof PushbackInputStream)) {
+ return false;
+ }
+
+ // it may be an attachment stream
+ PushbackInputStream pbStream = (PushbackInputStream)is;
+ boolean isEmpty = isEof(pbStream.read(bytes));
+ if (!isEmpty) {
+ pbStream.unread(bytes);
+ }
+
+ return isEmpty;
+ }
+ private static boolean isEof(int result) {
+ return result == -1;
+ }
+ /**
+ * Use this function instead of new String(byte[], String) to avoid surprises from
+ * non-standard default encodings.
+ * @param bytes
+ * @param charsetName
+ */
+ public static String newStringFromBytes(byte[] bytes, String charsetName) {
+ try {
+ return new String(bytes, charsetName);
+ } catch (UnsupportedEncodingException e) {
+ throw
+ new RuntimeException("Impossible failure: Charset.forName(\""
+ + charsetName + "\") returns invalid name.");
+
+ }
+ }
+
+
+ /**
+ * Use this function instead of new String(byte[]) to avoid surprises from non-standard default encodings.
+ * @param bytes
+ */
+ public static String newStringFromBytes(byte[] bytes) {
+ return newStringFromBytes(bytes, UTF8_CHARSET.name());
+ }
+
+ /**
+ * Use this function instead of new String(byte[], int, int, String)
+ * to avoid surprises from non-standard default encodings.
+ * @param bytes
+ * @param charsetName
+ * @param start
+ * @param length
+ */
+ public static String newStringFromBytes(byte[] bytes, String charsetName, int start, int length) {
+ try {
+ return new String(bytes, start, length, charsetName);
+ } catch (UnsupportedEncodingException e) {
+ throw
+ new RuntimeException("Impossible failure: Charset.forName(\""
+ + charsetName + "\") returns invalid name.");
+
+ }
+ }
+
+ /**
+ * Use this function instead of new String(byte[], int, int)
+ * to avoid surprises from non-standard default encodings.
+ * @param bytes
+ * @param start
+ * @param length
+ */
+ public static String newStringFromBytes(byte[] bytes, int start, int length) {
+ return newStringFromBytes(bytes, UTF8_CHARSET.name(), start, length);
+ }
+
+ public static int copy(final InputStream input, final OutputStream output)
+ throws IOException {
+ if (input == null) {
+ return 0;
+ }
+ if (output instanceof CopyingOutputStream) {
+ return ((CopyingOutputStream)output).copyFrom(input);
+ }
+ return copy(input, output, DEFAULT_BUFFER_SIZE);
+ }
+
+ public static int copyAndCloseInput(final InputStream input,
+ final OutputStream output) throws IOException {
+ try (InputStream in = input) {
+ return copy(in, output);
+ }
+ }
+
+ public static int copyAndCloseInput(final InputStream input,
+ final OutputStream output, int bufferSize) throws IOException {
+ try (InputStream in = input) {
+ return copy(in, output, bufferSize);
+ }
+ }
+
+ public static void copyAndCloseInput(final Reader input,
+ final Writer output) throws IOException {
+ try (Reader r = input) {
+ copy(r, output, DEFAULT_BUFFER_SIZE);
+ }
+ }
+
+ public static void copyAndCloseInput(final Reader input,
+ final Writer output, int bufferSize) throws IOException {
+ try (Reader r = input) {
+ copy(r, output, bufferSize);
+ }
+ }
+
+ public static int copy(final InputStream input, final OutputStream output,
+ int bufferSize) throws IOException {
+ int avail = input.available();
+ if (avail > 262144) {
+ avail = 262144;
+ }
+ if (avail > bufferSize) {
+ bufferSize = avail;
+ }
+ final byte[] buffer = new byte[bufferSize];
+ int n = input.read(buffer);
+ int total = 0;
+ while (-1 != n) {
+ if (n == 0) {
+ throw new IOException("0 bytes read in violation of InputStream.read(byte[])");
+ }
+ output.write(buffer, 0, n);
+ total += n;
+ n = input.read(buffer);
+ }
+ return total;
+ }
+
+ /**
+ * Copy at least the specified number of bytes from the input to the output
+ * or until the inputstream is finished.
+ * @param input
+ * @param output
+ * @param atLeast
+ * @throws IOException
+ */
+ public static void copyAtLeast(final InputStream input,
+ final OutputStream output,
+ int atLeast) throws IOException {
+ final byte[] buffer = new byte[4096];
+ int n = atLeast > buffer.length ? buffer.length : atLeast;
+ n = input.read(buffer, 0, n);
+ while (-1 != n) {
+ if (n == 0) {
+ throw new IOException("0 bytes read in violation of InputStream.read(byte[])");
+ }
+ output.write(buffer, 0, n);
+ atLeast -= n;
+ if (atLeast <= 0) {
+ return;
+ }
+ n = atLeast > buffer.length ? buffer.length : atLeast;
+ n = input.read(buffer, 0, n);
+ }
+ }
+
+ public static void copyAtLeast(final Reader input,
+ final Writer output,
+ int atLeast) throws IOException {
+ final char[] buffer = new char[4096];
+ int n = atLeast > buffer.length ? buffer.length : atLeast;
+ n = input.read(buffer, 0, n);
+ while (-1 != n) {
+ if (n == 0) {
+ throw new IOException("0 bytes read in violation of Reader.read(char[])");
+ }
+ output.write(buffer, 0, n);
+ atLeast -= n;
+ if (atLeast <= 0) {
+ return;
+ }
+ n = atLeast > buffer.length ? buffer.length : atLeast;
+ n = input.read(buffer, 0, n);
+ }
+ }
+
+
+ public static void copy(final Reader input, final Writer output,
+ final int bufferSize) throws IOException {
+ final char[] buffer = new char[bufferSize];
+ int n = input.read(buffer);
+ while (-1 != n) {
+ output.write(buffer, 0, n);
+ n = input.read(buffer);
+ }
+ }
+
+ public static void transferTo(InputStream inputStream, File destinationFile) throws IOException {
+ if (Transferable.class.isAssignableFrom(inputStream.getClass())) {
+ ((Transferable)inputStream).transferTo(destinationFile);
+ } else {
+ try (OutputStream out = Files.newOutputStream(destinationFile.toPath())) {
+ copyAndCloseInput(inputStream, out);
+ }
+ }
+ }
+
+
+ public static String toString(final InputStream input) throws IOException {
+ return toString(input, DEFAULT_BUFFER_SIZE);
+ }
+ public static String toString(final InputStream input, String charset) throws IOException {
+ return toString(input, DEFAULT_BUFFER_SIZE, charset);
+ }
+ public static String toString(final InputStream input, int bufferSize)
+ throws IOException {
+ return toString(input, bufferSize, null);
+ }
+ public static String toString(final InputStream input, int bufferSize, String charset)
+ throws IOException {
+
+
+ int avail = input.available();
+ if (avail > bufferSize) {
+ bufferSize = avail;
+ }
+ Reader reader = charset == null ? new InputStreamReader(input, UTF8_CHARSET)
+ : new InputStreamReader(input, charset);
+ return toString(reader, bufferSize);
+ }
+
+ public static String toString(final Reader input) throws IOException {
+ return toString(input, DEFAULT_BUFFER_SIZE);
+ }
+ public static String toString(final Reader input, int bufSize) throws IOException {
+
+ StringBuilder buf = new StringBuilder();
+ final char[] buffer = new char[bufSize];
+ try (Reader r = input) {
+ int n = r.read(buffer);
+ while (-1 != n) {
+ if (n == 0) {
+ throw new IOException("0 bytes read in violation of InputStream.read(byte[])");
+ }
+ buf.append(buffer, 0, n);
+ n = r.read(buffer);
+ }
+ return buf.toString();
+ }
+ }
+
+ public static String readStringFromStream(InputStream in)
+ throws IOException {
+ return toString(in);
+ }
+
+ /**
+ * Load the InputStream into memory and return a ByteArrayInputStream that
+ * represents it. Closes the in stream.
+ *
+ * @param in
+ * @throws IOException
+ */
+ public static ByteArrayInputStream loadIntoBAIS(InputStream in)
+ throws IOException {
+ int i = in.available();
+ if (i < DEFAULT_BUFFER_SIZE) {
+ i = DEFAULT_BUFFER_SIZE;
+ }
+ LoadingByteArrayOutputStream bout = new LoadingByteArrayOutputStream(i);
+ copy(in, bout);
+ in.close();
+ return bout.createInputStream();
+ }
+
+ public static void consume(InputStream in) throws IOException {
+ int i = in.available();
+ if (i == 0) {
+ //if i is 0, then we MAY have already hit the end of the stream
+ //so try a read and return rather than allocate a buffer and such
+ int i2 = in.read();
+ if (i2 == -1) {
+ return;
+ }
+ //reading the byte may have caused a buffer to fill
+ i = in.available();
+ }
+ if (i < DEFAULT_BUFFER_SIZE) {
+ i = DEFAULT_BUFFER_SIZE;
+ }
+ if (i > 65536) {
+ i = 65536;
+ }
+ byte[] bytes = new byte[i];
+ while (in.read(bytes) != -1) {
+ //nothing - just discarding
+ }
+ }
+
+ /**
+ * Consumes at least the given number of bytes from the input stream
+ * @param input
+ * @param atLeast
+ * @throws IOException
+ */
+ public static void consume(final InputStream input,
+ int atLeast) throws IOException {
+ final byte[] buffer = new byte[4096];
+ int n = atLeast > buffer.length ? buffer.length : atLeast;
+ n = input.read(buffer, 0, n);
+ while (-1 != n) {
+ if (n == 0) {
+ throw new IOException("0 bytes read in violation of InputStream.read(byte[])");
+ }
+ atLeast -= n;
+ if (atLeast <= 0) {
+ return;
+ }
+ n = atLeast > buffer.length ? buffer.length : atLeast;
+ n = input.read(buffer, 0, n);
+ }
+ }
+
+ public static byte[] readBytesFromStream(InputStream in) throws IOException {
+ int i = in.available();
+ if (i < DEFAULT_BUFFER_SIZE) {
+ i = DEFAULT_BUFFER_SIZE;
+ }
+ try (InputStream input = in; ByteArrayOutputStream bos = new ByteArrayOutputStream(i)) {
+ copy(input, bos);
+ return bos.toByteArray();
+ }
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/helpers/ServiceUtils.java b/transform/src/patch/java/org/apache/cxf/helpers/ServiceUtils.java
new file mode 100644
index 0000000..a39ee94
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/helpers/ServiceUtils.java
@@ -0,0 +1,214 @@
+/**
+ * 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.cxf.helpers;
+
+import java.util.StringTokenizer;
+
+import org.apache.cxf.annotations.SchemaValidation.SchemaValidationType;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+import org.apache.cxf.service.model.AbstractPropertiesHolder;
+import org.apache.cxf.service.model.BindingOperationInfo;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.service.model.OperationInfo;
+
+public final class ServiceUtils {
+
+ private ServiceUtils() {
+ }
+
+ /**
+ * A short cut method to be able to test for if Schema Validation should be enabled
+ * for IN or OUT without having to check BOTH and IN or OUT.
+ *
+ * @param message
+ * @param type
+ */
+ public static boolean isSchemaValidationEnabled(SchemaValidationType type, Message message) {
+ SchemaValidationType validationType = getSchemaValidationType(message);
+
+ boolean isRequestor = MessageUtils.isRequestor(message);
+ if (SchemaValidationType.REQUEST.equals(validationType)) {
+ if (isRequestor) {
+ validationType = SchemaValidationType.OUT;
+ } else {
+ validationType = SchemaValidationType.IN;
+ }
+ } else if (SchemaValidationType.RESPONSE.equals(validationType)) {
+ if (isRequestor) {
+ validationType = SchemaValidationType.IN;
+ } else {
+ validationType = SchemaValidationType.OUT;
+ }
+ }
+
+ return validationType.equals(type)
+ || ((SchemaValidationType.IN.equals(type) || SchemaValidationType.OUT.equals(type))
+ && SchemaValidationType.BOTH.equals(validationType));
+ }
+ /**
+ * A convenience method to check for schema validation config in the message context, and then in the service model.
+ * Does not modify the Message context (other than what is done in the getContextualProperty itself)
+ *
+ * @param message
+ */
+ public static SchemaValidationType getSchemaValidationType(Message message) {
+ SchemaValidationType validationType = getOverrideSchemaValidationType(message);
+ if (validationType == null) {
+ validationType = getSchemaValidationTypeFromModel(message);
+ }
+ if (validationType == null) {
+ Object obj = message.getContextualProperty(Message.SCHEMA_VALIDATION_ENABLED);
+ if (obj != null) {
+ validationType = getSchemaValidationType(obj);
+ }
+ }
+ if (validationType == null) {
+ validationType = SchemaValidationType.NONE;
+ }
+
+ return validationType;
+ }
+
+ private static SchemaValidationType getOverrideSchemaValidationType(Message message) {
+ Object obj = message.get(Message.SCHEMA_VALIDATION_ENABLED);
+ if (obj == null && message.getExchange() != null) {
+ obj = message.getExchange().get(Message.SCHEMA_VALIDATION_ENABLED);
+ }
+ if (obj != null) {
+ // this method will transform the legacy enabled as well
+ return getSchemaValidationType(obj);
+ }
+ return null;
+ }
+
+ private static SchemaValidationType getSchemaValidationTypeFromModel(Message message) {
+ Exchange exchange = message.getExchange();
+ SchemaValidationType validationType = null;
+
+ if (exchange != null) {
+
+ BindingOperationInfo boi = exchange.getBindingOperationInfo();
+ if (boi != null) {
+ OperationInfo opInfo = boi.getOperationInfo();
+ if (opInfo != null) {
+ validationType = getSchemaValidationTypeFromModel(opInfo);
+ }
+ }
+
+ if (validationType == null) {
+ Endpoint endpoint = exchange.getEndpoint();
+ if (endpoint != null) {
+ EndpointInfo ep = endpoint.getEndpointInfo();
+ if (ep != null) {
+ validationType = getSchemaValidationTypeFromModel(ep);
+ }
+ }
+ }
+ }
+
+ return validationType;
+ }
+
+ private static SchemaValidationType getSchemaValidationTypeFromModel(
+ AbstractPropertiesHolder properties) {
+ Object obj = properties.getProperty(Message.SCHEMA_VALIDATION_TYPE);
+ if (obj != null) {
+ return getSchemaValidationType(obj);
+ }
+ return null;
+ }
+
+ public static SchemaValidationType getSchemaValidationType(Object obj) {
+ if (obj instanceof SchemaValidationType) {
+ return (SchemaValidationType)obj;
+ } else if (obj != null) {
+ String value = obj.toString().toUpperCase(); // handle boolean values as well
+ if ("TRUE".equals(value)) {
+ return SchemaValidationType.BOTH;
+ } else if ("FALSE".equals(value)) {
+ return SchemaValidationType.NONE;
+ } else if (value.length() > 0) {
+ return SchemaValidationType.valueOf(value);
+ }
+ }
+
+ // fall through default value
+ return SchemaValidationType.NONE;
+ }
+
+ /**
+ * Generates a suitable service name from a given class. The returned name
+ * is the simple name of the class, i.e. without the package name.
+ *
+ * @param clazz the class.
+ * @return the name.
+ */
+ public static String makeServiceNameFromClassName(Class<?> clazz) {
+ String name = clazz.getName();
+ int last = name.lastIndexOf('.');
+ if (last != -1) {
+ name = name.substring(last + 1);
+ }
+
+ int inner = name.lastIndexOf('$');
+ if (inner != -1) {
+ name = name.substring(inner + 1);
+ }
+
+ return name;
+ }
+
+ /**
+ * Generates the name of a XML namespace from a given class name and
+ * protocol. The returned namespace will take the form
+ * <code>protocol://domain</code>, where <code>protocol</code> is the
+ * given protocol, and <code>domain</code> the inversed package name of
+ * the given class name. <p/> For instance, if the given class name is
+ * <code>org.codehaus.xfire.services.Echo</code>, and the protocol is
+ * <code>http</code>, the resulting namespace would be
+ * <code>http://services.xfire.codehaus.org</code>.
+ *
+ * @param className the class name
+ * @param protocol the protocol (eg. <code>http</code>)
+ * @return the namespace
+ */
+ public static String makeNamespaceFromClassName(String className, String protocol) {
+ int index = className.lastIndexOf('.');
+
+ if (index == -1) {
+ return protocol + "://" + "DefaultNamespace";
+ }
+
+ String packageName = className.substring(0, index);
+
+ StringTokenizer st = new StringTokenizer(packageName, ".");
+ String[] words = new String[st.countTokens()];
+
+ for (int i = words.length - 1; i >= 0; --i) {
+ words[i] = st.nextToken();
+ }
+
+ return protocol + "://" + String.join(".", words) + "/";
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/AbstractFaultChainInitiatorObserver.java b/transform/src/patch/java/org/apache/cxf/interceptor/AbstractFaultChainInitiatorObserver.java
new file mode 100644
index 0000000..70d5ae0
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/AbstractFaultChainInitiatorObserver.java
@@ -0,0 +1,142 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.util.SortedSet;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.classloader.ClassLoaderUtils.ClassLoaderHolder;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.FaultMode;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageImpl;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+import org.apache.cxf.service.model.BindingFaultInfo;
+import org.apache.cxf.transport.MessageObserver;
+
+public abstract class AbstractFaultChainInitiatorObserver implements MessageObserver {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(AbstractFaultChainInitiatorObserver.class);
+
+ private Bus bus;
+ private ClassLoader loader;
+
+ public AbstractFaultChainInitiatorObserver(Bus bus) {
+ this.bus = bus;
+ if (bus != null) {
+ loader = bus.getExtension(ClassLoader.class);
+ }
+ }
+
+ public void onMessage(Message message) {
+
+ assert null != message;
+
+ Bus origBus = BusFactory.getAndSetThreadDefaultBus(bus);
+ ClassLoaderHolder origLoader = null;
+ try {
+ if (loader != null) {
+ origLoader = ClassLoaderUtils.setThreadContextClassloader(loader);
+ }
+
+ Exchange exchange = message.getExchange();
+
+ Message faultMessage;
+
+ // now that we have switched over to the fault chain,
+ // prevent any further operations on the in/out message
+
+ if (isOutboundObserver()) {
+ Exception ex = message.getContent(Exception.class);
+ if (!(ex instanceof Fault)) {
+ ex = new Fault(ex);
+ }
+ FaultMode mode = message.get(FaultMode.class);
+
+ faultMessage = exchange.getOutMessage();
+ if (null == faultMessage) {
+ faultMessage = new MessageImpl();
+ faultMessage.setExchange(exchange);
+ faultMessage = exchange.getEndpoint().getBinding().createMessage(faultMessage);
+ }
+ faultMessage.setContent(Exception.class, ex);
+ if (null != mode) {
+ faultMessage.put(FaultMode.class, mode);
+ }
+ //CXF-3981
+ if (message.get("javax.xml.ws.addressing.context.inbound") != null) {
+ faultMessage.put("javax.xml.ws.addressing.context.inbound",
+ message.get("javax.xml.ws.addressing.context.inbound"));
+ }
+ exchange.setOutMessage(null);
+ exchange.setOutFaultMessage(faultMessage);
+ if (message.get(BindingFaultInfo.class) != null) {
+ faultMessage.put(BindingFaultInfo.class, message.get(BindingFaultInfo.class));
+ }
+ } else {
+ faultMessage = message;
+ exchange.setInMessage(null);
+ exchange.setInFaultMessage(faultMessage);
+ }
+
+
+ // setup chain
+ PhaseInterceptorChain chain = new PhaseInterceptorChain(getPhases());
+ initializeInterceptors(faultMessage.getExchange(), chain);
+
+ faultMessage.setInterceptorChain(chain);
+ try {
+ chain.doIntercept(faultMessage);
+ } catch (RuntimeException exc) {
+ LOG.log(Level.SEVERE, "ERROR_DURING_ERROR_PROCESSING", exc);
+ throw exc;
+ } catch (Exception exc) {
+ LOG.log(Level.SEVERE, "ERROR_DURING_ERROR_PROCESSING", exc);
+ throw new RuntimeException(exc);
+ }
+ } finally {
+ if (origBus != bus) {
+ BusFactory.setThreadDefaultBus(origBus);
+ }
+ if (origLoader != null) {
+ origLoader.reset();
+ }
+ }
+ }
+
+ protected abstract boolean isOutboundObserver();
+
+ protected abstract SortedSet<Phase> getPhases();
+
+ protected void initializeInterceptors(Exchange ex, PhaseInterceptorChain chain) {
+
+ }
+
+ public Bus getBus() {
+ return bus;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/AbstractLoggingInterceptor.java b/transform/src/patch/java/org/apache/cxf/interceptor/AbstractLoggingInterceptor.java
new file mode 100644
index 0000000..5178453
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/AbstractLoggingInterceptor.java
@@ -0,0 +1,298 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.service.model.InterfaceInfo;
+import org.apache.cxf.staxutils.PrettyPrintXMLStreamWriter;
+import org.apache.cxf.staxutils.StaxUtils;
+
+/**
+ * A simple logging handler which outputs the bytes of the message to the
+ * Logger.
+ * @deprecated
+ */
+@Deprecated
+public abstract class AbstractLoggingInterceptor extends AbstractPhaseInterceptor<Message> {
+ public static final int DEFAULT_LIMIT = 48 * 1024;
+ protected static final String BINARY_CONTENT_MESSAGE = "--- Binary Content ---";
+ protected static final String MULTIPART_CONTENT_MESSAGE = "--- Multipart Content ---";
+ private static final String MULTIPART_CONTENT_MEDIA_TYPE = "multipart";
+ private static final String LIVE_LOGGING_PROP = "org.apache.cxf.logging.enable";
+ private static final List<String> BINARY_CONTENT_MEDIA_TYPES = Arrays.asList(
+ "application/octet-stream", "application/pdf", "image/png", "image/jpeg", "image/gif");
+
+ protected int limit = DEFAULT_LIMIT;
+ protected long threshold = -1;
+ protected PrintWriter writer;
+ protected boolean prettyLogging;
+ private boolean showBinaryContent;
+ private boolean showMultipartContent = true;
+ private List<String> binaryContentMediaTypes = BINARY_CONTENT_MEDIA_TYPES;
+
+ public AbstractLoggingInterceptor(String phase) {
+ super(phase);
+ }
+ public AbstractLoggingInterceptor(String id, String phase) {
+ super(id, phase);
+ }
+
+ protected static boolean isLoggingDisabledNow(Message message) {
+ Object liveLoggingProp = message.getContextualProperty(LIVE_LOGGING_PROP);
+ return liveLoggingProp != null && PropertyUtils.isFalse(liveLoggingProp);
+ }
+
+ protected abstract Logger getLogger();
+
+ Logger getMessageLogger(Message message) {
+ if (isLoggingDisabledNow(message)) {
+ return null;
+ }
+ Endpoint ep = message.getExchange().getEndpoint();
+ if (ep == null || ep.getEndpointInfo() == null) {
+ return getLogger();
+ }
+ EndpointInfo endpoint = ep.getEndpointInfo();
+ if (endpoint.getService() == null) {
+ return getLogger();
+ }
+ Logger logger = endpoint.getProperty("MessageLogger", Logger.class);
+ if (logger == null) {
+ String serviceName = endpoint.getService().getName().getLocalPart();
+ InterfaceInfo iface = endpoint.getService().getInterface();
+ String portName = endpoint.getName().getLocalPart();
+ String portTypeName = iface.getName().getLocalPart();
+ String logName = "org.apache.cxf.services." + serviceName + "."
+ + portName + "." + portTypeName;
+ logger = LogUtils.getL7dLogger(this.getClass(), null, logName);
+ endpoint.setProperty("MessageLogger", logger);
+ }
+ return logger;
+ }
+
+ public void setOutputLocation(String s) {
+ if (s == null || "<logger>".equals(s)) {
+ writer = null;
+ } else if ("<stdout>".equals(s)) {
+ writer = new PrintWriter(System.out, true);
+ } else if ("<stderr>".equals(s)) {
+ writer = new PrintWriter(System.err, true);
+ } else {
+ try {
+ URI uri = new URI(s);
+ File file = new File(uri);
+ writer = new PrintWriter(new FileWriter(file, true), true);
+ } catch (Exception ex) {
+ getLogger().log(Level.WARNING, "Error configuring log location " + s, ex);
+ }
+ }
+ }
+
+ public void setPrintWriter(PrintWriter w) {
+ writer = w;
+ }
+
+ public PrintWriter getPrintWriter() {
+ return writer;
+ }
+
+ public void setLimit(int lim) {
+ limit = lim;
+ }
+
+ public int getLimit() {
+ return limit;
+ }
+
+ public void setPrettyLogging(boolean flag) {
+ prettyLogging = flag;
+ }
+
+ public boolean isPrettyLogging() {
+ return prettyLogging;
+ }
+
+ public void setInMemThreshold(long t) {
+ threshold = t;
+ }
+
+ public long getInMemThreshold() {
+ return threshold;
+ }
+
+ protected void writePayload(StringBuilder builder, CachedOutputStream cos,
+ String encoding, String contentType, boolean truncated)
+ throws Exception {
+ // Just transform the XML message when the cos has content
+ if (!truncated && isPrettyLogging() && contentType != null && contentType.contains("xml")
+ && !contentType.toLowerCase().contains("multipart/related") && cos.size() > 0) {
+
+ StringWriter swriter = new StringWriter();
+ XMLStreamWriter xwriter = StaxUtils.createXMLStreamWriter(swriter);
+ xwriter = new PrettyPrintXMLStreamWriter(xwriter, 2);
+ try (InputStream in = cos.getInputStream()) {
+ InputStreamReader inputStreamReader = StringUtils.isEmpty(encoding)
+ ? new InputStreamReader(in) : new InputStreamReader(in, encoding);
+ StaxUtils.copy(new StreamSource(inputStreamReader), xwriter);
+ } catch (XMLStreamException xse) {
+ //ignore
+ } finally {
+ try {
+ xwriter.flush();
+ xwriter.close();
+ } catch (XMLStreamException xse2) {
+ //ignore
+ }
+ }
+
+ String result = swriter.toString();
+ if (result.length() < limit || limit == -1) {
+ builder.append(result);
+ } else {
+ builder.append(result.substring(0, limit));
+ }
+
+ } else {
+ if (StringUtils.isEmpty(encoding)) {
+ cos.writeCacheTo(builder, limit);
+ } else {
+ cos.writeCacheTo(builder, encoding, limit);
+ }
+ }
+ }
+ protected void writePayload(StringBuilder builder,
+ StringWriter stringWriter,
+ String contentType)
+ throws Exception {
+ if (isPrettyLogging()
+ && contentType != null
+ && contentType.contains("xml")
+ && stringWriter.getBuffer().length() > 0) {
+ try {
+ writePrettyPayload(builder, stringWriter, contentType);
+ return;
+ } catch (Exception ex) {
+ // log it as is
+ }
+ }
+ StringBuffer buffer = stringWriter.getBuffer();
+ if (buffer.length() > limit) {
+ builder.append(buffer.subSequence(0, limit));
+ } else {
+ builder.append(buffer);
+ }
+ }
+ protected void writePrettyPayload(StringBuilder builder,
+ StringWriter stringWriter,
+ String contentType)
+ throws Exception {
+ // Just transform the XML message when the cos has content
+
+ StringWriter swriter = new StringWriter();
+ XMLStreamWriter xwriter = StaxUtils.createXMLStreamWriter(swriter);
+ xwriter = new PrettyPrintXMLStreamWriter(xwriter, 2);
+ StaxUtils.copy(new StreamSource(new StringReader(stringWriter.getBuffer().toString())), xwriter);
+ xwriter.close();
+
+ String result = swriter.toString();
+ if (result.length() < limit || limit == -1) {
+ builder.append(swriter.toString());
+ } else {
+ builder.append(swriter.toString().substring(0, limit));
+ }
+ }
+
+
+ /**
+ * Transform the string before display. The implementation in this class
+ * does nothing. Override this method if you wish to change the contents of the
+ * logged message before it is delivered to the output.
+ * For example, you can use this to mask out sensitive information.
+ * @param originalLogString the raw log message.
+ * @return transformed data
+ */
+ protected String transform(String originalLogString) {
+ return originalLogString;
+ }
+
+ protected void log(Logger logger, String message) {
+ message = transform(message);
+ if (writer != null) {
+ writer.println(message);
+ // Flushing the writer to make sure the message is written
+ writer.flush();
+ } else if (logger.isLoggable(Level.INFO)) {
+ LogRecord lr = new LogRecord(Level.INFO, message);
+ lr.setSourceClassName(logger.getName());
+ lr.setSourceMethodName(null);
+ lr.setLoggerName(logger.getName());
+ logger.log(lr);
+ }
+ }
+ public void setShowBinaryContent(boolean showBinaryContent) {
+ this.showBinaryContent = showBinaryContent;
+ }
+ public boolean isShowBinaryContent() {
+ return showBinaryContent;
+ }
+ protected boolean isBinaryContent(String contentType) {
+ return contentType != null && binaryContentMediaTypes.contains(contentType);
+ }
+ public boolean isShowMultipartContent() {
+ return showMultipartContent;
+ }
+ public void setShowMultipartContent(boolean showMultipartContent) {
+ this.showMultipartContent = showMultipartContent;
+ }
+ protected boolean isMultipartContent(String contentType) {
+ return contentType != null && contentType.startsWith(MULTIPART_CONTENT_MEDIA_TYPE);
+ }
+ public List<String> getBinaryContentMediaTypes() {
+ return binaryContentMediaTypes;
+ }
+ public void setBinaryContentMediaTypes(List<String> binaryContentMediaTypes) {
+ this.binaryContentMediaTypes = binaryContentMediaTypes;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/AnnotationInterceptors.java b/transform/src/patch/java/org/apache/cxf/interceptor/AnnotationInterceptors.java
new file mode 100644
index 0000000..8cc757e
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/AnnotationInterceptors.java
@@ -0,0 +1,151 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ResourceBundle;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.feature.Feature;
+import org.apache.cxf.feature.Features;
+import org.apache.cxf.message.Message;
+
+public class AnnotationInterceptors {
+
+ private static final ResourceBundle BUNDLE = BundleUtils.getBundle(AnnotationInterceptors.class);
+
+ private Class<?>[] clazzes;
+
+ public AnnotationInterceptors(Class<?> ... clz) {
+ clazzes = clz;
+ }
+
+ private <T> List<T> getAnnotationObject(Class<? extends Annotation> annotationClazz, Class<T> type) {
+
+ for (Class<?> cls : clazzes) {
+ Annotation annotation = cls.getAnnotation(annotationClazz);
+ if (annotation != null) {
+ return initializeAnnotationObjects(annotation, type);
+ }
+ }
+ return null;
+ }
+
+ private <T> List<T> initializeAnnotationObjects(Annotation annotation,
+ Class<T> type) {
+ List<T> list = new ArrayList<>();
+ for (String cn : getAnnotationObjectNames(annotation)) {
+ list.add(initializeAnnotationObject(cn, type));
+ }
+ for (Class<? extends T> cn : getAnnotationObjectClasses(annotation, type)) {
+ list.add(initializeAnnotationObject(cn));
+ }
+ return list;
+ }
+
+ @SuppressWarnings("unchecked")
+ private <T> Class<? extends T>[] getAnnotationObjectClasses(Annotation ann, Class<T> type) { //NOPMD
+ if (ann instanceof InFaultInterceptors) {
+ return (Class<? extends T>[])((InFaultInterceptors)ann).classes();
+ } else if (ann instanceof InInterceptors) {
+ return (Class<? extends T>[])((InInterceptors)ann).classes();
+ } else if (ann instanceof OutFaultInterceptors) {
+ return (Class<? extends T>[])((OutFaultInterceptors)ann).classes();
+ } else if (ann instanceof OutInterceptors) {
+ return (Class<? extends T>[])((OutInterceptors)ann).classes();
+ } else if (ann instanceof Features) {
+ return (Class<? extends T>[])((Features)ann).classes();
+ }
+ throw new UnsupportedOperationException("Doesn't support the annotation: " + ann);
+ }
+
+ private String[] getAnnotationObjectNames(Annotation ann) {
+ if (ann instanceof InFaultInterceptors) {
+ return ((InFaultInterceptors)ann).interceptors();
+ } else if (ann instanceof InInterceptors) {
+ return ((InInterceptors)ann).interceptors();
+ } else if (ann instanceof OutFaultInterceptors) {
+ return ((OutFaultInterceptors)ann).interceptors();
+ } else if (ann instanceof OutInterceptors) {
+ return ((OutInterceptors)ann).interceptors();
+ } else if (ann instanceof Features) {
+ return ((Features)ann).features();
+ }
+
+ throw new UnsupportedOperationException("Doesn't support the annotation: " + ann);
+ }
+
+ private <T> T initializeAnnotationObject(String annObjectName, Class<T> type) {
+ try {
+ final Object object = ClassLoaderUtils.loadClass(annObjectName, this.getClass()).newInstance();
+ return type.cast(object);
+ } catch (Throwable e) {
+ throw new Fault(new org.apache.cxf.common.i18n.Message(
+ "COULD_NOT_CREATE_ANNOTATION_OBJECT",
+ BUNDLE, annObjectName), e);
+ }
+ }
+ private <T> T initializeAnnotationObject(Class<T> type) {
+ try {
+ return type.cast(type.newInstance());
+ } catch (Throwable e) {
+ throw new Fault(new org.apache.cxf.common.i18n.Message(
+ "COULD_NOT_CREATE_ANNOTATION_OBJECT",
+ BUNDLE, type.getName()), e);
+ }
+ }
+
+ private List<Interceptor<? extends Message>> getAnnotationInterceptorList(Class<? extends Annotation> t) {
+ @SuppressWarnings("rawtypes")
+ List<Interceptor> i = getAnnotationObject(t, Interceptor.class);
+ if (i == null) {
+ return null;
+ }
+ List<Interceptor<? extends Message>> m = new ArrayList<>();
+ for (Interceptor<?> i2 : i) {
+ m.add(i2);
+ }
+ return m;
+ }
+
+ public List<Interceptor<? extends Message>> getInFaultInterceptors() {
+ return getAnnotationInterceptorList(InFaultInterceptors.class);
+ }
+
+ public List<Interceptor<? extends Message>> getInInterceptors() {
+ return getAnnotationInterceptorList(InInterceptors.class);
+ }
+
+ public List<Interceptor<? extends Message>> getOutFaultInterceptors() {
+ return getAnnotationInterceptorList(OutFaultInterceptors.class);
+ }
+
+ public List<Interceptor<? extends Message>> getOutInterceptors() {
+ return getAnnotationInterceptorList(OutInterceptors.class);
+ }
+
+ public List<Feature> getFeatures() {
+ return getAnnotationObject(Features.class, Feature.class);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/AttachmentInInterceptor.java b/transform/src/patch/java/org/apache/cxf/interceptor/AttachmentInInterceptor.java
new file mode 100644
index 0000000..0a56be1
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/AttachmentInInterceptor.java
@@ -0,0 +1,72 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.apache.cxf.attachment.AttachmentDeserializer;
+import org.apache.cxf.attachment.AttachmentUtil;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.phase.Phase;
+
+public class AttachmentInInterceptor extends AbstractPhaseInterceptor<Message> {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(AttachmentInInterceptor.class);
+
+ private static final List<String> TYPES = Collections.singletonList("multipart/related");
+
+ public AttachmentInInterceptor() {
+ super(Phase.RECEIVE);
+ }
+
+ public void handleMessage(Message message) {
+ if (isGET(message)) {
+ LOG.fine("AttachmentInInterceptor skipped in HTTP GET method");
+ return;
+ }
+ if (message.getContent(InputStream.class) == null) {
+ return;
+ }
+
+ String contentType = (String) message.get(Message.CONTENT_TYPE);
+ if (AttachmentUtil.isTypeSupported(contentType, getSupportedTypes())) {
+ AttachmentDeserializer ad = new AttachmentDeserializer(message, getSupportedTypes());
+ try {
+ ad.initializeAttachments();
+ } catch (IOException e) {
+ throw new Fault(e);
+ }
+ }
+ }
+
+ @Override
+ public void handleFault(Message messageParam) {
+ }
+
+ protected List<String> getSupportedTypes() {
+ return TYPES;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/ClientOutFaultObserver.java b/transform/src/patch/java/org/apache/cxf/interceptor/ClientOutFaultObserver.java
new file mode 100644
index 0000000..341b3b0
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/ClientOutFaultObserver.java
@@ -0,0 +1,68 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.util.Map;
+import java.util.SortedSet;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.endpoint.Client;
+import org.apache.cxf.endpoint.ClientCallback;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.phase.PhaseManager;
+
+public class ClientOutFaultObserver extends AbstractFaultChainInitiatorObserver {
+
+ public ClientOutFaultObserver(Bus bus) {
+ super(bus);
+ }
+
+ @Override
+ protected SortedSet<Phase> getPhases() {
+ return getBus().getExtension(PhaseManager.class).getOutPhases();
+ }
+
+ /**
+ * override the super class method
+ */
+ @Override
+ public void onMessage(Message m) {
+ if (m.get(Message.INBOUND_MESSAGE).equals(Boolean.TRUE)) {
+ //it's outbound fault observer so only take care of outbound fault
+ return;
+ }
+ Exception ex = m.getContent(Exception.class);
+ // remove callback so that it won't be invoked twice
+ ClientCallback callback = m.getExchange().remove(ClientCallback.class);
+
+ if (callback != null) {
+ Map<String, Object> resCtx = CastUtils.cast((Map<?, ?>) m.getExchange().getOutMessage().get(
+ Message.INVOCATION_CONTEXT));
+ resCtx = CastUtils.cast((Map<?, ?>) resCtx.get(Client.RESPONSE_CONTEXT));
+ callback.handleException(resCtx, ex);
+ }
+ }
+
+ protected boolean isOutboundObserver() {
+ return true;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/InFaultChainInitiatorObserver.java b/transform/src/patch/java/org/apache/cxf/interceptor/InFaultChainInitiatorObserver.java
new file mode 100644
index 0000000..fd35182
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/InFaultChainInitiatorObserver.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.cxf.interceptor;
+
+import java.util.Collection;
+import java.util.SortedSet;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.endpoint.Client;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+import org.apache.cxf.phase.PhaseManager;
+
+public class InFaultChainInitiatorObserver extends AbstractFaultChainInitiatorObserver {
+
+ public InFaultChainInitiatorObserver(Bus bus) {
+ super(bus);
+ }
+
+ @Override
+ protected void initializeInterceptors(Exchange ex, PhaseInterceptorChain chain) {
+ Endpoint e = ex.getEndpoint();
+ Client c = ex.get(Client.class);
+ InterceptorProvider ip = ex.get(InterceptorProvider.class);
+
+ chain.add(getBus().getInFaultInterceptors());
+ if (c != null) {
+ chain.add(c.getInFaultInterceptors());
+ } else if (ip != null) {
+ chain.add(ip.getInFaultInterceptors());
+ }
+ chain.add(e.getService().getInFaultInterceptors());
+ chain.add(e.getInFaultInterceptors());
+ chain.add(e.getBinding().getInFaultInterceptors());
+ if (e.getService().getDataBinding() instanceof InterceptorProvider) {
+ chain.add(((InterceptorProvider)e.getService().getDataBinding()).getInFaultInterceptors());
+ }
+
+ addToChain(chain, ex.getInFaultMessage());
+ addToChain(chain, ex.getOutMessage());
+ }
+ private void addToChain(PhaseInterceptorChain chain, Message m) {
+ Collection<InterceptorProvider> providers
+ = CastUtils.cast((Collection<?>)m.get(Message.INTERCEPTOR_PROVIDERS));
+ if (providers != null) {
+ for (InterceptorProvider p : providers) {
+ chain.add(p.getInFaultInterceptors());
+ }
+ }
+ Collection<Interceptor<? extends Message>> is
+ = CastUtils.cast((Collection<?>)m.get(Message.FAULT_IN_INTERCEPTORS));
+ if (is != null) {
+ chain.add(is);
+ }
+ }
+
+ protected SortedSet<Phase> getPhases() {
+ return getBus().getExtension(PhaseManager.class).getInPhases();
+ }
+
+ protected boolean isOutboundObserver() {
+ return false;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/InterceptorChain.java b/transform/src/patch/java/org/apache/cxf/interceptor/InterceptorChain.java
new file mode 100644
index 0000000..da5deba
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/InterceptorChain.java
@@ -0,0 +1,109 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.util.Collection;
+import java.util.ListIterator;
+
+import org.apache.cxf.message.Message;
+import org.apache.cxf.transport.MessageObserver;
+
+/**
+ * Base interface for all interceptor chains. An interceptor chain is an
+ * ordered list of interceptors associated with one portion of the message
+ * processing pipeline. Interceptor chains are defined for a client's request
+ * processing, response processing, and incoming SOAP fault processing. Interceptor
+ * chains are defined for a service's request processing, response processing, and
+ * outgoing SOAP fault processing.
+ */
+public interface InterceptorChain extends Iterable<Interceptor<? extends Message>> {
+
+ enum State {
+ PAUSED,
+ SUSPENDED,
+ EXECUTING,
+ COMPLETE,
+ ABORTED,
+ }
+
+ String STARTING_AFTER_INTERCEPTOR_ID = "starting_after_interceptor_id";
+ String STARTING_AT_INTERCEPTOR_ID = "starting_at_interceptor_id";
+
+ /**
+ * Adds a single interceptor to the interceptor chain.
+ *
+ * @param i the interceptor to add
+ */
+ void add(Interceptor<? extends Message> i);
+
+ /**
+ * Adds multiple interceptors to the interceptor chain.
+ * @param i the interceptors to add to the chain
+ */
+ void add(Collection<Interceptor<? extends Message>> i);
+
+ void remove(Interceptor<? extends Message> i);
+
+ boolean doIntercept(Message message);
+
+ boolean doInterceptStartingAfter(Message message, String startingAfterInterceptorID);
+
+ boolean doInterceptStartingAt(Message message, String startingAtInterceptorID);
+
+ /**
+ * Pauses the current chain. When the stack unwinds, the chain will just
+ * return from the doIntercept method normally.
+ */
+ void pause();
+
+ /**
+ * Suspends the current chain. When the stack unwinds, the chain back up
+ * the iterator by one (so on resume, the interceptor that called pause will
+ * be re-entered) and then throw a SuspendedInvocationException to the caller
+ */
+ void suspend();
+
+ /**
+ * Resumes the chain. The chain will use the current thread to continue processing
+ * the last message that was passed into doIntercept
+ */
+ void resume();
+
+ /**
+ * If the chain is marked as paused, this will JUST mark the chain as
+ * in the EXECUTING phase. This is useful if an interceptor pauses the chain,
+ * but then immediately decides it should not have done that. It can unpause
+ * the chain and return normally and the normal processing will continue.
+ */
+ void unpause();
+
+
+ void reset();
+
+ State getState();
+
+ ListIterator<Interceptor<? extends Message>> getIterator();
+
+ MessageObserver getFaultObserver();
+
+ void setFaultObserver(MessageObserver i);
+
+ void abort();
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/LoggingMessage.java b/transform/src/patch/java/org/apache/cxf/interceptor/LoggingMessage.java
new file mode 100644
index 0000000..661e3db
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/LoggingMessage.java
@@ -0,0 +1,133 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @deprecated use the logging module rt/features/logging instead
+ */
+@Deprecated
+public final class LoggingMessage {
+ public static final String ID_KEY = LoggingMessage.class.getName() + ".ID";
+ private static final AtomicInteger ID = new AtomicInteger();
+
+ private final String heading;
+ private final StringBuilder address;
+ private final StringBuilder contentType;
+ private final StringBuilder encoding;
+ private final StringBuilder httpMethod;
+ private final StringBuilder header;
+ private final StringBuilder message;
+ private final StringBuilder payload;
+ private final StringBuilder responseCode;
+ private final String id;
+
+
+ public LoggingMessage(String h, String i) {
+ heading = h;
+ id = i;
+
+ contentType = new StringBuilder();
+ address = new StringBuilder();
+ encoding = new StringBuilder();
+ httpMethod = new StringBuilder();
+ header = new StringBuilder();
+ message = new StringBuilder();
+ payload = new StringBuilder();
+ responseCode = new StringBuilder();
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public static String nextId() {
+ return Integer.toString(ID.incrementAndGet());
+ }
+
+
+ public StringBuilder getAddress() {
+ return address;
+ }
+
+ public StringBuilder getEncoding() {
+ return encoding;
+ }
+
+ public StringBuilder getHeader() {
+ return header;
+ }
+
+ public StringBuilder getHttpMethod() {
+ return httpMethod;
+ }
+
+ public StringBuilder getContentType() {
+ return contentType;
+ }
+
+ public StringBuilder getMessage() {
+ return message;
+ }
+
+ public StringBuilder getPayload() {
+ return payload;
+ }
+
+ public StringBuilder getResponseCode() {
+ return responseCode;
+ }
+
+ public String toString() {
+ StringBuilder buffer = new StringBuilder(128);
+ buffer.append(heading);
+ buffer.append("\nID: ").append(id);
+ if (address.length() > 0) {
+ buffer.append("\nAddress: ");
+ buffer.append(address);
+ }
+ if (responseCode.length() > 0) {
+ buffer.append("\nResponse-Code: ");
+ buffer.append(responseCode);
+ }
+ if (encoding.length() > 0) {
+ buffer.append("\nEncoding: ");
+ buffer.append(encoding);
+ }
+ if (httpMethod.length() > 0) {
+ buffer.append("\nHttp-Method: ");
+ buffer.append(httpMethod);
+ }
+ buffer.append("\nContent-Type: ");
+ buffer.append(contentType);
+ buffer.append("\nHeaders: ");
+ buffer.append(header);
+ if (message.length() > 0) {
+ buffer.append("\nMessages: ");
+ buffer.append(message);
+ }
+ if (payload.length() > 0) {
+ buffer.append("\nPayload: ");
+ buffer.append(payload);
+ }
+ buffer.append("\n--------------------------------------");
+ return buffer.toString();
+ }
+}
\ No newline at end of file
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/OneWayProcessorInterceptor.java b/transform/src/patch/java/org/apache/cxf/interceptor/OneWayProcessorInterceptor.java
new file mode 100644
index 0000000..b140601
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/OneWayProcessorInterceptor.java
@@ -0,0 +1,177 @@
+/**
+ * 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.cxf.interceptor;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.Executor;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.logging.Logger;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.io.DelegatingInputStream;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageImpl;
+import org.apache.cxf.message.MessageUtils;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.transport.Conduit;
+import org.apache.cxf.workqueue.WorkQueueManager;
+
+
+/**
+ *
+ */
+public class OneWayProcessorInterceptor extends AbstractPhaseInterceptor<Message> {
+ public static final String USE_ORIGINAL_THREAD
+ = OneWayProcessorInterceptor.class.getName() + ".USE_ORIGINAL_THREAD";
+ private static final Logger LOG = LogUtils.getL7dLogger(OneWayProcessorInterceptor.class);
+
+ public OneWayProcessorInterceptor() {
+ super(Phase.PRE_LOGICAL);
+ }
+ public OneWayProcessorInterceptor(String phase) {
+ super(phase);
+ }
+
+ @Override
+ public void handleFault(Message message) {
+ if (message.getExchange().isOneWay()
+ && !isRequestor(message)) {
+ //in a one way, if an exception is thrown, the stream needs to be closed
+ InputStream in = message.getContent(InputStream.class);
+ if (in != null) {
+ try {
+ in.close();
+ } catch (IOException e) {
+ //ignore
+ }
+ }
+
+ }
+ }
+ public void handleMessage(Message message) {
+
+ if (message.getExchange().isOneWay()
+ && !isRequestor(message)
+ && message.get(OneWayProcessorInterceptor.class) == null
+ && message.getExchange().get(Executor.class) == null) {
+ //one way on server side, fork the rest of this chain onto the
+ //workqueue, call the Outgoing chain directly.
+
+ message.put(OneWayProcessorInterceptor.class, this);
+ final InterceptorChain chain = message.getInterceptorChain();
+
+ boolean robust =
+ MessageUtils.getContextualBoolean(message, Message.ROBUST_ONEWAY, false);
+
+ boolean useOriginalThread =
+ MessageUtils.getContextualBoolean(message, USE_ORIGINAL_THREAD, false);
+
+ if (!useOriginalThread && !robust) {
+ //need to suck in all the data from the input stream as
+ //the transport might discard any data on the stream when this
+ //thread unwinds or when the empty response is sent back
+ DelegatingInputStream in = message.getContent(DelegatingInputStream.class);
+ if (in != null) {
+ in.cacheInput();
+ }
+ }
+
+ if (robust) {
+ // continue to invoke the chain
+ chain.pause();
+ chain.resume();
+ if (message.getContent(Exception.class) != null) {
+ // CXF-5629 fault has been delivered alread in resume()
+ return;
+ }
+ }
+
+ try {
+ Message partial = createMessage(message.getExchange());
+ partial.remove(Message.CONTENT_TYPE);
+ partial.setExchange(message.getExchange());
+ Conduit conduit = message.getExchange().getDestination()
+ .getBackChannel(message);
+ if (conduit != null) {
+ message.getExchange().setInMessage(null);
+ //for a one-way, the back channel could be
+ //null if it knows it cannot send anything.
+ conduit.prepare(partial);
+ conduit.close(partial);
+ message.getExchange().setInMessage(message);
+ }
+ } catch (IOException e) {
+ //IGNORE
+ }
+
+ if (!useOriginalThread && !robust) {
+ chain.pause();
+ try {
+ final Object lock = new Object();
+ synchronized (lock) {
+ message.getExchange().getBus().getExtension(WorkQueueManager.class)
+ .getAutomaticWorkQueue().execute(new Runnable() {
+ public void run() {
+ synchronized (lock) {
+ lock.notifyAll();
+ }
+ chain.resume();
+ }
+ });
+ //wait a few milliseconds for the background thread to start processing
+ //Mostly just to make an attempt at keeping the ordering of the
+ //messages coming in from a client. Not guaranteed though.
+ lock.wait(20L);
+ }
+ } catch (RejectedExecutionException e) {
+ LOG.warning(
+ "Executor queue is full, run the oneway invocation task in caller thread."
+ + " Users can specify a larger executor queue to avoid this.");
+ // only block the thread if the prop is unset or set to false, otherwise let it go
+ if (!MessageUtils.getContextualBoolean(message,
+ "org.apache.cxf.oneway.rejected_execution_exception", false)) {
+ //the executor queue is full, so run the task in the caller thread
+ chain.unpause();
+ }
+
+ } catch (InterruptedException e) {
+ //ignore - likely a busy work queue so we'll just let the one-way go
+ }
+ }
+ }
+ }
+
+ private static Message createMessage(Exchange exchange) {
+ Endpoint ep = exchange.getEndpoint();
+ Message msg = null;
+ if (ep != null) {
+ msg = new MessageImpl();
+ msg.setExchange(exchange);
+ msg = ep.getBinding().createMessage(msg);
+ }
+ return msg;
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/OutFaultChainInitiatorObserver.java b/transform/src/patch/java/org/apache/cxf/interceptor/OutFaultChainInitiatorObserver.java
new file mode 100644
index 0000000..a00e403
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/OutFaultChainInitiatorObserver.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.cxf.interceptor;
+
+import java.util.Collection;
+import java.util.SortedSet;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.endpoint.Client;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+import org.apache.cxf.phase.PhaseManager;
+
+public class OutFaultChainInitiatorObserver extends AbstractFaultChainInitiatorObserver {
+
+ public OutFaultChainInitiatorObserver(Bus bus) {
+ super(bus);
+ }
+
+ @Override
+ protected void initializeInterceptors(Exchange ex, PhaseInterceptorChain chain) {
+ Endpoint e = ex.getEndpoint();
+ Client c = ex.get(Client.class);
+
+ chain.add(getBus().getOutFaultInterceptors());
+ if (c != null) {
+ chain.add(c.getOutFaultInterceptors());
+ }
+ chain.add(e.getService().getOutFaultInterceptors());
+ chain.add(e.getOutFaultInterceptors());
+ chain.add(e.getBinding().getOutFaultInterceptors());
+ if (e.getService().getDataBinding() instanceof InterceptorProvider) {
+ chain.add(((InterceptorProvider)e.getService().getDataBinding()).getOutFaultInterceptors());
+ }
+
+ addToChain(chain, ex.getInMessage());
+ addToChain(chain, ex.getOutFaultMessage());
+ }
+ private void addToChain(PhaseInterceptorChain chain, Message m) {
+ Collection<InterceptorProvider> providers
+ = CastUtils.cast((Collection<?>)m.get(Message.INTERCEPTOR_PROVIDERS));
+ if (providers != null) {
+ for (InterceptorProvider p : providers) {
+ chain.add(p.getOutFaultInterceptors());
+ }
+ }
+ Collection<Interceptor<? extends Message>> is
+ = CastUtils.cast((Collection<?>)m.get(Message.FAULT_OUT_INTERCEPTORS));
+ if (is != null) {
+ chain.add(is);
+ }
+ if (m.getDestination() instanceof InterceptorProvider) {
+ chain.add(((InterceptorProvider)m.getDestination()).getOutFaultInterceptors());
+ }
+ }
+
+ protected SortedSet<Phase> getPhases() {
+ return getBus().getExtension(PhaseManager.class).getOutPhases();
+ }
+
+ protected boolean isOutboundObserver() {
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/security/DefaultSecurityContext.java b/transform/src/patch/java/org/apache/cxf/interceptor/security/DefaultSecurityContext.java
new file mode 100644
index 0000000..9b712f3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/security/DefaultSecurityContext.java
@@ -0,0 +1,188 @@
+/**
+ * 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.cxf.interceptor.security;
+
+
+import java.lang.reflect.Method;
+import java.security.Principal;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.security.GroupPrincipal;
+import org.apache.cxf.common.util.ReflectionUtil;
+import org.apache.cxf.security.LoginSecurityContext;
+
+/**
+ * SecurityContext which implements isUserInRole using the
+ * following approach : skip the first Subject principal, and then checks
+ * Groups the principal is a member of
+ */
+public class DefaultSecurityContext implements LoginSecurityContext {
+ private static final Logger LOG = LogUtils.getL7dLogger(DefaultSecurityContext.class);
+ private static Class<?> javaGroup;
+ private static Class<?> karafGroup;
+
+ private Principal p;
+ private Subject subject;
+
+ static {
+ try {
+ javaGroup = Class.forName("java.security.acl.Group");
+ } catch (Exception e) {
+ javaGroup = null;
+ }
+ try {
+ karafGroup = Class.forName("org.apache.karaf.jaas.boot.principal.Group");
+ } catch (Exception e) {
+ karafGroup = null;
+ }
+ }
+
+ public DefaultSecurityContext(Subject subject) {
+ this.p = findPrincipal(null, subject);
+ this.subject = subject;
+ }
+
+ public DefaultSecurityContext(String principalName, Subject subject) {
+ this.p = findPrincipal(principalName, subject);
+ this.subject = subject;
+ }
+
+ public DefaultSecurityContext(Principal p, Subject subject) {
+ this.p = p;
+ this.subject = subject;
+ if (p == null) {
+ this.p = findPrincipal(null, subject);
+ }
+ }
+
+ private static Principal findPrincipal(String principalName, Subject subject) {
+ if (subject == null) {
+ return null;
+ }
+
+ for (Principal principal : subject.getPrincipals()) {
+ if (!isGroupPrincipal(principal)
+ && (principalName == null || principal.getName().equals(principalName))) {
+ return principal;
+ }
+ }
+
+ // No match for the principalName. Just return first non-Group Principal
+ if (principalName != null) {
+ for (Principal principal : subject.getPrincipals()) {
+ if (!isGroupPrincipal(principal)) {
+ return principal;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public Principal getUserPrincipal() {
+ return p;
+ }
+
+ public boolean isUserInRole(String role) {
+ if (subject != null) {
+ for (Principal principal : subject.getPrincipals()) {
+ if (isGroupPrincipal(principal)
+ && checkGroup(principal, role)) {
+ return true;
+ } else if (p != principal
+ && role.equals(principal.getName())) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+
+ protected boolean checkGroup(Principal principal, String role) {
+ if (principal.getName().equals(role)) {
+ return true;
+ }
+
+ Enumeration<? extends Principal> members;
+ try {
+ Method m = ReflectionUtil.getMethod(principal.getClass(), "members");
+ m.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ Enumeration<? extends Principal> ms = (Enumeration<? extends Principal>)m.invoke(principal);
+ members = ms;
+ } catch (Exception e) {
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Unable to invoke memebers in " + principal.getName() + ":" + e.getMessage());
+ }
+ return false;
+ }
+
+ while (members.hasMoreElements()) {
+ // this might be a plain role but could represent a group consisting of other groups/roles
+ Principal member = members.nextElement();
+ if (member.getName().equals(role)
+ || isGroupPrincipal(member)
+ && checkGroup((GroupPrincipal)member, role)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+ public Subject getSubject() {
+ return subject;
+ }
+
+ public Set<Principal> getUserRoles() {
+ Set<Principal> roles = new HashSet<>();
+ if (subject != null) {
+ for (Principal principal : subject.getPrincipals()) {
+ if (principal != p) {
+ roles.add(principal);
+ }
+ }
+ }
+ return roles;
+ }
+
+
+ private static boolean instanceOfGroup(Object obj) {
+ try {
+ return (javaGroup != null && javaGroup.isInstance(obj))
+ || (karafGroup != null && karafGroup.isInstance(obj));
+ } catch (Exception ex) {
+ return false;
+ }
+ }
+
+ public static boolean isGroupPrincipal(Principal principal) {
+ return principal instanceof GroupPrincipal
+ || instanceOfGroup(principal);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/interceptor/security/JAASLoginInterceptor.java b/transform/src/patch/java/org/apache/cxf/interceptor/security/JAASLoginInterceptor.java
new file mode 100644
index 0000000..3363c20
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/interceptor/security/JAASLoginInterceptor.java
@@ -0,0 +1,233 @@
+/**
+ * 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.cxf.interceptor.security;
+
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+import javax.security.auth.callback.Callback;
+import javax.security.auth.callback.CallbackHandler;
+import javax.security.auth.callback.NameCallback;
+import javax.security.auth.login.Configuration;
+import javax.security.auth.login.LoginContext;
+import javax.security.auth.login.LoginException;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.interceptor.InterceptorChain;
+import org.apache.cxf.interceptor.security.callback.CallbackHandlerProvider;
+import org.apache.cxf.interceptor.security.callback.CallbackHandlerProviderAuthPol;
+import org.apache.cxf.interceptor.security.callback.CallbackHandlerProviderUsernameToken;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.security.SecurityContext;
+
+public class JAASLoginInterceptor extends AbstractPhaseInterceptor<Message> {
+ public static final String ROLE_CLASSIFIER_PREFIX = "prefix";
+ public static final String ROLE_CLASSIFIER_CLASS_NAME = "classname";
+
+ private static final Logger LOG = LogUtils.getL7dLogger(JAASLoginInterceptor.class);
+
+ private String contextName = "";
+ private Configuration loginConfig;
+ private String roleClassifier;
+ private String roleClassifierType = ROLE_CLASSIFIER_PREFIX;
+ private boolean reportFault;
+ private boolean useDoAs = true;
+ private List<CallbackHandlerProvider> callbackHandlerProviders;
+ private boolean allowAnonymous = true;
+ private boolean allowNamedPrincipals;
+
+ public JAASLoginInterceptor() {
+ this(Phase.UNMARSHAL);
+ }
+
+ public JAASLoginInterceptor(String phase) {
+ super(phase);
+ this.callbackHandlerProviders = new ArrayList<>();
+ this.callbackHandlerProviders.add(new CallbackHandlerProviderAuthPol());
+ this.callbackHandlerProviders.add(new CallbackHandlerProviderUsernameToken());
+ }
+
+ public void setContextName(String name) {
+ contextName = name;
+ }
+
+ public String getContextName() {
+ return contextName;
+ }
+
+ /**
+ * @deprecated replaced by {@link #setRoleClassifier(String)}
+ * @param name
+ */
+ @Deprecated
+ public void setRolePrefix(String name) {
+ setRoleClassifier(name);
+ }
+
+ public void setRoleClassifier(String value) {
+ roleClassifier = value;
+ }
+
+ public String getRoleClassifier() {
+ return roleClassifier;
+ }
+
+ public void setRoleClassifierType(String value) {
+ if (!ROLE_CLASSIFIER_PREFIX.equals(value)
+ && !ROLE_CLASSIFIER_CLASS_NAME.equals(value)) {
+ throw new IllegalArgumentException("Unsupported role classifier");
+ }
+ roleClassifierType = value;
+ }
+
+ public String getRoleClassifierType() {
+ return roleClassifierType;
+ }
+
+ public void setReportFault(boolean reportFault) {
+ this.reportFault = reportFault;
+ }
+
+ public void setUseDoAs(boolean useDoAs) {
+ this.useDoAs = useDoAs;
+ }
+
+ private CallbackHandler getFirstCallbackHandler(Message message) {
+ for (CallbackHandlerProvider cbp : callbackHandlerProviders) {
+ CallbackHandler cbh = cbp.create(message);
+ if (cbh != null) {
+ return cbh;
+ }
+ }
+ return null;
+ }
+
+ public void handleMessage(final Message message) {
+ if (allowNamedPrincipals) {
+ SecurityContext sc = message.get(SecurityContext.class);
+ if (sc != null && sc.getUserPrincipal() != null
+ && sc.getUserPrincipal().getName() != null) {
+ return;
+ }
+ }
+
+ CallbackHandler handler = getFirstCallbackHandler(message);
+
+ if (handler == null && !allowAnonymous) {
+ throw new AuthenticationException("Authentication required but no authentication information was supplied");
+ }
+
+ try {
+ LoginContext ctx = new LoginContext(getContextName(), null, handler, loginConfig);
+ ctx.login();
+ Subject subject = ctx.getSubject();
+ String name = getUsername(handler);
+ message.put(SecurityContext.class, createSecurityContext(name, subject));
+
+ // Run the further chain in the context of this subject.
+ // This allows other code to retrieve the subject using pure JAAS
+ if (useDoAs) {
+ Subject.doAs(subject, new PrivilegedAction<Void>() {
+
+ @Override
+ public Void run() {
+ InterceptorChain chain = message.getInterceptorChain();
+ if (chain != null) {
+ message.put("suspend.chain.on.current.interceptor", Boolean.TRUE);
+ chain.doIntercept(message);
+ }
+ return null;
+ }
+ });
+ }
+
+ } catch (LoginException ex) {
+ String errorMessage = "Authentication failed: " + ex.getMessage();
+ LOG.log(Level.FINE, errorMessage, ex);
+ if (reportFault) {
+ AuthenticationException aex = new AuthenticationException(errorMessage);
+ aex.initCause(ex);
+ throw aex;
+
+ }
+ throw new AuthenticationException("Authentication failed (details can be found in server log)");
+ }
+ }
+
+ private String getUsername(CallbackHandler handler) {
+ if (handler == null) {
+ return null;
+ }
+ try {
+ NameCallback usernameCallBack = new NameCallback("user");
+ handler.handle(new Callback[]{usernameCallBack });
+ return usernameCallBack.getName();
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ protected CallbackHandler getCallbackHandler(String name, String password) {
+ return new NamePasswordCallbackHandler(name, password);
+ }
+
+ protected SecurityContext createSecurityContext(String name, Subject subject) {
+ if (getRoleClassifier() != null) {
+ return new RolePrefixSecurityContextImpl(subject, getRoleClassifier(),
+ getRoleClassifierType());
+ }
+ return new DefaultSecurityContext(name, subject);
+ }
+
+ public Configuration getLoginConfig() {
+ return loginConfig;
+ }
+
+ public void setLoginConfig(Configuration loginConfig) {
+ this.loginConfig = loginConfig;
+ }
+
+ public List<CallbackHandlerProvider> getCallbackHandlerProviders() {
+ return callbackHandlerProviders;
+ }
+
+ public void setCallbackHandlerProviders(List<CallbackHandlerProvider> callbackHandlerProviders) {
+ this.callbackHandlerProviders.clear();
+ this.callbackHandlerProviders.addAll(callbackHandlerProviders);
+ }
+
+ public void addCallbackHandlerProviders(List<CallbackHandlerProvider> callbackHandlerProviders2) {
+ this.callbackHandlerProviders.addAll(callbackHandlerProviders2);
+ }
+
+ public void setAllowAnonymous(boolean allowAnonymous) {
+ this.allowAnonymous = allowAnonymous;
+ }
+
+ public void setAllowNamedPrincipals(boolean allowNamedPrincipals) {
+ this.allowNamedPrincipals = allowNamedPrincipals;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/internal/CXFAPINamespaceHandler.java b/transform/src/patch/java/org/apache/cxf/internal/CXFAPINamespaceHandler.java
new file mode 100644
index 0000000..e3d432d
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/internal/CXFAPINamespaceHandler.java
@@ -0,0 +1,127 @@
+/**
+ * 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.cxf.internal;
+
+import java.net.URL;
+import java.util.Set;
+
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+import org.apache.aries.blueprint.NamespaceHandler;
+import org.apache.aries.blueprint.Namespaces;
+import org.apache.aries.blueprint.ParserContext;
+import org.apache.aries.blueprint.mutable.MutableBeanMetadata;
+import org.apache.cxf.bus.blueprint.BusDefinitionParser;
+import org.apache.cxf.configuration.blueprint.SimpleBPBeanDefinitionParser;
+import org.apache.cxf.feature.FastInfosetFeature;
+import org.apache.cxf.workqueue.AutomaticWorkQueueImpl;
+import org.osgi.service.blueprint.reflect.ComponentMetadata;
+import org.osgi.service.blueprint.reflect.Metadata;
+
+@Namespaces({"http://cxf.apache.org/blueprint/core",
+ "http://cxf.apache.org/configuration/beans",
+ "http://cxf.apache.org/configuration/parameterized-types",
+ "http://cxf.apache.org/configuration/security",
+ "http://schemas.xmlsoap.org/wsdl/",
+ "http://www.w3.org/2005/08/addressing",
+ "http://schemas.xmlsoap.org/ws/2004/08/addressing"})
+public class CXFAPINamespaceHandler implements NamespaceHandler {
+
+ public URL getSchemaLocation(String namespace) {
+ String location = null;
+
+ // when schema is being resolved for custom namespace elements, "namespace" is real namespace
+ // (from xmlns:prefix="<namespace>"
+ // but when namespace is <xsd:import>ed, aries/xerces uses systemID (schemaLocation)
+
+ if ("http://cxf.apache.org/configuration/beans".equals(namespace)
+ || "http://cxf.apache.org/schemas/configuration/cxf-beans.xsd".equals(namespace)) {
+ location = "schemas/configuration/cxf-beans.xsd";
+ } else if ("http://cxf.apache.org/configuration/parameterized-types".equals(namespace)
+ || "http://cxf.apache.org/schemas/configuration/parameterized-types.xsd".equals(namespace)) {
+ location = "schemas/configuration/parameterized-types.xsd";
+ } else if ("http://cxf.apache.org/configuration/security".equals(namespace)
+ || "http://cxf.apache.org/schemas/configuration/security.xsd".equals(namespace)) {
+ location = "schemas/configuration/security.xsd";
+ } else if ("http://schemas.xmlsoap.org/wsdl/".equals(namespace)
+ || "http://schemas.xmlsoap.org/wsdl/2003-02-11.xsd".equals(namespace)) {
+ location = "schemas/wsdl/wsdl.xsd";
+ } else if ("http://www.w3.org/2005/08/addressing".equals(namespace)
+ || "http://www.w3.org/2006/03/addressing/ws-addr.xsd".equals(namespace)) {
+ location = "schemas/wsdl/ws-addr.xsd";
+ } else if ("http://schemas.xmlsoap.org/ws/2004/08/addressing".equals(namespace)) {
+ location = "schemas/wsdl/addressing.xsd";
+ } else if ("http://cxf.apache.org/blueprint/core".equals(namespace)) {
+ location = "schemas/blueprint/core.xsd";
+ }
+ if (location != null) {
+ return getClass().getClassLoader().getResource(location);
+ }
+ return null;
+ }
+
+
+ @SuppressWarnings("deprecation")
+ public Metadata parse(Element element, ParserContext context) {
+ String s = element.getLocalName();
+ if ("bus".equals(s)) {
+ //parse bus
+ return new BusDefinitionParser().parse(element, context);
+ } else if ("logging".equals(s)) {
+ //logging feature
+ return new SimpleBPBeanDefinitionParser(org.apache.cxf.feature.LoggingFeature.class)
+ .parse(element, context);
+ } else if ("fastinfoset".equals(s)) {
+ //fastinfosetfeature
+ return new SimpleBPBeanDefinitionParser(FastInfosetFeature.class).parse(element, context);
+ } else if ("workqueue".equals(s)) {
+ return new SimpleBPBeanDefinitionParser(AutomaticWorkQueueImpl.class) {
+
+ @Override
+ public String getId(Element element, ParserContext context) {
+ String id = element.hasAttribute("id") ? element.getAttribute("id") : null;
+ if (id == null) {
+ id = "cxf.workqueue.";
+ id += element.hasAttribute("name") ? element.getAttribute("name") : "def";
+ }
+ return id;
+ }
+
+ @Override
+ protected void processNameAttribute(Element element, ParserContext ctx,
+ MutableBeanMetadata bean, String val) {
+ bean.addProperty("name", createValue(ctx, val));
+ }
+ } .parse(element, context);
+ }
+ return null;
+ }
+
+ @SuppressWarnings("rawtypes")
+ public Set<Class> getManagedClasses() {
+ //probably should have the various stuff in cxf-api in here?
+ return null;
+ }
+ public ComponentMetadata decorate(Node node, ComponentMetadata component, ParserContext context) {
+ return null;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/io/CacheAndWriteOutputStream.java b/transform/src/patch/java/org/apache/cxf/io/CacheAndWriteOutputStream.java
new file mode 100644
index 0000000..d89edb9
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/io/CacheAndWriteOutputStream.java
@@ -0,0 +1,96 @@
+/**
+ * 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.cxf.io;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * This outputstream implementation will both write to the outputstream
+ * that is specified and cache the data at the same time. This allows us
+ * to go back and retransmit the data at a later time if necessary.
+ *
+ */
+public class CacheAndWriteOutputStream extends CachedOutputStream {
+ OutputStream flowThroughStream;
+ long count;
+ long limit = Long.MAX_VALUE;
+ private boolean isClosed;
+
+ public CacheAndWriteOutputStream(OutputStream stream) {
+ super();
+ if (stream == null) {
+ throw new IllegalArgumentException("Stream may not be null");
+ }
+ flowThroughStream = stream;
+ }
+
+ public void setCacheLimit(long l) {
+ limit = l;
+ }
+
+ public void closeFlowthroughStream() throws IOException {
+ postClose();
+ }
+
+ protected void postClose() throws IOException {
+ if (!isClosed) {
+ flowThroughStream.flush();
+ flowThroughStream.close();
+ isClosed = true;
+ }
+ }
+
+ public OutputStream getFlowThroughStream() {
+ return flowThroughStream;
+ }
+
+ @Override
+ protected void onWrite() throws IOException {
+ // does nothing
+ }
+
+ @Override
+ public void write(int b) throws IOException {
+ flowThroughStream.write(b);
+ if (count <= limit) {
+ super.write(b);
+ }
+ count++;
+ }
+
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+ flowThroughStream.write(b, off, len);
+ if (count <= limit) {
+ super.write(b, off, len);
+ }
+ count += len;
+ }
+
+ @Override
+ public void write(byte[] b) throws IOException {
+ flowThroughStream.write(b);
+ if (count <= limit) {
+ super.write(b);
+ }
+ count += b.length;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/io/CachedWriter.java b/transform/src/patch/java/org/apache/cxf/io/CachedWriter.java
new file mode 100644
index 0000000..0178563
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/io/CachedWriter.java
@@ -0,0 +1,665 @@
+/**
+ * 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.cxf.io;
+
+import java.io.BufferedOutputStream;
+import java.io.CharArrayReader;
+import java.io.CharArrayWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javax.crypto.CipherInputStream;
+import javax.crypto.CipherOutputStream;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.common.util.SystemPropertyAction;
+import org.apache.cxf.helpers.FileUtils;
+import org.apache.cxf.helpers.IOUtils;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+public class CachedWriter extends Writer {
+ private static final File DEFAULT_TEMP_DIR;
+ private static int defaultThreshold;
+ private static long defaultMaxSize;
+ private static String defaultCipherTransformation;
+
+ static {
+
+ String s = SystemPropertyAction.getPropertyOrNull(CachedConstants.OUTPUT_DIRECTORY_SYS_PROP);
+ if (s == null) {
+ // lookup the deprecated property
+ s = SystemPropertyAction.getPropertyOrNull("org.apache.cxf.io.CachedWriter.OutputDirectory");
+ }
+ if (s != null) {
+ File f = new File(s);
+ if (f.exists() && f.isDirectory()) {
+ DEFAULT_TEMP_DIR = f;
+ } else {
+ DEFAULT_TEMP_DIR = null;
+ }
+ } else {
+ DEFAULT_TEMP_DIR = null;
+ }
+
+ setDefaultThreshold(-1);
+ setDefaultMaxSize(-1);
+ setDefaultCipherTransformation(null);
+ }
+
+ protected boolean outputLocked;
+ protected Writer currentStream;
+
+ private boolean cosClosed;
+ private long threshold = defaultThreshold;
+ private long maxSize = defaultMaxSize;
+ private File outputDir = DEFAULT_TEMP_DIR;
+ private String cipherTransformation = defaultCipherTransformation;
+
+ private long totalLength;
+
+ private boolean inmem;
+
+ private boolean tempFileFailed;
+ private File tempFile;
+ private boolean allowDeleteOfFile = true;
+ private CipherPair ciphers;
+
+ private List<CachedWriterCallback> callbacks;
+
+ private List<Object> streamList = new ArrayList<>();
+
+
+ static class LoadingCharArrayWriter extends CharArrayWriter {
+ LoadingCharArrayWriter() {
+ super(1024);
+ }
+ public char[] rawCharArray() {
+ return super.buf;
+ }
+ }
+
+
+ public CachedWriter() {
+ this(defaultThreshold);
+
+ inmem = true;
+ }
+
+ public CachedWriter(long threshold) {
+ this.threshold = threshold;
+ currentStream = new LoadingCharArrayWriter();
+ inmem = true;
+ readBusProperties();
+ }
+
+ private void readBusProperties() {
+ Bus b = BusFactory.getThreadDefaultBus(false);
+ if (b != null) {
+ String v = getBusProperty(b, CachedConstants.THRESHOLD_BUS_PROP, null);
+ if (v != null && threshold == defaultThreshold) {
+ threshold = Integer.parseInt(v);
+ }
+ v = getBusProperty(b, CachedConstants.MAX_SIZE_BUS_PROP, null);
+ if (v != null) {
+ maxSize = Integer.parseInt(v);
+ }
+ v = getBusProperty(b, CachedConstants.CIPHER_TRANSFORMATION_BUS_PROP, null);
+ if (v != null) {
+ cipherTransformation = v;
+ }
+ v = getBusProperty(b, CachedConstants.OUTPUT_DIRECTORY_BUS_PROP, null);
+ if (v != null) {
+ File f = new File(v);
+ if (f.exists() && f.isDirectory()) {
+ outputDir = f;
+ }
+ }
+ }
+ }
+
+ private static String getBusProperty(Bus b, String key, String dflt) {
+ String v = (String)b.getProperty(key);
+ return v != null ? v : dflt;
+ }
+
+ public void holdTempFile() {
+ allowDeleteOfFile = false;
+ }
+ public void releaseTempFileHold() {
+ allowDeleteOfFile = true;
+ }
+
+ public void registerCallback(CachedWriterCallback cb) {
+ if (null == callbacks) {
+ callbacks = new ArrayList<>();
+ }
+ callbacks.add(cb);
+ }
+
+ public void deregisterCallback(CachedWriterCallback cb) {
+ if (null != callbacks) {
+ callbacks.remove(cb);
+ }
+ }
+
+ public List<CachedWriterCallback> getCallbacks() {
+ return callbacks == null ? null : Collections.unmodifiableList(callbacks);
+ }
+
+ /**
+ * Perform any actions required on stream flush (freeze headers, reset
+ * output stream ... etc.)
+ */
+ protected void doFlush() throws IOException {
+
+ }
+
+ public void flush() throws IOException {
+ if (!cosClosed) {
+ currentStream.flush();
+ }
+
+ if (null != callbacks) {
+ for (CachedWriterCallback cb : callbacks) {
+ cb.onFlush(this);
+ }
+ }
+ doFlush();
+ }
+
+ /**
+ * Perform any actions required on stream closure (handle response etc.)
+ */
+ protected void doClose() throws IOException {
+
+ }
+
+ /**
+ * Perform any actions required after stream closure (close the other related stream etc.)
+ */
+ protected void postClose() throws IOException {
+
+ }
+
+ /**
+ * Locks the output stream to prevent additional writes, but maintains
+ * a pointer to it so an InputStream can be obtained
+ * @throws IOException
+ */
+ public void lockOutputStream() throws IOException {
+ if (outputLocked) {
+ return;
+ }
+ currentStream.flush();
+ outputLocked = true;
+ if (null != callbacks) {
+ for (CachedWriterCallback cb : callbacks) {
+ cb.onClose(this);
+ }
+ }
+ doClose();
+ streamList.remove(currentStream);
+ }
+
+ public void close() throws IOException {
+ if (!cosClosed) {
+ currentStream.flush();
+ }
+ outputLocked = true;
+ if (null != callbacks) {
+ for (CachedWriterCallback cb : callbacks) {
+ cb.onClose(this);
+ }
+ }
+ doClose();
+ currentStream.close();
+ maybeDeleteTempFile(currentStream);
+ if (ciphers != null) {
+ ciphers.clean();
+ }
+ postClose();
+ }
+
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof CachedWriter) {
+ return currentStream.equals(((CachedWriter)obj).currentStream);
+ }
+ return currentStream.equals(obj);
+ }
+
+ /**
+ * Replace the original stream with the new one, optionally copying the content of the old one
+ * into the new one.
+ * When with Attachment, needs to replace the xml writer stream with the stream used by
+ * AttachmentSerializer or copy the cached output stream to the "real"
+ * output stream, i.e. onto the wire.
+ *
+ * @param out the new output stream
+ * @param copyOldContent flag indicating if the old content should be copied
+ * @throws IOException
+ */
+ public void resetOut(Writer out, boolean copyOldContent) throws IOException {
+ if (out == null) {
+ out = new LoadingCharArrayWriter();
+ }
+
+ if (currentStream instanceof CachedWriter) {
+ CachedWriter ac = (CachedWriter) currentStream;
+ Reader in = ac.getReader();
+ IOUtils.copyAndCloseInput(in, out);
+ } else {
+ if (inmem) {
+ if (currentStream instanceof LoadingCharArrayWriter) {
+ LoadingCharArrayWriter byteOut = (LoadingCharArrayWriter) currentStream;
+ if (copyOldContent && byteOut.size() > 0) {
+ byteOut.writeTo(out);
+ }
+ } else {
+ throw new IOException("Unknown format of currentStream");
+ }
+ } else {
+ // read the file
+ currentStream.close();
+ if (copyOldContent) {
+ InputStreamReader fin = createInputStreamReader(tempFile);
+ IOUtils.copyAndCloseInput(fin, out);
+ }
+ streamList.remove(currentStream);
+ deleteTempFile();
+ inmem = true;
+ }
+ }
+ currentStream = out;
+ outputLocked = false;
+ }
+
+
+ public long size() {
+ return totalLength;
+ }
+
+ public char[] getChars() throws IOException {
+ flush();
+ if (inmem) {
+ if (currentStream instanceof LoadingCharArrayWriter) {
+ return ((LoadingCharArrayWriter)currentStream).toCharArray();
+ }
+ throw new IOException("Unknown format of currentStream");
+ }
+ // read the file
+ try (Reader fin = createInputStreamReader(tempFile)) {
+ CharArrayWriter out = new CharArrayWriter((int)tempFile.length());
+ char[] bytes = new char[1024];
+ int x = fin.read(bytes);
+ while (x != -1) {
+ out.write(bytes, 0, x);
+ x = fin.read(bytes);
+ }
+ return out.toCharArray();
+ }
+ }
+
+ public void writeCacheTo(Writer out) throws IOException {
+ flush();
+ if (inmem) {
+ if (currentStream instanceof LoadingCharArrayWriter) {
+ ((LoadingCharArrayWriter)currentStream).writeTo(out);
+ } else {
+ throw new IOException("Unknown format of currentStream");
+ }
+ } else {
+ // read the file
+ try (Reader fin = createInputStreamReader(tempFile)) {
+ char[] bytes = new char[1024];
+ int x = fin.read(bytes);
+ while (x != -1) {
+ out.write(bytes, 0, x);
+ x = fin.read(bytes);
+ }
+ }
+ }
+ }
+
+ public void writeCacheTo(StringBuilder out, long limit) throws IOException {
+ flush();
+ if (totalLength < limit
+ || limit == -1) {
+ writeCacheTo(out);
+ return;
+ }
+
+ long count = 0;
+ if (inmem) {
+ if (currentStream instanceof LoadingCharArrayWriter) {
+ LoadingCharArrayWriter s = (LoadingCharArrayWriter)currentStream;
+ out.append(s.rawCharArray(), 0, (int)limit);
+ } else {
+ throw new IOException("Unknown format of currentStream");
+ }
+ } else {
+ // read the file
+ try (Reader fin = createInputStreamReader(tempFile)) {
+ char[] bytes = new char[1024];
+ long x = fin.read(bytes);
+ while (x != -1) {
+ if ((count + x) > limit) {
+ x = limit - count;
+ }
+ out.append(bytes, 0, (int)x);
+ count += x;
+
+ if (count >= limit) {
+ x = -1;
+ } else {
+ x = fin.read(bytes);
+ }
+ }
+ }
+ }
+ }
+
+ public void writeCacheTo(StringBuilder out) throws IOException {
+ flush();
+ if (inmem) {
+ if (currentStream instanceof LoadingCharArrayWriter) {
+ LoadingCharArrayWriter lcaw = (LoadingCharArrayWriter)currentStream;
+ out.append(lcaw.rawCharArray(), 0, lcaw.size());
+ } else {
+ throw new IOException("Unknown format of currentStream");
+ }
+ } else {
+ // read the file
+ try (Reader r = createInputStreamReader(tempFile)) {
+ char[] chars = new char[1024];
+ int x = r.read(chars);
+ while (x != -1) {
+ out.append(chars, 0, x);
+ x = r.read(chars);
+ }
+ }
+ }
+ }
+
+
+ /**
+ * @return the underlying output stream
+ */
+ public Writer getOut() {
+ return currentStream;
+ }
+
+ public int hashCode() {
+ return currentStream.hashCode();
+ }
+
+ public String toString() {
+ StringBuilder builder = new StringBuilder().append('[')
+ .append(CachedWriter.class.getName())
+ .append(" Content: ");
+ try {
+ writeCacheTo(builder);
+ } catch (IOException e) {
+ //ignore
+ }
+ return builder.append(']').toString();
+ }
+
+ protected void onWrite() throws IOException {
+
+ }
+
+ private void enforceLimits() throws IOException {
+ if (maxSize > 0 && totalLength > maxSize) {
+ throw new CacheSizeExceededException();
+ }
+ if (inmem && totalLength > threshold && currentStream instanceof LoadingCharArrayWriter) {
+ createFileOutputStream();
+ }
+ }
+
+
+ public void write(char[] cbuf, int off, int len) throws IOException {
+ if (!outputLocked) {
+ onWrite();
+ this.totalLength += len;
+ enforceLimits();
+ currentStream.write(cbuf, off, len);
+ }
+ }
+
+ private void createFileOutputStream() throws IOException {
+ if (tempFileFailed) {
+ return;
+ }
+ LoadingCharArrayWriter bout = (LoadingCharArrayWriter)currentStream;
+ try {
+ if (outputDir == null) {
+ tempFile = FileUtils.createTempFile("cos", "tmp");
+ } else {
+ tempFile = FileUtils.createTempFile("cos", "tmp", outputDir, false);
+ }
+ currentStream = createOutputStreamWriter(tempFile);
+ bout.writeTo(currentStream);
+ inmem = false;
+ streamList.add(currentStream);
+ } catch (Exception ex) {
+ //Could be IOException or SecurityException or other issues.
+ //Don't care what, just keep it in memory.
+ tempFileFailed = true;
+ if (currentStream != bout) {
+ currentStream.close();
+ }
+ deleteTempFile();
+ inmem = true;
+ currentStream = bout;
+ }
+ }
+
+ public File getTempFile() {
+ return tempFile != null && tempFile.exists() ? tempFile : null;
+ }
+
+ public Reader getReader() throws IOException {
+ flush();
+ if (inmem) {
+ if (currentStream instanceof LoadingCharArrayWriter) {
+ LoadingCharArrayWriter lcaw = (LoadingCharArrayWriter)currentStream;
+ return new CharArrayReader(lcaw.rawCharArray(), 0, lcaw.size());
+ }
+ return null;
+ }
+ try {
+ InputStream fileInputStream = new FileInputStream(tempFile) {
+ boolean closed;
+
+ @Override
+ public void close() throws IOException {
+ if (!closed) {
+ super.close();
+ maybeDeleteTempFile(this);
+ }
+ closed = true;
+ }
+ };
+ streamList.add(fileInputStream);
+ if (cipherTransformation != null) {
+ fileInputStream = new CipherInputStream(fileInputStream, ciphers.getDecryptor()) {
+ boolean closed;
+
+ @Override
+ public void close() throws IOException {
+ if (!closed) {
+ super.close();
+ closed = true;
+ }
+ }
+ };
+ }
+ return new InputStreamReader(fileInputStream, StandardCharsets.UTF_8);
+ } catch (FileNotFoundException e) {
+ throw new IOException("Cached file was deleted, " + e.toString());
+ }
+ }
+
+ private synchronized void deleteTempFile() {
+ if (tempFile != null) {
+ File file = tempFile;
+ tempFile = null;
+ FileUtils.delete(file);
+ }
+ }
+ private void maybeDeleteTempFile(Object stream) {
+ streamList.remove(stream);
+ if (!inmem && tempFile != null && streamList.isEmpty() && allowDeleteOfFile) {
+ if (currentStream != null) {
+ try {
+ currentStream.close();
+ postClose();
+ } catch (Exception e) {
+ //ignore
+ }
+ }
+ deleteTempFile();
+ currentStream = new LoadingCharArrayWriter();
+ inmem = true;
+ }
+ }
+
+ public void setOutputDir(File outputDir) throws IOException {
+ this.outputDir = outputDir;
+ }
+ public void setThreshold(long threshold) {
+ this.threshold = threshold;
+ }
+
+ public void setMaxSize(long maxSize) {
+ this.maxSize = maxSize;
+ }
+
+ public void setCipherTransformation(String cipherTransformation) {
+ this.cipherTransformation = cipherTransformation;
+ }
+
+ public static void setDefaultMaxSize(long l) {
+ if (l == -1) {
+ String s = System.getProperty(CachedConstants.MAX_SIZE_SYS_PROP);
+ if (s == null) {
+ // lookup the deprecated property
+ s = System.getProperty("org.apache.cxf.io.CachedWriter.MaxSize", "-1");
+ }
+ l = Long.parseLong(s);
+ }
+ defaultMaxSize = l;
+ }
+
+ public static void setDefaultThreshold(int i) {
+ if (i == -1) {
+ i = SystemPropertyAction.getInteger(CachedConstants.THRESHOLD_SYS_PROP, -1);
+ if (i == -1) {
+ // lookup the deprecated property
+ i = SystemPropertyAction.getInteger("org.apache.cxf.io.CachedWriter.Threshold", -1);
+ }
+ if (i <= 0) {
+ i = 64 * 1024;
+ }
+ }
+ defaultThreshold = i;
+
+ }
+
+ public static void setDefaultCipherTransformation(String n) {
+ if (n == null) {
+ n = SystemPropertyAction.getPropertyOrNull(CachedConstants.CIPHER_TRANSFORMATION_SYS_PROP);
+ }
+ defaultCipherTransformation = n;
+ }
+
+ private OutputStreamWriter createOutputStreamWriter(File file) throws IOException {
+ OutputStream out = new BufferedOutputStream(Files.newOutputStream(file.toPath()));
+ if (cipherTransformation != null) {
+ try {
+ if (ciphers == null) {
+ ciphers = new CipherPair(cipherTransformation);
+ }
+ } catch (GeneralSecurityException e) {
+ out.close();
+ throw new IOException(e.getMessage(), e);
+ }
+ out = new CipherOutputStream(out, ciphers.getEncryptor()) {
+
+ @Override
+ public void close() throws IOException {
+ if (!cosClosed) {
+ super.close();
+ cosClosed = true;
+ }
+ }
+ };
+ }
+ return new OutputStreamWriter(out, UTF_8) {
+
+ @Override
+ public void close() throws IOException {
+ if (!cosClosed) {
+ super.close();
+ cosClosed = true;
+ }
+ }
+ };
+ }
+
+ private InputStreamReader createInputStreamReader(File file) throws IOException {
+ InputStream in = Files.newInputStream(file.toPath());
+ if (cipherTransformation != null) {
+ in = new CipherInputStream(in, ciphers.getDecryptor()) {
+ boolean closed;
+
+ @Override
+ public void close() throws IOException {
+ if (!closed) {
+ super.close();
+ closed = true;
+ }
+ }
+ };
+ }
+ return new InputStreamReader(in, UTF_8);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/io/ReaderInputStream.java b/transform/src/patch/java/org/apache/cxf/io/ReaderInputStream.java
new file mode 100644
index 0000000..e95ed88
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/io/ReaderInputStream.java
@@ -0,0 +1,294 @@
+/**
+ * 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.cxf.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.CodingErrorAction;
+
+/**
+ * {@link InputStream} implementation that reads a character stream from a {@link Reader}
+ * and transforms it to a byte stream using a specified charset encoding. The stream
+ * is transformed using a {@link CharsetEncoder} object, guaranteeing that all charset
+ * encodings supported by the JRE are handled correctly. In particular for charsets such as
+ * UTF-16, the implementation ensures that one and only one byte order marker
+ * is produced.
+ * <p>
+ * Since in general it is not possible to predict the number of characters to be read from the
+ * {@link Reader} to satisfy a read request on the {@link ReaderInputStream}, all reads from
+ * the {@link Reader} are buffered. There is therefore no well defined correlation
+ * between the current position of the {@link Reader} and that of the {@link ReaderInputStream}.
+ * This also implies that in general there is no need to wrap the underlying {@link Reader}
+ * in a {@link java.io.BufferedReader}.
+ * <p>
+ * {@link ReaderInputStream} implements the inverse transformation of {@link java.io.InputStreamReader};
+ * in the following example, reading from <tt>in2</tt> would return the same byte
+ * sequence as reading from <tt>in</tt> (provided that the initial byte sequence is legal
+ * with respect to the charset encoding):
+ * <pre>
+ * InputStream in = ...
+ * Charset cs = ...
+ * InputStreamReader reader = new InputStreamReader(in, cs);
+ * ReaderInputStream in2 = new ReaderInputStream(reader, cs);</pre>
+ * {@link ReaderInputStream} implements the same transformation as {@link java.io.OutputStreamWriter},
+ * except that the control flow is reversed: both classes transform a character stream
+ * into a byte stream, but {@link java.io.OutputStreamWriter} pushes data to the underlying stream,
+ * while {@link ReaderInputStream} pulls it from the underlying stream.
+ * <p>
+ * Note that while there are use cases where there is no alternative to using
+ * this class, very often the need to use this class is an indication of a flaw
+ * in the design of the code. This class is typically used in situations where an existing
+ * API only accepts an {@link InputStream}, but where the most natural way to produce the data
+ * is as a character stream, i.e. by providing a {@link Reader} instance. An example of a situation
+ * where this problem may appear is when implementing the {@link javax.activation.DataSource}
+ * interface from the Java Activation Framework.
+ * <p>
+ * Given the fact that the {@link Reader} class doesn't provide any way to predict whether the next
+ * read operation will block or not, it is not possible to provide a meaningful
+ * implementation of the {@link InputStream#available()} method. A call to this method
+ * will always return 0. Also, this class doesn't support {@link InputStream#mark(int)}.
+ * <p>
+ * Instances of {@link ReaderInputStream} are not thread safe.
+ *
+ * @since 2.0
+ */
+public class ReaderInputStream extends InputStream {
+ private static final int DEFAULT_BUFFER_SIZE = 1024;
+
+ private final Reader reader;
+ private final CharsetEncoder encoder;
+
+ /**
+ * CharBuffer used as input for the decoder. It should be reasonably
+ * large as we read data from the underlying Reader into this buffer.
+ */
+ private final CharBuffer encoderIn;
+
+ /**
+ * ByteBuffer used as output for the decoder. This buffer can be small
+ * as it is only used to transfer data from the decoder to the
+ * buffer provided by the caller.
+ */
+ private final ByteBuffer encoderOut;
+
+ private CoderResult lastCoderResult;
+ private boolean endOfInput;
+
+ /**
+ * Construct a new {@link ReaderInputStream}.
+ *
+ * @param reader the target {@link Reader}
+ * @param encoder the charset encoder
+ * @since 2.1
+ */
+ public ReaderInputStream(Reader reader, CharsetEncoder encoder) {
+ this(reader, encoder, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * Construct a new {@link ReaderInputStream}.
+ *
+ * @param reader the target {@link Reader}
+ * @param encoder the charset encoder
+ * @param bufferSize the size of the input buffer in number of characters
+ * @since 2.1
+ */
+ public ReaderInputStream(Reader reader, CharsetEncoder encoder, int bufferSize) {
+ this.reader = reader;
+ this.encoder = encoder;
+ this.encoderIn = CharBuffer.allocate(bufferSize);
+ encoderIn.flip();
+ this.encoderOut = ByteBuffer.allocate(128);
+ encoderOut.flip();
+ }
+
+ /**
+ * Construct a new {@link ReaderInputStream}.
+ *
+ * @param reader the target {@link Reader}
+ * @param charset the charset encoding
+ * @param bufferSize the size of the input buffer in number of characters
+ */
+ public ReaderInputStream(Reader reader, Charset charset, int bufferSize) {
+ this(reader,
+ charset.newEncoder()
+ .onMalformedInput(CodingErrorAction.REPLACE)
+ .onUnmappableCharacter(CodingErrorAction.REPLACE),
+ bufferSize);
+ }
+
+ /**
+ * Construct a new {@link ReaderInputStream} with a default input buffer size of
+ * 1024 characters.
+ *
+ * @param reader the target {@link Reader}
+ * @param charset the charset encoding
+ */
+ public ReaderInputStream(Reader reader, Charset charset) {
+ this(reader, charset, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * Construct a new {@link ReaderInputStream}.
+ *
+ * @param reader the target {@link Reader}
+ * @param charsetName the name of the charset encoding
+ * @param bufferSize the size of the input buffer in number of characters
+ */
+ public ReaderInputStream(Reader reader, String charsetName, int bufferSize) {
+ this(reader, Charset.forName(charsetName), bufferSize);
+ }
+
+ /**
+ * Construct a new {@link ReaderInputStream} with a default input buffer size of
+ * 1024 characters.
+ *
+ * @param reader the target {@link Reader}
+ * @param charsetName the name of the charset encoding
+ */
+ public ReaderInputStream(Reader reader, String charsetName) {
+ this(reader, charsetName, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * Construct a new {@link ReaderInputStream} that uses the default character encoding
+ * with a default input buffer size of 1024 characters.
+ *
+ * @param reader the target {@link Reader}
+ */
+ public ReaderInputStream(Reader reader) {
+ this(reader, Charset.defaultCharset());
+ }
+
+ /**
+ * Fills the internal char buffer from the reader.
+ *
+ * @throws IOException
+ * If an I/O error occurs
+ */
+ private void fillBuffer() throws IOException {
+ if (!endOfInput && (lastCoderResult == null || lastCoderResult.isUnderflow())) {
+ encoderIn.compact();
+ int position = encoderIn.position();
+ // We don't use Reader#read(CharBuffer) here because it is more efficient
+ // to write directly to the underlying char array (the default implementation
+ // copies data to a temporary char array).
+ int c = reader.read(encoderIn.array(), position, encoderIn.remaining());
+ if (c == -1) {
+ endOfInput = true;
+ } else {
+ encoderIn.position(position + c);
+ }
+ encoderIn.flip();
+ }
+ encoderOut.compact();
+ lastCoderResult = encoder.encode(encoderIn, encoderOut, endOfInput);
+ encoderOut.flip();
+ }
+
+ /**
+ * Read the specified number of bytes into an array.
+ *
+ * @param b the byte array to read into
+ * @param off the offset to start reading bytes into
+ * @param len the number of bytes to read
+ * @return the number of bytes read or <code>-1</code>
+ * if the end of the stream has been reached
+ * @throws IOException if an I/O error occurs
+ */
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ if (b == null) {
+ throw new NullPointerException("Byte array must not be null");
+ }
+ if (len < 0 || off < 0 || (off + len) > b.length) {
+ throw new IndexOutOfBoundsException("Array Size=" + b.length
+ + ", offset=" + off + ", length=" + len);
+ }
+ int read = 0;
+ if (len == 0) {
+ return 0; // Always return 0 if len == 0
+ }
+ while (len > 0) {
+ if (encoderOut.hasRemaining()) {
+ int c = Math.min(encoderOut.remaining(), len);
+ encoderOut.get(b, off, c);
+ off += c;
+ len -= c;
+ read += c;
+ } else {
+ fillBuffer();
+ if (endOfInput && !encoderOut.hasRemaining()) {
+ break;
+ }
+ }
+ }
+ return read == 0 && endOfInput ? -1 : read;
+ }
+
+ /**
+ * Read the specified number of bytes into an array.
+ *
+ * @param b the byte array to read into
+ * @return the number of bytes read or <code>-1</code>
+ * if the end of the stream has been reached
+ * @throws IOException if an I/O error occurs
+ */
+ @Override
+ public int read(byte[] b) throws IOException {
+ return read(b, 0, b.length);
+ }
+
+ /**
+ * Read a single byte.
+ *
+ * @return either the byte read or <code>-1</code> if the end of the stream
+ * has been reached
+ * @throws IOException if an I/O error occurs
+ */
+ @Override
+ public int read() throws IOException {
+ for (;;) {
+ if (encoderOut.hasRemaining()) {
+ return encoderOut.get() & 0xFF;
+ } else {
+ fillBuffer();
+ if (endOfInput && !encoderOut.hasRemaining()) {
+ return -1;
+ }
+ }
+ }
+ }
+
+ /**
+ * Close the stream. This method will cause the underlying {@link Reader}
+ * to be closed.
+ * @throws IOException if an I/O error occurs
+ */
+ @Override
+ public void close() throws IOException {
+ reader.close();
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/io/WriteOnCloseOutputStream.java b/transform/src/patch/java/org/apache/cxf/io/WriteOnCloseOutputStream.java
new file mode 100644
index 0000000..17f4579
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/io/WriteOnCloseOutputStream.java
@@ -0,0 +1,46 @@
+/**
+ * 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.cxf.io;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * This outputstream implementation will cache the message until close()
+ * is called, at which point it will write the message to the OutputStream
+ * supplied via the constructor.
+ */
+public class WriteOnCloseOutputStream extends CachedOutputStream {
+
+ OutputStream flowThroughStream;
+
+ public WriteOnCloseOutputStream(OutputStream stream) {
+ super();
+ flowThroughStream = stream;
+ }
+
+
+ @Override
+ protected void doClose() throws IOException {
+ resetOut(flowThroughStream, true);
+ flowThroughStream.flush();
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/JAXRSInvoker.java b/transform/src/patch/java/org/apache/cxf/jaxrs/JAXRSInvoker.java
new file mode 100644
index 0000000..163ff78
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/JAXRSInvoker.java
@@ -0,0 +1,460 @@
+/**
+ * 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.cxf.jaxrs;
+
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Collections;
+import java.util.List;
+import java.util.ResourceBundle;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.logging.Logger;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.container.AsyncResponse;
+import javax.ws.rs.container.ResourceContext;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.classloader.ClassLoaderUtils.ClassLoaderHolder;
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ClassHelper;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.interceptor.InterceptorChain.State;
+import org.apache.cxf.jaxrs.impl.AsyncResponseImpl;
+import org.apache.cxf.jaxrs.impl.MetadataMap;
+import org.apache.cxf.jaxrs.impl.ResourceContextImpl;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.model.ClassResourceInfo;
+import org.apache.cxf.jaxrs.model.OperationResourceInfo;
+import org.apache.cxf.jaxrs.model.ProviderInfo;
+import org.apache.cxf.jaxrs.model.URITemplate;
+import org.apache.cxf.jaxrs.provider.ServerProviderFactory;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageContentsList;
+import org.apache.cxf.service.invoker.AbstractInvoker;
+
+public class JAXRSInvoker extends AbstractInvoker {
+ private static final Logger LOG = LogUtils.getL7dLogger(JAXRSInvoker.class);
+ private static final ResourceBundle BUNDLE = BundleUtils.getBundle(JAXRSInvoker.class);
+ private static final String SERVICE_LOADER_AS_CONTEXT = "org.apache.cxf.serviceloader-context";
+ private static final String SERVICE_OBJECT_SCOPE = "org.apache.cxf.service.scope";
+ private static final String REQUEST_SCOPE = "request";
+ private static final String LAST_SERVICE_OBJECT = "org.apache.cxf.service.object.last";
+ private static final String PROXY_INVOCATION_ERROR_FRAGMENT
+ = "object is not an instance of declaring class";
+
+ public JAXRSInvoker() {
+ }
+
+ public Object invoke(Exchange exchange, Object request) {
+ MessageContentsList responseList = checkExchangeForResponse(exchange);
+ if (responseList != null) {
+ return responseList;
+ }
+ AsyncResponse asyncResp = exchange.get(AsyncResponse.class);
+ if (asyncResp != null) {
+ AsyncResponseImpl asyncImpl = (AsyncResponseImpl)asyncResp;
+ asyncImpl.prepareContinuation();
+ try {
+ asyncImpl.handleTimeout();
+ return handleAsyncResponse(exchange, asyncImpl);
+ } catch (Throwable t) {
+ return handleAsyncFault(exchange, asyncImpl, t);
+ }
+ }
+
+ ResourceProvider provider = getResourceProvider(exchange);
+ Object rootInstance = null;
+ Message inMessage = exchange.getInMessage();
+ try {
+ rootInstance = getServiceObject(exchange);
+ Object serviceObject = getActualServiceObject(exchange, rootInstance);
+
+ return invoke(exchange, request, serviceObject);
+ } catch (WebApplicationException ex) {
+ responseList = checkExchangeForResponse(exchange);
+ if (responseList != null) {
+ return responseList;
+ }
+ return handleFault(ex, inMessage);
+ } finally {
+ boolean suspended = isSuspended(exchange);
+ if (suspended || exchange.isOneWay() || inMessage.get(Message.THREAD_CONTEXT_SWITCHED) != null) {
+ ServerProviderFactory.clearThreadLocalProxies(inMessage);
+ }
+ if (suspended || isServiceObjectRequestScope(inMessage)) {
+ persistRoots(exchange, rootInstance, provider);
+ } else {
+ provider.releaseInstance(inMessage, rootInstance);
+ }
+ }
+ }
+
+ private boolean isSuspended(Exchange exchange) {
+ return exchange.getInMessage().getInterceptorChain().getState() == State.SUSPENDED;
+ }
+
+ private Object handleAsyncResponse(Exchange exchange, AsyncResponseImpl ar) {
+ Object asyncObj = ar.getResponseObject();
+ if (asyncObj instanceof Throwable) {
+ final Throwable throwable = (Throwable)asyncObj;
+ Throwable cause = throwable;
+
+ if (throwable instanceof CompletionException) {
+ cause = throwable.getCause();
+ }
+
+ return handleAsyncFault(exchange, ar, (cause != null) ? cause : throwable);
+ }
+ setResponseContentTypeIfNeeded(exchange.getInMessage(), asyncObj);
+ return new MessageContentsList(asyncObj);
+ }
+
+ private Object handleAsyncFault(Exchange exchange, AsyncResponseImpl ar, Throwable t) {
+ try {
+ return handleFault(new Fault(t), exchange.getInMessage(), null, null);
+ } catch (Fault ex) {
+ ar.setUnmappedThrowable(ex.getCause() == null ? ex : ex.getCause());
+ if (isSuspended(exchange)) {
+ ar.reset();
+ exchange.getInMessage().getInterceptorChain().unpause();
+ }
+ return new MessageContentsList(Response.serverError().build());
+ }
+ }
+
+ private void persistRoots(Exchange exchange, Object rootInstance, Object provider) {
+ exchange.put(JAXRSUtils.ROOT_INSTANCE, rootInstance);
+ exchange.put(JAXRSUtils.ROOT_PROVIDER, provider);
+ }
+
+ @SuppressWarnings("unchecked")
+ public Object invoke(Exchange exchange, Object request, Object resourceObject) {
+
+ final OperationResourceInfo ori = exchange.get(OperationResourceInfo.class);
+ final ClassResourceInfo cri = ori.getClassResourceInfo();
+ final Message inMessage = exchange.getInMessage();
+ final ServerProviderFactory providerFactory = ServerProviderFactory.getInstance(inMessage);
+ cri.injectContexts(resourceObject, ori, inMessage);
+
+ if (cri.isRoot()) {
+ ProviderInfo<Application> appProvider = providerFactory.getApplicationProvider();
+ if (appProvider != null) {
+ InjectionUtils.injectContexts(appProvider.getProvider(),
+ appProvider,
+ inMessage);
+ }
+ }
+
+
+ Method methodToInvoke = getMethodToInvoke(cri, ori, resourceObject);
+
+ List<Object> params = null;
+ if (request instanceof List) {
+ params = CastUtils.cast((List<?>)request);
+ } else if (request != null) {
+ params = new MessageContentsList(request);
+ }
+
+ Object result = null;
+ ClassLoaderHolder contextLoader = null;
+ AsyncResponseImpl asyncResponse = null;
+ try {
+ if (setServiceLoaderAsContextLoader(inMessage)) {
+ contextLoader = ClassLoaderUtils
+ .setThreadContextClassloader(resourceObject.getClass().getClassLoader());
+ }
+ if (!ori.isSubResourceLocator()) {
+ asyncResponse = (AsyncResponseImpl)inMessage.get(AsyncResponse.class);
+ }
+ result = invoke(exchange, resourceObject, methodToInvoke, params);
+ if (asyncResponse == null && !ori.isSubResourceLocator()) {
+ asyncResponse = checkFutureResponse(inMessage, checkResultObject(result));
+ }
+ if (asyncResponse != null) {
+ if (!asyncResponse.suspendContinuationIfNeeded()) {
+ result = handleAsyncResponse(exchange, asyncResponse);
+ } else {
+ providerFactory.clearThreadLocalProxies();
+ }
+ }
+ } catch (Fault ex) {
+ Object faultResponse;
+ if (asyncResponse != null) {
+ faultResponse = handleAsyncFault(exchange, asyncResponse,
+ ex.getCause() == null ? ex : ex.getCause());
+ } else {
+ faultResponse = handleFault(ex, inMessage, cri, methodToInvoke);
+ }
+ return faultResponse;
+ } finally {
+ exchange.put(LAST_SERVICE_OBJECT, resourceObject);
+ if (contextLoader != null) {
+ contextLoader.reset();
+ }
+ }
+ ClassResourceInfo subCri = null;
+ if (ori.isSubResourceLocator()) {
+ try {
+ MultivaluedMap<String, String> values = getTemplateValues(inMessage);
+ String subResourcePath = values.getFirst(URITemplate.FINAL_MATCH_GROUP);
+ String httpMethod = (String)inMessage.get(Message.HTTP_REQUEST_METHOD);
+ String contentType = (String)inMessage.get(Message.CONTENT_TYPE);
+ if (contentType == null) {
+ contentType = "*/*";
+ }
+ List<MediaType> acceptContentType =
+ (List<MediaType>)exchange.get(Message.ACCEPT_CONTENT_TYPE);
+
+ result = checkSubResultObject(result, subResourcePath);
+
+ final Class<?> subResponseType;
+ if (result.getClass() == Class.class) {
+ ResourceContext rc = new ResourceContextImpl(inMessage, ori);
+ result = rc.getResource((Class<?>)result);
+ subResponseType = InjectionUtils.getActualType(methodToInvoke.getGenericReturnType());
+ } else {
+ subResponseType = methodToInvoke.getReturnType();
+ }
+
+ subCri = cri.getSubResource(subResponseType,
+ ClassHelper.getRealClass(exchange.getBus(), result), result);
+ if (subCri == null) {
+ org.apache.cxf.common.i18n.Message errorM =
+ new org.apache.cxf.common.i18n.Message("NO_SUBRESOURCE_FOUND",
+ BUNDLE,
+ subResourcePath);
+ LOG.severe(errorM.toString());
+ throw ExceptionUtils.toNotFoundException(null, null);
+ }
+
+ OperationResourceInfo subOri = JAXRSUtils.findTargetMethod(
+ Collections.singletonMap(subCri, values),
+ inMessage,
+ httpMethod,
+ values,
+ contentType,
+ acceptContentType);
+ exchange.put(OperationResourceInfo.class, subOri);
+ inMessage.put(URITemplate.TEMPLATE_PARAMETERS, values);
+ inMessage.put(URITemplate.URI_TEMPLATE, JAXRSUtils.getUriTemplate(inMessage, subCri, ori, subOri));
+
+ if (!subOri.isSubResourceLocator()
+ && JAXRSUtils.runContainerRequestFilters(providerFactory,
+ inMessage,
+ false,
+ subOri.getNameBindings())) {
+ return new MessageContentsList(exchange.get(Response.class));
+ }
+
+ // work out request parameters for the sub-resource class. Here we
+ // presume InputStream has not been consumed yet by the root resource class.
+ List<Object> newParams = JAXRSUtils.processParameters(subOri, values, inMessage);
+ inMessage.setContent(List.class, newParams);
+
+ return this.invoke(exchange, newParams, result);
+ } catch (IOException ex) {
+ Response resp = JAXRSUtils.convertFaultToResponse(ex, inMessage);
+ if (resp == null) {
+ resp = JAXRSUtils.convertFaultToResponse(ex, inMessage);
+ }
+ return new MessageContentsList(resp);
+ } catch (WebApplicationException ex) {
+ Response excResponse;
+ if (JAXRSUtils.noResourceMethodForOptions(ex.getResponse(),
+ (String)inMessage.get(Message.HTTP_REQUEST_METHOD))) {
+ excResponse = JAXRSUtils.createResponse(Collections.singletonList(subCri),
+ null, null, 200, true);
+ } else {
+ excResponse = JAXRSUtils.convertFaultToResponse(ex, inMessage);
+ }
+ return new MessageContentsList(excResponse);
+ }
+ }
+ setResponseContentTypeIfNeeded(inMessage, result);
+ return result;
+ }
+
+ protected AsyncResponseImpl checkFutureResponse(Message inMessage, Object result) {
+ if (result instanceof CompletionStage) {
+ final CompletionStage<?> stage = (CompletionStage<?>)result;
+ final AsyncResponseImpl asyncResponse = new AsyncResponseImpl(inMessage);
+ stage.whenComplete((v, t) -> {
+ if (t instanceof CancellationException) {
+ asyncResponse.cancel();
+ } else {
+ asyncResponse.resume(v != null ? v : t);
+ }
+ });
+ return asyncResponse;
+ }
+ return null;
+ }
+
+ protected Method getMethodToInvoke(ClassResourceInfo cri, OperationResourceInfo ori, Object resourceObject) {
+ Method resourceMethod = cri.getMethodDispatcher().getMethod(ori);
+
+ Method methodToInvoke;
+ if (Proxy.class.isInstance(resourceObject)) {
+ methodToInvoke = cri.getMethodDispatcher().getProxyMethod(resourceMethod);
+ if (methodToInvoke == null) {
+ methodToInvoke = InjectionUtils.checkProxy(resourceMethod, resourceObject);
+ cri.getMethodDispatcher().addProxyMethod(resourceMethod, methodToInvoke);
+ }
+ } else {
+ methodToInvoke = resourceMethod;
+ }
+ return methodToInvoke;
+ }
+
+ private MessageContentsList checkExchangeForResponse(Exchange exchange) {
+ Response r = exchange.get(Response.class);
+ if (r != null) {
+ JAXRSUtils.setMessageContentType(exchange.getInMessage(), r);
+ return new MessageContentsList(r);
+ }
+ return null;
+ }
+
+ private void setResponseContentTypeIfNeeded(Message inMessage, Object response) {
+ if (response instanceof Response) {
+ JAXRSUtils.setMessageContentType(inMessage, (Response)response);
+ }
+ }
+ private Object handleFault(Throwable ex, Message inMessage) {
+ return handleFault(new Fault(ex), inMessage, null, null);
+ }
+ private Object handleFault(Fault ex, Message inMessage,
+ ClassResourceInfo cri, Method methodToInvoke) {
+ String errorMessage = ex.getMessage();
+ if (errorMessage != null && cri != null
+ && errorMessage.contains(PROXY_INVOCATION_ERROR_FRAGMENT)) {
+ org.apache.cxf.common.i18n.Message errorM =
+ new org.apache.cxf.common.i18n.Message("PROXY_INVOCATION_FAILURE",
+ BUNDLE,
+ methodToInvoke,
+ cri.getServiceClass().getName());
+ LOG.severe(errorM.toString());
+ }
+ Response excResponse =
+ JAXRSUtils.convertFaultToResponse(ex.getCause() == null ? ex : ex.getCause(), inMessage);
+ if (excResponse == null) {
+ inMessage.getExchange().put(Message.PROPOGATE_EXCEPTION,
+ ExceptionUtils.propogateException(inMessage));
+ throw ex;
+ }
+ return new MessageContentsList(excResponse);
+ }
+
+ @SuppressWarnings("unchecked")
+ protected MultivaluedMap<String, String> getTemplateValues(Message msg) {
+ MultivaluedMap<String, String> values = new MetadataMap<>();
+ MultivaluedMap<String, String> oldValues =
+ (MultivaluedMap<String, String>)msg.get(URITemplate.TEMPLATE_PARAMETERS);
+ if (oldValues != null) {
+ values.putAll(oldValues);
+ }
+ return values;
+ }
+
+ private boolean setServiceLoaderAsContextLoader(Message inMessage) {
+ Object en = inMessage.getContextualProperty(SERVICE_LOADER_AS_CONTEXT);
+ return Boolean.TRUE.equals(en) || "true".equals(en);
+ }
+
+ private boolean isServiceObjectRequestScope(Message inMessage) {
+ Object scope = inMessage.getContextualProperty(SERVICE_OBJECT_SCOPE);
+ return REQUEST_SCOPE.equals(scope);
+ }
+
+ private ResourceProvider getResourceProvider(Exchange exchange) {
+ Object provider = exchange.remove(JAXRSUtils.ROOT_PROVIDER);
+ if (provider == null) {
+ OperationResourceInfo ori = exchange.get(OperationResourceInfo.class);
+ ClassResourceInfo cri = ori.getClassResourceInfo();
+ return cri.getResourceProvider();
+ }
+ return (ResourceProvider)provider;
+ }
+
+ public Object getServiceObject(Exchange exchange) {
+
+ Object root = exchange.remove(JAXRSUtils.ROOT_INSTANCE);
+ if (root != null) {
+ return root;
+ }
+
+ OperationResourceInfo ori = exchange.get(OperationResourceInfo.class);
+ ClassResourceInfo cri = ori.getClassResourceInfo();
+
+ return cri.getResourceProvider().getInstance(exchange.getInMessage());
+ }
+
+ protected Object getActualServiceObject(Exchange exchange, Object rootInstance) {
+
+ Object last = exchange.get(LAST_SERVICE_OBJECT);
+ return last != null ? last : rootInstance;
+ }
+
+
+
+ private static Object checkResultObject(Object result) {
+
+ if (result != null) {
+ if (result instanceof MessageContentsList) {
+ result = ((MessageContentsList)result).get(0);
+ } else if (result instanceof List) {
+ result = ((List<?>)result).get(0);
+ } else if (result.getClass().isArray()) {
+ result = ((Object[])result)[0];
+ }
+ }
+ return result;
+ }
+ private static Object checkSubResultObject(Object result, String subResourcePath) {
+ result = checkResultObject(result);
+ if (result == null) {
+ org.apache.cxf.common.i18n.Message errorM =
+ new org.apache.cxf.common.i18n.Message("NULL_SUBRESOURCE",
+ BUNDLE,
+ subResourcePath);
+ LOG.info(errorM.toString());
+ throw ExceptionUtils.toNotFoundException(null, null);
+ }
+
+ return result;
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/JAXRSServerFactoryBean.java b/transform/src/patch/java/org/apache/cxf/jaxrs/JAXRSServerFactoryBean.java
new file mode 100644
index 0000000..7871226
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/JAXRSServerFactoryBean.java
@@ -0,0 +1,467 @@
+/**
+ * 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.cxf.jaxrs;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.ws.rs.core.Application;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.classloader.ClassLoaderUtils.ClassLoaderHolder;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.endpoint.Server;
+import org.apache.cxf.endpoint.ServerImpl;
+import org.apache.cxf.feature.Feature;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.jaxrs.ext.ResourceComparator;
+import org.apache.cxf.jaxrs.impl.RequestPreprocessor;
+import org.apache.cxf.jaxrs.lifecycle.PerRequestResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;
+import org.apache.cxf.jaxrs.model.ApplicationInfo;
+import org.apache.cxf.jaxrs.model.ClassResourceInfo;
+import org.apache.cxf.jaxrs.provider.ServerProviderFactory;
+import org.apache.cxf.jaxrs.utils.AnnotationUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.service.factory.FactoryBeanListener;
+import org.apache.cxf.service.factory.ServiceConstructionException;
+import org.apache.cxf.service.invoker.Invoker;
+
+
+/**
+ * Bean to help easily create Server endpoints for JAX-RS. Example:
+ * <pre>
+ * JAXRSServerFactoryBean sf = JAXRSServerFactoryBean();
+ * sf.setResourceClasses(Book.class);
+ * sf.setBindingId(JAXRSBindingFactory.JAXRS_BINDING_ID);
+ * sf.setAddress("http://localhost:9080/");
+ * Server myServer = sf.create();
+ * </pre>
+ * This will start a server for you and register it with the ServerManager. Note
+ * you should explicitly close the {@link org.apache.cxf.endpoint.Server} created
+ * when finished with it:
+ * <pre>
+ * myServer.close();
+ * myServer.destroy(); // closes first if close() not previously called
+ * </pre>
+ */
+public class JAXRSServerFactoryBean extends AbstractJAXRSFactoryBean {
+
+ protected Map<Class<?>, ResourceProvider> resourceProviders = new HashMap<>();
+
+ private Server server;
+ private boolean start = true;
+ private Map<Object, Object> languageMappings;
+ private Map<Object, Object> extensionMappings;
+ private ResourceComparator rc;
+ private ApplicationInfo appProvider;
+ private String documentLocation;
+
+ public JAXRSServerFactoryBean() {
+ this(new JAXRSServiceFactoryBean());
+ }
+
+ public JAXRSServerFactoryBean(JAXRSServiceFactoryBean sf) {
+ super(sf);
+ }
+
+ /**
+ * Saves the reference to the JAX-RS {@link Application}
+ * @param app
+ */
+ public void setApplication(Application app) {
+ setApplicationInfo(new ApplicationInfo(app, getBus()));
+ }
+
+ public void setApplicationInfo(ApplicationInfo provider) {
+ appProvider = provider;
+ Set<String> appNameBindings = AnnotationUtils.getNameBindings(bus, provider.getProvider().getClass());
+ for (ClassResourceInfo cri : getServiceFactory().getClassResourceInfo()) {
+ Set<String> clsNameBindings = new LinkedHashSet<>(appNameBindings);
+ clsNameBindings.addAll(AnnotationUtils.getNameBindings(bus, cri.getServiceClass()));
+ cri.setNameBindings(clsNameBindings);
+ }
+ }
+
+ /**
+ * Resource comparator which may be used to customize the way
+ * a root resource or resource method is selected
+ * @param rcomp comparator
+ */
+ public void setResourceComparator(ResourceComparator rcomp) {
+ rc = rcomp;
+ }
+
+ /**
+ * By default the subresources are resolved dynamically, mainly due to
+ * the JAX-RS specification allowing Objects being returned from the subresource
+ * locators. Setting this property to true enables the runtime to do the
+ * early resolution.
+ *
+ * @param enableStatic enabling the static resolution if set to true
+ */
+ public void setStaticSubresourceResolution(boolean enableStatic) {
+ serviceFactory.setEnableStaticResolution(enableStatic);
+ }
+
+
+ /**
+ * Creates the JAX-RS Server instance
+ * @return the server
+ */
+ public void init() {
+ if (server == null) {
+ create();
+ }
+ }
+
+ /**
+ * Creates the JAX-RS Server instance
+ * @return the server
+ */
+ public Server create() {
+ ClassLoaderHolder origLoader = null;
+ try {
+ Bus bus = getBus();
+ ClassLoader loader = bus.getExtension(ClassLoader.class);
+ if (loader != null) {
+ origLoader = ClassLoaderUtils.setThreadContextClassloader(loader);
+ }
+ serviceFactory.setBus(bus);
+ checkResources(true);
+ if (serviceFactory.getService() == null) {
+ serviceFactory.create();
+ }
+
+ Endpoint ep = createEndpoint();
+
+ getServiceFactory().sendEvent(FactoryBeanListener.Event.PRE_SERVER_CREATE,
+ server);
+
+ server = new ServerImpl(getBus(),
+ ep,
+ getDestinationFactory(),
+ getBindingFactory());
+
+ Invoker invoker = serviceFactory.getInvoker();
+ if (invoker == null) {
+ ep.getService().setInvoker(createInvoker());
+ } else {
+ ep.getService().setInvoker(invoker);
+ }
+
+ ServerProviderFactory factory = setupFactory(ep);
+
+ ep.put(Application.class.getName(), appProvider);
+ factory.setRequestPreprocessor(
+ new RequestPreprocessor(languageMappings, extensionMappings));
+ ep.put(Bus.class.getName(), getBus());
+ if (documentLocation != null) {
+ ep.put(JAXRSUtils.DOC_LOCATION, documentLocation);
+ }
+ if (rc != null) {
+ ep.put("org.apache.cxf.jaxrs.comparator", rc);
+ }
+ checkPrivateEndpoint(ep);
+
+ applyBusFeatures(getBus());
+ applyFeatures();
+
+ updateClassResourceProviders(ep);
+ injectContexts(factory, (ApplicationInfo)ep.get(Application.class.getName()));
+ factory.applyDynamicFeatures(getServiceFactory().getClassResourceInfo());
+
+
+ getServiceFactory().sendEvent(FactoryBeanListener.Event.SERVER_CREATED,
+ server,
+ null,
+ null);
+
+
+ if (start) {
+ try {
+ server.start();
+ } catch (RuntimeException re) {
+ if (!(re instanceof ServiceConstructionException
+ && re.getMessage().startsWith("There is an endpoint already running on"))) {
+ //avoid destroying another server on the same endpoint url
+ server.destroy(); // prevent resource leak if server really started by itself
+
+ }
+ throw re;
+ }
+ }
+ } catch (Exception e) {
+ throw new ServiceConstructionException(e);
+ } finally {
+ if (origLoader != null) {
+ origLoader.reset();
+ }
+ }
+
+ return server;
+ }
+
+ public Server getServer() {
+ return server;
+ }
+
+ protected ServerProviderFactory setupFactory(Endpoint ep) {
+ ServerProviderFactory factory = ServerProviderFactory.createInstance(getBus());
+ setBeanInfo(factory);
+ factory.setApplicationProvider(appProvider);
+ super.setupFactory(factory, ep);
+ return factory;
+ }
+
+ protected void setBeanInfo(ServerProviderFactory factory) {
+ List<ClassResourceInfo> cris = serviceFactory.getClassResourceInfo();
+ for (ClassResourceInfo cri : cris) {
+ cri.initBeanParamInfo(factory);
+ }
+
+ }
+
+ protected void applyBusFeatures(final Bus bus) {
+ if (bus.getFeatures() != null) {
+ for (Feature feature : bus.getFeatures()) {
+ feature.initialize(server, bus);
+ }
+ }
+ }
+
+ protected void applyFeatures() {
+ if (getFeatures() != null) {
+ for (Feature feature : getFeatures()) {
+ feature.initialize(server, getBus());
+ }
+ }
+ }
+
+ protected Invoker createInvoker() {
+ return serviceFactory.createInvoker();
+ }
+
+ /**
+ * Sets the language mappings,
+ * example, 'en' is the key and 'en-gb' is the value.
+ *
+ * @param lMaps the language mappings
+ */
+ public void setLanguageMappings(Map<Object, Object> lMaps) {
+ languageMappings = lMaps;
+ }
+
+ /**
+ * Sets the extension mappings,
+ * example, 'xml' is the key and 'text/xml' is the value.
+ *
+ * @param extMaps the extension mappings
+ */
+ public void setExtensionMappings(Map<Object, Object> extMaps) {
+ extensionMappings = extMaps;
+ }
+
+ public List<Class<?>> getResourceClasses() {
+ return serviceFactory.getResourceClasses();
+ }
+
+ /**
+ * This method is used primarily by Spring handler processing
+ * the jaxrs:server/@serviceClass attribute. It delegates to
+ * setResourceClasses method accepting the array of Class parameters.
+ * @param clazz the service/resource class
+ */
+ public void setServiceClass(Class<?> clazz) {
+ serviceFactory.setResourceClasses(clazz);
+ }
+
+ /**
+ * Sets one or more root resource classes
+ * @param classes the list of resource classes
+ */
+ public void setResourceClasses(List<Class<?>> classes) {
+ serviceFactory.setResourceClasses(classes);
+ }
+
+ /**
+ * Sets one or more root resource classes
+ * @param classes the array of resource classes
+ */
+ public void setResourceClasses(Class<?>... classes) {
+ serviceFactory.setResourceClasses(classes);
+ }
+
+ /**
+ * Sets the resource beans. If this is set then the JAX-RS runtime
+ * will not be responsible for the life-cycle of resource classes.
+ *
+ * @param beans the array of resource instances
+ */
+ public void setServiceBeanObjects(Object... beans) {
+ setServiceBeans(Arrays.asList(beans));
+ }
+
+ /**
+ * Sets the single resource bean. If this is set then the JAX-RS runtime
+ * will not be responsible for the life-cycle of resource classes.
+ * Please avoid setting the resource class of this bean explicitly,
+ * the runtime will determine it itself.
+ *
+ * @param bean resource instance
+ */
+ public void setServiceBean(Object bean) {
+ setServiceBeans(Arrays.asList(bean));
+ }
+
+ /**
+ * Sets the resource beans. If this is set then the JAX-RS runtime
+ * will not be responsible for the life-cycle of resource classes.
+ *
+ * @param beans the list of resource instances
+ */
+ public void setServiceBeans(List<Object> beans) {
+ List<Object> newBeans = new ArrayList<>();
+ addToBeans(newBeans, beans);
+ serviceFactory.setResourceClassesFromBeans(newBeans);
+ }
+
+ /**
+ * Sets the provider managing the life-cycle of the given resource class
+ * <pre>
+ * Example:
+ * setResourceProvider(BookStoreInterface.class, new SingletonResourceProvider(new BookStore()));
+ * </pre>
+ * @param c resource class
+ * @param rp resource provider
+ */
+ public void setResourceProvider(Class<?> c, ResourceProvider rp) {
+ resourceProviders.put(c, rp);
+ }
+
+ /**
+ * Sets the provider managing the life-cycle of the resource class
+ * <pre>
+ * Example:
+ * setResourceProvider(new SingletonResourceProvider(new BookStore()));
+ * </pre>
+ * @param rp resource provider
+ */
+ public void setResourceProvider(ResourceProvider rp) {
+ setResourceProviders(CastUtils.cast(Collections.singletonList(rp), ResourceProvider.class));
+ }
+
+ /**
+ * Sets the list of providers managing the life-cycle of the resource classes
+ *
+ * @param rps resource providers
+ */
+ public void setResourceProviders(List<ResourceProvider> rps) {
+ for (ResourceProvider rp : rps) {
+ Class<?> c = rp.getResourceClass();
+ setServiceClass(c);
+ resourceProviders.put(c, rp);
+ }
+ }
+
+ /**
+ * Sets the custom Invoker which can be used to customize the way
+ * the default JAX-RS invoker calls on the service bean
+ * @param invoker
+ */
+ public void setInvoker(Invoker invoker) {
+ serviceFactory.setInvoker(invoker);
+ }
+
+ /**
+ * Determines whether Services are automatically started during the create() call. Default is true.
+ * If false will need to call start() method on Server to activate it.
+ * @param start Whether (true) or not (false) to start the Server during Server creation.
+ */
+ public void setStart(boolean start) {
+ this.start = start;
+ }
+
+ protected void injectContexts(ServerProviderFactory factory, ApplicationInfo fallback) {
+ // Sometimes the application provider (ApplicationInfo) is injected through
+ // the endpoint, not JAXRSServerFactoryBean (like for example OpenApiFeature
+ // or Swagger2Feature do). As such, without consulting the endpoint, the injection
+ // may not work properly.
+ final ApplicationInfo appInfoProvider = (appProvider == null) ? fallback : appProvider;
+ final Application application = appInfoProvider == null ? null : appInfoProvider.getProvider();
+
+ for (ClassResourceInfo cri : serviceFactory.getClassResourceInfo()) {
+ if (cri.isSingleton()) {
+ InjectionUtils.injectContextProxiesAndApplication(cri,
+ cri.getResourceProvider().getInstance(null),
+ application,
+ factory);
+ }
+ }
+ if (application != null) {
+ InjectionUtils.injectContextProxiesAndApplication(appInfoProvider,
+ application, null, null);
+ }
+ }
+
+ protected void updateClassResourceProviders(Endpoint ep) {
+ for (ClassResourceInfo cri : serviceFactory.getClassResourceInfo()) {
+ if (cri.getResourceProvider() == null) {
+ ResourceProvider rp = resourceProviders.get(cri.getResourceClass());
+ if (rp != null) {
+ cri.setResourceProvider(rp);
+ } else {
+ setDefaultResourceProvider(cri);
+ }
+ }
+ if (cri.getResourceProvider() instanceof SingletonResourceProvider) {
+ ((SingletonResourceProvider)cri.getResourceProvider()).init(ep);
+ }
+ }
+ }
+
+ protected void setDefaultResourceProvider(ClassResourceInfo cri) {
+ cri.setResourceProvider(new PerRequestResourceProvider(cri.getResourceClass()));
+ }
+
+ /**
+ * Set the reference to the document (WADL, etc) describing the endpoint
+ * @param docLocation document location
+ */
+ public void setDocLocation(String docLocation) {
+ this.documentLocation = docLocation;
+ }
+
+ /**
+ * Get the reference to the document (WADL, etc) describing the endpoint
+ * @return document location
+ */
+ public String getDocLocation() {
+ return documentLocation;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/impl/EntityTagHeaderProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/EntityTagHeaderProvider.java
new file mode 100644
index 0000000..0deb1c3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/EntityTagHeaderProvider.java
@@ -0,0 +1,77 @@
+/**
+ * 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.cxf.jaxrs.impl;
+
+import javax.ws.rs.core.EntityTag;
+import javax.ws.rs.ext.RuntimeDelegate.HeaderDelegate;
+
+public class EntityTagHeaderProvider implements HeaderDelegate<EntityTag> {
+
+ private static final String WEAK_PREFIX = "W/";
+
+ public EntityTag fromString(String header) {
+
+
+ if (header == null) {
+ throw new IllegalArgumentException("ETag value can not be null");
+ }
+
+ if ("*".equals(header)) {
+ return new EntityTag("*");
+ }
+
+ String tag;
+ boolean weak = false;
+ int i = header.indexOf(WEAK_PREFIX);
+ if (i != -1) {
+ weak = true;
+ if (i + 2 < header.length()) {
+ tag = header.substring(i + 2);
+ } else {
+ return new EntityTag("", weak);
+ }
+ } else {
+ tag = header;
+ }
+ if (tag.length() > 0 && !tag.startsWith("\"") && !tag.endsWith("\"")) {
+ return new EntityTag(tag, weak);
+ }
+ if (tag.length() < 2 || !tag.startsWith("\"") || !tag.endsWith("\"")) {
+ throw new IllegalArgumentException("Misformatted ETag : " + header);
+ }
+ tag = tag.length() == 2 ? "" : tag.substring(1, tag.length() - 1);
+ return new EntityTag(tag, weak);
+ }
+
+ public String toString(EntityTag tag) {
+ StringBuilder sb = new StringBuilder();
+ if (tag.isWeak()) {
+ sb.append(WEAK_PREFIX);
+ }
+ String tagValue = tag.getValue();
+ if (!tagValue.startsWith("\"")) {
+ sb.append('"').append(tagValue).append('"');
+ } else {
+ sb.append(tagValue);
+ }
+ return sb.toString();
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/impl/MediaTypeHeaderProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/MediaTypeHeaderProvider.java
new file mode 100644
index 0000000..a885a33
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/MediaTypeHeaderProvider.java
@@ -0,0 +1,221 @@
+/**
+ * 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.cxf.jaxrs.impl;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.ext.RuntimeDelegate.HeaderDelegate;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.SystemPropertyAction;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+
+public class MediaTypeHeaderProvider implements HeaderDelegate<MediaType> {
+ private static final Logger LOG = LogUtils.getL7dLogger(MediaTypeHeaderProvider.class);
+ private static final String STRICT_MEDIA_TYPE_CHECK =
+ "org.apache.cxf.jaxrs.mediaTypeCheck.strict";
+ private static final Pattern COMPLEX_PARAMETERS =
+ Pattern.compile("(([\\w-]+=\"[^\"]*\")|([\\w-]+=[\\w-/\\+]+))");
+
+ private static Map<String, MediaType> map = new ConcurrentHashMap<>();
+ private static final int MAX_MT_CACHE_SIZE =
+ SystemPropertyAction.getInteger("org.apache.cxf.jaxrs.max_mediatype_cache_size", 200);
+
+ public MediaType fromString(String mType) {
+
+ return valueOf(mType);
+ }
+
+ public static MediaType valueOf(String mType) {
+ if (mType == null) {
+ throw new IllegalArgumentException("Media type value can not be null");
+ }
+
+ MediaType result = map.get(mType);
+ if (result == null) {
+ result = internalValueOf(mType);
+ final int size = map.size();
+ if (size >= MAX_MT_CACHE_SIZE) {
+ map.clear();
+ }
+ map.put(mType, result);
+ }
+ return result;
+ }
+
+ public static MediaType internalValueOf(String mType) {
+
+ int i = mType.indexOf('/');
+ if (i == -1) {
+ return handleMediaTypeWithoutSubtype(mType.trim());
+ } else if (i == 0) {
+ throw new IllegalArgumentException("Invalid media type string: " + mType);
+ }
+
+ int paramsStart = mType.indexOf(';', i + 1);
+ int end = paramsStart == -1 ? mType.length() : paramsStart;
+
+ String type = mType.substring(0, i).trim();
+ String subtype = mType.substring(i + 1, end).trim();
+ if (!isValid(type) || !isValid(subtype)) {
+ throw new IllegalArgumentException("Invalid media type string: " + mType);
+ }
+
+ Map<String, String> parameters = Collections.emptyMap();
+ if (paramsStart != -1) {
+
+ parameters = new LinkedHashMap<>();
+
+ String paramString = mType.substring(paramsStart + 1);
+ if (paramString.contains("\"")) {
+ Matcher m = COMPLEX_PARAMETERS.matcher(paramString);
+ while (m.find()) {
+ String val = m.group().trim();
+ addParameter(parameters, val);
+ }
+ } else {
+ StringTokenizer st = new StringTokenizer(paramString, ";");
+ while (st.hasMoreTokens()) {
+ addParameter(parameters, st.nextToken());
+ }
+ }
+ }
+
+ return new MediaType(type.toLowerCase(),
+ subtype.toLowerCase(),
+ parameters);
+ }
+
+ private static void addParameter(Map<String, String> parameters, String token) {
+ int equalSign = token.indexOf('=');
+ if (equalSign == -1) {
+ throw new IllegalArgumentException("Wrong media type parameter, separator is missing");
+ }
+ parameters.put(token.substring(0, equalSign).trim().toLowerCase(),
+ token.substring(equalSign + 1).trim());
+ }
+
+ public String toString(MediaType type) {
+ return typeToString(type);
+ }
+ public static String typeToString(MediaType type) {
+ return typeToString(type, null);
+ }
+ // Max number of parameters that may be ignored is 3, at least as known
+ // to the implementation
+ public static String typeToString(MediaType type, List<String> ignoreParams) {
+ if (type == null) {
+ throw new IllegalArgumentException("MediaType parameter is null");
+ }
+ StringBuilder sb = new StringBuilder();
+ sb.append(type.getType()).append('/').append(type.getSubtype());
+
+ Map<String, String> params = type.getParameters();
+ if (params != null) {
+ for (Map.Entry<String, String> entry : params.entrySet()) {
+ if (ignoreParams != null && ignoreParams.contains(entry.getKey())) {
+ continue;
+ }
+ sb.append(';').append(entry.getKey()).append('=').append(entry.getValue());
+ }
+ }
+
+ return sb.toString();
+ }
+
+ private static MediaType handleMediaTypeWithoutSubtype(String mType) {
+ if (mType.startsWith(MediaType.MEDIA_TYPE_WILDCARD)) {
+ String mTypeNext = mType.length() == 1 ? "" : mType.substring(1).trim();
+ boolean mTypeNextEmpty = StringUtils.isEmpty(mTypeNext);
+ if (mTypeNextEmpty || mTypeNext.startsWith(";")) {
+ if (!mTypeNextEmpty) {
+ Map<String, String> parameters = new LinkedHashMap<>();
+ StringTokenizer st = new StringTokenizer(mType.substring(2).trim(), ";");
+ while (st.hasMoreTokens()) {
+ addParameter(parameters, st.nextToken());
+ }
+ return new MediaType(MediaType.MEDIA_TYPE_WILDCARD,
+ MediaType.MEDIA_TYPE_WILDCARD,
+ parameters);
+ }
+ return MediaType.WILDCARD_TYPE;
+
+ }
+ }
+ Message message = PhaseInterceptorChain.getCurrentMessage();
+ if (message != null
+ && !MessageUtils.getContextualBoolean(message, STRICT_MEDIA_TYPE_CHECK, false)) {
+ final MediaType mt;
+ if (mType.equals(MediaType.TEXT_PLAIN_TYPE.getType())) {
+ mt = MediaType.TEXT_PLAIN_TYPE;
+ } else if (mType.equals(MediaType.APPLICATION_XML_TYPE.getSubtype())) {
+ mt = MediaType.APPLICATION_XML_TYPE;
+ } else {
+ mt = MediaType.WILDCARD_TYPE;
+ }
+ LOG.fine("Converting a malformed media type '" + mType + "' to '" + typeToString(mt) + "'");
+ return mt;
+ }
+ throw new IllegalArgumentException("Media type separator is missing");
+ }
+
+ // Determines whether the type or subtype contains any of the tspecials characters defined at:
+ // https://tools.ietf.org/html/rfc2045#section-5.1
+ private static boolean isValid(String str) {
+ final int len = str.length();
+ if (len == 0) {
+ return false;
+ }
+ for (int i = 0; i < len; i++) {
+ switch (str.charAt(i)) {
+ case '/':
+ case '\\':
+ case '?':
+ case ':':
+ case '<':
+ case '>':
+ case ';':
+ case '(':
+ case ')':
+ case '@':
+ case ',':
+ case '[':
+ case ']':
+ case '=':
+ return false;
+ default:
+ continue;
+ }
+ }
+ return true;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/impl/RequestImpl.java b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/RequestImpl.java
new file mode 100644
index 0000000..5921f1a
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/RequestImpl.java
@@ -0,0 +1,388 @@
+/**
+ * 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.cxf.jaxrs.impl;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.core.EntityTag;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Request;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.ResponseBuilder;
+import javax.ws.rs.core.Variant;
+
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+
+/**
+ * TODO : deal with InvalidStateExceptions
+ *
+ */
+
+
+public class RequestImpl implements Request {
+ private final Message m;
+ private final HttpHeaders headers;
+
+ public RequestImpl(Message m) {
+ this.m = m;
+ this.headers = new HttpHeadersImpl(m);
+ }
+
+
+
+ public Variant selectVariant(List<Variant> vars) throws IllegalArgumentException {
+ if (vars == null || vars.isEmpty()) {
+ throw new IllegalArgumentException("List of Variants is either null or empty");
+ }
+ List<MediaType> acceptMediaTypes = headers.getAcceptableMediaTypes();
+ List<Locale> acceptLangs = headers.getAcceptableLanguages();
+ List<String> acceptEncs = parseAcceptEnc(
+ headers.getRequestHeaders().getFirst(HttpHeaders.ACCEPT_ENCODING));
+ List<Variant> requestVariants = sortAllCombinations(acceptMediaTypes, acceptLangs, acceptEncs);
+ List<Object> varyValues = new LinkedList<>();
+ for (Variant requestVar : requestVariants) {
+ for (Variant var : vars) {
+ MediaType mt = var.getMediaType();
+ Locale lang = var.getLanguage();
+ String enc = var.getEncoding();
+
+ boolean mtMatched = mt == null || requestVar.getMediaType().isCompatible(mt);
+ if (mtMatched) {
+ handleVaryValues(varyValues, HttpHeaders.ACCEPT);
+ }
+
+ boolean langMatched = lang == null || isLanguageMatched(requestVar.getLanguage(), lang);
+ if (langMatched) {
+ handleVaryValues(varyValues, HttpHeaders.ACCEPT_LANGUAGE);
+ }
+
+ boolean encMatched = acceptEncs.isEmpty() || enc == null
+ || isEncMatached(requestVar.getEncoding(), enc);
+ if (encMatched) {
+ handleVaryValues(varyValues, HttpHeaders.ACCEPT_ENCODING);
+ }
+
+ if (mtMatched && encMatched && langMatched) {
+ addVaryHeader(varyValues);
+ return var;
+ }
+ }
+ }
+ return null;
+ }
+
+ private static List<Variant> sortAllCombinations(List<MediaType> mediaTypes,
+ List<Locale> langs,
+ List<String> encs) {
+ List<Variant> requestVars = new LinkedList<>();
+ for (MediaType mt : mediaTypes) {
+ for (Locale lang : langs) {
+ if (encs.isEmpty()) {
+ requestVars.add(new Variant(mt, lang, null));
+ } else {
+ for (String enc : encs) {
+ requestVars.add(new Variant(mt, lang, enc));
+ }
+ }
+ }
+ }
+ Collections.sort(requestVars, VariantComparator.INSTANCE);
+ return requestVars;
+ }
+
+
+ private static void handleVaryValues(List<Object> varyValues, String ...values) {
+ for (String v : values) {
+ if (v != null && !varyValues.contains(v)) {
+ varyValues.add(v);
+ }
+ }
+ }
+
+ private static void addVaryHeader(List<Object> varyValues) {
+ // at this point we still have no out-bound message so lets
+ // use HttpServletResponse. If needed we can save the header on the exchange
+ // and then copy it into the out-bound message's headers
+ Message message = PhaseInterceptorChain.getCurrentMessage();
+ if (message != null) {
+ Object httpResponse = message.get("HTTP.RESPONSE");
+ if (httpResponse != null) {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < varyValues.size(); i++) {
+ if (i > 0) {
+ sb.append(',');
+ }
+ sb.append(varyValues.get(i).toString());
+ }
+ ((javax.servlet.http.HttpServletResponse)httpResponse)
+ .setHeader(HttpHeaders.VARY, sb.toString());
+ }
+ }
+ }
+
+ private static boolean isLanguageMatched(Locale locale, Locale l) {
+
+ String language = locale.getLanguage();
+ return "*".equals(language)
+ || language.equalsIgnoreCase(l.getLanguage());
+ }
+
+ private static boolean isEncMatached(String accepts, String enc) {
+ return accepts == null || "*".equals(accepts) || accepts.contains(enc);
+ }
+
+ private static List<String> parseAcceptEnc(String acceptEnc) {
+ if (StringUtils.isEmpty(acceptEnc)) {
+ return Collections.emptyList();
+ }
+ List<String> list = new LinkedList<>();
+ String[] values = acceptEnc.split(",");
+ for (String value : values) {
+ String[] pair = value.trim().split(";");
+ // ignore encoding qualifiers if any for now
+ list.add(pair[0]);
+ }
+ return list;
+ }
+
+ public ResponseBuilder evaluatePreconditions(EntityTag eTag) {
+ if (eTag == null) {
+ throw new IllegalArgumentException("ETag is null");
+ }
+ return evaluateAll(eTag, null);
+ }
+
+ private ResponseBuilder evaluateAll(EntityTag eTag, Date lastModified) {
+ // http://tools.ietf.org/search/draft-ietf-httpbis-p4-conditional-25#section-5
+ // Check If-Match. If it is not available proceed to checking If-Not-Modified-Since
+ // if it is available and the preconditions are not met - return, otherwise:
+ // Check If-Not-Match. If it is not available proceed to checking If-Modified-Since
+ // otherwise return the evaluation result
+
+ ResponseBuilder rb = evaluateIfMatch(eTag, lastModified);
+ if (rb == null) {
+ rb = evaluateIfNonMatch(eTag, lastModified);
+ }
+ return rb;
+ }
+
+ private ResponseBuilder evaluateIfMatch(EntityTag eTag, Date date) {
+ List<String> ifMatch = headers.getRequestHeader(HttpHeaders.IF_MATCH);
+
+ if (ifMatch == null || ifMatch.isEmpty()) {
+ return date == null ? null : evaluateIfNotModifiedSince(date);
+ }
+
+ try {
+ for (String value : ifMatch) {
+ if ("*".equals(value)) {
+ return null;
+ }
+ EntityTag requestTag = EntityTag.valueOf(value);
+ // must be a strong comparison
+ if (!requestTag.isWeak() && !eTag.isWeak() && requestTag.equals(eTag)) {
+ return null;
+ }
+ }
+ } catch (IllegalArgumentException ex) {
+ // ignore
+ }
+ return Response.status(Response.Status.PRECONDITION_FAILED).tag(eTag);
+ }
+
+ private ResponseBuilder evaluateIfNonMatch(EntityTag eTag, Date lastModified) {
+ List<String> ifNonMatch = headers.getRequestHeader(HttpHeaders.IF_NONE_MATCH);
+
+ if (ifNonMatch == null || ifNonMatch.isEmpty()) {
+ return lastModified == null ? null : evaluateIfModifiedSince(lastModified);
+ }
+
+ String method = getMethod();
+ boolean getOrHead = HttpMethod.GET.equals(method) || HttpMethod.HEAD.equals(method);
+ try {
+ for (String value : ifNonMatch) {
+ boolean result = "*".equals(value);
+ if (!result) {
+ EntityTag requestTag = EntityTag.valueOf(value);
+ result = getOrHead ? requestTag.equals(eTag)
+ : !requestTag.isWeak() && !eTag.isWeak() && requestTag.equals(eTag);
+ }
+ if (result) {
+ Response.Status status = getOrHead ? Response.Status.NOT_MODIFIED
+ : Response.Status.PRECONDITION_FAILED;
+ return Response.status(status).tag(eTag);
+ }
+ }
+ } catch (IllegalArgumentException ex) {
+ // ignore
+ }
+ return null;
+ }
+
+ public ResponseBuilder evaluatePreconditions(Date lastModified) {
+ if (lastModified == null) {
+ throw new IllegalArgumentException("Date is null");
+ }
+ ResponseBuilder rb = evaluateIfNotModifiedSince(lastModified);
+ if (rb == null) {
+ rb = evaluateIfModifiedSince(lastModified);
+ }
+ return rb;
+ }
+
+ private ResponseBuilder evaluateIfModifiedSince(Date lastModified) {
+ List<String> ifModifiedSince = headers.getRequestHeader(HttpHeaders.IF_MODIFIED_SINCE);
+
+ if (ifModifiedSince == null || ifModifiedSince.isEmpty()) {
+ return null;
+ }
+
+ SimpleDateFormat dateFormat = HttpUtils.getHttpDateFormat();
+
+ dateFormat.setLenient(false);
+ final Date dateSince;
+ try {
+ dateSince = dateFormat.parse(ifModifiedSince.get(0));
+ } catch (ParseException ex) {
+ // invalid header value, request should continue
+ return Response.status(Response.Status.PRECONDITION_FAILED);
+ }
+
+ if (dateSince.before(lastModified)) {
+ // request should continue
+ return null;
+ }
+
+ return Response.status(Response.Status.NOT_MODIFIED);
+ }
+
+ private ResponseBuilder evaluateIfNotModifiedSince(Date lastModified) {
+ List<String> ifNotModifiedSince = headers.getRequestHeader(HttpHeaders.IF_UNMODIFIED_SINCE);
+
+ if (ifNotModifiedSince == null || ifNotModifiedSince.isEmpty()) {
+ return null;
+ }
+
+ SimpleDateFormat dateFormat = HttpUtils.getHttpDateFormat();
+
+ dateFormat.setLenient(false);
+ final Date dateSince;
+ try {
+ dateSince = dateFormat.parse(ifNotModifiedSince.get(0));
+ } catch (ParseException ex) {
+ // invalid header value, request should continue
+ return Response.status(Response.Status.PRECONDITION_FAILED);
+ }
+
+ if (dateSince.before(lastModified)) {
+ return Response.status(Response.Status.PRECONDITION_FAILED);
+ }
+
+ return null;
+ }
+
+
+
+ public ResponseBuilder evaluatePreconditions(Date lastModified, EntityTag eTag) {
+ if (eTag == null || lastModified == null) {
+ throw new IllegalArgumentException("ETag or Date is null");
+ }
+ return evaluateAll(eTag, lastModified);
+ }
+
+ public String getMethod() {
+ return m.get(Message.HTTP_REQUEST_METHOD).toString();
+ }
+
+
+
+ public ResponseBuilder evaluatePreconditions() {
+ List<String> ifMatch = headers.getRequestHeader(HttpHeaders.IF_MATCH);
+ if (ifMatch != null) {
+ for (String value : ifMatch) {
+ if (!"*".equals(value)) {
+ return Response.status(Response.Status.PRECONDITION_FAILED).tag(EntityTag.valueOf(value));
+ }
+ }
+ }
+ return null;
+ }
+
+ private static class VariantComparator implements Comparator<Variant> {
+
+ static final VariantComparator INSTANCE = new VariantComparator();
+
+ public int compare(Variant v1, Variant v2) {
+ int result = compareMediaTypes(v1.getMediaType(), v2.getMediaType());
+
+ if (result != 0) {
+ return result;
+ }
+
+ result = compareLanguages(v1.getLanguage(), v2.getLanguage());
+
+ if (result == 0) {
+ result = compareEncodings(v1.getEncoding(), v2.getEncoding());
+ }
+
+ return result;
+ }
+
+ private static int compareMediaTypes(MediaType mt1, MediaType mt2) {
+ if (mt1 != null && mt2 == null) {
+ return -1;
+ } else if (mt1 == null && mt2 != null) {
+ return 1;
+ }
+ return JAXRSUtils.compareMediaTypes(mt1, mt2);
+ }
+
+ private static int compareLanguages(Locale l1, Locale l2) {
+ if (l1 != null && l2 == null) {
+ return -1;
+ } else if (l1 == null && l2 != null) {
+ return 1;
+ }
+ return 0;
+ }
+
+ private static int compareEncodings(String enc1, String enc2) {
+ if (enc1 != null && enc2 == null) {
+ return -1;
+ } else if (enc1 == null && enc2 != null) {
+ return 1;
+ }
+ return 0;
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/impl/ResourceContextImpl.java b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/ResourceContextImpl.java
new file mode 100644
index 0000000..ca1e629
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/ResourceContextImpl.java
@@ -0,0 +1,67 @@
+/**
+ * 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.cxf.jaxrs.impl;
+
+import javax.ws.rs.container.ResourceContext;
+
+import org.apache.cxf.jaxrs.ext.ResourceContextProvider;
+import org.apache.cxf.jaxrs.lifecycle.PerRequestResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.model.ClassResourceInfo;
+import org.apache.cxf.jaxrs.model.OperationResourceInfo;
+import org.apache.cxf.jaxrs.provider.ServerProviderFactory;
+import org.apache.cxf.message.Message;
+
+public class ResourceContextImpl implements ResourceContext {
+ private static final String CONTEXT_PROVIDER_PROP = "org.apache.cxf.jaxrs.resource.context.provider";
+ private final ClassResourceInfo cri;
+ private final Class<?> subClass;
+ private final Message m;
+ public ResourceContextImpl(Message m, OperationResourceInfo ori) {
+ this.m = m;
+ this.cri = ori.getClassResourceInfo();
+ this.subClass = ori.getMethodToInvoke().getReturnType();
+ }
+
+ @Override
+ public <T> T getResource(Class<T> cls) {
+ final ResourceProvider rp;
+
+ Object propValue = m.getContextualProperty(CONTEXT_PROVIDER_PROP);
+ if (propValue instanceof ResourceContextProvider) {
+ rp = ((ResourceContextProvider)propValue).getResourceProvider(cls);
+ } else {
+ rp = new PerRequestResourceProvider(cls);
+ }
+ T resource = cls.cast(rp.getInstance(m));
+ return doInitResource(cls, resource);
+ }
+
+ @Override
+ public <T> T initResource(T resource) {
+ return doInitResource(resource.getClass(), resource);
+ }
+
+ private <T> T doInitResource(Class<?> cls, T resource) {
+ ClassResourceInfo sub = cri.getSubResource(subClass, cls, resource, true, m);
+ sub.initBeanParamInfo(ServerProviderFactory.getInstance(m));
+ sub.injectContexts(resource, m.getExchange().get(OperationResourceInfo.class), m);
+ return resource;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/impl/tl/ThreadLocalInvocationHandler.java b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/tl/ThreadLocalInvocationHandler.java
new file mode 100644
index 0000000..bb27b5a
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/tl/ThreadLocalInvocationHandler.java
@@ -0,0 +1,53 @@
+/**
+ * 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.cxf.jaxrs.impl.tl;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+
+public class ThreadLocalInvocationHandler<T> extends AbstractThreadLocalProxy<T>
+ implements InvocationHandler {
+
+ public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
+ final Object target;
+ if (m.getDeclaringClass() == ThreadLocalProxy.class) {
+ target = this;
+ } else {
+ target = get();
+ if (target == null) {
+ if (m.getName().endsWith("toString")) {
+ return null;
+ }
+ Class<?> contextCls = m.getDeclaringClass();
+ throw new NullPointerException(
+ contextCls.getName()
+ + " context class has not been injected."
+ + " Check if ContextProvider supporting this class is registered");
+ }
+ }
+ try {
+ return m.invoke(target, args);
+ } catch (InvocationTargetException e) {
+ throw e.getCause();
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/interceptor/JAXRSInInterceptor.java b/transform/src/patch/java/org/apache/cxf/jaxrs/interceptor/JAXRSInInterceptor.java
new file mode 100644
index 0000000..3c9c5d8
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/interceptor/JAXRSInInterceptor.java
@@ -0,0 +1,274 @@
+/**
+ * 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.cxf.jaxrs.interceptor;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.NotFoundException;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.interceptor.OutgoingChainInterceptor;
+import org.apache.cxf.jaxrs.impl.MetadataMap;
+import org.apache.cxf.jaxrs.impl.RequestPreprocessor;
+import org.apache.cxf.jaxrs.impl.UriInfoImpl;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;
+import org.apache.cxf.jaxrs.model.ClassResourceInfo;
+import org.apache.cxf.jaxrs.model.OperationResourceInfo;
+import org.apache.cxf.jaxrs.model.URITemplate;
+import org.apache.cxf.jaxrs.provider.ServerProviderFactory;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageContentsList;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.phase.Phase;
+
+public class JAXRSInInterceptor extends AbstractPhaseInterceptor<Message> {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(JAXRSInInterceptor.class);
+ private static final ResourceBundle BUNDLE = BundleUtils.getBundle(JAXRSInInterceptor.class);
+ private static final String RESOURCE_METHOD = "org.apache.cxf.resource.method";
+ private static final String RESOURCE_OPERATION_NAME = "org.apache.cxf.resource.operation.name";
+
+ public JAXRSInInterceptor() {
+ super(Phase.UNMARSHAL);
+ }
+
+ public void handleMessage(Message message) {
+ final Exchange exchange = message.getExchange();
+
+ exchange.put(Message.REST_MESSAGE, Boolean.TRUE);
+ Response response = exchange.get(Response.class);
+ if (response == null) {
+ try {
+ processRequest(message, exchange);
+ if (exchange.isOneWay()) {
+ ServerProviderFactory.getInstance(message).clearThreadLocalProxies();
+ }
+ } catch (Fault ex) {
+ convertExceptionToResponseIfPossible(ex.getCause(), message);
+ } catch (RuntimeException ex) {
+ convertExceptionToResponseIfPossible(ex, message);
+ } catch (IOException ex) {
+ convertExceptionToResponseIfPossible(ex, message);
+ }
+ }
+
+ response = exchange.get(Response.class);
+ if (response != null) {
+ createOutMessage(message, response);
+ message.getInterceptorChain().doInterceptStartingAt(message,
+ OutgoingChainInterceptor.class.getName());
+ }
+ }
+
+ private void processRequest(Message message, Exchange exchange) throws IOException {
+
+ ServerProviderFactory providerFactory = ServerProviderFactory.getInstance(message);
+
+ RequestPreprocessor rp = providerFactory.getRequestPreprocessor();
+ if (rp != null) {
+ rp.preprocess(message, new UriInfoImpl(message, null));
+ }
+
+ // Global pre-match request filters
+ if (JAXRSUtils.runContainerRequestFilters(providerFactory, message, true, null)) {
+ return;
+ }
+ // HTTP method
+ String httpMethod = HttpUtils.getProtocolHeader(message, Message.HTTP_REQUEST_METHOD,
+ HttpMethod.POST, true);
+
+ // Path to match
+ String rawPath = HttpUtils.getPathToMatch(message, true);
+
+ Map<String, List<String>> protocolHeaders = CastUtils.cast((Map<?, ?>)message.get(Message.PROTOCOL_HEADERS));
+
+ // Content-Type
+ String requestContentType = null;
+ List<String> ctHeaderValues = protocolHeaders.get(Message.CONTENT_TYPE);
+ if (ctHeaderValues != null && !ctHeaderValues.isEmpty()) {
+ requestContentType = ctHeaderValues.get(0);
+ message.put(Message.CONTENT_TYPE, requestContentType);
+ }
+ if (requestContentType == null) {
+ requestContentType = (String)message.get(Message.CONTENT_TYPE);
+
+ if (requestContentType == null) {
+ requestContentType = MediaType.WILDCARD;
+ }
+ }
+
+ // Accept
+ String acceptTypes = null;
+ List<String> acceptHeaderValues = protocolHeaders.get(Message.ACCEPT_CONTENT_TYPE);
+ if (acceptHeaderValues != null && !acceptHeaderValues.isEmpty()) {
+ acceptTypes = acceptHeaderValues.get(0);
+ message.put(Message.ACCEPT_CONTENT_TYPE, acceptTypes);
+ }
+
+ if (acceptTypes == null) {
+ acceptTypes = HttpUtils.getProtocolHeader(message, Message.ACCEPT_CONTENT_TYPE, null);
+ if (acceptTypes == null) {
+ acceptTypes = "*/*";
+ message.put(Message.ACCEPT_CONTENT_TYPE, acceptTypes);
+ }
+ }
+ final List<MediaType> acceptContentTypes;
+ try {
+ acceptContentTypes = JAXRSUtils.sortMediaTypes(acceptTypes, JAXRSUtils.MEDIA_TYPE_Q_PARAM);
+ } catch (IllegalArgumentException ex) {
+ throw ExceptionUtils.toNotAcceptableException(null, null);
+ }
+ exchange.put(Message.ACCEPT_CONTENT_TYPE, acceptContentTypes);
+
+ //1. Matching target resource class
+ List<ClassResourceInfo> resources = JAXRSUtils.getRootResources(message);
+ Map<ClassResourceInfo, MultivaluedMap<String, String>> matchedResources =
+ JAXRSUtils.selectResourceClass(resources, rawPath, message);
+ if (matchedResources == null) {
+ org.apache.cxf.common.i18n.Message errorMsg =
+ new org.apache.cxf.common.i18n.Message("NO_ROOT_EXC",
+ BUNDLE,
+ message.get(Message.REQUEST_URI),
+ rawPath);
+ Level logLevel = JAXRSUtils.getExceptionLogLevel(message, NotFoundException.class);
+ LOG.log(logLevel == null ? Level.FINE : logLevel, errorMsg.toString());
+ Response resp = JAXRSUtils.createResponse(resources, message, errorMsg.toString(),
+ Response.Status.NOT_FOUND.getStatusCode(), false);
+ throw ExceptionUtils.toNotFoundException(null, resp);
+ }
+
+ MultivaluedMap<String, String> matchedValues = new MetadataMap<>();
+
+ final OperationResourceInfo ori;
+
+ try {
+ ori = JAXRSUtils.findTargetMethod(matchedResources, message,
+ httpMethod, matchedValues, requestContentType, acceptContentTypes, true, true);
+ setExchangeProperties(message, exchange, ori, matchedValues, resources.size());
+ } catch (WebApplicationException ex) {
+ if (JAXRSUtils.noResourceMethodForOptions(ex.getResponse(), httpMethod)) {
+ Response response = JAXRSUtils.createResponse(resources, null, null, 200, true);
+ exchange.put(Response.class, response);
+ return;
+ }
+ throw ex;
+ }
+
+
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Request path is: " + rawPath);
+ LOG.fine("Request HTTP method is: " + httpMethod);
+ LOG.fine("Request contentType is: " + requestContentType);
+ LOG.fine("Accept contentType is: " + acceptTypes);
+
+ LOG.fine("Found operation: " + ori.getMethodToInvoke().getName());
+ }
+
+ // Global and name-bound post-match request filters
+ if (!ori.isSubResourceLocator()
+ && JAXRSUtils.runContainerRequestFilters(providerFactory,
+ message,
+ false,
+ ori.getNameBindings())) {
+ return;
+ }
+
+
+ //Process parameters
+ List<Object> params = JAXRSUtils.processParameters(ori, matchedValues, message);
+ message.setContent(List.class, params);
+ }
+
+ private void convertExceptionToResponseIfPossible(Throwable ex, Message message) {
+ Response excResponse = JAXRSUtils.convertFaultToResponse(ex, message);
+ if (excResponse == null) {
+ ServerProviderFactory.getInstance(message).clearThreadLocalProxies();
+ message.getExchange().put(Message.PROPOGATE_EXCEPTION,
+ ExceptionUtils.propogateException(message));
+ throw ex instanceof RuntimeException ? (RuntimeException)ex
+ : ExceptionUtils.toInternalServerErrorException(ex, null);
+ }
+ message.getExchange().put(Response.class, excResponse);
+ message.getExchange().put(Throwable.class, ex);
+ }
+
+ private void setExchangeProperties(Message message,
+ Exchange exchange,
+ OperationResourceInfo ori,
+ MultivaluedMap<String, String> values,
+ int numberOfResources) {
+ final ClassResourceInfo cri = ori.getClassResourceInfo();
+ exchange.put(OperationResourceInfo.class, ori);
+ exchange.put(JAXRSUtils.ROOT_RESOURCE_CLASS, cri);
+ message.put(RESOURCE_METHOD, ori.getMethodToInvoke());
+ message.put(URITemplate.TEMPLATE_PARAMETERS, values);
+ message.put(URITemplate.URI_TEMPLATE, JAXRSUtils.getUriTemplate(message, cri, ori));
+
+ String plainOperationName = ori.getMethodToInvoke().getName();
+ if (numberOfResources > 1) {
+ plainOperationName = cri.getServiceClass().getSimpleName() + "#" + plainOperationName;
+ }
+ exchange.put(RESOURCE_OPERATION_NAME, plainOperationName);
+
+ if (ori.isOneway()
+ || PropertyUtils.isTrue(HttpUtils.getProtocolHeader(message, Message.ONE_WAY_REQUEST, null))) {
+ exchange.setOneWay(true);
+ }
+ ResourceProvider rp = cri.getResourceProvider();
+ if (rp instanceof SingletonResourceProvider) {
+ //cri.isSingleton is not guaranteed to indicate we have a 'pure' singleton
+ exchange.put(Message.SERVICE_OBJECT, rp.getInstance(message));
+ }
+ }
+
+ private Message createOutMessage(Message inMessage, Response r) {
+ Endpoint e = inMessage.getExchange().getEndpoint();
+ Message mout = e.getBinding().createMessage();
+ mout.setContent(List.class, new MessageContentsList(r));
+ mout.setExchange(inMessage.getExchange());
+ mout.setInterceptorChain(
+ OutgoingChainInterceptor.getOutInterceptorChain(inMessage.getExchange()));
+ inMessage.getExchange().setOutMessage(mout);
+ if (r.getStatus() >= Response.Status.BAD_REQUEST.getStatusCode()) {
+ inMessage.getExchange().put("cxf.io.cacheinput", Boolean.FALSE);
+ }
+ return mout;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/interceptor/JAXRSOutInterceptor.java b/transform/src/patch/java/org/apache/cxf/jaxrs/interceptor/JAXRSOutInterceptor.java
new file mode 100644
index 0000000..ad75c0f
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/interceptor/JAXRSOutInterceptor.java
@@ -0,0 +1,498 @@
+/**
+ * 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.cxf.jaxrs.interceptor;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.WriterInterceptor;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.stream.events.XMLEvent;
+
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.interceptor.AbstractOutDatabindingInterceptor;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.jaxrs.impl.ResponseImpl;
+import org.apache.cxf.jaxrs.impl.WriterInterceptorMBW;
+import org.apache.cxf.jaxrs.model.OperationResourceInfo;
+import org.apache.cxf.jaxrs.provider.AbstractConfigurableProvider;
+import org.apache.cxf.jaxrs.provider.ServerProviderFactory;
+import org.apache.cxf.jaxrs.utils.AnnotationUtils;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageContentsList;
+import org.apache.cxf.message.MessageUtils;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.staxutils.CachingXmlEventWriter;
+import org.apache.cxf.staxutils.StaxUtils;
+import org.apache.cxf.transport.http.AbstractHTTPDestination;
+
+public class JAXRSOutInterceptor extends AbstractOutDatabindingInterceptor {
+ private static final Logger LOG = LogUtils.getL7dLogger(JAXRSOutInterceptor.class);
+ private static final ResourceBundle BUNDLE = BundleUtils.getBundle(JAXRSOutInterceptor.class);
+
+ public JAXRSOutInterceptor() {
+ super(Phase.MARSHAL);
+ }
+
+ public void handleMessage(Message message) {
+ ServerProviderFactory providerFactory = ServerProviderFactory.getInstance(message);
+ try {
+ processResponse(providerFactory, message);
+ } finally {
+ ServerProviderFactory.releaseRequestState(providerFactory, message);
+ }
+
+
+ }
+
+ @SuppressWarnings("resource") // Response shouldn't be closed here
+ private void processResponse(ServerProviderFactory providerFactory, Message message) {
+
+ if (isResponseAlreadyHandled(message)) {
+ return;
+ }
+ MessageContentsList objs = MessageContentsList.getContentsList(message);
+ if (objs == null || objs.isEmpty()) {
+ return;
+ }
+
+ Object responseObj = objs.get(0);
+
+ final Response response;
+ if (responseObj instanceof Response) {
+ response = (Response)responseObj;
+ if (response.getStatus() == 500
+ && message.getExchange().get(JAXRSUtils.EXCEPTION_FROM_MAPPER) != null) {
+ message.put(Message.RESPONSE_CODE, 500);
+ return;
+ }
+ } else {
+ int status = getStatus(message, responseObj != null ? 200 : 204);
+ response = JAXRSUtils.toResponseBuilder(status).entity(responseObj).build();
+ }
+
+ Exchange exchange = message.getExchange();
+ OperationResourceInfo ori = (OperationResourceInfo)exchange.get(OperationResourceInfo.class
+ .getName());
+
+ serializeMessage(providerFactory, message, response, ori, true);
+ }
+
+
+
+ private int getStatus(Message message, int defaultValue) {
+ Object customStatus = message.getExchange().get(Message.RESPONSE_CODE);
+ return customStatus == null ? defaultValue : (Integer)customStatus;
+ }
+
+ private void serializeMessage(ServerProviderFactory providerFactory,
+ Message message,
+ Response theResponse,
+ OperationResourceInfo ori,
+ boolean firstTry) {
+
+ ResponseImpl response = (ResponseImpl)JAXRSUtils.copyResponseIfNeeded(theResponse);
+
+ final Exchange exchange = message.getExchange();
+
+ boolean headResponse = response.getStatus() == 200 && firstTry
+ && ori != null && HttpMethod.HEAD.equals(ori.getHttpMethod());
+ Object entity = response.getActualEntity();
+ if (headResponse && entity != null) {
+ LOG.info(new org.apache.cxf.common.i18n.Message("HEAD_WITHOUT_ENTITY", BUNDLE).toString());
+ entity = null;
+ }
+
+
+ Method invoked = ori == null ? null : ori.getAnnotatedMethod() != null
+ ? ori.getAnnotatedMethod() : ori.getMethodToInvoke();
+
+ Annotation[] annotations;
+ Annotation[] staticAnns = ori != null ? ori.getOutAnnotations() : new Annotation[]{};
+ Annotation[] responseAnns = response.getEntityAnnotations();
+ if (responseAnns != null) {
+ annotations = new Annotation[staticAnns.length + responseAnns.length];
+ System.arraycopy(staticAnns, 0, annotations, 0, staticAnns.length);
+ System.arraycopy(responseAnns, 0, annotations, staticAnns.length, responseAnns.length);
+ } else {
+ annotations = staticAnns;
+ }
+
+ response.setStatus(getActualStatus(response.getStatus(), entity));
+ response.setEntity(entity, annotations);
+
+ // Prepare the headers
+ MultivaluedMap<String, Object> responseHeaders =
+ prepareResponseHeaders(message, response, entity, firstTry);
+
+ // Run the filters
+ try {
+ JAXRSUtils.runContainerResponseFilters(providerFactory, response, message, ori, invoked);
+ } catch (Throwable ex) {
+ handleWriteException(providerFactory, message, ex, firstTry);
+ return;
+ }
+
+ // Write the entity
+ entity = InjectionUtils.getEntity(response.getActualEntity());
+ setResponseStatus(message, getActualStatus(response.getStatus(), entity));
+ if (entity == null) {
+ if (!headResponse) {
+ responseHeaders.putSingle(HttpHeaders.CONTENT_LENGTH, "0");
+ if (MessageUtils.getContextualBoolean(message, "remove.content.type.for.empty.response", false)) {
+ responseHeaders.remove(HttpHeaders.CONTENT_TYPE);
+ message.remove(Message.CONTENT_TYPE);
+ }
+ }
+ HttpUtils.convertHeaderValuesToString(responseHeaders, true);
+ return;
+ }
+
+ Object ignoreWritersProp = exchange.get(JAXRSUtils.IGNORE_MESSAGE_WRITERS);
+ boolean ignoreWriters =
+ ignoreWritersProp != null && Boolean.valueOf(ignoreWritersProp.toString());
+ if (ignoreWriters) {
+ writeResponseToStream(message.getContent(OutputStream.class), entity);
+ return;
+ }
+
+ MediaType responseMediaType =
+ getResponseMediaType(responseHeaders.getFirst(HttpHeaders.CONTENT_TYPE));
+
+ Class<?> serviceCls = invoked != null ? ori.getClassResourceInfo().getServiceClass() : null;
+ Class<?> targetType = InjectionUtils.getRawResponseClass(entity);
+ Type genericType = InjectionUtils.getGenericResponseType(invoked, serviceCls,
+ response.getActualEntity(), targetType, exchange);
+ targetType = InjectionUtils.updateParamClassToTypeIfNeeded(targetType, genericType);
+ annotations = response.getEntityAnnotations();
+
+ List<WriterInterceptor> writers = providerFactory
+ .createMessageBodyWriterInterceptor(targetType, genericType, annotations, responseMediaType, message,
+ ori == null ? null : ori.getNameBindings());
+
+ OutputStream outOriginal = message.getContent(OutputStream.class);
+ if (writers == null || writers.isEmpty()) {
+ writeResponseErrorMessage(message, outOriginal, "NO_MSG_WRITER", targetType, responseMediaType);
+ return;
+ }
+ try {
+ boolean checkWriters = false;
+ if (responseMediaType.isWildcardSubtype()) {
+ Produces pM = AnnotationUtils.getMethodAnnotation(ori == null ? null : ori.getAnnotatedMethod(),
+ Produces.class);
+ Produces pC = AnnotationUtils.getClassAnnotation(serviceCls, Produces.class);
+ checkWriters = pM == null && pC == null;
+ }
+ responseMediaType = checkFinalContentType(responseMediaType, writers, checkWriters);
+ } catch (Throwable ex) {
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.log(Level.FINE, ex.getMessage(), ex);
+ }
+ handleWriteException(providerFactory, message, ex, firstTry);
+ return;
+ }
+ String finalResponseContentType = JAXRSUtils.mediaTypeToString(responseMediaType);
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.fine("Response content type is: " + finalResponseContentType);
+ }
+ responseHeaders.putSingle(HttpHeaders.CONTENT_TYPE, finalResponseContentType);
+ message.put(Message.CONTENT_TYPE, finalResponseContentType);
+
+ boolean enabled = checkBufferingMode(message, writers, firstTry);
+ try {
+
+ try { // NOPMD
+ JAXRSUtils.writeMessageBody(writers,
+ entity,
+ targetType,
+ genericType,
+ annotations,
+ responseMediaType,
+ responseHeaders,
+ message);
+
+ if (isResponseRedirected(message)) {
+ return;
+ }
+ checkCachedStream(message, outOriginal, enabled);
+ } finally {
+ if (enabled) {
+ OutputStream os = message.getContent(OutputStream.class);
+ if (os != outOriginal && os instanceof CachedOutputStream) {
+ os.close();
+ }
+ message.setContent(OutputStream.class, outOriginal);
+ message.put(XMLStreamWriter.class.getName(), null);
+ }
+ }
+
+ } catch (Throwable ex) {
+ logWriteError(firstTry, targetType, responseMediaType);
+ handleWriteException(providerFactory, message, ex, firstTry);
+ }
+ }
+
+ private MultivaluedMap<String, Object> prepareResponseHeaders(Message message,
+ ResponseImpl response,
+ Object entity,
+ boolean firstTry) {
+ MultivaluedMap<String, Object> responseHeaders = response.getMetadata();
+ @SuppressWarnings("unchecked")
+ Map<String, List<Object>> userHeaders = (Map<String, List<Object>>)message.get(Message.PROTOCOL_HEADERS);
+ if (firstTry && userHeaders != null) {
+ responseHeaders.putAll(userHeaders);
+ }
+ if (entity != null) {
+ Object customContentType = responseHeaders.getFirst(HttpHeaders.CONTENT_TYPE);
+ if (customContentType == null) {
+ String initialResponseContentType = (String)message.get(Message.CONTENT_TYPE);
+ if (initialResponseContentType != null) {
+ responseHeaders.putSingle(HttpHeaders.CONTENT_TYPE, initialResponseContentType);
+ }
+ } else {
+ message.put(Message.CONTENT_TYPE, customContentType.toString());
+ }
+ }
+ message.put(Message.PROTOCOL_HEADERS, responseHeaders);
+ setResponseDate(responseHeaders, firstTry);
+ return responseHeaders;
+ }
+
+ private MediaType getResponseMediaType(Object mediaTypeHeader) {
+ MediaType responseMediaType;
+ if (mediaTypeHeader instanceof MediaType) {
+ responseMediaType = (MediaType)mediaTypeHeader;
+ } else {
+ responseMediaType = mediaTypeHeader == null ? MediaType.WILDCARD_TYPE
+ : JAXRSUtils.toMediaType(mediaTypeHeader.toString());
+ }
+ return responseMediaType;
+ }
+
+ private int getActualStatus(int status, Object responseObj) {
+ if (status == -1) {
+ return responseObj == null ? 204 : 200;
+ }
+ return status;
+ }
+
+ private boolean checkBufferingMode(Message m, List<WriterInterceptor> writers, boolean firstTry) {
+ if (!firstTry) {
+ return false;
+ }
+ WriterInterceptor last = writers.get(writers.size() - 1);
+ MessageBodyWriter<Object> w = ((WriterInterceptorMBW)last).getMBW();
+ Object outBuf = m.getContextualProperty(OUT_BUFFERING);
+ boolean enabled = PropertyUtils.isTrue(outBuf);
+ boolean configurableProvider = w instanceof AbstractConfigurableProvider;
+ if (!enabled && outBuf == null && configurableProvider) {
+ enabled = ((AbstractConfigurableProvider)w).getEnableBuffering();
+ }
+ if (enabled) {
+ boolean streamingOn = configurableProvider
+ && ((AbstractConfigurableProvider)w).getEnableStreaming();
+ if (streamingOn) {
+ m.setContent(XMLStreamWriter.class, new CachingXmlEventWriter());
+ } else {
+ m.setContent(OutputStream.class, new CachedOutputStream());
+ }
+ }
+ return enabled;
+ }
+
+ private void checkCachedStream(Message m, OutputStream osOriginal, boolean enabled) throws Exception {
+ final XMLStreamWriter writer;
+ if (enabled) {
+ writer = m.getContent(XMLStreamWriter.class);
+ } else {
+ writer = (XMLStreamWriter)m.get(XMLStreamWriter.class.getName());
+ }
+ if (writer instanceof CachingXmlEventWriter) {
+ CachingXmlEventWriter cache = (CachingXmlEventWriter)writer;
+ if (!cache.getEvents().isEmpty()) {
+ XMLStreamWriter origWriter = null;
+ try {
+ origWriter = StaxUtils.createXMLStreamWriter(osOriginal);
+ for (XMLEvent event : cache.getEvents()) {
+ StaxUtils.writeEvent(event, origWriter);
+ }
+ } finally {
+ StaxUtils.close(origWriter);
+ }
+ }
+ m.setContent(XMLStreamWriter.class, null);
+ return;
+ }
+ if (enabled) {
+ OutputStream os = m.getContent(OutputStream.class);
+ if (os != osOriginal && os instanceof CachedOutputStream) {
+ CachedOutputStream cos = (CachedOutputStream)os;
+ if (cos.size() != 0) {
+ cos.writeCacheTo(osOriginal);
+ }
+ }
+ }
+ }
+
+ private void logWriteError(boolean firstTry, Class<?> cls, MediaType ct) {
+ if (firstTry) {
+ JAXRSUtils.logMessageHandlerProblem("MSG_WRITER_PROBLEM", cls, ct);
+ }
+ }
+
+ private void handleWriteException(ServerProviderFactory pf,
+ Message message,
+ Throwable ex,
+ boolean firstTry) {
+ Response excResponse = null;
+ if (firstTry) {
+ excResponse = JAXRSUtils.convertFaultToResponse(ex, message);
+ } else {
+ message.getExchange().put(JAXRSUtils.SECOND_JAXRS_EXCEPTION, Boolean.TRUE);
+ }
+ if (excResponse == null) {
+ setResponseStatus(message, 500);
+ throw new Fault(ex);
+ }
+ serializeMessage(pf, message, excResponse, null, false);
+
+ }
+
+
+ private void writeResponseErrorMessage(Message message, OutputStream out,
+ String name, Class<?> cls, MediaType ct) {
+ message.put(Message.CONTENT_TYPE, "text/plain");
+ message.put(Message.RESPONSE_CODE, 500);
+ try {
+ String errorMessage = JAXRSUtils.logMessageHandlerProblem(name, cls, ct);
+ if (out != null) {
+ out.write(errorMessage.getBytes(StandardCharsets.UTF_8));
+ }
+ } catch (IOException another) {
+ // ignore
+ }
+ }
+
+
+ private MediaType checkFinalContentType(MediaType mt, List<WriterInterceptor> writers, boolean checkWriters) {
+ if (checkWriters) {
+ int mbwIndex = writers.size() == 1 ? 0 : writers.size() - 1;
+ MessageBodyWriter<Object> writer = ((WriterInterceptorMBW)writers.get(mbwIndex)).getMBW();
+ Produces pm = writer.getClass().getAnnotation(Produces.class);
+ if (pm != null) {
+ List<MediaType> sorted =
+ JAXRSUtils.sortMediaTypes(JAXRSUtils.getMediaTypes(pm.value()), JAXRSUtils.MEDIA_TYPE_QS_PARAM);
+ mt = JAXRSUtils.intersectMimeTypes(sorted, mt).get(0);
+ }
+ }
+ if (mt.isWildcardType() || mt.isWildcardSubtype()) {
+ if ("application".equals(mt.getType()) || mt.isWildcardType()) {
+ mt = MediaType.APPLICATION_OCTET_STREAM_TYPE;
+ } else {
+ throw ExceptionUtils.toNotAcceptableException(null, null);
+ }
+ }
+ return mt;
+ }
+
+ private void setResponseDate(MultivaluedMap<String, Object> headers, boolean firstTry) {
+ if (!firstTry || headers.containsKey(HttpHeaders.DATE)) {
+ return;
+ }
+ SimpleDateFormat format = HttpUtils.getHttpDateFormat();
+ headers.putSingle(HttpHeaders.DATE, format.format(new Date()));
+ }
+
+ private boolean isResponseAlreadyHandled(Message m) {
+ return isResponseAlreadyCommited(m) || isResponseRedirected(m);
+ }
+
+ private boolean isResponseAlreadyCommited(Message m) {
+ return Boolean.TRUE.equals(m.getExchange().get(AbstractHTTPDestination.RESPONSE_COMMITED));
+ }
+
+ private boolean isResponseRedirected(Message m) {
+ return Boolean.TRUE.equals(m.getExchange().get(AbstractHTTPDestination.REQUEST_REDIRECTED));
+ }
+
+ private void writeResponseToStream(OutputStream os, Object responseObj) {
+ try {
+ byte[] bytes = responseObj.toString().getBytes(StandardCharsets.UTF_8);
+ os.write(bytes, 0, bytes.length);
+ } catch (Exception ex) {
+ LOG.severe("Problem with writing the data to the output stream");
+ ex.printStackTrace();
+ throw new RuntimeException(ex);
+ }
+ }
+
+ private void setResponseStatus(Message message, int status) {
+ message.put(Message.RESPONSE_CODE, status);
+ boolean responseHeadersCopied = isResponseHeadersCopied(message);
+ if (responseHeadersCopied) {
+ HttpServletResponse response =
+ (HttpServletResponse)message.get(AbstractHTTPDestination.HTTP_RESPONSE);
+ response.setStatus(status);
+ }
+ }
+
+ // Some CXF interceptors such as FIStaxOutInterceptor will indirectly initiate
+ // an early copying of response code and headers into the HttpServletResponse
+ // TODO : Pushing the filter processing and copying response headers into say
+ // PRE-LOGICAl and PREPARE_SEND interceptors will most likely be a good thing
+ // however JAX-RS MessageBodyWriters are also allowed to add response headers
+ // which is reason why a MultipartMap parameter in MessageBodyWriter.writeTo
+ // method is modifiable. Thus we do need to know if the initial copy has already
+ // occurred: for now we will just use to ensure the correct status is set
+ private boolean isResponseHeadersCopied(Message message) {
+ return PropertyUtils.isTrue(message.get(AbstractHTTPDestination.RESPONSE_HEADERS_COPIED));
+ }
+
+ public void handleFault(Message message) {
+ // complete
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/model/AbstractResourceInfo.java b/transform/src/patch/java/org/apache/cxf/jaxrs/model/AbstractResourceInfo.java
new file mode 100644
index 0000000..edf010e
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/model/AbstractResourceInfo.java
@@ -0,0 +1,389 @@
+/**
+ * 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.cxf.jaxrs.model;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Context;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ReflectionUtil;
+import org.apache.cxf.jaxrs.impl.tl.ThreadLocalProxy;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+
+public abstract class AbstractResourceInfo {
+ public static final String CONSTRUCTOR_PROXY_MAP = "jaxrs-constructor-proxy-map";
+ private static final Logger LOG = LogUtils.getL7dLogger(AbstractResourceInfo.class);
+ private static final String FIELD_PROXY_MAP = "jaxrs-field-proxy-map";
+ private static final String SETTER_PROXY_MAP = "jaxrs-setter-proxy-map";
+
+ protected boolean root;
+ protected Class<?> resourceClass;
+ protected Class<?> serviceClass;
+
+ private Map<Class<?>, List<Field>> contextFields;
+ private Map<Class<?>, Map<Class<?>, Method>> contextMethods;
+ private Bus bus;
+ private boolean constructorProxiesAvailable;
+ private boolean contextsAvailable;
+
+ protected AbstractResourceInfo(Bus bus) {
+ this.bus = bus;
+ }
+
+ protected AbstractResourceInfo(Class<?> resourceClass, Class<?> serviceClass,
+ boolean isRoot, boolean checkContexts, Bus bus) {
+ this(resourceClass, serviceClass, isRoot, checkContexts, null, bus, null);
+ }
+
+ protected AbstractResourceInfo(Class<?> resourceClass,
+ Class<?> serviceClass,
+ boolean isRoot,
+ boolean checkContexts,
+ Map<Class<?>, ThreadLocalProxy<?>> constructorProxies,
+ Bus bus,
+ Object provider) {
+ this.bus = bus;
+ this.serviceClass = serviceClass;
+ this.resourceClass = resourceClass;
+ root = isRoot;
+ if (checkContexts && resourceClass != null) {
+ findContexts(serviceClass, provider, constructorProxies);
+ }
+ }
+
+ private void findContexts(Class<?> cls, Object provider,
+ Map<Class<?>, ThreadLocalProxy<?>> constructorProxies) {
+ findContextFields(cls, provider);
+ findContextSetterMethods(cls, provider);
+ if (constructorProxies != null) {
+ Map<Class<?>, Map<Class<?>, ThreadLocalProxy<?>>> proxies = getConstructorProxyMap();
+ proxies.put(serviceClass, constructorProxies);
+ constructorProxiesAvailable = true;
+ }
+
+
+ contextsAvailable = contextFields != null && !contextFields.isEmpty()
+ || contextMethods != null && !contextMethods.isEmpty()
+ || constructorProxiesAvailable;
+ }
+
+ public boolean contextsAvailable() {
+ return contextsAvailable;
+ }
+
+ public Bus getBus() {
+ return bus;
+ }
+
+ public void setResourceClass(Class<?> rClass) {
+ resourceClass = rClass;
+ if (serviceClass.isInterface() && resourceClass != null && !resourceClass.isInterface()) {
+ findContexts(resourceClass, null, null);
+ }
+ }
+
+ public Class<?> getServiceClass() {
+ return serviceClass;
+ }
+
+ private void findContextFields(Class<?> cls, Object provider) {
+ if (cls == Object.class || cls == null) {
+ return;
+ }
+ for (Field f : ReflectionUtil.getDeclaredFields(cls)) {
+ for (Annotation a : f.getAnnotations()) {
+ if (a.annotationType() == Context.class
+ && (f.getType().isInterface() || f.getType() == Application.class)) {
+ contextFields = addContextField(contextFields, f);
+ checkContextClass(f.getType());
+ if (!InjectionUtils.VALUE_CONTEXTS.contains(f.getType().getName())) {
+ addToMap(getFieldProxyMap(true), f, getFieldThreadLocalProxy(f, provider));
+ }
+ }
+ }
+ }
+ findContextFields(cls.getSuperclass(), provider);
+ }
+
+ private static ThreadLocalProxy<?> getFieldThreadLocalProxy(Field f, Object provider) {
+ if (provider != null) {
+ Object proxy = null;
+ synchronized (provider) {
+ try {
+ proxy = InjectionUtils.extractFieldValue(f, provider);
+ } catch (Throwable t) {
+ // continue
+ }
+ if (!(proxy instanceof ThreadLocalProxy)) {
+ proxy = InjectionUtils.createThreadLocalProxy(f.getType());
+ InjectionUtils.injectFieldValue(f, provider, proxy);
+ }
+ }
+ return (ThreadLocalProxy<?>)proxy;
+ }
+ return InjectionUtils.createThreadLocalProxy(f.getType());
+ }
+
+ private static ThreadLocalProxy<?> getMethodThreadLocalProxy(Method m, Object provider) {
+ if (provider != null) {
+ Object proxy = null;
+ synchronized (provider) {
+ try {
+ proxy = InjectionUtils.extractFromMethod(provider,
+ InjectionUtils.getGetterFromSetter(m),
+ false);
+ } catch (Throwable t) {
+ // continue
+ }
+ if (!(proxy instanceof ThreadLocalProxy)) {
+ proxy = InjectionUtils.createThreadLocalProxy(m.getParameterTypes()[0]);
+ InjectionUtils.injectThroughMethod(provider, m, proxy);
+ }
+ }
+ return (ThreadLocalProxy<?>)proxy;
+ }
+ return InjectionUtils.createThreadLocalProxy(m.getParameterTypes()[0]);
+ }
+
+ @SuppressWarnings("unchecked")
+ private <T> Map<Class<?>, Map<T, ThreadLocalProxy<?>>> getProxyMap(String prop, boolean create) {
+ // Avoid synchronizing on the bus for a ConcurrentHashMAp
+ if (bus.getProperties() instanceof ConcurrentHashMap) {
+ return (Map<Class<?>, Map<T, ThreadLocalProxy<?>>>) bus.getProperties().computeIfAbsent(prop, k ->
+ new ConcurrentHashMap<Class<?>, Map<T, ThreadLocalProxy<?>>>(2)
+ );
+ }
+
+ Object property;
+ synchronized (bus) {
+ property = bus.getProperty(prop);
+ if (property == null && create) {
+ Map<Class<?>, Map<T, ThreadLocalProxy<?>>> map
+ = new ConcurrentHashMap<>(2);
+ bus.setProperty(prop, map);
+ property = map;
+ }
+ }
+ return (Map<Class<?>, Map<T, ThreadLocalProxy<?>>>)property;
+ }
+
+ public Map<Class<?>, ThreadLocalProxy<?>> getConstructorProxies() {
+ if (constructorProxiesAvailable) {
+ return getConstructorProxyMap().get(serviceClass);
+ }
+ return null;
+ }
+
+ @SuppressWarnings("unchecked")
+ private Map<Class<?>, Map<Class<?>, ThreadLocalProxy<?>>> getConstructorProxyMap() {
+ Object property = bus.getProperty(CONSTRUCTOR_PROXY_MAP);
+ if (property == null) {
+ Map<Class<?>, Map<Class<?>, ThreadLocalProxy<?>>> map
+ = new ConcurrentHashMap<>(2);
+ bus.setProperty(CONSTRUCTOR_PROXY_MAP, map);
+ property = map;
+ }
+ return (Map<Class<?>, Map<Class<?>, ThreadLocalProxy<?>>>)property;
+ }
+
+ private Map<Class<?>, Map<Field, ThreadLocalProxy<?>>> getFieldProxyMap(boolean create) {
+ return getProxyMap(FIELD_PROXY_MAP, create);
+ }
+
+ private Map<Class<?>, Map<Method, ThreadLocalProxy<?>>> getSetterProxyMap(boolean create) {
+ return getProxyMap(SETTER_PROXY_MAP, create);
+ }
+
+ private void findContextSetterMethods(Class<?> cls, Object provider) {
+
+ for (Method m : cls.getMethods()) {
+
+ if (!m.getName().startsWith("set") || m.getParameterTypes().length != 1) {
+ continue;
+ }
+ for (Annotation a : m.getAnnotations()) {
+ if (a.annotationType() == Context.class) {
+ checkContextMethod(m, provider);
+ break;
+ }
+ }
+ }
+ Class<?>[] interfaces = cls.getInterfaces();
+ for (Class<?> i : interfaces) {
+ findContextSetterMethods(i, provider);
+ }
+ Class<?> superCls = cls.getSuperclass();
+ if (superCls != null && superCls != Object.class) {
+ findContextSetterMethods(superCls, provider);
+ }
+ }
+
+ private void checkContextMethod(Method m, Object provider) {
+ Class<?> type = m.getParameterTypes()[0];
+ if (type.isInterface() || type == Application.class) {
+ checkContextClass(type);
+ addContextMethod(type, m, provider);
+ }
+ }
+ private void checkContextClass(Class<?> type) {
+ if (!InjectionUtils.STANDARD_CONTEXT_CLASSES.contains(type.getName())) {
+ LOG.fine("Injecting a custom context " + type.getName()
+ + ", ContextProvider is required for this type");
+ }
+ }
+
+ public Map<Class<?>, Method> getContextMethods() {
+ Map<Class<?>, Method> methods = contextMethods == null ? null : contextMethods.get(getServiceClass());
+ return methods == null ? Collections.emptyMap()
+ : Collections.unmodifiableMap(methods);
+ }
+
+ private void addContextMethod(Class<?> contextClass, Method m, Object provider) {
+ if (contextMethods == null) {
+ contextMethods = new HashMap<>();
+ }
+ addToMap(contextMethods, contextClass, m);
+ if (!InjectionUtils.VALUE_CONTEXTS.contains(m.getParameterTypes()[0].getName())) {
+ addToMap(getSetterProxyMap(true), m, getMethodThreadLocalProxy(m, provider));
+ }
+ }
+
+ public boolean isRoot() {
+ return root;
+ }
+
+ public Class<?> getResourceClass() {
+ return resourceClass;
+ }
+
+ public List<Field> getContextFields() {
+ return getList(contextFields);
+ }
+
+ public ThreadLocalProxy<?> getContextFieldProxy(Field f) {
+ return getProxy(getFieldProxyMap(true), f);
+ }
+
+ public ThreadLocalProxy<?> getContextSetterProxy(Method m) {
+ return getProxy(getSetterProxyMap(true), m);
+ }
+
+ public abstract boolean isSingleton();
+
+ @SuppressWarnings("rawtypes")
+ public static void clearAllMaps() {
+ Bus bus = BusFactory.getThreadDefaultBus(false);
+ if (bus != null) {
+ Object property = bus.getProperty(FIELD_PROXY_MAP);
+ if (property != null) {
+ ((Map)property).clear();
+ }
+ property = bus.getProperty(SETTER_PROXY_MAP);
+ if (property != null) {
+ ((Map)property).clear();
+ }
+ property = bus.getProperty(CONSTRUCTOR_PROXY_MAP);
+ if (property != null) {
+ ((Map)property).clear();
+ }
+ }
+ }
+
+ public void clearThreadLocalProxies() {
+ clearProxies(getFieldProxyMap(false));
+ clearProxies(getSetterProxyMap(false));
+ clearProxies(getConstructorProxyMap());
+ }
+
+ private <T> void clearProxies(Map<Class<?>, Map<T, ThreadLocalProxy<?>>> tlps) {
+ Map<T, ThreadLocalProxy<?>> proxies = tlps == null ? null : tlps.get(getServiceClass());
+ if (proxies == null) {
+ return;
+ }
+ for (ThreadLocalProxy<?> tlp : proxies.values()) {
+ if (tlp != null) {
+ tlp.remove();
+ }
+ }
+ }
+
+ private Map<Class<?>, List<Field>> addContextField(Map<Class<?>, List<Field>> theFields, Field f) {
+ if (theFields == null) {
+ theFields = new HashMap<>();
+ }
+
+ List<Field> fields = theFields.get(serviceClass);
+ if (fields == null) {
+ fields = new ArrayList<>();
+ theFields.put(serviceClass, fields);
+ }
+ if (!fields.contains(f)) {
+ fields.add(f);
+ }
+ return theFields;
+ }
+
+ private <T, V> void addToMap(Map<Class<?>, Map<T, V>> proxyMap,
+ T f,
+ V proxy) {
+ Map<T, V> proxies = proxyMap.get(serviceClass);
+ if (proxies == null) {
+ proxies = new ConcurrentHashMap<>();
+ proxyMap.put(serviceClass, proxies);
+ }
+ if (!proxies.containsKey(f)) {
+ proxies.put(f, proxy);
+ }
+ }
+
+ private List<Field> getList(Map<Class<?>, List<Field>> fields) {
+ List<Field> ret = fields == null ? null : fields.get(getServiceClass());
+ if (ret != null) {
+ ret = Collections.unmodifiableList(ret);
+ } else {
+ ret = Collections.emptyList();
+ }
+ return ret;
+ }
+
+ private <T> ThreadLocalProxy<?> getProxy(Map<Class<?>, Map<T, ThreadLocalProxy<?>>> proxies,
+ T key) {
+
+ Map<?, ThreadLocalProxy<?>> theMap = proxies == null ? null : proxies.get(getServiceClass());
+ ThreadLocalProxy<?> ret = null;
+ if (theMap != null) {
+ ret = theMap.get(key);
+ }
+ return ret;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java b/transform/src/patch/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java
new file mode 100644
index 0000000..a69cac1
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java
@@ -0,0 +1,366 @@
+/**
+ * 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.cxf.jaxrs.model;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.MediaType;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.common.util.ClassHelper;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.provider.ServerProviderFactory;
+import org.apache.cxf.jaxrs.utils.AnnotationUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.jaxrs.utils.ResourceUtils;
+import org.apache.cxf.message.Message;
+
+public class ClassResourceInfo extends BeanResourceInfo {
+
+ private URITemplate uriTemplate;
+ private MethodDispatcher methodDispatcher;
+ private ResourceProvider resourceProvider;
+ private ConcurrentHashMap<SubresourceKey, ClassResourceInfo> subResources
+ = new ConcurrentHashMap<>();
+
+ private boolean enableStatic;
+ private boolean createdFromModel;
+ private String consumesTypes;
+ private String producesTypes;
+ private List<MediaType> defaultConsumes = Collections.singletonList(JAXRSUtils.ALL_TYPES);
+ private List<MediaType> defaultProduces = Collections.singletonList(JAXRSUtils.ALL_TYPES);
+ private Set<String> nameBindings = Collections.emptySet();
+ private ClassResourceInfo parent;
+ private Set<String> injectedSubInstances = new HashSet<>();
+ public ClassResourceInfo(ClassResourceInfo cri) {
+ super(cri.getBus());
+ if (cri.isCreatedFromModel() && !InjectionUtils.isConcreteClass(cri.getServiceClass())) {
+ this.root = cri.root;
+ this.serviceClass = cri.serviceClass;
+ this.uriTemplate = cri.uriTemplate;
+ this.methodDispatcher = new MethodDispatcher(cri.methodDispatcher, this);
+ this.subResources = cri.subResources;
+ //CHECKSTYLE:OFF
+ this.paramFields = cri.paramFields;
+ this.paramMethods = cri.paramMethods;
+ //CHECKSTYLE:ON
+ this.enableStatic = true;
+ this.nameBindings = cri.nameBindings;
+ this.parent = cri.parent;
+ } else {
+ throw new IllegalArgumentException();
+ }
+
+ }
+
+ public ClassResourceInfo(Class<?> theResourceClass, Class<?> theServiceClass,
+ boolean theRoot, boolean enableStatic, Bus bus) {
+ super(theResourceClass, theServiceClass, theRoot, theRoot || enableStatic, bus);
+ this.enableStatic = enableStatic;
+ if (resourceClass != null) {
+ nameBindings = AnnotationUtils.getNameBindings(bus, serviceClass);
+ }
+ }
+ //CHECKSTYLE:OFF
+ public ClassResourceInfo(Class<?> theResourceClass, Class<?> theServiceClass,
+ boolean theRoot, boolean enableStatic, Bus bus, List<MediaType> defaultProduces,
+ List<MediaType> defaultConsumes) {
+ //CHECKSTYLE:ON
+ this(theResourceClass, theServiceClass, theRoot, enableStatic, bus);
+ if (defaultProduces != null) {
+ this.defaultProduces = defaultProduces;
+ }
+ if (defaultConsumes != null) {
+ this.defaultConsumes = defaultConsumes;
+ }
+ }
+ public ClassResourceInfo(Class<?> theResourceClass, Class<?> theServiceClass,
+ boolean theRoot, boolean enableStatic, boolean createdFromModel, Bus bus) {
+ this(theResourceClass, theServiceClass, theRoot, enableStatic, bus);
+ this.createdFromModel = createdFromModel;
+ }
+ //CHECKSTYLE:OFF
+ public ClassResourceInfo(Class<?> theResourceClass, Class<?> theServiceClass,
+ boolean theRoot, boolean enableStatic, boolean createdFromModel,
+ String consumesTypes, String producesTypes, Bus bus) {
+ //CHECKSTYLE:ON
+ this(theResourceClass, theServiceClass, theRoot, enableStatic, createdFromModel, bus);
+ this.consumesTypes = consumesTypes;
+ this.producesTypes = producesTypes;
+ }
+
+ // The following constructors are used by tests only
+ public ClassResourceInfo(Class<?> theResourceClass) {
+ this(theResourceClass, true);
+ }
+
+ public ClassResourceInfo(Class<?> theResourceClass, boolean theRoot) {
+ this(theResourceClass, theResourceClass, theRoot);
+ }
+
+ public ClassResourceInfo(Class<?> theResourceClass, Class<?> theServiceClass) {
+ this(theResourceClass, theServiceClass, false);
+ }
+
+ public ClassResourceInfo(Class<?> theResourceClass, Class<?> theServiceClass, boolean theRoot) {
+ this(theResourceClass, theServiceClass, theRoot, false, BusFactory.getDefaultBus(true));
+ }
+
+ public ClassResourceInfo findResource(Class<?> typedClass, Class<?> instanceClass) {
+ instanceClass = enableStatic ? typedClass : instanceClass;
+ SubresourceKey key = new SubresourceKey(typedClass, instanceClass);
+ return subResources.get(key);
+ }
+
+ @Override
+ public boolean contextsAvailable() {
+ // avoid re-injecting the contexts if the root acts as subresource
+ return super.contextsAvailable() && (isRoot() || parent != null);
+ }
+
+ public ClassResourceInfo getSubResource(Class<?> typedClass, Class<?> instanceClass) {
+ return getSubResource(typedClass, instanceClass, null, enableStatic, null);
+ }
+
+ public ClassResourceInfo getSubResource(Class<?> typedClass, Class<?> instanceClass, Object instance) {
+ instanceClass = enableStatic && typedClass != Object.class ? typedClass : instanceClass;
+ return getSubResource(typedClass, instanceClass, instance, enableStatic, JAXRSUtils.getCurrentMessage());
+ }
+
+ public ClassResourceInfo getSubResource(Class<?> typedClass,
+ Class<?> instanceClass,
+ Object instance,
+ boolean resolveContexts,
+ Message message) {
+
+ SubresourceKey key = new SubresourceKey(typedClass, instanceClass);
+ ClassResourceInfo cri = subResources.get(key);
+ if (cri == null) {
+ cri = ResourceUtils.createClassResourceInfo(typedClass, instanceClass, this, false, resolveContexts,
+ getBus());
+ if (cri != null) {
+ if (message != null) {
+ cri.initBeanParamInfo(ServerProviderFactory.getInstance(message));
+ }
+ subResources.putIfAbsent(key, cri);
+ }
+ }
+ // this branch will run only if ResourceContext is used
+ // or static resolution is enabled for subresources initialized
+ // from within singleton root resources (not default)
+ if (resolveContexts && cri != null && cri.isSingleton() && instance != null && cri.contextsAvailable()) {
+ synchronized (this) {
+ if (!injectedSubInstances.contains(instance.toString())) {
+ Application app = null;
+ if (message != null) {
+ ProviderInfo<?> appProvider =
+ (ProviderInfo<?>)message.getExchange().getEndpoint().get(Application.class.getName());
+ if (appProvider != null) {
+ app = (Application)appProvider.getProvider();
+ }
+ }
+ InjectionUtils.injectContextProxiesAndApplication(cri, instance, app, null);
+ injectedSubInstances.add(instance.toString());
+ }
+ }
+ }
+
+ return cri;
+ }
+
+ public void addSubClassResourceInfo(ClassResourceInfo cri) {
+ subResources.putIfAbsent(new SubresourceKey(cri.getResourceClass(),
+ cri.getServiceClass()),
+ cri);
+ }
+
+ public Collection<ClassResourceInfo> getSubResources() {
+ return Collections.unmodifiableCollection(subResources.values());
+ }
+
+ public Set<String> getNameBindings() {
+ if (parent == null) {
+ return nameBindings;
+ }
+ return parent.getNameBindings();
+ }
+
+ public void setNameBindings(Set<String> names) {
+ nameBindings = names;
+ }
+
+ public Set<String> getAllowedMethods() {
+ Set<String> methods = new HashSet<>();
+ for (OperationResourceInfo o : methodDispatcher.getOperationResourceInfos()) {
+ String method = o.getHttpMethod();
+ if (method != null) {
+ methods.add(method);
+ }
+ }
+ return methods;
+ }
+
+
+
+ public URITemplate getURITemplate() {
+ return uriTemplate;
+ }
+
+ public void setURITemplate(URITemplate u) {
+ uriTemplate = u;
+ }
+
+ public MethodDispatcher getMethodDispatcher() {
+ return methodDispatcher;
+ }
+
+ public void setMethodDispatcher(MethodDispatcher md) {
+ methodDispatcher = md;
+ }
+
+ public boolean hasSubResources() {
+ return !subResources.isEmpty();
+ }
+
+
+ public boolean isCreatedFromModel() {
+ return createdFromModel;
+ }
+
+ public ResourceProvider getResourceProvider() {
+ return resourceProvider;
+ }
+
+ public void setResourceProvider(ResourceProvider rp) {
+ resourceProvider = rp;
+ }
+
+ public List<MediaType> getProduceMime() {
+ if (producesTypes != null) {
+ return JAXRSUtils.parseMediaTypes(producesTypes);
+ }
+ Produces produces = AnnotationUtils.getClassAnnotation(getServiceClass(), Produces.class);
+ if (produces != null || parent == null) {
+ return JAXRSUtils.getProduceTypes(produces, defaultProduces);
+ }
+ return parent.getProduceMime();
+ }
+
+ public List<MediaType> getConsumeMime() {
+ if (consumesTypes != null) {
+ return JAXRSUtils.parseMediaTypes(consumesTypes);
+ }
+ Consumes consumes = AnnotationUtils.getClassAnnotation(getServiceClass(), Consumes.class);
+ if (consumes != null || parent == null) {
+ return JAXRSUtils.getConsumeTypes(consumes, defaultConsumes);
+ }
+ return parent.getConsumeMime();
+ }
+
+ public Path getPath() {
+ return AnnotationUtils.getClassAnnotation(getServiceClass(), Path.class);
+ }
+
+ @Override
+ public boolean isSingleton() {
+ if (parent == null) {
+ return resourceProvider != null && resourceProvider.isSingleton();
+ }
+ return parent.isSingleton();
+ }
+
+ public void setParent(ClassResourceInfo parent) {
+ this.parent = parent;
+ }
+
+ public ClassResourceInfo getParent() {
+ return parent;
+ }
+
+ public void initBeanParamInfo(ServerProviderFactory factory) {
+ if (factory != null) {
+ Set<OperationResourceInfo> oris = getMethodDispatcher().getOperationResourceInfos();
+ for (OperationResourceInfo ori : oris) {
+ List<Parameter> params = ori.getParameters();
+ for (Parameter param : params) {
+ if (param.getType() == ParameterType.BEAN) {
+ Class<?> cls = ori.getMethodToInvoke().getParameterTypes()[param.getIndex()];
+ BeanParamInfo bpi = new BeanParamInfo(cls, getBus());
+ factory.addBeanParamInfo(bpi);
+ }
+ }
+ }
+ List<Method> methods = super.getParameterMethods();
+ for (Method m : methods) {
+ if (m.getAnnotation(BeanParam.class) != null) {
+ BeanParamInfo bpi = new BeanParamInfo(m.getParameterTypes()[0], getBus());
+ factory.addBeanParamInfo(bpi);
+ }
+ }
+ List<Field> fields = super.getParameterFields();
+ for (Field f : fields) {
+ if (f.getAnnotation(BeanParam.class) != null) {
+ BeanParamInfo bpi = new BeanParamInfo(f.getType(), getBus());
+ factory.addBeanParamInfo(bpi);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void clearThreadLocalProxies() {
+ super.clearThreadLocalProxies();
+ if (!injectedSubInstances.isEmpty()) {
+ for (ClassResourceInfo sub : subResources.values()) {
+ if (sub != this) {
+ sub.clearThreadLocalProxies();
+ }
+ }
+ }
+ }
+
+ public void injectContexts(Object resourceObject, OperationResourceInfo ori, Message inMessage) {
+ final boolean contextsAvailable = contextsAvailable();
+ final boolean paramsAvailable = paramsAvailable();
+ if (contextsAvailable || paramsAvailable) {
+ Object realResourceObject = ClassHelper.getRealObject(resourceObject);
+ if (paramsAvailable) {
+ JAXRSUtils.injectParameters(ori, this, realResourceObject, inMessage);
+ }
+ if (contextsAvailable) {
+ InjectionUtils.injectContexts(realResourceObject, this, inMessage);
+ }
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/model/URITemplate.java b/transform/src/patch/java/org/apache/cxf/jaxrs/model/URITemplate.java
new file mode 100644
index 0000000..85fdd7e
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/model/URITemplate.java
@@ -0,0 +1,627 @@
+/**
+ * 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.cxf.jaxrs.model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.ws.rs.Path;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.PathSegment;
+
+import org.apache.cxf.common.util.SystemPropertyAction;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+
+public final class URITemplate {
+
+ public static final String TEMPLATE_PARAMETERS = "jaxrs.template.parameters";
+ public static final String URI_TEMPLATE = "jaxrs.template.uri";
+ public static final String LIMITED_REGEX_SUFFIX = "(/.*)?";
+ public static final String FINAL_MATCH_GROUP = "FINAL_MATCH_GROUP";
+ private static final String DEFAULT_PATH_VARIABLE_REGEX = "([^/]+?)";
+ private static final String CHARACTERS_TO_ESCAPE = ".*+$()";
+ private static final String SLASH = "/";
+ private static final String SLASH_QUOTE = "/;";
+ private static final int MAX_URI_TEMPLATE_CACHE_SIZE =
+ SystemPropertyAction.getInteger("org.apache.cxf.jaxrs.max_uri_template_cache_size", 2000);
+ private static final Map<String, URITemplate> URI_TEMPLATE_CACHE = new ConcurrentHashMap<>();
+
+ private final String template;
+ private final List<String> variables = new ArrayList<>();
+ private final List<String> customVariables = new ArrayList<>();
+ private final Pattern templateRegexPattern;
+ private final String literals;
+ private final List<UriChunk> uriChunks;
+
+ public URITemplate(String theTemplate) {
+ template = theTemplate;
+ StringBuilder literalChars = new StringBuilder();
+ StringBuilder patternBuilder = new StringBuilder();
+ CurlyBraceTokenizer tok = new CurlyBraceTokenizer(template);
+ uriChunks = new ArrayList<>();
+ while (tok.hasNext()) {
+ String templatePart = tok.next();
+ UriChunk chunk = UriChunk.createUriChunk(templatePart);
+ uriChunks.add(chunk);
+ if (chunk instanceof Literal) {
+ String encodedValue = HttpUtils.encodePartiallyEncoded(chunk.getValue(), false);
+ String substr = escapeCharacters(encodedValue);
+ literalChars.append(substr);
+ patternBuilder.append(substr);
+ } else if (chunk instanceof Variable) {
+ Variable var = (Variable)chunk;
+ variables.add(var.getName());
+ String pattern = var.getPattern();
+ if (pattern != null) {
+ customVariables.add(var.getName());
+ // Add parenthesis to the pattern to identify a regex in the pattern,
+ // however do not add them if they already exist since that will cause the Matcher
+ // to create extraneous values. Parens identify a group so multiple parens would
+ // indicate multiple groups.
+ if (pattern.startsWith("(") && pattern.endsWith(")")) {
+ patternBuilder.append(pattern);
+ } else {
+ patternBuilder.append('(');
+ patternBuilder.append(pattern);
+ patternBuilder.append(')');
+ }
+ } else {
+ patternBuilder.append(DEFAULT_PATH_VARIABLE_REGEX);
+ }
+ }
+ }
+ literals = literalChars.toString();
+
+ int endPos = patternBuilder.length() - 1;
+ boolean endsWithSlash = (endPos >= 0) && patternBuilder.charAt(endPos) == '/';
+ if (endsWithSlash) {
+ patternBuilder.deleteCharAt(endPos);
+ }
+ patternBuilder.append(LIMITED_REGEX_SUFFIX);
+
+ templateRegexPattern = Pattern.compile(patternBuilder.toString());
+ }
+
+ public String getLiteralChars() {
+ return literals;
+ }
+
+ public String getValue() {
+ return template;
+ }
+
+ public String getPatternValue() {
+ return templateRegexPattern.toString();
+ }
+
+ /**
+ * List of all variables in order of appearance in template.
+ *
+ * @return unmodifiable list of variable names w/o patterns, e.g. for "/foo/{v1:\\d}/{v2}" returned list
+ * is ["v1","v2"].
+ */
+ public List<String> getVariables() {
+ return Collections.unmodifiableList(variables);
+ }
+
+ /**
+ * List of variables with patterns (regexps). List is subset of elements from {@link #getVariables()}.
+ *
+ * @return unmodifiable list of variables names w/o patterns.
+ */
+ public List<String> getCustomVariables() {
+ return Collections.unmodifiableList(customVariables);
+ }
+
+ private static String escapeCharacters(String expression) {
+
+ int length = expression.length();
+ int i = 0;
+ char ch = ' ';
+ for (; i < length; ++i) {
+ ch = expression.charAt(i);
+ if (isReservedCharacter(ch)) {
+ break;
+ }
+ }
+
+ if (i == length) {
+ return expression;
+ }
+
+ // Allows for up to 8 escaped characters before we start creating more
+ // StringBuilders. 8 is an arbitrary limit, but it seems to be
+ // sufficient in most cases.
+ StringBuilder sb = new StringBuilder(length + 8);
+ sb.append(expression, 0, i);
+ sb.append('\\');
+ sb.append(ch);
+ ++i;
+ for (; i < length; ++i) {
+ ch = expression.charAt(i);
+ if (isReservedCharacter(ch)) {
+ sb.append('\\');
+ }
+ sb.append(ch);
+ }
+ return sb.toString();
+ }
+
+ private static boolean isReservedCharacter(char ch) {
+ return CHARACTERS_TO_ESCAPE.indexOf(ch) != -1;
+ }
+
+ public boolean match(String uri, MultivaluedMap<String, String> templateVariableToValue) {
+
+ if (uri == null) {
+ return (templateRegexPattern == null) ? true : false;
+ }
+
+ if (templateRegexPattern == null) {
+ return false;
+ }
+
+ Matcher m = templateRegexPattern.matcher(uri);
+ if (!m.matches() || template.equals(SLASH) && uri.startsWith(SLASH_QUOTE)) {
+ if (uri.contains(";")) {
+ // we might be trying to match one or few path segments
+ // containing matrix
+ // parameters against a clear path segment as in @Path("base").
+ List<PathSegment> pList = JAXRSUtils.getPathSegments(template, false);
+ List<PathSegment> uList = JAXRSUtils.getPathSegments(uri, false);
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < uList.size(); i++) {
+ final String segment;
+ if (pList.size() > i && pList.get(i).getPath().indexOf('{') == -1) {
+ segment = uList.get(i).getPath();
+ } else {
+ segment = HttpUtils.fromPathSegment(uList.get(i));
+ }
+ if (!segment.isEmpty()) {
+ sb.append(SLASH);
+ }
+ sb.append(segment);
+ }
+ uri = sb.toString();
+ if (uri.isEmpty()) {
+ uri = SLASH;
+ }
+ m = templateRegexPattern.matcher(uri);
+ if (!m.matches()) {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ // Assign the matched template values to template variables
+ int groupCount = m.groupCount();
+
+ int i = 1;
+ for (String name : variables) {
+ while (i <= groupCount) {
+ String value = m.group(i++);
+ if ((value == null || value.length() == 0 && i < groupCount)
+ && variables.size() + 1 < groupCount) {
+ continue;
+ }
+ templateVariableToValue.add(name, value);
+ break;
+ }
+ }
+ // The right hand side value, might be used to further resolve
+ // sub-resources.
+
+ String finalGroup = i > groupCount ? SLASH : m.group(groupCount);
+ if (finalGroup == null || finalGroup.startsWith(SLASH_QUOTE)) {
+ finalGroup = SLASH;
+ }
+
+ templateVariableToValue.putSingle(FINAL_MATCH_GROUP, finalGroup);
+
+ return true;
+ }
+
+ /**
+ * Substitutes template variables with listed values. List of values is counterpart for
+ * {@link #getVariables() list of variables}. When list of value is shorter than variables substitution
+ * is partial. When variable has pattern, value must fit to pattern, otherwise
+ * {@link IllegalArgumentException} is thrown.
+ * <p>
+ * Example1: for template "/{a}/{b}/{a}" {@link #getVariables()} returns "[a, b, a]"; providing here list
+ * of value "[foo, bar, baz]" results with "/foo/bar/baz".
+ * <p>
+ * Example2: for template "/{a}/{b}/{a}" providing list of values "[foo]" results with "/foo/{b}/{a}".
+ *
+ * @param values values for variables
+ * @return template with bound variables.
+ * @throws IllegalArgumentException when values is null, any value does not match pattern etc.
+ */
+ public String substitute(List<String> values) throws IllegalArgumentException {
+ if (values == null) {
+ throw new IllegalArgumentException("values is null");
+ }
+ Iterator<String> iter = values.iterator();
+ StringBuilder sb = new StringBuilder();
+ for (UriChunk chunk : uriChunks) {
+ if (chunk instanceof Variable) {
+ Variable var = (Variable)chunk;
+ if (iter.hasNext()) {
+ String value = iter.next();
+ if (!var.matches(value)) {
+ throw new IllegalArgumentException("Value '" + value + "' does not match variable "
+ + var.getName() + " with pattern "
+ + var.getPattern());
+ }
+ sb.append(value);
+ } else {
+ sb.append(var);
+ }
+ } else {
+ sb.append(chunk);
+ }
+ }
+ return sb.toString();
+ }
+
+ String substitute(Map<String, ? extends Object> valuesMap) throws IllegalArgumentException {
+ return this.substitute(valuesMap, Collections.<String>emptySet(), false);
+ }
+
+ /**
+ * Substitutes template variables with mapped values. Variables are mapped to values; if not all variables
+ * are bound result will still contain variables. Note that all variables with the same name are replaced
+ * by one value.
+ * <p>
+ * Example: for template "/{a}/{b}/{a}" {@link #getVariables()} returns "[a, b, a]"; providing here
+ * mapping "[a: foo, b: bar]" results with "/foo/bar/foo" (full substitution) and for mapping "[b: baz]"
+ * result is "{a}/baz/{a}" (partial substitution).
+ *
+ * @param valuesMap map variables to their values; on each value Object.toString() is called.
+ * @return template with bound variables.
+ */
+ public String substitute(Map<String, ? extends Object> valuesMap,
+ Set<String> encodePathSlashVars,
+ boolean allowUnresolved) throws IllegalArgumentException {
+ if (valuesMap == null) {
+ throw new IllegalArgumentException("valuesMap is null");
+ }
+ StringBuilder sb = new StringBuilder();
+ for (UriChunk chunk : uriChunks) {
+ if (chunk instanceof Variable) {
+ Variable var = (Variable)chunk;
+ Object value = valuesMap.get(var.getName());
+ if (value != null) {
+ String sval = value.toString();
+ if (!var.matches(sval)) {
+ throw new IllegalArgumentException("Value '" + sval + "' does not match variable "
+ + var.getName() + " with pattern "
+ + var.getPattern());
+ }
+ if (encodePathSlashVars.contains(var.getName())) {
+ sval = sval.replaceAll("/", "%2F");
+ }
+ sb.append(sval);
+ } else if (allowUnresolved) {
+ sb.append(chunk);
+ } else {
+ throw new IllegalArgumentException("Template variable " + var.getName()
+ + " has no matching value");
+ }
+ } else {
+ sb.append(chunk);
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Encoded literal characters surrounding template variables,
+ * ex. "a {id} b" will be encoded to "a%20{id}%20b"
+ * @return encoded value
+ */
+ public String encodeLiteralCharacters(boolean isQuery) {
+ final float encodedRatio = 1.5f;
+ StringBuilder sb = new StringBuilder((int)(encodedRatio * template.length()));
+ for (UriChunk chunk : uriChunks) {
+ String val = chunk.getValue();
+ if (chunk instanceof Literal) {
+ sb.append(HttpUtils.encodePartiallyEncoded(val, isQuery));
+ } else {
+ sb.append(val);
+ }
+ }
+ return sb.toString();
+ }
+
+ public static URITemplate createTemplate(Path path) {
+
+ return createTemplate(path == null ? null : path.value());
+ }
+
+ public static URITemplate createTemplate(String pathValue) {
+ if (pathValue == null) {
+ pathValue = "/";
+ } else if (!pathValue.startsWith("/")) {
+ pathValue = "/" + pathValue;
+ }
+ return createExactTemplate(pathValue);
+ }
+
+ public static URITemplate createExactTemplate(String pathValue) {
+ URITemplate template = URI_TEMPLATE_CACHE.get(pathValue);
+ if (template == null) {
+ template = new URITemplate(pathValue);
+ if (URI_TEMPLATE_CACHE.size() >= MAX_URI_TEMPLATE_CACHE_SIZE) {
+ URI_TEMPLATE_CACHE.clear();
+ }
+ URI_TEMPLATE_CACHE.put(pathValue, template);
+ }
+ return template;
+ }
+
+ public static int compareTemplates(URITemplate t1, URITemplate t2) {
+ int l1 = t1.getLiteralChars().length();
+ int l2 = t2.getLiteralChars().length();
+ // descending order
+ int result = l1 < l2 ? 1 : l1 > l2 ? -1 : 0;
+ if (result == 0) {
+ int g1 = t1.getVariables().size();
+ int g2 = t2.getVariables().size();
+ // descending order
+ result = g1 < g2 ? 1 : g1 > g2 ? -1 : 0;
+ if (result == 0) {
+ int gCustom1 = t1.getCustomVariables().size();
+ int gCustom2 = t2.getCustomVariables().size();
+ result = gCustom1 < gCustom2 ? 1 : gCustom1 > gCustom2 ? -1 : 0;
+ if (result == 0) {
+ result = t1.getPatternValue().compareTo(t2.getPatternValue());
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Stringified part of URI. Chunk is not URI segment; chunk can span over multiple URI segments or one URI
+ * segments can have multiple chunks. Chunk is used to decompose URI of {@link URITemplate} into literals
+ * and variables. Example: "foo/bar/{baz}{blah}" is decomposed into chunks: "foo/bar", "{baz}" and
+ * "{blah}".
+ */
+ private abstract static class UriChunk {
+ /**
+ * Creates object form string.
+ *
+ * @param uriChunk stringified uri chunk
+ * @return If param has variable form then {@link Variable} instance is created, otherwise chunk is
+ * treated as {@link Literal}.
+ */
+ public static UriChunk createUriChunk(String uriChunk) {
+ if (uriChunk == null || "".equals(uriChunk)) {
+ throw new IllegalArgumentException("uriChunk is empty");
+ }
+ UriChunk uriChunkRepresentation = Variable.create(uriChunk);
+ if (uriChunkRepresentation == null) {
+ uriChunkRepresentation = Literal.create(uriChunk);
+ }
+ return uriChunkRepresentation;
+ }
+
+ public abstract String getValue();
+
+ @Override
+ public String toString() {
+ return getValue();
+ }
+ }
+
+ private static final class Literal extends UriChunk {
+ private String value;
+
+ private Literal() {
+ // empty constructor
+ }
+
+ public static Literal create(String uriChunk) {
+ if (uriChunk == null || "".equals(uriChunk)) {
+ throw new IllegalArgumentException("uriChunk is empty");
+ }
+ Literal literal = new Literal();
+ literal.value = uriChunk;
+ return literal;
+ }
+
+ @Override
+ public String getValue() {
+ return value;
+ }
+
+ }
+
+ /**
+ * Variable of URITemplate. Variable has either "{varname:pattern}" syntax or "{varname}".
+ */
+ private static final class Variable extends UriChunk {
+ private static final Pattern VARIABLE_PATTERN = Pattern.compile("(\\w[-\\w\\.]*[ ]*)(\\:(.+))?");
+ private String name;
+ private Pattern pattern;
+
+ private Variable() {
+ // empty constructor
+ }
+
+ /**
+ * Creates variable from stringified part of URI.
+ *
+ * @param uriChunk uriChunk chunk that depicts variable
+ * @return Variable if variable was successfully created; null if uriChunk was not a variable
+ */
+ public static Variable create(String uriChunk) {
+ Variable newVariable = new Variable();
+ if (uriChunk == null || "".equals(uriChunk)) {
+ return null;
+ }
+ if (CurlyBraceTokenizer.insideBraces(uriChunk)) {
+ uriChunk = CurlyBraceTokenizer.stripBraces(uriChunk).trim();
+ Matcher matcher = VARIABLE_PATTERN.matcher(uriChunk);
+ if (matcher.matches()) {
+ newVariable.name = matcher.group(1).trim();
+ if (matcher.group(2) != null && matcher.group(3) != null) {
+ String patternExpression = matcher.group(3).trim();
+ newVariable.pattern = Pattern.compile(patternExpression);
+ }
+ return newVariable;
+ }
+ }
+ return null;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getPattern() {
+ return pattern != null ? pattern.pattern() : null;
+ }
+
+ /**
+ * Checks whether value matches variable. If variable has pattern its checked against, otherwise true
+ * is returned.
+ *
+ * @param value value of variable
+ * @return true if value is valid for variable, false otherwise.
+ */
+ public boolean matches(String value) {
+ if (pattern == null) {
+ return true;
+ }
+ return pattern.matcher(value).matches();
+ }
+
+ @Override
+ public String getValue() {
+ if (pattern != null) {
+ return "{" + name + ":" + pattern + "}";
+ }
+ return "{" + name + "}";
+ }
+ }
+
+ /**
+ * Splits string into parts inside and outside curly braces. Nested curly braces are ignored and treated
+ * as part inside top-level curly braces. Example: string "foo{bar{baz}}blah" is split into three tokens,
+ * "foo","{bar{baz}}" and "blah". When closed bracket is missing, whole unclosed part is returned as one
+ * token, e.g.: "foo{bar" is split into "foo" and "{bar". When opening bracket is missing, closing
+ * bracket is ignored and taken as part of current token e.g.: "foo{bar}baz}blah" is split into "foo",
+ * "{bar}" and "baz}blah".
+ * <p>
+ * This is helper class for {@link URITemplate} that enables recurring literals appearing next to regular
+ * expressions e.g. "/foo/{zipcode:[0-9]{5}}/". Nested expressions with closed sections, like open-closed
+ * brackets causes expression to be out of regular grammar (is context-free grammar) which are not
+ * supported by Java regexp version.
+ */
+ static class CurlyBraceTokenizer {
+
+ private List<String> tokens = new ArrayList<>();
+ private int tokenIdx;
+
+ CurlyBraceTokenizer(String string) {
+ boolean outside = true;
+ int level = 0;
+ int lastIdx = 0;
+ int idx;
+ for (idx = 0; idx < string.length(); idx++) {
+ if (string.charAt(idx) == '{') {
+ if (outside) {
+ if (lastIdx < idx) {
+ tokens.add(string.substring(lastIdx, idx));
+ }
+ lastIdx = idx;
+ outside = false;
+ } else {
+ level++;
+ }
+ } else if (string.charAt(idx) == '}' && !outside) {
+ if (level > 0) {
+ level--;
+ } else {
+ if (lastIdx < idx) {
+ tokens.add(string.substring(lastIdx, idx + 1));
+ }
+ lastIdx = idx + 1;
+ outside = true;
+ }
+ }
+ }
+ if (lastIdx < idx) {
+ tokens.add(string.substring(lastIdx, idx));
+ }
+ }
+
+ /**
+ * Token is enclosed by curly braces.
+ *
+ * @param token
+ * text to verify
+ * @return true if enclosed, false otherwise.
+ */
+ public static boolean insideBraces(String token) {
+ return token.charAt(0) == '{' && token.charAt(token.length() - 1) == '}';
+ }
+
+ /**
+ * Strips token from enclosed curly braces. If token is not enclosed method
+ * has no side effect.
+ *
+ * @param token
+ * text to verify
+ * @return text stripped from curly brace begin-end pair.
+ */
+ public static String stripBraces(String token) {
+ if (insideBraces(token)) {
+ return token.substring(1, token.length() - 1);
+ }
+ return token;
+ }
+
+ public boolean hasNext() {
+ return tokens.size() > tokenIdx;
+ }
+
+ public String next() {
+ if (hasNext()) {
+ return tokens.get(tokenIdx++);
+ }
+ throw new IllegalStateException("no more elements");
+ }
+ }
+}
+
+
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/CachingMessageBodyReader.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/CachingMessageBodyReader.java
new file mode 100644
index 0000000..ecdc8f1
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/CachingMessageBodyReader.java
@@ -0,0 +1,100 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.List;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.Provider;
+
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+
+@Provider
+public class CachingMessageBodyReader<T> extends AbstractCachingMessageProvider<T>
+ implements MessageBodyReader<T> {
+
+ private List<MessageBodyReader<T>> delegatingReaders;
+
+ public boolean isReadable(Class<?> type, Type gType, Annotation[] anns, MediaType mt) {
+ if (delegatingReaders != null) {
+ return getDelegatingReader(type, gType, anns, mt) != null;
+ }
+ return isProviderKeyNotSet();
+ }
+
+ private MessageBodyReader<T> getDelegatingReader(Class<?> type, Type gType, Annotation[] anns, MediaType mt) {
+ for (MessageBodyReader<T> reader: delegatingReaders) {
+ if (reader.isReadable(type, gType, anns, mt)) {
+ return reader;
+ }
+ }
+ return null;
+ }
+
+ public T readFrom(Class<T> type, Type gType, Annotation[] anns, MediaType mt,
+ MultivaluedMap<String, String> theheaders, InputStream is)
+ throws IOException, WebApplicationException {
+ this.setObject(
+ getReader(type, gType, anns, mt).readFrom(type, gType, anns, mt, theheaders, is));
+ return getObject();
+ }
+
+
+ protected MessageBodyReader<T> getReader(Class<?> type, Type gType, Annotation[] anns, MediaType mt) {
+ if (delegatingReaders != null) {
+ return getDelegatingReader(type, gType, anns, mt);
+ }
+ final MessageBodyReader<T> r;
+
+ mc.put(ACTIVE_JAXRS_PROVIDER_KEY, this);
+ try {
+ @SuppressWarnings("unchecked")
+ Class<T> actualType = (Class<T>)type;
+ r = mc.getProviders().getMessageBodyReader(actualType, gType, anns, mt);
+ } finally {
+ mc.put(ACTIVE_JAXRS_PROVIDER_KEY, null);
+ }
+
+ if (r == null) {
+ org.apache.cxf.common.i18n.Message message =
+ new org.apache.cxf.common.i18n.Message("NO_MSG_READER", BUNDLE, type);
+ LOG.severe(message.toString());
+ throw ExceptionUtils.toNotAcceptableException(null, null);
+ }
+ return r;
+ }
+
+ public void setDelegatingReader(MessageBodyReader<T> reader) {
+ this.delegatingReaders = Collections.singletonList(reader);
+ }
+
+ public void setDelegatingReaders(List<MessageBodyReader<T>> readers) {
+ this.delegatingReaders = readers;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/CachingMessageBodyWriter.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/CachingMessageBodyWriter.java
new file mode 100644
index 0000000..21eab42
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/CachingMessageBodyWriter.java
@@ -0,0 +1,102 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.List;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+
+@Provider
+public class CachingMessageBodyWriter<T> extends AbstractCachingMessageProvider<T>
+ implements MessageBodyWriter<T> {
+
+ private List<MessageBodyWriter<T>> delegatingWriters;
+
+ public long getSize(T t, Class<?> type, Type gType, Annotation[] anns, MediaType mediaType) {
+ return -1;
+ }
+
+ public boolean isWriteable(Class<?> type, Type gType, Annotation[] anns, MediaType mt) {
+ if (delegatingWriters != null) {
+ return getDelegatingWriter(type, gType, anns, mt) != null;
+ }
+ return isProviderKeyNotSet();
+ }
+
+ private MessageBodyWriter<T> getDelegatingWriter(Class<?> type, Type gType, Annotation[] anns, MediaType mt) {
+ for (MessageBodyWriter<T> writer: delegatingWriters) {
+ if (writer.isWriteable(type, gType, anns, mt)) {
+ return writer;
+ }
+ }
+ return null;
+ }
+
+ public void writeTo(T obj, Class<?> type, Type gType, Annotation[] anns, MediaType mt,
+ MultivaluedMap<String, Object> theheaders, OutputStream os)
+ throws IOException, WebApplicationException {
+ this.setObject(obj);
+ getWriter(type, gType, anns, mt).writeTo(getObject(), type, gType, anns, mt, theheaders, os);
+ }
+
+
+ protected MessageBodyWriter<T> getWriter(Class<?> type, Type gType, Annotation[] anns, MediaType mt) {
+ if (delegatingWriters != null) {
+ return getDelegatingWriter(type, gType, anns, mt);
+ }
+ MessageBodyWriter<T> w;
+
+ mc.put(ACTIVE_JAXRS_PROVIDER_KEY, this);
+ try {
+ @SuppressWarnings("unchecked")
+ Class<T> actualType = (Class<T>)type;
+ w = mc.getProviders().getMessageBodyWriter(actualType, gType, anns, mt);
+ } finally {
+ mc.put(ACTIVE_JAXRS_PROVIDER_KEY, null);
+ }
+
+ if (w == null) {
+ org.apache.cxf.common.i18n.Message message =
+ new org.apache.cxf.common.i18n.Message("NO_MSG_WRITER", BUNDLE, type);
+ LOG.severe(message.toString());
+ throw ExceptionUtils.toInternalServerErrorException(null, null);
+ }
+ return w;
+ }
+
+ public void setDelegatingWriter(MessageBodyWriter<T> writer) {
+ this.delegatingWriters = Collections.singletonList(writer);
+ }
+
+ public void setDelegatingWriters(List<MessageBodyWriter<T>> writers) {
+ this.delegatingWriters = writers;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/DataSourceProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/DataSourceProvider.java
new file mode 100644
index 0000000..efecac4
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/DataSourceProvider.java
@@ -0,0 +1,110 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.logging.Logger;
+
+import javax.activation.DataHandler;
+import javax.activation.DataSource;
+import javax.activation.FileDataSource;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.jaxrs.ext.multipart.InputStreamDataSource;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+
+@Provider
+public class DataSourceProvider<T> implements MessageBodyReader<T>, MessageBodyWriter<T> {
+ protected static final Logger LOG = LogUtils.getL7dLogger(DataSourceProvider.class);
+ private boolean useDataSourceContentType;
+
+ public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mt) {
+ return isSupported(type);
+ }
+
+ public T readFrom(Class<T> cls, Type genericType, Annotation[] annotations,
+ MediaType type,
+ MultivaluedMap<String, String> headers, InputStream is)
+ throws IOException {
+
+ final DataSource ds;
+ if (cls == FileDataSource.class) {
+ File file = new BinaryDataProvider<File>().readFrom(File.class, File.class, annotations, type, headers, is);
+ ds = new FileDataSource(file);
+ } else if (cls == DataSource.class || cls == DataHandler.class) {
+ ds = new InputStreamDataSource(is, type.toString());
+ } else {
+ LOG.warning("Unsupported DataSource class: " + cls.getName());
+ throw ExceptionUtils.toWebApplicationException(null, null);
+ }
+ return cls.cast(DataSource.class.isAssignableFrom(cls) ? ds : new DataHandler(ds));
+ }
+
+ public long getSize(T t, Class<?> type, Type genericType, Annotation[] annotations,
+ MediaType mt) {
+ return -1;
+ }
+
+ public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mt) {
+ return isSupported(type);
+ }
+
+ private static boolean isSupported(Class<?> type) {
+ return DataSource.class.isAssignableFrom(type) || DataHandler.class.isAssignableFrom(type);
+ }
+
+ public void writeTo(T src, Class<?> cls, Type genericType, Annotation[] annotations,
+ MediaType type, MultivaluedMap<String, Object> headers, OutputStream os)
+ throws IOException {
+ DataSource ds = DataSource.class.isAssignableFrom(cls)
+ ? (DataSource)src : ((DataHandler)src).getDataSource();
+ if (useDataSourceContentType) {
+ setContentTypeIfNeeded(type, headers, ds.getContentType());
+ }
+ IOUtils.copyAndCloseInput(ds.getInputStream(), os);
+ }
+
+ private void setContentTypeIfNeeded(MediaType type,
+ MultivaluedMap<String, Object> headers, String ct) {
+
+ if (!StringUtils.isEmpty(ct) && !type.equals(JAXRSUtils.toMediaType(ct))) {
+ headers.putSingle("Content-Type", ct);
+ }
+ }
+
+ public void setUseDataSourceContentType(boolean useDataSourceContentType) {
+ this.useDataSourceContentType = useDataSourceContentType;
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/FormEncodingProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/FormEncodingProvider.java
new file mode 100644
index 0000000..0344592
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/FormEncodingProvider.java
@@ -0,0 +1,228 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Encoded;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.Form;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+
+import org.apache.cxf.jaxrs.ext.MessageContext;
+import org.apache.cxf.jaxrs.ext.multipart.Attachment;
+import org.apache.cxf.jaxrs.ext.multipart.MultipartBody;
+import org.apache.cxf.jaxrs.impl.MetadataMap;
+import org.apache.cxf.jaxrs.utils.AnnotationUtils;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.FormUtils;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.multipart.AttachmentUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+
+@Produces({"application/x-www-form-urlencoded", "multipart/form-data" })
+@Consumes({"application/x-www-form-urlencoded", "multipart/form-data" })
+@Provider
+public class FormEncodingProvider<T> extends AbstractConfigurableProvider
+ implements MessageBodyReader<T>, MessageBodyWriter<T> {
+
+ private FormValidator validator;
+ @Context private MessageContext mc;
+ private String attachmentDir;
+ private String attachmentThreshold;
+ private String attachmentMaxSize;
+
+ private boolean expectEncoded;
+
+ public FormEncodingProvider() {
+
+ }
+
+ public FormEncodingProvider(boolean expectEncoded) {
+ this.expectEncoded = expectEncoded;
+ }
+
+ public void setExpectedEncoded(boolean expect) {
+ this.expectEncoded = expect;
+ }
+
+ public void setAttachmentDirectory(String dir) {
+ attachmentDir = dir;
+ }
+
+ public void setAttachmentThreshold(String threshold) {
+ attachmentThreshold = threshold;
+ }
+
+ public void setAttachmentMaxSize(String maxSize) {
+ attachmentMaxSize = maxSize;
+ }
+
+ public void setValidator(FormValidator formValidator) {
+ validator = formValidator;
+ }
+
+ public boolean isReadable(Class<?> type, Type genericType,
+ Annotation[] annotations, MediaType mt) {
+ return isSupported(type, mt);
+ }
+
+ public T readFrom(
+ Class<T> clazz, Type genericType, Annotation[] annotations, MediaType mt,
+ MultivaluedMap<String, String> headers, InputStream is)
+ throws IOException {
+ if (is == null) {
+ return null;
+ }
+ try {
+ if (mt.isCompatible(MediaType.MULTIPART_FORM_DATA_TYPE)) {
+ MultipartBody body = AttachmentUtils.getMultipartBody(mc);
+ if (MultipartBody.class.isAssignableFrom(clazz)) {
+ return clazz.cast(body);
+ } else if (Attachment.class.isAssignableFrom(clazz)) {
+ return clazz.cast(body.getRootAttachment());
+ }
+ }
+
+ MultivaluedMap<String, String> params = createMap(clazz);
+ populateMap(params, annotations, is, mt, !keepEncoded(annotations));
+ validateMap(params);
+
+ persistParamsOnMessage(params);
+
+ return getFormObject(clazz, params);
+ } catch (WebApplicationException e) {
+ throw e;
+ } catch (Exception e) {
+ throw ExceptionUtils.toBadRequestException(e, null);
+ }
+ }
+
+ protected boolean keepEncoded(Annotation[] anns) {
+ return AnnotationUtils.getAnnotation(anns, Encoded.class) != null
+ || expectEncoded;
+ }
+
+ protected void persistParamsOnMessage(MultivaluedMap<String, String> params) {
+ Message message = PhaseInterceptorChain.getCurrentMessage();
+ if (message != null) {
+ message.put(FormUtils.FORM_PARAM_MAP, params);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ protected MultivaluedMap<String, String> createMap(Class<?> clazz) throws Exception {
+ if (clazz == MultivaluedMap.class || clazz == Form.class) {
+ return new MetadataMap<String, String>();
+ }
+ return (MultivaluedMap<String, String>)clazz.newInstance();
+ }
+
+ private T getFormObject(Class<T> clazz, MultivaluedMap<String, String> params) {
+ return clazz.cast(Form.class.isAssignableFrom(clazz) ? new Form(params) : params);
+ }
+
+ /**
+ * Retrieve map of parameters from the passed in message
+ */
+ protected void populateMap(MultivaluedMap<String, String> params,
+ Annotation[] anns,
+ InputStream is,
+ MediaType mt,
+ boolean decode) {
+ if (mt.isCompatible(MediaType.MULTIPART_FORM_DATA_TYPE)) {
+ MultipartBody body =
+ AttachmentUtils.getMultipartBody(mc, attachmentDir, attachmentThreshold, attachmentMaxSize);
+ FormUtils.populateMapFromMultipart(params, body, PhaseInterceptorChain.getCurrentMessage(),
+ decode);
+ } else {
+ String enc = HttpUtils.getEncoding(mt, StandardCharsets.UTF_8.name());
+
+ Object servletRequest = mc != null ? mc.getHttpServletRequest() : null;
+ if (servletRequest == null) {
+ FormUtils.populateMapFromString(params,
+ PhaseInterceptorChain.getCurrentMessage(),
+ FormUtils.readBody(is, enc),
+ enc,
+ decode);
+ } else {
+ FormUtils.populateMapFromString(params,
+ PhaseInterceptorChain.getCurrentMessage(),
+ FormUtils.readBody(is, enc),
+ enc,
+ decode,
+ (javax.servlet.http.HttpServletRequest)servletRequest);
+ }
+ }
+ }
+
+ protected void validateMap(MultivaluedMap<String, String> params) {
+ if (validator != null) {
+ validator.validate(params);
+ }
+ }
+
+ public long getSize(T t, Class<?> type,
+ Type genericType, Annotation[] annotations,
+ MediaType mediaType) {
+ return -1;
+ }
+
+ public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations,
+ MediaType mt) {
+ return isSupported(type, mt);
+ }
+
+ private static boolean isSupported(Class<?> type, MediaType mt) {
+ return (MultivaluedMap.class.isAssignableFrom(type) || Form.class.isAssignableFrom(type))
+ || ("multipart".equalsIgnoreCase(mt.getType())
+ && mt.isCompatible(MediaType.MULTIPART_FORM_DATA_TYPE)
+ && (MultivaluedMap.class.isAssignableFrom(type) || Form.class.isAssignableFrom(type)));
+ }
+
+ @SuppressWarnings("unchecked")
+ public void writeTo(T obj, Class<?> c, Type t, Annotation[] anns,
+ MediaType mt, MultivaluedMap<String, Object> headers, OutputStream os)
+ throws IOException, WebApplicationException {
+
+ MultivaluedMap<String, String> map =
+ (MultivaluedMap<String, String>)(obj instanceof Form ? ((Form)obj).asMap() : obj);
+ boolean encoded = keepEncoded(anns);
+
+ String enc = HttpUtils.getSetEncoding(mt, headers, StandardCharsets.UTF_8.name());
+
+ FormUtils.writeMapToOutputStream(map, os, enc, encoded);
+
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/JAXBElementProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/JAXBElementProvider.java
new file mode 100644
index 0000000..ab27e02
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/JAXBElementProvider.java
@@ -0,0 +1,635 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriBuilder;
+import javax.ws.rs.ext.Provider;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.Source;
+
+import org.w3c.dom.Document;
+
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.jaxrs.ext.MessageContext;
+import org.apache.cxf.jaxrs.ext.Nullable;
+import org.apache.cxf.jaxrs.ext.xml.XMLInstruction;
+import org.apache.cxf.jaxrs.ext.xml.XMLSource;
+import org.apache.cxf.jaxrs.ext.xml.XSISchemaLocation;
+import org.apache.cxf.jaxrs.ext.xml.XSLTTransform;
+import org.apache.cxf.jaxrs.utils.AnnotationUtils;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXBUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Attachment;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.staxutils.DepthExceededStaxException;
+import org.apache.cxf.staxutils.StaxUtils;
+import org.apache.cxf.staxutils.transform.TransformUtils;
+
+@Produces({"application/xml", "application/*+xml", "text/xml" })
+@Consumes({"application/xml", "application/*+xml", "text/xml" })
+@Provider
+public class JAXBElementProvider<T> extends AbstractJAXBProvider<T> {
+ private static final String XML_PI_START = "<?xml version=\"1.0\" encoding=\"";
+ private static final String XML_PI_PROPERTY_RI = "com.sun.xml.bind.xmlHeaders";
+ private static final String XML_PI_PROPERTY_RI_INT = "com.sun.xml.internal.bind.xmlHeaders";
+
+ private static final String[] MARSHALLER_PROPERTIES = {
+ Marshaller.JAXB_ENCODING,
+ Marshaller.JAXB_FORMATTED_OUTPUT,
+ Marshaller.JAXB_FRAGMENT,
+ Marshaller.JAXB_NO_NAMESPACE_SCHEMA_LOCATION,
+ Marshaller.JAXB_SCHEMA_LOCATION,
+ NS_MAPPER_PROPERTY_RI,
+ NS_MAPPER_PROPERTY_RI_INT,
+ XML_PI_PROPERTY_RI,
+ XML_PI_PROPERTY_RI_INT
+ };
+
+ private Map<String, Object> mProperties = Collections.emptyMap();
+ private Map<String, String> nsPrefixes = Collections.emptyMap();
+ private String xmlResourceOffset = "";
+ private String xmlPiPropertyName;
+
+ public JAXBElementProvider() {
+
+ }
+
+ protected boolean objectFactoryOrIndexAvailable(Class<?> type) {
+ return !Document.class.isAssignableFrom(type) && super.objectFactoryOrIndexAvailable(type);
+ }
+
+ public void setXmlResourceOffset(String value) {
+ xmlResourceOffset = value;
+ }
+
+ public void setNamespacePrefixes(Map<String, String> prefixes) {
+ nsPrefixes = prefixes;
+ }
+
+ protected void setXmlPiProperty(Marshaller ms, String value) throws Exception {
+ if (xmlPiPropertyName != null) {
+ setMarshallerProp(ms, value, xmlPiPropertyName, null);
+ } else {
+ setMarshallerProp(ms, value, XML_PI_PROPERTY_RI, XML_PI_PROPERTY_RI_INT);
+ }
+ }
+
+ @Override
+ protected boolean canBeReadAsJaxbElement(Class<?> type) {
+ return super.canBeReadAsJaxbElement(type)
+ && type != XMLSource.class && !Source.class.isAssignableFrom(type);
+ }
+
+ @Context
+ public void setMessageContext(MessageContext mc) {
+ super.setContext(mc);
+ }
+
+ public void setMarshallerProperties(Map<String, Object> marshallProperties) {
+ mProperties = marshallProperties;
+ }
+
+ public void setSchemaLocation(String schemaLocation) {
+ mProperties.put(Marshaller.JAXB_SCHEMA_LOCATION, schemaLocation);
+ }
+
+ public T readFrom(Class<T> type, Type genericType, Annotation[] anns, MediaType mt,
+ MultivaluedMap<String, String> headers, InputStream is)
+ throws IOException {
+ if (isPayloadEmpty(headers)) {
+ if (AnnotationUtils.getAnnotation(anns, Nullable.class) != null) {
+ return null;
+ }
+ reportEmptyContentLength();
+ }
+
+ XMLStreamReader reader = null;
+ Unmarshaller unmarshaller = null;
+ try {
+
+ boolean isCollection = InjectionUtils.isSupportedCollectionOrArray(type);
+ Class<?> theGenericType = isCollection ? InjectionUtils.getActualType(genericType) : type;
+ Class<?> theType = getActualType(theGenericType, genericType, anns);
+
+ unmarshaller = createUnmarshaller(theType, genericType, isCollection);
+ addAttachmentUnmarshaller(unmarshaller);
+ Object response = null;
+ if (JAXBElement.class.isAssignableFrom(type)
+ || !isCollection && (unmarshalAsJaxbElement
+ || jaxbElementClassMap != null && jaxbElementClassMap.containsKey(theType.getName()))) {
+ try (InputStream in = IOUtils.nullOrNotEmptyStream(is)) {
+ // The return value might be "null" in case of empty stream, in this
+ // case the unmarshaller fails with javax.xml.bind.UnmarshalException instead
+ // of returning empty response.
+ if (in != null) {
+ reader = getStreamReader(in, type, mt);
+ reader = TransformUtils.createNewReaderIfNeeded(reader, in);
+
+ if (JAXBElement.class.isAssignableFrom(type) && type == theType) {
+ response = unmarshaller.unmarshal(reader);
+ } else {
+ response = unmarshaller.unmarshal(reader, theType);
+ }
+ }
+ }
+ } else {
+ response = doUnmarshal(unmarshaller, type, is, anns, mt);
+ }
+
+ if (response instanceof JAXBElement && !JAXBElement.class.isAssignableFrom(type)) {
+ response = ((JAXBElement<?>)response).getValue();
+ }
+ if (isCollection) {
+ response = ((CollectionWrapper)response).getCollectionOrArray(
+ unmarshaller, theType, type, genericType,
+ org.apache.cxf.jaxrs.utils.JAXBUtils.getAdapter(theGenericType, anns));
+ } else {
+ response = checkAdapter(response, type, anns, false);
+ }
+ return type.cast(response);
+
+ } catch (JAXBException e) {
+ handleJAXBException(e, true);
+ } catch (DepthExceededStaxException e) {
+ throw ExceptionUtils.toWebApplicationException(null, JAXRSUtils.toResponse(413));
+ } catch (WebApplicationException e) {
+ throw e;
+ } catch (Exception e) {
+ LOG.warning(ExceptionUtils.getStackTrace(e));
+ throw ExceptionUtils.toBadRequestException(e, null);
+ } finally {
+ try {
+ StaxUtils.close(reader);
+ } catch (XMLStreamException e) {
+ // Ignore
+ }
+ JAXBUtils.closeUnmarshaller(unmarshaller);
+ }
+ // unreachable
+ return null;
+ }
+
+ protected Object doUnmarshal(Unmarshaller unmarshaller, Class<?> type, InputStream is,
+ Annotation[] anns, MediaType mt)
+ throws JAXBException {
+ XMLStreamReader reader = getStreamReader(is, type, mt);
+ if (reader != null) {
+ try {
+ return unmarshalFromReader(unmarshaller, reader, anns, mt);
+ } catch (JAXBException e) {
+ throw e;
+ } finally {
+ try {
+ StaxUtils.close(reader);
+ } catch (XMLStreamException e) {
+ // Ignore
+ }
+ }
+ }
+ return unmarshalFromInputStream(unmarshaller, is, anns, mt);
+ }
+
+ protected XMLStreamReader getStreamReader(InputStream is, Class<?> type, MediaType mt) {
+ MessageContext mc = getContext();
+ XMLStreamReader reader = mc != null ? mc.getContent(XMLStreamReader.class) : null;
+ if (reader == null && mc != null) {
+ XMLInputFactory factory = (XMLInputFactory)mc.get(XMLInputFactory.class.getName());
+ if (factory != null) {
+ try {
+ reader = factory.createXMLStreamReader(is);
+ } catch (XMLStreamException e) {
+ throw ExceptionUtils.toInternalServerErrorException(
+ new RuntimeException("Can not create XMLStreamReader", e), null);
+ }
+ }
+ }
+
+ if (reader == null && is == null) {
+ reader = getStreamHandlerFromCurrentMessage(XMLStreamReader.class);
+ }
+
+ reader = createTransformReaderIfNeeded(reader, is);
+ reader = createDepthReaderIfNeeded(reader, is);
+ if (InjectionUtils.isSupportedCollectionOrArray(type)) {
+ return new JAXBCollectionWrapperReader(TransformUtils.createNewReaderIfNeeded(reader, is));
+ }
+ return reader;
+
+ }
+
+ protected Object unmarshalFromInputStream(Unmarshaller unmarshaller, InputStream is,
+ Annotation[] anns, MediaType mt)
+ throws JAXBException {
+ // Try to create the read before unmarshalling the stream
+ XMLStreamReader xmlReader = null;
+ try {
+ if (is == null) {
+ Reader reader = getStreamHandlerFromCurrentMessage(Reader.class);
+ if (reader == null) {
+ LOG.severe("No InputStream, Reader, or XMLStreamReader is available");
+ throw ExceptionUtils.toInternalServerErrorException(null, null);
+ }
+ xmlReader = StaxUtils.createXMLStreamReader(reader);
+ } else {
+ xmlReader = StaxUtils.createXMLStreamReader(is);
+ }
+ configureReaderRestrictions(xmlReader);
+ return unmarshaller.unmarshal(xmlReader);
+ } finally {
+ try {
+ StaxUtils.close(xmlReader);
+ } catch (XMLStreamException e) {
+ // Ignore
+ }
+ }
+ }
+
+ protected Object unmarshalFromReader(Unmarshaller unmarshaller, XMLStreamReader reader,
+ Annotation[] anns, MediaType mt)
+ throws JAXBException {
+ return unmarshaller.unmarshal(reader);
+ }
+
+ public void writeTo(T obj, Class<?> cls, Type genericType, Annotation[] anns,
+ MediaType m, MultivaluedMap<String, Object> headers, OutputStream os)
+ throws IOException {
+ try {
+ String encoding = HttpUtils.getSetEncoding(m, headers, StandardCharsets.UTF_8.name());
+ if (InjectionUtils.isSupportedCollectionOrArray(cls)) {
+ marshalCollection(cls, obj, genericType, encoding, os, m, anns);
+ } else {
+ Object actualObject = checkAdapter(obj, cls, anns, true);
+ Class<?> actualClass = obj != actualObject || cls.isInterface()
+ ? actualObject.getClass() : cls;
+ marshal(actualObject, actualClass, genericType, encoding, os, m, anns);
+ }
+ } catch (JAXBException e) {
+ handleJAXBException(e, false);
+ } catch (WebApplicationException e) {
+ throw e;
+ } catch (Exception e) {
+ LOG.warning(ExceptionUtils.getStackTrace(e));
+ throw ExceptionUtils.toInternalServerErrorException(e, null);
+ }
+ }
+
+ protected void marshalCollection(Class<?> originalCls, Object collection,
+ Type genericType, String enc, OutputStream os,
+ MediaType m, Annotation[] anns)
+ throws Exception {
+
+ Class<?> actualClass = InjectionUtils.getActualType(genericType);
+ actualClass = getActualType(actualClass, genericType, anns);
+
+ Collection<?> c = originalCls.isArray() ? Arrays.asList((Object[]) collection)
+ : (Collection<?>) collection;
+
+ Iterator<?> it = c.iterator();
+
+ Object firstObj = it.hasNext() ? it.next() : null;
+
+ final QName qname;
+ if (firstObj instanceof JAXBElement) {
+ JAXBElement<?> el = (JAXBElement<?>)firstObj;
+ qname = el.getName();
+ actualClass = el.getDeclaredType();
+ } else {
+ qname = getCollectionWrapperQName(actualClass, genericType, firstObj, true);
+ }
+ if (qname == null) {
+ String message = new org.apache.cxf.common.i18n.Message("NO_COLLECTION_ROOT",
+ BUNDLE).toString();
+ throw new WebApplicationException(Response.serverError()
+ .entity(message).build());
+ }
+
+ os.write((XML_PI_START + (enc == null ? StandardCharsets.UTF_8.name() : enc) + "\"?>").getBytes());
+
+ final String startTag;
+ final String endTag;
+ if (!qname.getNamespaceURI().isEmpty()) {
+ String prefix = nsPrefixes.get(qname.getNamespaceURI());
+ if (prefix == null) {
+ prefix = "ns1";
+ }
+ startTag = "<" + prefix + ':' + qname.getLocalPart() + " xmlns:" + prefix + "=\""
+ + qname.getNamespaceURI() + "\">";
+ endTag = "</" + prefix + ':' + qname.getLocalPart() + ">";
+ } else {
+ startTag = "<" + qname.getLocalPart() + ">";
+ endTag = "</" + qname.getLocalPart() + ">";
+ }
+ os.write(startTag.getBytes());
+ if (firstObj != null) {
+ XmlJavaTypeAdapter adapter =
+ org.apache.cxf.jaxrs.utils.JAXBUtils.getAdapter(firstObj.getClass(), anns);
+ marshalCollectionMember(JAXBUtils.useAdapter(firstObj, adapter, true),
+ actualClass, genericType, enc, os, anns, m,
+ qname.getNamespaceURI());
+ while (it.hasNext()) {
+ marshalCollectionMember(JAXBUtils.useAdapter(it.next(), adapter, true), actualClass,
+ genericType, enc, os, anns, m,
+ qname.getNamespaceURI());
+ }
+ }
+ os.write(endTag.getBytes());
+ }
+ //CHECKSTYLE:OFF
+ protected void marshalCollectionMember(Object obj,
+ Class<?> cls,
+ Type genericType,
+ String enc,
+ OutputStream os,
+ Annotation[] anns,
+ MediaType mt,
+ String ns) throws Exception {
+ //CHECKSTYLE:ON
+ if (!(obj instanceof JAXBElement)) {
+ obj = convertToJaxbElementIfNeeded(obj, cls, genericType);
+ }
+
+ if (obj instanceof JAXBElement && cls != JAXBElement.class) {
+ cls = JAXBElement.class;
+ }
+
+ Marshaller ms = createMarshaller(obj, cls, genericType, enc);
+ ms.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE);
+ if (ns.length() > 0) {
+ Map<String, String> map = new HashMap<>();
+ // set the default just in case
+ if (!nsPrefixes.containsKey(ns)) {
+ map.put(ns, "ns1");
+ }
+ map.putAll(nsPrefixes);
+ setNamespaceMapper(ms, map);
+ }
+ marshal(obj, cls, genericType, enc, os, anns, mt, ms);
+ }
+
+ protected void marshal(Object obj, Class<?> cls, Type genericType,
+ String enc, OutputStream os, MediaType mt) throws Exception {
+ marshal(obj, cls, genericType, enc, os, mt, new Annotation[]{});
+ }
+
+ protected void marshal(Object obj, Class<?> cls, Type genericType,
+ String enc, OutputStream os, MediaType mt,
+ Annotation[] anns) throws Exception {
+ obj = convertToJaxbElementIfNeeded(obj, cls, genericType);
+ if (obj instanceof JAXBElement && cls != JAXBElement.class) {
+ cls = JAXBElement.class;
+ }
+
+ Marshaller ms = createMarshaller(obj, cls, genericType, enc);
+ if (!nsPrefixes.isEmpty()) {
+ setNamespaceMapper(ms, nsPrefixes);
+ }
+ addAttachmentMarshaller(ms);
+ processXmlAnnotations(ms, mt, anns);
+ marshal(obj, cls, genericType, enc, os, anns, mt, ms);
+ }
+
+ private void processXmlAnnotations(Marshaller ms, MediaType mt, Annotation[] anns) throws Exception {
+ if (anns == null) {
+ return;
+ }
+ for (Annotation ann : anns) {
+ if (ann.annotationType() == XMLInstruction.class) {
+ addProcessingInstructions(ms, (XMLInstruction)ann);
+ } else if (ann.annotationType() == XSISchemaLocation.class) {
+ addSchemaLocation(ms, (XSISchemaLocation)ann);
+ } else if (ann.annotationType() == XSLTTransform.class) {
+ addXslProcessingInstruction(ms, mt, (XSLTTransform)ann);
+ }
+ }
+ }
+
+ private void addProcessingInstructions(Marshaller ms, XMLInstruction pi) throws Exception {
+ String value = pi.value();
+ int ind = value.indexOf("href='");
+ if (ind > 0) {
+ String relRef = value.substring(ind + 6);
+ relRef = relRef.substring(0, relRef.length() - 3).trim();
+ if (relRef.endsWith("'")) {
+ relRef = relRef.substring(0, relRef.length() - 1);
+ }
+ String absRef = resolveXMLResourceURI(relRef);
+ value = value.substring(0, ind + 6) + absRef + "'?>";
+ }
+ setXmlPiProperty(ms, value);
+ }
+
+ private void addXslProcessingInstruction(Marshaller ms, MediaType mt, XSLTTransform ann)
+ throws Exception {
+ if (ann.type() == XSLTTransform.TransformType.CLIENT
+ || ann.type() == XSLTTransform.TransformType.BOTH && ann.mediaTypes().length > 0) {
+ for (String s : ann.mediaTypes()) {
+ if (mt.isCompatible(JAXRSUtils.toMediaType(s))) {
+ return;
+ }
+ }
+ String absRef = resolveXMLResourceURI(ann.value());
+ String xslPi = "<?xml-stylesheet type=\"text/xsl\" href=\"" + absRef + "\"?>";
+ setXmlPiProperty(ms, xslPi);
+ }
+ }
+
+ private void addSchemaLocation(Marshaller ms, XSISchemaLocation sl) throws Exception {
+ String value = sl.resolve() ? resolveXMLResourceURI(sl.value()) : sl.value();
+ String propName = !sl.noNamespace()
+ ? Marshaller.JAXB_SCHEMA_LOCATION : Marshaller.JAXB_NO_NAMESPACE_SCHEMA_LOCATION;
+ ms.setProperty(propName, value);
+ }
+
+ protected String resolveXMLResourceURI(String path) {
+ MessageContext mc = getContext();
+ if (mc != null) {
+ String httpBasePath = (String)mc.get("http.base.path");
+ final UriBuilder builder;
+ if (httpBasePath != null) {
+ builder = UriBuilder.fromPath(httpBasePath);
+ } else {
+ builder = mc.getUriInfo().getBaseUriBuilder();
+ }
+ return builder.path(path).path(xmlResourceOffset).build().toString();
+ }
+ return path;
+ }
+
+
+
+ protected void addAttachmentMarshaller(Marshaller ms) {
+ Collection<Attachment> attachments = getAttachments(true);
+ if (attachments != null) {
+ Object value = getContext().getContextualProperty(Message.MTOM_THRESHOLD);
+ Integer threshold = value != null ? Integer.valueOf(value.toString()) : Integer.valueOf(0);
+ ms.setAttachmentMarshaller(new JAXBAttachmentMarshaller(
+ attachments, threshold));
+ }
+ }
+
+ protected void addAttachmentUnmarshaller(Unmarshaller um) {
+ Collection<Attachment> attachments = getAttachments(false);
+ if (attachments != null) {
+ um.setAttachmentUnmarshaller(new JAXBAttachmentUnmarshaller(
+ attachments));
+ }
+ }
+
+ private Collection<Attachment> getAttachments(boolean write) {
+ MessageContext mc = getContext();
+ if (mc != null) {
+ // TODO: there has to be a better fix
+ String propertyName = write ? "WRITE-" + Message.ATTACHMENTS : Message.ATTACHMENTS;
+ return CastUtils.cast((Collection<?>)mc.get(propertyName));
+ }
+ return null;
+ }
+ //CHECKSTYLE:OFF
+ protected final void marshal(Object obj, Class<?> cls, Type genericType,
+ String enc, OutputStream os,
+ Annotation[] anns, MediaType mt, Marshaller ms)
+ throws Exception {
+ //CHECKSTYLE:ON
+ for (Map.Entry<String, Object> entry : mProperties.entrySet()) {
+ ms.setProperty(entry.getKey(), entry.getValue());
+ }
+ MessageContext mc = getContext();
+ if (mc != null) {
+ // check Marshaller properties which might've been set earlier on,
+ // they'll overwrite statically configured ones
+ for (String key : MARSHALLER_PROPERTIES) {
+ Object value = mc.get(key);
+ if (value != null) {
+ ms.setProperty(key, value);
+ }
+ }
+
+ }
+ XMLStreamWriter writer = getStreamWriter(obj, os, mt);
+ if (writer != null) {
+ if (os == null) {
+ ms.setProperty(Marshaller.JAXB_FRAGMENT, true);
+ } else if (mc != null) {
+ if (mc.getContent(XMLStreamWriter.class) != null) {
+ ms.setProperty(Marshaller.JAXB_FRAGMENT, true);
+ }
+ mc.put(XMLStreamWriter.class.getName(), writer);
+ }
+ marshalToWriter(ms, obj, writer, anns, mt);
+ if (mc != null) {
+ writer.writeEndDocument();
+ }
+ } else {
+ marshalToOutputStream(ms, obj, os, anns, mt);
+ }
+ }
+
+ protected XMLStreamWriter getStreamWriter(Object obj, OutputStream os, MediaType mt) {
+ XMLStreamWriter writer = null;
+ MessageContext mc = getContext();
+ if (mc != null) {
+ writer = mc.getContent(XMLStreamWriter.class);
+ if (writer == null) {
+ XMLOutputFactory factory = (XMLOutputFactory)mc.get(XMLOutputFactory.class.getName());
+ if (factory != null) {
+ try {
+ writer = factory.createXMLStreamWriter(os);
+ } catch (XMLStreamException e) {
+ throw ExceptionUtils.toInternalServerErrorException(
+ new RuntimeException("Cant' create XMLStreamWriter", e), null);
+ }
+ }
+ }
+ if (writer == null && getEnableStreaming()) {
+ writer = StaxUtils.createXMLStreamWriter(os);
+ }
+ }
+
+ if (writer == null && os == null) {
+ writer = getStreamHandlerFromCurrentMessage(XMLStreamWriter.class);
+ }
+ return createTransformWriterIfNeeded(writer, os, true);
+ }
+
+ protected void marshalToOutputStream(Marshaller ms, Object obj, OutputStream os,
+ Annotation[] anns, MediaType mt)
+ throws Exception {
+ org.apache.cxf.common.jaxb.JAXBUtils.setMinimumEscapeHandler(ms);
+ if (os == null) {
+ Writer writer = getStreamHandlerFromCurrentMessage(Writer.class);
+ if (writer == null) {
+ LOG.severe("No OutputStream, Writer, or XMLStreamWriter is available");
+ throw ExceptionUtils.toInternalServerErrorException(null, null);
+ }
+ ms.marshal(obj, writer);
+ writer.flush();
+ } else {
+ ms.marshal(obj, os);
+ }
+ }
+
+ protected void marshalToWriter(Marshaller ms, Object obj, XMLStreamWriter writer,
+ Annotation[] anns, MediaType mt)
+ throws Exception {
+ org.apache.cxf.common.jaxb.JAXBUtils.setNoEscapeHandler(ms);
+ ms.marshal(obj, writer);
+ }
+
+ public void setXmlPiPropertyName(String xmlPiPropertyName) {
+ this.xmlPiPropertyName = xmlPiPropertyName;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/MultipartProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/MultipartProvider.java
new file mode 100644
index 0000000..e129eff
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/MultipartProvider.java
@@ -0,0 +1,474 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import javax.activation.DataHandler;
+import javax.activation.DataSource;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+
+import org.apache.cxf.attachment.AttachmentUtil;
+import org.apache.cxf.attachment.ByteDataSource;
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PrimitiveUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.jaxrs.ext.MessageContext;
+import org.apache.cxf.jaxrs.ext.multipart.Attachment;
+import org.apache.cxf.jaxrs.ext.multipart.ContentDisposition;
+import org.apache.cxf.jaxrs.ext.multipart.InputStreamDataSource;
+import org.apache.cxf.jaxrs.ext.multipart.Multipart;
+import org.apache.cxf.jaxrs.ext.multipart.MultipartBody;
+import org.apache.cxf.jaxrs.ext.multipart.MultipartOutputFilter;
+import org.apache.cxf.jaxrs.impl.MetadataMap;
+import org.apache.cxf.jaxrs.utils.AnnotationUtils;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.jaxrs.utils.multipart.AttachmentUtils;
+import org.apache.cxf.message.Message;
+
+@Provider
+@Consumes({"multipart/related", "multipart/mixed", "multipart/alternative", "multipart/form-data" })
+@Produces({"multipart/related", "multipart/mixed", "multipart/alternative", "multipart/form-data" })
+public class MultipartProvider extends AbstractConfigurableProvider
+ implements MessageBodyReader<Object>, MessageBodyWriter<Object> {
+
+ private static final String SUPPORT_TYPE_AS_MULTIPART = "support.type.as.multipart";
+ private static final String SINGLE_PART_IS_COLLECTION = "single.multipart.is.collection";
+ private static final Logger LOG = LogUtils.getL7dLogger(MultipartProvider.class);
+ private static final ResourceBundle BUNDLE = BundleUtils.getBundle(MultipartProvider.class);
+ private static final Set<Class<?>> WELL_KNOWN_MULTIPART_CLASSES = new HashSet<>();
+ private static final Set<String> MULTIPART_SUBTYPES = new HashSet<>();
+ static {
+ WELL_KNOWN_MULTIPART_CLASSES.add(MultipartBody.class);
+ WELL_KNOWN_MULTIPART_CLASSES.add(Attachment.class);
+
+ MULTIPART_SUBTYPES.add("form-data");
+ MULTIPART_SUBTYPES.add("mixed");
+ MULTIPART_SUBTYPES.add("related");
+ MULTIPART_SUBTYPES.add("alternative");
+ }
+
+ @Context
+ private MessageContext mc;
+ private String attachmentDir;
+ private String attachmentThreshold;
+ private String attachmentMaxSize;
+
+ public void setMessageContext(MessageContext context) {
+ this.mc = context;
+ }
+
+ public void setAttachmentDirectory(String dir) {
+ attachmentDir = dir;
+ }
+
+ public void setAttachmentThreshold(String threshold) {
+ attachmentThreshold = threshold;
+ }
+
+ public void setAttachmentMaxSize(String maxSize) {
+ attachmentMaxSize = maxSize;
+ }
+
+ public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations,
+ MediaType mt) {
+ return isSupported(type, annotations, mt);
+
+ }
+
+ private boolean isSupported(Class<?> type, Annotation[] anns, MediaType mt) {
+ return mediaTypeSupported(mt)
+ && (WELL_KNOWN_MULTIPART_CLASSES.contains(type)
+ || Collection.class.isAssignableFrom(type)
+ || Map.class.isAssignableFrom(type) && type != MultivaluedMap.class
+ || AnnotationUtils.getAnnotation(anns, Multipart.class) != null
+ || PropertyUtils.isTrue(mc.getContextualProperty(SUPPORT_TYPE_AS_MULTIPART)));
+ }
+
+ protected void checkContentLength() {
+ if (mc != null && isPayloadEmpty(mc.getHttpHeaders())) {
+ String message = new org.apache.cxf.common.i18n.Message("EMPTY_BODY", BUNDLE).toString();
+ LOG.warning(message);
+ throw new WebApplicationException(400);
+ }
+ }
+
+ public Object readFrom(Class<Object> c, Type t, Annotation[] anns, MediaType mt,
+ MultivaluedMap<String, String> headers, InputStream is)
+ throws IOException, WebApplicationException {
+ checkContentLength();
+ List<Attachment> infos = AttachmentUtils.getAttachments(
+ mc, attachmentDir, attachmentThreshold, attachmentMaxSize);
+
+ boolean collectionExpected = Collection.class.isAssignableFrom(c);
+ if (collectionExpected
+ && AnnotationUtils.getAnnotation(anns, Multipart.class) == null) {
+ return getAttachmentCollection(t, infos, anns);
+ }
+ if (c.isAssignableFrom(Map.class)) {
+ Map<String, Object> map = new LinkedHashMap<>(infos.size());
+ Class<?> actual = getActualType(t, 1);
+ for (Attachment a : infos) {
+ map.put(a.getContentType().toString(), fromAttachment(a, actual, actual, anns));
+ }
+ return map;
+ }
+ if (MultipartBody.class.isAssignableFrom(c)) {
+ return new MultipartBody(infos);
+ }
+
+ Multipart id = AnnotationUtils.getAnnotation(anns, Multipart.class);
+ Attachment multipart = AttachmentUtils.getMultipart(id, mt, infos);
+ if (multipart != null) {
+ if (collectionExpected
+ && !mediaTypeSupported(multipart.getContentType())
+ && !PropertyUtils.isTrue(mc.getContextualProperty(SINGLE_PART_IS_COLLECTION))) {
+ List<Attachment> allMultiparts = AttachmentUtils.getMatchingAttachments(id, infos);
+ return getAttachmentCollection(t, allMultiparts, anns);
+ }
+ return fromAttachment(multipart, c, t, anns);
+ }
+
+ if (id != null && !id.required()) {
+ /*
+ * Return default value for a missing optional part
+ */
+ Object defaultValue = null;
+ if (c.isPrimitive()) {
+ defaultValue = PrimitiveUtils.read((Class<?>)c == boolean.class ? "false" : "0", c);
+ }
+ return defaultValue;
+ }
+
+ throw ExceptionUtils.toBadRequestException(null, null);
+
+ }
+
+ private Object getAttachmentCollection(Type t, List<Attachment> infos, Annotation[] anns) throws IOException {
+ Class<?> actual = getActualType(t, 0);
+ if (Attachment.class.isAssignableFrom(actual)) {
+ return infos;
+ }
+ Collection<Object> objects = new ArrayList<>();
+ for (Attachment a : infos) {
+ objects.add(fromAttachment(a, actual, actual, anns));
+ }
+ return objects;
+ }
+
+ private Class<?> getActualType(Type type, int pos) {
+ Class<?> actual = null;
+ try {
+ actual = InjectionUtils.getActualType(type, pos);
+ } catch (Exception ex) {
+ // ignore;
+ }
+ return actual != null && actual != Object.class ? actual : Attachment.class;
+ }
+
+ private <T> Object fromAttachment(Attachment multipart, Class<T> c, Type t, Annotation[] anns)
+ throws IOException {
+ if (DataHandler.class.isAssignableFrom(c)) {
+ return multipart.getDataHandler();
+ } else if (DataSource.class.isAssignableFrom(c)) {
+ return multipart.getDataHandler().getDataSource();
+ } else if (Attachment.class.isAssignableFrom(c)) {
+ return multipart;
+ } else {
+ if (mediaTypeSupported(multipart.getContentType())) {
+ mc.put("org.apache.cxf.multipart.embedded", true);
+ mc.put("org.apache.cxf.multipart.embedded.ctype", multipart.getContentType());
+ mc.put("org.apache.cxf.multipart.embedded.input",
+ multipart.getDataHandler().getInputStream());
+ anns = new Annotation[]{};
+ }
+ MessageBodyReader<T> r =
+ mc.getProviders().getMessageBodyReader(c, t, anns, multipart.getContentType());
+ if (r != null) {
+ InputStream is = multipart.getDataHandler().getInputStream();
+ return r.readFrom(c, t, anns, multipart.getContentType(), multipart.getHeaders(),
+ is);
+ }
+ }
+ return null;
+ }
+
+ private boolean mediaTypeSupported(MediaType mt) {
+ return "multipart".equals(mt.getType()) && MULTIPART_SUBTYPES.contains(mt.getSubtype());
+ }
+
+ public long getSize(Object t, Class<?> type, Type genericType, Annotation[] annotations,
+ MediaType mediaType) {
+ return -1;
+ }
+
+ public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations,
+ MediaType mt) {
+ return isSupported(type, annotations, mt);
+ }
+
+
+ public void writeTo(Object obj, Class<?> type, Type genericType, Annotation[] anns, MediaType mt,
+ MultivaluedMap<String, Object> headers, OutputStream os)
+ throws IOException, WebApplicationException {
+
+ List<Attachment> handlers = convertToDataHandlers(obj, type, genericType, anns, mt);
+ if (mc.get(AttachmentUtils.OUT_FILTERS) != null) {
+ List<MultipartOutputFilter> filters = CastUtils.cast((List<?>)mc.get(AttachmentUtils.OUT_FILTERS));
+ for (MultipartOutputFilter filter : filters) {
+ filter.filter(handlers);
+ }
+ }
+ mc.put(MultipartBody.OUTBOUND_MESSAGE_ATTACHMENTS, handlers);
+ handlers.get(0).getDataHandler().writeTo(os);
+ }
+
+ private List<Attachment> convertToDataHandlers(Object obj,
+ Class<?> type, Type genericType,
+ Annotation[] anns, MediaType mt) throws IOException {
+ if (Map.class.isAssignableFrom(obj.getClass())) {
+ Map<Object, Object> objects = CastUtils.cast((Map<?, ?>)obj);
+ List<Attachment> handlers = new ArrayList<>(objects.size());
+ int i = 0;
+ for (Iterator<Map.Entry<Object, Object>> iter = objects.entrySet().iterator();
+ iter.hasNext();) {
+ Map.Entry<Object, Object> entry = iter.next();
+ Object value = entry.getValue();
+ Attachment handler = createDataHandler(value, value.getClass(),
+ new Annotation[]{},
+ entry.getKey().toString(),
+ mt.toString(),
+ i++);
+ handlers.add(handler);
+ }
+ return handlers;
+ }
+ String rootMediaType = getRootMediaType(anns, mt);
+ if (List.class.isAssignableFrom(obj.getClass())) {
+ return getAttachments((List<?>)obj, rootMediaType);
+ }
+ if (MultipartBody.class.isAssignableFrom(type)) {
+ List<Attachment> atts = ((MultipartBody)obj).getAllAttachments();
+ // these attachments may have no DataHandlers, but objects only
+ return getAttachments(atts, rootMediaType);
+ }
+ Attachment handler = createDataHandler(obj,
+ genericType, anns,
+ rootMediaType, mt.toString(), 1);
+ return Collections.singletonList(handler);
+ }
+
+ private List<Attachment> getAttachments(List<?> objects, String rootMediaType) throws IOException {
+ List<Attachment> handlers = new ArrayList<>(objects.size());
+ for (int i = 0; i < objects.size(); i++) {
+ Object value = objects.get(i);
+ Attachment handler = createDataHandler(value,
+ value.getClass(), new Annotation[]{},
+ rootMediaType, rootMediaType, i);
+ handlers.add(handler);
+ }
+ return handlers;
+ }
+
+ private <T> Attachment createDataHandler(T obj,
+ Type genericType,
+ Annotation[] anns,
+ String mimeType,
+ String mainMediaType,
+ int id) throws IOException {
+ @SuppressWarnings("unchecked")
+ Class<T> cls = (Class<T>)obj.getClass();
+ return createDataHandler(obj, cls, genericType, anns, mimeType, mainMediaType, id);
+ }
+ private <T> Attachment createDataHandler(T obj,
+ Class<T> cls,
+ Type genericType,
+ Annotation[] anns,
+ String mimeType,
+ String mainMediaType,
+ int id) throws IOException {
+ final DataHandler dh;
+ if (InputStream.class.isAssignableFrom(obj.getClass())) {
+ dh = createInputStreamDH((InputStream)obj, mimeType);
+ } else if (DataHandler.class.isAssignableFrom(obj.getClass())) {
+ dh = (DataHandler)obj;
+ } else if (DataSource.class.isAssignableFrom(obj.getClass())) {
+ dh = new DataHandler((DataSource)obj);
+ } else if (File.class.isAssignableFrom(obj.getClass())) {
+ File f = (File)obj;
+ ContentDisposition cd = mainMediaType.startsWith(MediaType.MULTIPART_FORM_DATA)
+ ? new ContentDisposition("form-data;name=file;filename=" + f.getName()) : null;
+ return new Attachment(AttachmentUtil.BODY_ATTACHMENT_ID, Files.newInputStream(f.toPath()), cd);
+ } else if (Attachment.class.isAssignableFrom(obj.getClass())) {
+ Attachment att = (Attachment)obj;
+ if (att.getObject() == null) {
+ return att;
+ }
+ dh = getHandlerForObject(att.getObject(),
+ att.getObject().getClass(), new Annotation[]{},
+ att.getContentType().toString(), id);
+ return new Attachment(att.getContentId(), dh, att.getHeaders());
+ } else if (byte[].class.isAssignableFrom(obj.getClass())) {
+ ByteDataSource source = new ByteDataSource((byte[])obj);
+ source.setContentType(mimeType);
+ dh = new DataHandler(source);
+ } else {
+ dh = getHandlerForObject(obj, cls, genericType, anns, mimeType);
+ }
+ String contentId = getContentId(anns, id);
+ MultivaluedMap<String, String> headers = new MetadataMap<>();
+ headers.putSingle("Content-Type", mimeType);
+
+ return new Attachment(contentId, dh, headers);
+ }
+
+ private String getContentId(Annotation[] anns, int id) {
+ Multipart part = AnnotationUtils.getAnnotation(anns, Multipart.class);
+ if (part != null && !"".equals(part.value())) {
+ return part.value();
+ }
+ return id == 0 ? AttachmentUtil.BODY_ATTACHMENT_ID : Integer.toString(id);
+ }
+
+ private <T> DataHandler getHandlerForObject(T obj,
+ Class<T> cls, Type genericType,
+ Annotation[] anns,
+ String mimeType) {
+ MediaType mt = JAXRSUtils.toMediaType(mimeType);
+ mc.put(ProviderFactory.ACTIVE_JAXRS_PROVIDER_KEY, this);
+
+ final MessageBodyWriter<T> r;
+ try {
+ r = mc.getProviders().getMessageBodyWriter(cls, genericType, anns, mt);
+ } finally {
+ mc.put(ProviderFactory.ACTIVE_JAXRS_PROVIDER_KEY, null);
+ }
+ if (r == null) {
+ org.apache.cxf.common.i18n.Message message =
+ new org.apache.cxf.common.i18n.Message("NO_MSG_WRITER",
+ BUNDLE,
+ cls);
+ LOG.severe(message.toString());
+ throw ExceptionUtils.toInternalServerErrorException(null, null);
+ }
+
+ return new MessageBodyWriterDataHandler<T>(r, obj, cls, genericType, anns, mt);
+ }
+ private <T> DataHandler getHandlerForObject(T obj,
+ Type genericType,
+ Annotation[] anns,
+ String mimeType, int id) {
+ @SuppressWarnings("unchecked")
+ Class<T> cls = (Class<T>)obj.getClass();
+ return getHandlerForObject(obj, cls, genericType, anns, mimeType);
+ }
+
+ private DataHandler createInputStreamDH(InputStream is, String mimeType) {
+ return new DataHandler(new InputStreamDataSource(is, mimeType));
+ }
+
+ private String getRootMediaType(Annotation[] anns, MediaType mt) {
+ String mimeType = mt.getParameters().get("type");
+ if (mimeType != null) {
+ return mimeType;
+ }
+ Multipart id = AnnotationUtils.getAnnotation(anns, Multipart.class);
+ if (id != null && !MediaType.WILDCARD.equals(id.type())) {
+ mimeType = id.type();
+ }
+ if (mimeType == null) {
+ if (PropertyUtils.isTrue(mc.getContextualProperty(Message.MTOM_ENABLED))) {
+ mimeType = "text/xml";
+ } else {
+ mimeType = MediaType.APPLICATION_OCTET_STREAM;
+ }
+ }
+ return mimeType;
+ }
+
+ private static class MessageBodyWriterDataHandler<T> extends DataHandler {
+ private MessageBodyWriter<T> writer;
+ private T obj;
+ private Class<T> cls;
+ private Type genericType;
+ private Annotation[] anns;
+ private MediaType contentType;
+ MessageBodyWriterDataHandler(MessageBodyWriter<T> writer,
+ T obj,
+ Class<T> cls,
+ Type genericType,
+ Annotation[] anns,
+ MediaType contentType) {
+ super(new ByteDataSource("1".getBytes(), contentType.toString()));
+ this.writer = writer;
+ this.obj = obj;
+ this.cls = cls;
+ this.genericType = genericType;
+ this.anns = anns;
+ this.contentType = contentType;
+ }
+
+ @Override
+ public void writeTo(OutputStream os) {
+ try {
+ writer.writeTo(obj, cls, genericType, anns, contentType,
+ new MetadataMap<String, Object>(), os);
+ } catch (IOException ex) {
+ throw ExceptionUtils.toInternalServerErrorException(ex, null);
+ }
+ }
+
+ @Override
+ public String getContentType() {
+ return contentType.toString();
+ }
+
+ // TODO : throw UnsupportedOperationException for all other DataHandler methods
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/SourceProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/SourceProvider.java
new file mode 100644
index 0000000..76980b8
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/SourceProvider.java
@@ -0,0 +1,236 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.util.logging.Logger;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.Source;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.stream.StreamSource;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.jaxrs.ext.MessageContext;
+import org.apache.cxf.jaxrs.ext.xml.XMLSource;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.PhaseInterceptorChain;
+import org.apache.cxf.staxutils.DepthExceededStaxException;
+import org.apache.cxf.staxutils.StaxSource;
+import org.apache.cxf.staxutils.StaxUtils;
+
+@Provider
+@Produces({"application/xml", "application/*+xml", "text/xml" })
+@Consumes({"application/xml", "application/*+xml", "text/xml", "text/html" })
+public class SourceProvider<T> extends AbstractConfigurableProvider implements
+ MessageBodyReader<T>, MessageBodyWriter<T> {
+
+ private static final String PREFERRED_FORMAT = "source-preferred-format";
+ private static final Logger LOG = LogUtils.getL7dLogger(SourceProvider.class);
+ @Context
+ private MessageContext context;
+
+
+ public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mt) {
+ return Source.class.isAssignableFrom(type)
+ || Node.class.isAssignableFrom(type);
+ }
+
+ public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mt) {
+ return Source.class.isAssignableFrom(type)
+ || XMLSource.class.isAssignableFrom(type)
+ || Document.class.isAssignableFrom(type);
+ }
+
+ public T readFrom(Class<T> source, Type genericType, Annotation[] annotations, MediaType m,
+ MultivaluedMap<String, String> headers, InputStream is)
+ throws IOException {
+
+ Class<?> theSource = source;
+ if (theSource == Source.class) {
+ String s = getPreferredSource();
+ if ("sax".equalsIgnoreCase(s) || "cxf.stax".equalsIgnoreCase(s)) {
+ theSource = SAXSource.class;
+ }
+ }
+ try {
+ if (DOMSource.class.isAssignableFrom(theSource) || Document.class.isAssignableFrom(theSource)) {
+
+ boolean docRequired = Document.class.isAssignableFrom(theSource);
+ XMLStreamReader reader = getReader(is);
+ try {
+ Document doc = StaxUtils.read(reader);
+ return source.cast(docRequired ? doc : new DOMSource(doc));
+ } catch (DepthExceededStaxException e) {
+ throw ExceptionUtils.toWebApplicationException(null, JAXRSUtils.toResponse(413));
+ } catch (XMLStreamException e) {
+ if (e.getMessage() != null && e.getMessage().startsWith("Maximum Number")) {
+ throw ExceptionUtils.toWebApplicationException(null, JAXRSUtils.toResponse(413));
+ }
+ throw ExceptionUtils.toBadRequestException(e, null);
+ } catch (Exception e) {
+ IOException ioex = new IOException("Problem creating a Source object");
+ ioex.setStackTrace(e.getStackTrace());
+ throw ioex;
+ } finally {
+ try {
+ reader.close();
+ } catch (XMLStreamException e) {
+ //ignore
+ }
+ }
+ } else if (SAXSource.class.isAssignableFrom(theSource)
+ || StaxSource.class.isAssignableFrom(theSource)) {
+ return source.cast(new StaxSource(getReader(is)));
+ } else if (StreamSource.class.isAssignableFrom(theSource)
+ || Source.class.isAssignableFrom(theSource)) {
+ return source.cast(new StreamSource(getRealStream(is)));
+ } else if (XMLSource.class.isAssignableFrom(theSource)) {
+ return source.cast(new XMLSource(getRealStream(is)));
+ }
+ } catch (ClassCastException e) {
+ String msg = "Unsupported class: " + source.getName();
+ LOG.warning(msg);
+ throw ExceptionUtils.toInternalServerErrorException(null, null);
+ }
+
+ throw new IOException("Unrecognized source");
+ }
+
+ protected XMLStreamReader getReader(InputStream is) {
+ XMLStreamReader reader = getReaderFromMessage();
+ if (reader == null) {
+ reader = StaxUtils.createXMLStreamReader(is);
+ }
+ return configureReaderRestrictions(reader);
+ }
+
+ protected XMLStreamReader configureReaderRestrictions(XMLStreamReader reader) {
+ Message message = PhaseInterceptorChain.getCurrentMessage();
+ if (message != null) {
+ try {
+ return StaxUtils.configureReader(reader, message);
+ } catch (XMLStreamException ex) {
+ throw ExceptionUtils.toInternalServerErrorException(ex, null);
+ }
+ }
+ return reader;
+ }
+
+ protected InputStream getRealStream(InputStream is) throws IOException {
+ XMLStreamReader reader = getReaderFromMessage();
+ return reader == null ? is : getStreamFromReader(reader);
+ }
+
+ private InputStream getStreamFromReader(XMLStreamReader input)
+ throws IOException {
+
+ try (CachedOutputStream out = new CachedOutputStream()) {
+ StaxUtils.copy(input, out);
+ return out.getInputStream();
+ } catch (XMLStreamException ex) {
+ throw new IOException("XMLStreamException:" + ex.getMessage());
+ }
+ }
+
+ protected XMLStreamReader getReaderFromMessage() {
+ MessageContext mc = getContext();
+ if (mc != null) {
+ return mc.getContent(XMLStreamReader.class);
+ }
+ return null;
+ }
+
+ public void writeTo(T source, Class<?> clazz, Type genericType, Annotation[] annotations,
+ MediaType mt, MultivaluedMap<String, Object> headers, OutputStream os)
+ throws IOException {
+
+ String encoding = HttpUtils.getSetEncoding(mt, headers, StandardCharsets.UTF_8.name());
+
+ final XMLStreamReader reader;
+ if (source instanceof Source) {
+ reader = StaxUtils.createXMLStreamReader((Source)source);
+ } else if (source instanceof Document) {
+ reader = StaxUtils.createXMLStreamReader((Document)source);
+ } else {
+ reader = StaxUtils.createXMLStreamReader(new DOMSource((Node)source));
+ }
+ XMLStreamWriter writer = StaxUtils.createXMLStreamWriter(os, encoding);
+ try {
+ StaxUtils.copy(reader, writer);
+ } catch (XMLStreamException e) {
+ throw ExceptionUtils.toInternalServerErrorException(e, null);
+ } finally {
+ try {
+ reader.close();
+ } catch (XMLStreamException e) {
+ //ignore
+ }
+ try {
+ writer.flush();
+ writer.close();
+ } catch (XMLStreamException e) {
+ //ignore
+ }
+ }
+ }
+
+ public long getSize(T source, Class<?> type, Type genericType, Annotation[] annotations,
+ MediaType mt) {
+ return -1;
+ }
+
+ protected String getPreferredSource() {
+ MessageContext mc = getContext();
+ String source = null;
+ if (mc != null) {
+ source = (String)mc.getContextualProperty(PREFERRED_FORMAT);
+ }
+ return source != null ? source : "sax";
+
+ }
+
+ protected MessageContext getContext() {
+ return context;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/XSLTJaxbProvider.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/XSLTJaxbProvider.java
new file mode 100644
index 0000000..4250963
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/XSLTJaxbProvider.java
@@ -0,0 +1,588 @@
+/**
+ * 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.cxf.jaxrs.provider;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.PathSegment;
+import javax.ws.rs.core.UriInfo;
+import javax.ws.rs.ext.Provider;
+import javax.xml.XMLConstants;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.Templates;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.URIResolver;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.sax.SAXTransformerFactory;
+import javax.xml.transform.sax.TransformerHandler;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import org.xml.sax.XMLFilter;
+import org.xml.sax.XMLReader;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.io.CachedOutputStream;
+import org.apache.cxf.jaxrs.ext.MessageContext;
+import org.apache.cxf.jaxrs.ext.xml.XSLTTransform;
+import org.apache.cxf.jaxrs.utils.AnnotationUtils;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.jaxrs.utils.ResourceUtils;
+import org.apache.cxf.staxutils.StaxSource;
+import org.apache.cxf.staxutils.StaxUtils;
+
+@Produces({"application/xml", "application/*+xml", "text/xml", "text/html" })
+@Consumes({"application/xml", "application/*+xml", "text/xml", "text/html" })
+@Provider
+public class XSLTJaxbProvider<T> extends JAXBElementProvider<T> {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(XSLTJaxbProvider.class);
+
+ private static final String ABSOLUTE_PATH_PARAMETER = "absolute.path";
+ private static final String BASE_PATH_PARAMETER = "base.path";
+ private static final String RELATIVE_PATH_PARAMETER = "relative.path";
+ private static final String XSLT_TEMPLATE_PROPERTY = "xslt.template";
+ private SAXTransformerFactory factory;
+ private Templates inTemplates;
+ private Templates outTemplates;
+ private Map<String, Templates> inMediaTemplates;
+ private Map<String, Templates> outMediaTemplates;
+ private ConcurrentHashMap<String, Templates> annotationTemplates =
+ new ConcurrentHashMap<>();
+
+ private List<String> inClassesToHandle;
+ private List<String> outClassesToHandle;
+ private Map<String, Object> inParamsMap;
+ private Map<String, Object> outParamsMap;
+ private Map<String, String> inProperties;
+ private Map<String, String> outProperties;
+ private URIResolver uriResolver;
+ private String systemId;
+
+ private boolean supportJaxbOnly;
+ private boolean refreshTemplates;
+ private boolean secureProcessing = true;
+
+ public void setSupportJaxbOnly(boolean support) {
+ this.supportJaxbOnly = support;
+ }
+
+ @Override
+ public boolean isReadable(Class<?> type, Type genericType, Annotation[] anns, MediaType mt) {
+ if (!super.isReadable(type, genericType, anns, mt)) {
+ return false;
+ }
+
+ if (InjectionUtils.isSupportedCollectionOrArray(type)) {
+ return supportJaxbOnly;
+ }
+
+ // if the user has set the list of in classes and a given class
+ // is in that list then it can only be handled by the template
+ if (inClassCanBeHandled(type.getName()) || inClassesToHandle == null && !supportJaxbOnly) {
+ return inTemplatesAvailable(type, anns, mt);
+ }
+ return supportJaxbOnly;
+ }
+
+ @Override
+ public boolean isWriteable(Class<?> type, Type genericType, Annotation[] anns, MediaType mt) {
+ // JAXB support is required
+ if (!super.isWriteable(type, genericType, anns, mt)) {
+ return false;
+ }
+ if (InjectionUtils.isSupportedCollectionOrArray(type)) {
+ return supportJaxbOnly;
+ }
+
+ // if the user has set the list of out classes and a given class
+ // is in that list then it can only be handled by the template
+ if (outClassCanBeHandled(type.getName()) || outClassesToHandle == null && !supportJaxbOnly) {
+ return outTemplatesAvailable(type, anns, mt);
+ }
+ return supportJaxbOnly;
+ }
+
+ protected boolean inTemplatesAvailable(Class<?> cls, Annotation[] anns, MediaType mt) {
+ return inTemplates != null
+ || inMediaTemplates != null && inMediaTemplates.containsKey(mt.getType() + "/"
+ + mt.getSubtype())
+ || getTemplatesFromAnnotation(cls, anns, mt) != null;
+ }
+
+ protected boolean outTemplatesAvailable(Class<?> cls, Annotation[] anns, MediaType mt) {
+ return outTemplates != null
+ || outMediaTemplates != null && outMediaTemplates.containsKey(mt.getType()
+ + "/" + mt.getSubtype())
+ || getTemplatesFromAnnotation(cls, anns, mt) != null;
+ }
+
+ protected Templates getTemplatesFromAnnotation(Class<?> cls,
+ Annotation[] anns,
+ MediaType mt) {
+ Templates t = null;
+ XSLTTransform ann = getXsltTransformAnn(anns, mt);
+ if (ann != null) {
+ t = annotationTemplates.get(ann.value());
+ if (t == null || refreshTemplates) {
+ String path = ann.value();
+ final String cp = "classpath:";
+ if (!path.startsWith(cp)) {
+ path = cp + path;
+ }
+ t = createTemplates(path);
+ if (t == null) {
+ createTemplates(ClassLoaderUtils.getResource(ann.value(), cls));
+ }
+ if (t != null) {
+ annotationTemplates.put(ann.value(), t);
+ }
+ }
+ }
+ return t;
+
+ }
+
+ protected Templates getAnnotationTemplates(Annotation[] anns) {
+ Templates t = null;
+ XSLTTransform ann = AnnotationUtils.getAnnotation(anns, XSLTTransform.class);
+ if (ann != null) {
+ t = annotationTemplates.get(ann.value());
+ }
+ return t;
+
+ }
+
+ protected XSLTTransform getXsltTransformAnn(Annotation[] anns, MediaType mt) {
+ XSLTTransform ann = AnnotationUtils.getAnnotation(anns, XSLTTransform.class);
+ if (ann != null && ann.type() != XSLTTransform.TransformType.CLIENT) {
+ if (ann.mediaTypes().length > 0) {
+ for (String s : ann.mediaTypes()) {
+ if (mt.isCompatible(JAXRSUtils.toMediaType(s))) {
+ return ann;
+ }
+ }
+ return null;
+ }
+ return ann;
+ }
+ return null;
+ }
+
+
+
+ protected Templates getInTemplates(Annotation[] anns, MediaType mt) {
+ Templates t = createTemplatesFromContext();
+ if (t != null) {
+ return t;
+ }
+ t = inTemplates != null ? inTemplates
+ : inMediaTemplates != null ? inMediaTemplates.get(mt.getType() + "/" + mt.getSubtype()) : null;
+ if (t == null) {
+ t = getAnnotationTemplates(anns);
+ }
+ return t;
+ }
+
+ protected Templates getOutTemplates(Annotation[] anns, MediaType mt) {
+ Templates t = createTemplatesFromContext();
+ if (t != null) {
+ return t;
+ }
+ t = outTemplates != null ? outTemplates
+ : outMediaTemplates != null ? outMediaTemplates.get(mt.getType() + "/" + mt.getSubtype()) : null;
+ if (t == null) {
+ t = getAnnotationTemplates(anns);
+ }
+ return t;
+ }
+
+ @Override
+ protected Object unmarshalFromInputStream(Unmarshaller unmarshaller, InputStream is,
+ Annotation[] anns, MediaType mt)
+ throws JAXBException {
+ try {
+
+ Templates t = createTemplates(getInTemplates(anns, mt), inParamsMap, inProperties);
+ if (t == null && supportJaxbOnly) {
+ return super.unmarshalFromInputStream(unmarshaller, is, anns, mt);
+ }
+
+ if (unmarshaller.getClass().getName().contains("eclipse")) {
+ //eclipse MOXy doesn't work properly with the XMLFilter/Reader thing
+ //so we need to bounce through a DOM
+ Source reader = new StaxSource(StaxUtils.createXMLStreamReader(is));
+ DOMResult dom = new DOMResult();
+ t.newTransformer().transform(reader, dom);
+ return unmarshaller.unmarshal(dom.getNode());
+ }
+ XMLFilter filter;
+ try {
+ filter = factory.newXMLFilter(t);
+ } catch (TransformerConfigurationException ex) {
+ TemplatesImpl ti = (TemplatesImpl)t;
+ filter = factory.newXMLFilter(ti.getTemplates());
+ trySettingProperties(filter, ti);
+ }
+ XMLReader reader = new StaxSource(StaxUtils.createXMLStreamReader(is));
+ filter.setParent(reader);
+ SAXSource source = new SAXSource();
+ source.setXMLReader(filter);
+ if (systemId != null) {
+ source.setSystemId(systemId);
+ }
+ return unmarshaller.unmarshal(source);
+ } catch (TransformerException ex) {
+ LOG.warning("Transformation exception : " + ex.getMessage());
+ throw ExceptionUtils.toInternalServerErrorException(ex, null);
+ }
+ }
+
+ private void trySettingProperties(Object filter, TemplatesImpl ti) {
+ try {
+ //Saxon doesn't allow creating a Filter or Handler from anything other than it's original
+ //Templates. That then requires setting the parameters after the fact, but there
+ //isn't a standard API for that, so we have to grab the Transformer via reflection to
+ //set the parameters.
+ Transformer tr = (Transformer)filter.getClass().getMethod("getTransformer").invoke(filter);
+ tr.setURIResolver(ti.resolver);
+ for (Map.Entry<String, Object> entry : ti.transformParameters.entrySet()) {
+ tr.setParameter(entry.getKey(), entry.getValue());
+ }
+ for (Map.Entry<String, String> entry : ti.outProps.entrySet()) {
+ tr.setOutputProperty(entry.getKey(), entry.getValue());
+ }
+ } catch (Exception e) {
+ LOG.log(Level.WARNING, "Could not set properties for transfomer", e);
+ }
+ }
+
+ @Override
+ protected Object unmarshalFromReader(Unmarshaller unmarshaller, XMLStreamReader reader,
+ Annotation[] anns, MediaType mt)
+ throws JAXBException {
+ CachedOutputStream out = new CachedOutputStream();
+ try {
+ XMLStreamWriter writer = StaxUtils.createXMLStreamWriter(out);
+ StaxUtils.copy(new StaxSource(reader), writer);
+ writer.writeEndDocument();
+ writer.flush();
+ writer.close();
+ return unmarshalFromInputStream(unmarshaller, out.getInputStream(), anns, mt);
+ } catch (Exception ex) {
+ throw ExceptionUtils.toBadRequestException(ex, null);
+ }
+ }
+
+ @Override
+ protected void marshalToWriter(Marshaller ms, Object obj, XMLStreamWriter writer,
+ Annotation[] anns, MediaType mt)
+ throws Exception {
+ CachedOutputStream out = new CachedOutputStream();
+ marshalToOutputStream(ms, obj, out, anns, mt);
+
+ StaxUtils.copy(new StreamSource(out.getInputStream()), writer);
+ }
+
+ @Override
+ protected void addAttachmentMarshaller(Marshaller ms) {
+ // complete
+ }
+
+ protected Result getStreamResult(OutputStream os, Annotation[] anns, MediaType mt) throws Exception {
+ return new StreamResult(os);
+ }
+
+ @Override
+ protected void marshalToOutputStream(Marshaller ms, Object obj, OutputStream os,
+ Annotation[] anns, MediaType mt)
+ throws Exception {
+
+ Templates t = createTemplates(getOutTemplates(anns, mt), outParamsMap, outProperties);
+ if (t == null && supportJaxbOnly) {
+ super.marshalToOutputStream(ms, obj, os, anns, mt);
+ return;
+ }
+ org.apache.cxf.common.jaxb.JAXBUtils.setMinimumEscapeHandler(ms);
+ TransformerHandler th;
+ try {
+ th = factory.newTransformerHandler(t);
+ } catch (TransformerConfigurationException ex) {
+ TemplatesImpl ti = (TemplatesImpl)t;
+ th = factory.newTransformerHandler(ti.getTemplates());
+ this.trySettingProperties(th, ti);
+ }
+ Result result = getStreamResult(os, anns, mt);
+ if (systemId != null) {
+ result.setSystemId(systemId);
+ }
+ th.setResult(result);
+
+ if (getContext() == null) {
+ th.startDocument();
+ }
+ ms.marshal(obj, th);
+ if (getContext() == null) {
+ th.endDocument();
+ }
+ }
+
+ public void setOutTemplate(String loc) {
+ outTemplates = createTemplates(loc);
+ }
+
+ public void setInTemplate(String loc) {
+ inTemplates = createTemplates(loc);
+ }
+
+ public void setInMediaTemplates(Map<String, String> map) {
+ inMediaTemplates = new HashMap<>();
+ for (Map.Entry<String, String> entry : map.entrySet()) {
+ inMediaTemplates.put(entry.getKey(), createTemplates(entry.getValue()));
+ }
+ }
+
+ public void setOutMediaTemplates(Map<String, String> map) {
+ outMediaTemplates = new HashMap<>();
+ for (Map.Entry<String, String> entry : map.entrySet()) {
+ outMediaTemplates.put(entry.getKey(), createTemplates(entry.getValue()));
+ }
+ }
+
+ public void setResolver(URIResolver resolver) {
+ uriResolver = resolver;
+ if (factory != null) {
+ factory.setURIResolver(uriResolver);
+ }
+ }
+
+ public void setSystemId(String system) {
+ systemId = system;
+ }
+
+ public void setInParameters(Map<String, Object> inParams) {
+ this.inParamsMap = inParams;
+ }
+
+ public void setOutParameters(Map<String, Object> outParams) {
+ this.outParamsMap = outParams;
+ }
+
+ public void setInProperties(Map<String, String> inProps) {
+ this.inProperties = inProps;
+ }
+
+ public void setOutProperties(Map<String, String> outProps) {
+ this.outProperties = outProps;
+ }
+
+ public void setInClassNames(List<String> classNames) {
+ inClassesToHandle = classNames;
+ }
+
+ public boolean inClassCanBeHandled(String className) {
+ return inClassesToHandle != null && inClassesToHandle.contains(className);
+ }
+
+ public void setOutClassNames(List<String> classNames) {
+ outClassesToHandle = classNames;
+ }
+
+ public boolean outClassCanBeHandled(String className) {
+ return outClassesToHandle != null && outClassesToHandle.contains(className);
+ }
+
+ protected Templates createTemplates(Templates templates,
+ Map<String, Object> configuredParams,
+ Map<String, String> outProps) {
+ if (templates == null) {
+ if (supportJaxbOnly) {
+ return null;
+ }
+ LOG.severe("No template is available");
+ throw ExceptionUtils.toInternalServerErrorException(null, null);
+ }
+
+ TemplatesImpl templ = new TemplatesImpl(templates, uriResolver);
+ MessageContext mc = getContext();
+ if (mc != null) {
+ UriInfo ui = mc.getUriInfo();
+ MultivaluedMap<String, String> params = ui.getPathParameters();
+ for (Map.Entry<String, List<String>> entry : params.entrySet()) {
+ String value = entry.getValue().get(0);
+ int ind = value.indexOf(';');
+ if (ind > 0) {
+ value = value.substring(0, ind);
+ }
+ templ.setTransformerParameter(entry.getKey(), value);
+ }
+
+ List<PathSegment> segments = ui.getPathSegments();
+ if (!segments.isEmpty()) {
+ setTransformParameters(templ, segments.get(segments.size() - 1).getMatrixParameters());
+ }
+ setTransformParameters(templ, ui.getQueryParameters());
+ templ.setTransformerParameter(ABSOLUTE_PATH_PARAMETER, ui.getAbsolutePath().toString());
+ templ.setTransformerParameter(RELATIVE_PATH_PARAMETER, ui.getPath());
+ templ.setTransformerParameter(BASE_PATH_PARAMETER, ui.getBaseUri().toString());
+ if (configuredParams != null) {
+ for (Map.Entry<String, Object> entry : configuredParams.entrySet()) {
+ templ.setTransformerParameter(entry.getKey(), entry.getValue());
+ }
+ }
+ }
+ if (outProps != null) {
+ templ.setOutProperties(outProps);
+ }
+
+ return templ;
+ }
+
+ private void setTransformParameters(TemplatesImpl templ, MultivaluedMap<String, String> params) {
+ for (Map.Entry<String, List<String>> entry : params.entrySet()) {
+ templ.setTransformerParameter(entry.getKey(), entry.getValue().get(0));
+ }
+ }
+
+ protected Templates createTemplates(String loc) {
+ try {
+ return createTemplates(ResourceUtils.getResourceURL(loc, this.getBus()));
+ } catch (Exception ex) {
+ LOG.warning("No template can be created : " + ex.getMessage());
+ }
+ return null;
+ }
+
+ protected Templates createTemplatesFromContext() {
+ MessageContext mc = getContext();
+ if (mc != null) {
+ String template = (String)mc.getContextualProperty(XSLT_TEMPLATE_PROPERTY);
+ if (template != null) {
+ return createTemplates(template);
+ }
+ }
+ return null;
+ }
+
+ protected Templates createTemplates(URL urlStream) {
+ if (urlStream == null) {
+ return null;
+ }
+
+ try (Reader r = new BufferedReader(
+ new InputStreamReader(urlStream.openStream(), StandardCharsets.UTF_8))) {
+ Source source = new StreamSource(r);
+ source.setSystemId(urlStream.toExternalForm());
+ if (factory == null) {
+ factory = (SAXTransformerFactory)TransformerFactory.newInstance();
+ factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, secureProcessing);
+ if (uriResolver != null) {
+ factory.setURIResolver(uriResolver);
+ }
+ }
+ return factory.newTemplates(source);
+
+ } catch (Exception ex) {
+ LOG.warning("No template can be created : " + ex.getMessage());
+ }
+ return null;
+ }
+
+ public void setRefreshTemplates(boolean refresh) {
+ this.refreshTemplates = refresh;
+ }
+
+ public void setSecureProcessing(boolean secureProcessing) {
+ this.secureProcessing = secureProcessing;
+ }
+
+ private static class TemplatesImpl implements Templates {
+
+ private Templates templates;
+ private URIResolver resolver;
+ private Map<String, Object> transformParameters = new HashMap<>();
+ private Map<String, String> outProps = new HashMap<>();
+
+ TemplatesImpl(Templates templates, URIResolver resolver) {
+ this.templates = templates;
+ this.resolver = resolver;
+ }
+
+ public Templates getTemplates() {
+ return templates;
+ }
+
+ public void setTransformerParameter(String name, Object value) {
+ transformParameters.put(name, value);
+ }
+
+ public void setOutProperties(Map<String, String> props) {
+ this.outProps = props;
+ }
+
+ public Properties getOutputProperties() {
+ return templates.getOutputProperties();
+ }
+
+ public Transformer newTransformer() throws TransformerConfigurationException {
+ Transformer tr = templates.newTransformer();
+ tr.setURIResolver(resolver);
+ for (Map.Entry<String, Object> entry : transformParameters.entrySet()) {
+ tr.setParameter(entry.getKey(), entry.getValue());
+ }
+ for (Map.Entry<String, String> entry : outProps.entrySet()) {
+ tr.setOutputProperty(entry.getKey(), entry.getValue());
+ }
+ return tr;
+ }
+
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/security/JAASAuthenticationFilter.java b/transform/src/patch/java/org/apache/cxf/jaxrs/security/JAASAuthenticationFilter.java
new file mode 100644
index 0000000..4dd05e3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/security/JAASAuthenticationFilter.java
@@ -0,0 +1,170 @@
+/**
+ * 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.cxf.jaxrs.security;
+
+import java.net.URI;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.annotation.Priority;
+import javax.security.auth.callback.CallbackHandler;
+import javax.security.auth.login.Configuration;
+import javax.ws.rs.Priorities;
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerRequestFilter;
+import javax.ws.rs.container.PreMatching;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.ResponseBuilder;
+import javax.ws.rs.core.UriBuilder;
+
+import org.apache.cxf.interceptor.security.JAASLoginInterceptor;
+import org.apache.cxf.interceptor.security.NamePasswordCallbackHandler;
+import org.apache.cxf.jaxrs.impl.HttpHeadersImpl;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Message;
+
+@PreMatching
+@Priority(Priorities.AUTHENTICATION)
+public class JAASAuthenticationFilter implements ContainerRequestFilter {
+
+ private static final List<MediaType> HTML_MEDIA_TYPES =
+ Arrays.asList(MediaType.APPLICATION_XHTML_XML_TYPE, MediaType.TEXT_HTML_TYPE);
+
+ private URI redirectURI;
+ private String realmName;
+ private boolean ignoreBasePath = true;
+
+ private JAASLoginInterceptor interceptor;
+
+ public JAASAuthenticationFilter() {
+ interceptor = new JAASLoginInterceptor() {
+ protected CallbackHandler getCallbackHandler(String name, String password) {
+ return JAASAuthenticationFilter.this.getCallbackHandler(name, password);
+ }
+ };
+ interceptor.setUseDoAs(false);
+ }
+
+ @Deprecated
+ public void setRolePrefix(String name) {
+ interceptor.setRolePrefix(name);
+ }
+
+
+ public void setIgnoreBasePath(boolean ignore) {
+ this.ignoreBasePath = ignore;
+ }
+
+ public void setContextName(String name) {
+ interceptor.setContextName(name);
+ }
+
+ public void setLoginConfig(Configuration config) {
+ interceptor.setLoginConfig(config);
+ }
+
+ public void setRoleClassifier(String rc) {
+ interceptor.setRoleClassifier(rc);
+ }
+
+ public void setRoleClassifierType(String rct) {
+ interceptor.setRoleClassifierType(rct);
+ }
+
+
+ public void setRedirectURI(String uri) {
+ this.redirectURI = URI.create(uri);
+ }
+
+ public void setRealmName(String name) {
+ this.realmName = name;
+ }
+
+ protected CallbackHandler getCallbackHandler(String name, String password) {
+ return new NamePasswordCallbackHandler(name, password);
+ }
+
+ @Override
+ public void filter(ContainerRequestContext context) {
+ Message m = JAXRSUtils.getCurrentMessage();
+ try {
+ interceptor.handleMessage(m);
+ } catch (SecurityException ex) {
+ context.abortWith(handleAuthenticationException(ex, m));
+ }
+ }
+
+ protected Response handleAuthenticationException(SecurityException ex, Message m) {
+ HttpHeaders headers = new HttpHeadersImpl(m);
+ if (redirectURI != null && isRedirectPossible(headers)) {
+
+ final URI finalRedirectURI;
+
+ if (!redirectURI.isAbsolute()) {
+ String endpointAddress = HttpUtils.getEndpointAddress(m);
+ Object basePathProperty = m.get(Message.BASE_PATH);
+ if (ignoreBasePath && basePathProperty != null && !"/".equals(basePathProperty)) {
+ int index = endpointAddress.lastIndexOf(basePathProperty.toString());
+ if (index != -1) {
+ endpointAddress = endpointAddress.substring(0, index);
+ }
+ }
+ finalRedirectURI = UriBuilder.fromUri(endpointAddress).path(redirectURI.toString()).build();
+ } else {
+ finalRedirectURI = redirectURI;
+ }
+
+ return Response.status(getRedirectStatus()).
+ header(HttpHeaders.LOCATION, finalRedirectURI).build();
+ }
+ ResponseBuilder builder = Response.status(Response.Status.UNAUTHORIZED);
+
+ StringBuilder sb = new StringBuilder();
+
+ List<String> authHeader = headers.getRequestHeader(HttpHeaders.AUTHORIZATION);
+ if (authHeader != null && !authHeader.isEmpty()) {
+ // should HttpHeadersImpl do it ?
+ String[] authValues = authHeader.get(0).split(" ");
+ if (authValues.length > 0) {
+ sb.append(authValues[0]);
+ }
+ } else {
+ sb.append("Basic");
+ }
+ if (realmName != null) {
+ sb.append(" realm=\"").append(realmName).append('"');
+ }
+ builder.header(HttpHeaders.WWW_AUTHENTICATE, sb.toString());
+
+ return builder.build();
+ }
+
+ protected Response.Status getRedirectStatus() {
+ return Response.Status.TEMPORARY_REDIRECT;
+ }
+
+ protected boolean isRedirectPossible(HttpHeaders headers) {
+ List<MediaType> clientTypes = headers.getAcceptableMediaTypes();
+ return !JAXRSUtils.intersectMimeTypes(clientTypes, HTML_MEDIA_TYPES, false)
+ .isEmpty();
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/security/KerberosAuthenticationFilter.java b/transform/src/patch/java/org/apache/cxf/jaxrs/security/KerberosAuthenticationFilter.java
new file mode 100644
index 0000000..1c7a164
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/security/KerberosAuthenticationFilter.java
@@ -0,0 +1,251 @@
+/**
+ * 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.cxf.jaxrs.security;
+
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.List;
+import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+import javax.security.auth.callback.CallbackHandler;
+import javax.security.auth.login.Configuration;
+import javax.security.auth.login.LoginContext;
+import javax.security.auth.login.LoginException;
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerRequestFilter;
+import javax.ws.rs.container.PreMatching;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.security.SimplePrincipal;
+import org.apache.cxf.common.security.SimpleSecurityContext;
+import org.apache.cxf.common.util.Base64Exception;
+import org.apache.cxf.common.util.Base64Utility;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.jaxrs.ext.MessageContext;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.security.SecurityContext;
+import org.ietf.jgss.GSSContext;
+import org.ietf.jgss.GSSException;
+import org.ietf.jgss.GSSManager;
+import org.ietf.jgss.GSSName;
+import org.ietf.jgss.Oid;
+@PreMatching
+public class KerberosAuthenticationFilter implements ContainerRequestFilter {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(KerberosAuthenticationFilter.class);
+
+ private static final String NEGOTIATE_SCHEME = "Negotiate";
+ private static final String PROPERTY_USE_KERBEROS_OID = "auth.spnego.useKerberosOid";
+ private static final String KERBEROS_OID = "1.2.840.113554.1.2.2";
+ private static final String SPNEGO_OID = "1.3.6.1.5.5.2";
+
+ private MessageContext messageContext;
+ private CallbackHandler callbackHandler;
+ private Configuration loginConfig;
+ private String loginContextName = "";
+ private String servicePrincipalName;
+ private String realm;
+
+ @Override
+ public void filter(ContainerRequestContext context) {
+
+ List<String> authHeaders = messageContext.getHttpHeaders()
+ .getRequestHeader(HttpHeaders.AUTHORIZATION);
+ if (authHeaders == null || authHeaders.size() != 1) {
+ LOG.fine("No Authorization header is available");
+ throw ExceptionUtils.toNotAuthorizedException(null, getFaultResponse());
+ }
+ String[] authPair = authHeaders.get(0).split(" ");
+ if (authPair.length != 2 || !NEGOTIATE_SCHEME.equalsIgnoreCase(authPair[0])) {
+ LOG.fine("Negotiate Authorization scheme is expected");
+ throw ExceptionUtils.toNotAuthorizedException(null, getFaultResponse());
+ }
+
+ byte[] serviceTicket = getServiceTicket(authPair[1]);
+
+ try {
+ Subject serviceSubject = loginAndGetSubject();
+
+ GSSContext gssContext = createGSSContext();
+
+ Subject.doAs(serviceSubject, new ValidateServiceTicketAction(gssContext, serviceTicket));
+
+ GSSName srcName = gssContext.getSrcName();
+ if (srcName == null) {
+ throw ExceptionUtils.toNotAuthorizedException(null, getFaultResponse());
+ }
+
+ String complexUserName = srcName.toString();
+
+ String simpleUserName = complexUserName;
+ int index = simpleUserName.lastIndexOf('@');
+ if (index > 0) {
+ simpleUserName = simpleUserName.substring(0, index);
+ }
+ Message m = JAXRSUtils.getCurrentMessage();
+ m.put(SecurityContext.class, createSecurityContext(simpleUserName, complexUserName, gssContext));
+
+ if (!gssContext.getCredDelegState()) {
+ gssContext.dispose();
+ }
+
+ } catch (LoginException e) {
+ LOG.fine("Unsuccessful JAAS login for the service principal: " + e.getMessage());
+ throw ExceptionUtils.toNotAuthorizedException(e, getFaultResponse());
+ } catch (GSSException e) {
+ LOG.fine("GSS API exception: " + e.getMessage());
+ throw ExceptionUtils.toNotAuthorizedException(e, getFaultResponse());
+ } catch (PrivilegedActionException e) {
+ LOG.fine("PrivilegedActionException: " + e.getMessage());
+ throw ExceptionUtils.toNotAuthorizedException(e, getFaultResponse());
+ }
+ }
+
+ protected SecurityContext createSecurityContext(String simpleUserName, String complexUserName,
+ GSSContext gssContext) {
+ return new KerberosSecurityContext(new KerberosPrincipal(simpleUserName, complexUserName), gssContext);
+ }
+
+ protected GSSContext createGSSContext() throws GSSException {
+ boolean useKerberosOid = PropertyUtils.isTrue(
+ messageContext.getContextualProperty(PROPERTY_USE_KERBEROS_OID));
+ Oid oid = new Oid(useKerberosOid ? KERBEROS_OID : SPNEGO_OID);
+
+ GSSManager gssManager = GSSManager.getInstance();
+
+ String spn = getCompleteServicePrincipalName();
+ GSSName gssService = gssManager.createName(spn, null);
+
+ return gssManager.createContext(gssService.canonicalize(oid),
+ oid, null, GSSContext.DEFAULT_LIFETIME);
+ }
+
+ protected Subject loginAndGetSubject() throws LoginException {
+
+ // The login without a callback can work if
+ // - Kerberos keytabs are used with a principal name set in the JAAS config
+ // - Kerberos is integrated into the OS logon process
+ // meaning that a process which runs this code has the
+ // user identity
+
+ final LoginContext lc;
+ if (!StringUtils.isEmpty(loginContextName) || loginConfig != null) {
+ lc = new LoginContext(loginContextName, null, callbackHandler, loginConfig);
+ } else {
+ LOG.fine("LoginContext can not be initialized");
+ throw new LoginException();
+ }
+ lc.login();
+ return lc.getSubject();
+ }
+
+ private byte[] getServiceTicket(String encodedServiceTicket) {
+ try {
+ return Base64Utility.decode(encodedServiceTicket);
+ } catch (Base64Exception ex) {
+ throw ExceptionUtils.toNotAuthorizedException(null, getFaultResponse());
+ }
+ }
+
+ private static Response getFaultResponse() {
+ return JAXRSUtils.toResponseBuilder(401).header(HttpHeaders.WWW_AUTHENTICATE, NEGOTIATE_SCHEME).build();
+ }
+
+ protected String getCompleteServicePrincipalName() {
+ String name = servicePrincipalName == null
+ ? "HTTP/" + messageContext.getUriInfo().getBaseUri().getHost() : servicePrincipalName;
+ if (realm != null) {
+ name += "@" + realm;
+ }
+ return name;
+
+
+ }
+
+ @Context
+ public void setMessageContext(MessageContext context) {
+ this.messageContext = context;
+ }
+
+ public void setLoginContextName(String contextName) {
+ this.loginContextName = contextName;
+ }
+
+ public void setServicePrincipalName(String servicePrincipalName) {
+ this.servicePrincipalName = servicePrincipalName;
+ }
+
+ public void setRealm(String realm) {
+ this.realm = realm;
+ }
+
+ public void setCallbackHandler(CallbackHandler callbackHandler) {
+ this.callbackHandler = callbackHandler;
+ }
+
+ private static final class ValidateServiceTicketAction implements PrivilegedExceptionAction<byte[]> {
+ private final GSSContext context;
+ private final byte[] token;
+
+ private ValidateServiceTicketAction(GSSContext context, byte[] token) {
+ this.context = context;
+ this.token = token;
+ }
+
+ public byte[] run() throws GSSException {
+ return context.acceptSecContext(token, 0, token.length);
+ }
+ }
+
+ public static class KerberosPrincipal extends SimplePrincipal {
+ private static final long serialVersionUID = 1L;
+ private String complexName;
+ public KerberosPrincipal(String simpleName, String complexName) {
+ super(simpleName);
+ this.complexName = complexName;
+ }
+
+ public String getKerberosName() {
+ return complexName;
+ }
+ }
+
+ public static class KerberosSecurityContext extends SimpleSecurityContext {
+ private GSSContext context;
+ public KerberosSecurityContext(KerberosPrincipal principal,
+ GSSContext context) {
+ super(principal);
+ this.context = context;
+ }
+
+ public GSSContext getGSSContext() {
+ return context;
+ }
+ }
+
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/servlet/CXFNonSpringJaxrsServlet.java b/transform/src/patch/java/org/apache/cxf/jaxrs/servlet/CXFNonSpringJaxrsServlet.java
new file mode 100644
index 0000000..290c223
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/servlet/CXFNonSpringJaxrsServlet.java
@@ -0,0 +1,640 @@
+/**
+ * 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.cxf.jaxrs.servlet;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.ws.rs.core.Application;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PrimitiveUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.feature.Feature;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.interceptor.Interceptor;
+import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
+import org.apache.cxf.jaxrs.lifecycle.PerRequestResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;
+import org.apache.cxf.jaxrs.model.ApplicationInfo;
+import org.apache.cxf.jaxrs.model.ProviderInfo;
+import org.apache.cxf.jaxrs.provider.ProviderFactory;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.ResourceUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.service.invoker.Invoker;
+import org.apache.cxf.transport.http.DestinationRegistry;
+import org.apache.cxf.transport.servlet.CXFNonSpringServlet;
+
+public class CXFNonSpringJaxrsServlet extends CXFNonSpringServlet {
+
+ private static final long serialVersionUID = -8916352798780577499L;
+
+ private static final Logger LOG = LogUtils.getL7dLogger(CXFNonSpringJaxrsServlet.class);
+
+ private static final String USER_MODEL_PARAM = "user.model";
+ private static final String SERVICE_ADDRESS_PARAM = "jaxrs.address";
+ private static final String IGNORE_APP_PATH_PARAM = "jaxrs.application.address.ignore";
+ private static final String SERVICE_CLASSES_PARAM = "jaxrs.serviceClasses";
+ private static final String PROVIDERS_PARAM = "jaxrs.providers";
+ private static final String FEATURES_PARAM = "jaxrs.features";
+ private static final String OUT_INTERCEPTORS_PARAM = "jaxrs.outInterceptors";
+ private static final String OUT_FAULT_INTERCEPTORS_PARAM = "jaxrs.outFaultInterceptors";
+ private static final String IN_INTERCEPTORS_PARAM = "jaxrs.inInterceptors";
+ private static final String INVOKER_PARAM = "jaxrs.invoker";
+ private static final String SERVICE_SCOPE_PARAM = "jaxrs.scope";
+ private static final String EXTENSIONS_PARAM = "jaxrs.extensions";
+ private static final String LANGUAGES_PARAM = "jaxrs.languages";
+ private static final String PROPERTIES_PARAM = "jaxrs.properties";
+ private static final String SCHEMAS_PARAM = "jaxrs.schemaLocations";
+ private static final String DOC_LOCATION_PARAM = "jaxrs.documentLocation";
+ private static final String STATIC_SUB_RESOLUTION_PARAM = "jaxrs.static.subresources";
+ private static final String SERVICE_SCOPE_SINGLETON = "singleton";
+ private static final String SERVICE_SCOPE_REQUEST = "prototype";
+
+ private static final String PARAMETER_SPLIT_CHAR = "class.parameter.split.char";
+ private static final String DEFAULT_PARAMETER_SPLIT_CHAR = ",";
+ private static final String SPACE_PARAMETER_SPLIT_CHAR = "space";
+
+ private static final String JAXRS_APPLICATION_PARAM = "javax.ws.rs.Application";
+
+ private ClassLoader classLoader;
+ private Application application;
+
+ public CXFNonSpringJaxrsServlet() {
+
+ }
+
+ public CXFNonSpringJaxrsServlet(Application app) {
+ this.application = app;
+ }
+
+ public CXFNonSpringJaxrsServlet(Object singletonService) {
+ this(Collections.singleton(singletonService));
+ }
+ public CXFNonSpringJaxrsServlet(Set<Object> applicationSingletons) {
+ this(new ApplicationImpl(applicationSingletons));
+ }
+
+ public CXFNonSpringJaxrsServlet(Application app, DestinationRegistry destinationRegistry, Bus bus) {
+ super(destinationRegistry, bus);
+ this.application = app;
+ }
+
+ @Override
+ public void init(ServletConfig servletConfig) throws ServletException {
+ super.init(servletConfig);
+
+ if (getApplication() != null) {
+ createServerFromApplication(servletConfig);
+ return;
+ }
+
+ String applicationClass = servletConfig.getInitParameter(JAXRS_APPLICATION_PARAM);
+ if (applicationClass != null) {
+ createServerFromApplication(applicationClass, servletConfig);
+ return;
+ }
+
+ String splitChar = getParameterSplitChar(servletConfig);
+ JAXRSServerFactoryBean bean = new JAXRSServerFactoryBean();
+ bean.setBus(getBus());
+
+ String address = servletConfig.getInitParameter(SERVICE_ADDRESS_PARAM);
+ if (address == null) {
+ address = "/";
+ }
+ bean.setAddress(address);
+
+ bean.setStaticSubresourceResolution(getStaticSubResolutionValue(servletConfig));
+
+ String modelRef = servletConfig.getInitParameter(USER_MODEL_PARAM);
+ if (modelRef != null) {
+ bean.setModelRef(modelRef.trim());
+ }
+ setDocLocation(bean, servletConfig);
+ setSchemasLocations(bean, servletConfig);
+ setAllInterceptors(bean, servletConfig, splitChar);
+ setInvoker(bean, servletConfig);
+
+ Map<Class<?>, Map<String, List<String>>> resourceClasses =
+ getServiceClasses(servletConfig, modelRef != null, splitChar);
+ Map<Class<?>, ResourceProvider> resourceProviders =
+ getResourceProviders(servletConfig, resourceClasses);
+
+ List<?> providers = getProviders(servletConfig, splitChar);
+
+ bean.setResourceClasses(new ArrayList<Class<?>>(resourceClasses.keySet()));
+ bean.setProviders(providers);
+ for (Map.Entry<Class<?>, ResourceProvider> entry : resourceProviders.entrySet()) {
+ bean.setResourceProvider(entry.getKey(), entry.getValue());
+ }
+ setExtensions(bean, servletConfig);
+
+ List<? extends Feature> features = getFeatures(servletConfig, splitChar);
+ bean.getFeatures().addAll(features);
+
+ bean.create();
+ }
+
+ protected String getParameterSplitChar(ServletConfig servletConfig) {
+ String param = servletConfig.getInitParameter(PARAMETER_SPLIT_CHAR);
+ if (!StringUtils.isEmpty(param) && SPACE_PARAMETER_SPLIT_CHAR.equals(param.trim())) {
+ return " ";
+ }
+ return DEFAULT_PARAMETER_SPLIT_CHAR;
+ }
+ protected boolean getStaticSubResolutionValue(ServletConfig servletConfig) {
+ String param = servletConfig.getInitParameter(STATIC_SUB_RESOLUTION_PARAM);
+ if (param != null) {
+ return Boolean.valueOf(param.trim());
+ }
+ return false;
+ }
+
+ protected void setExtensions(JAXRSServerFactoryBean bean, ServletConfig servletConfig) {
+ bean.setExtensionMappings(
+ CastUtils.cast((Map<?, ?>)parseMapSequence(servletConfig.getInitParameter(EXTENSIONS_PARAM))));
+ bean.setLanguageMappings(
+ CastUtils.cast((Map<?, ?>)parseMapSequence(servletConfig.getInitParameter(LANGUAGES_PARAM))));
+ Map<String, Object> properties = CastUtils.cast(
+ parseMapSequence(servletConfig.getInitParameter(PROPERTIES_PARAM)),
+ String.class, Object.class);
+ if (properties != null) {
+ bean.getProperties(true).putAll(properties);
+ }
+ }
+
+ protected void setAllInterceptors(JAXRSServerFactoryBean bean, ServletConfig servletConfig,
+ String splitChar)
+ throws ServletException {
+ setInterceptors(bean, servletConfig, OUT_INTERCEPTORS_PARAM, splitChar);
+ setInterceptors(bean, servletConfig, OUT_FAULT_INTERCEPTORS_PARAM, splitChar);
+ setInterceptors(bean, servletConfig, IN_INTERCEPTORS_PARAM, splitChar);
+ }
+
+ protected void setSchemasLocations(JAXRSServerFactoryBean bean, ServletConfig servletConfig) {
+ String schemas = servletConfig.getInitParameter(SCHEMAS_PARAM);
+ if (schemas == null) {
+ return;
+ }
+ String[] locations = schemas.split(" ");
+ List<String> list = new ArrayList<>();
+ for (String loc : locations) {
+ String theLoc = loc.trim();
+ if (!theLoc.isEmpty()) {
+ list.add(theLoc);
+ }
+ }
+ if (!list.isEmpty()) {
+ bean.setSchemaLocations(list);
+ }
+ }
+
+ protected void setDocLocation(JAXRSServerFactoryBean bean, ServletConfig servletConfig) {
+ String wadlLoc = servletConfig.getInitParameter(DOC_LOCATION_PARAM);
+ if (wadlLoc != null) {
+ bean.setDocLocation(wadlLoc);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ protected void setInterceptors(JAXRSServerFactoryBean bean, ServletConfig servletConfig,
+ String paramName,
+ String splitChar) throws ServletException {
+ String value = servletConfig.getInitParameter(paramName);
+ if (value == null) {
+ return;
+ }
+ String[] values = value.split(splitChar);
+ List<Interceptor<? extends Message>> list = new ArrayList<>();
+ for (String interceptorVal : values) {
+ Map<String, List<String>> props = new HashMap<>();
+ String theValue = getClassNameAndProperties(interceptorVal, props);
+ if (!theValue.isEmpty()) {
+ try {
+ Class<?> intClass = loadClass(theValue, "Interceptor");
+ Object object = intClass.newInstance();
+ injectProperties(object, props);
+ list.add((Interceptor<? extends Message>)object);
+ } catch (ServletException ex) {
+ throw ex;
+ } catch (Exception ex) {
+ LOG.warning("Interceptor class " + theValue + " can not be created");
+ throw new ServletException(ex);
+ }
+ }
+ }
+ if (!list.isEmpty()) {
+ if (OUT_INTERCEPTORS_PARAM.equals(paramName)) {
+ bean.setOutInterceptors(list);
+ } else if (OUT_FAULT_INTERCEPTORS_PARAM.equals(paramName)) {
+ bean.setOutFaultInterceptors(list);
+ } else {
+ bean.setInInterceptors(list);
+ }
+ }
+ }
+
+ protected void setInvoker(JAXRSServerFactoryBean bean, ServletConfig servletConfig)
+ throws ServletException {
+ String value = servletConfig.getInitParameter(INVOKER_PARAM);
+ if (value == null) {
+ return;
+ }
+ Map<String, List<String>> props = new HashMap<>();
+ String theValue = getClassNameAndProperties(value, props);
+ if (!theValue.isEmpty()) {
+ try {
+ Class<?> intClass = loadClass(theValue, "Invoker");
+ Object object = intClass.newInstance();
+ injectProperties(object, props);
+ bean.setInvoker((Invoker)object);
+ } catch (ServletException ex) {
+ throw ex;
+ } catch (Exception ex) {
+ LOG.warning("Invoker class " + theValue + " can not be created");
+ throw new ServletException(ex);
+ }
+ }
+
+
+ }
+
+ protected Map<Class<?>, Map<String, List<String>>> getServiceClasses(ServletConfig servletConfig,
+ boolean modelAvailable,
+ String splitChar) throws ServletException {
+ String serviceBeans = servletConfig.getInitParameter(SERVICE_CLASSES_PARAM);
+ if (serviceBeans == null) {
+ if (modelAvailable) {
+ return Collections.emptyMap();
+ }
+ throw new ServletException("At least one resource class should be specified");
+ }
+ String[] classNames = serviceBeans.split(splitChar);
+ Map<Class<?>, Map<String, List<String>>> map = new HashMap<>();
+ for (String cName : classNames) {
+ Map<String, List<String>> props = new HashMap<>();
+ String theName = getClassNameAndProperties(cName, props);
+ if (!theName.isEmpty()) {
+ Class<?> cls = loadClass(theName);
+ map.put(cls, props);
+ }
+ }
+ if (map.isEmpty()) {
+ throw new ServletException("At least one resource class should be specified");
+ }
+ return map;
+ }
+
+ protected List<? extends Feature> getFeatures(ServletConfig servletConfig, String splitChar)
+ throws ServletException {
+
+ String featuresList = servletConfig.getInitParameter(FEATURES_PARAM);
+ if (featuresList == null) {
+ return Collections.< Feature >emptyList();
+ }
+ String[] classNames = featuresList.split(splitChar);
+ List< Feature > features = new ArrayList<>();
+ for (String cName : classNames) {
+ Map<String, List<String>> props = new HashMap<>();
+ String theName = getClassNameAndProperties(cName, props);
+ if (!theName.isEmpty()) {
+ Class<?> cls = loadClass(theName);
+ if (Feature.class.isAssignableFrom(cls)) {
+ features.add((Feature)createSingletonInstance(cls, props, servletConfig));
+ }
+ }
+ }
+ return features;
+ }
+
+ protected List<?> getProviders(ServletConfig servletConfig, String splitChar) throws ServletException {
+ String providersList = servletConfig.getInitParameter(PROVIDERS_PARAM);
+ if (providersList == null) {
+ return Collections.emptyList();
+ }
+ String[] classNames = providersList.split(splitChar);
+ List<Object> providers = new ArrayList<>();
+ for (String cName : classNames) {
+ Map<String, List<String>> props = new HashMap<>();
+ String theName = getClassNameAndProperties(cName, props);
+ if (!theName.isEmpty()) {
+ Class<?> cls = loadClass(theName);
+ providers.add(createSingletonInstance(cls, props, servletConfig));
+ }
+ }
+ return providers;
+ }
+
+ private String getClassNameAndProperties(String cName, Map<String, List<String>> props) {
+ String theName = cName.trim();
+ int ind = theName.indexOf('(');
+ if (ind != -1 && theName.endsWith(")")) {
+ props.putAll(parseMapListSequence(theName.substring(ind + 1, theName.length() - 1)));
+ theName = theName.substring(0, ind).trim();
+ }
+ return theName;
+ }
+
+ protected static Map<String, List<String>> parseMapListSequence(String sequence) {
+ if (sequence != null) {
+ sequence = sequence.trim();
+ Map<String, List<String>> map = new HashMap<>();
+ String[] pairs = sequence.split(" ");
+ for (String pair : pairs) {
+ String thePair = pair.trim();
+ if (thePair.length() == 0) {
+ continue;
+ }
+ String[] values = thePair.split("=");
+ String key;
+ String value;
+ if (values.length == 2) {
+ key = values[0].trim();
+ value = values[1].trim();
+ } else {
+ key = thePair;
+ value = "";
+ }
+ List<String> list = map.get(key);
+ if (list == null) {
+ list = new LinkedList<>();
+ map.put(key, list);
+ }
+ list.add(value);
+ }
+ return map;
+ }
+ return Collections.emptyMap();
+ }
+
+ protected Map<Class<?>, ResourceProvider> getResourceProviders(ServletConfig servletConfig,
+ Map<Class<?>, Map<String, List<String>>> resourceClasses) throws ServletException {
+ String scope = servletConfig.getInitParameter(SERVICE_SCOPE_PARAM);
+ if (scope != null && !SERVICE_SCOPE_SINGLETON.equals(scope)
+ && !SERVICE_SCOPE_REQUEST.equals(scope)) {
+ throw new ServletException("Only singleton and prototype scopes are supported");
+ }
+ boolean isPrototype = SERVICE_SCOPE_REQUEST.equals(scope);
+ Map<Class<?>, ResourceProvider> map = new HashMap<>();
+ for (Map.Entry<Class<?>, Map<String, List<String>>> entry : resourceClasses.entrySet()) {
+ Class<?> c = entry.getKey();
+ map.put(c, isPrototype ? new PerRequestResourceProvider(c)
+ : new SingletonResourceProvider(
+ createSingletonInstance(c, entry.getValue(), servletConfig),
+ true));
+ }
+ return map;
+ }
+
+ protected boolean isAppResourceLifecycleASingleton(Application app, ServletConfig servletConfig) {
+ String scope = servletConfig.getInitParameter(SERVICE_SCOPE_PARAM);
+ if (scope == null) {
+ scope = (String)app.getProperties().get(SERVICE_SCOPE_PARAM);
+ }
+ return SERVICE_SCOPE_SINGLETON.equals(scope);
+ }
+
+ protected Object createSingletonInstance(Class<?> cls, Map<String, List<String>> props, ServletConfig sc)
+ throws ServletException {
+ Constructor<?> c = ResourceUtils.findResourceConstructor(cls, false);
+ if (c == null) {
+ throw new ServletException("No valid constructor found for " + cls.getName());
+ }
+ boolean isApplication = Application.class.isAssignableFrom(c.getDeclaringClass());
+ try {
+ final ProviderInfo<? extends Object> provider;
+ if (c.getParameterTypes().length == 0) {
+ if (isApplication) {
+ provider = new ApplicationInfo((Application)c.newInstance(), getBus());
+ } else {
+ provider = new ProviderInfo<>(c.newInstance(), getBus(), false, true);
+ }
+ } else {
+ Map<Class<?>, Object> values = new HashMap<>();
+ values.put(ServletContext.class, sc.getServletContext());
+ values.put(ServletConfig.class, sc);
+ provider = ProviderFactory.createProviderFromConstructor(c, values, getBus(), isApplication, true);
+ }
+ Object instance = provider.getProvider();
+ injectProperties(instance, props);
+ configureSingleton(instance);
+ return isApplication ? provider : instance;
+ } catch (InstantiationException ex) {
+ ex.printStackTrace();
+ throw new ServletException("Resource class " + cls.getName()
+ + " can not be instantiated");
+ } catch (IllegalAccessException ex) {
+ ex.printStackTrace();
+ throw new ServletException("Resource class " + cls.getName()
+ + " can not be instantiated due to IllegalAccessException");
+ } catch (InvocationTargetException ex) {
+ ex.printStackTrace();
+ throw new ServletException("Resource class " + cls.getName()
+ + " can not be instantiated due to InvocationTargetException");
+ }
+ }
+
+ private void injectProperties(Object instance, Map<String, List<String>> props) {
+ if (props == null || props.isEmpty()) {
+ return;
+ }
+ Method[] methods = instance.getClass().getMethods();
+ Map<String, Method> methodsMap = new HashMap<>();
+ for (Method m : methods) {
+ methodsMap.put(m.getName(), m);
+ }
+ for (Map.Entry<String, List<String>> entry : props.entrySet()) {
+ Method m = methodsMap.get("set" + StringUtils.capitalize(entry.getKey()));
+ if (m != null) {
+ Class<?> type = m.getParameterTypes()[0];
+ Object value;
+ if (InjectionUtils.isPrimitive(type)) {
+ value = PrimitiveUtils.read(entry.getValue().get(0), type);
+ } else {
+ value = entry.getValue();
+ }
+ InjectionUtils.injectThroughMethod(instance, m, value);
+ }
+ }
+ }
+
+ protected void configureSingleton(Object instance) {
+
+ }
+
+ protected void createServerFromApplication(String applicationNames, ServletConfig servletConfig)
+ throws ServletException {
+
+ boolean ignoreApplicationPath = isIgnoreApplicationPath(servletConfig);
+
+ String[] classNames = applicationNames.split(getParameterSplitChar(servletConfig));
+
+ if (classNames.length > 1 && ignoreApplicationPath) {
+ throw new ServletException("\"" + IGNORE_APP_PATH_PARAM
+ + "\" parameter must be set to false for multiple Applications be supported");
+ }
+
+ for (String cName : classNames) {
+ ApplicationInfo providerApp = createApplicationInfo(cName, servletConfig);
+
+ Application app = providerApp.getProvider();
+ JAXRSServerFactoryBean bean = ResourceUtils.createApplication(
+ app,
+ ignoreApplicationPath,
+ getStaticSubResolutionValue(servletConfig),
+ isAppResourceLifecycleASingleton(app, servletConfig),
+ getBus());
+ String splitChar = getParameterSplitChar(servletConfig);
+ setAllInterceptors(bean, servletConfig, splitChar);
+ setInvoker(bean, servletConfig);
+ setExtensions(bean, servletConfig);
+ setDocLocation(bean, servletConfig);
+ setSchemasLocations(bean, servletConfig);
+
+ List<?> providers = getProviders(servletConfig, splitChar);
+ bean.setProviders(providers);
+ List<? extends Feature> features = getFeatures(servletConfig, splitChar);
+ bean.getFeatures().addAll(features);
+
+ bean.setBus(getBus());
+ bean.setApplicationInfo(providerApp);
+ bean.create();
+ }
+ }
+
+ protected boolean isIgnoreApplicationPath(ServletConfig servletConfig) {
+ String ignoreParam = servletConfig.getInitParameter(IGNORE_APP_PATH_PARAM);
+ return ignoreParam == null || PropertyUtils.isTrue(ignoreParam);
+ }
+
+ protected void createServerFromApplication(ServletConfig servletConfig)
+ throws ServletException {
+
+ Application app = getApplication();
+ JAXRSServerFactoryBean bean = ResourceUtils.createApplication(
+ app,
+ isIgnoreApplicationPath(servletConfig),
+ getStaticSubResolutionValue(servletConfig),
+ isAppResourceLifecycleASingleton(app, servletConfig),
+ getBus());
+ String splitChar = getParameterSplitChar(servletConfig);
+ setAllInterceptors(bean, servletConfig, splitChar);
+ setInvoker(bean, servletConfig);
+ setExtensions(bean, servletConfig);
+ setDocLocation(bean, servletConfig);
+ setSchemasLocations(bean, servletConfig);
+
+ List<?> providers = getProviders(servletConfig, splitChar);
+ bean.setProviders(providers);
+ List<? extends Feature> features = getFeatures(servletConfig, splitChar);
+ bean.getFeatures().addAll(features);
+
+ bean.setBus(getBus());
+ bean.setApplication(getApplication());
+ bean.create();
+ }
+
+ protected Application createApplicationInstance(String appClassName, ServletConfig servletConfig)
+ throws ServletException {
+ return null;
+ }
+ protected ApplicationInfo createApplicationInfo(String appClassName, ServletConfig servletConfig)
+ throws ServletException {
+
+ Application customApp = createApplicationInstance(appClassName, servletConfig);
+ if (customApp != null) {
+ return new ApplicationInfo(customApp, getBus());
+ }
+ Map<String, List<String>> props = new HashMap<>();
+ appClassName = getClassNameAndProperties(appClassName, props);
+ Class<?> appClass = loadApplicationClass(appClassName);
+ ApplicationInfo appInfo = (ApplicationInfo)createSingletonInstance(appClass, props, servletConfig);
+ Map<String, Object> servletProps = new HashMap<>();
+ ServletContext servletContext = servletConfig.getServletContext();
+ for (Enumeration<String> names = servletContext.getInitParameterNames(); names.hasMoreElements();) {
+ String name = names.nextElement();
+ servletProps.put(name, servletContext.getInitParameter(name));
+ }
+ for (Enumeration<String> names = servletConfig.getInitParameterNames(); names.hasMoreElements();) {
+ String name = names.nextElement();
+ servletProps.put(name, servletConfig.getInitParameter(name));
+ }
+ appInfo.setOverridingProps(servletProps);
+ return appInfo;
+ }
+
+ protected Class<?> loadApplicationClass(String appClassName) throws ServletException {
+ return loadClass(appClassName, "Application");
+ }
+
+ protected Class<?> loadClass(String cName) throws ServletException {
+ return loadClass(cName, "Resource");
+ }
+
+ protected Class<?> loadClass(String cName, String classType) throws ServletException {
+ try {
+ final Class<?> cls;
+ if (classLoader == null) {
+ cls = ClassLoaderUtils.loadClass(cName, CXFNonSpringJaxrsServlet.class);
+ } else {
+ cls = classLoader.loadClass(cName);
+ }
+ return cls;
+ } catch (ClassNotFoundException ex) {
+ throw new ServletException("No " + classType + " class " + cName.trim() + " can be found", ex);
+ }
+ }
+
+ public void setClassLoader(ClassLoader loader) {
+ this.classLoader = loader;
+ }
+
+ protected Application getApplication() {
+ return application;
+ }
+
+ private static class ApplicationImpl extends Application {
+ private Set<Object> applicationSingletons;
+ ApplicationImpl(Set<Object> applicationSingletons) {
+ this.applicationSingletons = applicationSingletons;
+ }
+ public Set<Object> getSingletons() {
+ return applicationSingletons;
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/spring/JAXRSServerFactoryBeanDefinitionParser.java b/transform/src/patch/java/org/apache/cxf/jaxrs/spring/JAXRSServerFactoryBeanDefinitionParser.java
new file mode 100644
index 0000000..2115f6d
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/spring/JAXRSServerFactoryBeanDefinitionParser.java
@@ -0,0 +1,286 @@
+/**
+ * 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.cxf.jaxrs.spring;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import javax.ws.rs.Path;
+import javax.ws.rs.ext.Provider;
+import javax.xml.namespace.QName;
+
+import org.w3c.dom.Element;
+
+import org.apache.cxf.bus.spring.BusWiringBeanFactoryPostProcessor;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ClasspathScanner;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.configuration.spring.AbstractBeanDefinitionParser;
+import org.apache.cxf.endpoint.Server;
+import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
+import org.apache.cxf.jaxrs.JAXRSServiceFactoryBean;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.model.UserResource;
+import org.apache.cxf.jaxrs.utils.ExceptionUtils;
+import org.apache.cxf.jaxrs.utils.ResourceUtils;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.BeanDefinitionStoreException;
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+
+
+public class JAXRSServerFactoryBeanDefinitionParser extends AbstractBeanDefinitionParser {
+ private static final Logger LOG = LogUtils.getL7dLogger(JAXRSServerFactoryBeanDefinitionParser.class);
+
+ public JAXRSServerFactoryBeanDefinitionParser() {
+ super();
+ setBeanClass(SpringJAXRSServerFactoryBean.class);
+ }
+
+ @Override
+ protected void mapAttribute(BeanDefinitionBuilder bean, Element e, String name, String val) {
+ if ("beanNames".equals(name)) {
+ String[] values = val.split(" ");
+ List<SpringResourceFactory> tempFactories = new ArrayList<>(values.length);
+ for (String v : values) {
+ String theValue = v.trim();
+ if (theValue.length() > 0) {
+ tempFactories.add(new SpringResourceFactory(theValue));
+ }
+ }
+ bean.addPropertyValue("tempResourceProviders", tempFactories);
+ } else if ("serviceName".equals(name)) {
+ QName q = parseQName(e, val);
+ bean.addPropertyValue(name, q);
+ } else if ("basePackages".equals(name)) {
+ bean.addPropertyValue("basePackages", ClasspathScanner.parsePackages(val));
+ } else if ("serviceAnnotation".equals(name)) {
+ bean.addPropertyValue("serviceAnnotation", val);
+ } else if ("publish".equals(name)) {
+ mapToProperty(bean, "start", val);
+ } else {
+ mapToProperty(bean, name, val);
+ }
+ }
+
+ @Override
+ protected void mapElement(ParserContext ctx, BeanDefinitionBuilder bean, Element el, String name) {
+ if ("properties".equals(name)
+ || "extensionMappings".equals(name)
+ || "languageMappings".equals(name)) {
+ Map<?, ?> map = ctx.getDelegate().parseMapElement(el, bean.getBeanDefinition());
+ bean.addPropertyValue(name, map);
+ } else if ("executor".equals(name)) {
+ setFirstChildAsProperty(el, ctx, bean, "serviceFactory.executor");
+ } else if ("invoker".equals(name)) {
+ setFirstChildAsProperty(el, ctx, bean, "serviceFactory.invoker");
+ } else if ("binding".equals(name)) {
+ setFirstChildAsProperty(el, ctx, bean, "bindingConfig");
+ } else if ("inInterceptors".equals(name) || "inFaultInterceptors".equals(name)
+ || "outInterceptors".equals(name) || "outFaultInterceptors".equals(name)) {
+ List<?> list = ctx.getDelegate().parseListElement(el, bean.getBeanDefinition());
+ bean.addPropertyValue(name, list);
+ } else if ("features".equals(name) || "schemaLocations".equals(name)
+ || "providers".equals(name) || "serviceBeans".equals(name)
+ || "modelBeans".equals(name)) {
+ List<?> list = ctx.getDelegate().parseListElement(el, bean.getBeanDefinition());
+ bean.addPropertyValue(name, list);
+ } else if ("serviceFactories".equals(name)) {
+ List<?> list = ctx.getDelegate().parseListElement(el, bean.getBeanDefinition());
+ bean.addPropertyValue("resourceProviders", list);
+ } else if ("model".equals(name)) {
+ List<UserResource> resources = ResourceUtils.getResourcesFromElement(el);
+ bean.addPropertyValue("modelBeans", resources);
+ } else {
+ setFirstChildAsProperty(el, ctx, bean, name);
+ }
+ }
+
+
+ @Override
+ protected void doParse(Element element, ParserContext ctx, BeanDefinitionBuilder bean) {
+ super.doParse(element, ctx, bean);
+
+ bean.setInitMethodName("create");
+ bean.setDestroyMethodName("destroy");
+
+ // We don't really want to delay the registration of our Server
+ bean.setLazyInit(false);
+ }
+
+ @Override
+ protected String resolveId(Element elem,
+ AbstractBeanDefinition definition,
+ ParserContext ctx)
+ throws BeanDefinitionStoreException {
+ String id = super.resolveId(elem, definition, ctx);
+ if (StringUtils.isEmpty(id)) {
+ id = getBeanClass().getName() + "--" + definition.hashCode();
+ }
+
+ return id;
+ }
+
+ @Override
+ protected boolean hasBusProperty() {
+ return true;
+ }
+
+ public static class SpringJAXRSServerFactoryBean extends JAXRSServerFactoryBean implements
+ ApplicationContextAware {
+
+ private List<SpringResourceFactory> tempFactories;
+ private List<String> basePackages;
+ private String serviceAnnotation;
+ private ApplicationContext context;
+ private boolean serviceBeansAvailable;
+ private boolean providerBeansAvailable;
+ private boolean resourceProvidersAvailable;
+
+ public SpringJAXRSServerFactoryBean() {
+ super();
+ }
+
+ public SpringJAXRSServerFactoryBean(JAXRSServiceFactoryBean sf) {
+ super(sf);
+ }
+
+ public void destroy() {
+ Server server = super.getServer();
+ if (server != null && server.isStarted()) {
+ server.destroy();
+ }
+ }
+ @Override
+ public void setServiceBeans(List<Object> beans) {
+ super.setServiceBeans(beans);
+ this.serviceBeansAvailable = true;
+ }
+ @Override
+ public void setProviders(List<? extends Object> beans) {
+ super.setProviders(beans);
+ this.providerBeansAvailable = true;
+ }
+ public void setResourceProviders(List<ResourceProvider> rps) {
+ super.setResourceProviders(rps);
+ this.resourceProvidersAvailable = true;
+ }
+ public void setBasePackages(List<String> basePackages) {
+ this.basePackages = basePackages;
+ }
+
+ public void setServiceAnnotation(String serviceAnnotation) {
+ this.serviceAnnotation = serviceAnnotation;
+ }
+
+ public void setTempResourceProviders(List<SpringResourceFactory> providers) {
+ tempFactories = providers;
+ }
+
+ public void setApplicationContext(ApplicationContext ctx) throws BeansException {
+ this.context = ctx;
+
+ if (tempFactories != null) {
+ List<ResourceProvider> factories = new ArrayList<>(
+ tempFactories.size());
+ for (int i = 0; i < tempFactories.size(); i++) {
+ SpringResourceFactory factory = tempFactories.get(i);
+ factory.setApplicationContext(ctx);
+ factories.add(factory);
+ }
+ tempFactories.clear();
+ setResourceProviders(factories);
+ }
+ Class<? extends Annotation> serviceAnnotationClass = loadServiceAnnotationClass();
+ if (basePackages != null) {
+ try {
+ final Map< Class< ? extends Annotation >, Collection< Class< ? > > > classes =
+ ClasspathScanner.findClasses(basePackages, Provider.class, Path.class);
+
+ this.setServiceBeans(createBeansFromDiscoveredClasses(context,
+ classes.get(Path.class),
+ serviceAnnotationClass));
+ this.setProviders(createBeansFromDiscoveredClasses(context,
+ classes.get(Provider.class),
+ serviceAnnotationClass));
+ } catch (IOException ex) {
+ throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
+ } catch (ClassNotFoundException ex) {
+ throw new BeanCreationException("Failed to create bean from classfile", ex);
+ }
+ } else if (serviceAnnotationClass != null
+ && !serviceBeansAvailable && !providerBeansAvailable && !resourceProvidersAvailable) {
+ discoverContextResources(serviceAnnotationClass);
+ }
+ if (bus == null) {
+ setBus(BusWiringBeanFactoryPostProcessor.addDefaultBus(ctx));
+ }
+ }
+ private void discoverContextResources(Class<? extends Annotation> serviceAnnotationClass) {
+ AbstractSpringComponentScanServer scanServer =
+ new AbstractSpringComponentScanServer(serviceAnnotationClass) { };
+ scanServer.setApplicationContext(context);
+ scanServer.setJaxrsResources(this);
+ }
+ @SuppressWarnings("unchecked")
+ private Class<? extends Annotation> loadServiceAnnotationClass() {
+ if (serviceAnnotation != null) {
+ try {
+ return (Class<? extends Annotation>)ClassLoaderUtils.loadClass(serviceAnnotation, this.getClass());
+ } catch (Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+ return null;
+ }
+ }
+ static List<Object> createBeansFromDiscoveredClasses(ApplicationContext context,
+ Collection<Class<?>> classes,
+ Class<? extends Annotation> serviceClassAnnotation) {
+ AutowireCapableBeanFactory beanFactory = context.getAutowireCapableBeanFactory();
+ final List< Object > providers = new ArrayList<>();
+ for (final Class< ? > clazz: classes) {
+ if (serviceClassAnnotation != null && clazz.getAnnotation(serviceClassAnnotation) == null) {
+ continue;
+ }
+ Object bean;
+ try {
+ bean = beanFactory.createBean(clazz, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
+ } catch (Exception ex) {
+ String stackTrace = ExceptionUtils.getStackTrace(ex);
+ LOG.fine("Autowire failure for a " + clazz.getName() + " bean: " + stackTrace);
+ bean = beanFactory.createBean(clazz);
+ }
+ providers.add(bean);
+ }
+ return providers;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/utils/HttpUtils.java b/transform/src/patch/java/org/apache/cxf/jaxrs/utils/HttpUtils.java
new file mode 100644
index 0000000..aa42382
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/utils/HttpUtils.java
@@ -0,0 +1,704 @@
+/**
+ * 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.cxf.jaxrs.utils;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.Set;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.PathSegment;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriBuilder;
+import javax.ws.rs.ext.RuntimeDelegate;
+import javax.ws.rs.ext.RuntimeDelegate.HeaderDelegate;
+
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.UrlUtils;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.jaxrs.impl.HttpHeadersImpl;
+import org.apache.cxf.jaxrs.impl.HttpServletRequestFilter;
+import org.apache.cxf.jaxrs.impl.HttpServletResponseFilter;
+import org.apache.cxf.jaxrs.impl.MetadataMap;
+import org.apache.cxf.jaxrs.impl.PathSegmentImpl;
+import org.apache.cxf.jaxrs.impl.RuntimeDelegateImpl;
+import org.apache.cxf.jaxrs.model.ParameterType;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.transport.Destination;
+import org.apache.cxf.transport.http.AbstractHTTPDestination;
+import org.apache.cxf.transport.http.Headers;
+import org.apache.cxf.transport.servlet.BaseUrlHelper;
+
+public final class HttpUtils {
+
+ private static final ResourceBundle BUNDLE = BundleUtils.getBundle(HttpUtils.class);
+ private static final Logger LOG = LogUtils.getL7dLogger(HttpUtils.class);
+
+ private static final String REQUEST_PATH_TO_MATCH = "path_to_match";
+ private static final String REQUEST_PATH_TO_MATCH_SLASH = "path_to_match_slash";
+
+ private static final String HTTP_SCHEME = "http";
+ private static final String LOCAL_HOST_IP_ADDRESS = "127.0.0.1";
+ private static final String REPLACE_LOOPBACK_PROPERTY = "replace.loopback.address.with.localhost";
+ private static final String LOCAL_HOST_IP_ADDRESS_SCHEME = "://" + LOCAL_HOST_IP_ADDRESS;
+ private static final String ANY_IP_ADDRESS = "0.0.0.0";
+ private static final String ANY_IP_ADDRESS_SCHEME = "://" + ANY_IP_ADDRESS;
+ private static final int DEFAULT_HTTP_PORT = 80;
+
+ private static final Pattern ENCODE_PATTERN = Pattern.compile("%[0-9a-fA-F][0-9a-fA-F]");
+ private static final String CHARSET_PARAMETER = "charset";
+ private static final String DOUBLE_QUOTE = "\"";
+
+ // there are more of such characters, ex, '*' but '*' is not affected by UrlEncode
+ private static final String PATH_RESERVED_CHARACTERS = "=@/:!$&\'(),;~";
+ private static final String QUERY_RESERVED_CHARACTERS = "?/,";
+
+ private static final Set<String> KNOWN_HTTP_VERBS_WITH_NO_REQUEST_CONTENT =
+ new HashSet<>(Arrays.asList(new String[]{"GET", "HEAD", "OPTIONS", "TRACE"}));
+ private static final Set<String> KNOWN_HTTP_VERBS_WITH_NO_RESPONSE_CONTENT =
+ new HashSet<>(Arrays.asList(new String[]{"HEAD", "OPTIONS"}));
+
+ private HttpUtils() {
+ }
+
+ public static String urlDecode(String value, String enc) {
+ return UrlUtils.urlDecode(value, enc);
+ }
+
+ public static String urlDecode(String value) {
+ return UrlUtils.urlDecode(value);
+ }
+
+ public static String pathDecode(String value) {
+ return UrlUtils.pathDecode(value);
+ }
+
+ private static String componentEncode(String reservedChars, String value) {
+
+ StringBuilder buffer = null;
+ int length = value.length();
+ int startingIndex = 0;
+ for (int i = 0; i < length; i++) {
+ char currentChar = value.charAt(i);
+ if (reservedChars.indexOf(currentChar) != -1) {
+ if (buffer == null) {
+ buffer = new StringBuilder(length + 8);
+ }
+ // If it is going to be an empty string nothing to encode.
+ if (i != startingIndex) {
+ buffer.append(urlEncode(value.substring(startingIndex, i)));
+ }
+ buffer.append(currentChar);
+ startingIndex = i + 1;
+ }
+ }
+
+ if (buffer == null) {
+ return urlEncode(value);
+ }
+ if (startingIndex < length) {
+ buffer.append(urlEncode(value.substring(startingIndex, length)));
+ }
+
+ return buffer.toString();
+ }
+
+ public static String queryEncode(String value) {
+
+ return componentEncode(QUERY_RESERVED_CHARACTERS, value);
+ }
+
+ public static String urlEncode(String value) {
+
+ return urlEncode(value, StandardCharsets.UTF_8.name());
+ }
+
+ public static String urlEncode(String value, String enc) {
+
+ return UrlUtils.urlEncode(value, enc);
+ }
+
+ public static String pathEncode(String value) {
+
+ String result = componentEncode(PATH_RESERVED_CHARACTERS, value);
+ // URLEncoder will encode '+' to %2B but will turn ' ' into '+'
+ // We need to retain '+' and encode ' ' as %20
+ if (result.indexOf('+') != -1) {
+ result = result.replace("+", "%20");
+ }
+ if (result.indexOf("%2B") != -1) {
+ result = result.replace("%2B", "+");
+ }
+
+ return result;
+ }
+
+ public static boolean isPartiallyEncoded(String value) {
+ return ENCODE_PATTERN.matcher(value).find();
+ }
+
+ /**
+ * Encodes partially encoded string. Encode all values but those matching pattern
+ * "percent char followed by two hexadecimal digits".
+ *
+ * @param encoded fully or partially encoded string.
+ * @return fully encoded string
+ */
+ public static String encodePartiallyEncoded(String encoded, boolean query) {
+ if (encoded.length() == 0) {
+ return encoded;
+ }
+ Matcher m = ENCODE_PATTERN.matcher(encoded);
+
+ if (!m.find()) {
+ return query ? HttpUtils.queryEncode(encoded) : HttpUtils.pathEncode(encoded);
+ }
+
+ int length = encoded.length();
+ StringBuilder sb = new StringBuilder(length + 8);
+ int i = 0;
+ do {
+ String before = encoded.substring(i, m.start());
+ sb.append(query ? HttpUtils.queryEncode(before) : HttpUtils.pathEncode(before));
+ sb.append(m.group());
+ i = m.end();
+ } while (m.find());
+ String tail = encoded.substring(i, length);
+ sb.append(query ? HttpUtils.queryEncode(tail) : HttpUtils.pathEncode(tail));
+ return sb.toString();
+ }
+
+ public static SimpleDateFormat getHttpDateFormat() {
+ return Headers.getHttpDateFormat();
+ }
+
+ public static String toHttpDate(Date date) {
+ return Headers.toHttpDate(date);
+ }
+
+ public static RuntimeDelegate getOtherRuntimeDelegate() {
+ try {
+ RuntimeDelegate rd = RuntimeDelegate.getInstance();
+ return rd instanceof RuntimeDelegateImpl ? null : rd;
+ } catch (Throwable t) {
+ return null;
+ }
+ }
+
+ public static HeaderDelegate<Object> getHeaderDelegate(Object o) {
+ return getHeaderDelegate(RuntimeDelegate.getInstance(), o);
+ }
+
+ @SuppressWarnings("unchecked")
+ public static HeaderDelegate<Object> getHeaderDelegate(RuntimeDelegate rd, Object o) {
+ return rd == null ? null : (HeaderDelegate<Object>)rd.createHeaderDelegate(o.getClass());
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <T> MultivaluedMap<String, T> getModifiableStringHeaders(Message m) {
+ MultivaluedMap<String, Object> headers = getModifiableHeaders(m);
+ convertHeaderValuesToString(headers, false);
+ return (MultivaluedMap<String, T>)headers;
+ }
+
+ public static MultivaluedMap<String, Object> getModifiableHeaders(Message m) {
+ Map<String, List<Object>> headers = CastUtils.cast((Map<?, ?>)m.get(Message.PROTOCOL_HEADERS));
+ return new MetadataMap<String, Object>(headers, false, false, true);
+ }
+
+ public static void convertHeaderValuesToString(Map<String, List<Object>> headers, boolean delegateOnly) {
+ if (headers == null) {
+ return;
+ }
+ RuntimeDelegate rd = getOtherRuntimeDelegate();
+ if (rd == null && delegateOnly) {
+ return;
+ }
+ for (Map.Entry<String, List<Object>> entry : headers.entrySet()) {
+ List<Object> values = entry.getValue();
+ for (int i = 0; i < values.size(); i++) {
+ Object value = values.get(i);
+
+ if (value != null && !(value instanceof String)) {
+
+ HeaderDelegate<Object> hd = getHeaderDelegate(rd, value);
+
+ if (hd != null) {
+ value = hd.toString(value);
+ } else if (!delegateOnly) {
+ value = value.toString();
+ }
+
+ try {
+ values.set(i, value);
+ } catch (UnsupportedOperationException ex) {
+ // this may happen if an unmodifiable List was set via Map put
+ List<Object> newList = new ArrayList<>(values);
+ newList.set(i, value);
+ // Won't help if the map is unmodifiable in which case it is a bug anyway
+ headers.put(entry.getKey(), newList);
+ }
+
+ }
+
+ }
+ }
+
+ }
+
+ public static Date getHttpDate(String value) {
+ if (value == null) {
+ return null;
+ }
+ try {
+ return Headers.getHttpDateFormat().parse(value);
+ } catch (ParseException ex) {
+ return null;
+ }
+ }
+
+ public static Locale getLocale(String value) {
+ if (value == null) {
+ return null;
+ }
+ final String language;
+ String locale = null;
+ int index = value.indexOf('-');
+ if (index == 0 || index == value.length() - 1) {
+ throw new IllegalArgumentException("Illegal locale value : " + value);
+ }
+
+ if (index > 0) {
+ language = value.substring(0, index);
+ locale = value.substring(index + 1);
+ } else {
+ language = value;
+ }
+
+ if (locale == null) {
+ return new Locale(language);
+ }
+ return new Locale(language, locale);
+
+ }
+
+ public static int getContentLength(String value) {
+ if (value == null) {
+ return -1;
+ }
+ try {
+ int len = Integer.parseInt(value);
+ return len >= 0 ? len : -1;
+ } catch (Exception ex) {
+ return -1;
+ }
+ }
+
+ public static String getHeaderString(List<String> values) {
+ if (values == null) {
+ return null;
+ }
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < values.size(); i++) {
+ String value = values.get(i);
+ if (StringUtils.isEmpty(value)) {
+ continue;
+ }
+ sb.append(value);
+ if (i + 1 < values.size()) {
+ sb.append(',');
+ }
+ }
+ return sb.toString();
+ }
+
+ public static boolean isDateRelatedHeader(String headerName) {
+ return HttpHeaders.DATE.equalsIgnoreCase(headerName)
+ || HttpHeaders.IF_MODIFIED_SINCE.equalsIgnoreCase(headerName)
+ || HttpHeaders.IF_UNMODIFIED_SINCE.equalsIgnoreCase(headerName)
+ || HttpHeaders.EXPIRES.equalsIgnoreCase(headerName)
+ || HttpHeaders.LAST_MODIFIED.equalsIgnoreCase(headerName);
+ }
+
+ public static boolean isHttpRequest(Message message) {
+ return message.get(AbstractHTTPDestination.HTTP_REQUEST) != null;
+ }
+
+ public static URI toAbsoluteUri(String relativePath, Message message) {
+ String base = BaseUrlHelper.getBaseURL(
+ (HttpServletRequest)message.get(AbstractHTTPDestination.HTTP_REQUEST));
+ return URI.create(base + relativePath);
+ }
+
+ public static URI toAbsoluteUri(URI u, Message message) {
+ HttpServletRequest request =
+ (HttpServletRequest)message.get(AbstractHTTPDestination.HTTP_REQUEST);
+ boolean absolute = u.isAbsolute();
+ StringBuilder uriBuf = new StringBuilder();
+ if (request != null && (!absolute || isLocalHostOrAnyIpAddress(u, uriBuf, message))) {
+ String serverAndPort = request.getServerName();
+ boolean localAddressUsed = false;
+ if (absolute) {
+ if (ANY_IP_ADDRESS.equals(serverAndPort)) {
+ serverAndPort = request.getLocalAddr();
+ localAddressUsed = true;
+ }
+ if (LOCAL_HOST_IP_ADDRESS.equals(serverAndPort)) {
+ serverAndPort = "localhost";
+ localAddressUsed = true;
+ }
+ }
+
+
+ int port = localAddressUsed ? request.getLocalPort() : request.getServerPort();
+ if (port != DEFAULT_HTTP_PORT) {
+ serverAndPort += ":" + port;
+ }
+ String base = request.getScheme() + "://" + serverAndPort;
+ if (!absolute) {
+ u = URI.create(base + u.toString());
+ } else {
+ int originalPort = u.getPort();
+ String hostValue = uriBuf.toString().contains(ANY_IP_ADDRESS_SCHEME)
+ ? ANY_IP_ADDRESS : LOCAL_HOST_IP_ADDRESS;
+ String replaceValue = originalPort == -1 ? hostValue : hostValue + ":" + originalPort;
+ u = URI.create(u.toString().replace(replaceValue, serverAndPort));
+ }
+ }
+ return u;
+ }
+
+ private static boolean isLocalHostOrAnyIpAddress(URI u, StringBuilder uriStringBuffer, Message m) {
+ String uriString = u.toString();
+ boolean result = uriString.contains(LOCAL_HOST_IP_ADDRESS_SCHEME) && replaceLoopBackAddress(m)
+ || uriString.contains(ANY_IP_ADDRESS_SCHEME);
+ uriStringBuffer.append(uriString);
+ return result;
+ }
+
+ private static boolean replaceLoopBackAddress(Message m) {
+ Object prop = m.getContextualProperty(REPLACE_LOOPBACK_PROPERTY);
+ return prop == null || PropertyUtils.isTrue(prop);
+ }
+
+ public static void resetRequestURI(Message m, String requestURI) {
+ m.remove(REQUEST_PATH_TO_MATCH_SLASH);
+ m.remove(REQUEST_PATH_TO_MATCH);
+ m.put(Message.REQUEST_URI, requestURI);
+ }
+
+
+ public static String getPathToMatch(Message m, boolean addSlash) {
+ String var = addSlash ? REQUEST_PATH_TO_MATCH_SLASH : REQUEST_PATH_TO_MATCH;
+ String pathToMatch = (String)m.get(var);
+ if (pathToMatch != null) {
+ return pathToMatch;
+ }
+ String requestAddress = getProtocolHeader(m, Message.REQUEST_URI, "/");
+ if (m.get(Message.QUERY_STRING) == null) {
+ int index = requestAddress.lastIndexOf('?');
+ if (index > 0 && index < requestAddress.length()) {
+ m.put(Message.QUERY_STRING, requestAddress.substring(index + 1));
+ requestAddress = requestAddress.substring(0, index);
+ }
+ }
+ String baseAddress = getBaseAddress(m);
+ pathToMatch = getPathToMatch(requestAddress, baseAddress, addSlash);
+ m.put(var, pathToMatch);
+ return pathToMatch;
+ }
+
+ public static String getProtocolHeader(Message m, String name, String defaultValue) {
+ return getProtocolHeader(m, name, defaultValue, false);
+ }
+
+ public static String getProtocolHeader(Message m, String name, String defaultValue, boolean setOnMessage) {
+ String value = (String)m.get(name);
+ if (value == null) {
+ value = new HttpHeadersImpl(m).getRequestHeaders().getFirst(name);
+ if (value != null && setOnMessage) {
+ m.put(name, value);
+ }
+ }
+ return value == null ? defaultValue : value;
+ }
+
+ public static String getBaseAddress(Message m) {
+ String endpointAddress = getEndpointAddress(m);
+ try {
+ URI uri = new URI(endpointAddress);
+ String path = uri.getRawPath();
+ String scheme = uri.getScheme();
+ if (scheme != null && !scheme.startsWith(HttpUtils.HTTP_SCHEME)
+ && HttpUtils.isHttpRequest(m)) {
+ path = HttpUtils.toAbsoluteUri(path, m).getRawPath();
+ }
+ return (path == null || path.length() == 0) ? "/" : path;
+ } catch (URISyntaxException ex) {
+ return endpointAddress;
+ }
+ }
+
+ public static String getEndpointAddress(Message m) {
+ String address;
+ Destination d = m.getExchange().getDestination();
+ if (d != null) {
+ if (d instanceof AbstractHTTPDestination) {
+ EndpointInfo ei = ((AbstractHTTPDestination)d).getEndpointInfo();
+ HttpServletRequest request = (HttpServletRequest)m.get(AbstractHTTPDestination.HTTP_REQUEST);
+ Object property = request != null
+ ? request.getAttribute("org.apache.cxf.transport.endpoint.address") : null;
+ address = property != null ? property.toString() : ei.getAddress();
+ } else {
+ address = m.containsKey(Message.BASE_PATH)
+ ? (String)m.get(Message.BASE_PATH) : d.getAddress().getAddress().getValue();
+ }
+ } else {
+ address = (String)m.get(Message.ENDPOINT_ADDRESS);
+ }
+ if (address.startsWith("http") && address.endsWith("//")) {
+ address = address.substring(0, address.length() - 1);
+ }
+ return address;
+ }
+
+ public static void updatePath(Message m, String path) {
+ String baseAddress = getBaseAddress(m);
+ boolean pathSlash = path.startsWith("/");
+ boolean baseSlash = baseAddress.endsWith("/");
+ if (pathSlash && baseSlash) {
+ path = path.substring(1);
+ } else if (!pathSlash && !baseSlash) {
+ path = "/" + path;
+ }
+ m.put(Message.REQUEST_URI, baseAddress + path);
+ m.remove(REQUEST_PATH_TO_MATCH);
+ m.remove(REQUEST_PATH_TO_MATCH_SLASH);
+ }
+
+
+ public static String getPathToMatch(String path, String address, boolean addSlash) {
+
+ int ind = path.indexOf(address);
+ if (ind == -1 && address.equals(path + "/")) {
+ path += "/";
+ ind = 0;
+ }
+ if (ind == 0) {
+ path = path.substring(address.length());
+ }
+ if (addSlash && !path.startsWith("/")) {
+ path = "/" + path;
+ }
+
+ return path;
+ }
+
+ public static String getOriginalAddress(Message m) {
+ Destination d = m.getDestination();
+ return d == null ? "/" : d.getAddress().getAddress().getValue();
+ }
+
+ public static String fromPathSegment(PathSegment ps) {
+ if (PathSegmentImpl.class.isAssignableFrom(ps.getClass())) {
+ return ((PathSegmentImpl)ps).getOriginalPath();
+ }
+ StringBuilder sb = new StringBuilder();
+ sb.append(ps.getPath());
+ for (Map.Entry<String, List<String>> entry : ps.getMatrixParameters().entrySet()) {
+ for (String value : entry.getValue()) {
+ sb.append(';').append(entry.getKey());
+ if (value != null) {
+ sb.append('=').append(value);
+ }
+ }
+ }
+ return sb.toString();
+ }
+
+ public static Response.Status getParameterFailureStatus(ParameterType pType) {
+ if (pType == ParameterType.MATRIX || pType == ParameterType.PATH
+ || pType == ParameterType.QUERY) {
+ return Response.Status.NOT_FOUND;
+ }
+ return Response.Status.BAD_REQUEST;
+ }
+
+ public static String getSetEncoding(MediaType mt, MultivaluedMap<String, Object> headers,
+ String defaultEncoding) {
+ String enc = getMediaTypeCharsetParameter(mt);
+ if (enc == null) {
+ return defaultEncoding;
+ }
+ try {
+ "0".getBytes(enc);
+ return enc;
+ } catch (UnsupportedEncodingException ex) {
+ String message = new org.apache.cxf.common.i18n.Message("UNSUPPORTED_ENCODING",
+ BUNDLE, enc, defaultEncoding).toString();
+ LOG.warning(message);
+ headers.putSingle(HttpHeaders.CONTENT_TYPE,
+ JAXRSUtils.mediaTypeToString(mt, CHARSET_PARAMETER)
+ + ';' + CHARSET_PARAMETER + "="
+ + (defaultEncoding == null ? StandardCharsets.UTF_8 : defaultEncoding));
+ }
+ return defaultEncoding;
+ }
+
+ public static String getEncoding(MediaType mt, String defaultEncoding) {
+ String charset = mt == null ? defaultEncoding : getMediaTypeCharsetParameter(mt);
+ return charset == null ? defaultEncoding : charset;
+ }
+
+ public static String getMediaTypeCharsetParameter(MediaType mt) {
+ String charset = mt.getParameters().get(CHARSET_PARAMETER);
+ if (charset != null && charset.startsWith(DOUBLE_QUOTE)
+ && charset.endsWith(DOUBLE_QUOTE) && charset.length() > 1) {
+ charset = charset.substring(1, charset.length() - 1);
+ }
+ return charset;
+ }
+
+ public static URI resolve(UriBuilder baseBuilder, URI uri) {
+ if (!uri.isAbsolute()) {
+ return baseBuilder.build().resolve(uri);
+ }
+ return uri;
+ }
+
+ public static URI relativize(URI base, URI uri) {
+ // quick bail-out
+ if (!(base.isAbsolute()) || !(uri.isAbsolute())) {
+ return uri;
+ }
+ if (base.isOpaque() || uri.isOpaque()) {
+ // Unlikely case of an URN which can't deal with
+ // relative path, such as urn:isbn:0451450523
+ return uri;
+ }
+ // Check for common root
+ URI root = base.resolve("/");
+ if (!(root.equals(uri.resolve("/")))) {
+ // Different protocol/auth/host/port, return as is
+ return uri;
+ }
+
+ // Ignore hostname bits for the following , but add "/" in the beginning
+ // so that in worst case we'll still return "/fred" rather than
+ // "http://example.com/fred".
+ URI baseRel = URI.create("/").resolve(root.relativize(base));
+ URI uriRel = URI.create("/").resolve(root.relativize(uri));
+
+ // Is it same path?
+ if (baseRel.getPath().equals(uriRel.getPath())) {
+ return baseRel.relativize(uriRel);
+ }
+
+ // Direct siblings? (ie. in same folder)
+ URI commonBase = baseRel.resolve("./");
+ if (commonBase.equals(uriRel.resolve("./"))) {
+ return commonBase.relativize(uriRel);
+ }
+
+ // No, then just keep climbing up until we find a common base.
+ URI relative = URI.create("");
+ while (!(uriRel.getPath().startsWith(commonBase.getPath())) && !"/".equals(commonBase.getPath())) {
+ commonBase = commonBase.resolve("../");
+ relative = relative.resolve("../");
+ }
+
+ // Now we can use URI.relativize
+ URI relToCommon = commonBase.relativize(uriRel);
+ // and prepend the needed ../
+ return relative.resolve(relToCommon);
+
+ }
+
+ public static String toHttpLanguage(Locale locale) {
+ return Headers.toHttpLanguage(locale);
+ }
+
+ public static boolean isPayloadEmpty(MultivaluedMap<String, String> headers) {
+ if (headers != null) {
+ String value = headers.getFirst(HttpHeaders.CONTENT_LENGTH);
+ if (value != null) {
+ try {
+ Long len = Long.valueOf(value);
+ return len <= 0;
+ } catch (NumberFormatException ex) {
+ // ignore
+ }
+ }
+ }
+
+ return false;
+ }
+
+ public static <T> T createServletResourceValue(Message m, Class<T> clazz) {
+
+ Object value = null;
+ if (clazz == HttpServletRequest.class) {
+ HttpServletRequest request = (HttpServletRequest)m.get(AbstractHTTPDestination.HTTP_REQUEST);
+ value = request != null ? new HttpServletRequestFilter(request, m) : null;
+ } else if (clazz == HttpServletResponse.class) {
+ HttpServletResponse response = (HttpServletResponse)m.get(AbstractHTTPDestination.HTTP_RESPONSE);
+ value = response != null ? new HttpServletResponseFilter(response, m) : null;
+ } else if (clazz == ServletContext.class) {
+ value = m.get(AbstractHTTPDestination.HTTP_CONTEXT);
+ } else if (clazz == ServletConfig.class) {
+ value = m.get(AbstractHTTPDestination.HTTP_CONFIG);
+ }
+
+ return clazz.cast(value);
+ }
+
+ public static boolean isMethodWithNoRequestContent(String method) {
+ return KNOWN_HTTP_VERBS_WITH_NO_REQUEST_CONTENT.contains(method);
+ }
+
+ public static boolean isMethodWithNoResponseContent(String method) {
+ return KNOWN_HTTP_VERBS_WITH_NO_RESPONSE_CONTENT.contains(method);
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/utils/ResourceUtils.java b/transform/src/patch/java/org/apache/cxf/jaxrs/utils/ResourceUtils.java
new file mode 100644
index 0000000..fb53bd6
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/utils/ResourceUtils.java
@@ -0,0 +1,1044 @@
+/**
+ * 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.cxf.jaxrs.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.ResourceBundle;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.ws.rs.ApplicationPath;
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.CookieParam;
+import javax.ws.rs.Encoded;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.MatrixParam;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.container.AsyncResponse;
+import javax.ws.rs.container.Suspended;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+import javax.xml.namespace.QName;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.feature.Feature;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.helpers.DOMUtils;
+import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
+import org.apache.cxf.jaxrs.ext.DefaultMethod;
+import org.apache.cxf.jaxrs.ext.xml.ElementClass;
+import org.apache.cxf.jaxrs.ext.xml.XMLName;
+import org.apache.cxf.jaxrs.lifecycle.PerRequestResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.ResourceProvider;
+import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;
+import org.apache.cxf.jaxrs.model.ClassResourceInfo;
+import org.apache.cxf.jaxrs.model.MethodDispatcher;
+import org.apache.cxf.jaxrs.model.OperationResourceInfo;
+import org.apache.cxf.jaxrs.model.Parameter;
+import org.apache.cxf.jaxrs.model.ParameterType;
+import org.apache.cxf.jaxrs.model.ResourceTypes;
+import org.apache.cxf.jaxrs.model.URITemplate;
+import org.apache.cxf.jaxrs.model.UserOperation;
+import org.apache.cxf.jaxrs.model.UserResource;
+import org.apache.cxf.jaxrs.provider.JAXBElementProvider;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageImpl;
+import org.apache.cxf.resource.ResourceManager;
+import org.apache.cxf.staxutils.StaxUtils;
+
+public final class ResourceUtils {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(ResourceUtils.class);
+ private static final ResourceBundle BUNDLE = BundleUtils.getBundle(ResourceUtils.class);
+ private static final String CLASSPATH_PREFIX = "classpath:";
+ private static final String NOT_RESOURCE_METHOD_MESSAGE_ID = "NOT_RESOURCE_METHOD";
+ private static final String NOT_SUSPENDED_ASYNC_MESSAGE_ID = "NOT_SUSPENDED_ASYNC_METHOD";
+ private static final String NO_VOID_RETURN_ASYNC_MESSAGE_ID = "NO_VOID_RETURN_ASYNC_METHOD";
+ private static final Set<String> SERVER_PROVIDER_CLASS_NAMES;
+ static {
+ SERVER_PROVIDER_CLASS_NAMES = new HashSet<>();
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.MessageBodyWriter");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.MessageBodyReader");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ExceptionMapper");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ContextResolver");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ReaderInterceptor");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.WriterInterceptor");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.ext.ParamConverterProvider");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.container.ContainerRequestFilter");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.container.ContainerResponseFilter");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.container.DynamicFeature");
+ SERVER_PROVIDER_CLASS_NAMES.add("javax.ws.rs.core.Feature");
+ SERVER_PROVIDER_CLASS_NAMES.add("org.apache.cxf.jaxrs.ext.ContextProvider");
+
+ }
+
+ private ResourceUtils() {
+ }
+
+ private static Method[] getDeclaredMethods(final Class<?> c) {
+ return AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
+ @Override
+ public Method[] run() {
+ return c.getDeclaredMethods();
+ }
+ });
+ }
+ public static Method findPostConstructMethod(Class<?> c) {
+ return findPostConstructMethod(c, null);
+ }
+ public static Method findPostConstructMethod(Class<?> c, String name) {
+ if (Object.class == c || null == c) {
+ return null;
+ }
+ for (Method m : getDeclaredMethods(c)) {
+ if (name != null) {
+ if (m.getName().equals(name)) {
+ return m;
+ }
+ } else if (m.getAnnotation(PostConstruct.class) != null) {
+ return m;
+ }
+ }
+ Method m = findPostConstructMethod(c.getSuperclass(), name);
+ if (m != null) {
+ return m;
+ }
+ for (Class<?> i : c.getInterfaces()) {
+ m = findPostConstructMethod(i, name);
+ if (m != null) {
+ return m;
+ }
+ }
+ return null;
+ }
+
+ public static Method findPreDestroyMethod(Class<?> c) {
+ return findPreDestroyMethod(c, null);
+ }
+
+ public static Method findPreDestroyMethod(Class<?> c, String name) {
+ if (Object.class == c || null == c) {
+ return null;
+ }
+ for (Method m : getDeclaredMethods(c)) {
+ if (name != null) {
+ if (m.getName().equals(name)) {
+ return m;
+ }
+ } else if (m.getAnnotation(PreDestroy.class) != null) {
+ return m;
+ }
+ }
+ Method m = findPreDestroyMethod(c.getSuperclass(), name);
+ if (m != null) {
+ return m;
+ }
+ for (Class<?> i : c.getInterfaces()) {
+ m = findPreDestroyMethod(i, name);
+ if (m != null) {
+ return m;
+ }
+ }
+ return null;
+ }
+
+ public static ClassResourceInfo createClassResourceInfo(
+ Map<String, UserResource> resources, UserResource model,
+ Class<?> defaultClass,
+ boolean isRoot, boolean enableStatic,
+ Bus bus) {
+ final boolean isDefaultClass = defaultClass != null;
+ Class<?> sClass = !isDefaultClass ? loadClass(model.getName()) : defaultClass;
+ return createServiceClassResourceInfo(resources, model, sClass, isRoot, enableStatic, bus);
+ }
+
+ public static ClassResourceInfo createServiceClassResourceInfo(
+ Map<String, UserResource> resources, UserResource model,
+ Class<?> sClass, boolean isRoot, boolean enableStatic, Bus bus) {
+ if (model == null) {
+ throw new RuntimeException("Resource class " + sClass.getName() + " has no model info");
+ }
+ ClassResourceInfo cri =
+ new ClassResourceInfo(sClass, sClass, isRoot, enableStatic, true,
+ model.getConsumes(), model.getProduces(), bus);
+ URITemplate t = URITemplate.createTemplate(model.getPath());
+ cri.setURITemplate(t);
+
+ MethodDispatcher md = new MethodDispatcher();
+ Map<String, UserOperation> ops = model.getOperationsAsMap();
+
+ Method defaultMethod = null;
+ Map<String, Method> methodNames = new HashMap<>();
+ for (Method m : cri.getServiceClass().getMethods()) {
+ if (m.getAnnotation(DefaultMethod.class) != null) {
+ // if needed we can also support multiple default methods
+ defaultMethod = m;
+ }
+ methodNames.put(m.getName(), m);
+ }
+
+ for (Map.Entry<String, UserOperation> entry : ops.entrySet()) {
+ UserOperation op = entry.getValue();
+ Method actualMethod = methodNames.get(op.getName());
+ if (actualMethod == null) {
+ actualMethod = defaultMethod;
+ }
+ if (actualMethod == null) {
+ continue;
+ }
+ OperationResourceInfo ori =
+ new OperationResourceInfo(actualMethod, cri, URITemplate.createTemplate(op.getPath()),
+ op.getVerb(), op.getConsumes(), op.getProduces(),
+ op.getParameters(),
+ op.isOneway());
+ String rClassName = actualMethod.getReturnType().getName();
+ if (op.getVerb() == null) {
+ if (resources.containsKey(rClassName)) {
+ ClassResourceInfo subCri = rClassName.equals(model.getName()) ? cri
+ : createServiceClassResourceInfo(resources, resources.get(rClassName),
+ actualMethod.getReturnType(), false, enableStatic, bus);
+ if (subCri != null) {
+ cri.addSubClassResourceInfo(subCri);
+ md.bind(ori, actualMethod);
+ }
+ }
+ } else {
+ md.bind(ori, actualMethod);
+ }
+ }
+
+ cri.setMethodDispatcher(md);
+ return checkMethodDispatcher(cri) ? cri : null;
+
+ }
+
+ public static ClassResourceInfo createClassResourceInfo(final Class<?> rClass,
+ final Class<?> sClass,
+ boolean root,
+ boolean enableStatic) {
+ return createClassResourceInfo(rClass, sClass, root, enableStatic, BusFactory.getThreadDefaultBus());
+
+ }
+
+ public static ClassResourceInfo createClassResourceInfo(final Class<?> rClass,
+ final Class<?> sClass,
+ boolean root,
+ boolean enableStatic,
+ Bus bus) {
+ return createClassResourceInfo(rClass, sClass, null, root, enableStatic, bus);
+ }
+
+ public static ClassResourceInfo createClassResourceInfo(final Class<?> rClass,
+ final Class<?> sClass,
+ ClassResourceInfo parent,
+ boolean root,
+ boolean enableStatic,
+ Bus bus) {
+ return createClassResourceInfo(rClass, sClass, parent, root, enableStatic, bus, null, null);
+ }
+
+ //CHECKSTYLE:OFF
+ public static ClassResourceInfo createClassResourceInfo(final Class<?> rClass,
+ final Class<?> sClass,
+ ClassResourceInfo parent,
+ boolean root,
+ boolean enableStatic,
+ Bus bus,
+ List<MediaType> defaultConsumes,
+ List<MediaType> defaultProduces) {
+ //CHECKSTYLE:ON
+ ClassResourceInfo cri = new ClassResourceInfo(rClass, sClass, root, enableStatic, bus,
+ defaultConsumes, defaultProduces);
+ cri.setParent(parent);
+
+ if (root) {
+ URITemplate t = URITemplate.createTemplate(cri.getPath());
+ cri.setURITemplate(t);
+ }
+
+ evaluateResourceClass(cri, enableStatic);
+ return checkMethodDispatcher(cri) ? cri : null;
+ }
+
+ private static void evaluateResourceClass(ClassResourceInfo cri, boolean enableStatic) {
+ MethodDispatcher md = new MethodDispatcher();
+ Class<?> serviceClass = cri.getServiceClass();
+
+ final Set<Method> annotatedMethods = new HashSet<>();
+
+ for (Method m : serviceClass.getMethods()) {
+ if (!m.isBridge() && !m.isSynthetic()) {
+ //do real methods first
+ Method annotatedMethod = AnnotationUtils.getAnnotatedMethod(serviceClass, m);
+ if (!annotatedMethods.contains(annotatedMethod)) {
+ evaluateResourceMethod(cri, enableStatic, md, m, annotatedMethod);
+ annotatedMethods.add(annotatedMethod);
+ }
+ }
+ }
+ for (Method m : serviceClass.getMethods()) {
+ if (m.isBridge() || m.isSynthetic()) {
+ //if a bridge/synthetic method isn't already mapped to something, go ahead and do it
+ Method annotatedMethod = AnnotationUtils.getAnnotatedMethod(serviceClass, m);
+ if (!annotatedMethods.contains(annotatedMethod)) {
+ evaluateResourceMethod(cri, enableStatic, md, m, annotatedMethod);
+ annotatedMethods.add(annotatedMethod);
+ }
+ }
+ }
+ cri.setMethodDispatcher(md);
+ }
+
+ private static void evaluateResourceMethod(ClassResourceInfo cri, boolean enableStatic, MethodDispatcher md,
+ Method m, Method annotatedMethod) {
+ String httpMethod = AnnotationUtils.getHttpMethodValue(annotatedMethod);
+ Path path = AnnotationUtils.getMethodAnnotation(annotatedMethod, Path.class);
+
+ if (httpMethod != null || path != null) {
+ if (!checkAsyncResponse(annotatedMethod)) {
+ return;
+ }
+
+ md.bind(createOperationInfo(m, annotatedMethod, cri, path, httpMethod), m);
+ if (httpMethod == null) {
+ // subresource locator
+ Class<?> subClass = m.getReturnType();
+ if (subClass == Class.class) {
+ subClass = InjectionUtils.getActualType(m.getGenericReturnType());
+ }
+ if (enableStatic) {
+ ClassResourceInfo subCri = cri.findResource(subClass, subClass);
+ if (subCri == null) {
+ ClassResourceInfo ancestor = getAncestorWithSameServiceClass(cri, subClass);
+ subCri = ancestor != null ? ancestor
+ : createClassResourceInfo(subClass, subClass, cri, false, enableStatic,
+ cri.getBus());
+ }
+
+ if (subCri != null) {
+ cri.addSubClassResourceInfo(subCri);
+ }
+ }
+ }
+ } else {
+ reportInvalidResourceMethod(m, NOT_RESOURCE_METHOD_MESSAGE_ID, Level.FINE);
+ }
+ }
+
+ private static void reportInvalidResourceMethod(Method m, String messageId, Level logLevel) {
+ if (LOG.isLoggable(logLevel)) {
+ LOG.log(logLevel, new org.apache.cxf.common.i18n.Message(messageId,
+ BUNDLE,
+ m.getDeclaringClass().getName(),
+ m.getName()).toString());
+ }
+ }
+
+ private static boolean checkAsyncResponse(Method m) {
+ Class<?>[] types = m.getParameterTypes();
+ for (int i = 0; i < types.length; i++) {
+ if (types[i] == AsyncResponse.class) {
+ if (AnnotationUtils.getAnnotation(m.getParameterAnnotations()[i], Suspended.class) == null) {
+ reportInvalidResourceMethod(m, NOT_SUSPENDED_ASYNC_MESSAGE_ID, Level.FINE);
+ return false;
+ }
+ if (m.getReturnType() == Void.TYPE || m.getReturnType() == Void.class) {
+ return true;
+ }
+ reportInvalidResourceMethod(m, NO_VOID_RETURN_ASYNC_MESSAGE_ID, Level.WARNING);
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static ClassResourceInfo getAncestorWithSameServiceClass(ClassResourceInfo parent, Class<?> subClass) {
+ if (parent == null) {
+ return null;
+ }
+ if (parent.getServiceClass() == subClass) {
+ return parent;
+ }
+ return getAncestorWithSameServiceClass(parent.getParent(), subClass);
+ }
+
+ public static Constructor<?> findResourceConstructor(Class<?> resourceClass, boolean perRequest) {
+ List<Constructor<?>> cs = new LinkedList<>();
+ for (Constructor<?> c : resourceClass.getConstructors()) {
+ Class<?>[] params = c.getParameterTypes();
+ Annotation[][] anns = c.getParameterAnnotations();
+ boolean match = true;
+ for (int i = 0; i < params.length; i++) {
+ if (!perRequest) {
+ if (AnnotationUtils.getAnnotation(anns[i], Context.class) == null) {
+ match = false;
+ break;
+ }
+ } else if (!AnnotationUtils.isValidParamAnnotations(anns[i])) {
+ match = false;
+ break;
+ }
+ }
+ if (match) {
+ cs.add(c);
+ }
+ }
+ Collections.sort(cs, new Comparator<Constructor<?>>() {
+
+ public int compare(Constructor<?> c1, Constructor<?> c2) {
+ int p1 = c1.getParameterTypes().length;
+ int p2 = c2.getParameterTypes().length;
+ return p1 > p2 ? -1 : p1 < p2 ? 1 : 0;
+ }
+
+ });
+ return cs.isEmpty() ? null : cs.get(0);
+ }
+
+ public static List<Parameter> getParameters(Method resourceMethod) {
+ Annotation[][] paramAnns = resourceMethod.getParameterAnnotations();
+ if (paramAnns.length == 0) {
+ return CastUtils.cast(Collections.emptyList(), Parameter.class);
+ }
+ Class<?>[] types = resourceMethod.getParameterTypes();
+ List<Parameter> params = new ArrayList<>(paramAnns.length);
+ for (int i = 0; i < paramAnns.length; i++) {
+ Parameter p = getParameter(i, paramAnns[i], types[i]);
+ params.add(p);
+ }
+ return params;
+ }
+
+ //CHECKSTYLE:OFF
+ public static Parameter getParameter(int index, Annotation[] anns, Class<?> type) {
+
+ Context ctx = AnnotationUtils.getAnnotation(anns, Context.class);
+ if (ctx != null) {
+ return new Parameter(ParameterType.CONTEXT, index, null);
+ }
+
+ boolean isEncoded = AnnotationUtils.getAnnotation(anns, Encoded.class) != null;
+
+ BeanParam bp = AnnotationUtils.getAnnotation(anns, BeanParam.class);
+ if (bp != null) {
+ return new Parameter(ParameterType.BEAN, index, null, isEncoded, null);
+ }
+
+ String dValue = AnnotationUtils.getDefaultParameterValue(anns);
+
+ PathParam a = AnnotationUtils.getAnnotation(anns, PathParam.class);
+ if (a != null) {
+ return new Parameter(ParameterType.PATH, index, a.value(), isEncoded, dValue);
+ }
+ QueryParam q = AnnotationUtils.getAnnotation(anns, QueryParam.class);
+ if (q != null) {
+ return new Parameter(ParameterType.QUERY, index, q.value(), isEncoded, dValue);
+ }
+ MatrixParam m = AnnotationUtils.getAnnotation(anns, MatrixParam.class);
+ if (m != null) {
+ return new Parameter(ParameterType.MATRIX, index, m.value(), isEncoded, dValue);
+ }
+
+ FormParam f = AnnotationUtils.getAnnotation(anns, FormParam.class);
+ if (f != null) {
+ return new Parameter(ParameterType.FORM, index, f.value(), isEncoded, dValue);
+ }
+
+ HeaderParam h = AnnotationUtils.getAnnotation(anns, HeaderParam.class);
+ if (h != null) {
+ return new Parameter(ParameterType.HEADER, index, h.value(), isEncoded, dValue);
+ }
+
+ CookieParam c = AnnotationUtils.getAnnotation(anns, CookieParam.class);
+ if (c != null) {
+ return new Parameter(ParameterType.COOKIE, index, c.value(), isEncoded, dValue);
+ }
+
+ return new Parameter(ParameterType.REQUEST_BODY, index, null);
+
+ }
+ //CHECKSTYLE:ON
+
+ private static OperationResourceInfo createOperationInfo(Method m, Method annotatedMethod,
+ ClassResourceInfo cri, Path path, String httpMethod) {
+ OperationResourceInfo ori = new OperationResourceInfo(m, annotatedMethod, cri);
+ URITemplate t = URITemplate.createTemplate(path);
+ ori.setURITemplate(t);
+ ori.setHttpMethod(httpMethod);
+ return ori;
+ }
+
+
+ private static boolean checkMethodDispatcher(ClassResourceInfo cr) {
+ if (cr.getMethodDispatcher().getOperationResourceInfos().isEmpty()) {
+ LOG.warning(new org.apache.cxf.common.i18n.Message("NO_RESOURCE_OP_EXC",
+ BUNDLE,
+ cr.getServiceClass().getName()).toString());
+ return false;
+ }
+ return true;
+ }
+
+
+ private static Class<?> loadClass(String cName) {
+ try {
+ return ClassLoaderUtils.loadClass(cName.trim(), ResourceUtils.class);
+ } catch (ClassNotFoundException ex) {
+ throw new RuntimeException("No class " + cName.trim() + " can be found", ex);
+ }
+ }
+
+
+ public static List<UserResource> getUserResources(String loc, Bus bus) {
+ try (InputStream is = ResourceUtils.getResourceStream(loc, bus)) {
+ if (is == null) {
+ return null;
+ }
+ return getUserResources(is);
+ } catch (Exception ex) {
+ LOG.warning("Problem with processing a user model at " + loc);
+ }
+
+ return null;
+ }
+
+ public static InputStream getResourceStream(String loc, Bus bus) throws IOException {
+ URL url = getResourceURL(loc, bus);
+ return url == null ? null : url.openStream();
+ }
+
+ public static URL getResourceURL(String loc, Bus bus) throws IOException {
+ URL url;
+ if (loc.startsWith(CLASSPATH_PREFIX)) {
+ String path = loc.substring(CLASSPATH_PREFIX.length());
+ url = ResourceUtils.getClasspathResourceURL(path, ResourceUtils.class, bus);
+ } else {
+ try {
+ url = new URL(loc);
+ } catch (Exception ex) {
+ // it can be either a classpath or file resource without a scheme
+ url = ResourceUtils.getClasspathResourceURL(loc, ResourceUtils.class, bus);
+ if (url == null) {
+ File file = new File(loc);
+ if (file.exists()) {
+ url = file.toURI().toURL();
+ }
+ }
+ }
+ }
+ if (url == null) {
+ LOG.warning("No resource " + loc + " is available");
+ }
+ return url;
+ }
+
+ public static InputStream getClasspathResourceStream(String path, Class<?> callingClass, Bus bus) {
+ InputStream is = ClassLoaderUtils.getResourceAsStream(path, callingClass);
+ return is == null ? getResource(path, InputStream.class, bus) : is;
+ }
+
+ public static URL getClasspathResourceURL(String path, Class<?> callingClass, Bus bus) {
+ URL url = ClassLoaderUtils.getResource(path, callingClass);
+ return url == null ? getResource(path, URL.class, bus) : url;
+ }
+
+ public static <T> T getResource(String path, Class<T> resourceClass, Bus bus) {
+ if (bus != null) {
+ ResourceManager rm = bus.getExtension(ResourceManager.class);
+ if (rm != null) {
+ return rm.resolveResource(path, resourceClass);
+ }
+ }
+ return null;
+ }
+
+ public static Properties loadProperties(String propertiesLocation, Bus bus) throws IOException {
+ Properties props = new Properties();
+ try (InputStream is = getResourceStream(propertiesLocation, bus)) {
+ props.load(is);
+ }
+ return props;
+ }
+
+ public static List<UserResource> getUserResources(String loc) {
+ return getUserResources(loc, BusFactory.getThreadDefaultBus());
+ }
+
+ public static List<UserResource> getUserResources(InputStream is) throws Exception {
+ Document doc = StaxUtils.read(new InputStreamReader(is, StandardCharsets.UTF_8));
+ return getResourcesFromElement(doc.getDocumentElement());
+ }
+
+ public static List<UserResource> getResourcesFromElement(Element modelEl) {
+ List<UserResource> resources = new ArrayList<>();
+ List<Element> resourceEls =
+ DOMUtils.findAllElementsByTagNameNS(modelEl,
+ "http://cxf.apache.org/jaxrs", "resource");
+ for (Element e : resourceEls) {
+ resources.add(getResourceFromElement(e));
+ }
+ return resources;
+ }
+
+
+ public static ResourceTypes getAllRequestResponseTypes(List<ClassResourceInfo> cris,
+ boolean jaxbOnly) {
+ return getAllRequestResponseTypes(cris, jaxbOnly, null);
+ }
+
+ public static ResourceTypes getAllRequestResponseTypes(List<ClassResourceInfo> cris,
+ boolean jaxbOnly,
+ MessageBodyWriter<?> jaxbWriter) {
+ ResourceTypes types = new ResourceTypes();
+ for (ClassResourceInfo resource : cris) {
+ getAllTypesForResource(resource, types, jaxbOnly, jaxbWriter);
+ }
+ return types;
+ }
+
+ public static Class<?> getActualJaxbType(Class<?> type, Method resourceMethod, boolean inbound) {
+ ElementClass element = resourceMethod.getAnnotation(ElementClass.class);
+ if (element != null) {
+ Class<?> cls = inbound ? element.request() : element.response();
+ if (cls != Object.class) {
+ return cls;
+ }
+ }
+ return type;
+ }
+
+ private static void getAllTypesForResource(ClassResourceInfo resource,
+ ResourceTypes types,
+ boolean jaxbOnly,
+ MessageBodyWriter<?> jaxbWriter) {
+ Class<?> jaxbElement = null;
+ try {
+ jaxbElement = ClassLoaderUtils.loadClass("javax.xml.bind.JAXBElement", ResourceUtils.class);
+ } catch (final ClassNotFoundException e) {
+ // no-op
+ }
+
+ for (OperationResourceInfo ori : resource.getMethodDispatcher().getOperationResourceInfos()) {
+ Method method = ori.getAnnotatedMethod() == null ? ori.getMethodToInvoke() : ori.getAnnotatedMethod();
+ Class<?> realReturnType = method.getReturnType();
+ Class<?> cls = realReturnType;
+ if (cls == Response.class || ori.isAsync()) {
+ cls = getActualJaxbType(cls, method, false);
+ }
+ Type type = method.getGenericReturnType();
+ if (jaxbOnly) {
+ checkJaxbType(resource.getServiceClass(), cls, realReturnType == Response.class || ori.isAsync()
+ ? cls : type, types, method.getAnnotations(), jaxbWriter, jaxbElement);
+ } else {
+ types.getAllTypes().put(cls, type);
+ }
+
+ for (Parameter pm : ori.getParameters()) {
+ if (pm.getType() == ParameterType.REQUEST_BODY) {
+ Class<?> inType = method.getParameterTypes()[pm.getIndex()];
+ if (inType != AsyncResponse.class) {
+ Type paramType = method.getGenericParameterTypes()[pm.getIndex()];
+ if (jaxbOnly) {
+ checkJaxbType(resource.getServiceClass(), inType, paramType, types,
+ method.getParameterAnnotations()[pm.getIndex()], jaxbWriter, jaxbElement);
+ } else {
+ types.getAllTypes().put(inType, paramType);
+ }
+ }
+ }
+ }
+
+ }
+
+ for (ClassResourceInfo sub : resource.getSubResources()) {
+ if (!isRecursiveSubResource(resource, sub)) {
+ getAllTypesForResource(sub, types, jaxbOnly, jaxbWriter);
+ }
+ }
+ }
+
+ private static boolean isRecursiveSubResource(ClassResourceInfo parent, ClassResourceInfo sub) {
+ if (parent == null) {
+ return false;
+ }
+ if (parent == sub) {
+ return true;
+ }
+ return isRecursiveSubResource(parent.getParent(), sub);
+ }
+
+ private static void checkJaxbType(Class<?> serviceClass,
+ Class<?> type,
+ Type genericType,
+ ResourceTypes types,
+ Annotation[] anns,
+ MessageBodyWriter<?> jaxbWriter,
+ Class<?> jaxbElement) {
+ boolean isCollection = false;
+ if (InjectionUtils.isSupportedCollectionOrArray(type)) {
+ type = InjectionUtils.getActualType(genericType);
+ isCollection = true;
+ }
+ if (type == Object.class && !(genericType instanceof Class)
+ || genericType instanceof TypeVariable) {
+ Type theType = InjectionUtils.processGenericTypeIfNeeded(serviceClass,
+ Object.class,
+ genericType);
+ type = InjectionUtils.getActualType(theType);
+ }
+ if (type == null
+ || InjectionUtils.isPrimitive(type)
+ || (jaxbElement != null && jaxbElement.isAssignableFrom(type))
+ || Response.class.isAssignableFrom(type)
+ || type.isInterface()) {
+ return;
+ }
+
+ MessageBodyWriter<?> writer = jaxbWriter;
+ if (writer == null) {
+ JAXBElementProvider<Object> defaultWriter = new JAXBElementProvider<>();
+ defaultWriter.setMarshallAsJaxbElement(true);
+ defaultWriter.setXmlTypeAsJaxbElementOnly(true);
+ writer = defaultWriter;
+ }
+ if (writer.isWriteable(type, type, anns, MediaType.APPLICATION_XML_TYPE)) {
+ types.getAllTypes().put(type, type);
+ Class<?> genCls = InjectionUtils.getActualType(genericType);
+ if (genCls != type && genCls != null && genCls != Object.class
+ && !InjectionUtils.isSupportedCollectionOrArray(genCls)) {
+ types.getAllTypes().put(genCls, genCls);
+ }
+
+ XMLName name = AnnotationUtils.getAnnotation(anns, XMLName.class);
+ QName qname = name != null ? JAXRSUtils.convertStringToQName(name.value()) : null;
+ if (isCollection) {
+ types.getCollectionMap().put(type, qname);
+ } else {
+ types.getXmlNameMap().put(type, qname);
+ }
+ }
+ }
+
+ private static UserResource getResourceFromElement(Element e) {
+ UserResource resource = new UserResource();
+ resource.setName(e.getAttribute("name"));
+ resource.setPath(e.getAttribute("path"));
+ resource.setConsumes(e.getAttribute("consumes"));
+ resource.setProduces(e.getAttribute("produces"));
+ List<Element> operEls =
+ DOMUtils.findAllElementsByTagNameNS(e,
+ "http://cxf.apache.org/jaxrs", "operation");
+ List<UserOperation> opers = new ArrayList<>(operEls.size());
+ for (Element operEl : operEls) {
+ opers.add(getOperationFromElement(operEl));
+ }
+ resource.setOperations(opers);
+ return resource;
+ }
+
+ private static UserOperation getOperationFromElement(Element e) {
+ UserOperation op = new UserOperation();
+ op.setName(e.getAttribute("name"));
+ op.setVerb(e.getAttribute("verb"));
+ op.setPath(e.getAttribute("path"));
+ op.setOneway(Boolean.parseBoolean(e.getAttribute("oneway")));
+ op.setConsumes(e.getAttribute("consumes"));
+ op.setProduces(e.getAttribute("produces"));
+ List<Element> paramEls =
+ DOMUtils.findAllElementsByTagNameNS(e,
+ "http://cxf.apache.org/jaxrs", "param");
+ List<Parameter> params = new ArrayList<>(paramEls.size());
+ for (int i = 0; i < paramEls.size(); i++) {
+ Element paramEl = paramEls.get(i);
+ Parameter p = new Parameter(paramEl.getAttribute("type"), i, paramEl.getAttribute("name"));
+ p.setEncoded(Boolean.valueOf(paramEl.getAttribute("encoded")));
+ p.setDefaultValue(paramEl.getAttribute("defaultValue"));
+ String pClass = paramEl.getAttribute("class");
+ if (!StringUtils.isEmpty(pClass)) {
+ try {
+ p.setJavaType(ClassLoaderUtils.loadClass(pClass, ResourceUtils.class));
+ } catch (Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+ params.add(p);
+ }
+ op.setParameters(params);
+ return op;
+ }
+
+ public static Object[] createConstructorArguments(Constructor<?> c,
+ Message m,
+ boolean perRequest) {
+ return createConstructorArguments(c, m, perRequest, null);
+ }
+
+ public static Object[] createConstructorArguments(Constructor<?> c,
+ Message m,
+ boolean perRequest,
+ Map<Class<?>, Object> contextValues) {
+ Class<?>[] params = c.getParameterTypes();
+ Annotation[][] anns = c.getParameterAnnotations();
+ Type[] genericTypes = c.getGenericParameterTypes();
+ return createConstructorArguments(c, m, perRequest, contextValues, params, anns, genericTypes);
+ }
+
+ public static Object[] createConstructorArguments(Constructor<?> c,
+ Message m,
+ boolean perRequest,
+ Map<Class<?>,
+ Object> contextValues,
+ Class<?>[] params,
+ Annotation[][] anns,
+ Type[] genericTypes) {
+ if (m == null) {
+ m = new MessageImpl();
+ }
+ @SuppressWarnings("unchecked")
+ MultivaluedMap<String, String> templateValues =
+ (MultivaluedMap<String, String>)m.get(URITemplate.TEMPLATE_PARAMETERS);
+ Object[] values = new Object[params.length];
+ for (int i = 0; i < params.length; i++) {
+ if (AnnotationUtils.getAnnotation(anns[i], Context.class) != null) {
+ Object contextValue = contextValues != null ? contextValues.get(params[i]) : null;
+ if (contextValue == null) {
+ if (perRequest || InjectionUtils.VALUE_CONTEXTS.contains(params[i].getName())) {
+ values[i] = JAXRSUtils.createContextValue(m, genericTypes[i], params[i]);
+ } else {
+ values[i] = InjectionUtils.createThreadLocalProxy(params[i]);
+ }
+ } else {
+ values[i] = contextValue;
+ }
+ } else {
+ // this branch won't execute for singletons given that the found constructor
+ // is guaranteed to have only Context parameters, if any, for singletons
+ Parameter p = ResourceUtils.getParameter(i, anns[i], params[i]);
+ values[i] = JAXRSUtils.createHttpParameterValue(
+ p, params[i], genericTypes[i], anns[i], m, templateValues, null);
+ }
+ }
+ return values;
+ }
+
+ @SuppressWarnings("unchecked")
+ public static JAXRSServerFactoryBean createApplication(Application app,
+ boolean ignoreAppPath,
+ boolean staticSubresourceResolution,
+ boolean useSingletonResourceProvider,
+ Bus bus) {
+
+ Set<Object> singletons = app.getSingletons();
+ verifySingletons(singletons);
+
+ List<Class<?>> resourceClasses = new ArrayList<>();
+ List<Object> providers = new ArrayList<>();
+ List<Feature> features = new ArrayList<>();
+ Map<Class<?>, ResourceProvider> map = new HashMap<>();
+
+ // Note, app.getClasses() returns a list of per-request classes
+ // or singleton provider classes
+ for (Class<?> cls : app.getClasses()) {
+ if (isValidApplicationClass(cls, singletons)) {
+ if (isValidProvider(cls)) {
+ providers.add(createProviderInstance(cls));
+ } else if (Feature.class.isAssignableFrom(cls)) {
+ features.add(createFeatureInstance((Class<? extends Feature>) cls));
+ } else {
+ resourceClasses.add(cls);
+ if (useSingletonResourceProvider) {
+ map.put(cls, new SingletonResourceProvider(createProviderInstance(cls)));
+ } else {
+ map.put(cls, new PerRequestResourceProvider(cls));
+ }
+ }
+ }
+ }
+
+ // we can get either a provider or resource class here
+ for (Object o : singletons) {
+ if (isValidProvider(o.getClass())) {
+ providers.add(o);
+ } else if (o instanceof Feature) {
+ features.add((Feature) o);
+ } else {
+ resourceClasses.add(o.getClass());
+ map.put(o.getClass(), new SingletonResourceProvider(o));
+ }
+ }
+
+ JAXRSServerFactoryBean bean = new JAXRSServerFactoryBean();
+ if (bus != null) {
+ bean.setBus(bus);
+ }
+
+ String address = "/";
+ if (!ignoreAppPath) {
+ ApplicationPath appPath = locateApplicationPath(app.getClass());
+ if (appPath != null) {
+ address = appPath.value();
+ }
+ }
+ if (!address.startsWith("/")) {
+ address = "/" + address;
+ }
+ bean.setAddress(address);
+ bean.setStaticSubresourceResolution(staticSubresourceResolution);
+ bean.setResourceClasses(resourceClasses);
+ bean.setProviders(providers);
+ bean.getFeatures().addAll(features);
+ for (Map.Entry<Class<?>, ResourceProvider> entry : map.entrySet()) {
+ bean.setResourceProvider(entry.getKey(), entry.getValue());
+ }
+ Map<String, Object> appProps = app.getProperties();
+ if (appProps != null) {
+ bean.getProperties(true).putAll(appProps);
+ }
+ bean.setApplication(app);
+ return bean;
+ }
+
+ public static Object createProviderInstance(Class<?> cls) {
+ try {
+ Constructor<?> c = ResourceUtils.findResourceConstructor(cls, false);
+ if (c != null && c.getParameterTypes().length == 0) {
+ return c.newInstance();
+ }
+ return c;
+ } catch (Throwable ex) {
+ throw new RuntimeException("Provider " + cls.getName() + " can not be created", ex);
+ }
+ }
+
+ public static Feature createFeatureInstance(Class<? extends Feature> cls) {
+ try {
+ Constructor<?> c = ResourceUtils.findResourceConstructor(cls, false);
+
+ if (c == null) {
+ throw new RuntimeException("No valid constructor found for " + cls.getName());
+ }
+
+ return (Feature) c.newInstance();
+ } catch (Throwable ex) {
+ throw new RuntimeException("Feature " + cls.getName() + " can not be created", ex);
+ }
+ }
+
+ private static boolean isValidProvider(Class<?> c) {
+ if (c == null || c == Object.class) {
+ return false;
+ }
+ if (c.getAnnotation(Provider.class) != null) {
+ return true;
+ }
+ for (Class<?> itf : c.getInterfaces()) {
+ if (SERVER_PROVIDER_CLASS_NAMES.contains(itf.getName())) {
+ return true;
+ }
+ }
+ return isValidProvider(c.getSuperclass());
+ }
+
+ private static void verifySingletons(Set<Object> singletons) {
+ if (singletons.isEmpty()) {
+ return;
+ }
+ Set<String> map = new HashSet<>();
+ for (Object s : singletons) {
+ if (map.contains(s.getClass().getName())) {
+ throw new RuntimeException("More than one instance of the same singleton class "
+ + s.getClass().getName() + " is available");
+ }
+ map.add(s.getClass().getName());
+ }
+ }
+
+ public static boolean isValidResourceClass(Class<?> c) {
+ if (c.isInterface() || Modifier.isAbstract(c.getModifiers())) {
+ LOG.info("Ignoring invalid resource class " + c.getName());
+ return false;
+ }
+ return true;
+ }
+
+ public static ApplicationPath locateApplicationPath(Class<?> appClass) {
+ ApplicationPath appPath = appClass.getAnnotation(ApplicationPath.class);
+ if (appPath == null && appClass.getSuperclass() != Application.class) {
+ return locateApplicationPath(appClass.getSuperclass());
+ }
+ return appPath;
+ }
+
+ private static boolean isValidApplicationClass(Class<?> c, Set<Object> singletons) {
+ if (!isValidResourceClass(c)) {
+ return false;
+ }
+ for (Object s : singletons) {
+ if (c == s.getClass()) {
+ LOG.info("Ignoring per-request resource class " + c.getName()
+ + " as it is also registered as singleton");
+ return false;
+ }
+ }
+ return true;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/message/MessageUtils.java b/transform/src/patch/java/org/apache/cxf/message/MessageUtils.java
new file mode 100644
index 0000000..e7f7523
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/message/MessageUtils.java
@@ -0,0 +1,261 @@
+/**
+ * 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.cxf.message;
+
+import java.lang.reflect.Method;
+import java.net.HttpURLConnection;
+import java.util.Optional;
+import java.util.logging.Logger;
+
+import org.w3c.dom.Node;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.service.invoker.MethodDispatcher;
+import org.apache.cxf.service.model.BindingOperationInfo;
+
+
+/**
+ * Holder for utility methods relating to messages.
+ */
+public final class MessageUtils {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(MessageUtils.class);
+
+ /**
+ * Prevents instantiation.
+ */
+ private MessageUtils() {
+ }
+
+ /**
+ * Determine if message is outbound.
+ *
+ * @param message the current Message
+ * @return true if the message direction is outbound
+ */
+ public static boolean isOutbound(Message message) {
+ if (message == null) {
+ return false;
+ }
+
+ Exchange exchange = message.getExchange();
+ return exchange != null
+ && (message == exchange.getOutMessage() || message == exchange.getOutFaultMessage());
+ }
+
+ /**
+ * Determine if message is fault.
+ *
+ * @param message the current Message
+ * @return true if the message is a fault
+ */
+ public static boolean isFault(Message message) {
+ return message != null
+ && message.getExchange() != null
+ && (message == message.getExchange().getInFaultMessage() || message == message.getExchange()
+ .getOutFaultMessage());
+ }
+
+ /**
+ * Determine the fault mode for the underlying (fault) message
+ * (for use on server side only).
+ *
+ * @param message the fault message
+ * @return the FaultMode
+ */
+ public static FaultMode getFaultMode(Message message) {
+ if (message != null
+ && message.getExchange() != null
+ && message == message.getExchange().getOutFaultMessage()) {
+ FaultMode mode = message.get(FaultMode.class);
+ if (null != mode) {
+ return mode;
+ }
+ return FaultMode.RUNTIME_FAULT;
+ }
+ return null;
+ }
+
+ /**
+ * Determine if current messaging role is that of requestor.
+ *
+ * @param message the current Message
+ * @return true if the current messaging role is that of requestor
+ */
+ public static boolean isRequestor(Message message) {
+ if (message != null) {
+ Boolean requestor = (Boolean) message.get(Message.REQUESTOR_ROLE);
+ return requestor != null && requestor;
+ }
+ return false;
+ }
+
+ /**
+ * Determine if the current message is a partial response.
+ *
+ * @param message the current message
+ * @return true if the current messags is a partial response
+ */
+ public static boolean isPartialResponse(Message message) {
+ return message != null && Boolean.TRUE.equals(message.get(Message.PARTIAL_RESPONSE_MESSAGE));
+ }
+
+ /**
+ * Determines if the current message is an empty partial response, which
+ * is a partial response with an empty content.
+ *
+ * @param message the current message
+ * @return true if the current messags is a partial empty response
+ */
+ public static boolean isEmptyPartialResponse(Message message) {
+ return message != null && Boolean.TRUE.equals(message.get(Message.EMPTY_PARTIAL_RESPONSE_MESSAGE));
+ }
+
+ /**
+ * Returns true if a value is either the String "true" (regardless of case) or Boolean.TRUE.
+ * @param value
+ * @return true if value is either the String "true" or Boolean.TRUE
+ * @deprecated replaced by {@link #PropertyUtils#isTrue(Object)}
+ */
+ @Deprecated
+ public static boolean isTrue(Object value) {
+ return PropertyUtils.isTrue(value);
+ }
+
+ public static boolean getContextualBoolean(Message m, String key) {
+ return getContextualBoolean(m, key, false);
+ }
+ public static boolean getContextualBoolean(Message m, String key, boolean defaultValue) {
+ if (m != null) {
+ Object o = m.getContextualProperty(key);
+ if (o != null) {
+ return PropertyUtils.isTrue(o);
+ }
+ }
+ return defaultValue;
+ }
+
+ public static int getContextualInteger(Message m, String key, int defaultValue) {
+ if (m != null) {
+ Object o = m.getContextualProperty(key);
+ if (o instanceof String) {
+ try {
+ int i = Integer.parseInt((String)o);
+ if (i > 0) {
+ return i;
+ }
+ } catch (NumberFormatException ex) {
+ LOG.warning("Incorrect integer value of " + o + " specified for: " + key);
+ }
+ }
+ }
+ return defaultValue;
+ }
+
+ public static Object getContextualProperty(Message m, String propPreferred, String propDefault) {
+ Object prop = null;
+ if (m != null) {
+ prop = m.getContextualProperty(propPreferred);
+ if (prop == null && propDefault != null) {
+ prop = m.getContextualProperty(propDefault);
+ }
+ }
+ return prop;
+ }
+
+ /**
+ * Returns true if the underlying content format is a W3C DOM or a SAAJ message.
+ */
+ public static boolean isDOMPresent(Message m) {
+ return m != null && m.getContent(Node.class) != null;
+ /*
+ for (Class c : m.getContentFormats()) {
+ if (c.equals(Node.class) || "javax.xml.soap.SOAPMessage".equals(c.getName())) {
+ return true;
+ }
+ }
+ return false;
+ */
+ }
+
+ public static Optional<Method> getTargetMethod(Message m) {
+ Method method;
+ BindingOperationInfo bop = m.getExchange().getBindingOperationInfo();
+ if (bop != null) {
+ MethodDispatcher md = (MethodDispatcher) m.getExchange().getService().get(MethodDispatcher.class.getName());
+ method = md.getMethod(bop);
+ } else {
+ // See please JAXRSInInterceptor#RESOURCE_METHOD for the reference
+ method = (Method) m.get("org.apache.cxf.resource.method");
+ }
+ return Optional.ofNullable(method);
+ }
+
+ /**
+ * Gets the response code from the message and tries to deduct one if it
+ * is not set yet.
+ * @param message message to get response code from
+ * @return response code (or deducted value assuming success)
+ */
+ public static int getReponseCodeFromMessage(Message message) {
+ Integer i = (Integer)message.get(Message.RESPONSE_CODE);
+ if (i != null) {
+ return i.intValue();
+ }
+ int code = hasNoResponseContent(message) ? HttpURLConnection.HTTP_ACCEPTED : HttpURLConnection.HTTP_OK;
+ // put the code in the message so that others can get it
+ message.put(Message.RESPONSE_CODE, code);
+ return code;
+ }
+
+ /**
+ * Determines if the current message has no response content.
+ * The message has no response content if either:
+ * - the request is oneway and the current message is no partial
+ * response or an empty partial response.
+ * - the request is not oneway but the current message is an empty partial
+ * response.
+ * @param message
+ * @return
+ */
+ public static boolean hasNoResponseContent(Message message) {
+ final boolean ow = isOneWay(message);
+ final boolean pr = MessageUtils.isPartialResponse(message);
+ final boolean epr = MessageUtils.isEmptyPartialResponse(message);
+
+ //REVISIT may need to provide an option to choose other behavior?
+ // old behavior not suppressing any responses => ow && !pr
+ // suppress empty responses for oneway calls => ow && (!pr || epr)
+ // suppress additionally empty responses for decoupled twoway calls =>
+ return (ow && !pr) || epr;
+ }
+
+ /**
+ * Checks if the message is oneway or not
+ * @param message the message under consideration
+ * @return true if the message has been marked as oneway
+ */
+ public static boolean isOneWay(Message message) {
+ final Exchange ex = message.getExchange();
+ return ex != null && ex.isOneWay();
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/phase/PhaseChainCache.java b/transform/src/patch/java/org/apache/cxf/phase/PhaseChainCache.java
new file mode 100644
index 0000000..ccd12d2
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/phase/PhaseChainCache.java
@@ -0,0 +1,137 @@
+/**
+ * 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.cxf.phase;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.SortedSet;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.apache.cxf.common.util.ModCountCopyOnWriteArrayList;
+import org.apache.cxf.interceptor.Interceptor;
+import org.apache.cxf.message.Message;
+
+/**
+ * The PhaseChainCache provides default interceptor chains for SOAP requests
+ * and responses, both from the client and web service side. The list of
+ * phases supplied in the get() methods of this class are defined by default
+ * within org.apache.cxf.phase.PhaseManagerImpl. For an example of this class
+ * in use, check the sourcecode of org.apache.cxf.endpoint.ClientImpl.
+ */
+public final class PhaseChainCache {
+ AtomicReference<ChainHolder> lastData = new AtomicReference<>();
+
+ public PhaseInterceptorChain get(SortedSet<Phase> phaseList,
+ List<Interceptor<? extends Message>> p1) {
+ return getChain(lastData, phaseList, p1);
+ }
+
+ public PhaseInterceptorChain get(SortedSet<Phase> phaseList,
+ List<Interceptor<? extends Message>> p1,
+ List<Interceptor<? extends Message>> p2) {
+ return getChain(lastData, phaseList, p1, p2);
+ }
+ public PhaseInterceptorChain get(SortedSet<Phase> phaseList,
+ List<Interceptor<? extends Message>> p1,
+ List<Interceptor<? extends Message>> p2,
+ List<Interceptor<? extends Message>> p3) {
+ return getChain(lastData, phaseList, p1, p2, p3);
+ }
+ public PhaseInterceptorChain get(SortedSet<Phase> phaseList,
+ List<Interceptor<? extends Message>> p1,
+ List<Interceptor<? extends Message>> p2,
+ List<Interceptor<? extends Message>> p3,
+ List<Interceptor<? extends Message>> p4) {
+ return getChain(lastData, phaseList, p1, p2, p3, p4);
+ }
+ public PhaseInterceptorChain get(SortedSet<Phase> phaseList,
+ List<Interceptor<? extends Message>> p1,
+ List<Interceptor<? extends Message>> p2,
+ List<Interceptor<? extends Message>> p3,
+ List<Interceptor<? extends Message>> p4,
+ List<Interceptor<? extends Message>> p5) {
+ return getChain(lastData, phaseList, p1, p2, p3, p4, p5);
+ }
+
+ @SafeVarargs
+ static PhaseInterceptorChain getChain(AtomicReference<ChainHolder> lastData,
+ SortedSet<Phase> phaseList,
+ List<Interceptor<? extends Message>> ... providers) {
+ ChainHolder last = lastData.get();
+
+ if (last == null
+ || !last.matches(providers)) {
+
+ PhaseInterceptorChain chain = new PhaseInterceptorChain(phaseList);
+ List<ModCountCopyOnWriteArrayList<Interceptor<? extends Message>>> copy
+ = new ArrayList<>(providers.length);
+ for (List<Interceptor<? extends Message>> p : providers) {
+ copy.add(new ModCountCopyOnWriteArrayList<>(p));
+ chain.add(p);
+ }
+ last = new ChainHolder(chain, copy);
+ lastData.set(last);
+ }
+
+
+ return last.chain.cloneChain();
+ }
+
+ private static class ChainHolder {
+ List<ModCountCopyOnWriteArrayList<Interceptor<? extends Message>>> lists;
+ PhaseInterceptorChain chain;
+
+ ChainHolder(PhaseInterceptorChain c,
+ List<ModCountCopyOnWriteArrayList<Interceptor<? extends Message>>> l) {
+ lists = l;
+ chain = c;
+ }
+
+ @SafeVarargs
+ final boolean matches(List<Interceptor<? extends Message>> ... providers) {
+ if (lists.size() == providers.length) {
+ for (int x = 0; x < providers.length; x++) {
+ if (lists.get(x).size() != providers[x].size()) {
+ return false;
+ }
+
+ if (providers[x].getClass() == ModCountCopyOnWriteArrayList.class) {
+ if (((ModCountCopyOnWriteArrayList<?>)providers[x]).getModCount()
+ != lists.get(x).getModCount()) {
+ return false;
+ }
+ } else {
+ ListIterator<Interceptor<? extends Message>> i1 = lists.get(x).listIterator();
+ ListIterator<Interceptor<? extends Message>> i2 = providers[x].listIterator();
+
+ while (i1.hasNext()) {
+ if (i1.next() != i2.next()) {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/phase/PhaseInterceptorChain.java b/transform/src/patch/java/org/apache/cxf/phase/PhaseInterceptorChain.java
new file mode 100644
index 0000000..c8a52a8
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/phase/PhaseInterceptorChain.java
@@ -0,0 +1,857 @@
+/**
+ * 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.cxf.phase;
+
+import java.lang.ref.WeakReference;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.continuations.SuspendedInvocationException;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.interceptor.Interceptor;
+import org.apache.cxf.interceptor.InterceptorChain;
+import org.apache.cxf.interceptor.ServiceInvokerInterceptor;
+import org.apache.cxf.logging.FaultListener;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.FaultMode;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+import org.apache.cxf.service.Service;
+import org.apache.cxf.service.model.BindingOperationInfo;
+import org.apache.cxf.service.model.OperationInfo;
+import org.apache.cxf.transport.MessageObserver;
+
+/**
+ * A PhaseInterceptorChain orders Interceptors according to the phase they
+ * participate in and also according to the before & after properties on an
+ * Interceptor.
+ * <p>
+ * A List of phases is supplied to the PhaseInterceptorChain in the constructor.
+ * This class is typically instantiated from the PhaseChainCache class in this
+ * package. Interceptors that are added to the chain are ordered by phase.
+ * Within a phase, interceptors can order themselves. Each PhaseInterceptor
+ * has an ID. PhaseInterceptors can supply a Collection of IDs which they
+ * should run before or after, supplying fine grained ordering.
+ * <p>
+ *
+ */
+public class PhaseInterceptorChain implements InterceptorChain {
+ public static final String PREVIOUS_MESSAGE = PhaseInterceptorChain.class.getName() + ".PREVIOUS_MESSAGE";
+
+ private static final Logger LOG = LogUtils.getL7dLogger(PhaseInterceptorChain.class);
+
+ private static final ThreadLocal<Message> CURRENT_MESSAGE = new ThreadLocal<>();
+
+ private final Map<String, Integer> nameMap;
+ private final Phase[] phases;
+
+ // heads[phase] refers to the first interceptor of the given phase
+ private InterceptorHolder[] heads;
+ // tails[phase] refers to the last interceptor of the given phase
+ private InterceptorHolder[] tails;
+ // hasAfters[phase] indicates that the given phase has already inserted
+ // interceptors that may need to be placed after future to-be-inserted
+ // interceptors. This flag is used to activate ordering of interceptors
+ // when new ones are added to the list for this phase.
+ // Note no hasBefores[] is needed because implementation adds subsequent
+ // interceptors to the end of the list by default.
+ private boolean[] hasAfters;
+
+
+ private State state;
+ private Message pausedMessage;
+ private MessageObserver faultObserver;
+ private PhaseInterceptorIterator iterator;
+ private final boolean isFineLogging;
+
+ // currently one chain for one request/response, use below as signal
+ // to avoid duplicate fault processing on nested calling of
+ // doIntercept(), which will throw same fault multi-times
+ private boolean faultOccurred;
+ private boolean chainReleased;
+
+
+ private PhaseInterceptorChain(PhaseInterceptorChain src) {
+ isFineLogging = LOG.isLoggable(Level.FINE);
+
+ //only used for clone
+ state = State.EXECUTING;
+
+ //immutable, just repoint
+ nameMap = src.nameMap;
+ phases = src.phases;
+
+ int length = phases.length;
+ hasAfters = new boolean[length];
+ System.arraycopy(src.hasAfters, 0, hasAfters, 0, length);
+
+ heads = new InterceptorHolder[length];
+ tails = new InterceptorHolder[length];
+
+ InterceptorHolder last = null;
+ for (int x = 0; x < length; x++) {
+ InterceptorHolder ih = src.heads[x];
+ while (ih != null
+ && ih.phaseIdx == x) {
+ InterceptorHolder ih2 = new InterceptorHolder(ih);
+ ih2.prev = last;
+ if (last != null) {
+ last.next = ih2;
+ }
+ if (heads[x] == null) {
+ heads[x] = ih2;
+ }
+ tails[x] = ih2;
+ last = ih2;
+ ih = ih.next;
+ }
+ }
+ }
+
+ public PhaseInterceptorChain(SortedSet<Phase> ps) {
+ state = State.EXECUTING;
+ isFineLogging = LOG.isLoggable(Level.FINE);
+
+ int numPhases = ps.size();
+ phases = new Phase[numPhases];
+ nameMap = new HashMap<>();
+
+ heads = new InterceptorHolder[numPhases];
+ tails = new InterceptorHolder[numPhases];
+ hasAfters = new boolean[numPhases];
+
+ int idx = 0;
+ for (Phase phase : ps) {
+ phases[idx] = phase;
+ nameMap.put(phase.getName(), idx);
+ ++idx;
+ }
+ }
+
+ public static Message getCurrentMessage() {
+ return CURRENT_MESSAGE.get();
+ }
+
+ public static boolean setCurrentMessage(PhaseInterceptorChain chain, Message m) {
+ if (getCurrentMessage() == m) {
+ return false;
+ }
+ if (chain.iterator.hasPrevious()) {
+ chain.iterator.previous();
+ if (chain.iterator.next() instanceof ServiceInvokerInterceptor) {
+ CURRENT_MESSAGE.set(m);
+ return true;
+ }
+ String error = "Only ServiceInvokerInterceptor can update the current chain message";
+ LOG.warning(error);
+ throw new IllegalStateException(error);
+ }
+ return false;
+
+ }
+
+ public synchronized State getState() {
+ return state;
+ }
+
+ public synchronized void releaseAndAcquireChain() {
+ while (!chainReleased) {
+ try {
+ this.wait();
+ } catch (InterruptedException ex) {
+ // ignore
+ }
+ }
+ chainReleased = false;
+ }
+
+ public synchronized void releaseChain() {
+ this.chainReleased = true;
+ this.notifyAll();
+ }
+
+ public PhaseInterceptorChain cloneChain() {
+ return new PhaseInterceptorChain(this);
+ }
+
+ private void updateIterator() {
+ if (iterator == null) {
+ iterator = new PhaseInterceptorIterator(heads);
+ outputChainToLog(false);
+ }
+ }
+
+ public void add(Collection<Interceptor<? extends Message>> newhandlers) {
+ add(newhandlers, false);
+ }
+
+ public void add(Collection<Interceptor<? extends Message>> newhandlers, boolean force) {
+ if (newhandlers == null) {
+ return;
+ }
+
+ for (Interceptor<? extends Message> handler : newhandlers) {
+ add(handler, force);
+ }
+ }
+
+ public void add(Interceptor<? extends Message> i) {
+ add(i, false);
+ }
+
+ public void add(Interceptor<? extends Message> i, boolean force) {
+ PhaseInterceptor<? extends Message> pi = (PhaseInterceptor<? extends Message>)i;
+
+ String phaseName = pi.getPhase();
+ Integer phase = nameMap.get(phaseName);
+
+ if (phase == null) {
+ LOG.warning("Skipping interceptor " + i.getClass().getName()
+ + ((phaseName == null) ? ": Phase declaration is missing."
+ : ": Phase " + phaseName + " specified does not exist."));
+ } else {
+ if (isFineLogging) {
+ LOG.fine("Adding interceptor " + i + " to phase " + phaseName);
+ }
+
+ insertInterceptor(phase, pi, force);
+ }
+ Collection<PhaseInterceptor<? extends Message>> extras
+ = pi.getAdditionalInterceptors();
+ if (extras != null) {
+ for (PhaseInterceptor<? extends Message> p : extras) {
+ add(p, force);
+ }
+ }
+ }
+
+ public synchronized void pause() {
+ state = State.PAUSED;
+ pausedMessage = CURRENT_MESSAGE.get();
+ }
+ public synchronized void unpause() {
+ if (state == State.PAUSED || state == State.SUSPENDED) {
+ state = State.EXECUTING;
+ pausedMessage = null;
+ }
+ }
+
+ public synchronized void suspend() {
+ state = State.SUSPENDED;
+ pausedMessage = CURRENT_MESSAGE.get();
+ }
+
+ public synchronized void resume() {
+ if (state == State.PAUSED || state == State.SUSPENDED) {
+ state = State.EXECUTING;
+ Message m = pausedMessage;
+ pausedMessage = null;
+ doIntercept(m);
+ }
+ }
+
+ /**
+ * Intercept a message, invoking each phase's handlers in turn.
+ *
+ * @param message the message
+ * @throws Exception
+ */
+ @SuppressWarnings("unchecked")
+ public synchronized boolean doIntercept(Message message) {
+ updateIterator();
+
+ Message oldMessage = CURRENT_MESSAGE.get();
+ try {
+ CURRENT_MESSAGE.set(message);
+ if (oldMessage != null
+ && !message.containsKey(PREVIOUS_MESSAGE)
+ && message != oldMessage
+ && message.getExchange() != oldMessage.getExchange()) {
+ message.put(PREVIOUS_MESSAGE, new WeakReference<Message>(oldMessage));
+ }
+ while (state == State.EXECUTING && iterator.hasNext()) {
+ try {
+ Interceptor<Message> currentInterceptor = (Interceptor<Message>)iterator.next();
+ if (isFineLogging) {
+ LOG.fine("Invoking handleMessage on interceptor " + currentInterceptor);
+ }
+ //System.out.println("-----------" + currentInterceptor);
+ currentInterceptor.handleMessage(message);
+ if (state == State.SUSPENDED) {
+ // throw the exception to make sure thread exit without interrupt
+ throw new SuspendedInvocationException();
+ }
+
+ } catch (SuspendedInvocationException ex) {
+
+ // Moving the chain iterator to the previous interceptor is needed
+ // for the invocation to be resumed from the same interceptor which
+ // suspended the invocation.
+ // If "suspend.chain.on.current.interceptor" is set to true then
+ // the chain will be resumed from the interceptor which follows
+ // the interceptor which suspended the invocation.
+ Object suspendProp = message.remove("suspend.chain.on.current.interceptor");
+ if ((suspendProp == null || PropertyUtils.isFalse(suspendProp))
+ && iterator.hasPrevious()) {
+ iterator.previous();
+ }
+ pause();
+ throw ex;
+ } catch (RuntimeException ex) {
+ if (!faultOccurred) {
+ faultOccurred = true;
+ wrapExceptionAsFault(message, ex);
+ }
+ state = State.ABORTED;
+ }
+ }
+ if (state == State.EXECUTING) {
+ state = State.COMPLETE;
+ }
+ return state == State.COMPLETE;
+ } finally {
+ CURRENT_MESSAGE.set(oldMessage);
+ }
+ }
+
+ private void wrapExceptionAsFault(Message message, RuntimeException ex) {
+ String description = getServiceInfo(message);
+
+ message.setContent(Exception.class, ex);
+ unwind(message);
+ Exception ex2 = message.getContent(Exception.class);
+ if (ex2 == null) {
+ ex2 = ex;
+ }
+
+ FaultListener flogger = (FaultListener)
+ message.getContextualProperty(FaultListener.class.getName());
+ boolean useDefaultLogging = true;
+ if (flogger != null) {
+ useDefaultLogging = flogger.faultOccurred(ex2, description, message);
+ }
+ if (useDefaultLogging) {
+ doDefaultLogging(message, ex2, description);
+ }
+
+ if (message.getExchange() != null && message.getContent(Exception.class) != null) {
+ message.getExchange().put(Exception.class, ex2);
+ }
+
+ if (faultObserver != null && !isOneWay(message)) {
+ // CXF-5629. when exchange is one way and robust, it becomes req-resp in order to
+ // send the fault
+ message.getExchange().setOneWay(false);
+ faultObserver.onMessage(message);
+ }
+ }
+
+ private String getServiceInfo(Message message) {
+ StringBuilder description = new StringBuilder();
+ if (message.getExchange() != null) {
+ Exchange exchange = message.getExchange();
+ Service service = exchange.getService();
+ if (service != null) {
+ description.append('\'');
+ description.append(service.getName());
+ BindingOperationInfo boi = exchange.getBindingOperationInfo();
+ OperationInfo opInfo = boi != null ? boi.getOperationInfo() : null;
+ if (opInfo != null) {
+ description.append('#').append(opInfo.getName());
+ }
+ description.append("\' ");
+ }
+ }
+ return description.toString();
+ }
+
+ private void doDefaultLogging(Message message, Exception ex, String description) {
+ FaultMode mode = message.get(FaultMode.class);
+ if (mode == FaultMode.CHECKED_APPLICATION_FAULT) {
+ if (isFineLogging) {
+ LogUtils.log(LOG, Level.FINE,
+ "Application " + description
+ + "has thrown exception, unwinding now", ex);
+ } else if (LOG.isLoggable(Level.INFO)) {
+ Throwable t = ex;
+ if (ex instanceof Fault
+ && ex.getCause() != null) {
+ t = ex.getCause();
+ }
+
+ LogUtils.log(LOG, Level.INFO,
+ "Application " + description
+ + "has thrown exception, unwinding now: "
+ + t.getClass().getName()
+ + ": " + ex.getMessage());
+ }
+ } else if (LOG.isLoggable(Level.WARNING)) {
+ if (mode == FaultMode.UNCHECKED_APPLICATION_FAULT) {
+ LogUtils.log(LOG, Level.WARNING,
+ "Application " + description
+ + "has thrown exception, unwinding now", ex);
+ } else {
+ LogUtils.log(LOG, Level.WARNING,
+ "Interceptor for " + description
+ + "has thrown exception, unwinding now", ex);
+ }
+ }
+ }
+
+ private boolean isOneWay(Message message) {
+ return (message.getExchange() != null) && message.getExchange().isOneWay() && !isRobustOneWay(message);
+ }
+
+ private boolean isRobustOneWay(Message message) {
+ return MessageUtils.getContextualBoolean(message, Message.ROBUST_ONEWAY, false);
+ }
+
+ /**
+ * Intercept a message, invoking each phase's handlers in turn,
+ * starting after the specified interceptor.
+ *
+ * @param message the message
+ * @param startingAfterInterceptorID the id of the interceptor
+ * @throws Exception
+ */
+ public synchronized boolean doInterceptStartingAfter(Message message,
+ String startingAfterInterceptorID) {
+ updateIterator();
+ while (state == State.EXECUTING && iterator.hasNext()) {
+ PhaseInterceptor<? extends Message> currentInterceptor
+ = (PhaseInterceptor<? extends Message>)iterator.next();
+ if (currentInterceptor.getId().equals(startingAfterInterceptorID)) {
+ break;
+ }
+ }
+ return doIntercept(message);
+ }
+
+ /**
+ * Intercept a message, invoking each phase's handlers in turn,
+ * starting at the specified interceptor.
+ *
+ * @param message the message
+ * @param startingAtInterceptorID the id of the interceptor
+ * @throws Exception
+ */
+ public synchronized boolean doInterceptStartingAt(Message message,
+ String startingAtInterceptorID) {
+ updateIterator();
+ while (state == State.EXECUTING && iterator.hasNext()) {
+ PhaseInterceptor<? extends Message> currentInterceptor
+ = (PhaseInterceptor<? extends Message>)iterator.next();
+ if (currentInterceptor.getId().equals(startingAtInterceptorID)) {
+ iterator.previous();
+ break;
+ }
+ }
+ return doIntercept(message);
+ }
+
+ public synchronized void reset() {
+ updateIterator();
+ if (state == State.COMPLETE) {
+ state = State.EXECUTING;
+ iterator.reset();
+ } else {
+ iterator.reset();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public void unwind(Message message) {
+ while (iterator.hasPrevious()) {
+ Interceptor<Message> currentInterceptor = (Interceptor<Message>)iterator.previous();
+ if (isFineLogging) {
+ LOG.fine("Invoking handleFault on interceptor " + currentInterceptor);
+ }
+ try {
+ currentInterceptor.handleFault(message);
+ } catch (RuntimeException e) {
+ LOG.log(Level.WARNING, "Exception in handleFault on interceptor " + currentInterceptor, e);
+ throw e;
+ } catch (Exception e) {
+ LOG.log(Level.WARNING, "Exception in handleFault on interceptor " + currentInterceptor, e);
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ public void remove(Interceptor<? extends Message> i) {
+ PhaseInterceptorIterator it = new PhaseInterceptorIterator(heads);
+ while (it.hasNext()) {
+ InterceptorHolder holder = it.nextInterceptorHolder();
+ if (holder.interceptor == i) {
+ remove(holder);
+ return;
+ }
+ }
+ }
+
+ public synchronized void abort() {
+ this.state = InterceptorChain.State.ABORTED;
+ }
+
+ public Iterator<Interceptor<? extends Message>> iterator() {
+ return getIterator();
+ }
+ public ListIterator<Interceptor<? extends Message>> getIterator() {
+ return new PhaseInterceptorIterator(heads);
+ }
+
+ private void remove(InterceptorHolder i) {
+ if (i.prev != null) {
+ i.prev.next = i.next;
+ }
+ if (i.next != null) {
+ i.next.prev = i.prev;
+ }
+ int ph = i.phaseIdx;
+ if (heads[ph] == i) {
+ if (i.next != null
+ && i.next.phaseIdx == ph) {
+ heads[ph] = i.next;
+ } else {
+ heads[ph] = null;
+ tails[ph] = null;
+ }
+ }
+ if (tails[ph] == i) {
+ if (i.prev != null
+ && i.prev.phaseIdx == ph) {
+ tails[ph] = i.prev;
+ } else {
+ heads[ph] = null;
+ tails[ph] = null;
+ }
+ }
+ }
+
+ private void insertInterceptor(int phase, PhaseInterceptor<? extends Message> interc, boolean force) {
+ InterceptorHolder ih = new InterceptorHolder(interc, phase);
+ if (heads[phase] == null) {
+ // no interceptors yet in this phase
+ heads[phase] = ih;
+ tails[phase] = ih;
+ hasAfters[phase] = !interc.getAfter().isEmpty();
+
+ int idx = phase - 1;
+ while (idx >= 0) {
+ if (tails[idx] != null) {
+ break;
+ }
+ --idx;
+ }
+ if (idx >= 0) {
+ //found something before us, in an earlier phase
+ ih.prev = tails[idx];
+ ih.next = tails[idx].next;
+ if (ih.next != null) {
+ ih.next.prev = ih;
+ }
+ tails[idx].next = ih;
+ } else {
+ //did not find something before us, try after
+ idx = phase + 1;
+ while (idx < heads.length) {
+ if (heads[idx] != null) {
+ break;
+ }
+ ++idx;
+ }
+
+ if (idx != heads.length) {
+ //found something after us
+ ih.next = heads[idx];
+ heads[idx].prev = ih;
+ }
+ }
+ } else { // this phase already has interceptors attached
+
+ // list of interceptors that the new interceptor should precede
+ Set<String> beforeList = interc.getBefore();
+
+ // list of interceptors that the new interceptor should be after
+ Set<String> afterList = interc.getAfter();
+
+ // firstBefore will hold the first interceptor of a given phase
+ // that the interceptor to be added must precede
+ InterceptorHolder firstBefore = null;
+
+ // lastAfter will hold the last interceptor of a given phase
+ // that the interceptor to be added must come after
+ InterceptorHolder lastAfter = null;
+
+ String id = interc.getId();
+ if (hasAfters[phase] || !beforeList.isEmpty()) {
+
+ InterceptorHolder ih2 = heads[phase];
+ while (ih2 != tails[phase].next) {
+ PhaseInterceptor<? extends Message> cmp = ih2.interceptor;
+ String cmpId = cmp.getId();
+ if (cmpId != null && firstBefore == null
+ && (beforeList.contains(cmpId)
+ || cmp.getAfter().contains(id))) {
+ firstBefore = ih2;
+ }
+ if (cmp.getBefore().contains(id)
+ || (cmpId != null && afterList.contains(cmpId))) {
+ lastAfter = ih2;
+ }
+ if (!force && cmpId.equals(id)) {
+ // interceptor is already in chain
+ return;
+ }
+ ih2 = ih2.next;
+ }
+ if (lastAfter == null && beforeList.contains("*")) {
+ firstBefore = heads[phase];
+ }
+
+ } else if (!force) {
+ // skip interceptor if already in chain
+ InterceptorHolder ih2 = heads[phase];
+ while (ih2 != tails[phase].next) {
+ if (ih2.interceptor.getId().equals(id)) {
+ return;
+ }
+ ih2 = ih2.next;
+ }
+
+ }
+ hasAfters[phase] |= !afterList.isEmpty();
+
+ if (firstBefore == null
+ && lastAfter == null
+ && !beforeList.isEmpty()
+ && afterList.isEmpty()) {
+ //if this interceptor has stuff it MUST be before,
+ //but nothing it must be after, just
+ //stick it at the beginning
+ firstBefore = heads[phase];
+ }
+
+ if (firstBefore == null) {
+ //just add new interceptor at the end
+ ih.prev = tails[phase];
+ ih.next = tails[phase].next;
+ tails[phase].next = ih;
+
+ if (ih.next != null) {
+ ih.next.prev = ih;
+ }
+ tails[phase] = ih;
+ } else {
+ ih.prev = firstBefore.prev;
+ if (ih.prev != null) {
+ ih.prev.next = ih;
+ }
+ ih.next = firstBefore;
+ firstBefore.prev = ih;
+
+ if (heads[phase] == firstBefore) {
+ heads[phase] = ih;
+ }
+ }
+ }
+ if (iterator != null) {
+ outputChainToLog(true);
+ }
+ }
+
+ public String toString() {
+ return toString("");
+ }
+ private String toString(String message) {
+ StringBuilder chain = new StringBuilder(128);
+
+ chain.append("Chain ")
+ .append(super.toString())
+ .append(message)
+ .append(". Current flow:\n");
+
+ for (int x = 0; x < phases.length; x++) {
+ if (heads[x] != null) {
+ chain.append(" ");
+ printPhase(x, chain);
+ }
+ }
+ return chain.toString();
+ }
+ private void printPhase(int ph, StringBuilder chain) {
+
+ chain.append(phases[ph].getName())
+ .append(" [");
+ InterceptorHolder i = heads[ph];
+ boolean first = true;
+ while (i != tails[ph].next) {
+ if (first) {
+ first = false;
+ } else {
+ chain.append(", ");
+ }
+ String nm = i.interceptor.getClass().getSimpleName();
+ if (StringUtils.isEmpty(nm)) {
+ nm = i.interceptor.getId();
+ }
+ chain.append(nm);
+ i = i.next;
+ }
+ chain.append("]\n");
+ }
+
+ private void outputChainToLog(boolean modified) {
+ if (isFineLogging) {
+ if (modified) {
+ LOG.fine(toString(" was modified"));
+ } else {
+ LOG.fine(toString(" was created"));
+ }
+ }
+ }
+
+ public MessageObserver getFaultObserver() {
+ return faultObserver;
+ }
+
+ public void setFaultObserver(MessageObserver faultObserver) {
+ this.faultObserver = faultObserver;
+ }
+
+ static final class PhaseInterceptorIterator implements ListIterator<Interceptor<? extends Message>> {
+ InterceptorHolder[] heads;
+ InterceptorHolder prev;
+ InterceptorHolder first;
+
+ PhaseInterceptorIterator(InterceptorHolder[] h) {
+ heads = h;
+ first = findFirst();
+ }
+
+ public void reset() {
+ prev = null;
+ first = findFirst();
+ }
+
+ private InterceptorHolder findFirst() {
+ for (int x = 0; x < heads.length; x++) {
+ if (heads[x] != null) {
+ return heads[x];
+ }
+ }
+ return null;
+ }
+
+
+ public boolean hasNext() {
+ if (prev == null) {
+ return first != null;
+ }
+ return prev.next != null;
+ }
+
+ public Interceptor<? extends Message> next() {
+ if (prev == null) {
+ if (first == null) {
+ throw new NoSuchElementException();
+ }
+ prev = first;
+ } else {
+ if (prev.next == null) {
+ throw new NoSuchElementException();
+ }
+ prev = prev.next;
+ }
+ return prev.interceptor;
+ }
+ public InterceptorHolder nextInterceptorHolder() {
+ if (prev == null) {
+ if (first == null) {
+ throw new NoSuchElementException();
+ }
+ prev = first;
+ } else {
+ if (prev.next == null) {
+ throw new NoSuchElementException();
+ }
+ prev = prev.next;
+ }
+ return prev;
+ }
+
+ public boolean hasPrevious() {
+ return prev != null;
+ }
+ public Interceptor<? extends Message> previous() {
+ if (prev == null) {
+ throw new NoSuchElementException();
+ }
+ InterceptorHolder tmp = prev;
+ prev = prev.prev;
+ return tmp.interceptor;
+ }
+
+ public int nextIndex() {
+ throw new UnsupportedOperationException();
+ }
+ public int previousIndex() {
+ throw new UnsupportedOperationException();
+ }
+ public void add(Interceptor<? extends Message> o) {
+ throw new UnsupportedOperationException();
+ }
+ public void set(Interceptor<? extends Message> o) {
+ throw new UnsupportedOperationException();
+ }
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ }
+
+
+ static final class InterceptorHolder {
+ PhaseInterceptor<? extends Message> interceptor;
+ InterceptorHolder next;
+ InterceptorHolder prev;
+ int phaseIdx;
+
+ InterceptorHolder(PhaseInterceptor<? extends Message> i, int p) {
+ interceptor = i;
+ phaseIdx = p;
+ }
+ InterceptorHolder(InterceptorHolder p) {
+ interceptor = p.interceptor;
+ phaseIdx = p.phaseIdx;
+ }
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/service/factory/FactoryBeanListener.java b/transform/src/patch/java/org/apache/cxf/service/factory/FactoryBeanListener.java
new file mode 100644
index 0000000..687f211
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/service/factory/FactoryBeanListener.java
@@ -0,0 +1,145 @@
+/**
+ * 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.cxf.service.factory;
+
+/**
+ *
+ */
+public interface FactoryBeanListener {
+ enum Event {
+ /**
+ * Event fired at the very start of processing. No parameters. Useful
+ * for setting up any state the listener may need to maintain.
+ */
+ START_CREATE,
+
+ /**
+ * Event fired at the very end of processing. One parameter is passed
+ * in which is the Service object that was created.
+ */
+ END_CREATE,
+
+ /**
+ * Called at the start of processing when it detects that the service
+ * is to be created based on a wsdl contract. One String parameter
+ * of the URL of the wsdl.
+ */
+ CREATE_FROM_WSDL,
+
+ /**
+ * Called at the start of processing when it detects that the service
+ * is to be created based on a Java class. One Class<?> parameter
+ * of the class that is being analyzed.
+ */
+ CREATE_FROM_CLASS,
+
+ /**
+ * Called after the wsdl is loaded/parsed. Single parameter of the
+ * WSS4J Definition of the WSDL.
+ */
+ WSDL_LOADED,
+
+ /**
+ * Called after the Service is set into the Factory after which the getService()
+ * call will return a valid value. One parameter of the Service object.
+ */
+ SERVICE_SET,
+
+
+ /**
+ * OperationInfo, Method
+ */
+ INTERFACE_OPERATION_BOUND,
+
+ /**
+ * OperationInfo, Method, MessageInfo
+ */
+ OPERATIONINFO_IN_MESSAGE_SET,
+ OPERATIONINFO_OUT_MESSAGE_SET,
+
+ /**
+ * OperationInfo, Class<? extends Throwable>, FaultInfo
+ */
+ OPERATIONINFO_FAULT,
+
+ /**
+ * InterfaceInfo, Class<?>
+ */
+ INTERFACE_CREATED,
+
+ /**
+ * DataBinding
+ */
+ DATABINDING_INITIALIZED,
+
+ /**
+ * EndpointInfo, Endpoint, Class
+ */
+ ENDPOINT_CREATED,
+
+ /**
+ * Server, targetObject, Class
+ */
+ PRE_SERVER_CREATE,
+
+ /**
+ * Server, targetObject, Class
+ */
+ SERVER_CREATED,
+
+ /**
+ * BindingInfo, BindingOperationInfo, Implementation Method
+ */
+ BINDING_OPERATION_CREATED,
+
+ /**
+ * BindingInfo
+ */
+ BINDING_CREATED,
+
+ /**
+ * Endpoint
+ */
+ PRE_CLIENT_CREATE,
+
+ /**
+ * Endpoint, Client
+ */
+ CLIENT_CREATED,
+
+ /**
+ * EndpointInfo, Endpoint, SEI Class, Class
+ */
+ ENDPOINT_SELECTED,
+
+ /**
+ * EndpointInfo
+ */
+ ENDPOINTINFO_CREATED,
+
+ /**
+ * Class[], InvokationHandler, Proxy
+ */
+ PROXY_CREATED,
+ }
+
+
+ void handleEvent(Event ev, AbstractServiceFactoryBean factory, Object ... args);
+}
diff --git a/transform/src/patch/java/org/apache/cxf/service/invoker/FactoryInvoker.java b/transform/src/patch/java/org/apache/cxf/service/invoker/FactoryInvoker.java
new file mode 100644
index 0000000..465046b
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/service/invoker/FactoryInvoker.java
@@ -0,0 +1,70 @@
+/**
+ * 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.cxf.service.invoker;
+
+import java.util.ResourceBundle;
+
+import org.apache.cxf.common.i18n.BundleUtils;
+import org.apache.cxf.common.i18n.Message;
+import org.apache.cxf.interceptor.Fault;
+import org.apache.cxf.message.Exchange;
+
+/**
+ * This invoker implementation calls a Factory to create the service object.
+ *
+ */
+public class FactoryInvoker extends AbstractInvoker {
+ static final ResourceBundle BUNDLE = BundleUtils.getBundle(FactoryInvoker.class);
+
+ protected Factory factory;
+
+ /**
+ * Create a FactoryInvoker object.
+ *
+ * @param factory the factory used to create service object.
+ */
+ public FactoryInvoker(Factory factory) {
+ this.factory = factory;
+ }
+ public FactoryInvoker() {
+ }
+ public void setFactory(Factory f) {
+ this.factory = f;
+ }
+
+ public Object getServiceObject(Exchange ex) {
+ try {
+ return factory.create(ex);
+ } catch (Fault e) {
+ throw e;
+ } catch (Throwable e) {
+ throw new Fault(new Message("CREATE_SERVICE_OBJECT_EXC", BUNDLE), e);
+ }
+ }
+
+ @Override
+ public void releaseServiceObject(final Exchange ex, Object obj) {
+ factory.release(ex, obj);
+ }
+
+ public boolean isSingletonFactory() {
+ return factory instanceof SingletonFactory;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/service/model/AbstractPropertiesHolder.java b/transform/src/patch/java/org/apache/cxf/service/model/AbstractPropertiesHolder.java
new file mode 100644
index 0000000..d80e02d
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/service/model/AbstractPropertiesHolder.java
@@ -0,0 +1,271 @@
+/**
+ * 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.cxf.service.model;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.xml.namespace.QName;
+
+public abstract class AbstractPropertiesHolder implements Extensible {
+ private AbstractPropertiesHolder delegate;
+ private boolean delegateProperties;
+
+ private AtomicReference<Map<String, Object>> propertyMap = new AtomicReference<>();
+ private AtomicReference<Object[]> extensors = new AtomicReference<>();
+ private Map<QName, Object> extensionAttributes;
+ private String documentation;
+
+
+ public final void setDelegate(AbstractPropertiesHolder p, boolean props) {
+ delegate = p;
+ delegateProperties = props;
+ if (delegate == null) {
+ return;
+ }
+ if (documentation != null) {
+ delegate.setDocumentation(documentation);
+ documentation = null;
+ }
+ if (extensionAttributes != null) {
+ delegate.setExtensionAttributes(extensionAttributes);
+ extensionAttributes = null;
+ }
+ if (extensors.get() != null) {
+ for (Object el : extensors.get()) {
+ delegate.addExtensor(el);
+ }
+ extensors.set(null);
+ }
+ if (delegateProperties && propertyMap.get() != null) {
+ for (Map.Entry<String, Object> p2 : propertyMap.get().entrySet()) {
+ delegate.setProperty(p2.getKey(), p2.getValue());
+ }
+ propertyMap.set(null);
+ }
+ }
+
+ public String getDocumentation() {
+ if (delegate != null) {
+ return delegate.getDocumentation();
+ }
+ return documentation;
+ }
+ public void setDocumentation(String s) {
+ if (delegate != null) {
+ delegate.setDocumentation(s);
+ } else {
+ documentation = s;
+ }
+ }
+ public Map<String, Object> getProperties() {
+ if (delegate != null && delegateProperties) {
+ return delegate.getProperties();
+ }
+ return propertyMap.get();
+ }
+ public Object getProperty(String name) {
+ if (delegate != null && delegateProperties) {
+ return delegate.getProperty(name);
+ }
+ if (null == propertyMap.get()) {
+ return null;
+ }
+ return propertyMap.get().get(name);
+ }
+ public Object removeProperty(String name) {
+ if (delegate != null && delegateProperties) {
+ delegate.removeProperty(name);
+ }
+ if (null == propertyMap.get()) {
+ return null;
+ }
+ return propertyMap.get().remove(name);
+ }
+
+ public <T> T getProperty(String name, Class<T> cls) {
+ return cls.cast(getProperty(name));
+ }
+ public boolean hasProperty(String name) {
+ if (delegate != null && delegateProperties) {
+ return delegate.hasProperty(name);
+ }
+ Map<String, Object> map = propertyMap.get();
+ if (map != null) {
+ return map.containsKey(name);
+ }
+ return false;
+ }
+
+ public void setProperty(String name, Object v) {
+ if (delegate != null && delegateProperties) {
+ delegate.setProperty(name, v);
+ return;
+ }
+ if (null == propertyMap.get()) {
+ propertyMap.compareAndSet(null, new ConcurrentHashMap<>(4, 0.75f, 2));
+ }
+ if (v == null) {
+ propertyMap.get().remove(name);
+ } else {
+ propertyMap.get().put(name, v);
+ }
+ }
+
+ public boolean containsExtensor(Object el) {
+ if (delegate != null) {
+ return delegate.containsExtensor(el);
+ }
+
+ Object[] exts = extensors.get();
+ if (exts != null) {
+ for (Object o : exts) {
+ if (o == el) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ public void addExtensor(Object el) {
+ if (delegate != null) {
+ delegate.addExtensor(el);
+ return;
+ }
+ Object[] exts = extensors.get();
+ Object[] exts2;
+ if (exts == null) {
+ exts2 = new Object[1];
+ } else {
+ exts2 = new Object[exts.length + 1];
+ System.arraycopy(exts, 0, exts2, 0, exts.length);
+ }
+ exts2[exts2.length - 1] = el;
+ if (!extensors.compareAndSet(exts, exts2)) {
+ //keep trying
+ addExtensor(el);
+ }
+ }
+
+ public <T> T getExtensor(Class<T> cls) {
+ if (delegate != null) {
+ return delegate.getExtensor(cls);
+ }
+ Object[] exts = extensors.get();
+ if (exts == null) {
+ return null;
+ }
+ for (int x = 0; x < exts.length; x++) {
+ if (cls.isInstance(exts[x])) {
+ return cls.cast(exts[x]);
+ }
+ }
+ return null;
+ }
+ public <T> List<T> getExtensors(Class<T> cls) {
+ if (delegate != null) {
+ return delegate.getExtensors(cls);
+ }
+
+ Object[] exts = extensors.get();
+ if (exts == null) {
+ return null;
+ }
+ List<T> list = new ArrayList<>(exts.length);
+ for (int x = 0; x < exts.length; x++) {
+ if (cls.isInstance(exts[x])) {
+ list.add(cls.cast(exts[x]));
+ }
+ }
+ return list;
+ }
+
+ public AtomicReference<Object[]> getExtensors() {
+ if (delegate != null) {
+ return delegate.getExtensors();
+ }
+ return extensors;
+ }
+
+
+ public Object getExtensionAttribute(QName name) {
+ if (delegate != null) {
+ return delegate.getExtensionAttribute(name);
+ }
+ return null == extensionAttributes ? null : extensionAttributes.get(name);
+ }
+
+ public Map<QName, Object> getExtensionAttributes() {
+ if (delegate != null) {
+ return delegate.getExtensionAttributes();
+ }
+ return extensionAttributes;
+ }
+
+ public void addExtensionAttribute(QName name, Object attr) {
+ if (delegate != null) {
+ delegate.addExtensionAttribute(name, attr);
+ return;
+ }
+ if (null == extensionAttributes) {
+ extensionAttributes = new HashMap<>();
+ }
+ extensionAttributes.put(name, attr);
+ }
+
+ public void setExtensionAttributes(Map<QName, Object> attrs) {
+ if (delegate != null) {
+ delegate.setExtensionAttributes(attrs);
+ return;
+ }
+ extensionAttributes = attrs;
+ }
+
+ /**
+ * Lookup a configuration value. This may be found in the properties holder supplied
+ * (i.e. an EndpointInfo or ServiceInfo), or it may be a property on the Bus itself.
+ * If no value is found, the defaultValue is returned.
+ *
+ * @param defaultValue the default value
+ * @param type the extensor type
+ * @return the configuration value or the default
+ */
+ public <T> T getTraversedExtensor(T defaultValue, Class<T> type) {
+ if (delegate != null) {
+ return delegate.getTraversedExtensor(defaultValue, type);
+ }
+ T extensor = getExtensor(type);
+ if (extensor == null) {
+ return defaultValue;
+ }
+ return extensor;
+ }
+
+
+ protected static final boolean equals(Object o1, Object o2) {
+ return Objects.equals(o1, o2);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/service/model/FaultInfo.java b/transform/src/patch/java/org/apache/cxf/service/model/FaultInfo.java
new file mode 100644
index 0000000..f2f240f
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/service/model/FaultInfo.java
@@ -0,0 +1,61 @@
+/**
+ * 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.cxf.service.model;
+
+import javax.xml.namespace.QName;
+
+public class FaultInfo extends AbstractMessageContainer {
+ private QName faultName;
+
+ public FaultInfo(QName fname, QName mname, OperationInfo info) {
+ super(info, mname);
+ faultName = fname;
+ }
+
+ public QName getFaultName() {
+ return faultName;
+ }
+ public void setFaultName(QName fname) {
+ faultName = fname;
+ }
+
+
+
+ @Override
+ public int hashCode() {
+ return faultName == null ? -1 : faultName.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == this) {
+ return true;
+ }
+
+ if (!(o instanceof FaultInfo)) {
+ return false;
+ }
+ FaultInfo oi = (FaultInfo)o;
+ return equals(faultName, oi.faultName)
+ && super.equals(o);
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/service/model/InterfaceInfo.java b/transform/src/patch/java/org/apache/cxf/service/model/InterfaceInfo.java
new file mode 100644
index 0000000..a5c3f26
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/service/model/InterfaceInfo.java
@@ -0,0 +1,124 @@
+/**
+ * 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.cxf.service.model;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.common.i18n.Message;
+import org.apache.cxf.common.logging.LogUtils;
+
+public class InterfaceInfo extends AbstractDescriptionElement implements NamedItem {
+ private static final Logger LOG = LogUtils.getL7dLogger(InterfaceInfo.class);
+
+ QName name;
+ ServiceInfo service;
+
+ Map<QName, OperationInfo> operations = new ConcurrentHashMap<>(4, 0.75f, 2);
+
+ public InterfaceInfo(ServiceInfo info, QName q) {
+ name = q;
+ service = info;
+ info.setInterface(this);
+ }
+ public DescriptionInfo getDescription() {
+ if (service == null) {
+ return null;
+ }
+ return service.getDescription();
+ }
+
+ public ServiceInfo getService() {
+ return service;
+ }
+
+ public void setName(QName n) {
+ name = n;
+ }
+ public QName getName() {
+ return name;
+ }
+
+
+ /**
+ * Adds an operation to this service.
+ *
+ * @param oname the qualified name of the operation.
+ * @return the operation.
+ */
+ public OperationInfo addOperation(QName oname) {
+ if (oname == null) {
+ throw new NullPointerException(
+ new Message("OPERATION.NAME.NOT.NULL", LOG).toString());
+ }
+ if (operations.containsKey(oname)) {
+ throw new IllegalArgumentException(
+ new Message("DUPLICATED.OPERATION.NAME", LOG, oname).toString());
+ }
+
+ OperationInfo operation = new OperationInfo(this, oname);
+ addOperation(operation);
+ return operation;
+ }
+
+ /**
+ * Adds an operation to this service.
+ *
+ * @param operation the operation.
+ */
+ void addOperation(OperationInfo operation) {
+ operations.put(operation.getName(), operation);
+ }
+
+ /**
+ * Removes an operation from this service.
+ *
+ * @param operation the operation.
+ */
+ public void removeOperation(OperationInfo operation) {
+ operations.remove(operation.getName());
+ }
+
+ /**
+ * Returns the operation info with the given name, if found.
+ *
+ * @param oname the name.
+ * @return the operation; or <code>null</code> if not found.
+ */
+ public OperationInfo getOperation(QName oname) {
+ return operations.get(oname);
+ }
+
+ /**
+ * Returns all operations for this service.
+ *
+ * @return all operations.
+ */
+ public Collection<OperationInfo> getOperations() {
+ return Collections.unmodifiableCollection(operations.values());
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/service/model/OperationInfo.java b/transform/src/patch/java/org/apache/cxf/service/model/OperationInfo.java
new file mode 100644
index 0000000..d5fe4d3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/service/model/OperationInfo.java
@@ -0,0 +1,242 @@
+/**
+ * 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.cxf.service.model;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.common.i18n.Message;
+import org.apache.cxf.common.logging.LogUtils;
+
+public class OperationInfo extends AbstractPropertiesHolder implements NamedItem {
+ private static final Logger LOG = LogUtils.getL7dLogger(OperationInfo.class);
+ InterfaceInfo intf;
+ QName opName;
+ String inName;
+ MessageInfo inputMessage;
+ String outName;
+ MessageInfo outputMessage;
+ Map<QName, FaultInfo> faults;
+ OperationInfo unwrappedOperation;
+ List<String> parameterOrdering;
+
+ public OperationInfo() {
+ }
+
+ OperationInfo(InterfaceInfo it, QName n) {
+ intf = it;
+ setName(n);
+ }
+ OperationInfo(OperationInfo op) {
+ intf = op.getInterface();
+ setName(op.getName());
+ }
+
+ /**
+ * Returns the name of the Operation.
+ * @return the name of the Operation
+ */
+ public QName getName() {
+ return opName;
+ }
+ /**
+ * Sets the name of the operation.
+ * @param name the new name of the operation
+ */
+ public final void setName(QName name) {
+ if (name == null) {
+ throw new NullPointerException("Operation Name cannot be null.");
+ }
+ opName = name;
+ }
+ public InterfaceInfo getInterface() {
+ return intf;
+ }
+
+
+ public MessageInfo createMessage(QName nm, MessageInfo.Type type) {
+ return new MessageInfo(this, type, nm);
+ }
+
+ public MessageInfo getOutput() {
+ return outputMessage;
+ }
+ public String getOutputName() {
+ return outName;
+ }
+ public void setOutput(String nm, MessageInfo out) {
+ outName = nm;
+ outputMessage = out;
+ if (unwrappedOperation != null && unwrappedOperation.getOutput() != null) {
+ unwrappedOperation.getOutput().setDelegate(out, false);
+ }
+ }
+ public boolean hasOutput() {
+ return outputMessage != null;
+ }
+
+ public MessageInfo getInput() {
+ return inputMessage;
+ }
+ public String getInputName() {
+ return inName;
+ }
+ public void setInput(String nm, MessageInfo in) {
+ inName = nm;
+ inputMessage = in;
+ if (unwrappedOperation != null && unwrappedOperation.getInput() != null) {
+ unwrappedOperation.getInput().setDelegate(in, false);
+ }
+ }
+ public boolean hasInput() {
+ return inputMessage != null;
+ }
+
+ public boolean isOneWay() {
+ return inputMessage != null && outputMessage == null;
+ }
+
+ public boolean isUnwrappedCapable() {
+ return unwrappedOperation != null;
+ }
+
+ public OperationInfo getUnwrappedOperation() {
+ return unwrappedOperation;
+ }
+ public void setUnwrappedOperation(OperationInfo op) {
+ unwrappedOperation = op;
+ }
+ public boolean isUnwrapped() {
+ return false;
+ }
+
+
+ /**
+ * Adds an fault to this operation.
+ *
+ * @param name the fault name.
+ */
+ public FaultInfo addFault(QName name, QName message) {
+ if (name == null) {
+ throw new NullPointerException(new Message("FAULT.NAME.NOT.NULL", LOG).toString());
+ }
+ if (faults != null && faults.containsKey(name)) {
+ throw new IllegalArgumentException(
+ new Message("DUPLICATED.FAULT.NAME", LOG, name).toString());
+ }
+ FaultInfo fault = new FaultInfo(name, message, this);
+ addFault(fault);
+ return fault;
+ }
+
+ /**
+ * Adds a fault to this operation.
+ *
+ * @param fault the fault.
+ */
+ public synchronized void addFault(FaultInfo fault) {
+ if (faults == null) {
+ faults = new ConcurrentHashMap<>(4, 0.75f, 2);
+ }
+ faults.put(fault.getFaultName(), fault);
+ }
+
+ /**
+ * Removes a fault from this operation.
+ *
+ * @param name the qualified fault name.
+ */
+ public void removeFault(QName name) {
+ if (faults != null) {
+ faults.remove(name);
+ }
+ }
+
+ /**
+ * Returns the fault with the given name, if found.
+ *
+ * @param name the name.
+ * @return the fault; or <code>null</code> if not found.
+ */
+ public FaultInfo getFault(QName name) {
+ if (faults != null) {
+ return faults.get(name);
+ }
+ return null;
+ }
+
+ public boolean hasFaults() {
+ return faults != null && !faults.isEmpty();
+ }
+
+ /**
+ * Returns all faults for this operation.
+ *
+ * @return all faults.
+ */
+ public Collection<FaultInfo> getFaults() {
+ if (faults == null) {
+ return Collections.emptyList();
+ }
+ return Collections.unmodifiableCollection(faults.values());
+ }
+
+ public void setParameterOrdering(List<String> o) {
+ this.parameterOrdering = o;
+ }
+
+ public List<String> getParameterOrdering() {
+ return parameterOrdering;
+ }
+
+ @Override
+ public String toString() {
+ return new StringBuilder("[OperationInfo: ")
+ .append(opName)
+ .append(']').toString();
+ }
+
+ public int hashCode() {
+ return opName == null ? -1 : opName.hashCode();
+ }
+
+ public boolean equals(Object o) {
+ if (o == this) {
+ return true;
+ }
+
+ if (!(o instanceof OperationInfo)) {
+ return false;
+ }
+ OperationInfo oi = (OperationInfo)o;
+ return equals(opName, oi.opName)
+ && equals(inputMessage, oi.inputMessage)
+ && equals(outputMessage, oi.outputMessage)
+ && equals(faults, oi.faults)
+ && equals(intf.getName(), oi.intf.getName());
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/service/model/UnwrappedOperationInfo.java b/transform/src/patch/java/org/apache/cxf/service/model/UnwrappedOperationInfo.java
new file mode 100644
index 0000000..31ed72c
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/service/model/UnwrappedOperationInfo.java
@@ -0,0 +1,72 @@
+/**
+ * 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.cxf.service.model;
+
+import java.util.Collection;
+
+import javax.xml.namespace.QName;
+
+public class UnwrappedOperationInfo extends OperationInfo {
+ OperationInfo wrappedOp;
+
+ public UnwrappedOperationInfo(OperationInfo op) {
+ super(op);
+ wrappedOp = op;
+ setDelegate(wrappedOp, true);
+ }
+
+ public OperationInfo getWrappedOperation() {
+ return wrappedOp;
+ }
+
+ @Override
+ public boolean isUnwrapped() {
+ return true;
+ }
+
+ @Override
+ public FaultInfo addFault(QName name, QName message) {
+ return wrappedOp.addFault(name, message);
+ }
+
+ @Override
+ public FaultInfo getFault(QName name) {
+ return wrappedOp.getFault(name);
+ }
+
+ @Override
+ public Collection<FaultInfo> getFaults() {
+ return wrappedOp.getFaults();
+ }
+
+
+ @Override
+ public void setOutput(String nm, MessageInfo out) {
+ super.setOutput(nm, out);
+ out.setDelegate(wrappedOp.getOutput(), false);
+ }
+
+ @Override
+ public void setInput(String nm, MessageInfo in) {
+ super.setInput(nm, in);
+ in.setDelegate(wrappedOp.getInput(), false);
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/staxutils/StaxUtils.java b/transform/src/patch/java/org/apache/cxf/staxutils/StaxUtils.java
new file mode 100644
index 0000000..440968c
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/staxutils/StaxUtils.java
@@ -0,0 +1,2222 @@
+/**
+ * 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.cxf.staxutils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.Location;
+import javax.xml.stream.StreamFilter;
+import javax.xml.stream.XMLEventFactory;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLResolver;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.stream.events.Attribute;
+import javax.xml.stream.events.Characters;
+import javax.xml.stream.events.DTD;
+import javax.xml.stream.events.Namespace;
+import javax.xml.stream.events.StartDocument;
+import javax.xml.stream.events.StartElement;
+import javax.xml.stream.events.XMLEvent;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.sax.SAXSource;
+import javax.xml.transform.stax.StAXSource;
+import javax.xml.transform.stream.StreamSource;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.CDATASection;
+import org.w3c.dom.Comment;
+import org.w3c.dom.Document;
+import org.w3c.dom.DocumentFragment;
+import org.w3c.dom.DocumentType;
+import org.w3c.dom.Element;
+import org.w3c.dom.EntityReference;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.ProcessingInstruction;
+import org.w3c.dom.Text;
+import org.w3c.dom.UserDataHandler;
+
+import org.xml.sax.InputSource;
+import org.xml.sax.XMLReader;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.PropertyUtils;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.SystemPropertyAction;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.helpers.DOMUtils;
+import org.apache.cxf.message.Message;
+
+public final class StaxUtils {
+ // System properties for defaults, but also contextual properties usable
+ // for StaxInInterceptor
+ public static final String MAX_CHILD_ELEMENTS =
+ "org.apache.cxf.stax.maxChildElements";
+ public static final String MAX_ELEMENT_DEPTH =
+ "org.apache.cxf.stax.maxElementDepth";
+ public static final String MAX_ATTRIBUTE_COUNT =
+ "org.apache.cxf.stax.maxAttributeCount";
+ public static final String MAX_ATTRIBUTE_SIZE =
+ "org.apache.cxf.stax.maxAttributeSize";
+ public static final String MAX_TEXT_LENGTH =
+ "org.apache.cxf.stax.maxTextLength";
+ public static final String MIN_TEXT_SEGMENT =
+ "org.apache.cxf.stax.minTextSegment";
+ public static final String MAX_ELEMENT_COUNT =
+ "org.apache.cxf.stax.maxElementCount";
+ public static final String MAX_XML_CHARACTERS =
+ "org.apache.cxf.stax.maxXMLCharacters";
+
+ public static final String ALLOW_INSECURE_PARSER =
+ "org.apache.cxf.stax.allowInsecureParser";
+
+ private static final String INNER_ELEMENT_COUNT_SYSTEM_PROP =
+ "org.apache.cxf.staxutils.innerElementCountThreshold";
+ private static final String INNER_ELEMENT_LEVEL_SYSTEM_PROP =
+ "org.apache.cxf.staxutils.innerElementLevelThreshold";
+ private static final String AUTO_CLOSE_INPUT_SOURCE_PROP =
+ "org.apache.cxf.staxutils.autoCloseInputSource";
+
+ private static final Logger LOG = LogUtils.getL7dLogger(StaxUtils.class);
+
+ private static final Queue<XMLInputFactory> NS_AWARE_INPUT_FACTORY_POOL;
+ private static final XMLInputFactory SAFE_INPUT_FACTORY;
+ private static final Queue<XMLOutputFactory> OUTPUT_FACTORY_POOL;
+ private static final XMLOutputFactory SAFE_OUTPUT_FACTORY;
+
+ private static final String XML_NS = "http://www.w3.org/2000/xmlns/";
+ private static final String[] DEF_PREFIXES = new String[] {
+ "ns1".intern(), "ns2".intern(), "ns3".intern(),
+ "ns4".intern(), "ns5".intern(), "ns6".intern(),
+ "ns7".intern(), "ns8".intern(), "ns9".intern()
+ };
+
+ private static final int MAX_ATTR_COUNT_VAL =
+ getInteger(MAX_ATTRIBUTE_COUNT, 500);
+ private static final int MAX_ATTR_SIZE_VAL =
+ getInteger(MAX_ATTRIBUTE_SIZE, 64 * 1024); //64K per attribute, likely just "list" will hit
+ private static final int MAX_TEXT_LENGTH_VAL =
+ getInteger(MAX_TEXT_LENGTH, 128 * 1024 * 1024); //128M - more than this should DEFINITELY use MTOM
+ private static final int MIN_TEXT_SEGMENT_VAL =
+ getInteger(MIN_TEXT_SEGMENT, 64); // Same default as woodstox
+ private static final long MAX_ELEMENT_COUNT_VAL =
+ getLong(MAX_ELEMENT_COUNT, Long.MAX_VALUE);
+ private static final long MAX_XML_CHARS_VAL =
+ getLong(MAX_XML_CHARACTERS, Long.MAX_VALUE);
+ private static final int PARSER_POOL_SIZE_VAL =
+ getInteger("org.apache.cxf.staxutils.pool-size", 20);
+ private static final boolean ALLOW_INSECURE_PARSER_VAL;
+ private static final boolean AUTO_CLOSE_INPUT_SOURCE;
+
+ // Here we check old names first and then new names for the threshold properties
+ private static final int MAX_ELEMENT_DEPTH_VAL =
+ getInteger(MAX_ELEMENT_DEPTH, getInteger(INNER_ELEMENT_LEVEL_SYSTEM_PROP, 100));
+ private static final int MAX_CHILD_ELEMENTS_VAL =
+ getInteger(MAX_CHILD_ELEMENTS, getInteger(INNER_ELEMENT_COUNT_SYSTEM_PROP, 50000));
+
+ // Variables from Woodstox
+ private static final String P_MAX_ATTRIBUTES_PER_ELEMENT = "com.ctc.wstx.maxAttributesPerElement";
+ private static final String P_MAX_ATTRIBUTE_SIZE = "com.ctc.wstx.maxAttributeSize";
+ private static final String P_MAX_TEXT_LENGTH = "com.ctc.wstx.maxTextLength";
+ private static final String P_MAX_ELEMENT_COUNT = "com.ctc.wstx.maxElementCount";
+ private static final String P_MAX_CHARACTERS = "com.ctc.wstx.maxCharacters";
+ private static final String P_MAX_ELEMENT_DEPTH = "com.ctc.wstx.maxElementDepth";
+ private static final String P_MAX_CHILDREN_PER_ELEMENT = "com.ctc.wstx.maxChildrenPerElement";
+ private static final String P_MIN_TEXT_SEGMENT = "com.ctc.wstx.minTextSegment";
+
+
+ static {
+ NS_AWARE_INPUT_FACTORY_POOL = new ArrayBlockingQueue<>(PARSER_POOL_SIZE_VAL);
+ OUTPUT_FACTORY_POOL = new ArrayBlockingQueue<>(PARSER_POOL_SIZE_VAL);
+
+ String allowInsecureParser = SystemPropertyAction.getPropertyOrNull(ALLOW_INSECURE_PARSER);
+ if (!StringUtils.isEmpty(allowInsecureParser)) {
+ ALLOW_INSECURE_PARSER_VAL = "1".equals(allowInsecureParser) || Boolean.parseBoolean(allowInsecureParser);
+ } else {
+ ALLOW_INSECURE_PARSER_VAL = false;
+ }
+
+ String autoCloseInputSource = SystemPropertyAction.getPropertyOrNull(AUTO_CLOSE_INPUT_SOURCE_PROP);
+ if (!StringUtils.isEmpty(autoCloseInputSource)) {
+ AUTO_CLOSE_INPUT_SOURCE = "1".equals(autoCloseInputSource) || Boolean.parseBoolean(autoCloseInputSource);
+ } else {
+ AUTO_CLOSE_INPUT_SOURCE = false; /* set 'false' by default */
+ }
+
+ XMLInputFactory xif = null;
+ try {
+ xif = createXMLInputFactory(true);
+ String xifClassName = xif.getClass().getName();
+ if (!xifClassName.contains("ctc.wstx") && !xifClassName.contains("xml.xlxp")
+ && !xifClassName.contains("xml.xlxp2") && !xifClassName.contains("bea.core")) {
+ xif = null;
+ }
+ } catch (Throwable t) {
+ //ignore, can always drop down to the pooled factories
+ }
+ SAFE_INPUT_FACTORY = xif;
+
+ XMLOutputFactory xof = null;
+ try {
+ xof = XMLOutputFactory.newInstance();
+ String xofClassName = xof.getClass().getName();
+ if (!xofClassName.contains("ctc.wstx") && !xofClassName.contains("xml.xlxp")
+ && !xofClassName.contains("xml.xlxp2") && !xofClassName.contains("bea.core")) {
+ xof = null;
+ }
+ } catch (Throwable t) {
+ //ignore, can always drop down to the pooled factories
+ }
+ SAFE_OUTPUT_FACTORY = xof;
+
+ }
+
+ private StaxUtils() {
+ }
+ private static int getInteger(String prop, int def) {
+ try {
+ String s = SystemPropertyAction.getPropertyOrNull(prop);
+ if (StringUtils.isEmpty(s)) {
+ return def;
+ }
+ int i = Integer.parseInt(s);
+ if (i < 0) {
+ i = def;
+ }
+ return i;
+ } catch (Throwable t) {
+ //ignore
+ }
+ return def;
+ }
+ private static long getLong(String prop, long def) {
+ try {
+ String s = SystemPropertyAction.getPropertyOrNull(prop);
+ if (StringUtils.isEmpty(s)) {
+ return def;
+ }
+ long i = Long.parseLong(s);
+ if (i < 0) {
+ i = def;
+ }
+ return i;
+ } catch (Throwable t) {
+ //ignore
+ }
+ return def;
+ }
+
+ /**
+ * Return a cached, namespace-aware, factory.
+ */
+ private static XMLInputFactory getXMLInputFactory() {
+ if (SAFE_INPUT_FACTORY != null) {
+ return SAFE_INPUT_FACTORY;
+ }
+ XMLInputFactory f = NS_AWARE_INPUT_FACTORY_POOL.poll();
+ if (f == null) {
+ f = createXMLInputFactory(true);
+ }
+ return f;
+ }
+
+ private static void returnXMLInputFactory(XMLInputFactory factory) {
+ if (SAFE_INPUT_FACTORY != factory) {
+ NS_AWARE_INPUT_FACTORY_POOL.offer(factory);
+ }
+ }
+
+ private static XMLOutputFactory getXMLOutputFactory() {
+ if (SAFE_OUTPUT_FACTORY != null) {
+ return SAFE_OUTPUT_FACTORY;
+ }
+ XMLOutputFactory f = OUTPUT_FACTORY_POOL.poll();
+ if (f == null) {
+ f = XMLOutputFactory.newInstance();
+ }
+ return f;
+ }
+
+ private static void returnXMLOutputFactory(XMLOutputFactory factory) {
+ if (SAFE_OUTPUT_FACTORY != factory) {
+ OUTPUT_FACTORY_POOL.offer(factory);
+ }
+ }
+
+ /**
+ * Return a new factory so that the caller can set sticky parameters.
+ * @param nsAware
+ * @throws XMLStreamException
+ */
+ public static XMLInputFactory createXMLInputFactory(boolean nsAware) {
+ XMLInputFactory factory = null;
+ try {
+ factory = XMLInputFactory.newInstance();
+ } catch (Throwable t) {
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.log(Level.FINE, "XMLInputFactory.newInstance() failed with: ", t);
+ }
+ }
+ if (factory == null || !setRestrictionProperties(factory)) {
+ try {
+ factory = createWoodstoxFactory();
+ } catch (Throwable t) {
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.log(Level.FINE, "Cannot create Woodstox XMLInputFactory: ", t);
+ }
+ }
+
+ if (factory == null) {
+ throw new RuntimeException("Failed to create XMLInputFactory.");
+ }
+
+ if (!setRestrictionProperties(factory)) {
+ if (ALLOW_INSECURE_PARSER_VAL) {
+ LOG.log(Level.WARNING, "INSECURE_PARSER_DETECTED", factory.getClass().getName());
+ } else {
+ throw new RuntimeException("Cannot create a secure XMLInputFactory, "
+ + "you should either add woodstox or set " + ALLOW_INSECURE_PARSER
+ + " system property to true if an unsafe mode is acceptable.");
+ }
+ }
+ }
+ setProperty(factory, XMLInputFactory.IS_NAMESPACE_AWARE, nsAware);
+ setProperty(factory, XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
+ setProperty(factory, XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, Boolean.FALSE);
+ setProperty(factory, XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE);
+ factory.setXMLResolver(new XMLResolver() {
+ public Object resolveEntity(String publicID, String systemID,
+ String baseURI, String namespace)
+ throws XMLStreamException {
+ throw new XMLStreamException("Reading external entities is disabled");
+ }
+ });
+
+ return factory;
+ }
+
+ private static XMLInputFactory createWoodstoxFactory() {
+ return WoodstoxHelper.createInputFactory();
+ }
+
+ public static XMLEventFactory createWoodstoxEventFactory() {
+ return WoodstoxHelper.createEventFactory();
+ }
+
+ private static boolean setRestrictionProperties(XMLInputFactory factory) {
+ //For now, we can only support Woodstox 4.2.x and newer as none of the other
+ //stax parsers support these settings
+ final boolean wstxMaxs = setProperty(factory, P_MAX_ATTRIBUTES_PER_ELEMENT, MAX_ATTR_COUNT_VAL)
+ && setProperty(factory, P_MAX_ATTRIBUTE_SIZE, MAX_ATTR_SIZE_VAL)
+ && setProperty(factory, P_MAX_CHILDREN_PER_ELEMENT, MAX_CHILD_ELEMENTS_VAL)
+ && setProperty(factory, P_MAX_ELEMENT_COUNT, MAX_ELEMENT_COUNT_VAL)
+ && setProperty(factory, P_MAX_ELEMENT_DEPTH, MAX_ELEMENT_DEPTH_VAL)
+ && setProperty(factory, P_MAX_CHARACTERS, MAX_XML_CHARS_VAL)
+ && setProperty(factory, P_MAX_TEXT_LENGTH, MAX_TEXT_LENGTH_VAL);
+ return wstxMaxs
+ && setProperty(factory, P_MIN_TEXT_SEGMENT, MIN_TEXT_SEGMENT_VAL);
+ }
+
+ private static boolean setProperty(XMLInputFactory f, String p, Object o) {
+ try {
+ f.setProperty(p, o);
+ return true;
+ } catch (Throwable t) {
+ //ignore
+ }
+ return false;
+ }
+
+
+
+ public static XMLStreamWriter createXMLStreamWriter(Writer out) {
+ XMLOutputFactory factory = getXMLOutputFactory();
+ try {
+ return factory.createXMLStreamWriter(out);
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Cant' create XMLStreamWriter", e);
+ } finally {
+ returnXMLOutputFactory(factory);
+ }
+ }
+
+ public static XMLStreamWriter createXMLStreamWriter(OutputStream out) {
+ return createXMLStreamWriter(out, null);
+ }
+
+ public static XMLStreamWriter createXMLStreamWriter(OutputStream out, String encoding) {
+ XMLOutputFactory factory = getXMLOutputFactory();
+ try {
+ return factory.createXMLStreamWriter(out, encoding != null ? encoding : StandardCharsets.UTF_8.name());
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Cant' create XMLStreamWriter", e);
+ } finally {
+ returnXMLOutputFactory(factory);
+ }
+ }
+
+ public static XMLStreamWriter createXMLStreamWriter(Result r) {
+ if (r instanceof DOMResult) {
+ //use our own DOM writer to avoid issues with Sun's
+ //version that doesn't support getNamespaceContext
+ DOMResult dr = (DOMResult)r;
+ Node nd = dr.getNode();
+ if (nd instanceof Document) {
+ return new W3CDOMStreamWriter((Document)nd);
+ } else if (nd instanceof Element) {
+ return new W3CDOMStreamWriter((Element)nd);
+ } else if (nd instanceof DocumentFragment) {
+ return new W3CDOMStreamWriter((DocumentFragment)nd);
+ }
+ }
+ XMLOutputFactory factory = getXMLOutputFactory();
+ try {
+ return factory.createXMLStreamWriter(r);
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Cant' create XMLStreamWriter", e);
+ } finally {
+ returnXMLOutputFactory(factory);
+ }
+ }
+
+ public static XMLStreamReader createFilteredReader(XMLStreamReader reader, StreamFilter filter) {
+ XMLInputFactory factory = getXMLInputFactory();
+ try {
+ return factory.createFilteredReader(reader, filter);
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Cant' create XMLStreamReader", e);
+ } finally {
+ returnXMLInputFactory(factory);
+ }
+ }
+
+
+ public static void nextEvent(XMLStreamReader dr) {
+ try {
+ dr.next();
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ }
+ }
+
+ public static boolean toNextText(DepthXMLStreamReader reader) {
+ if (reader.getEventType() == XMLStreamConstants.CHARACTERS) {
+ return true;
+ }
+
+ try {
+ int depth = reader.getDepth();
+ int event = reader.getEventType();
+ while (reader.getDepth() >= depth && reader.hasNext()) {
+ if (event == XMLStreamConstants.CHARACTERS && reader.getDepth() == depth + 1) {
+ return true;
+ }
+ event = reader.next();
+ }
+ return false;
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ }
+ }
+ public static boolean toNextTag(XMLStreamReader reader) {
+ try {
+ // advance to first tag.
+ int x = reader.getEventType();
+ while (x != XMLStreamConstants.START_ELEMENT
+ && x != XMLStreamConstants.END_ELEMENT
+ && reader.hasNext()) {
+ x = reader.next();
+ }
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ }
+ return true;
+ }
+
+ public static boolean toNextTag(DepthXMLStreamReader reader, QName endTag) {
+ try {
+ int depth = reader.getDepth();
+ int event = reader.getEventType();
+ while (reader.getDepth() >= depth && reader.hasNext()) {
+ if (event == XMLStreamConstants.START_ELEMENT && reader.getName().equals(endTag)
+ && reader.getDepth() == depth + 1) {
+ return true;
+ }
+ event = reader.next();
+ }
+ return false;
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ }
+ }
+
+ public static void writeStartElement(XMLStreamWriter writer, String prefix, String name, String namespace)
+ throws XMLStreamException {
+ if (prefix == null) {
+ prefix = "";
+ }
+
+ if (!namespace.isEmpty()) {
+ writer.writeStartElement(prefix, name, namespace);
+ if (!prefix.isEmpty()) {
+ writer.writeNamespace(prefix, namespace);
+ writer.setPrefix(prefix, namespace);
+ } else {
+ writer.writeDefaultNamespace(namespace);
+ writer.setDefaultNamespace(namespace);
+ }
+ } else {
+ writer.writeStartElement(name);
+ writer.writeDefaultNamespace("");
+ writer.setDefaultNamespace("");
+ }
+ }
+
+ /**
+ * Returns true if currently at the start of an element, otherwise move
+ * forwards to the next element start and return true, otherwise false is
+ * returned if the end of the stream is reached.
+ */
+ public static boolean skipToStartOfElement(XMLStreamReader in) throws XMLStreamException {
+ for (int code = in.getEventType(); code != XMLStreamConstants.END_DOCUMENT; code = in.next()) {
+ if (code == XMLStreamConstants.START_ELEMENT) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static boolean toNextElement(DepthXMLStreamReader dr) {
+ if (dr.getEventType() == XMLStreamConstants.START_ELEMENT) {
+ return true;
+ }
+ if (dr.getEventType() == XMLStreamConstants.END_ELEMENT) {
+ return false;
+ }
+ try {
+ int depth = dr.getDepth();
+
+ for (int event = dr.getEventType(); dr.getDepth() >= depth && dr.hasNext(); event = dr.next()) {
+ if (event == XMLStreamConstants.START_ELEMENT && dr.getDepth() == depth + 1) {
+ return true;
+ } else if (event == XMLStreamConstants.END_ELEMENT) {
+ depth--;
+ }
+ }
+
+ return false;
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ }
+ }
+
+ public static boolean skipToStartOfElement(DepthXMLStreamReader in) throws XMLStreamException {
+ for (int code = in.getEventType(); code != XMLStreamConstants.END_DOCUMENT; code = in.next()) {
+ if (code == XMLStreamConstants.START_ELEMENT) {
+ return true;
+ }
+ }
+ return false;
+ }
+ public static void copy(Source source, OutputStream os) throws XMLStreamException {
+ XMLStreamWriter writer = createXMLStreamWriter(os);
+ try {
+ copy(source, writer);
+ } finally {
+ try {
+ writer.flush();
+ } catch (XMLStreamException ex) {
+ //ignore
+ }
+ StaxUtils.close(writer);
+ }
+ }
+ public static void copy(Source source, XMLStreamWriter writer) throws XMLStreamException {
+ if (source instanceof StaxSource) {
+ StaxSource ss = (StaxSource)source;
+ if (ss.getXMLStreamReader() == null) {
+ return;
+ }
+ } else if (source instanceof StAXSource) {
+ StAXSource ss = (StAXSource)source;
+ if (ss.getXMLStreamReader() == null) {
+ return;
+ }
+ } else if (source instanceof SAXSource) {
+ SAXSource ss = (SAXSource)source;
+ InputSource src = ss.getInputSource();
+ if (src == null || (src.getSystemId() == null && src.getPublicId() == null)) {
+ if (ss.getXMLReader() != null) {
+ //OK - reader is OK. We'll use that out
+ StreamWriterContentHandler ch = new StreamWriterContentHandler(writer);
+ XMLReader reader = ((SAXSource)source).getXMLReader();
+ reader.setContentHandler(ch);
+ try {
+ try {
+ reader.setFeature("http://xml.org/sax/features/namespaces", true);
+ } catch (Throwable t) {
+ //ignore
+ }
+ try {
+ reader.setProperty("http://xml.org/sax/properties/lexical-handler", ch);
+ } catch (Throwable t) {
+ //ignore
+ }
+ reader.parse(((SAXSource)source).getInputSource());
+ return;
+ } catch (Exception e) {
+ throw new XMLStreamException(e.getMessage(), e);
+ }
+ } else if (ss.getInputSource() == null) {
+ //nothing to copy, just return
+ return;
+ }
+ }
+
+ } else if (source instanceof StreamSource) {
+ StreamSource ss = (StreamSource)source;
+ if (ss.getInputStream() == null
+ && ss.getReader() == null
+ && ss.getSystemId() == null) {
+ //nothing to copy, just return
+ return;
+ }
+ }
+ XMLStreamReader reader = createXMLStreamReader(source);
+ copy(reader, writer);
+ reader.close();
+ }
+
+ public static Document copy(Document doc)
+ throws XMLStreamException, ParserConfigurationException {
+
+ XMLStreamReader reader = createXMLStreamReader(doc);
+ W3CDOMStreamWriter writer = new W3CDOMStreamWriter();
+ copy(reader, writer);
+ Document d = writer.getDocument();
+ try {
+ d.setDocumentURI(doc.getDocumentURI());
+ } catch (Exception ex) {
+ //ignore - probably not DOM level 3
+ }
+ return d;
+ }
+ public static void copy(Document doc, XMLStreamWriter writer) throws XMLStreamException {
+ XMLStreamReader reader = createXMLStreamReader(doc);
+ copy(reader, writer);
+ }
+ public static void copy(Element node, XMLStreamWriter writer) throws XMLStreamException {
+ XMLStreamReader reader = createXMLStreamReader(node);
+ copy(reader, writer);
+ }
+
+ public static void copy(XMLStreamReader reader, OutputStream os)
+ throws XMLStreamException {
+ XMLStreamWriter xsw = StaxUtils.createXMLStreamWriter(os);
+ StaxUtils.copy(reader, xsw);
+ xsw.close();
+ }
+
+ public static void writeTo(Node node, OutputStream os) throws XMLStreamException {
+ copy(new DOMSource(node), os);
+ }
+ public static void writeTo(Node node, OutputStream os, int indent) throws XMLStreamException {
+ if (indent > 0) {
+ XMLStreamWriter writer = new PrettyPrintXMLStreamWriter(createXMLStreamWriter(os), indent);
+ try {
+ copy(new DOMSource(node), writer);
+ } finally {
+ writer.close();
+ }
+ } else {
+ copy(new DOMSource(node), os);
+ }
+ }
+ public static void writeTo(Node node, Writer os) throws XMLStreamException {
+ writeTo(node, os, 0);
+ }
+ public static void writeTo(Node node, Writer os, int indent) throws XMLStreamException {
+ XMLStreamWriter writer = createXMLStreamWriter(os);
+ if (indent > 0) {
+ writer = new PrettyPrintXMLStreamWriter(writer, indent);
+ }
+ try {
+ copy(new DOMSource(node), writer);
+ } finally {
+ writer.close();
+ }
+ }
+
+
+ /**
+ * Copies the reader to the writer. The start and end document methods must
+ * be handled on the writer manually.
+ *
+ * @param reader
+ * @param writer
+ * @throws XMLStreamException
+ */
+ public static void copy(XMLStreamReader reader, XMLStreamWriter writer) throws XMLStreamException {
+ copy(reader, writer, false, false);
+ }
+ public static void copy(XMLStreamReader reader, XMLStreamWriter writer, boolean fragment)
+ throws XMLStreamException {
+ copy(reader, writer, fragment, false);
+ }
+ public static void copy(XMLStreamReader reader,
+ XMLStreamWriter writer,
+ boolean fragment,
+ boolean isThreshold) throws XMLStreamException {
+ // number of elements read in
+ int read = 0;
+ int elementCount = 0;
+ final Deque<Integer> countStack = new ArrayDeque<>();
+ int event = reader.getEventType();
+
+ while (reader.hasNext()) {
+ switch (event) {
+ case XMLStreamConstants.START_ELEMENT:
+ read++;
+ if (isThreshold) {
+ elementCount++;
+
+ if (MAX_ELEMENT_DEPTH_VAL != -1 && read >= MAX_ELEMENT_DEPTH_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementLevelThreshold:"
+ + MAX_ELEMENT_DEPTH_VAL);
+ }
+ if (MAX_CHILD_ELEMENTS_VAL != -1 && elementCount >= MAX_CHILD_ELEMENTS_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementCountThreshold:"
+ + MAX_CHILD_ELEMENTS_VAL);
+ }
+ countStack.push(elementCount);
+ elementCount = 0;
+ }
+ writeStartElement(reader, writer);
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (read > 0) {
+ writer.writeEndElement();
+ }
+ read--;
+ if (read < 0 && fragment) {
+ return;
+ }
+ if (isThreshold && !countStack.isEmpty()) {
+ elementCount = countStack.pop();
+ }
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ case XMLStreamConstants.SPACE:
+ String s = reader.getText();
+ if (s != null) {
+ writer.writeCharacters(s);
+ }
+ break;
+ case XMLStreamConstants.COMMENT:
+ writer.writeComment(reader.getText());
+ break;
+ case XMLStreamConstants.CDATA:
+ writer.writeCData(reader.getText());
+ break;
+ case XMLStreamConstants.START_DOCUMENT:
+ case XMLStreamConstants.END_DOCUMENT:
+ case XMLStreamConstants.ATTRIBUTE:
+ case XMLStreamConstants.NAMESPACE:
+ break;
+ default:
+ break;
+ }
+ event = reader.next();
+ }
+ }
+
+ private static void writeStartElement(XMLStreamReader reader, XMLStreamWriter writer)
+ throws XMLStreamException {
+ String uri = reader.getNamespaceURI();
+ String prefix = reader.getPrefix();
+ String local = reader.getLocalName();
+
+ if (prefix == null) {
+ prefix = "";
+ }
+
+ boolean writeElementNS = false;
+
+ if (uri != null) {
+ writeElementNS = true;
+ Iterator<String> it = CastUtils.cast(writer.getNamespaceContext().getPrefixes(uri));
+ if (!it.hasNext() && StringUtils.isEmpty(prefix) && StringUtils.isEmpty(uri)
+ && StringUtils.isEmpty(writer.getNamespaceContext().getNamespaceURI(""))) {
+ writeElementNS = false;
+ }
+ while (it.hasNext()) {
+ String s = it.next();
+ if (s == null) {
+ s = "";
+ }
+ if (s.equals(prefix)) {
+ writeElementNS = false;
+ }
+ }
+ }
+
+ // Write out the element name
+ if (uri != null) {
+ if (prefix.isEmpty() && StringUtils.isEmpty(uri)) {
+ writer.writeStartElement(local);
+ } else {
+ writer.writeStartElement(prefix, local, uri);
+ }
+ } else {
+ writer.writeStartElement(local);
+ }
+
+ // Write out the namespaces
+ for (int i = 0; i < reader.getNamespaceCount(); i++) {
+ String nsURI = reader.getNamespaceURI(i);
+ String nsPrefix = reader.getNamespacePrefix(i);
+ if (nsPrefix == null) {
+ nsPrefix = "";
+ }
+ if (nsURI == null) {
+ nsURI = "";
+ }
+ if (nsPrefix.isEmpty()) {
+ writer.writeDefaultNamespace(nsURI);
+ writer.setDefaultNamespace(nsURI);
+ } else {
+ writer.writeNamespace(nsPrefix, nsURI);
+ writer.setPrefix(nsPrefix, nsURI);
+ }
+
+ if (nsURI.equals(uri) && nsPrefix.equals(prefix)) {
+ writeElementNS = false;
+ }
+ }
+
+ // Check if the namespace still needs to be written.
+ // We need this check because namespace writing works
+ // different on Woodstox and the RI.
+ if (writeElementNS) {
+ if (prefix.isEmpty()) {
+ writer.writeDefaultNamespace(uri);
+ writer.setDefaultNamespace(uri);
+ } else {
+ writer.writeNamespace(prefix, uri);
+ writer.setPrefix(prefix, uri);
+ }
+ }
+
+ // Write out attributes
+ for (int i = 0; i < reader.getAttributeCount(); i++) {
+ String ns = reader.getAttributeNamespace(i);
+ String nsPrefix = reader.getAttributePrefix(i);
+ if (ns == null || ns.isEmpty()) {
+ writer.writeAttribute(reader.getAttributeLocalName(i), reader.getAttributeValue(i));
+ } else if (nsPrefix == null || nsPrefix.isEmpty()) {
+ writer.writeAttribute(reader.getAttributeNamespace(i), reader.getAttributeLocalName(i),
+ reader.getAttributeValue(i));
+ } else {
+ Iterator<String> it = CastUtils.cast(writer.getNamespaceContext().getPrefixes(ns));
+ boolean writeNs = true;
+ while (it != null && it.hasNext()) {
+ String s = it.next();
+ if (s == null) {
+ s = "";
+ }
+ if (s.equals(nsPrefix)) {
+ writeNs = false;
+ }
+ }
+ if (writeNs) {
+ writer.writeNamespace(nsPrefix, ns);
+ writer.setPrefix(nsPrefix, ns);
+ }
+ writer.writeAttribute(reader.getAttributePrefix(i), reader.getAttributeNamespace(i), reader
+ .getAttributeLocalName(i), reader.getAttributeValue(i));
+ }
+
+ }
+ }
+
+ public static void writeDocument(Document d, XMLStreamWriter writer, boolean repairing)
+ throws XMLStreamException {
+ writeDocument(d, writer, true, repairing);
+ }
+
+ public static void writeDocument(Document d, XMLStreamWriter writer, boolean writeProlog,
+ boolean repairing) throws XMLStreamException {
+ if (writeProlog) {
+ writer.writeStartDocument();
+ }
+
+ Node node = d.getFirstChild();
+ while (node != null) {
+ if (writeProlog || node.getNodeType() == Node.ELEMENT_NODE) {
+ writeNode(node, writer, repairing);
+ }
+ node = node.getNextSibling();
+ }
+
+ if (writeProlog) {
+ writer.writeEndDocument();
+ }
+ }
+
+ /**
+ * Writes an Element to an XMLStreamWriter. The writer must already have
+ * started the document (via writeStartDocument()). Also, this probably
+ * won't work with just a fragment of a document. The Element should be the
+ * root element of the document.
+ *
+ * @param e
+ * @param writer
+ * @throws XMLStreamException
+ */
+ public static void writeElement(Element e, XMLStreamWriter writer, boolean repairing)
+ throws XMLStreamException {
+ writeElement(e, writer, repairing, true);
+ }
+
+ /**
+ * Writes an Element to an XMLStreamWriter. The writer must already have
+ * started the document (via writeStartDocument()). Also, this probably
+ * won't work with just a fragment of a document. The Element should be the
+ * root element of the document.
+ *
+ * @param e
+ * @param writer
+ * @param endElement true if the element should be ended
+ * @throws XMLStreamException
+ */
+ public static void writeElement(Element e,
+ XMLStreamWriter writer,
+ boolean repairing,
+ boolean endElement)
+ throws XMLStreamException {
+ String prefix = e.getPrefix();
+ String ns = e.getNamespaceURI();
+ String localName = e.getLocalName();
+
+ if (prefix == null) {
+ prefix = "";
+ }
+ if (localName == null) {
+ localName = e.getNodeName();
+
+ if (localName == null) {
+ throw new IllegalStateException("Element's local name cannot be null!");
+ }
+ }
+
+ String decUri = writer.getNamespaceContext().getNamespaceURI(prefix);
+ boolean declareNamespace = decUri == null || !decUri.equals(ns);
+
+ if (ns == null || ns.isEmpty()) {
+ writer.writeStartElement(localName);
+ if (StringUtils.isEmpty(decUri)) {
+ declareNamespace = false;
+ }
+ } else {
+ writer.writeStartElement(prefix, localName, ns);
+ }
+
+ for (Node attr : sortElementAttributes(e.getAttributes())) {
+
+ String name = attr.getLocalName();
+ String attrPrefix = attr.getPrefix();
+ if (attrPrefix == null) {
+ attrPrefix = "";
+ }
+ if (name == null) {
+ name = attr.getNodeName();
+ }
+
+ if ("xmlns".equals(attrPrefix)) {
+ writer.writeNamespace(name, attr.getNodeValue());
+ writer.setPrefix(name, attr.getNodeValue());
+ if (name.equals(prefix) && attr.getNodeValue().equals(ns)) {
+ declareNamespace = false;
+ }
+ } else {
+ if ("xmlns".equals(name) && "".equals(attrPrefix)) {
+ writer.writeDefaultNamespace(attr.getNodeValue());
+ writer.setDefaultNamespace(attr.getNodeValue());
+ if (attr.getNodeValue().equals(ns)) {
+ declareNamespace = false;
+ } else if (StringUtils.isEmpty(attr.getNodeValue())
+ && StringUtils.isEmpty(ns)) {
+ declareNamespace = false;
+ }
+ } else {
+ String attns = attr.getNamespaceURI();
+ String value = attr.getNodeValue();
+ if (attns == null || attns.isEmpty()) {
+ writer.writeAttribute(name, value);
+ } else if (attrPrefix.isEmpty()) {
+ writer.writeAttribute(attns, name, value);
+ } else {
+ if (repairing && writer.getNamespaceContext().getNamespaceURI(attrPrefix) == null) {
+ writer.writeNamespace(attrPrefix, attns);
+ }
+ writer.writeAttribute(attrPrefix, attns, name, value);
+ }
+ }
+ }
+ }
+
+ if (declareNamespace && repairing) {
+ if (ns == null) {
+ writer.writeNamespace(prefix, "");
+ writer.setPrefix(prefix, "");
+ } else {
+ writer.writeNamespace(prefix, ns);
+ writer.setPrefix(prefix, ns);
+ }
+ }
+
+ Node nd = e.getFirstChild();
+ while (nd != null) {
+ writeNode(nd, writer, repairing);
+ nd = nd.getNextSibling();
+ }
+
+ if (endElement) {
+ writer.writeEndElement();
+ }
+ }
+
+ private static List<Node> sortElementAttributes(NamedNodeMap attrs) {
+ if (attrs.getLength() == 0) {
+ return Collections.<Node> emptyList();
+ }
+ List<Node> sortedAttrs = new ArrayList<>(attrs.getLength());
+ for (int i = 0; i < attrs.getLength(); i++) {
+ Node attr = attrs.item(i);
+ String name = attr.getLocalName();
+ if (name == null) {
+ name = attr.getNodeName();
+ }
+ if ("xmlns".equals(attr.getPrefix()) || "xmlns".equals(name)) {
+ sortedAttrs.add(0, attr);
+ } else {
+ sortedAttrs.add(attr);
+ }
+ }
+
+ return sortedAttrs;
+ }
+
+ public static void writeNode(Node n, XMLStreamWriter writer, boolean repairing)
+ throws XMLStreamException {
+
+ switch (n.getNodeType()) {
+ case Node.ELEMENT_NODE:
+ writeElement((Element)n, writer, repairing);
+ break;
+ case Node.TEXT_NODE:
+ writer.writeCharacters(((Text)n).getNodeValue());
+ break;
+ case Node.COMMENT_NODE:
+ writer.writeComment(((Comment)n).getData());
+ break;
+ case Node.CDATA_SECTION_NODE:
+ writer.writeCData(((CDATASection)n).getData());
+ break;
+ case Node.ENTITY_REFERENCE_NODE:
+ writer.writeEntityRef(((EntityReference)n).getNodeValue());
+ break;
+ case Node.PROCESSING_INSTRUCTION_NODE:
+ ProcessingInstruction pi = (ProcessingInstruction)n;
+ writer.writeProcessingInstruction(pi.getTarget(), pi.getData());
+ break;
+ case Node.DOCUMENT_NODE:
+ writeDocument((Document)n, writer, repairing);
+ break;
+ case Node.DOCUMENT_FRAGMENT_NODE: {
+ DocumentFragment frag = (DocumentFragment)n;
+ Node child = frag.getFirstChild();
+ while (child != null) {
+ writeNode(child, writer, repairing);
+ child = child.getNextSibling();
+ }
+ break;
+ }
+ case Node.DOCUMENT_TYPE_NODE:
+ try {
+ if (((DocumentType)n).getTextContent() != null) {
+ writer.writeDTD(((DocumentType)n).getTextContent());
+ }
+ } catch (UnsupportedOperationException ex) {
+ //can we ignore? DOM writers really don't allow this
+ //as there isn't a way to write a DTD in dom
+ }
+ break;
+ default:
+ throw new IllegalStateException("Found type: " + n.getClass().getName());
+ }
+ }
+
+ public static Document read(Source s) throws XMLStreamException {
+ XMLStreamReader reader = createXMLStreamReader(s);
+ try {
+ return read(reader);
+ } finally {
+ try {
+ reader.close();
+ } catch (Exception ex) {
+ //ignore
+ }
+ }
+ }
+ public static Document read(InputStream s) throws XMLStreamException {
+ XMLStreamReader reader = createXMLStreamReader(s);
+ try {
+ return read(reader);
+ } finally {
+ try {
+ reader.close();
+ } catch (Exception ex) {
+ //ignore
+ }
+ }
+ }
+ public static Document read(Reader s) throws XMLStreamException {
+ XMLStreamReader reader = createXMLStreamReader(s);
+ try {
+ return read(reader);
+ } finally {
+ try {
+ reader.close();
+ } catch (Exception ex) {
+ //ignore
+ }
+ }
+ }
+ public static Document read(File is) throws XMLStreamException, IOException {
+ try (InputStream fin = Files.newInputStream(is.toPath())) {
+ return read(fin);
+ }
+ }
+ public static Document read(InputSource s) throws XMLStreamException {
+ XMLStreamReader reader = null;
+ try {
+ reader = createXMLStreamReader(s);
+ return read(reader);
+ } finally {
+ StaxUtils.close(reader);
+ }
+ }
+ public static Document read(XMLStreamReader reader) throws XMLStreamException {
+ return read(reader, false);
+ }
+ public static Document read(XMLStreamReader reader, boolean recordLoc) throws XMLStreamException {
+ Document doc = DOMUtils.createDocument();
+ if (reader.getLocation().getSystemId() != null) {
+ try {
+ doc.setDocumentURI(reader.getLocation().getSystemId());
+ } catch (Exception e) {
+ //ignore - probably not DOM level 3
+ }
+ }
+ readDocElements(doc, doc, reader, true, recordLoc);
+ return doc;
+ }
+
+ public static Document read(DocumentBuilder builder, XMLStreamReader reader, boolean repairing)
+ throws XMLStreamException {
+
+ Document doc = builder == null ? DOMUtils.createDocument() : builder.newDocument();
+ if (reader.getLocation().getSystemId() != null) {
+ try {
+ doc.setDocumentURI(reader.getLocation().getSystemId());
+ } catch (Exception e) {
+ //ignore - probably not DOM level 3
+ }
+ }
+ readDocElements(doc, reader, repairing);
+ return doc;
+ }
+
+ /**
+ * @param parent
+ */
+ private static Document getDocument(Node parent) {
+ return (parent instanceof Document) ? (Document)parent : parent.getOwnerDocument();
+ }
+
+ private static boolean isDeclared(Element e, String namespaceURI, String prefix) {
+ while (e != null) {
+ Attr att;
+ if (prefix != null && !prefix.isEmpty()) {
+ att = e.getAttributeNodeNS(XML_NS, prefix);
+ } else {
+ att = e.getAttributeNode("xmlns");
+ }
+
+ if (att != null && att.getNodeValue().equals(namespaceURI)) {
+ return true;
+ }
+
+ if (e.getParentNode() instanceof Element) {
+ e = (Element)e.getParentNode();
+ } else if (StringUtils.isEmpty(prefix) && StringUtils.isEmpty(namespaceURI)) {
+ //A document that probably doesn't have any namespace qualifies elements
+ return true;
+ } else {
+ break;
+ }
+ }
+ return false;
+ }
+
+ public static void readDocElements(Node parent, XMLStreamReader reader, boolean repairing)
+ throws XMLStreamException {
+ Document doc = getDocument(parent);
+ readDocElements(doc, parent, reader, repairing, false);
+ }
+
+ public static void readDocElements(Node parent, XMLStreamReader reader, boolean repairing,
+ boolean isThreshold)
+ throws XMLStreamException {
+ Document doc = getDocument(parent);
+ readDocElements(doc, parent, reader, repairing, false, isThreshold);
+ }
+
+ /**
+ * @param parent
+ * @param reader
+ * @throws XMLStreamException
+ */
+ public static void readDocElements(Document doc, Node parent,
+ XMLStreamReader reader, boolean repairing, boolean recordLoc)
+ throws XMLStreamException {
+ readDocElements(doc, parent, reader, repairing, recordLoc, false);
+ }
+
+ /**
+ * @param parent
+ * @param reader
+ * @throws XMLStreamException
+ */
+ public static void readDocElements(Document doc, Node parent,
+ XMLStreamReader reader, boolean repairing, boolean recordLoc,
+ boolean isThreshold)
+ throws XMLStreamException {
+ final Deque<Node> stack = new ArrayDeque<>();
+ int event = reader.getEventType();
+ int elementCount = 0;
+ while (reader.hasNext()) {
+ switch (event) {
+ case XMLStreamConstants.START_ELEMENT: {
+ elementCount++;
+ Element e;
+ if (!StringUtils.isEmpty(reader.getPrefix())) {
+ e = doc.createElementNS(reader.getNamespaceURI(),
+ reader.getPrefix() + ':' + reader.getLocalName());
+ } else {
+ e = doc.createElementNS(reader.getNamespaceURI(), reader.getLocalName());
+ }
+ e = (Element)parent.appendChild(e);
+ recordLoc = addLocation(doc, e, reader, recordLoc);
+
+ for (int ns = 0; ns < reader.getNamespaceCount(); ns++) {
+ String uri = reader.getNamespaceURI(ns);
+ String prefix = reader.getNamespacePrefix(ns);
+
+ declare(e, uri, prefix);
+ }
+
+ for (int att = 0; att < reader.getAttributeCount(); att++) {
+ String name = reader.getAttributeLocalName(att);
+ String prefix = reader.getAttributePrefix(att);
+ if (prefix != null && !prefix.isEmpty()) {
+ name = prefix + ':' + name;
+ }
+
+ Attr attr = doc.createAttributeNS(reader.getAttributeNamespace(att), name);
+ attr.setValue(reader.getAttributeValue(att));
+ e.setAttributeNode(attr);
+ }
+
+ if (repairing && !isDeclared(e, reader.getNamespaceURI(), reader.getPrefix())) {
+ declare(e, reader.getNamespaceURI(), reader.getPrefix());
+ }
+ stack.push(parent);
+ if (isThreshold && MAX_ELEMENT_DEPTH_VAL != -1
+ && stack.size() >= MAX_ELEMENT_DEPTH_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementLevelThreshold:"
+ + MAX_ELEMENT_DEPTH_VAL);
+ }
+ if (isThreshold && MAX_CHILD_ELEMENTS_VAL != -1
+ && elementCount >= MAX_CHILD_ELEMENTS_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementCountThreshold:"
+ + MAX_CHILD_ELEMENTS_VAL);
+ }
+ parent = e;
+ break;
+ }
+ case XMLStreamConstants.END_ELEMENT:
+ if (stack.isEmpty()) {
+ return;
+ }
+ parent = stack.pop();
+ if (parent instanceof Document || parent instanceof DocumentFragment) {
+ return;
+ }
+ break;
+ case XMLStreamConstants.NAMESPACE:
+ break;
+ case XMLStreamConstants.ATTRIBUTE:
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ if (parent != null) {
+ recordLoc = addLocation(doc,
+ parent.appendChild(doc.createTextNode(reader.getText())),
+ reader, recordLoc);
+ }
+ break;
+ case XMLStreamConstants.COMMENT:
+ if (parent != null) {
+ parent.appendChild(doc.createComment(reader.getText()));
+ }
+ break;
+ case XMLStreamConstants.CDATA:
+ recordLoc = addLocation(doc,
+ parent.appendChild(doc.createCDATASection(reader.getText())),
+ reader, recordLoc);
+ break;
+ case XMLStreamConstants.PROCESSING_INSTRUCTION:
+ parent.appendChild(doc.createProcessingInstruction(reader.getPITarget(), reader.getPIData()));
+ break;
+ case XMLStreamConstants.ENTITY_REFERENCE:
+ parent.appendChild(doc.createProcessingInstruction(reader.getPITarget(), reader.getPIData()));
+ break;
+ default:
+ break;
+ }
+
+ if (reader.hasNext()) {
+ event = reader.next();
+ }
+ }
+ }
+
+ public static class StreamToDOMContext {
+ private final Deque<Node> stack = new ArrayDeque<>();
+ private int elementCount;
+ private boolean repairing;
+ private boolean recordLoc;
+ private boolean threshold;
+
+ public StreamToDOMContext(boolean repairing, boolean recordLoc, boolean threshold) {
+ this.repairing = repairing;
+ this.recordLoc = recordLoc;
+ this.threshold = threshold;
+ }
+
+ public void setRecordLoc(boolean recordLoc) {
+ this.recordLoc = recordLoc;
+ }
+
+ public boolean isRecordLoc() {
+ return this.recordLoc;
+ }
+
+ public boolean isRepairing() {
+ return this.repairing;
+ }
+
+ public boolean isThreshold() {
+ return this.threshold;
+ }
+
+ public int incrementCount() {
+ return ++elementCount;
+ }
+
+ public int decreaseCount() {
+ return --elementCount;
+ }
+
+ public int getCount() {
+ return elementCount;
+ }
+
+ public void pushToStack(Node node) {
+ stack.push(node);
+ }
+
+ public Node popFromStack() {
+ return stack.pop();
+ }
+
+ public int getStackSize() {
+ return stack.size();
+ }
+
+ public boolean isStackEmpty() {
+ return stack.isEmpty();
+ }
+ }
+
+ public static void readDocElements(Document doc, Node parent, XMLStreamReader reader, StreamToDOMContext context)
+ throws XMLStreamException {
+ int event = reader.getEventType();
+ while (reader.hasNext()) {
+ switch (event) {
+ case XMLStreamConstants.START_ELEMENT: {
+ context.incrementCount();
+ Element e;
+ if (!StringUtils.isEmpty(reader.getPrefix())) {
+ e = doc.createElementNS(reader.getNamespaceURI(),
+ reader.getPrefix() + ":" + reader.getLocalName());
+ } else {
+ e = doc.createElementNS(reader.getNamespaceURI(), reader.getLocalName());
+ }
+ e = (Element)parent.appendChild(e);
+ if (context.isRecordLoc()) {
+ context.setRecordLoc(addLocation(doc, e, reader.getLocation(), context.isRecordLoc()));
+ }
+
+ for (int ns = 0; ns < reader.getNamespaceCount(); ns++) {
+ String uri = reader.getNamespaceURI(ns);
+ String prefix = reader.getNamespacePrefix(ns);
+
+ declare(e, uri, prefix);
+ }
+
+ for (int att = 0; att < reader.getAttributeCount(); att++) {
+ String name = reader.getAttributeLocalName(att);
+ String prefix = reader.getAttributePrefix(att);
+ if (prefix != null && prefix.length() > 0) {
+ name = prefix + ":" + name;
+ }
+
+ Attr attr = doc.createAttributeNS(reader.getAttributeNamespace(att), name);
+ attr.setValue(reader.getAttributeValue(att));
+ e.setAttributeNode(attr);
+ }
+
+ if (context.isRepairing() && !isDeclared(e, reader.getNamespaceURI(), reader.getPrefix())) {
+ declare(e, reader.getNamespaceURI(), reader.getPrefix());
+ }
+ context.pushToStack(parent);
+ if (context.isThreshold() && MAX_ELEMENT_DEPTH_VAL != -1
+ && context.getStackSize() >= MAX_ELEMENT_DEPTH_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementLevelThreshold:"
+ + MAX_ELEMENT_DEPTH_VAL);
+ }
+ if (context.isThreshold() && MAX_CHILD_ELEMENTS_VAL != -1
+ && context.getCount() >= MAX_CHILD_ELEMENTS_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementCountThreshold:"
+ + MAX_CHILD_ELEMENTS_VAL);
+ }
+ parent = e;
+ break;
+ }
+ case XMLStreamConstants.END_ELEMENT:
+ if (context.isStackEmpty()) {
+ return;
+ }
+ parent = context.popFromStack();
+ if (parent instanceof Document || parent instanceof DocumentFragment) {
+ return;
+ }
+ break;
+ case XMLStreamConstants.NAMESPACE:
+ break;
+ case XMLStreamConstants.ATTRIBUTE:
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ if (parent != null) {
+ context.setRecordLoc(addLocation(doc,
+ parent.appendChild(doc.createTextNode(reader.getText())),
+ reader.getLocation(), context.isRecordLoc()));
+ }
+ break;
+ case XMLStreamConstants.COMMENT:
+ if (parent != null) {
+ parent.appendChild(doc.createComment(reader.getText()));
+ }
+ break;
+ case XMLStreamConstants.CDATA:
+ context.setRecordLoc(addLocation(doc,
+ parent.appendChild(doc.createCDATASection(reader.getText())),
+ reader.getLocation(), context.isRecordLoc()));
+ break;
+ case XMLStreamConstants.PROCESSING_INSTRUCTION:
+ parent.appendChild(doc.createProcessingInstruction(reader.getPITarget(), reader.getPIData()));
+ break;
+ case XMLStreamConstants.ENTITY_REFERENCE:
+ parent.appendChild(doc.createProcessingInstruction(reader.getPITarget(), reader.getPIData()));
+ break;
+ default:
+ break;
+ }
+
+ if (reader.hasNext()) {
+ event = reader.next();
+ }
+ }
+ }
+
+ public static Node readDocElement(Document doc, Node parent, XMLEvent ev, StreamToDOMContext context)
+ throws XMLStreamException {
+ switch (ev.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT: {
+ context.incrementCount();
+ Element e;
+ StartElement startElem = ev.asStartElement();
+ QName name = startElem.getName();
+ if (!StringUtils.isEmpty(name.getPrefix())) {
+ e = doc.createElementNS(name.getNamespaceURI(),
+ name.getPrefix() + ":" + name.getLocalPart());
+ } else {
+ e = doc.createElementNS(name.getNamespaceURI(), name.getLocalPart());
+ }
+ e = (Element)parent.appendChild(e);
+ if (context.isRecordLoc()) {
+ context.setRecordLoc(addLocation(doc, e, startElem.getLocation(), context.isRecordLoc()));
+ }
+
+ if (context.isRepairing() && !isDeclared(e, name.getNamespaceURI(), name.getPrefix())) {
+ declare(e, name.getNamespaceURI(), name.getPrefix());
+ }
+ context.pushToStack(parent);
+ if (context.isThreshold() && MAX_ELEMENT_DEPTH_VAL != -1
+ && context.getStackSize() >= MAX_ELEMENT_DEPTH_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementLevelThreshold:"
+ + MAX_ELEMENT_DEPTH_VAL);
+ }
+ if (context.isThreshold() && MAX_CHILD_ELEMENTS_VAL != -1
+ && context.getCount() >= MAX_CHILD_ELEMENTS_VAL) {
+ throw new DepthExceededStaxException("reach the innerElementCountThreshold:"
+ + MAX_CHILD_ELEMENTS_VAL);
+ }
+ parent = e;
+ break;
+ }
+ case XMLStreamConstants.END_ELEMENT:
+ if (context.isStackEmpty()) {
+ return parent;
+ }
+ parent = context.popFromStack();
+ if (parent instanceof Document || parent instanceof DocumentFragment) {
+ return parent;
+ }
+ break;
+ case XMLStreamConstants.NAMESPACE:
+ Namespace ns = (Namespace)ev;
+ declare((Element)parent, ns.getNamespaceURI(), ns.getPrefix());
+ break;
+ case XMLStreamConstants.ATTRIBUTE:
+ Attribute at = (Attribute)ev;
+ QName qname = at.getName();
+ String attName = qname.getLocalPart();
+ String attPrefix = qname.getPrefix();
+ if (attPrefix != null && attPrefix.length() > 0) {
+ attName = attPrefix + ":" + attName;
+ }
+ Attr attr = doc.createAttributeNS(qname.getNamespaceURI(), attName);
+ attr.setValue(at.getValue());
+ ((Element)parent).setAttributeNode(attr);
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ Characters characters = ev.asCharacters();
+ context.setRecordLoc(addLocation(doc,
+ parent.appendChild(doc.createTextNode(characters.getData())),
+ characters.getLocation(), context.isRecordLoc()));
+ break;
+ case XMLStreamConstants.COMMENT:
+ parent.appendChild(doc.createComment(((javax.xml.stream.events.Comment)ev).getText()));
+ break;
+ case XMLStreamConstants.CDATA:
+ Characters cdata = ev.asCharacters();
+ context.setRecordLoc(addLocation(doc,
+ parent.appendChild(doc.createCDATASection(cdata.getData())),
+ cdata.getLocation(), context.isRecordLoc()));
+ break;
+ case XMLStreamConstants.PROCESSING_INSTRUCTION:
+ parent.appendChild(doc.createProcessingInstruction(((ProcessingInstruction)ev).getTarget(),
+ ((ProcessingInstruction)ev).getData()));
+ break;
+ case XMLStreamConstants.ENTITY_REFERENCE:
+ javax.xml.stream.events.EntityReference er = (javax.xml.stream.events.EntityReference)ev;
+ parent.appendChild(doc.createEntityReference(er.getName()));
+ break;
+ default:
+ break;
+ }
+ return parent;
+ }
+
+ private static boolean addLocation(Document doc, Node node,
+ Location loc,
+ boolean recordLoc) {
+ if (recordLoc && loc != null && (loc.getColumnNumber() != 0 || loc.getLineNumber() != 0)) {
+ try {
+ final int charOffset = loc.getCharacterOffset();
+ final int colNum = loc.getColumnNumber();
+ final int linNum = loc.getLineNumber();
+ final String pubId = loc.getPublicId() == null ? doc.getDocumentURI() : loc.getPublicId();
+ final String sysId = loc.getSystemId() == null ? doc.getDocumentURI() : loc.getSystemId();
+ Location loc2 = new Location() {
+ public int getCharacterOffset() {
+ return charOffset;
+ }
+ public int getColumnNumber() {
+ return colNum;
+ }
+ public int getLineNumber() {
+ return linNum;
+ }
+ public String getPublicId() {
+ return pubId;
+ }
+ public String getSystemId() {
+ return sysId;
+ }
+ };
+ node.setUserData("location", loc2, LocationUserDataHandler.INSTANCE);
+ } catch (Throwable ex) {
+ //possibly not DOM level 3, won't be able to record this then
+ return false;
+ }
+ }
+ return recordLoc;
+ }
+
+ private static boolean addLocation(Document doc, Node node,
+ XMLStreamReader reader,
+ boolean recordLoc) {
+ return addLocation(doc, node, reader.getLocation(), recordLoc);
+ }
+
+ private static class LocationUserDataHandler implements UserDataHandler {
+ public static final LocationUserDataHandler INSTANCE = new LocationUserDataHandler();
+
+ public void handle(short operation, String key, Object data, Node src, Node dst) {
+ if (operation == NODE_CLONED) {
+ dst.setUserData(key, data, this);
+ }
+ }
+ }
+
+ private static void declare(Element node, String uri, String prefix) {
+ String qualname;
+ if (prefix != null && prefix.length() > 0) {
+ qualname = "xmlns:" + prefix;
+ } else {
+ qualname = "xmlns";
+ }
+ Attr attr = node.getOwnerDocument().createAttributeNS(XML_NS, qualname);
+ attr.setValue(uri);
+ node.setAttributeNodeNS(attr);
+ }
+ public static XMLStreamReader createXMLStreamReader(InputSource src) {
+ String sysId = src.getSystemId() == null ? null : src.getSystemId();
+ String pubId = src.getPublicId() == null ? null : src.getPublicId();
+ if (src.getByteStream() != null) {
+ final InputStream is = src.getByteStream();
+
+ if (src.getEncoding() == null) {
+ final StreamSource ss = new StreamSource(is, sysId);
+ ss.setPublicId(pubId);
+
+ final XMLStreamReader xmlStreamReader = createXMLStreamReader(ss);
+ if (AUTO_CLOSE_INPUT_SOURCE) {
+ return new AutoCloseableXMLStreamReader(xmlStreamReader, is);
+ } else {
+ return xmlStreamReader;
+ }
+ }
+
+ return new AutoCloseableXMLStreamReader(createXMLStreamReader(is, src.getEncoding()), is);
+ } else if (src.getCharacterStream() != null) {
+ final Reader reader = src.getCharacterStream();
+ final StreamSource ss = new StreamSource(reader, sysId);
+ ss.setPublicId(pubId);
+ final XMLStreamReader xmlStreamReader = createXMLStreamReader(ss);
+ if (AUTO_CLOSE_INPUT_SOURCE) {
+ return new AutoCloseableXMLStreamReader(xmlStreamReader, reader);
+ } else {
+ return xmlStreamReader;
+ }
+ } else {
+ try {
+ final URL url = new URL(sysId);
+ final InputStream is = url.openStream();
+ final StreamSource ss = new StreamSource(is, sysId);
+ ss.setPublicId(pubId);
+ return new AutoCloseableXMLStreamReader(createXMLStreamReader(ss), is);
+ } catch (Exception ex) {
+ //ignore - not a valid URL
+ }
+ }
+ throw new IllegalArgumentException("InputSource must have a ByteStream or CharacterStream");
+ }
+ /**
+ * @param in
+ * @param encoding
+ */
+ public static XMLStreamReader createXMLStreamReader(InputStream in, String encoding) {
+ XMLInputFactory factory = getXMLInputFactory();
+ try {
+ return factory.createXMLStreamReader(in, encoding != null ? encoding : StandardCharsets.UTF_8.name());
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ } finally {
+ returnXMLInputFactory(factory);
+ }
+ }
+
+ /**
+ * @param in
+ */
+ public static XMLStreamReader createXMLStreamReader(InputStream in) {
+ XMLInputFactory factory = getXMLInputFactory();
+ try {
+ return factory.createXMLStreamReader(in);
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ } finally {
+ returnXMLInputFactory(factory);
+ }
+ }
+ public static XMLStreamReader createXMLStreamReader(String systemId, InputStream in) {
+ XMLInputFactory factory = getXMLInputFactory();
+ try {
+ return factory.createXMLStreamReader(systemId, in);
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ } finally {
+ returnXMLInputFactory(factory);
+ }
+ }
+
+ public static XMLStreamReader createXMLStreamReader(Element el) {
+ return new W3CDOMStreamReader(el);
+ }
+ public static XMLStreamReader createXMLStreamReader(Document doc) {
+ return new W3CDOMStreamReader(doc.getDocumentElement());
+ }
+ public static XMLStreamReader createXMLStreamReader(Element el, String sysId) {
+ return new W3CDOMStreamReader(el, sysId);
+ }
+ public static XMLStreamReader createXMLStreamReader(Document doc, String sysId) {
+ return new W3CDOMStreamReader(doc.getDocumentElement(), sysId);
+ }
+
+ public static XMLStreamReader createXMLStreamReader(Source source) {
+ try {
+ if (source instanceof DOMSource) {
+ DOMSource ds = (DOMSource)source;
+ Node nd = ds.getNode();
+ Element el = null;
+ if (nd instanceof Document) {
+ el = ((Document)nd).getDocumentElement();
+ } else if (nd instanceof Element) {
+ el = (Element)nd;
+ }
+
+ if (null != el) {
+ return new W3CDOMStreamReader(el, source.getSystemId());
+ }
+ } else if (source instanceof StAXSource) {
+ return ((StAXSource)source).getXMLStreamReader();
+ } else if (source instanceof StaxSource) {
+ return ((StaxSource)source).getXMLStreamReader();
+ } else if (source instanceof SAXSource) {
+ SAXSource ss = (SAXSource)source;
+ if (ss.getXMLReader() == null) {
+ return createXMLStreamReader(((SAXSource)source).getInputSource());
+ }
+ }
+
+ XMLInputFactory factory = getXMLInputFactory();
+ try {
+ XMLStreamReader reader = null;
+
+ try {
+ reader = factory.createXMLStreamReader(source);
+ } catch (UnsupportedOperationException e) {
+ //ignore
+ }
+ if (reader == null && source instanceof StreamSource) {
+ //createXMLStreamReader from Source is optional, we'll try and map it
+ StreamSource ss = (StreamSource)source;
+ if (ss.getInputStream() != null) {
+ reader = factory.createXMLStreamReader(ss.getSystemId(),
+ ss.getInputStream());
+ } else {
+ reader = factory.createXMLStreamReader(ss.getSystemId(),
+ ss.getReader());
+ }
+ }
+ return reader;
+ } finally {
+ returnXMLInputFactory(factory);
+ }
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ }
+ }
+
+ /**
+ * @param reader
+ */
+ public static XMLStreamReader createXMLStreamReader(Reader reader) {
+ XMLInputFactory factory = getXMLInputFactory();
+ try {
+ return factory.createXMLStreamReader(reader);
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Couldn't parse stream.", e);
+ } finally {
+ returnXMLInputFactory(factory);
+ }
+ }
+
+ /**
+ * Reads a QName from the element text. Reader must be positioned at the
+ * start tag.
+ */
+ public static QName readQName(XMLStreamReader reader) throws XMLStreamException {
+ String value = reader.getElementText();
+ if (value == null) {
+ return null;
+ }
+ value = value.trim();
+
+ int index = value.indexOf(':');
+
+ if (index == -1) {
+ return new QName(value);
+ }
+
+ String prefix = value.substring(0, index);
+ String localName = value.substring(index + 1);
+ String ns = reader.getNamespaceURI(prefix);
+
+ if (!StringUtils.isEmpty(prefix) && ns == null) {
+ throw new RuntimeException("Invalid QName in mapping: " + value);
+ }
+
+ if (ns == null) {
+ return new QName(localName);
+ }
+
+ return new QName(ns, localName, prefix);
+ }
+
+ /**
+ * Create a unique namespace uri/prefix combination.
+ *
+ * @return The namespace with the specified URI. If one doesn't exist, one
+ * is created.
+ * @throws XMLStreamException
+ */
+ public static String getUniquePrefix(XMLStreamWriter writer, String namespaceURI, boolean declare)
+ throws XMLStreamException {
+ String prefix = writer.getPrefix(namespaceURI);
+ if (prefix == null) {
+ prefix = getUniquePrefix(writer);
+
+ if (declare) {
+ writer.setPrefix(prefix, namespaceURI);
+ writer.writeNamespace(prefix, namespaceURI);
+ }
+ }
+ return prefix;
+ }
+ public static String getUniquePrefix(XMLStreamWriter writer, String namespaceURI)
+ throws XMLStreamException {
+ return getUniquePrefix(writer, namespaceURI, false);
+ }
+ public static String getUniquePrefix(XMLStreamWriter writer) {
+ NamespaceContext nc = writer.getNamespaceContext();
+ if (nc == null) {
+ return DEF_PREFIXES[0];
+ }
+ for (String t : DEF_PREFIXES) {
+ String uri = nc.getNamespaceURI(t);
+ if (StringUtils.isEmpty(uri)) {
+ return t;
+ }
+ }
+
+ int n = 10;
+ while (true) {
+ String nsPrefix = "ns" + n;
+ String uri = nc.getNamespaceURI(nsPrefix);
+ if (StringUtils.isEmpty(uri)) {
+ return nsPrefix;
+ }
+ n++;
+ }
+ }
+
+
+ public static void printXmlFragment(XMLStreamReader reader) {
+ try {
+ StringWriter sw = new StringWriter(1024);
+ XMLStreamWriter writer = null;
+ try {
+ writer = new PrettyPrintXMLStreamWriter(createXMLStreamWriter(sw), 4);
+ copy(reader, writer);
+ writer.flush();
+ } finally {
+ StaxUtils.close(writer);
+ }
+ LOG.info(sw.toString());
+ } catch (XMLStreamException e) {
+ LOG.severe(e.getMessage());
+ }
+ }
+
+
+ private static void writeStartElementEvent(XMLEvent event, XMLStreamWriter writer)
+ throws XMLStreamException {
+ StartElement start = event.asStartElement();
+ QName name = start.getName();
+ String nsURI = name.getNamespaceURI();
+ String localName = name.getLocalPart();
+ String prefix = name.getPrefix();
+
+ if (prefix != null) {
+ writer.writeStartElement(prefix, localName, nsURI);
+ } else if (nsURI != null) {
+ writer.writeStartElement(localName, nsURI);
+ } else {
+ writer.writeStartElement(localName);
+ }
+ Iterator<XMLEvent> it = CastUtils.cast(start.getNamespaces());
+ while (it != null && it.hasNext()) {
+ writeEvent(it.next(), writer);
+ }
+
+ it = CastUtils.cast(start.getAttributes());
+ while (it != null && it.hasNext()) {
+ writeAttributeEvent(it.next(), writer);
+ }
+ }
+ private static void writeAttributeEvent(XMLEvent event, XMLStreamWriter writer)
+ throws XMLStreamException {
+
+ Attribute attr = (Attribute)event;
+ QName name = attr.getName();
+ String nsURI = name.getNamespaceURI();
+ String localName = name.getLocalPart();
+ String prefix = name.getPrefix();
+ String value = attr.getValue();
+
+ if (prefix != null) {
+ writer.writeAttribute(prefix, nsURI, localName, value);
+ } else if (nsURI != null) {
+ writer.writeAttribute(nsURI, localName, value);
+ } else {
+ writer.writeAttribute(localName, value);
+ }
+ }
+
+ public static void writeEvent(XMLEvent event, XMLStreamWriter writer)
+ throws XMLStreamException {
+
+ switch (event.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ writeStartElementEvent(event, writer);
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ writer.writeEndElement();
+ break;
+ case XMLStreamConstants.ATTRIBUTE:
+ writeAttributeEvent(event, writer);
+ break;
+ case XMLStreamConstants.ENTITY_REFERENCE:
+ writer.writeEntityRef(((javax.xml.stream.events.EntityReference)event).getName());
+ break;
+ case XMLStreamConstants.DTD:
+ writer.writeDTD(((DTD)event).getDocumentTypeDeclaration());
+ break;
+ case XMLStreamConstants.PROCESSING_INSTRUCTION:
+ if (((javax.xml.stream.events.ProcessingInstruction)event).getData() != null) {
+ writer.writeProcessingInstruction(
+ ((javax.xml.stream.events.ProcessingInstruction)event).getTarget(),
+ ((javax.xml.stream.events.ProcessingInstruction)event).getData());
+ } else {
+ writer.writeProcessingInstruction(
+ ((javax.xml.stream.events.ProcessingInstruction)event).getTarget());
+ }
+ break;
+ case XMLStreamConstants.NAMESPACE:
+ if (((Namespace)event).isDefaultNamespaceDeclaration()) {
+ writer.writeDefaultNamespace(((Namespace)event).getNamespaceURI());
+ writer.setDefaultNamespace(((Namespace)event).getNamespaceURI());
+ } else {
+ writer.writeNamespace(((Namespace)event).getPrefix(),
+ ((Namespace)event).getNamespaceURI());
+ writer.setPrefix(((Namespace)event).getPrefix(),
+ ((Namespace)event).getNamespaceURI());
+ }
+ break;
+ case XMLStreamConstants.COMMENT:
+ writer.writeComment(((javax.xml.stream.events.Comment)event).getText());
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ case XMLStreamConstants.SPACE:
+ writer.writeCharacters(event.asCharacters().getData());
+ break;
+ case XMLStreamConstants.CDATA:
+ writer.writeCData(event.asCharacters().getData());
+ break;
+ case XMLStreamConstants.START_DOCUMENT:
+ if (((StartDocument)event).encodingSet()) {
+ writer.writeStartDocument(((StartDocument)event).getCharacterEncodingScheme(),
+ ((StartDocument)event).getVersion());
+
+ } else {
+ writer.writeStartDocument(((StartDocument)event).getVersion());
+ }
+ break;
+ case XMLStreamConstants.END_DOCUMENT:
+ writer.writeEndDocument();
+ break;
+ default:
+ //shouldn't get here
+ }
+ }
+ public static void print(Node node) {
+ XMLStreamWriter writer = null;
+ try {
+ writer = createXMLStreamWriter(System.out);
+ copy(new DOMSource(node), writer);
+ writer.flush();
+ } catch (XMLStreamException e) {
+ throw new RuntimeException(e);
+ } finally {
+ StaxUtils.close(writer);
+ }
+ }
+
+ public static String toString(Source src) {
+ StringWriter sw = new StringWriter(1024);
+ XMLStreamWriter writer = null;
+ try {
+ writer = createXMLStreamWriter(sw);
+ copy(src, writer);
+ writer.flush();
+ } catch (XMLStreamException e) {
+ throw new RuntimeException(e);
+ } finally {
+ StaxUtils.close(writer);
+ }
+ return sw.toString();
+ }
+ public static String toString(Node src) {
+ return toString(new DOMSource(src));
+ }
+ public static String toString(Document doc) {
+ StringWriter sw = new StringWriter(1024);
+ XMLStreamWriter writer = null;
+ try {
+ writer = createXMLStreamWriter(sw);
+ copy(doc, writer);
+ writer.flush();
+ } catch (XMLStreamException e) {
+ throw new RuntimeException(e);
+ } finally {
+ StaxUtils.close(writer);
+ }
+ return sw.toString();
+ }
+ public static String toString(Element el) {
+ return toString(el, 0);
+ }
+ public static String toString(Element el, int indent) {
+ StringWriter sw = new StringWriter(1024);
+ XMLStreamWriter writer = null;
+ try {
+ writer = createXMLStreamWriter(sw);
+ if (indent > 0) {
+ writer = new PrettyPrintXMLStreamWriter(writer, indent);
+ }
+ copy(el, writer);
+ writer.flush();
+ } catch (XMLStreamException e) {
+ throw new RuntimeException(e);
+ } finally {
+ StaxUtils.close(writer);
+ }
+ return sw.toString();
+ }
+ public static void close(XMLStreamReader reader) throws XMLStreamException {
+ if (reader != null) {
+ reader.close();
+ }
+ }
+
+ public static void close(XMLStreamWriter writer) {
+ if (writer != null) {
+ try {
+ writer.close();
+ } catch (Exception e) {
+ //ignore
+ }
+ }
+ }
+
+ public static boolean isSecureReader(XMLStreamReader reader, Message message) {
+ if (reader instanceof DocumentDepthProperties) {
+ return true;
+ }
+ try {
+ if (reader.getProperty(P_MAX_CHILDREN_PER_ELEMENT) != null) {
+ return true;
+ }
+ } catch (Exception ex) {
+ //ignore
+ }
+ return false;
+ }
+
+ public static XMLStreamReader configureReader(XMLStreamReader xreader, Message message) throws XMLStreamException {
+ Integer messageMaxChildElements = PropertyUtils.getInteger(message, MAX_CHILD_ELEMENTS);
+ Integer messageMaxElementDepth = PropertyUtils.getInteger(message, MAX_ELEMENT_DEPTH);
+ Integer messageMaxAttributeCount = PropertyUtils.getInteger(message, MAX_ATTRIBUTE_COUNT);
+ Integer messageMaxAttributeSize = PropertyUtils.getInteger(message, MAX_ATTRIBUTE_SIZE);
+ Integer messageMaxTextLength = PropertyUtils.getInteger(message, MAX_TEXT_LENGTH);
+ Long messageMaxElementCount = PropertyUtils.getLong(message, MAX_ELEMENT_COUNT);
+ Long messageMaxXMLCharacters = PropertyUtils.getLong(message, MAX_XML_CHARACTERS);
+ return configureReader(xreader, messageMaxChildElements, messageMaxElementDepth,
+ messageMaxAttributeCount, messageMaxAttributeSize, messageMaxTextLength,
+ messageMaxElementCount, messageMaxXMLCharacters);
+ }
+
+ //CHECKSTYLE:OFF - lots of params to configure
+ public static XMLStreamReader configureReader(XMLStreamReader reader, Integer maxChildElements,
+ Integer maxElementDepth, Integer maxAttributeCount,
+ Integer maxAttributeSize, Integer maxTextLength,
+ Long maxElementCount, Long maxXMLCharacters)
+ throws XMLStreamException {
+ //CHECKSTYLE:ON
+
+ // We currently ONLY support Woodstox 4.2.x for most of this other than a few things
+ // that we can handle via a wrapper.
+ try {
+ DocumentDepthProperties p = null;
+ if (maxChildElements != null) {
+ try {
+ setProperty(reader, P_MAX_CHILDREN_PER_ELEMENT, maxChildElements);
+ } catch (Throwable t) {
+ //we can handle this via a wrapper
+ p = new DocumentDepthProperties();
+ p.setInnerElementCountThreshold(maxChildElements);
+ }
+ }
+ if (maxElementDepth != null) {
+ try {
+ setProperty(reader, P_MAX_ELEMENT_DEPTH, maxElementDepth);
+ } catch (Throwable t) {
+ //we can handle this via a wrapper
+ if (p == null) {
+ p = new DocumentDepthProperties();
+ }
+ p.setInnerElementLevelThreshold(maxElementDepth);
+ }
+ }
+ if (maxAttributeCount != null) {
+ setProperty(reader, P_MAX_ATTRIBUTES_PER_ELEMENT, maxAttributeCount);
+ }
+ if (maxAttributeSize != null) {
+ setProperty(reader, P_MAX_ATTRIBUTE_SIZE, maxAttributeSize);
+ }
+ if (maxTextLength != null) {
+ setProperty(reader, P_MAX_TEXT_LENGTH, maxTextLength);
+ }
+ if (maxElementCount != null) {
+ try {
+ setProperty(reader, P_MAX_ELEMENT_COUNT, maxElementCount);
+ } catch (Throwable t) {
+ //we can handle this via a wrapper
+ if (p == null) {
+ p = new DocumentDepthProperties();
+ }
+ p.setElementCountThreshold(maxElementCount.intValue());
+ }
+ }
+ if (maxXMLCharacters != null) {
+ setProperty(reader, P_MAX_CHARACTERS, maxXMLCharacters);
+ }
+ if (p != null) {
+ reader = new DepthRestrictingStreamReader(reader, p);
+ }
+ } catch (ClassCastException cce) {
+ //not an XMLStreamReader2
+ if (ALLOW_INSECURE_PARSER_VAL) {
+ LOG.warning("INSTANCE_NOT_XMLSTREAMREADER2");
+ } else {
+ throw new XMLStreamException(cce.getMessage(), cce);
+ }
+ } catch (IllegalArgumentException cce) {
+ //not a property supported by this version of woodstox
+ if (ALLOW_INSECURE_PARSER_VAL) {
+ LOG.log(Level.WARNING, "SECURE_PROPERTY_NOT_SUPPORTED", cce.getMessage());
+ } else {
+ throw new XMLStreamException(cce.getMessage(), cce);
+ }
+ }
+ return reader;
+ }
+ private static void setProperty(XMLStreamReader reader, String p, Object v) {
+ WoodstoxHelper.setProperty(reader, p, v);
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/staxutils/W3CDOMStreamReader.java b/transform/src/patch/java/org/apache/cxf/staxutils/W3CDOMStreamReader.java
new file mode 100644
index 0000000..03b1992
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/staxutils/W3CDOMStreamReader.java
@@ -0,0 +1,429 @@
+/**
+ * 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.cxf.staxutils;
+
+import java.util.ArrayList;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.stream.Location;
+import javax.xml.stream.XMLStreamException;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Comment;
+import org.w3c.dom.Document;
+import org.w3c.dom.DocumentFragment;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.ProcessingInstruction;
+import org.w3c.dom.Text;
+import org.w3c.dom.TypeInfo;
+
+import org.apache.cxf.helpers.DOMUtils;
+
+public class W3CDOMStreamReader extends AbstractDOMStreamReader<Node, Node> {
+ private Node content;
+
+ private Document document;
+
+ private W3CNamespaceContext context;
+
+ private String sysId;
+
+ /**
+ * @param element
+ */
+ public W3CDOMStreamReader(Element element) {
+ super(new ElementFrame<Node, Node>(element, null));
+ content = element;
+ newFrame(getCurrentFrame());
+
+ this.document = element.getOwnerDocument();
+ }
+ public W3CDOMStreamReader(Element element, String systemId) {
+ this(element);
+ sysId = systemId;
+ }
+ public W3CDOMStreamReader(Document doc) {
+ super(new ElementFrame<Node, Node>(doc, false) {
+ public boolean isDocument() {
+ return true;
+ }
+ });
+ this.document = doc;
+ }
+ public W3CDOMStreamReader(DocumentFragment docfrag) {
+ super(new ElementFrame<Node, Node>(docfrag, true) {
+ public boolean isDocumentFragment() {
+ return true;
+ }
+ });
+ this.document = docfrag.getOwnerDocument();
+ }
+
+ /**
+ * Get the document associated with this stream.
+ */
+ public Document getDocument() {
+ return document;
+ }
+ public String getSystemId() {
+ try {
+ return sysId == null ? document.getDocumentURI() : sysId;
+ } catch (Throwable ex) {
+ //ignore, probably not DOM level 3
+ }
+ return sysId;
+ }
+ /**
+ * Find name spaces declaration in atrributes and move them to separate
+ * collection.
+ */
+ @Override
+ protected final void newFrame(ElementFrame<Node, Node> frame) {
+ Node element = getCurrentNode();
+ frame.uris = new ArrayList<>();
+ frame.prefixes = new ArrayList<>();
+ frame.attributes = new ArrayList<>();
+
+ if (context == null) {
+ context = new W3CNamespaceContext();
+ }
+ if (element instanceof Element) {
+ context.setElement((Element)element);
+ }
+
+ NamedNodeMap nodes = element.getAttributes();
+
+ if (nodes != null) {
+ for (int i = 0; i < nodes.getLength(); i++) {
+ Node node = nodes.item(i);
+ String prefix = node.getPrefix();
+ String localName = node.getLocalName();
+ String value = node.getNodeValue();
+ String name = node.getNodeName();
+
+ if (prefix == null) {
+ prefix = "";
+ }
+
+ if ("xmlns".equals(name)) {
+ frame.uris.add(value);
+ frame.prefixes.add("");
+ } else if (!prefix.isEmpty() && "xmlns".equals(prefix)) {
+ frame.uris.add(value);
+ frame.prefixes.add(localName);
+ } else if (name.startsWith("xmlns:")) {
+ frame.uris.add(value);
+ frame.prefixes.add(name.substring(6));
+ } else {
+ frame.attributes.add(node);
+ }
+ }
+ }
+ }
+
+ public final Node getCurrentNode() {
+ return getCurrentFrame().element;
+ }
+ public final Element getCurrentElement() {
+ return (Element)getCurrentFrame().element;
+ }
+
+ @Override
+ protected ElementFrame<Node, Node> getChildFrame() {
+ return new ElementFrame<Node, Node>(getCurrentFrame().currentChild,
+ getCurrentFrame());
+ }
+
+ @Override
+ protected boolean hasMoreChildren() {
+ if (getCurrentFrame().currentChild == null) {
+ return getCurrentNode().getFirstChild() != null;
+ }
+ return getCurrentFrame().currentChild.getNextSibling() != null;
+ }
+
+ @Override
+ protected int nextChild() {
+ ElementFrame<Node, Node> frame = getCurrentFrame();
+ if (frame.currentChild == null) {
+ content = getCurrentNode().getFirstChild();
+ } else {
+ content = frame.currentChild.getNextSibling();
+ }
+
+ frame.currentChild = content;
+ switch (content.getNodeType()) {
+ case Node.ELEMENT_NODE:
+ return START_ELEMENT;
+ case Node.TEXT_NODE:
+ return CHARACTERS;
+ case Node.COMMENT_NODE:
+ return COMMENT;
+ case Node.CDATA_SECTION_NODE:
+ return CDATA;
+ case Node.ENTITY_REFERENCE_NODE:
+ return ENTITY_REFERENCE;
+ case Node.PROCESSING_INSTRUCTION_NODE:
+ return PROCESSING_INSTRUCTION;
+ default:
+ throw new IllegalStateException("Found type: " + content.getClass().getName());
+ }
+ }
+
+ @Override
+ public String getElementText() throws XMLStreamException {
+ String result = DOMUtils.getRawContent(content);
+
+ ElementFrame<Node, Node> frame = getCurrentFrame();
+ frame.ended = true;
+ currentEvent = END_ELEMENT;
+ endElement();
+
+ // we should not return null according to the StAx API javadoc
+ return result != null ? result : "";
+ }
+
+ @Override
+ public String getNamespaceURI(String prefix) {
+ ElementFrame<Node, Node> frame = getCurrentFrame();
+
+ while (null != frame) {
+ int index = frame.prefixes.indexOf(prefix);
+ if (index != -1) {
+ return frame.uris.get(index);
+ }
+
+ if (frame.parent == null && frame.getElement() instanceof Element) {
+ return ((Element)frame.getElement()).lookupNamespaceURI(prefix);
+ }
+ frame = frame.parent;
+ }
+
+ return null;
+ }
+
+ public String getAttributeValue(String ns, String local) {
+ Attr at;
+ if (ns == null || ns.isEmpty()) {
+ at = getCurrentElement().getAttributeNode(local);
+ } else {
+ at = getCurrentElement().getAttributeNodeNS(ns, local);
+ }
+
+ if (at == null) {
+ return null;
+ }
+ return at.getNodeValue();
+ }
+
+ public int getAttributeCount() {
+ return getCurrentFrame().attributes.size();
+ }
+
+ Attr getAttribute(int i) {
+ return (Attr)getCurrentFrame().attributes.get(i);
+ }
+
+ private String getLocalName(Attr attr) {
+
+ String name = attr.getLocalName();
+ if (name == null) {
+ name = attr.getNodeName();
+ }
+ return name;
+ }
+
+ public QName getAttributeName(int i) {
+ Attr at = getAttribute(i);
+
+ String prefix = at.getPrefix();
+ String ln = getLocalName(at);
+ // at.getNodeName();
+ String ns = at.getNamespaceURI();
+
+ if (prefix == null) {
+ return new QName(ns, ln);
+ }
+ return new QName(ns, ln, prefix);
+ }
+
+ public String getAttributeNamespace(int i) {
+ return getAttribute(i).getNamespaceURI();
+ }
+
+ public String getAttributeLocalName(int i) {
+ Attr attr = getAttribute(i);
+ return getLocalName(attr);
+ }
+
+ public String getAttributePrefix(int i) {
+ return getAttribute(i).getPrefix();
+ }
+
+ public String getAttributeType(int i) {
+ Attr attr = getAttribute(i);
+ if (attr.isId()) {
+ return "ID";
+ }
+ TypeInfo schemaType = null;
+ try {
+ schemaType = attr.getSchemaTypeInfo();
+ } catch (Throwable t) {
+ //DOM level 2?
+ }
+ return (schemaType == null) ? "CDATA"
+ : schemaType.getTypeName() == null ? "CDATA" : schemaType.getTypeName();
+ }
+
+
+ public String getAttributeValue(int i) {
+ return getAttribute(i).getValue();
+ }
+
+ public boolean isAttributeSpecified(int i) {
+ return getAttribute(i).getValue() != null;
+ }
+
+ public int getNamespaceCount() {
+ return getCurrentFrame().prefixes.size();
+ }
+
+ public String getNamespacePrefix(int i) {
+ return getCurrentFrame().prefixes.get(i);
+ }
+
+ public String getNamespaceURI(int i) {
+ return getCurrentFrame().uris.get(i);
+ }
+
+ public NamespaceContext getNamespaceContext() {
+ return context;
+ }
+
+ public String getText() {
+ if (content instanceof Text) {
+ return ((Text)content).getData();
+ } else if (content instanceof Comment) {
+ return ((Comment)content).getData();
+ }
+ return DOMUtils.getRawContent(getCurrentNode());
+ }
+
+ public char[] getTextCharacters() {
+ return getText().toCharArray();
+ }
+
+ public int getTextStart() {
+ return 0;
+ }
+
+ public int getTextLength() {
+ return getText().length();
+ }
+
+ public String getEncoding() {
+ return null;
+ }
+
+ public QName getName() {
+ Node el = getCurrentNode();
+
+ String prefix = getPrefix();
+ String ln = getLocalName();
+
+ return new QName(el.getNamespaceURI(), ln, prefix);
+ }
+
+ public String getLocalName() {
+ String ln = getCurrentNode().getLocalName();
+ if (ln == null) {
+ ln = getCurrentNode().getNodeName();
+ if (ln.indexOf(':') != -1) {
+ ln = ln.substring(ln.indexOf(':') + 1);
+ }
+ }
+ return ln;
+ }
+
+ public String getNamespaceURI() {
+ String ln = getCurrentNode().getLocalName();
+ if (ln == null) {
+ ln = getCurrentNode().getNodeName();
+ if (ln.indexOf(':') == -1) {
+ ln = getNamespaceURI("");
+ } else {
+ ln = getNamespaceURI(ln.substring(0, ln.indexOf(':')));
+ }
+ return ln;
+ }
+ return getCurrentNode().getNamespaceURI();
+ }
+
+ public String getPrefix() {
+ String prefix = getCurrentNode().getPrefix();
+ if (prefix == null) {
+ String nodeName = getCurrentNode().getNodeName();
+ if (nodeName.indexOf(':') != -1) {
+ prefix = nodeName.substring(0, nodeName.indexOf(':'));
+ } else {
+ prefix = "";
+ }
+ }
+ return prefix;
+ }
+
+ public String getPITarget() {
+ return ((ProcessingInstruction)content).getTarget();
+ }
+
+ public String getPIData() {
+ return ((ProcessingInstruction)content).getData();
+ }
+ public Location getLocation() {
+ try {
+ Object o = getCurrentNode().getUserData("location");
+ if (o instanceof Location) {
+ return (Location)o;
+ }
+ } catch (Throwable ex) {
+ //ignore, probably not DOM level 3
+ }
+ return super.getLocation();
+ }
+
+ public String toString() {
+ if (document == null) {
+ return "<null>";
+ }
+ if (document.getDocumentElement() == null) {
+ return "<null document element>";
+ }
+ try {
+ return StaxUtils.toString(document);
+ } catch (Throwable t) {
+ t.printStackTrace();
+ return super.toString();
+ }
+ }
+
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/transport/ChainInitiationObserver.java b/transform/src/patch/java/org/apache/cxf/transport/ChainInitiationObserver.java
new file mode 100644
index 0000000..a4b8aa3
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/transport/ChainInitiationObserver.java
@@ -0,0 +1,197 @@
+/**
+ * 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.cxf.transport;
+
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Collection;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.binding.Binding;
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.classloader.ClassLoaderUtils.ClassLoaderHolder;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.interceptor.Interceptor;
+import org.apache.cxf.interceptor.InterceptorChain;
+import org.apache.cxf.interceptor.InterceptorProvider;
+import org.apache.cxf.message.Exchange;
+import org.apache.cxf.message.ExchangeImpl;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.PhaseChainCache;
+import org.apache.cxf.phase.PhaseManager;
+import org.apache.cxf.service.Service;
+import org.apache.cxf.service.model.EndpointInfo;
+
+public class ChainInitiationObserver implements MessageObserver {
+ protected Endpoint endpoint;
+ protected Bus bus;
+ protected ClassLoader loader;
+
+ private PhaseChainCache chainCache = new PhaseChainCache();
+
+ public ChainInitiationObserver(Endpoint endpoint, Bus bus) {
+ super();
+ this.endpoint = endpoint;
+ this.bus = bus;
+ if (bus != null) {
+ loader = bus.getExtension(ClassLoader.class);
+ }
+ }
+
+ public void onMessage(Message m) {
+ Bus origBus = BusFactory.getAndSetThreadDefaultBus(bus);
+ ClassLoaderHolder origLoader = null;
+ try {
+ if (loader != null) {
+ origLoader = ClassLoaderUtils.setThreadContextClassloader(loader);
+ }
+ InterceptorChain phaseChain;
+
+ if (m.getInterceptorChain() != null) {
+ phaseChain = m.getInterceptorChain();
+ // To make sure the phase chain is run by one thread once
+ synchronized (phaseChain) {
+ if (phaseChain.getState() == InterceptorChain.State.PAUSED
+ || phaseChain.getState() == InterceptorChain.State.SUSPENDED) {
+ phaseChain.resume();
+ return;
+ }
+ }
+ }
+
+ Message message = getBinding().createMessage(m);
+ Exchange exchange = message.getExchange();
+ if (exchange == null) {
+ exchange = new ExchangeImpl();
+ m.setExchange(exchange);
+ }
+ exchange.setInMessage(message);
+ setExchangeProperties(exchange, message);
+
+ InterceptorProvider dbp = null;
+ if (endpoint.getService().getDataBinding() instanceof InterceptorProvider) {
+ dbp = (InterceptorProvider)endpoint.getService().getDataBinding();
+ }
+ // setup chain
+ if (dbp == null) {
+ phaseChain = chainCache.get(bus.getExtension(PhaseManager.class).getInPhases(),
+ bus.getInInterceptors(),
+ endpoint.getService().getInInterceptors(),
+ endpoint.getInInterceptors(),
+ getBinding().getInInterceptors());
+ } else {
+ phaseChain = chainCache.get(bus.getExtension(PhaseManager.class).getInPhases(),
+ bus.getInInterceptors(),
+ endpoint.getService().getInInterceptors(),
+ endpoint.getInInterceptors(),
+ getBinding().getInInterceptors(),
+ dbp.getInInterceptors());
+ }
+
+
+
+ message.setInterceptorChain(phaseChain);
+
+ phaseChain.setFaultObserver(endpoint.getOutFaultObserver());
+
+ addToChain(phaseChain, message);
+
+ phaseChain.doIntercept(message);
+
+ } finally {
+ if (origBus != bus) {
+ BusFactory.setThreadDefaultBus(origBus);
+ }
+ if (origLoader != null) {
+ origLoader.reset();
+ }
+ }
+ }
+ private void addToChain(InterceptorChain chain, Message m) {
+ Collection<InterceptorProvider> providers
+ = CastUtils.cast((Collection<?>)m.get(Message.INTERCEPTOR_PROVIDERS));
+ if (providers != null) {
+ for (InterceptorProvider p : providers) {
+ chain.add(p.getInInterceptors());
+ }
+ }
+ Collection<Interceptor<? extends Message>> is
+ = CastUtils.cast((Collection<?>)m.get(Message.IN_INTERCEPTORS));
+ if (is != null) {
+ chain.add(is);
+ }
+ if (m.getDestination() instanceof InterceptorProvider) {
+ chain.add(((InterceptorProvider)m.getDestination()).getInInterceptors());
+ }
+ }
+
+ protected Binding getBinding() {
+ return endpoint.getBinding();
+ }
+
+ protected void setExchangeProperties(Exchange exchange, Message m) {
+ exchange.put(Endpoint.class, endpoint);
+ exchange.put(Binding.class, getBinding());
+ exchange.put(Bus.class, bus);
+ if (exchange.getDestination() == null) {
+ exchange.setDestination(m.getDestination());
+ }
+ if (endpoint != null && endpoint.getService() != null) {
+ exchange.put(Service.class, endpoint.getService());
+
+ EndpointInfo endpointInfo = endpoint.getEndpointInfo();
+
+ if (endpointInfo.getService() != null) {
+ QName serviceQName = endpointInfo.getService().getName();
+ exchange.put(Message.WSDL_SERVICE, serviceQName);
+
+ QName interfaceQName = endpointInfo.getService().getInterface().getName();
+ exchange.put(Message.WSDL_INTERFACE, interfaceQName);
+
+
+ QName portQName = endpointInfo.getName();
+ exchange.put(Message.WSDL_PORT, portQName);
+ URI wsdlDescription = endpointInfo.getProperty("URI", URI.class);
+ if (wsdlDescription == null && !endpointInfo.hasProperty("URI")) {
+ String address = endpointInfo.getAddress();
+ try {
+ wsdlDescription = new URI(address + "?wsdl");
+ } catch (URISyntaxException e) {
+ // do nothing
+ }
+ endpointInfo.setProperty("URI", wsdlDescription);
+ }
+ exchange.put(Message.WSDL_DESCRIPTION, wsdlDescription);
+ }
+ } else {
+ exchange.put(Service.class, null);
+ }
+ }
+
+ public Endpoint getEndpoint() {
+ return endpoint;
+ }
+
+}
diff --git a/transform/src/patch/java/org/apache/cxf/validation/AbstractBeanValidationInterceptor.java b/transform/src/patch/java/org/apache/cxf/validation/AbstractBeanValidationInterceptor.java
new file mode 100644
index 0000000..3fecf1a
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/validation/AbstractBeanValidationInterceptor.java
@@ -0,0 +1,65 @@
+/**
+ * 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.cxf.validation;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import javax.validation.ValidationException;
+
+import org.apache.cxf.message.Message;
+
+public abstract class AbstractBeanValidationInterceptor extends AbstractValidationInterceptor {
+ protected AbstractBeanValidationInterceptor(String phase) {
+ super(phase);
+ }
+
+ @Override
+ protected Object getServiceObject(Message message) {
+ return checkNotNull(super.getServiceObject(message), "SERVICE_OBJECT_NULL");
+ }
+
+ @Override
+ protected Method getServiceMethod(Message message) {
+ return (Method)checkNotNull(super.getServiceMethod(message), "SERVICE_METHOD_NULL");
+ }
+
+ private Object checkNotNull(Object object, String name) {
+ if (object == null) {
+ String message = new org.apache.cxf.common.i18n.Message(name, BUNDLE).toString();
+ LOG.severe(message);
+ throw new ValidationException(message);
+ }
+ return object;
+ }
+
+ @Override
+ protected void handleValidation(final Message message, final Object resourceInstance,
+ final Method method, final List<Object> arguments) {
+ if (!arguments.isEmpty()) {
+ BeanValidationProvider provider = getProvider(message);
+ provider.validateParameters(resourceInstance, method, unwrapArgs(arguments).toArray());
+ message.getExchange().put(BeanValidationProvider.class, provider);
+ }
+ }
+
+ protected List<Object> unwrapArgs(List<Object> arguments) {
+ return arguments;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/workqueue/AutomaticWorkQueueImpl.java b/transform/src/patch/java/org/apache/cxf/workqueue/AutomaticWorkQueueImpl.java
new file mode 100644
index 0000000..bff113e
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/workqueue/AutomaticWorkQueueImpl.java
@@ -0,0 +1,619 @@
+/**
+ * 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.cxf.workqueue;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.concurrent.DelayQueue;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.cxf.common.classloader.ClassLoaderUtils;
+import org.apache.cxf.common.classloader.ClassLoaderUtils.ClassLoaderHolder;
+import org.apache.cxf.common.injection.NoJSR250Annotations;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ReflectionUtil;
+
+@NoJSR250Annotations
+public class AutomaticWorkQueueImpl implements AutomaticWorkQueue {
+ public static final String PROPERTY_NAME = "name";
+ static final int DEFAULT_MAX_QUEUE_SIZE = 256;
+ private static final Logger LOG =
+ LogUtils.getL7dLogger(AutomaticWorkQueueImpl.class);
+
+
+ String name = "default";
+ int maxQueueSize;
+ int initialThreads;
+ int lowWaterMark;
+ int highWaterMark;
+ long dequeueTimeout;
+ AtomicInteger approxThreadCount = new AtomicInteger();
+
+ ThreadPoolExecutor executor;
+ Method addWorkerMethod;
+ Object[] addWorkerArgs;
+
+ AWQThreadFactory threadFactory;
+ ReentrantLock mainLock;
+ final ReentrantLock addThreadLock = new ReentrantLock();
+
+ DelayQueue<DelayedTaskWrapper> delayQueue;
+ WatchDog watchDog;
+
+ boolean shared;
+ int sharedCount;
+
+ private List<PropertyChangeListener> changeListenerList;
+
+ public AutomaticWorkQueueImpl() {
+ this(DEFAULT_MAX_QUEUE_SIZE);
+ }
+ public AutomaticWorkQueueImpl(String name) {
+ this(DEFAULT_MAX_QUEUE_SIZE, name);
+ }
+ public AutomaticWorkQueueImpl(int max) {
+ this(max, "default");
+ }
+ public AutomaticWorkQueueImpl(int max, String name) {
+ this(max,
+ 0,
+ 25,
+ 5,
+ 2 * 60 * 1000L,
+ name);
+ }
+ public AutomaticWorkQueueImpl(int mqs,
+ int initialThreads,
+ int highWaterMark,
+ int lowWaterMark,
+ long dequeueTimeout) {
+ this(mqs, initialThreads, highWaterMark, lowWaterMark, dequeueTimeout, "default");
+ }
+ public AutomaticWorkQueueImpl(int mqs,
+ int initialThreads,
+ int highWaterMark,
+ int lowWaterMark,
+ long dequeueTimeout,
+ String name) {
+ this.maxQueueSize = mqs == -1 ? DEFAULT_MAX_QUEUE_SIZE : mqs;
+ this.initialThreads = initialThreads;
+ this.highWaterMark = -1 == highWaterMark ? Integer.MAX_VALUE : highWaterMark;
+ this.lowWaterMark = -1 == lowWaterMark ? Integer.MAX_VALUE : lowWaterMark;
+ this.dequeueTimeout = dequeueTimeout;
+ this.name = name;
+ this.changeListenerList = new ArrayList<>();
+ }
+
+ public void addChangeListener(PropertyChangeListener listener) {
+ this.changeListenerList.add(listener);
+ }
+
+ public void removeChangeListener(PropertyChangeListener listener) {
+ this.changeListenerList.remove(listener);
+ }
+
+ public void notifyChangeListeners(PropertyChangeEvent event) {
+ for (PropertyChangeListener listener : changeListenerList) {
+ listener.propertyChange(event);
+ }
+ }
+
+ public void setShared(boolean shared) {
+ this.shared = shared;
+ }
+ public boolean isShared() {
+ return shared;
+ }
+ public void addSharedUser() {
+ sharedCount++;
+ }
+ public void removeSharedUser() {
+ sharedCount--;
+ }
+ public int getShareCount() {
+ return sharedCount;
+ }
+
+ protected synchronized ThreadPoolExecutor getExecutor() {
+ if (executor == null) {
+ threadFactory = createThreadFactory(name);
+ executor = new ThreadPoolExecutor(lowWaterMark,
+ highWaterMark,
+ TimeUnit.MILLISECONDS.toMillis(dequeueTimeout),
+ TimeUnit.MILLISECONDS,
+ new LinkedBlockingQueue<Runnable>(maxQueueSize),
+ threadFactory) {
+ @Override
+ protected void terminated() {
+ ThreadFactory f = executor.getThreadFactory();
+ if (f instanceof AWQThreadFactory) {
+ ((AWQThreadFactory)f).shutdown();
+ }
+ if (watchDog != null) {
+ watchDog.shutdown();
+ }
+ }
+ };
+
+
+ if (LOG.isLoggable(Level.FINE)) {
+ StringBuilder buf = new StringBuilder(128).append("Constructing automatic work queue with:\n")
+ .append("max queue size: ").append(maxQueueSize).append('\n')
+ .append("initialThreads: ").append(initialThreads).append('\n')
+ .append("lowWaterMark: ").append(lowWaterMark).append('\n')
+ .append("highWaterMark: ").append(highWaterMark).append('\n');
+ LOG.fine(buf.toString());
+ }
+
+ if (initialThreads > highWaterMark) {
+ initialThreads = highWaterMark;
+ }
+
+ // as we cannot prestart more core than corePoolSize initial threads, we temporarily
+ // change the corePoolSize to the number of initial threads
+ // this is important as otherwise these threads will be created only when
+ // the queue has filled up,
+ // potentially causing problems with starting up under heavy load
+ if (initialThreads < Integer.MAX_VALUE && initialThreads > 0) {
+ executor.setCorePoolSize(initialThreads);
+ int started = executor.prestartAllCoreThreads();
+ if (started < initialThreads) {
+ LOG.log(Level.WARNING, "THREAD_START_FAILURE_MSG",
+ new Object[] {started, initialThreads});
+ }
+ executor.setCorePoolSize(lowWaterMark);
+ }
+
+ ReentrantLock l;
+ try {
+ Field f = ThreadPoolExecutor.class.getDeclaredField("mainLock");
+ ReflectionUtil.setAccessible(f);
+ l = (ReentrantLock)f.get(executor);
+ } catch (Throwable t) {
+ l = new ReentrantLock();
+ }
+ mainLock = l;
+
+
+ try {
+ //java 7
+ addWorkerMethod = ThreadPoolExecutor.class.getDeclaredMethod("addWorker",
+ Runnable.class, Boolean.TYPE);
+ addWorkerArgs = new Object[] {null, Boolean.FALSE};
+ } catch (Throwable t2) {
+ //nothing we cando
+ }
+ }
+ return executor;
+ }
+ private AWQThreadFactory createThreadFactory(final String nm) {
+ ThreadGroup group;
+ try {
+ //Try and find the highest level ThreadGroup that we're allowed to use.
+ //That SHOULD allow the default classloader and thread locals and such
+ //to be the least likely to cause issues down the road.
+ group = AccessController.doPrivileged(
+ new PrivilegedAction<ThreadGroup>() {
+ public ThreadGroup run() {
+ ThreadGroup group = Thread.currentThread().getThreadGroup();
+ ThreadGroup parent = group;
+ try {
+ while (parent != null) {
+ group = parent;
+ parent = parent.getParent();
+ }
+ } catch (SecurityException se) {
+ //ignore - if we get here, the "group" is as high as
+ //the security manager will allow us to go. Use that one.
+ }
+ return new ThreadGroup(group, nm + "-workqueue");
+ }
+ }
+ );
+ } catch (SecurityException e) {
+ group = new ThreadGroup(nm + "-workqueue");
+ }
+ return new AWQThreadFactory(group, nm);
+ }
+
+ static class DelayedTaskWrapper implements Delayed, Runnable {
+ long trigger;
+ Runnable work;
+
+ DelayedTaskWrapper(Runnable work, long delay) {
+ this.work = work;
+ trigger = System.currentTimeMillis() + delay;
+ }
+
+ public long getDelay(TimeUnit unit) {
+ long n = trigger - System.currentTimeMillis();
+ return unit.convert(n, TimeUnit.MILLISECONDS);
+ }
+
+ public int compareTo(Delayed delayed) {
+ long other = ((DelayedTaskWrapper)delayed).trigger;
+ int returnValue;
+ if (this.trigger < other) {
+ returnValue = -1;
+ } else if (this.trigger > other) {
+ returnValue = 1;
+ } else {
+ returnValue = 0;
+ }
+ return returnValue;
+ }
+
+ public void run() {
+ work.run();
+ }
+
+ }
+
+ class WatchDog extends Thread {
+ DelayQueue<DelayedTaskWrapper> delayQueue;
+ AtomicBoolean shutdown = new AtomicBoolean(false);
+
+ WatchDog(DelayQueue<DelayedTaskWrapper> queue) {
+ delayQueue = queue;
+ }
+
+ public void shutdown() {
+ shutdown.set(true);
+ // to exit the waiting thread
+ interrupt();
+ }
+
+ public void run() {
+ DelayedTaskWrapper task;
+ try {
+ while (!shutdown.get()) {
+ task = delayQueue.take();
+ if (task != null) {
+ try {
+ execute(task);
+ } catch (Exception ex) {
+ LOG.warning("Executing the task from DelayQueue with exception: " + ex);
+ }
+ }
+ }
+ } catch (InterruptedException e) {
+ if (LOG.isLoggable(Level.FINE)) {
+ LOG.finer("The DelayQueue watchdog Task is stopping");
+ }
+ }
+
+ }
+
+ }
+ class AWQThreadFactory implements ThreadFactory {
+ final AtomicInteger threadNumber = new AtomicInteger(1);
+ ThreadGroup group;
+ String name;
+ ClassLoader loader;
+
+ AWQThreadFactory(ThreadGroup gp, String nm) {
+ group = gp;
+ name = nm;
+ //force the loader to be the loader of CXF, not the application loader
+ loader = AutomaticWorkQueueImpl.class.getClassLoader();
+ }
+
+ public Thread newThread(final Runnable r) {
+ if (group.isDestroyed()) {
+ group = new ThreadGroup(group.getParent(), name + "-workqueue");
+ }
+ Runnable wrapped = new Runnable() {
+ public void run() {
+ approxThreadCount.incrementAndGet();
+ try {
+ r.run();
+ } finally {
+ approxThreadCount.decrementAndGet();
+ }
+ }
+ };
+ final Thread t = new Thread(group,
+ wrapped,
+ name + "-workqueue-" + threadNumber.getAndIncrement(),
+ 0);
+ AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
+ public Boolean run() {
+ t.setContextClassLoader(loader);
+ return true;
+ }
+ });
+ t.setDaemon(true);
+ if (t.getPriority() != Thread.NORM_PRIORITY) {
+ t.setPriority(Thread.NORM_PRIORITY);
+ }
+ return t;
+ }
+ public void setName(String s) {
+ name = s;
+ }
+ public void shutdown() {
+ if (!group.isDestroyed()) {
+ try {
+ group.destroy();
+ group.setDaemon(true);
+ } catch (Throwable t) {
+ //ignore
+ }
+ }
+ }
+ }
+
+ public void setName(String s) {
+ name = s;
+ if (threadFactory != null) {
+ threadFactory.setName(s);
+ }
+ }
+ public String getName() {
+ return name;
+ }
+
+ public String toString() {
+ return new StringBuilder(super.toString())
+ .append(" [queue size: ").append(getSize())
+ .append(", max size: ").append(maxQueueSize)
+ .append(", threads: ").append(getPoolSize())
+ .append(", active threads: ").append(getActiveCount())
+ .append(", low water mark: ").append(getLowWaterMark())
+ .append(", high water mark: ").append(getHighWaterMark())
+ .append(']').toString();
+ }
+
+ public void execute(final Runnable command) {
+ //Grab the context classloader of this thread. We'll make sure we use that
+ //on the thread the runnable actually runs on.
+
+ final ClassLoader loader = Thread.currentThread().getContextClassLoader();
+ Runnable r = new Runnable() {
+ public void run() {
+ ClassLoaderHolder orig = ClassLoaderUtils.setThreadContextClassloader(loader);
+ try {
+ command.run();
+ } finally {
+ if (orig != null) {
+ orig.reset();
+ }
+ }
+ }
+ };
+ //The ThreadPoolExecutor in the JDK doesn't expand the number
+ //of threads until the queue is full. However, we would
+ //prefer the number of threads to expand immediately and
+ //only uses the queue if we've reached the maximum number
+ //of threads.
+ ThreadPoolExecutor ex = getExecutor();
+ ex.execute(r);
+ if (addWorkerMethod != null
+ && !ex.getQueue().isEmpty()
+ && this.approxThreadCount.get() < highWaterMark
+ && addThreadLock.tryLock()) {
+ try {
+ mainLock.lock();
+ try {
+ int ps = this.getPoolSize();
+ int sz = executor.getQueue().size();
+ int sz2 = this.getActiveCount();
+
+ if ((sz + sz2) > ps) {
+ // Needs --add-opens java.base/java.util.concurrent=ALL-UNNAMED for JDK16+
+ ReflectionUtil.setAccessible(addWorkerMethod).invoke(executor, addWorkerArgs);
+ }
+ } catch (Exception exc) {
+ //ignore
+ } finally {
+ mainLock.unlock();
+ }
+ } finally {
+ addThreadLock.unlock();
+ }
+ }
+ }
+
+ // WorkQueue interface
+ public void execute(Runnable work, long timeout) {
+ try {
+ execute(work);
+ } catch (RejectedExecutionException ree) {
+ try {
+ if (!getExecutor().getQueue().offer(work, timeout, TimeUnit.MILLISECONDS)) {
+ throw ree;
+ }
+ } catch (InterruptedException ie) {
+ throw ree;
+ }
+ }
+ }
+
+ public synchronized void schedule(final Runnable work, final long delay) {
+ if (delayQueue == null) {
+ delayQueue = new DelayQueue<>();
+ watchDog = new WatchDog(delayQueue);
+ watchDog.setDaemon(true);
+ watchDog.start();
+ }
+ delayQueue.put(new DelayedTaskWrapper(work, delay));
+ }
+
+ // AutomaticWorkQueue interface
+
+ public void shutdown(boolean processRemainingWorkItems) {
+ if (executor != null) {
+ if (!processRemainingWorkItems) {
+ executor.getQueue().clear();
+ }
+ executor.shutdown();
+ }
+ }
+
+
+ /**
+ * Gets the maximum size (capacity) of the backing queue.
+ * @return the maximum size (capacity) of the backing queue.
+ */
+ public long getMaxSize() {
+ return maxQueueSize;
+ }
+
+ /**
+ * Gets the current size of the backing queue.
+ * @return the current size of the backing queue.
+ */
+ public long getSize() {
+ return executor == null ? 0 : executor.getQueue().size();
+ }
+
+
+ public boolean isEmpty() {
+ return executor == null || executor.getQueue().isEmpty();
+ }
+
+ public boolean isFull() {
+ return executor != null && executor.getQueue().remainingCapacity() == 0;
+ }
+
+ public int getHighWaterMark() {
+ int hwm = executor == null ? highWaterMark : executor.getMaximumPoolSize();
+ return hwm == Integer.MAX_VALUE ? -1 : hwm;
+ }
+
+ public int getLowWaterMark() {
+ int lwm = executor == null ? lowWaterMark : executor.getCorePoolSize();
+ return lwm == Integer.MAX_VALUE ? -1 : lwm;
+ }
+
+ public int getInitialSize() {
+ return this.initialThreads;
+ }
+
+ public void setHighWaterMark(int hwm) {
+ highWaterMark = hwm < 0 ? Integer.MAX_VALUE : hwm;
+ if (executor != null) {
+ notifyChangeListeners(new PropertyChangeEvent(this, "highWaterMark",
+ this.executor.getMaximumPoolSize(), hwm));
+ executor.setMaximumPoolSize(highWaterMark);
+ }
+ }
+
+ public void setLowWaterMark(int lwm) {
+ lowWaterMark = lwm < 0 ? 0 : lwm;
+ if (executor != null) {
+ notifyChangeListeners(new PropertyChangeEvent(this, "lowWaterMark",
+ this.executor.getCorePoolSize(), lwm));
+ executor.setCorePoolSize(lowWaterMark);
+ }
+ }
+
+ public void setInitialSize(int initialSize) {
+ notifyChangeListeners(new PropertyChangeEvent(this, "initialSize", this.initialThreads, initialSize));
+ this.initialThreads = initialSize;
+ }
+
+ public void setQueueSize(int size) {
+ notifyChangeListeners(new PropertyChangeEvent(this, "queueSize", this.maxQueueSize, size));
+ this.maxQueueSize = size;
+ }
+
+ public void setDequeueTimeout(long l) {
+ notifyChangeListeners(new PropertyChangeEvent(this, "dequeueTimeout", this.dequeueTimeout, l));
+ this.dequeueTimeout = l;
+ }
+
+ public boolean isShutdown() {
+ if (executor == null) {
+ return false;
+ }
+ return executor.isShutdown();
+ }
+ public int getLargestPoolSize() {
+ if (executor == null) {
+ return 0;
+ }
+ return executor.getLargestPoolSize();
+ }
+ public int getPoolSize() {
+ if (executor == null) {
+ return 0;
+ }
+ return executor.getPoolSize();
+ }
+ public int getActiveCount() {
+ if (executor == null) {
+ return 0;
+ }
+ return executor.getActiveCount();
+ }
+ public void update(Dictionary<String, String> config) {
+ String s = config.get("highWaterMark");
+ if (s != null) {
+ this.highWaterMark = Integer.parseInt(s);
+ }
+ s = config.get("lowWaterMark");
+ if (s != null) {
+ this.lowWaterMark = Integer.parseInt(s);
+ }
+ s = config.get("initialSize");
+ if (s != null) {
+ this.initialThreads = Integer.parseInt(s);
+ }
+ s = config.get("dequeueTimeout");
+ if (s != null) {
+ this.dequeueTimeout = Long.parseLong(s);
+ }
+ s = config.get("queueSize");
+ if (s != null) {
+ this.maxQueueSize = Integer.parseInt(s);
+ }
+ }
+ public Dictionary<String, String> getProperties() {
+ Dictionary<String, String> properties = new Hashtable<>();
+ NumberFormat nf = NumberFormat.getIntegerInstance();
+ properties.put("name", nf.format(getName()));
+ properties.put("highWaterMark", nf.format(getHighWaterMark()));
+ properties.put("lowWaterMark", nf.format(getLowWaterMark()));
+ properties.put("initialSize", nf.format(getLowWaterMark()));
+ properties.put("dequeueTimeout", nf.format(getLowWaterMark()));
+ properties.put("queueSize", nf.format(getLowWaterMark()));
+ return properties;
+ }
+}
diff --git a/transform/src/patch/java/org/apache/cxf/ws/addressing/MAPAggregator.java b/transform/src/patch/java/org/apache/cxf/ws/addressing/MAPAggregator.java
new file mode 100644
index 0000000..206494d
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/ws/addressing/MAPAggregator.java
@@ -0,0 +1,224 @@
+/**
+ * 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.cxf.ws.addressing;
+
+import java.util.Collection;
+
+import org.apache.cxf.message.Message;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.phase.PhaseInterceptor;
+
+/**
+ * Logical Handler responsible for aggregating the Message Addressing
+ * Properties for outgoing messages.
+ */
+public class MAPAggregator extends AbstractPhaseInterceptor<Message> {
+ public static final String USING_ADDRESSING = MAPAggregator.class.getName() + ".usingAddressing";
+ public static final String ADDRESSING_DISABLED = MAPAggregator.class.getName() + ".addressingDisabled";
+ public static final String DECOUPLED_DESTINATION = MAPAggregator.class.getName()
+ + ".decoupledDestination";
+ public static final String ACTION_VERIFIED = MAPAggregator.class.getName() + ".actionVerified";
+ public static final String ADDRESSING_NAMESPACE = MAPAggregator.class.getName() + ".addressingNamespace";
+
+ public interface MAPAggregatorLoader {
+ MAPAggregator createImplementation(MAPAggregator mag);
+ }
+
+ protected MessageIdCache messageIdCache;
+ protected boolean usingAddressingAdvisory = true;
+ protected boolean addressingRequired;
+ protected boolean allowDuplicates = true;
+ protected WSAddressingFeature.AddressingResponses addressingResponses
+ = WSAddressingFeature.AddressingResponses.ALL;
+
+ /**
+ * The real implementation of the MAPAggregator interceptor
+ */
+ private MAPAggregator impl;
+
+ /**
+ * Constructor.
+ */
+ public MAPAggregator() {
+ super(MAPAggregator.class.getName(), Phase.PRE_LOGICAL);
+ addBefore("org.apache.cxf.interceptor.OneWayProcessorInterceptor");
+ }
+
+ /**
+ * Indicates if duplicate messageIDs are allowed.
+ * @return true if duplicate messageIDs are allowed
+ */
+ public boolean allowDuplicates() {
+ if (impl != null) {
+ return impl.allowDuplicates();
+ }
+ return allowDuplicates;
+ }
+
+ /**
+ * Allows/disallows duplicate messageIdDs.
+ * @param ad whether duplicate messageIDs are allowed
+ */
+ public void setAllowDuplicates(boolean ad) {
+ if (impl != null) {
+ impl.setAllowDuplicates(ad);
+ }
+ allowDuplicates = ad;
+ }
+
+ /**
+ * Whether the presence of the <wsaw:UsingAddressing> element
+ * in the WSDL is purely advisory, i.e. its absence doesn't prevent
+ * the encoding of WS-A headers.
+ *
+ * @return true if the presence of the <wsaw:UsingAddressing> element is
+ * advisory
+ */
+ public boolean isUsingAddressingAdvisory() {
+ if (impl != null) {
+ return impl.isUsingAddressingAdvisory();
+ }
+ return usingAddressingAdvisory;
+ }
+
+ /**
+ * Controls whether the presence of the <wsaw:UsingAddressing> element
+ * in the WSDL is purely advisory, i.e. its absence doesn't prevent
+ * the encoding of WS-A headers.
+ *
+ * @param advisory true if the presence of the <wsaw:UsingAddressing>
+ * element is to be advisory
+ */
+ public void setUsingAddressingAdvisory(boolean advisory) {
+ if (impl != null) {
+ impl.setUsingAddressingAdvisory(advisory);
+ }
+ usingAddressingAdvisory = advisory;
+ }
+
+ /**
+ * Whether the use of addressing is completely required for this endpoint
+ *
+ * @return true if addressing is required
+ */
+ public boolean isAddressingRequired() {
+ if (impl != null) {
+ return impl.addressingRequired;
+ }
+ return addressingRequired;
+ }
+ /**
+ * Sets whether the use of addressing is completely required for this endpoint
+ *
+ */
+ public void setAddressingRequired(boolean required) {
+ if (impl != null) {
+ impl.setAddressingRequired(required);
+ }
+ addressingRequired = required;
+ }
+
+ /**
+ * Sets Addresing Response
+ *
+ */
+ public void setAddressingResponses(WSAddressingFeature.AddressingResponses responses) {
+ if (impl != null) {
+ impl.setAddressingResponses(responses);
+ }
+ addressingResponses = responses;
+ }
+
+ /**
+ * Returns the cache used to enforce duplicate message IDs when
+ * {@link #allowDuplicates()} returns {@code false}.
+ *
+ * @return the cache used to enforce duplicate message IDs
+ */
+ public MessageIdCache getMessageIdCache() {
+ if (impl != null) {
+ return impl.getMessageIdCache();
+ }
+ return messageIdCache;
+ }
+
+ /**
+ * Sets the cache used to enforce duplicate message IDs when
+ * {@link #allowDuplicates()} returns {@code false}.
+ *
+ * @param messageIdCache the cache to use
+ *
+ * @throws NullPointerException if {@code messageIdCache} is {@code null}
+ */
+ public void setMessageIdCache(MessageIdCache messageIdCache) {
+ if (messageIdCache == null) {
+ throw new NullPointerException("messageIdCache cannot be null.");
+ }
+ if (impl != null) {
+ impl.setMessageIdCache(messageIdCache);
+ }
+ this.messageIdCache = messageIdCache;
+ }
+
+ /**
+ * Sets Addressing Response
+ *
+ */
+ public WSAddressingFeature.AddressingResponses getAddressingResponses() {
+ if (impl != null) {
+ return impl.getAddressingResponses();
+ }
+ return addressingResponses;
+ }
+
+ /**
+ * Invoked for normal processing of inbound and outbound messages.
+ *
+ * @param message the current message
+ */
+ public void handleMessage(Message message) {
+ if (impl == null) {
+ //load impl
+ MAPAggregatorLoader loader = message.getExchange().getBus()
+ .getExtension(MAPAggregatorLoader.class);
+ impl = loader.createImplementation(this);
+ }
+ impl.handleMessage(message);
+ }
+
+ @Override
+ public void handleFault(Message message) {
+ if (impl != null) {
+ impl.handleFault(message);
+ }
+ }
+
+
+ @Override
+ public Collection<PhaseInterceptor<? extends Message>> getAdditionalInterceptors() {
+ if (impl != null) {
+ return impl.getAdditionalInterceptors();
+ }
+ return super.getAdditionalInterceptors();
+ }
+
+
+}
