/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.xml.messaging.saaj.soap;
import java.io.*;
import java.util.Iterator;
import java.util.logging.Logger;
import java.util.logging.Level;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.xml.soap.*;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import org.w3c.dom.*;
import com.sun.xml.messaging.saaj.packaging.mime.internet.MimeBodyPart;
import com.sun.xml.messaging.saaj.SOAPExceptionImpl;
import com.sun.xml.messaging.saaj.soap.impl.ElementImpl;
import com.sun.xml.messaging.saaj.soap.impl.EnvelopeImpl;
import com.sun.xml.messaging.saaj.soap.name.NameImpl;
import com.sun.xml.messaging.saaj.util.*;
import javax.xml.transform.sax.SAXSource;
/**
* SOAPPartImpl is the first attachment. This contains the XML/SOAP document.
*
* @author Anil Vijendran (anil@sun.com)
*/
public abstract class SOAPPartImpl extends SOAPPart implements SOAPDocument {
protected static final Logger log =
Logger.getLogger(LogDomainConstants.SOAP_DOMAIN,
"com.sun.xml.messaging.saaj.soap.LocalStrings");
protected MimeHeaders headers;
protected Envelope envelope;
protected Source source;
protected SOAPDocumentImpl document;
//flag to indicate if a setContent happened.
private boolean sourceWasSet = false;
// Records whether the input source had an xml decl or not.
protected boolean omitXmlDecl = true;
// Records the charset encoding of the input stream source if provided.
protected String sourceCharsetEncoding = null;
/**
* Reference to containing message (may be null)
*/
protected MessageImpl message;
protected SOAPPartImpl() {
this(null);
}
protected SOAPPartImpl(MessageImpl message) {
document = new SOAPDocumentImpl(this);
headers = new MimeHeaders();
this.message = message;
headers.setHeader("Content-Type", getContentType());
}
protected abstract String getContentType();
protected abstract Envelope createEnvelopeFromSource()
throws SOAPException;
protected abstract Envelope createEmptyEnvelope(String prefix)
throws SOAPException;
protected abstract SOAPPartImpl duplicateType();
protected String getContentTypeString() {
return getContentType();
}
public boolean isFastInfoset() {
return (message != null) ? message.isFastInfoset() : false;
}
public SOAPEnvelope getEnvelope() throws SOAPException {
// If there is no SOAP envelope already created, then create
// one from a source if one exists. If there is a newer source
// then use that source.
if (sourceWasSet)
sourceWasSet = false;
lookForEnvelope();
if (envelope != null) {
if (source != null) { // there's a newer source, use it
document.removeChild(envelope);
envelope = createEnvelopeFromSource();
}
} else if (source != null) {
envelope = createEnvelopeFromSource();
} else {
envelope = createEmptyEnvelope(null);
document.insertBefore(envelope, null);
}
return envelope;
}
protected void lookForEnvelope() throws SOAPException {
Element envelopeChildElement = document.doGetDocumentElement();
if (envelopeChildElement == null || envelopeChildElement instanceof Envelope) {
envelope = (EnvelopeImpl) envelopeChildElement;
} else if (!(envelopeChildElement instanceof ElementImpl)) {
log.severe("SAAJ0512.soap.incorrect.factory.used");
throw new SOAPExceptionImpl("Unable to create envelope: incorrect factory used during tree construction");
} else {
ElementImpl soapElement = (ElementImpl) envelopeChildElement;
if (soapElement.getLocalName().equalsIgnoreCase("Envelope")) {
String prefix = soapElement.getPrefix();
String uri = (prefix == null) ? soapElement.getNamespaceURI() : soapElement.getNamespaceURI(prefix);
if(!uri.equals(NameImpl.SOAP11_NAMESPACE) && !uri.equals(NameImpl.SOAP12_NAMESPACE)) {
log.severe("SAAJ0513.soap.unknown.ns");
throw new SOAPVersionMismatchException("Unable to create envelope from given source because the namespace was not recognized");
}
} else {
log.severe("SAAJ0514.soap.root.elem.not.named.envelope");
throw new SOAPExceptionImpl(
"Unable to create envelope from given source because the root element is not named \"Envelope\"");
}
}
}
public void removeAllMimeHeaders() {
headers.removeAllHeaders();
}
public void removeMimeHeader(String header) {
headers.removeHeader(header);
}
public String[] getMimeHeader(String name) {
return headers.getHeader(name);
}
public void setMimeHeader(String name, String value) {
headers.setHeader(name, value);
}
public void addMimeHeader(String name, String value) {
headers.addHeader(name, value);
}
public Iterator getAllMimeHeaders() {
return headers.getAllHeaders();
}
public Iterator getMatchingMimeHeaders(String[] names) {
return headers.getMatchingHeaders(names);
}
public Iterator getNonMatchingMimeHeaders(String[] names) {
return headers.getNonMatchingHeaders(names);
}
public Source getContent() throws SOAPException {
if (source != null) {
InputStream bis = null;
if (source instanceof JAXMStreamSource) {
StreamSource streamSource = (StreamSource)source;
bis = streamSource.getInputStream();
} else if (FastInfosetReflection.isFastInfosetSource(source)) {
// FastInfosetSource inherits from SAXSource
SAXSource saxSource = (SAXSource)source;
bis = saxSource.getInputSource().getByteStream();
}
if (bis != null) {
try {
bis.reset();
} catch (IOException e) {
/* This exception will never be thrown.
*
* The setContent method will modify the source
* if StreamSource to JAXMStreamSource, that uses
* a ByteInputStream, and for a FastInfosetSource will
* replace the InputStream with a ByteInputStream.
*/
}
}
return source;
}
return ((Envelope) getEnvelope()).getContent();
}
public void setContent(Source source) throws SOAPException {
try {
if (source instanceof StreamSource) {
InputStream is = ((StreamSource) source).getInputStream();
Reader rdr = ((StreamSource) source).getReader();
if (is != null) {
this.source = new JAXMStreamSource(is);
} else if (rdr != null) {
this.source = new JAXMStreamSource(rdr);
} else {
log.severe("SAAJ0544.soap.no.valid.reader.for.src");
throw new SOAPExceptionImpl("Source does not have a valid Reader or InputStream");
}
}
else if (FastInfosetReflection.isFastInfosetSource(source)) {
// InputStream is = source.getInputStream()
InputStream is = FastInfosetReflection.FastInfosetSource_getInputStream(source);
/*
* Underlying stream must be ByteInputStream for getContentAsStream(). We pay the
* cost of copying the underlying bytes here to avoid multiple copies every time
* getBytes() is called on a ByteInputStream.
*/
if (!(is instanceof ByteInputStream)) {
ByteOutputStream bout = new ByteOutputStream();
bout.write(is);
// source.setInputStream(new ByteInputStream(...))
FastInfosetReflection.FastInfosetSource_setInputStream(
source, bout.newInputStream());
}
this.source = source;
}
else {
this.source = source;
}
sourceWasSet = true;
}
catch (Exception ex) {
ex.printStackTrace();
log.severe("SAAJ0545.soap.cannot.set.src.for.part");
throw new SOAPExceptionImpl(
"Error setting the source for SOAPPart: " + ex.getMessage());
}
}
public ByteInputStream getContentAsStream() throws IOException {
if (source != null) {
InputStream is = null;
// Allow message to be transcode if so requested
if (source instanceof StreamSource && !isFastInfoset()) {
is = ((StreamSource) source).getInputStream();
}
else if (FastInfosetReflection.isFastInfosetSource(source) &&
isFastInfoset())
{
try {
// InputStream is = source.getInputStream()
is = FastInfosetReflection.FastInfosetSource_getInputStream(source);
}
catch (Exception e) {
throw new IOException(e.toString());
}
}
if (is != null) {
if (!(is instanceof ByteInputStream)) {
log.severe("SAAJ0546.soap.stream.incorrect.type");
throw new IOException("Internal error: stream not of the right type");
}
return (ByteInputStream) is;
}
// need to do something here for reader...
// for now we'll see if we can fallback...
}
ByteOutputStream b = new ByteOutputStream();
Envelope env = null;
try {
env = (Envelope) getEnvelope();
env.output(b, isFastInfoset());
}
catch (SOAPException soapException) {
log.severe("SAAJ0547.soap.cannot.externalize");
throw new SOAPIOException(
"SOAP exception while trying to externalize: ",
soapException);
}
return b.newInputStream();
}
MimeBodyPart getMimePart() throws SOAPException {
try {
MimeBodyPart headerEnvelope = new MimeBodyPart();
headerEnvelope.setDataHandler(getDataHandler());
AttachmentPartImpl.copyMimeHeaders(headers, headerEnvelope);
return headerEnvelope;
} catch (SOAPException ex) {
throw ex;
} catch (Exception ex) {
log.severe("SAAJ0548.soap.cannot.externalize.hdr");
throw new SOAPExceptionImpl("Unable to externalize header", ex);
}
}
MimeHeaders getMimeHeaders() {
return headers;
}
DataHandler getDataHandler() {
DataSource ds = new DataSource() {
public OutputStream getOutputStream() throws IOException {
throw new IOException("Illegal Operation");
}
public String getContentType() {
return getContentTypeString();
}
public String getName() {
return getContentId();
}
public InputStream getInputStream() throws IOException {
return getContentAsStream();
}
};
return new DataHandler(ds);
}
public SOAPDocumentImpl getDocument() {
handleNewSource();
return document;
}
public SOAPPartImpl getSOAPPart() {
return this;
}
public DocumentType getDoctype() {
return document.getDoctype();
}
// Forward all of these calls to the document to ensure that they work the
// same way whether they are called from here or directly from the document.
// If the document needs any help from this SOAPPart then
// Make it use a call-back as in doGetDocumentElement() below
public DOMImplementation getImplementation() {
return document.getImplementation();
}
public Element getDocumentElement() {
// If there is no SOAP envelope already created, then create
// one from a source if one exists. If there is a newer source
// then use that source.
try {
getEnvelope();
} catch (SOAPException e) {
}
return document.getDocumentElement();
}
protected void doGetDocumentElement() {
handleNewSource();
try {
lookForEnvelope();
} catch (SOAPException e) {
}
}
public Element createElement(String tagName) throws DOMException {
return document.createElement(tagName);
}
public DocumentFragment createDocumentFragment() {
return document.createDocumentFragment();
}
public org.w3c.dom.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) {
handleNewSource();
return document.getElementsByTagName(tagname);
}
public org.w3c.dom.Node importNode(
org.w3c.dom.Node importedNode,
boolean deep)
throws DOMException {
handleNewSource();
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) {
handleNewSource();
return document.getElementsByTagNameNS(namespaceURI, localName);
}
public Element getElementById(String elementId) {
handleNewSource();
return document.getElementById(elementId);
}
public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
throws DOMException {
handleNewSource();
return document.appendChild(newChild);
}
public org.w3c.dom.Node cloneNode(boolean deep) {
handleNewSource();
return document.cloneNode(deep);
}
protected SOAPPartImpl doCloneNode() {
handleNewSource();
SOAPPartImpl newSoapPart = duplicateType();
newSoapPart.headers = MimeHeadersUtil.copy(this.headers);
newSoapPart.source = this.source;
return newSoapPart;
}
public NamedNodeMap getAttributes() {
return document.getAttributes();
}
public NodeList getChildNodes() {
handleNewSource();
return document.getChildNodes();
}
public org.w3c.dom.Node getFirstChild() {
handleNewSource();
return document.getFirstChild();
}
public org.w3c.dom.Node getLastChild() {
handleNewSource();
return document.getLastChild();
}
public String getLocalName() {
return document.getLocalName();
}
public String getNamespaceURI() {
return document.getNamespaceURI();
}
public org.w3c.dom.Node getNextSibling() {
handleNewSource();
return document.getNextSibling();
}
public String getNodeName() {
return document.getNodeName();
}
public short getNodeType() {
return document.getNodeType();
}
public String getNodeValue() throws DOMException {
return document.getNodeValue();
}
public Document getOwnerDocument() {
return document.getOwnerDocument();
}
public org.w3c.dom.Node getParentNode() {
return document.getParentNode();
}
public String getPrefix() {
return document.getPrefix();
}
public org.w3c.dom.Node getPreviousSibling() {
return document.getPreviousSibling();
}
public boolean hasAttributes() {
return document.hasAttributes();
}
public boolean hasChildNodes() {
handleNewSource();
return document.hasChildNodes();
}
public org.w3c.dom.Node insertBefore(
org.w3c.dom.Node arg0,
org.w3c.dom.Node arg1)
throws DOMException {
handleNewSource();
return document.insertBefore(arg0, arg1);
}
public boolean isSupported(String arg0, String arg1) {
return document.isSupported(arg0, arg1);
}
public void normalize() {
handleNewSource();
document.normalize();
}
public org.w3c.dom.Node removeChild(org.w3c.dom.Node arg0)
throws DOMException {
handleNewSource();
return document.removeChild(arg0);
}
public org.w3c.dom.Node replaceChild(
org.w3c.dom.Node arg0,
org.w3c.dom.Node arg1)
throws DOMException {
handleNewSource();
return document.replaceChild(arg0, arg1);
}
public void setNodeValue(String arg0) throws DOMException {
document.setNodeValue(arg0);
}
public void setPrefix(String arg0) throws DOMException {
document.setPrefix(arg0);
}
private void handleNewSource() {
if (sourceWasSet) {
// There is a newer source use that source.
try {
getEnvelope();
} catch (SOAPException e) {
}
}
}
protected XMLDeclarationParser lookForXmlDecl() throws SOAPException {
if ((source != null) && (source instanceof StreamSource)) {
Reader reader = null;
InputStream inputStream = ((StreamSource) source).getInputStream();
if (inputStream != null) {
if (getSourceCharsetEncoding() == null) {
reader = new InputStreamReader(inputStream);
} else {
try {
reader =
new InputStreamReader(
inputStream, getSourceCharsetEncoding());
} catch (UnsupportedEncodingException uee) {
log.log(
Level.SEVERE,
"SAAJ0551.soap.unsupported.encoding",
new Object[] {getSourceCharsetEncoding()});
throw new SOAPExceptionImpl(
"Unsupported encoding " + getSourceCharsetEncoding(),
uee);
}
}
} else {
reader = ((StreamSource) source).getReader();
}
if (reader != null) {
PushbackReader pushbackReader =
new PushbackReader(reader, 4096); //some size to unread <?xml ....?>
XMLDeclarationParser ev =
new XMLDeclarationParser(pushbackReader);
try {
ev.parse();
} catch (Exception e) {
log.log(
Level.SEVERE,
"SAAJ0552.soap.xml.decl.parsing.failed");
throw new SOAPExceptionImpl(
"XML declaration parsing failed", e);
}
String xmlDecl = ev.getXmlDeclaration();
if ((xmlDecl != null) && (xmlDecl.length() > 0))
this.omitXmlDecl = false;
return ev;
}
}
return null;
}
public void setSourceCharsetEncoding(String charset) {
this.sourceCharsetEncoding = charset;
}
public org.w3c.dom.Node renameNode(org.w3c.dom.Node n, String namespaceURI, String qualifiedName)
throws DOMException {
handleNewSource();
return document.renameNode(n, namespaceURI, qualifiedName);
}
public void normalizeDocument() {
document.normalizeDocument();
}
public DOMConfiguration getDomConfig() {
return document.getDomConfig();
}
public org.w3c.dom.Node adoptNode(org.w3c.dom.Node source) throws DOMException {
handleNewSource();
return document.adoptNode(source);
}
public void setDocumentURI(String documentURI) {
document.setDocumentURI(documentURI);
}
public String getDocumentURI() {
return document.getDocumentURI();
}
public void setStrictErrorChecking(boolean strictErrorChecking) {
document.setStrictErrorChecking(strictErrorChecking);
}
public String getInputEncoding() {
return document.getInputEncoding();
}
public String getXmlEncoding() {
return document.getXmlEncoding();
}
public boolean getXmlStandalone() {
return document.getXmlStandalone();
}
public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
document.setXmlStandalone(xmlStandalone);
}
public String getXmlVersion() {
return document.getXmlVersion();
}
public void setXmlVersion(String xmlVersion) throws DOMException {
document.setXmlVersion(xmlVersion);
}
public boolean getStrictErrorChecking() {
return document.getStrictErrorChecking();
}
// DOM L3 methods from org.w3c.dom.Node
public String getBaseURI() {
return document.getBaseURI();
}
public short compareDocumentPosition(org.w3c.dom.Node other)
throws DOMException {
return document.compareDocumentPosition(other);
}
public String getTextContent()
throws DOMException {
return document.getTextContent();
}
public void setTextContent(String textContent) throws DOMException {
document.setTextContent(textContent);
}
public boolean isSameNode(org.w3c.dom.Node other) {
return document.isSameNode(other);
}
public String lookupPrefix(String namespaceURI) {
return document.lookupPrefix(namespaceURI);
}
public boolean isDefaultNamespace(String namespaceURI) {
return document.isDefaultNamespace(namespaceURI);
}
public String lookupNamespaceURI(String prefix) {
return document.lookupNamespaceURI(prefix);
}
public boolean isEqualNode(org.w3c.dom.Node arg) {
return document.isEqualNode(arg);
}
public Object getFeature(String feature,
String version) {
return document.getFeature(feature,version);
}
public Object setUserData(String key,
Object data,
UserDataHandler handler) {
return document.setUserData(key, data, handler);
}
public Object getUserData(String key) {
return document.getUserData(key);
}
public void recycleNode() {
// Nothing seems to be required to be done here
}
public String getValue() {
return null;
}
public void setValue(String value) {
log.severe("SAAJ0571.soappart.setValue.not.defined");
throw new IllegalStateException("Setting value of a soap part is not defined");
}
public void setParentElement(SOAPElement parent) throws SOAPException {
log.severe("SAAJ0570.soappart.parent.element.not.defined");
throw new SOAPExceptionImpl("The parent element of a soap part is not defined");
}
public SOAPElement getParentElement() {
return null;
}
public void detachNode() {
// Nothing seems to be required to be done here
}
public String getSourceCharsetEncoding() {
return sourceCharsetEncoding;
}
}