1 /*
   2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.xml.internal.messaging.saaj.soap.impl;
  27 
  28 import java.io.IOException;
  29 import java.io.OutputStream;
  30 import java.io.OutputStreamWriter;
  31 
  32 import java.util.logging.Level;
  33 
  34 import javax.xml.namespace.QName;
  35 import javax.xml.soap.*;
  36 import javax.xml.stream.XMLStreamException;
  37 import javax.xml.stream.XMLStreamReader;
  38 import javax.xml.stream.XMLStreamWriter;
  39 import javax.xml.transform.*;
  40 import javax.xml.transform.dom.DOMSource;
  41 import javax.xml.transform.stream.StreamResult;
  42 
  43 import com.sun.xml.internal.messaging.saaj.SOAPExceptionImpl;
  44 import com.sun.xml.internal.messaging.saaj.soap.LazyEnvelope;
  45 import com.sun.xml.internal.messaging.saaj.soap.SOAPDocumentImpl;
  46 import com.sun.xml.internal.messaging.saaj.soap.StaxBridge;
  47 import com.sun.xml.internal.messaging.saaj.soap.StaxLazySourceBridge;
  48 import com.sun.xml.internal.messaging.saaj.soap.name.NameImpl;
  49 import com.sun.xml.internal.messaging.saaj.util.FastInfosetReflection;
  50 import com.sun.xml.internal.messaging.saaj.util.stax.LazyEnvelopeStaxReader;
  51 import com.sun.xml.internal.messaging.saaj.util.transform.EfficientStreamingTransformer;
  52 
  53 import com.sun.xml.internal.org.jvnet.staxex.util.DOMStreamReader;
  54 import com.sun.xml.internal.org.jvnet.staxex.util.XMLStreamReaderToXMLStreamWriter;
  55 
  56 /**
  57  * Our implementation of the SOAP envelope.
  58  *
  59  * @author Anil Vijendran (anil@sun.com)
  60  */
  61 public abstract class EnvelopeImpl extends ElementImpl implements LazyEnvelope {
  62     protected HeaderImpl header;
  63     protected BodyImpl body;
  64     String omitXmlDecl = "yes";
  65     String charset = "utf-8";
  66     String xmlDecl = null;
  67 
  68     protected EnvelopeImpl(SOAPDocumentImpl ownerDoc, Name name) {
  69         super(ownerDoc, name);
  70     }
  71 
  72     protected EnvelopeImpl(SOAPDocumentImpl ownerDoc, QName name) {
  73         super(ownerDoc, name);
  74     }
  75 
  76     protected EnvelopeImpl(
  77         SOAPDocumentImpl ownerDoc,
  78         NameImpl name,
  79         boolean createHeader,
  80         boolean createBody)
  81         throws SOAPException {
  82         this(ownerDoc, name);
  83 
  84         ensureNamespaceIsDeclared(
  85             getElementQName().getPrefix(), getElementQName().getNamespaceURI());
  86 
  87         // XXX
  88         if (createHeader)
  89             addHeader();
  90 
  91         if (createBody)
  92             addBody();
  93     }
  94 
  95     protected abstract NameImpl getHeaderName(String prefix);
  96     protected abstract NameImpl getBodyName(String prefix);
  97 
  98     public SOAPHeader addHeader() throws SOAPException {
  99         return addHeader(null);
 100     }
 101 
 102     public SOAPHeader addHeader(String prefix) throws SOAPException {
 103 
 104         if (prefix == null || prefix.equals("")) {
 105             prefix = getPrefix();
 106         }
 107 
 108         NameImpl headerName = getHeaderName(prefix);
 109         NameImpl bodyName = getBodyName(prefix);
 110 
 111         HeaderImpl header = null;
 112         SOAPElement firstChild = (SOAPElement) getFirstChildElement();
 113 
 114         if (firstChild != null) {
 115             if (firstChild.getElementName().equals(headerName)) {
 116                 log.severe("SAAJ0120.impl.header.already.exists");
 117                 throw new SOAPExceptionImpl("Can't add a header when one is already present.");
 118             } else if (!firstChild.getElementName().equals(bodyName)) {
 119                 log.severe("SAAJ0121.impl.invalid.first.child.of.envelope");
 120                 throw new SOAPExceptionImpl("First child of Envelope must be either a Header or Body");
 121             }
 122         }
 123 
 124         header = (HeaderImpl) createElement(headerName);
 125         insertBefore(header, firstChild);
 126         header.ensureNamespaceIsDeclared(headerName.getPrefix(), headerName.getURI());
 127 
 128         return header;
 129     }
 130 
 131     protected void lookForHeader() throws SOAPException {
 132         NameImpl headerName = getHeaderName(null);
 133 
 134         HeaderImpl hdr = (HeaderImpl) findChild(headerName);
 135         header = hdr;
 136     }
 137 
 138     public SOAPHeader getHeader() throws SOAPException {
 139         lookForHeader();
 140         return header;
 141     }
 142 
 143     protected void lookForBody() throws SOAPException {
 144         NameImpl bodyName = getBodyName(null);
 145 
 146         BodyImpl bodyChildElement = (BodyImpl) findChild(bodyName);
 147         body = bodyChildElement;
 148     }
 149 
 150     public SOAPBody addBody() throws SOAPException {
 151         return addBody(null);
 152     }
 153 
 154     public SOAPBody addBody(String prefix) throws SOAPException {
 155         lookForBody();
 156 
 157         if (prefix == null || prefix.equals("")) {
 158             prefix = getPrefix();
 159         }
 160 
 161         if (body == null) {
 162             NameImpl bodyName = getBodyName(prefix);
 163             body = (BodyImpl) createElement(bodyName);
 164             insertBefore(body, null);
 165             body.ensureNamespaceIsDeclared(bodyName.getPrefix(), bodyName.getURI());
 166         } else {
 167             log.severe("SAAJ0122.impl.body.already.exists");
 168             throw new SOAPExceptionImpl("Can't add a body when one is already present.");
 169         }
 170 
 171         return body;
 172     }
 173 
 174     protected SOAPElement addElement(Name name) throws SOAPException {
 175         if (getBodyName(null).equals(name)) {
 176             return addBody(name.getPrefix());
 177         }
 178         if (getHeaderName(null).equals(name)) {
 179             return addHeader(name.getPrefix());
 180         }
 181 
 182         return super.addElement(name);
 183     }
 184 
 185     protected SOAPElement addElement(QName name) throws SOAPException {
 186         if (getBodyName(null).equals(NameImpl.convertToName(name))) {
 187             return addBody(name.getPrefix());
 188         }
 189         if (getHeaderName(null).equals(NameImpl.convertToName(name))) {
 190             return addHeader(name.getPrefix());
 191         }
 192 
 193         return super.addElement(name);
 194     }
 195 
 196     public SOAPBody getBody() throws SOAPException {
 197         lookForBody();
 198         return body;
 199     }
 200 
 201     public Source getContent() {
 202         return new DOMSource(getOwnerDocument());
 203     }
 204 
 205     public Name createName(String localName, String prefix, String uri)
 206         throws SOAPException {
 207 
 208         // validating parameters before passing them on
 209         // to make sure that the namespace specification rules are followed
 210 
 211         // reserved xmlns prefix cannot be used.
 212         if ("xmlns".equals(prefix)) {
 213             log.severe("SAAJ0123.impl.no.reserved.xmlns");
 214             throw new SOAPExceptionImpl("Cannot declare reserved xmlns prefix");
 215         }
 216         // Qualified name cannot be xmlns.
 217         if ((prefix == null) && ("xmlns".equals(localName))) {
 218             log.severe("SAAJ0124.impl.qualified.name.cannot.be.xmlns");
 219             throw new SOAPExceptionImpl("Qualified name cannot be xmlns");
 220         }
 221 
 222         return NameImpl.create(localName, prefix, uri);
 223     }
 224 
 225     public Name createName(String localName, String prefix)
 226         throws SOAPException {
 227         String namespace = getNamespaceURI(prefix);
 228         if (namespace == null) {
 229             log.log(
 230                 Level.SEVERE,
 231                 "SAAJ0126.impl.cannot.locate.ns",
 232                 new String[] { prefix });
 233             throw new SOAPExceptionImpl(
 234                 "Unable to locate namespace for prefix " + prefix);
 235         }
 236         return NameImpl.create(localName, prefix, namespace);
 237     }
 238 
 239     public Name createName(String localName) throws SOAPException {
 240         return NameImpl.createFromUnqualifiedName(localName);
 241     }
 242 
 243     public void setOmitXmlDecl(String value) {
 244         this.omitXmlDecl = value;
 245     }
 246 
 247     public void setXmlDecl(String value) {
 248         this.xmlDecl = value;
 249     }
 250 
 251     private String getOmitXmlDecl() {
 252         return this.omitXmlDecl;
 253     }
 254 
 255     public void setCharsetEncoding(String value) {
 256         charset = value;
 257     }
 258 
 259     public void output(OutputStream out) throws IOException {
 260         try {
 261 //            materializeBody();
 262             Transformer transformer =
 263                 EfficientStreamingTransformer.newTransformer();
 264 
 265             transformer.setOutputProperty(
 266                 OutputKeys.OMIT_XML_DECLARATION, "yes");
 267                 /*omitXmlDecl);*/
 268             // no equivalent for "setExpandEmptyElements"
 269             transformer.setOutputProperty(
 270                 OutputKeys.ENCODING,
 271                 charset);
 272 
 273             if (omitXmlDecl.equals("no") && xmlDecl == null) {
 274                 xmlDecl = "<?xml version=\"" + getOwnerDocument().getXmlVersion() + "\" encoding=\"" +
 275                     charset + "\" ?>";
 276             }
 277 
 278            StreamResult result = new StreamResult(out);
 279             if (xmlDecl != null) {
 280                 OutputStreamWriter writer = new OutputStreamWriter(out, charset);
 281                 writer.write(xmlDecl);
 282                 writer.flush();
 283                 result = new StreamResult(writer);
 284             }
 285 
 286             if (log.isLoggable(Level.FINE)) {
 287                 log.log(Level.FINE, "SAAJ0190.impl.set.xml.declaration",
 288                         new String[] { omitXmlDecl });
 289                 log.log(Level.FINE, "SAAJ0191.impl.set.encoding",
 290                         new String[] { charset });
 291             }
 292 
 293             //StreamResult result = new StreamResult(out);
 294             transformer.transform(getContent(), result);
 295         } catch (Exception ex) {
 296             throw new IOException(ex.getMessage());
 297         }
 298     }
 299 
 300     /**
 301      * Serialize to FI if boolean parameter set.
 302      */
 303     public void output(OutputStream out, boolean isFastInfoset)
 304         throws IOException
 305     {
 306         if (!isFastInfoset) {
 307             output(out);
 308         }
 309         else {
 310             try {
 311                 // Run transform and generate FI output from content
 312                 Source source = getContent();
 313                 Transformer transformer = EfficientStreamingTransformer.newTransformer();
 314                     transformer.transform(getContent(),
 315                         FastInfosetReflection.FastInfosetResult_new(out));
 316             }
 317             catch (Exception ex) {
 318                 throw new IOException(ex.getMessage());
 319             }
 320         }
 321     }
 322 
 323     //    public void prettyPrint(OutputStream out) throws IOException {
 324     //        if (getDocument() == null)
 325     //            initDocument();
 326     //
 327     //        OutputFormat format = OutputFormat.createPrettyPrint();
 328     //
 329     //        format.setIndentSize(2);
 330     //        format.setNewlines(true);
 331     //        format.setTrimText(true);
 332     //        format.setPadText(true);
 333     //        format.setExpandEmptyElements(false);
 334     //
 335     //        XMLWriter writer = new XMLWriter(out, format);
 336     //        writer.write(getDocument());
 337     //    }
 338     //
 339     //    public void prettyPrint(Writer out) throws IOException {
 340     //        if (getDocument() == null)
 341     //            initDocument();
 342     //
 343     //        OutputFormat format = OutputFormat.createPrettyPrint();
 344     //
 345     //        format.setIndentSize(2);
 346     //        format.setNewlines(true);
 347     //        format.setTrimText(true);
 348     //        format.setPadText(true);
 349     //        format.setExpandEmptyElements(false);
 350     //
 351     //        XMLWriter writer = new XMLWriter(out, format);
 352     //        writer.write(getDocument());
 353     //    }
 354 
 355 
 356      public SOAPElement setElementQName(QName newName) throws SOAPException {
 357         log.log(Level.SEVERE,
 358                 "SAAJ0146.impl.invalid.name.change.requested",
 359                 new Object[] {elementQName.getLocalPart(),
 360                               newName.getLocalPart()});
 361         throw new SOAPException("Cannot change name for "
 362                                 + elementQName.getLocalPart() + " to "
 363                                 + newName.getLocalPart());
 364      }
 365 
 366     @Override
 367     public void setStaxBridge(StaxBridge bridge) throws SOAPException {
 368         //set it on the body
 369         ((BodyImpl) getBody()).setStaxBridge(bridge);
 370     }
 371 
 372     @Override
 373     public StaxBridge getStaxBridge() throws SOAPException {
 374         return ((BodyImpl) getBody()).getStaxBridge();
 375     }
 376 
 377     @Override
 378     public XMLStreamReader getPayloadReader() throws SOAPException {
 379         return ((BodyImpl) getBody()).getPayloadReader();
 380     }
 381 
 382     @Override
 383     public void writeTo(final XMLStreamWriter writer) throws XMLStreamException, SOAPException {
 384         StaxBridge readBridge = this.getStaxBridge();
 385         if (readBridge != null && readBridge instanceof StaxLazySourceBridge) {
 386 //              StaxSoapWriteBridge writingBridge =  new StaxSoapWriteBridge(this);
 387 //              writingBridge.write(writer);
 388                 final String soapEnvNS = this.getNamespaceURI();
 389                 final DOMStreamReader reader = new DOMStreamReader(this);
 390                 XMLStreamReaderToXMLStreamWriter writingBridge =  new XMLStreamReaderToXMLStreamWriter();
 391                 writingBridge.bridge( new XMLStreamReaderToXMLStreamWriter.Breakpoint(reader, writer) {
 392                         public boolean proceedAfterStartElement()  {
 393                                 if ("Body".equals(reader.getLocalName()) && soapEnvNS.equals(reader.getNamespaceURI()) ){
 394                                         return false;
 395                                 } else
 396                                         return true;
 397                         }
 398             });//bridgeToBodyStartTag
 399             ((StaxLazySourceBridge)readBridge).writePayloadTo(writer);
 400             writer.writeEndElement();//body
 401             writer.writeEndElement();//env
 402             writer.writeEndDocument();
 403             writer.flush();
 404         } else {
 405                 LazyEnvelopeStaxReader lazyEnvReader = new LazyEnvelopeStaxReader(this);
 406                 XMLStreamReaderToXMLStreamWriter writingBridge = new XMLStreamReaderToXMLStreamWriter();
 407                 writingBridge.bridge(lazyEnvReader, writer);
 408 //            writingBridge.bridge(new XMLStreamReaderToXMLStreamWriter.Breakpoint(lazyEnvReader, writer));
 409         }
 410         //Assume the staxBridge is exhausted now since we would have read the body reader
 411         ((BodyImpl) getBody()).setPayloadStreamRead();
 412     }
 413 
 414     @Override
 415     public QName getPayloadQName() throws SOAPException {
 416         return ((BodyImpl) getBody()).getPayloadQName();
 417     }
 418 
 419     @Override
 420     public String getPayloadAttributeValue(String localName) throws SOAPException {
 421         return ((BodyImpl) getBody()).getPayloadAttributeValue(localName);
 422     }
 423 
 424     @Override
 425     public String getPayloadAttributeValue(QName qName) throws SOAPException {
 426         return ((BodyImpl) getBody()).getPayloadAttributeValue(qName);
 427     }
 428 
 429     @Override
 430     public boolean isLazy() {
 431         try {
 432             return ((BodyImpl) getBody()).isLazy();
 433         } catch (SOAPException e) {
 434             return false;
 435         }
 436     }
 437 
 438 }
--- EOF ---