| /* |
| * Copyright 2001-2004 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.axis ; |
| |
| import org.apache.axis.components.logger.LogFactory; |
| import org.apache.axis.encoding.DeserializationContext; |
| import org.apache.axis.encoding.SerializationContext; |
| import org.apache.axis.message.InputStreamBody; |
| import org.apache.axis.message.MimeHeaders; |
| import org.apache.axis.message.SOAPDocumentImpl; |
| import org.apache.axis.message.SOAPEnvelope; |
| import org.apache.axis.message.SOAPHeaderElement; |
| import org.apache.axis.transport.http.HTTPConstants; |
| import org.apache.axis.utils.ByteArray; |
| import org.apache.axis.utils.Messages; |
| import org.apache.axis.utils.SessionUtils; |
| import org.apache.axis.utils.XMLUtils; |
| import org.apache.axis.handlers.HandlerChainImpl; |
| import org.apache.commons.logging.Log; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.CDATASection; |
| import org.w3c.dom.Comment; |
| import org.w3c.dom.DOMException; |
| import org.w3c.dom.DOMImplementation; |
| 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.NodeList; |
| import org.w3c.dom.ProcessingInstruction; |
| import org.w3c.dom.Text; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| |
| import javax.xml.soap.SOAPException; |
| import javax.xml.soap.SOAPMessage; |
| import javax.xml.transform.Source; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.stream.StreamSource; |
| import java.io.BufferedOutputStream; |
| import java.io.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.PrintWriter; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.io.StringWriter; |
| import java.io.UnsupportedEncodingException; |
| import java.io.Writer; |
| import java.util.Iterator; |
| import java.util.Vector; |
| |
| /** |
| * The SOAPPart provides access to the root part of the Message which |
| * contains the envelope. |
| * <p> |
| * SOAPPart implements Part, providing common MIME operations. |
| * <p> |
| * SOAPPart also allows access to its envelope, |
| * as a string, byte[], InputStream, or SOAPEnvelope. (This functionality |
| * used to be in Message, and has been moved here more or less verbatim |
| * pending further cleanup.) |
| * |
| * @author Rob Jellinghaus (robj@unrealities.com) |
| * @author Doug Davis (dug@us.ibm.com) |
| * @author Glen Daniels (gdaniels@allaire.com) |
| * @author Heejune Ahn (cityboy@tmax.co.kr) |
| */ |
| public class SOAPPart extends javax.xml.soap.SOAPPart implements Part |
| { |
| protected static Log log = |
| LogFactory.getLog(SOAPPart.class.getName()); |
| |
| public static final int FORM_STRING = 1; |
| public static final int FORM_INPUTSTREAM = 2; |
| public static final int FORM_SOAPENVELOPE = 3; |
| public static final int FORM_BYTES = 4; |
| public static final int FORM_BODYINSTREAM = 5; |
| public static final int FORM_FAULT = 6; |
| public static final int FORM_OPTIMIZED = 7; |
| private int currentForm; |
| |
| /** |
| * property used to set SOAPEnvelope as default form |
| */ |
| public static final String ALLOW_FORM_OPTIMIZATION = "axis.form.optimization"; |
| |
| |
| //private Hashtable headers = new Hashtable(); |
| private MimeHeaders mimeHeaders = new MimeHeaders(); |
| |
| private static final String[] formNames = |
| { "", "FORM_STRING", "FORM_INPUTSTREAM", "FORM_SOAPENVELOPE", |
| "FORM_BYTES", "FORM_BODYINSTREAM", "FORM_FAULT", "FORM_OPTIMIZED" }; |
| |
| /** |
| * The current representation of the SOAP contents of this part. |
| * May be a String, byte[], InputStream, or SOAPEnvelope, depending |
| * on whatever was last asked for. (ack) |
| * <p> |
| * currentForm must have the corresponding value. |
| * <p> |
| * As someone once said: "Just a placeholder until we figure out what the actual Message |
| * object is." |
| */ |
| private Object currentMessage ; |
| |
| /** |
| * default message encoding charset |
| */ |
| private String currentEncoding = "UTF-8"; |
| |
| // These two fields are used for caching in getAsString and getAsBytes |
| private String currentMessageAsString = null; |
| private byte[] currentMessageAsBytes = null; |
| private org.apache.axis.message.SOAPEnvelope currentMessageAsEnvelope= null; |
| |
| /** |
| * Message object this part is tied to. Used for serialization settings. |
| */ |
| private Message msgObject; |
| |
| /** Field contentSource. */ |
| private Source contentSource = null; |
| |
| /** |
| * The original message. Again, may be String, byte[], InputStream, |
| * or SOAPEnvelope. |
| */ |
| // private Object originalMessage ; //free up reference this is not in use. |
| |
| /** |
| * Create a new SOAPPart. |
| * <p> |
| * Do not call this directly! Should only be called by Message. |
| * |
| * @param parent the parent <code>Message</code> |
| * @param initialContents the initial contens <code>Object</code> |
| * @param isBodyStream if the body is in a stream |
| */ |
| public SOAPPart(Message parent, Object initialContents, boolean isBodyStream) { |
| |
| setMimeHeader(HTTPConstants.HEADER_CONTENT_ID , SessionUtils.generateSessionId()); |
| setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE , "text/xml"); |
| |
| msgObject=parent; |
| // originalMessage = initialContents; |
| int form = FORM_STRING; |
| if (initialContents instanceof SOAPEnvelope) { |
| form = FORM_SOAPENVELOPE; |
| ((SOAPEnvelope)initialContents).setOwnerDocument(this); |
| } else if (initialContents instanceof InputStream) { |
| form = isBodyStream ? FORM_BODYINSTREAM : FORM_INPUTSTREAM; |
| } else if (initialContents instanceof byte[]) { |
| form = FORM_BYTES; |
| } else if (initialContents instanceof AxisFault) { |
| form = FORM_FAULT; |
| } |
| |
| if (log.isDebugEnabled()) { |
| log.debug("Enter: SOAPPart ctor(" + formNames[form] + ")"); |
| } |
| |
| setCurrentMessage(initialContents, form); |
| |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart ctor()"); |
| } |
| } |
| |
| |
| /** |
| * Get the <code>Message</code> for this <code>Part</code>. |
| * |
| * @return the <code>Message</code> for this <code>Part</code> |
| */ |
| public Message getMessage(){ |
| return msgObject; |
| } |
| |
| /** |
| * Set the Message for this Part. |
| * Do not call this Directly. Called by Message. |
| * |
| * @param msg the <code>Message</code> for this part |
| */ |
| public void setMessage (Message msg) { |
| this.msgObject= msg; |
| } |
| |
| /** |
| * Content type is always "text/xml" for SOAPParts. |
| * |
| * @return the content type |
| */ |
| public String getContentType() { |
| return "text/xml"; |
| } |
| |
| /** |
| * Get the content length for this SOAPPart. |
| * This will force buffering of the SOAPPart, but it will |
| * also cache the byte[] form of the SOAPPart. |
| * |
| * @return the content length in bytes |
| */ |
| public long getContentLength() throws AxisFault { |
| saveChanges(); |
| if (currentForm == FORM_OPTIMIZED) { |
| return ((ByteArray) currentMessage).size(); |
| } else if (currentForm == FORM_BYTES) { |
| return ((byte[]) currentMessage).length; |
| } |
| byte[] bytes = this.getAsBytes(); |
| return bytes.length; |
| } |
| |
| /** |
| * This set the SOAP Envelope for this part. |
| * <p> |
| * Note: It breaks the chicken/egg created. |
| * I need a message to create an attachment... |
| * From the attachment I should be able to get a reference... |
| * I now want to edit elements in the envelope in order to |
| * place the attachment reference to it. |
| * How do I now update the SOAP envelope with what I've changed? |
| * |
| * @param env the <code>SOAPEnvelope</CODE> for this <code>SOAPPart</code> |
| */ |
| |
| public void setSOAPEnvelope(org.apache.axis.message.SOAPEnvelope env){ |
| setCurrentMessage(env, FORM_SOAPENVELOPE) ; |
| } |
| |
| /** |
| * Write the contents to the specified stream. |
| * |
| * @param os the <code>java.io.OutputStream</code> to write to |
| */ |
| public void writeTo(java.io.OutputStream os) throws IOException { |
| if ( currentForm == FORM_BYTES ) { |
| os.write((byte[])currentMessage); |
| } else if ( currentForm == FORM_OPTIMIZED ) { |
| ((ByteArray) currentMessage).writeTo(os); |
| } else { |
| Writer writer = new OutputStreamWriter(os, currentEncoding); |
| writer = new BufferedWriter(new PrintWriter(writer)); |
| writeTo(writer); |
| writer.flush(); |
| } |
| } |
| |
| /** |
| * Write the contents to the specified writer. |
| * |
| * @param writer the <code>Writer</code> to write to |
| */ |
| public void writeTo(Writer writer) throws IOException { |
| boolean inclXmlDecl = false; |
| |
| if (msgObject.getMessageContext() != null) { // if we have message context (JAX-RPC), write xml decl always. |
| inclXmlDecl = true; |
| } else { // if we have no message context (SAAJ), write xml decl according to property. |
| try { |
| String xmlDecl = (String)msgObject.getProperty(SOAPMessage.WRITE_XML_DECLARATION); |
| if (xmlDecl != null && xmlDecl.equals("true")) { |
| inclXmlDecl = true; |
| } |
| } catch (SOAPException e) { |
| throw new IOException(e.getMessage()); |
| } |
| } |
| |
| if ( currentForm == FORM_FAULT ) { |
| AxisFault env = (AxisFault)currentMessage; |
| try { |
| SerializationContext serContext = new SerializationContext(writer, getMessage().getMessageContext()); |
| serContext.setSendDecl(inclXmlDecl); |
| serContext.setEncoding(currentEncoding); |
| env.output(serContext); |
| } catch (Exception e) { |
| log.error(Messages.getMessage("exception00"), e); |
| throw env; |
| } |
| return; |
| } |
| |
| if ( currentForm == FORM_SOAPENVELOPE ) { |
| SOAPEnvelope env = (SOAPEnvelope)currentMessage; |
| try { |
| SerializationContext serContext = new SerializationContext(writer, getMessage().getMessageContext()); |
| serContext.setSendDecl(inclXmlDecl); |
| serContext.setEncoding(currentEncoding); |
| env.output(serContext); |
| } catch (Exception e) { |
| throw AxisFault.makeFault(e); |
| } |
| return; |
| } |
| |
| String xml = this.getAsString(); |
| if(inclXmlDecl){ |
| if(!xml.startsWith("<?xml")){ |
| writer.write("<?xml version=\"1.0\" encoding=\""); |
| writer.write(currentEncoding); |
| writer.write("\"?>"); |
| } |
| } |
| writer.write(xml); |
| } |
| |
| /** |
| * Get the current message, in whatever form it happens to be right now. |
| * Will return a String, byte[], InputStream, or SOAPEnvelope, depending |
| * on circumstances. |
| * <p> |
| * The method name is historical. |
| * TODO: rename this for clarity; should be more like getContents. |
| * |
| * @return the current content |
| */ |
| public Object getCurrentMessage() { |
| return currentMessage; |
| } |
| |
| /** |
| * Set the current message |
| * @param currMsg |
| * @param form |
| */ |
| public void setCurrentMessage(Object currMsg, int form) { |
| currentMessageAsString = null; //Get rid of any cached stuff this is new. |
| currentMessageAsBytes = null; |
| currentMessageAsEnvelope= null; |
| setCurrentForm(currMsg, form); |
| } |
| /** |
| * Set the current contents of this Part. |
| * The method name is historical. |
| * TODO: rename this for clarity to something more like setContents??? |
| * |
| * @param currMsg the new content of this part |
| * @param form the form of the message |
| */ |
| private void setCurrentForm(Object currMsg, int form) { |
| if (log.isDebugEnabled()) { |
| String msgStr; |
| if (currMsg instanceof String) { |
| msgStr = (String)currMsg; |
| } else { |
| msgStr = currMsg.getClass().getName(); |
| } |
| log.debug(Messages.getMessage("setMsgForm", formNames[form], |
| "" + msgStr)); |
| } |
| |
| // only change form if allowed |
| if (isFormOptimizationAllowed()) { |
| currentMessage = currMsg; |
| currentForm = form; |
| if (currentForm == FORM_SOAPENVELOPE) { |
| currentMessageAsEnvelope = (org.apache.axis.message.SOAPEnvelope) currMsg; |
| } |
| } |
| } |
| |
| /** |
| * check if the allow optimization flag is on |
| * @return form optimization flag |
| */ |
| private boolean isFormOptimizationAllowed() { |
| boolean allowFormOptimization = true; |
| Message msg = getMessage(); |
| if (msg != null) { |
| MessageContext ctx = msg.getMessageContext(); |
| if (ctx != null) { |
| Boolean propFormOptimization = (Boolean)ctx.getProperty(ALLOW_FORM_OPTIMIZATION); |
| if (propFormOptimization != null) { |
| allowFormOptimization = propFormOptimization.booleanValue(); |
| } |
| } |
| } |
| return allowFormOptimization; |
| } |
| |
| public int getCurrentForm() { |
| return currentForm; |
| } |
| |
| /** |
| * Get the contents of this Part (not the headers!), as a byte |
| * array. This will force buffering of the message. |
| * |
| * @return an array of bytes containing a byte representation of this Part |
| * @throws AxisFault if this Part can't be serialized to the byte array |
| */ |
| public byte[] getAsBytes() throws AxisFault { |
| log.debug("Enter: SOAPPart::getAsBytes"); |
| if ( currentForm == FORM_OPTIMIZED ) { |
| log.debug("Exit: SOAPPart::getAsBytes"); |
| try { |
| return ((ByteArray) currentMessage).toByteArray(); |
| } catch (IOException e) { |
| throw AxisFault.makeFault(e); |
| } |
| } |
| if ( currentForm == FORM_BYTES ) { |
| log.debug("Exit: SOAPPart::getAsBytes"); |
| return (byte[])currentMessage; |
| } |
| |
| if ( currentForm == FORM_BODYINSTREAM ) { |
| try { |
| getAsSOAPEnvelope(); |
| } catch (Exception e) { |
| log.fatal(Messages.getMessage("makeEnvFail00"), e); |
| log.debug("Exit: SOAPPart::getAsBytes"); |
| return null; |
| } |
| } |
| |
| if ( currentForm == FORM_INPUTSTREAM ) { |
| // Assumes we don't need a content length |
| try { |
| InputStream inp = null; |
| byte[] buf = null; |
| try{ |
| inp = (InputStream) currentMessage ; |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| buf = new byte[4096]; |
| int len ; |
| while ( (len = inp.read(buf,0,4096)) != -1 ) |
| baos.write( buf, 0, len ); |
| buf = baos.toByteArray(); |
| }finally{ |
| if(inp != null && |
| currentMessage instanceof org.apache.axis.transport.http.SocketInputStream ) |
| inp.close(); |
| } |
| setCurrentForm( buf, FORM_BYTES ); |
| log.debug("Exit: SOAPPart::getAsBytes"); |
| return (byte[])currentMessage; |
| } |
| catch( Exception e ) { |
| log.error(Messages.getMessage("exception00"), e); |
| } |
| log.debug("Exit: SOAPPart::getAsBytes"); |
| return null; |
| } |
| |
| if ( currentForm == FORM_SOAPENVELOPE || |
| currentForm == FORM_FAULT ){ |
| currentEncoding = XMLUtils.getEncoding(msgObject, null); |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| BufferedOutputStream os = new BufferedOutputStream(baos); |
| try { |
| this.writeTo(os); |
| os.flush(); |
| } catch (Exception e) { |
| throw AxisFault.makeFault(e); |
| } |
| setCurrentForm(baos.toByteArray(), FORM_BYTES); |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsBytes(): " + currentMessage); |
| } |
| return (byte[]) currentMessage; |
| } |
| |
| if ( currentForm == FORM_STRING ) { |
| // If the current message was already converted from |
| // a byte[] to String, return the byte[] representation |
| // (this is done to avoid unnecessary conversions) |
| if (currentMessage == currentMessageAsString && |
| currentMessageAsBytes != null) { |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsBytes()"); |
| } |
| return currentMessageAsBytes; |
| } |
| // Save this message in case it is requested later in getAsString |
| currentMessageAsString = (String) currentMessage; |
| try{ |
| currentEncoding = XMLUtils.getEncoding(msgObject, null); |
| setCurrentForm( ((String)currentMessage).getBytes(currentEncoding), |
| FORM_BYTES ); |
| }catch(UnsupportedEncodingException ue){ |
| setCurrentForm( ((String)currentMessage).getBytes(), |
| FORM_BYTES ); |
| } |
| currentMessageAsBytes = (byte[]) currentMessage; |
| |
| log.debug("Exit: SOAPPart::getAsBytes"); |
| return (byte[])currentMessage; |
| } |
| |
| log.error(Messages.getMessage("cantConvert00", ""+currentForm)); |
| |
| log.debug("Exit: SOAPPart::getAsBytes"); |
| return null; |
| } |
| |
| public void saveChanges() throws AxisFault { |
| log.debug("Enter: SOAPPart::saveChanges"); |
| if ( currentForm == FORM_SOAPENVELOPE || |
| currentForm == FORM_FAULT ){ |
| currentEncoding = XMLUtils.getEncoding(msgObject, null); |
| ByteArray array = new ByteArray(); |
| try { |
| writeTo(array); |
| array.flush(); |
| } catch (Exception e) { |
| throw AxisFault.makeFault(e); |
| } |
| setCurrentForm( array, FORM_OPTIMIZED ); |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::saveChanges(): " + currentMessage); |
| } |
| } |
| } |
| /** |
| * Get the contents of this Part (not the headers!), as a String. |
| * This will force buffering of the message. |
| * |
| * @return a <code>String</code> containing the content of this message |
| * @throws AxisFault if there is an error serializing this part |
| */ |
| public String getAsString() throws AxisFault { |
| log.debug("Enter: SOAPPart::getAsString"); |
| if ( currentForm == FORM_STRING ) { |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); |
| } |
| return (String)currentMessage; |
| } |
| |
| if ( currentForm == FORM_INPUTSTREAM || |
| currentForm == FORM_BODYINSTREAM ) { |
| getAsBytes(); |
| // Fall thru to "Bytes" |
| } |
| |
| if ( currentForm == FORM_OPTIMIZED) { |
| try { |
| currentMessageAsBytes = |
| ((ByteArray) currentMessage).toByteArray(); |
| } catch (IOException e) { |
| throw AxisFault.makeFault(e); |
| } |
| |
| try{ |
| setCurrentForm(new String((byte[])currentMessageAsBytes, |
| currentEncoding), |
| FORM_STRING); |
| }catch(UnsupportedEncodingException ue){ |
| setCurrentForm( new String((byte[]) currentMessageAsBytes), |
| FORM_STRING ); |
| } |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); |
| } |
| return (String)currentMessage; |
| } |
| |
| if ( currentForm == FORM_BYTES ) { |
| // If the current message was already converted from |
| // a String to byte[], return the String representation |
| // (this is done to avoid unnecessary conversions) |
| if (currentMessage == currentMessageAsBytes && |
| currentMessageAsString != null) { |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsString(): " + currentMessageAsString); |
| } |
| return currentMessageAsString; |
| } |
| |
| // Save this message in case it is requested later in getAsBytes |
| currentMessageAsBytes = (byte[]) currentMessage; |
| try{ |
| setCurrentForm(new String((byte[])currentMessage, |
| currentEncoding), |
| FORM_STRING); |
| }catch(UnsupportedEncodingException ue){ |
| setCurrentForm( new String((byte[]) currentMessage), |
| FORM_STRING ); |
| } |
| currentMessageAsString = (String) currentMessage; |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); |
| } |
| return (String)currentMessage; |
| } |
| |
| if ( currentForm == FORM_FAULT ) { |
| StringWriter writer = new StringWriter(); |
| try { |
| this.writeTo(writer); |
| } catch (Exception e) { |
| log.error(Messages.getMessage("exception00"), e); |
| return null; |
| } |
| setCurrentForm(writer.getBuffer().toString(), FORM_STRING); |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); |
| } |
| return (String)currentMessage; |
| } |
| |
| if ( currentForm == FORM_SOAPENVELOPE ) { |
| StringWriter writer = new StringWriter(); |
| try { |
| this.writeTo(writer); |
| } catch (Exception e) { |
| throw AxisFault.makeFault(e); |
| } |
| setCurrentForm(writer.getBuffer().toString(), FORM_STRING); |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); |
| } |
| return (String)currentMessage; |
| } |
| |
| log.error( Messages.getMessage("cantConvert01", ""+currentForm)); |
| |
| log.debug("Exit: SOAPPart::getAsString()"); |
| return null; |
| } |
| |
| /** |
| * Get the contents of this Part (not the MIME headers!), as a |
| * SOAPEnvelope. This will force a complete parse of the |
| * message. |
| * |
| * @return a <code>SOAPEnvelope</code> containing the message content |
| * @throws AxisFault if the envelope could not be constructed |
| */ |
| public SOAPEnvelope getAsSOAPEnvelope() |
| throws AxisFault |
| { |
| if (log.isDebugEnabled()) { |
| log.debug("Enter: SOAPPart::getAsSOAPEnvelope()"); |
| log.debug(Messages.getMessage("currForm", formNames[currentForm])); |
| } |
| if ( currentForm == FORM_SOAPENVELOPE ) |
| return (SOAPEnvelope)currentMessage; |
| |
| |
| if (currentForm == FORM_BODYINSTREAM) { |
| InputStreamBody bodyEl = |
| new InputStreamBody((InputStream)currentMessage); |
| SOAPEnvelope env = new SOAPEnvelope(); |
| env.setOwnerDocument(this); |
| env.addBodyElement(bodyEl); |
| setCurrentForm(env, FORM_SOAPENVELOPE); |
| return env; |
| } |
| |
| InputSource is; |
| |
| if ( currentForm == FORM_INPUTSTREAM ) { |
| is = new InputSource( (InputStream) currentMessage ); |
| String encoding = XMLUtils.getEncoding(msgObject, null, null); |
| if (encoding != null) { |
| currentEncoding = encoding; |
| is.setEncoding(currentEncoding); |
| } |
| } else { |
| is = new InputSource(new StringReader(getAsString())); |
| } |
| DeserializationContext dser = new DeserializationContext(is, |
| getMessage().getMessageContext(), |
| getMessage().getMessageType()); |
| dser.getEnvelope().setOwnerDocument(this); |
| // This may throw a SAXException |
| try { |
| dser.parse(); |
| } catch (SAXException e) { |
| Exception real = e.getException(); |
| if (real == null) |
| real = e; |
| throw AxisFault.makeFault(real); |
| } |
| |
| SOAPEnvelope nse= dser.getEnvelope(); |
| if(currentMessageAsEnvelope != null){ |
| //Need to synchronize back processed header info. |
| Vector newHeaders= nse.getHeaders(); |
| Vector oldHeaders= currentMessageAsEnvelope.getHeaders(); |
| if( null != newHeaders && null != oldHeaders){ |
| Iterator ohi= oldHeaders.iterator(); |
| Iterator nhi= newHeaders.iterator(); |
| while( ohi.hasNext() && nhi.hasNext()){ |
| SOAPHeaderElement nhe= (SOAPHeaderElement)nhi.next(); |
| SOAPHeaderElement ohe= (SOAPHeaderElement)ohi.next(); |
| |
| if(ohe.isProcessed()) nhe.setProcessed(true); |
| } |
| } |
| |
| } |
| |
| setCurrentForm(nse, FORM_SOAPENVELOPE); |
| |
| log.debug("Exit: SOAPPart::getAsSOAPEnvelope"); |
| SOAPEnvelope env = (SOAPEnvelope)currentMessage; |
| env.setOwnerDocument(this); |
| return env; |
| } |
| |
| /** |
| * Add the specified MIME header, as per JAXM. |
| * |
| * @param header the header to add |
| * @param value the value of that header |
| */ |
| public void addMimeHeader (String header, String value) { |
| mimeHeaders.addHeader(header, value); |
| } |
| |
| /** |
| * Get the specified MIME header. |
| * |
| * @param header the name of a MIME header |
| * @return the value of the first header named <code>header</code> |
| */ |
| private String getFirstMimeHeader (String header) { |
| String[] values = mimeHeaders.getHeader(header); |
| if(values != null && values.length>0) |
| return values[0]; |
| return null; |
| } |
| |
| /** |
| * Total size in bytes (of all content and headers, as encoded). |
| public abstract int getSize(); |
| */ |
| |
| /** |
| * Content location. |
| * |
| * @return the content location |
| */ |
| public String getContentLocation() { |
| return getFirstMimeHeader(HTTPConstants.HEADER_CONTENT_LOCATION); |
| } |
| |
| /** |
| * Set content location. |
| * |
| * @param loc the content location |
| */ |
| public void setContentLocation(String loc) { |
| setMimeHeader(HTTPConstants.HEADER_CONTENT_LOCATION, loc); |
| } |
| |
| /** |
| * Sets Content-Id of this part. |
| * already defined. |
| * @param newCid new Content-Id |
| */ |
| public void setContentId(String newCid){ |
| setMimeHeader(HTTPConstants.HEADER_CONTENT_ID,newCid); |
| } |
| |
| /** |
| * Content ID. |
| * |
| * @return the content ID |
| */ |
| public String getContentId() { |
| return getFirstMimeHeader(HTTPConstants.HEADER_CONTENT_ID); |
| } |
| /** |
| * Content ID. |
| * |
| * @return the contentId reference value that should be used directly |
| * as an href in a SOAP element to reference this attachment. |
| * <B>Not part of JAX-RPC, JAX-M, SAAJ, etc. </B> |
| */ |
| public String getContentIdRef() { |
| return org.apache.axis.attachments.Attachments.CIDprefix + |
| getContentId(); |
| } |
| |
| |
| /** |
| * Get all headers that match. |
| * |
| * @param match an array of <code>String</code>s giving mime header names |
| * @return an <code>Iterator</code> over all values matching these headers |
| */ |
| public java.util.Iterator getMatchingMimeHeaders( final String[] match){ |
| return mimeHeaders.getMatchingHeaders(match); |
| } |
| |
| /** |
| * Get all headers that do not match. |
| * |
| * @param match an array of <code>String</code>s giving mime header names |
| * @return an <code>Iterator</code> over all values not matching these |
| * headers |
| */ |
| public java.util.Iterator getNonMatchingMimeHeaders( final String[] match){ |
| return mimeHeaders.getNonMatchingHeaders(match); |
| } |
| |
| /** |
| * Sets the content of the <CODE>SOAPEnvelope</CODE> object |
| * with the data from the given <CODE>Source</CODE> object. |
| * @param source <CODE>javax.xml.transform.Source</CODE> object with the data to |
| * be set |
| * @throws SOAPException if there is a problem in |
| * setting the source |
| * @see #getContent() getContent() |
| */ |
| public void setContent(Source source) throws SOAPException { |
| if(source == null) |
| throw new SOAPException(Messages.getMessage("illegalArgumentException00")); |
| |
| // override the checks in HandlerChainImpl for JAXRPCHandler kludge |
| MessageContext ctx = getMessage().getMessageContext(); |
| if (ctx != null) { |
| ctx.setProperty(org.apache.axis.SOAPPart.ALLOW_FORM_OPTIMIZATION, |
| Boolean.TRUE); |
| } |
| |
| contentSource = source; |
| InputSource in = org.apache.axis.utils.XMLUtils.sourceToInputSource(contentSource); |
| InputStream is = in.getByteStream(); |
| if(is != null) { |
| setCurrentMessage(is, FORM_INPUTSTREAM); |
| } else { |
| Reader r = in.getCharacterStream(); |
| if(r == null) { |
| throw new SOAPException(Messages.getMessage("noCharacterOrByteStream")); |
| } |
| BufferedReader br = new BufferedReader(r); |
| String line = null; |
| StringBuffer sb = new StringBuffer(); |
| try { |
| while((line = br.readLine()) != null) { |
| sb.append(line); |
| } |
| } catch (IOException e) { |
| throw new SOAPException(Messages.getMessage("couldNotReadFromCharStream"), e); |
| } |
| setCurrentMessage(sb.toString(), FORM_STRING); |
| } |
| } |
| |
| /** |
| * Returns the content of the SOAPEnvelope as a JAXP <CODE> |
| * Source</CODE> object. |
| * @return the content as a <CODE> |
| * javax.xml.transform.Source</CODE> object |
| * @throws SOAPException if the implementation cannot |
| * convert the specified <CODE>Source</CODE> object |
| * @see #setContent(javax.xml.transform.Source) setContent(javax.xml.transform.Source) |
| */ |
| public Source getContent() throws SOAPException { |
| if(contentSource == null) { |
| switch(currentForm) { |
| case FORM_STRING: |
| String s = (String) currentMessage; |
| contentSource = new StreamSource(new StringReader(s)); |
| break; |
| case FORM_INPUTSTREAM: |
| contentSource = |
| new StreamSource((InputStream) currentMessage); |
| break; |
| case FORM_SOAPENVELOPE: |
| SOAPEnvelope se = (SOAPEnvelope) currentMessage; |
| try { |
| contentSource = new DOMSource(se.getAsDocument()); |
| } catch (Exception e) { |
| throw new SOAPException(Messages.getMessage("errorGetDocFromSOAPEnvelope"), |
| e); |
| } |
| break; |
| case FORM_OPTIMIZED: |
| try { |
| ByteArrayInputStream baos = new ByteArrayInputStream(((ByteArray) currentMessage).toByteArray()); |
| contentSource = new StreamSource(baos); |
| } catch (IOException e) { |
| throw new SOAPException(Messages.getMessage("errorGetDocFromSOAPEnvelope"), |
| e); |
| } |
| break; |
| case FORM_BYTES: |
| byte[] bytes = (byte[]) currentMessage; |
| contentSource = |
| new StreamSource(new ByteArrayInputStream(bytes)); |
| break; |
| case FORM_BODYINSTREAM: |
| contentSource = |
| new StreamSource((InputStream) currentMessage); |
| break; |
| } |
| } |
| return contentSource; |
| } |
| |
| /** |
| * Retrieves all the headers for this <CODE>SOAPPart</CODE> |
| * object as an iterator over the <CODE>MimeHeader</CODE> |
| * objects. |
| * @return an <CODE>Iterator</CODE> object with all of the Mime |
| * headers for this <CODE>SOAPPart</CODE> object |
| */ |
| public Iterator getAllMimeHeaders() { |
| return mimeHeaders.getAllHeaders(); |
| } |
| |
| /** |
| * Changes the first header entry that matches the given |
| * header name so that its value is the given value, adding a |
| * new header with the given name and value if no existing |
| * header is a match. If there is a match, this method clears |
| * all existing values for the first header that matches and |
| * sets the given value instead. If more than one header has |
| * the given name, this method removes all of the matching |
| * headers after the first one. |
| * |
| * <P>Note that RFC822 headers can contain only US-ASCII |
| * characters.</P> |
| * @param name a <CODE>String</CODE> giving the |
| * header name for which to search |
| * @param value a <CODE>String</CODE> giving the |
| * value to be set. This value will be substituted for the |
| * current value(s) of the first header that is a match if |
| * there is one. If there is no match, this value will be |
| * the value for a new <CODE>MimeHeader</CODE> object. |
| * @throws java.lang.IllegalArgumentException if |
| * there was a problem with the specified mime header name |
| * or value |
| * @see #getMimeHeader(java.lang.String) getMimeHeader(java.lang.String) |
| */ |
| public void setMimeHeader(String name, String value) { |
| mimeHeaders.setHeader(name,value); |
| } |
| |
| /** |
| * Gets all the values of the <CODE>MimeHeader</CODE> object |
| * in this <CODE>SOAPPart</CODE> object that is identified by |
| * the given <CODE>String</CODE>. |
| * @param name the name of the header; example: |
| * "Content-Type" |
| * @return a <CODE>String</CODE> array giving all the values for |
| * the specified header |
| * @see #setMimeHeader(java.lang.String, java.lang.String) setMimeHeader(java.lang.String, java.lang.String) |
| */ |
| public String[] getMimeHeader(String name) { |
| return mimeHeaders.getHeader(name); |
| } |
| |
| /** |
| * Removes all the <CODE>MimeHeader</CODE> objects for this |
| * <CODE>SOAPEnvelope</CODE> object. |
| */ |
| public void removeAllMimeHeaders() { |
| mimeHeaders.removeAllHeaders(); |
| } |
| |
| /** |
| * Removes all MIME headers that match the given name. |
| * @param header a <CODE>String</CODE> giving |
| * the name of the MIME header(s) to be removed |
| */ |
| public void removeMimeHeader(String header) { |
| mimeHeaders.removeHeader(header); |
| } |
| |
| /** |
| * Gets the <CODE>SOAPEnvelope</CODE> object associated with |
| * this <CODE>SOAPPart</CODE> object. Once the SOAP envelope is |
| * obtained, it can be used to get its contents. |
| * @return the <CODE>SOAPEnvelope</CODE> object for this <CODE> |
| * SOAPPart</CODE> object |
| * @throws SOAPException if there is a SOAP error |
| */ |
| public javax.xml.soap.SOAPEnvelope getEnvelope() throws SOAPException { |
| try { |
| return getAsSOAPEnvelope(); |
| } catch (AxisFault af) { |
| throw new SOAPException(af); |
| } |
| } |
| |
| /** |
| * Implementation of org.w3c.Document |
| * Most of methods will be implemented using the delgate |
| * instance of SOAPDocumentImpl |
| * This is for two reasons: |
| * - possible change of message classes, by extenstion of xerces implementation |
| * - we cannot extends SOAPPart (multiple inheritance), |
| * since it is defined as Abstract class |
| * *********************************************************** |
| */ |
| |
| private Document document = new SOAPDocumentImpl(this); |
| /** |
| * @since SAAJ 1.2 |
| */ |
| public Document getSOAPDocument(){ |
| if(document == null){ |
| document = new SOAPDocumentImpl(this); |
| } |
| return document; |
| } |
| |
| /** |
| * @return |
| */ |
| public DocumentType getDoctype(){ |
| return document.getDoctype(); |
| } |
| |
| /** |
| * @return |
| */ |
| public DOMImplementation getImplementation(){ |
| return document.getImplementation(); |
| } |
| |
| /** |
| * SOAPEnvelope is the Document Elements of this XML docuement |
| */ |
| protected Document mDocument; |
| |
| public Element getDocumentElement() |
| { |
| try{ |
| return getEnvelope(); |
| }catch(SOAPException se){ |
| return null; |
| } |
| } |
| |
| /** |
| * |
| * @param tagName |
| * @return |
| * @throws DOMException |
| */ |
| public Element createElement(String tagName) throws DOMException { |
| return document.createElement(tagName); |
| } |
| |
| public DocumentFragment createDocumentFragment() { |
| return document.createDocumentFragment(); |
| } |
| |
| public Text createTextNode(String data) { |
| return document.createTextNode(data); |
| } |
| |
| public Comment createComment(String data){ |
| return document.createComment(data); |
| } |
| |
| public CDATASection createCDATASection(String data) throws DOMException { |
| return document.createCDATASection(data); |
| } |
| |
| public ProcessingInstruction createProcessingInstruction(String target, String data) |
| throws DOMException { |
| return document.createProcessingInstruction(target,data); |
| } |
| |
| public Attr createAttribute(String name)throws DOMException { |
| return document.createAttribute(name); |
| } |
| |
| public EntityReference createEntityReference(String name) throws DOMException { |
| return document.createEntityReference(name); |
| } |
| |
| public NodeList getElementsByTagName(String tagname) { |
| return document.getElementsByTagName(tagname); |
| } |
| |
| public Node importNode(Node importedNode, boolean deep) |
| throws DOMException { |
| return document.importNode(importedNode, deep); |
| } |
| |
| public Element createElementNS(String namespaceURI, String qualifiedName) |
| throws DOMException { |
| return document.createElementNS(namespaceURI, qualifiedName); |
| } |
| |
| public Attr createAttributeNS(String namespaceURI, String qualifiedName) |
| throws DOMException { |
| return document.createAttributeNS(namespaceURI, qualifiedName); |
| } |
| |
| public NodeList getElementsByTagNameNS(String namespaceURI, String localName) { |
| return document.getElementsByTagNameNS(namespaceURI,localName); |
| } |
| |
| public Element getElementById(String elementId){ |
| return document.getElementById(elementId); |
| } |
| |
| ///////////////////////////////////////////////////////////// |
| |
| public String getEncoding() |
| { |
| return currentEncoding; |
| } |
| |
| public void setEncoding(String s) |
| { |
| currentEncoding = s; |
| } |
| |
| public boolean getStandalone() |
| { |
| throw new UnsupportedOperationException("Not yet implemented.71"); |
| } |
| |
| |
| public void setStandalone(boolean flag) |
| { |
| throw new UnsupportedOperationException("Not yet implemented.72"); |
| } |
| |
| public boolean getStrictErrorChecking() |
| { |
| throw new UnsupportedOperationException("Not yet implemented.73"); |
| } |
| |
| |
| public void setStrictErrorChecking(boolean flag) |
| { |
| throw new UnsupportedOperationException("Not yet implemented. 74"); |
| } |
| |
| |
| public String getVersion() |
| { |
| throw new UnsupportedOperationException("Not yet implemented. 75"); |
| } |
| |
| |
| public void setVersion(String s) |
| { |
| throw new UnsupportedOperationException("Not yet implemented.76"); |
| } |
| |
| |
| public Node adoptNode(Node node) |
| throws DOMException |
| { |
| throw new UnsupportedOperationException("Not yet implemented.77"); |
| } |
| |
| /** |
| * Node Implementation |
| */ |
| |
| public String getNodeName(){ |
| return document.getNodeName(); |
| } |
| |
| public String getNodeValue() throws DOMException { |
| return document.getNodeValue(); |
| } |
| |
| public void setNodeValue(String nodeValue) throws DOMException{ |
| document.setNodeValue(nodeValue); |
| } |
| |
| public short getNodeType() { |
| return document.getNodeType(); |
| } |
| |
| public Node getParentNode(){ |
| return document.getParentNode(); |
| } |
| |
| public NodeList getChildNodes() { |
| return document.getChildNodes(); |
| } |
| |
| public Node getFirstChild() { |
| return document.getFirstChild(); |
| } |
| |
| public Node getLastChild(){ |
| return document.getLastChild(); |
| } |
| |
| public Node getPreviousSibling(){ |
| return document.getPreviousSibling(); |
| } |
| |
| public Node getNextSibling(){ |
| return document.getNextSibling(); |
| } |
| |
| public NamedNodeMap getAttributes(){ |
| return document.getAttributes(); |
| } |
| |
| public Document getOwnerDocument(){ |
| return document.getOwnerDocument(); |
| } |
| |
| public Node insertBefore(Node newChild, Node refChild) throws DOMException { |
| return document.insertBefore(newChild, refChild); |
| } |
| |
| public Node replaceChild(Node newChild, Node oldChild) throws DOMException { |
| return document.replaceChild(newChild, oldChild); |
| } |
| |
| public Node removeChild(Node oldChild) throws DOMException { |
| return document.removeChild(oldChild); |
| } |
| |
| public Node appendChild(Node newChild) throws DOMException { |
| return document.appendChild(newChild); |
| } |
| |
| public boolean hasChildNodes(){ |
| return document.hasChildNodes(); |
| } |
| public Node cloneNode(boolean deep) { |
| return document.cloneNode(deep); |
| } |
| |
| public void normalize(){ |
| document.normalize(); |
| } |
| |
| public boolean isSupported(String feature, String version){ |
| return document.isSupported(feature, version); |
| } |
| |
| public String getNamespaceURI() { |
| return document.getNamespaceURI(); |
| } |
| |
| public String getPrefix() { |
| return document.getPrefix(); |
| } |
| |
| public void setPrefix(String prefix) throws DOMException { |
| document.setPrefix(prefix); |
| } |
| public String getLocalName() { |
| return document.getLocalName(); |
| } |
| |
| public boolean hasAttributes(){ |
| return document.hasAttributes(); |
| } |
| |
| public boolean isBodyStream() { |
| return (currentForm == SOAPPart.FORM_INPUTSTREAM || currentForm == SOAPPart.FORM_BODYINSTREAM); |
| } |
| } |
| |
