| /* |
| * Copyright 2004,2005 The Apache Software Foundation. |
| * |
| * Licensed 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.axis2.transport; |
| |
| import org.apache.axiom.attachments.Attachments; |
| import org.apache.axiom.om.OMException; |
| import org.apache.axiom.om.util.StAXUtils; |
| import org.apache.axiom.om.impl.MTOMConstants; |
| import org.apache.axiom.om.impl.builder.StAXBuilder; |
| import org.apache.axiom.om.impl.builder.StAXOMBuilder; |
| import org.apache.axiom.om.impl.builder.XOPAwareStAXOMBuilder; |
| import org.apache.axiom.soap.SOAP11Constants; |
| import org.apache.axiom.soap.SOAP12Constants; |
| import org.apache.axiom.soap.SOAPEnvelope; |
| import org.apache.axiom.soap.SOAPFactory; |
| import org.apache.axiom.soap.impl.builder.MTOMStAXSOAPModelBuilder; |
| import org.apache.axiom.soap.impl.builder.StAXSOAPModelBuilder; |
| import org.apache.axiom.soap.impl.llom.soap11.SOAP11Factory; |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.Constants; |
| import org.apache.axis2.context.MessageContext; |
| import org.apache.axis2.context.OperationContext; |
| import org.apache.axis2.description.Parameter; |
| import org.apache.axis2.i18n.Messages; |
| import org.apache.axis2.transport.http.HTTPConstants; |
| |
| import javax.xml.parsers.FactoryConfigurationError; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.stream.XMLStreamReader; |
| import java.io.BufferedReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.PushbackInputStream; |
| import java.io.Reader; |
| |
| public class TransportUtils { |
| private static final int BOM_SIZE = 4; |
| |
| public static SOAPEnvelope createSOAPMessage(MessageContext msgContext, String soapNamespaceURI) |
| throws AxisFault { |
| InputStream inStream = (InputStream) msgContext.getProperty(MessageContext.TRANSPORT_IN); |
| |
| msgContext.setProperty(MessageContext.TRANSPORT_IN, null); |
| |
| // this inputstram is set by the TransportSender represents a two way transport or |
| // by a Transport Recevier |
| if (inStream == null) { |
| throw new AxisFault(Messages.getMessage("inputstreamNull")); |
| } |
| |
| return createSOAPMessage(msgContext, inStream, soapNamespaceURI); |
| } |
| |
| public static SOAPEnvelope createSOAPMessage(MessageContext msgContext, InputStream inStream, |
| String soapNamespaceURI) |
| throws AxisFault { |
| try { |
| Object contentType ; |
| OperationContext opContext = msgContext.getOperationContext(); |
| |
| if (opContext != null) { |
| contentType = opContext.getProperty(HTTPConstants.MTOM_RECEIVED_CONTENT_TYPE); |
| } else { |
| throw new AxisFault(Messages.getMessage("cannotBeNullOperationContext")); |
| } |
| |
| StAXBuilder builder; |
| SOAPEnvelope envelope ; |
| String charSetEnc = |
| (String) msgContext.getProperty(Constants.Configuration.CHARACTER_SET_ENCODING); |
| |
| if (charSetEnc == null) { |
| charSetEnc = (String) opContext.getProperty(Constants.Configuration.CHARACTER_SET_ENCODING); |
| } |
| |
| if (charSetEnc == null) { |
| charSetEnc = MessageContext.DEFAULT_CHAR_SET_ENCODING; |
| } |
| |
| if (contentType != null) { |
| msgContext.setDoingMTOM(true); |
| builder = selectBuilderForMIME(msgContext, inStream, |
| (String) contentType,true); |
| envelope = (SOAPEnvelope) builder.getDocumentElement(); |
| } else if (msgContext.isDoingREST()) { |
| XMLStreamReader xmlreader = |
| StAXUtils.createXMLStreamReader(inStream, charSetEnc); |
| SOAPFactory soapFactory = new SOAP11Factory(); |
| |
| builder = new StAXOMBuilder(xmlreader); |
| builder.setOMBuilderFactory(soapFactory); |
| envelope = soapFactory.getDefaultEnvelope(); |
| envelope.getBody().addChild(builder.getDocumentElement()); |
| |
| // We now have the message inside an envolope. However, this is |
| // only an OM; We need to build a SOAP model from it. |
| |
| builder = new StAXSOAPModelBuilder(envelope.getXMLStreamReader(), soapNamespaceURI); |
| envelope = (SOAPEnvelope) builder.getDocumentElement(); |
| } else { |
| XMLStreamReader xmlreader = |
| StAXUtils.createXMLStreamReader(inStream, charSetEnc); |
| |
| builder = new StAXSOAPModelBuilder(xmlreader, soapNamespaceURI); |
| envelope = (SOAPEnvelope) builder.getDocumentElement(); |
| } |
| |
| return envelope; |
| } catch (Exception e) { |
| throw new AxisFault(e); |
| } |
| } |
| |
| /** |
| * Extracts and returns the character set encoding from the |
| * Content-type header |
| * Example: |
| * Content-Type: text/xml; charset=utf-8 |
| * |
| * @param contentType |
| */ |
| public static String getCharSetEncoding(String contentType) { |
| int index = contentType.indexOf(HTTPConstants.CHAR_SET_ENCODING); |
| |
| if (index == -1) { // Charset encoding not found in the content-type header |
| // Using the default UTF-8 |
| return MessageContext.DEFAULT_CHAR_SET_ENCODING; |
| } |
| |
| // If there are spaces around the '=' sign |
| int indexOfEq = contentType.indexOf("=", index); |
| |
| // There can be situations where "charset" is not the last parameter of the Content-Type header |
| int indexOfSemiColon = contentType.indexOf(";", indexOfEq); |
| String value; |
| |
| if (indexOfSemiColon > 0) { |
| value = (contentType.substring(indexOfEq + 1, indexOfSemiColon)); |
| } else { |
| value = (contentType.substring(indexOfEq + 1, contentType.length())).trim(); |
| } |
| |
| // There might be "" around the value - if so remove them |
| if(value.indexOf('\"')!=-1){ |
| value = value.replaceAll("\"", ""); |
| } |
| |
| return value.trim(); |
| } |
| |
| public static StAXBuilder selectBuilderForMIME(MessageContext msgContext, |
| InputStream inStream, String contentTypeString, boolean isSOAP) |
| throws OMException, XMLStreamException, FactoryConfigurationError { |
| StAXBuilder builder = null; |
| |
| Object cacheAttachmentProperty = msgContext |
| .getProperty(Constants.Configuration.CACHE_ATTACHMENTS); |
| String cacheAttachmentString = null; |
| boolean fileCacheForAttachments; |
| |
| if (cacheAttachmentProperty != null |
| && cacheAttachmentProperty instanceof String) { |
| cacheAttachmentString = (String) cacheAttachmentProperty; |
| fileCacheForAttachments = (Constants.VALUE_TRUE |
| .equals(cacheAttachmentString)); |
| } else { |
| Parameter parameter_cache_attachment = msgContext |
| .getParameter(Constants.Configuration.CACHE_ATTACHMENTS); |
| cacheAttachmentString = (parameter_cache_attachment != null) ? (String) parameter_cache_attachment |
| .getValue() |
| : null; |
| } |
| fileCacheForAttachments = (Constants.VALUE_TRUE |
| .equals(cacheAttachmentString)); |
| |
| String attachmentRepoDir = null; |
| String attachmentSizeThreshold = null; |
| |
| if (fileCacheForAttachments) { |
| Object attachmentRepoDirProperty = msgContext |
| .getProperty(Constants.Configuration.ATTACHMENT_TEMP_DIR); |
| |
| if (attachmentRepoDirProperty != null) { |
| attachmentRepoDir = (String) attachmentRepoDirProperty; |
| } else { |
| Parameter attachmentRepoDirParameter = msgContext |
| .getParameter(Constants.Configuration.ATTACHMENT_TEMP_DIR); |
| attachmentRepoDir = (attachmentRepoDirParameter != null) ? (String) attachmentRepoDirParameter |
| .getValue() |
| : null; |
| } |
| |
| Object attachmentSizeThresholdProperty = msgContext |
| .getProperty(Constants.Configuration.FILE_SIZE_THRESHOLD); |
| if (attachmentSizeThresholdProperty != null |
| && attachmentSizeThresholdProperty instanceof String) { |
| attachmentSizeThreshold = (String) attachmentSizeThresholdProperty; |
| } else { |
| Parameter attachmentSizeThresholdParameter = msgContext |
| .getParameter(Constants.Configuration.FILE_SIZE_THRESHOLD); |
| attachmentSizeThreshold = attachmentSizeThresholdParameter |
| .getValue().toString(); |
| } |
| } |
| |
| Attachments attachments = new Attachments(inStream, contentTypeString, |
| fileCacheForAttachments, attachmentRepoDir, |
| attachmentSizeThreshold); |
| String charSetEncoding = getCharSetEncoding(attachments |
| .getSOAPPartContentType()); |
| XMLStreamReader streamReader; |
| |
| if ((charSetEncoding == null) |
| || "null".equalsIgnoreCase(charSetEncoding)) { |
| charSetEncoding = MessageContext.UTF_8; |
| } |
| |
| try { |
| streamReader = StAXUtils.createXMLStreamReader(getReader( |
| attachments.getSOAPPartInputStream(), charSetEncoding)); |
| } catch (IOException e) { |
| throw new XMLStreamException(e); |
| } |
| |
| msgContext.setProperty(Constants.Configuration.CHARACTER_SET_ENCODING, |
| charSetEncoding); |
| |
| /* |
| * Put a reference to Attachments Map in to the message context For |
| * backword compatibility with Axis2 1.0 |
| */ |
| msgContext.setProperty(MTOMConstants.ATTACHMENTS, attachments); |
| |
| /* |
| * Setting the Attachments map to new SwA API |
| */ |
| msgContext.setAttachmentMap(attachments); |
| |
| String soapEnvelopeNamespaceURI = null; |
| if (contentTypeString.indexOf(SOAP12Constants.SOAP_12_CONTENT_TYPE) > -1) { |
| soapEnvelopeNamespaceURI = SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI; |
| } else if (contentTypeString |
| .indexOf(SOAP11Constants.SOAP_11_CONTENT_TYPE) > -1) { |
| soapEnvelopeNamespaceURI = SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI; |
| } |
| |
| if (isSOAP) { |
| if (attachments.getAttachmentSpecType().equals( |
| MTOMConstants.MTOM_TYPE) |
| & null != soapEnvelopeNamespaceURI) { |
| |
| /* |
| * Creates the MTOM specific MTOMStAXSOAPModelBuilder |
| */ |
| builder = new MTOMStAXSOAPModelBuilder(streamReader, |
| attachments, soapEnvelopeNamespaceURI); |
| |
| } else if (attachments.getAttachmentSpecType().equals( |
| MTOMConstants.SWA_TYPE) |
| & null != soapEnvelopeNamespaceURI) { |
| builder = new StAXSOAPModelBuilder(streamReader, |
| soapEnvelopeNamespaceURI); |
| } |
| } |
| // To handle REST XOP case |
| else { |
| if (attachments.getAttachmentSpecType().equals( |
| MTOMConstants.MTOM_TYPE)) { |
| XOPAwareStAXOMBuilder stAXOMBuilder = new XOPAwareStAXOMBuilder( |
| streamReader, attachments); |
| builder = stAXOMBuilder; |
| |
| } else if (attachments.getAttachmentSpecType().equals( |
| MTOMConstants.SWA_TYPE)) { |
| builder = new StAXOMBuilder(streamReader); |
| } |
| } |
| |
| return builder; |
| } |
| |
| /** |
| * Use the BOM Mark to identify the encoding to be used. Fall back to |
| * default encoding specified |
| * |
| * @param is |
| * @param charSetEncoding |
| * @throws java.io.IOException |
| */ |
| private static Reader getReader(InputStream is, String charSetEncoding) throws IOException { |
| PushbackInputStream is2 = new PushbackInputStream(is, BOM_SIZE); |
| String encoding; |
| byte bom[] = new byte[BOM_SIZE]; |
| int n, unread; |
| |
| n = is2.read(bom, 0, bom.length); |
| |
| if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) { |
| encoding = "UTF-8"; |
| unread = n - 3; |
| } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) { |
| encoding = "UTF-16BE"; |
| unread = n - 2; |
| } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) { |
| encoding = "UTF-16LE"; |
| unread = n - 2; |
| } else if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE) |
| && (bom[3] == (byte) 0xFF)) { |
| encoding = "UTF-32BE"; |
| unread = n - 4; |
| } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00) |
| && (bom[3] == (byte) 0x00)) { |
| encoding = "UTF-32LE"; |
| unread = n - 4; |
| } else { |
| |
| // Unicode BOM mark not found, unread all bytes |
| encoding = charSetEncoding; |
| unread = n; |
| } |
| |
| if (unread > 0) { |
| is2.unread(bom, (n - unread), unread); |
| } |
| |
| return new BufferedReader(new InputStreamReader(is2, encoding)); |
| } |
| } |
