OpenSPCoop2MessageSoapStreamReader.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.message.soap.reader;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.ByteArrayOutputStream;
  25. import java.io.InputStream;
  26. import java.io.OutputStream;
  27. import java.io.SequenceInputStream;

  29. import javax.xml.parsers.SAXParser;
  30. import javax.xml.parsers.SAXParserFactory;
  31. import javax.xml.soap.MimeHeaders;
  32. import javax.xml.soap.SOAPBody;
  33. import javax.xml.soap.SOAPHeader;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.openspcoop2.message.OpenSPCoop2Message;
  37. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  38. import org.openspcoop2.message.constants.Costanti;
  39. import org.openspcoop2.message.constants.MessageType;
  40. import org.openspcoop2.message.exception.MessageException;
  41. import org.openspcoop2.message.soap.OpenSPCoop2Message_saaj_11_impl;
  42. import org.openspcoop2.message.soap.OpenSPCoop2Message_saaj_12_impl;
  43. import org.openspcoop2.message.soap.SoapUtils;
  44. import org.openspcoop2.utils.Utilities;
  45. import org.openspcoop2.utils.resources.Charset;
  46. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  47. import org.openspcoop2.utils.transport.http.HttpConstants;
  48. import org.openspcoop2.utils.xml.TransformerConfig;
  49. import org.openspcoop2.utils.xml.XMLUtils;
  50. import org.w3c.dom.Node;
  51. import org.xml.sax.InputSource;
  52. import org.xml.sax.XMLReader;

  54. /**
  55.  * OpenSPCoop2MessageSoapParser
  56.  *
  57.  * @author Andrea Poli (poli@link.it)
  58.  * @author $Author$
  59.  * @version $Rev$, $Date$
  60.  */
  61. public class OpenSPCoop2MessageSoapStreamReader {

  63.     public static boolean SOAP_HEADER_OPTIMIZATION_ENABLED = true;
  64.     
  65.     @SuppressWarnings("unused")
  66.     private OpenSPCoop2MessageFactory msgFactory;
  67.     private InputStream is;
  68.     private String contentType;
  69.     private int bufferThresholdKb;
  70.     
  71.     public OpenSPCoop2MessageSoapStreamReader(OpenSPCoop2MessageFactory msgFactory, String contentType, InputStream is, int bufferThresholdKb) {
  72.         this.msgFactory = msgFactory;
  73.         this.contentType = contentType;
  74.         this.is = is;
  75.         this.bufferThresholdKb = bufferThresholdKb;
  76.     }

  78.     private String envelope;
  79.     private String prefixEnvelope = null;
  80.     private String namespace;
  81.     
  82.     private String header;
  83.     private String prefixHeader = null;
  84.     private OpenSPCoop2Message _headerMsgCompleto;
  85.     private boolean soapHeaderModified = false;
  86.     
  87.     private boolean soapHeaderOptimizable = false;
  88.     private long startHeaderOffset;
  89.     private long endHeaderOffset;
  90.     private long startBodyOffset;
  91.     private String isCharset;
  92.     
  93.     private String body;
  94.     private boolean bodyEmpty;
  95.     //private Element rootElement;
  96.     private String rootElementNamespace;
  97.     private String rootElementLocalName;
  98.     private String rootElementPrefix;
  99.     private String fault;
  100.     
  101.     private int bufferSize;
  102.     
  103.     private boolean parsingComplete = false;
  104.     
  105.     private MessageException tBuffered = null;
  106.     
  107.     public void checkException() throws MessageException {
  108.         if(this.tBuffered!=null) {
  109.             throw this.tBuffered;
  110.         }
  111.     }
  112.     private InputStream bufferedInputStream = null;
  113.     public InputStream getBufferedInputStream() {
  114.         return this.bufferedInputStream;
  115.     }
  116.     public void releaseBufferedInputStream() {
  117.         this.bufferedInputStream = null;
  118.     }
  119.     public void read() throws MessageException {

  121.         this.bufferedInputStream = this.is;
  122.                 
  123.         if(this.tBuffered!=null) {
  124.             throw this.tBuffered;
  125.         }
  126.         
  127.         if(this.contentType==null || StringUtils.isEmpty(this.contentType) || this.is == null) {
  128.             return;
  129.         }
  130.         boolean multipart = false;
  131.         try {
  132.             multipart = ContentTypeUtilities.isMultipartType(this.contentType);
  133.         }catch(Throwable t) {}
  134.         String charset = null;
  135.         try {
  136.             if(!multipart) {
  137.                 charset = ContentTypeUtilities.readCharsetFromContentType(this.contentType);
  138.                 this.isCharset = charset; 
  139.                 if(Charset.UTF_8.getValue().equalsIgnoreCase(charset)) {
  140.                     charset = null;
  141.                 }
  142.             }
  143.             else {
  144.                 String internalCT = ContentTypeUtilities.getInternalMultipartContentType(this.contentType);
  145.                 this.isCharset = ContentTypeUtilities.readCharsetFromContentType(internalCT);
  146.             }
  147.         }catch(Throwable t) {}
  148.         
  149.         try {
  150.             ByteArrayOutputStream bufferReaded = new ByteArrayOutputStream();
  151.             int lettiBuffer = 0;
  152.             
  153.             StringBuilder sbActual = null;
  154.             long sbActualOffsetStart = -1;
  155.             byte[] bufferRaw = new byte[1024];
  156.             long bLetti = 0;
  157.             int letturaPrecedente = 0;
  158.             int kbLetti = 0;
  159.             
  160.             boolean envelopeFound = false; 
  161.             
  162.             StringBuilder headerBuilder = null;
  163.             String headerClosure = null;
  164.             boolean headerCompletato = false;
  165.             
  166.             boolean bodyFound = false;
  167.             String prefixBody = null;
  168.             
  169.             StringBuilder elementAfterBodyBuilder = null;
  170.             
  171.             boolean cdataFound = false;
  172.             boolean commentFound = false;
  173.             
  174.             boolean analisiTerminata = false;
  175.             
  176. //          String check = org.openspcoop2.utils.Utilities.getAsString(this.is, "UTF8");
  177. //          System.out.println("STREAM: "+check);
  178. //          this.is = new java.io.ByteArrayInputStream(check.getBytes());
  179.             
  180.             while ( (lettiBuffer=this.is.read(bufferRaw)) !=-1) {
  181.                 
  182.                 // bufferizzo (1024 byte = 1kb alla volta)
  183.                 bufferReaded.write(bufferRaw, 0, lettiBuffer);
  184.                 kbLetti++;
  185.                 if(letturaPrecedente>0) {
  186.                     bLetti = bLetti + letturaPrecedente;
  187.                 }
  188.                 letturaPrecedente = lettiBuffer;
  189.             
  190.                 // In caso di charset differente, uso una stringa
  191.                 String bufferString = null;
  192.                 if(charset!=null) {
  193.                     ByteArrayOutputStream bufferTmp = new ByteArrayOutputStream();
  194.                     bufferTmp.write(bufferRaw, 0, lettiBuffer);
  195.                     bufferTmp.flush();
  196.                     bufferTmp.close();
  197.                     bufferString = new String(bufferTmp.toByteArray(), charset);
  198.                     lettiBuffer = bufferString.length();
  199.                 }
  200.                 
  201.                 // analizzo
  202.                 for (int i = 0; i < lettiBuffer; i++) {
  203.                     char c = bufferString!=null ? bufferString.charAt(i) : (char) bufferRaw[i];
  204.                     
  205.                     if(headerCompletato && this.endHeaderOffset<=0) {
  206.                         this.endHeaderOffset = sbActualOffsetStart;
  207.                     }
  208.                     
  209.                     if( (c == '<' || startsWithLessThan(sbActual)) 
  210.                             && 
  211.                             !cdataFound &&
  212.                             !commentFound) {
  213.                                                 
  214.                         if(sbActual!=null) {
  215.                             if(sbActual.length()>0) {
  216.                                 
  217.                                 // devo verificare se ho incontrato un cdata o sto continuando a leggere un header
  218.                                 String sPreClosure = sbActual.toString();
  219.                                 sbActual.setLength(0);
  220.                                 sbActualOffsetStart = i+bLetti;
  221.                                 
  222.                                 if(sPreClosure.startsWith("<![CDATA[")) {
  223.                                     //System.out.println("FOND CDATA! in sPreClosure");
  224.                                     cdataFound=true;
  225.                                 }
  226.                                 else if(sPreClosure.startsWith("<!--")) {
  227.                                     //System.out.println("FOND <!-- COMMENTO in sPreClosure: ["+sPreClosure+"]");
  228.                                     if(!sPreClosure.endsWith("-->")){
  229.                                         commentFound=true;
  230.                                     }
  231.                                 }
  232.                                 
  233.                                 if(headerClosure!=null) {
  234.                                     //System.out.println("AGGIUNGO AD HEADER TESTO ["+sPreClosure+"]");
  235.                                     headerBuilder.append(sPreClosure);
  236.                                 }
  237.                                 else if(bodyFound) {
  238.                                     if(!sPreClosure.startsWith("<![CDATA[") && !sPreClosure.startsWith("<!--")) {
  239.                                         //System.out.println("AGGIUNGO A BODY ["+sPreClosure+"]");
  240.                                         if(elementAfterBodyBuilder!=null) {
  241.                                             elementAfterBodyBuilder.append(sPreClosure);
  242.                                         }
  243.                                         else {
  244.                                             elementAfterBodyBuilder = new StringBuilder(sPreClosure);
  245.                                         }
  246.                                     }
  247.                                 }
  248.                                 
  249.                             }
  250.                         }
  251.                         else {
  252.                             sbActual = new StringBuilder();
  253.                             sbActualOffsetStart = i+bLetti;
  254.                         }
  255.                     }
  256.                     if(sbActual!=null) {
  257.                         sbActual.append(c);
  258.                     }
  259.                     if(c == '>' || endsWithGreaterThan(sbActual)) {
  260.                         
  261.                         if(sbActual==null) {
  262.                             //NO: gli attachments potrebbero rientrare in questo caso
  263.                             if(multipart) {
  264.                                 continue;
  265.                             }
  266.                             else {
  267.                                 throw new Exception("Invalid content; found premature '>' character ("+bufferReaded.toString()+")");
  268.                             }
  269.                         }
  270.                         
  271.                         String s = sbActual.toString();
  272.                         
  273.                         //System.out.println("S ["+s+"]");
  274.                         
  275.                         if(cdataFound) {
  276.                             if(headerClosure!=null) {
  277.                                 //System.out.println("AGGIUNGO AD HEADER CDATA ["+sbActual.toString()+"]");
  278.                                 headerBuilder.append(sbActual.toString());
  279.                             }
  280.                             sbActual.setLength(0);
  281.                             sbActualOffsetStart = i+bLetti;
  282.                             //System.out.println("continuo perche CDATA... ");
  283.                             if(s.endsWith("]]>")) {
  284.                                 cdataFound=false;
  285.                                 //System.out.println("FOUND FINE CDATA");
  286.                             }
  287.                             continue;
  288.                         }
  289.                         if(s.startsWith("<![CDATA[")) {
  290.                             //System.out.println("FOUND CDATA!");
  291.                             cdataFound=true;
  292.                             continue;
  293.                         }
  294.                         
  295.                         if(commentFound) {
  296.                             if(headerClosure!=null) {
  297.                                 //System.out.println("AGGIUNGO AD HEADER COMMENTO ["+sbActual.toString()+"]");
  298.                                 headerBuilder.append(sbActual.toString());
  299.                             }
  300.                             sbActual.setLength(0);
  301.                             sbActualOffsetStart = i+bLetti;
  302.                             //System.out.println("continuo perche COMMENTO... ");
  303.                             if(s.endsWith("-->")) {
  304.                                 commentFound=false;
  305.                                 //System.out.println("FOUND FINE COMMENTO");
  306.                             }
  307.                             continue;
  308.                         }
  309.                         if(s.startsWith("<!--")) {
  310.                             //System.out.println("FOUND <!-- COMMENTO: ["+s+"]");
  311.                             if(s.endsWith("-->")){
  312.                                 if(headerClosure!=null) {
  313.                                     //System.out.println("AGGIUNGO AD HEADER COMMENTO ["+sbActual.toString()+"]");
  314.                                     headerBuilder.append(sbActual.toString());
  315.                                 }
  316.                                 sbActual.setLength(0);
  317.                                 sbActualOffsetStart = i+bLetti;
  318.                             }
  319.                             else {
  320.                                 commentFound=true;
  321.                             }
  322.                             continue;
  323.                         }
  324.                         
  325.                         if(s.startsWith("<?")) {
  326.                             continue;
  327.                         }
  328.                         
  329.                         if(!envelopeFound && isOpenedElement(s,"<Envelope")) {
  330.                             this.envelope = s;
  331.                             //System.out.println("INIZIALIZZO ENVELOPE ["+s+"]");
  332.                             if(!analizyEnvelopeNamespace(this.envelope)) {
  333.                                 //System.out.println("TERMINO");
  334.                                 analisiTerminata=true;
  335.                                 break;
  336.                             }
  337.                             envelopeFound = true;
  338.                             this.prefixEnvelope = "";
  339.                         }
  340.                         else if(!envelopeFound && isOpenedElement(s,":Envelope")) {
  341.                             String sPrefix = s.substring(0, s.indexOf(":Envelope"));
  342.                             if(sPrefix.startsWith("<") && !sPrefix.contains(" ") && sPrefix.length()>1) {
  343.                                 this.envelope = s;
  344.                                 //System.out.println("INIZIALIZZO ENVELOPE ["+s+"]");
  345.                                 if(!analizyEnvelopeNamespace(this.envelope)) {
  346.                                     //System.out.println("TERMINO");
  347.                                     analisiTerminata=true;
  348.                                     break;
  349.                                 }
  350.                                 envelopeFound = true;
  351.                                 this.prefixEnvelope = sPrefix.substring(1)+":";
  352.                             }
  353.                             else {
  354.                                 analisiTerminata=true;
  355.                                 break;
  356.                             }
  357.                         }
  358.                         else if(envelopeFound) {
  359.                         
  360.                             if(headerClosure!=null) {
  361.                                 //System.out.println("AGGIUNGO AD HEADER ["+s+"]");
  362.                                 headerBuilder.append(s);
  363.                                 sbActual.setLength(0);
  364.                                 sbActualOffsetStart = i+bLetti;
  365.                                 if(s.startsWith(headerClosure)) {
  366.                                     headerClosure=null; 
  367.                                     headerCompletato = true;
  368.                                 }
  369.                                 continue;
  370.                             }
  371.                             
  372.                             if(headerBuilder==null && isOpenedElement(s,"<Header")) {
  373.                                 //System.out.println("INIZIALIZZO HEADER ["+s+"]");
  374.                                 //headerBuilder = new StringBuilder(s);
  375.                                 headerBuilder = new StringBuilder();
  376.                                 if(!s.endsWith("/>")) {
  377.                                     headerClosure = "</Header";
  378.                                 }
  379.                                 if(bodyFound) {
  380.                                     analisiTerminata=true;
  381.                                     break;
  382.                                 }
  383.                                 else {
  384.                                     this.startHeaderOffset = sbActualOffsetStart;
  385.                                     this.prefixHeader = "";
  386.                                 }
  387.                             }
  388.                             else if(headerBuilder==null && isOpenedElement(s,":Header")) {
  389.                                 String sPrefix = s.substring(0, s.indexOf(":Header"));
  390.                                 if(sPrefix.startsWith("<") && !sPrefix.contains(" ") && sPrefix.length()>1) {
  391.                                     //System.out.println("INIZIALIZZO HEADER ["+s+"]");
  392.                                     //headerBuilder = new StringBuilder(s);
  393.                                     headerBuilder = new StringBuilder();
  394.                                     if(!s.endsWith("/>")) {
  395.                                         headerClosure = "</"+sPrefix.substring(1)+":"+"Header";
  396.                                     }
  397.                                     if(bodyFound) {
  398.                                         analisiTerminata=true;
  399.                                         break;
  400.                                     }
  401.                                     else {
  402.                                         this.startHeaderOffset = sbActualOffsetStart;
  403.                                         this.prefixHeader = sPrefix.substring(1)+":";
  404.                                     }
  405.                                 }
  406.                                 else {
  407.                                     analisiTerminata=true;
  408.                                     break;
  409.                                 }
  410.                             }
  411.                             else if(!bodyFound && isOpenedElement(s,"<Body")) {
  412.                                 //System.out.println("INIZIALIZZO BODY ["+s+"]");
  413.                                 this.body = s;
  414.                                 bodyFound = true;
  415.                                 prefixBody = "";
  416.                                 if(this.startHeaderOffset<=0) {
  417.                                     this.startHeaderOffset = sbActualOffsetStart;
  418.                                 }
  419.                                 this.startBodyOffset=sbActualOffsetStart;
  420.                                 sbActual.setLength(0);
  421.                                 sbActualOffsetStart = i+bLetti;
  422.                             }
  423.                             else if(!bodyFound && isOpenedElement(s,":Body")) {
  424.                                 String sPrefix = s.substring(0, s.indexOf(":Body"));
  425.                                 if(sPrefix.startsWith("<") && !sPrefix.contains(" ") && sPrefix.length()>1) {
  426.                                     //System.out.println("INIZIALIZZO BODY ["+s+"]");
  427.                                     this.body = s;
  428.                                     bodyFound = true;
  429.                                     prefixBody = sPrefix.substring(1)+":";
  430.                                     if(this.startHeaderOffset<=0) {
  431.                                         this.startHeaderOffset = sbActualOffsetStart;
  432.                                     }
  433.                                     this.startBodyOffset=sbActualOffsetStart;
  434.                                     sbActual.setLength(0);
  435.                                     sbActualOffsetStart = i+bLetti;
  436.                                 }
  437.                                 else {
  438.                                     analisiTerminata=true;
  439.                                     break;
  440.                                 }
  441.                             }
  442.                             else if(bodyFound) {
  443.                                 if(this.fault==null && isOpenedElement(s,"<Fault")) {
  444.                                     //System.out.println("INIZIALIZZO FAULT ["+s+"]");
  445.                                     this.fault = s;
  446.                                 }
  447.                                 else if(this.fault==null && isOpenedElement(s,":Fault")) {
  448.                                     String sPrefix = s.substring(0, s.indexOf(":Fault"));
  449.                                     if(sPrefix.startsWith("<") && !sPrefix.contains(" ")) {
  450.                                         //System.out.println("INIZIALIZZO FAULT ["+s+"]");
  451.                                         this.fault = s;
  452.                                     }
  453.                                 }
  454.                                 else {
  455.                                     
  456.                                     String closeBody = "</"+prefixBody+"Body";
  457.                                     String closeEnvelope = "</"+this.prefixEnvelope+"Envelope";
  458.                                     if( isClosedElement(s,closeBody) || isClosedElement(s,closeEnvelope) ){
  459.                                         this.parsingComplete = true;
  460.                                     }
  461.                                     else {
  462.                                         if(!endsWithGreaterThan(s)){
  463.                                             if(elementAfterBodyBuilder!=null) {
  464.                                                 //System.out.println("AGGIUNGO A BODY dentro ["+s+"]");
  465.                                                 elementAfterBodyBuilder.append(s);
  466.                                             }
  467.                                             else {
  468.                                                 //System.out.println("CREO A BODY ["+s+"]");
  469.                                                 elementAfterBodyBuilder = new StringBuilder(s);
  470.                                             }
  471.                                         }
  472.                                     }
  473.                                     
  474.                                     analisiTerminata=true;
  475.                                     break;
  476.                                 }
  477.                             }
  478.                             
  479.                         }
  480.                     }
  481.                     
  482.                 }
  483.                 if(analisiTerminata) {
  484.                     break;
  485.                 }
  486.                 if(kbLetti==this.bufferThresholdKb) {
  487.                     // buffer dimensione massima raggiunta
  488.                     break;
  489.                 }
  490.             }
  491.             
  492.             // svuoto
  493.             if(sbActual!=null) {
  494.                 if(sbActual.length()>0) {
  495.                     sbActual.setLength(0);
  496.                 }
  497.             }
  498.             
  499.             
  500.             bufferReaded.flush();
  501.             bufferReaded.close();
  502.             if(bufferReaded.size()>0) {
  503.                 this.bufferSize = bufferReaded.size();
  504.                 ByteArrayInputStream bin = new ByteArrayInputStream(bufferReaded.toByteArray());
  505.                 if(lettiBuffer!=-1) {
  506.                     // sono uscita prima della chiusura dello stream
  507.                     this.bufferedInputStream = new SequenceInputStream(bin,this.is);
  508.                 }
  509.                 else {
  510.                     // letto tutto
  511.                     this.bufferedInputStream = bin;
  512.                 }
  513.             }
  514.             
  515.             
  516.             boolean throwException = false;
  517.             String elementAfterBody = null;
  518.             //System.out.println("BODY ["+elementAfterBodyBuilder+"]");
  519.             if(elementAfterBodyBuilder!=null && elementAfterBodyBuilder.length()>0) {
  520.                 elementAfterBody = elementAfterBodyBuilder.toString();
  521.             }
  522.             if(elementAfterBody!=null || this.fault!=null) {
  523.                 throwException=true; // ho terminato di leggere la parte interessante del messaggio
  524.                 this.parsingComplete = true;
  525.             }

  527.             if(headerBuilder!=null && headerBuilder.length()>0) {
  528.                 if(this.envelope.endsWith("/>")) {
  529.                     if(throwException) {
  530.                         throw new Exception("Invalid content; found 'Header' after envelope closure '/>': ("+headerBuilder+")");
  531.                     }
  532.                     else{
  533.                         return;
  534.                     }
  535.                 }
  536.                 if(headerCompletato) {
  537.                     StringBuilder sbHeaderAnalizer = new StringBuilder();
  538.                     sbHeaderAnalizer.append(this.envelope);
  539.                     sbHeaderAnalizer.append(headerBuilder.toString());
  540.                     sbHeaderAnalizer.append("<").append(this.prefixEnvelope).append("Body/>");
  541.                     sbHeaderAnalizer.append("</").append(this.prefixEnvelope).append("Envelope>");
  542.                     this.header = sbHeaderAnalizer.toString();
  543.                 }
  544.             }
  545.             if(this.body!=null) {
  546.                 //System.out.println("BODY ["+this.body+"]");
  547.                 if(this.envelope.endsWith("/>")) {
  548.                     if(throwException) {
  549.                         throw new Exception("Invalid content; found 'Body' after envelope closure '/>': ("+this.body+")");
  550.                     }
  551.                     else{
  552.                         return;
  553.                     }
  554.                 }
  555.                 if(this.body.endsWith("/>")) {
  556.                     this.bodyEmpty = true;
  557.                 }
  558.             }
  559.             
  560.             if(this.fault!=null) {
  561.                 //System.out.println("TROVATO FAULT ["+this.fault+"]");
  562.                 if(this.body.endsWith("/>")) {
  563.                     if(throwException) {
  564.                         throw new Exception("Invalid content; found Fault after body closure '/>': ("+this.fault+")");
  565.                     }
  566.                     else{
  567.                         return;
  568.                     }
  569.                 }
  570.                 StringBuilder sbFaultAnalizer = new StringBuilder();
  571.                 sbFaultAnalizer.append(this.envelope);
  572.                 sbFaultAnalizer.append(this.body);
  573.                 sbFaultAnalizer.append(this.fault);
  574.                 if((this.fault.contains("<") && this.fault.contains(">")) && !this.fault.trim().endsWith("/>")) {
  575.                     //System.out.println("CALCOLO!! ["+this.fault+"]");
  576.                     int i = 0;
  577.                     for (; i < this.fault.length(); i++) {
  578.                         char c = this.fault.charAt(i);
  579.                         if(c=='<') {
  580.                             i++;
  581.                             break;
  582.                         }
  583.                     }
  584.                     //System.out.println("DOPO GIRO: "+i);
  585.                     StringBuilder sb = new StringBuilder();
  586.                     for (; i < this.fault.length(); i++) {
  587.                         char c = this.fault.charAt(i);
  588.                         if(c==' ' || c=='>' || c=='\t' || c=='\r' || c=='\n') {
  589.                             break;
  590.                         }
  591.                         sb.append(c);
  592.                     }
  593.                     sbFaultAnalizer.append("</").append(sb.toString()).append(">");
  594.                     //System.out.println("TROVATO:["+sb.toString()+"]");
  595.                 }
  596.                 
  597.                 sbFaultAnalizer.append("</").append(prefixBody).append("Body>");
  598.                 sbFaultAnalizer.append("</").append(this.prefixEnvelope).append("Envelope>");
  599.                 //Element e = null;
  600.                 String namespaceFaultTrovato = null;
  601.                 try {
  602.                     OpenSPCoop2Message msg = buildOp2Message(sbFaultAnalizer.toString().getBytes(), this.getMessageType());
  603.                     SOAPBody soapBody = msg.castAsSoap().getSOAPBody();
  604.                     if(soapBody!=null) {
  605.                         if(soapBody.hasFault()) {
  606.                             namespaceFaultTrovato = soapBody.getFault().getNamespaceURI();
  607.                         }
  608.                     }
  609.                 }catch(Throwable t) {
  610.                     if(throwException) {
  611.                         throw new Exception("Invalid content ("+sbFaultAnalizer.toString()+"): "+t.getMessage(),t);
  612.                     }
  613.                     else{
  614.                         return;
  615.                     }
  616.                 }
  617.                 if(!this.namespace.equals(namespaceFaultTrovato)) {
  618.                     elementAfterBody = this.fault;
  619.                     this.fault = null; // si tratta di un contenuto applicativo con nome Fault
  620.                 }
  621.             }
  622.             
  623.             
  624.             if(this.fault==null && elementAfterBody!=null) {
  625.                 //System.out.println("elementAfterBody ["+elementAfterBody+"]");

  627.                 StringBuilder sbElementAnalizer = new StringBuilder();
  628.                 sbElementAnalizer.append(this.envelope);
  629.                 sbElementAnalizer.append(this.body);
  630.                 sbElementAnalizer.append(elementAfterBody);
  631.                 if((elementAfterBody.contains("<") && elementAfterBody.contains(">")) && !elementAfterBody.trim().endsWith("/>")) {
  632.                     //System.out.println("CALCOLO!! ["+elementAfterBody+"]");
  633.                     int i = 0;
  634.                     for (; i < elementAfterBody.length(); i++) {
  635.                         char c = elementAfterBody.charAt(i);
  636.                         if(c=='<') {
  637.                             i++;
  638.                             break;
  639.                         }
  640.                     }
  641.                     //System.out.println("DOPO GIRO: "+i);
  642.                     StringBuilder sb = new StringBuilder();
  643.                     for (; i < elementAfterBody.length(); i++) {
  644.                         char c = elementAfterBody.charAt(i);
  645.                         if(c==' ' || c=='>' || c=='\t' || c=='\r' || c=='\n') {
  646.                             break;
  647.                         }
  648.                         sb.append(c);
  649.                     }
  650.                     sbElementAnalizer.append("</").append(sb.toString()).append(">");
  651.                     //System.out.println("TROVATO:["+sb.toString()+"]");
  652.                 }
  653.                 else {
  654.                     //System.out.println("RIPULISCO");
  655.                     boolean empty = true;
  656.                     for (int i = 0; i < elementAfterBody.length(); i++) {
  657.                         char c = elementAfterBody.charAt(i);
  658.                         if(c!=' ' && c!='\t' && c!='\r' && c!='\n') {
  659.                             empty = false;
  660.                             break;
  661.                         }
  662.                     }
  663.                     //System.out.println("RIPULISCO EMPTY: "+empty);
  664.                     if(empty) {
  665.                         this.bodyEmpty=true;
  666.                     }
  667.                 }
  668.                 
  669.                 //System.out.println("BODY ["+this.body+"]");
  670.                 if(this.body!=null && this.body.endsWith("/>")) {
  671.                     if(!this.bodyEmpty) {
  672.                         if(throwException) {
  673.                             throw new Exception("Invalid content; found element after body closure '/>': ("+elementAfterBody+")");
  674.                         }
  675.                         else{
  676.                             return;
  677.                         }
  678.                     }
  679.                 }
  680.                 else {
  681.                 
  682.                     sbElementAnalizer.append("</").append(prefixBody).append("Body>");
  683.                     sbElementAnalizer.append("</").append(this.prefixEnvelope).append("Envelope>");
  684.                     //System.out.println("UTILIZZO:["+sbElementAnalizer.toString()+"]");
  685.                     //Element e = null;
  686.                     SAXParser saxParser = null;
  687.                     try {
  688.                         //e = XMLUtils.getInstance().newElement(sbElementAnalizer.toString().getBytes());
  689.                         
  690.                         saxParser = getParser();
  691.                         XMLReader xmlReader = saxParser.getXMLReader();
  692.                         RootElementSaxContentHandler saxHandler = new RootElementSaxContentHandler(this.namespace);
  693.                         xmlReader.setContentHandler(saxHandler);
  694.                         //System.out.println("ANALIZZO '"+sbElementAnalizer.toString()+"'");
  695.                         try(ByteArrayInputStream bin = new ByteArrayInputStream(sbElementAnalizer.toString().getBytes())){
  696.                             InputSource inputSource = new InputSource(bin);
  697.                             xmlReader.parse(inputSource);
  698.                         }
  699.                         this.rootElementLocalName = saxHandler.getLocalName();
  700.                         this.rootElementNamespace = saxHandler.getNamespace();  
  701.                         this.rootElementPrefix = saxHandler.getPrefix();
  702.                     }catch(Throwable t) {
  703.                         if(throwException) {
  704.                             throw new Exception("Invalid content '"+elementAfterBody+"' ("+sbElementAnalizer.toString()+"): "+t.getMessage(),t);
  705.                         }
  706.                         else{
  707.                             return;
  708.                         }
  709.                     }finally {
  710.                         if(saxParser!=null) {
  711.                             returnParser(saxParser);
  712.                         }
  713.                     }
  714.     //              Node body = SoapUtils.getFirstNotEmptyChildNode(this.msgFactory, e, false);
  715.     //              if(body!=null) {
  716.     //                  Node element = SoapUtils.getFirstNotEmptyChildNode(this.msgFactory, body, false);
  717.     //                  if(element instanceof Element) {
  718.     //                      this.rootElement = (Element) element;
  719.     //                  }
  720.     //              }
  721.                 }
  722.                 
  723.             }
  724.             
  725.             if(this.fault==null && elementAfterBody==null) {
  726.                 if(this.parsingComplete) { // siamo arrivato alla chiusura del body o dell'envelope
  727.                     this.bodyEmpty=true;
  728.                 }
  729.             }
  730.             
  731.             
  732.             //System.out.println("parsingComplete["+this.parsingComplete+"] charset["+charset+"] startHeaderOffset["+this.startHeaderOffset+"] < endHeaderOffset["+this.endHeaderOffset+"] < startBodyOffset["+this.startBodyOffset+"]");
  733.             if(this.parsingComplete) {
  734.                 if(charset==null || !charset.startsWith("UTF-16")) {
  735.                     if(this.startHeaderOffset>0 && this.startBodyOffset>=this.startHeaderOffset) {
  736.                         this.soapHeaderOptimizable = true;
  737.                         if(this.endHeaderOffset>0) {
  738.                             if(this.endHeaderOffset<this.startHeaderOffset || this.endHeaderOffset>this.startBodyOffset) {
  739.                                 // inconsistenza
  740.                                 this.soapHeaderOptimizable = false;
  741.                             }
  742.                         }
  743.                     }
  744.                 }
  745.             }
  746.             
  747.         }catch(Throwable t) {
  748.             this.tBuffered = new MessageException(t.getMessage(),t);
  749.             throw this.tBuffered;
  750.         }
  751.         
  752.         return;
  753.         
  754.     }
  755.     private boolean endsWithGreaterThan( String s ) {
  756.         if ( s == null || s.length() < 4 )
  757.             return false;
  758.         int startIx = s.length() - 4;
  759.         return ( s.charAt(startIx) == '&' && s.charAt(startIx + 1) == 'g' && s.charAt(startIx + 2) == 't' && s.charAt(startIx + 3) == ';' );
  760.     }
  761.     private boolean endsWithGreaterThan( StringBuilder buffer ) {
  762.         if ( buffer == null || buffer.length() < 4 )
  763.             return false;
  764.         int startIx = buffer.length() - 4;
  765.         return ( buffer.charAt(startIx) == '&' && buffer.charAt(startIx + 1) == 'g' && buffer.charAt(startIx + 2) == 't' && buffer.charAt(startIx + 3) == ';' );
  766.     }
  767.     private boolean startsWithLessThan( StringBuilder buffer ) {
  768.         if ( buffer == null || buffer.length() < 4 )
  769.             return false;
  770.         return ( buffer.charAt(0) == '&' && buffer.charAt(1) == 'l' && buffer.charAt(2) == 't' && buffer.charAt(3) == ';' );
  771.     }
  772.     
  773.     private boolean isOpenedElement(String s, String prefix) {
  774.         if(prefix.startsWith(":")) {
  775.             return s.contains(prefix+" ") || s.contains(prefix+">") || s.contains(prefix+"/")  || 
  776.                     s.contains(prefix+"\n") || s.contains(prefix+"\r") || s.contains(prefix+"\t");
  777.         }
  778.         else {
  779.             return s.startsWith(prefix+" ") || s.startsWith(prefix+">") || s.startsWith(prefix+"/")  || 
  780.                     s.startsWith(prefix+"\n") || s.startsWith(prefix+"\r") || s.startsWith(prefix+"\t");
  781.         }
  782.     }
  783.     private boolean isClosedElement(String s, String prefix) {
  784.         return s.startsWith(prefix+" ") || s.startsWith(prefix+">") || 
  785.                 s.startsWith(prefix+"\n") || s.startsWith(prefix+"\r") || s.startsWith(prefix+"\t");
  786.     }
  787.     
  788.     private boolean analizyEnvelopeNamespace(String envelope) throws Exception {
  789.         if(envelope!=null) {
  790.             String s = null;
  791.             if(envelope.endsWith("/>")) {
  792.                 s = envelope;
  793.             }
  794.             else {
  795.                 s = envelope.replace(">", "/>");
  796.             }
  797.             
  798.             //Element e = XMLUtils.getInstance().newElement(s.getBytes());
  799.             //this.namespace = e.getNamespaceURI();
  800.             //System.out.println("ENVELOPE PARSE ["+envelope+"]");
  801.             SAXParser saxParser = null;
  802.             try {
  803.                 saxParser = getParser();
  804.                 XMLReader xmlReader = saxParser.getXMLReader();
  805.                 SoapEnvelopeSaxContentHandler saxHandler = new SoapEnvelopeSaxContentHandler();
  806.                 xmlReader.setContentHandler(saxHandler);
  807.                 try(ByteArrayInputStream bin = new ByteArrayInputStream(s.getBytes())){
  808.                     InputSource inputSource = new InputSource(bin);
  809.                     xmlReader.parse(inputSource);
  810.                 }
  811.                 this.namespace = saxHandler.getNamespace();
  812.                 //System.out.println("ENVELOPE PARSE ["+envelope+"], found namespace: "+this.namespace);
  813.             }
  814.             catch(Throwable t) {
  815.                 throw new Exception("Invalid content ("+s+"): "+t.getMessage(),t);
  816.             }
  817.             finally {
  818.                 if(saxParser!=null) {
  819.                     returnParser(saxParser);
  820.                 }
  821.             }
  822.             
  823.             
  824.             return Costanti.SOAP_ENVELOPE_NAMESPACE.equals(this.namespace) ||
  825.                     Costanti.SOAP12_ENVELOPE_NAMESPACE.equals(this.namespace);
  826.         }
  827.         return false;
  828.     }

  830.     public String getEnvelope() {
  831.         return this.envelope;
  832.     }

  834.     public String getNamespace() {
  835.         return this.namespace;
  836.     }
  837.     
  838.     public MessageType getMessageType() {
  839.         if(Costanti.SOAP_ENVELOPE_NAMESPACE.equals(this.namespace)) {
  840.             return MessageType.SOAP_11;
  841.         }
  842.         else {
  843.             return MessageType.SOAP_12;
  844.         }
  845.     }

  847.     public boolean isParsingComplete() {
  848.         return this.parsingComplete;
  849.     }
  850.     
  851. //  public String getBody() {
  852. //      return this.body;
  853. //  }

  855.     public boolean isFault() {
  856.         return this.fault!=null;
  857.     }
  858.     
  859.     public boolean isEmpty() {
  860.         return this.bodyEmpty;
  861.     }
  862.     
  863.     public int getBufferSize() {
  864.         return this.bufferSize;
  865.     }
  866.     
  867.     public OpenSPCoop2Message getHeader_OpenSPCoop2Message() throws MessageException {
  868.         boolean checkIsEmpty = true;
  869.         SOAPHeader s = _getHeader(checkIsEmpty, false); // perchè la struttura del soap header viene mantenuta anche vuota, per preservare i commenti.
  870.         if(s!=null) {
  871.             return this._headerMsgCompleto;
  872.         }
  873.         return null;
  874.     }
  875.     public SOAPHeader getHeader() throws MessageException {
  876.         return _getHeader(false, false);
  877.     }
  878.     public SOAPHeader getModifiableHeader() throws MessageException {
  879.         this.soapHeaderModified = true;
  880.         return _getHeader(false, false);
  881.     }
  882.     public SOAPHeader addHeader() throws MessageException {
  883.         return _getHeader(false, true);
  884.     }
  885.     public boolean isSoapHeaderModified() {
  886.         return this.soapHeaderModified;
  887.     }
  888.     public void setSoapHeaderModified(boolean soapHeaderModified) {
  889.         this.soapHeaderModified = soapHeaderModified;
  890.     }
  891.     private MessageException parseErrorHeader = null;
  892.     private SOAPHeader _getHeader(boolean checkIsEmpty, boolean buildIfEmpty) throws MessageException {
  893.         
  894.         if(this.parseErrorHeader!=null) {
  895.             throw this.parseErrorHeader;
  896.         }
  897.         
  898.         SOAPHeader soapHeader = null;
  899.         
  900.         if(this._headerMsgCompleto!=null) {
  901.             try{
  902.                 soapHeader = this._headerMsgCompleto.castAsSoap().getSOAPHeader();
  903.             }catch(Throwable t) {
  904.                 throw SoapUtils.buildMessageException("Error during access header: "+t.getMessage(),t);
  905.             }
  906.         }
  907.         else {
  908.             if(this._headerMsgCompleto==null && this.header!=null) {
  909.                 try {
  910.                     //System.out.println("COSTRUISCO ["+this.header+"]");
  911.                     this._headerMsgCompleto = buildOp2Message(this.header.getBytes(), this.getMessageType());
  912.                     soapHeader = this._headerMsgCompleto.castAsSoap().getSOAPHeader();
  913.                     //System.out.println("COSTRUITO ["+org.openspcoop2.message.xml.XMLUtils.getInstance(this.msgFactory).toString(soapHeader)+"]");
  914.                                         
  915.                     if(soapHeader!=null) {
  916.                         if("".equals(this.prefixEnvelope)) {
  917.                             this._headerMsgCompleto.castAsSoap().getSOAPPart().getEnvelope().setPrefix("");
  918.                         }
  919.                         if("".equals(this.prefixHeader)) {
  920.                             soapHeader.setPrefix("");
  921.                         }
  922.                         //System.out.println("HEADER COSTRUITO DA QUANTO LETTO CON SAAJ PREFIX ["+soapHeader.getPrefix()+"], LETTO: "+this.header);
  923.                     }
  924.                     
  925.                     //this._header = XMLUtils.getInstance().newElement(this.header.getBytes());
  926.                     
  927.                     this.header = null; // libero memoria
  928.                     
  929.                 }catch(Throwable t) {
  930.                     //System.out.println("ECCEZIONE!");
  931.                     this.parseErrorHeader = SoapUtils.buildMessageException("Invalid header ("+this.header+"): "+t.getMessage(),t);
  932.                     throw this.parseErrorHeader;
  933.                 }
  934.             }
  935.             
  936.             if(this._headerMsgCompleto==null && buildIfEmpty) {
  937.                 try {
  938.                     String xmlns = "";
  939.                     if(this.prefixEnvelope!=null && !"".equals(this.prefixEnvelope)) {
  940.                         xmlns=":"+this.prefixEnvelope;
  941.                         if(xmlns.endsWith(":") && xmlns.length()>1) {
  942.                             xmlns = xmlns.substring(0, xmlns.length()-1);
  943.                         }
  944.                     }
  945.                     String envelope = "<"+this.prefixEnvelope+"Envelope xmlns"+xmlns+"=\""+this.namespace+"\"><"+this.prefixEnvelope+"Header/></"+this.prefixEnvelope+"Envelope>";
  946.                     this._headerMsgCompleto = buildOp2Message(envelope.getBytes(), this.getMessageType());
  947.                     soapHeader = this._headerMsgCompleto.castAsSoap().getSOAPHeader();
  948.                     if("".equals(xmlns)) {
  949.                         this._headerMsgCompleto.castAsSoap().getSOAPPart().getEnvelope().setPrefix("");
  950.                         soapHeader.setPrefix("");
  951.                     }
  952.                     //System.out.println("HEADER CREATO CON SAAJ PREFIX ["+soapHeader.getPrefix()+"]");
  953.                     this.soapHeaderModified = true;
  954.                 }catch(Throwable t) {
  955.                     throw SoapUtils.buildMessageException("Build header failed: "+t.getMessage(),t);
  956.                 }
  957.             }
  958.         }
  959.         
  960.         if(soapHeader!=null && checkIsEmpty) {
  961.             Node n = SoapUtils.getFirstNotEmptyChildNode(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), soapHeader, false);
  962.             if(n==null) {
  963.                 soapHeader = null;
  964.             }
  965.         }
  966.         
  967.         /*if(soapHeader!=null) {
  968.             try {
  969.                 TransformerConfig xmlConfig = new TransformerConfig();
  970.                 xmlConfig.setOmitXMLDeclaration(true);
  971.                 xmlConfig.setCharset(this.isCharset);
  972.                 System.out.println("COSTRUITO ["+org.openspcoop2.message.xml.XMLUtils.getInstance(OpenSPCoop2MessageFactory.getDefaultMessageFactory()).toString(soapHeader, xmlConfig)+"]");
  973.                 org.w3c.dom.NodeList l = soapHeader.getChildNodes();
  974.                 for (int i = 0; i < l.getLength(); i++) {
  975.                     System.out.println("BEFORE ["+l.item(i).getClass().getName()+"] ["+l.item(i).getLocalName()+"]");
  976.                 }
  977.             }catch(Throwable t) {
  978.                 System.out.println("ERRORE");
  979.             }
  980.         }*/
  981.         
  982.         return soapHeader;
  983.     }
  984.     public void clearHeader() {
  985.         this._headerMsgCompleto=null;
  986.         this.soapHeaderOptimizable=false;
  987.     }


  990. //  public Element getRootElement() {
  991. //      return this.rootElement;
  992. //  }
  993.     public String getRootElementNamespace() {
  994.         return this.rootElementNamespace;
  995.     }
  996.     public String getRootElementLocalName() {
  997.         return this.rootElementLocalName;
  998.     }
  999.     public String getRootElementPrefix() {
  1000.         return this.rootElementPrefix;
  1001.     }
  1002.     
  1003.     private static ThreadLocal<SAXParser> saxParserThreadLocal = 
  1004.                 new ThreadLocal<SAXParser>() {
  1005.             @Override
  1006.             protected SAXParser initialValue() {
  1007.                 try{
  1008.                     SAXParserFactory saxFactory = XMLUtils.getInstance().getSAXParserFactory();
  1009. //                  try {
  1010. //                      saxFactory.setFeature("jdk.xml.resetSymbolTable", true);
  1011. //                  } catch(Throwable e) {
  1012. //                  }
  1013.                     saxFactory.setNamespaceAware(true);
  1014.                     SAXParser parser = saxFactory.newSAXParser();
  1015.                     return parser;
  1016.                 }catch(Throwable t){
  1017.                     throw new RuntimeException("Inizializzazione SAXParser fallita: "+t.getMessage(),t);
  1018.                 }
  1019.             }
  1020.     };
  1021.     private static SAXParser getParser() {
  1022.         return saxParserThreadLocal.get();
  1023.     }
  1024.     public static void removeParser() {
  1025.         saxParserThreadLocal.remove();
  1026.     }
  1027.             
  1028.     private static void returnParser(SAXParser saxParser) {
  1029.         saxParser.reset();
  1030.     }
  1031.     
  1032.     private static OpenSPCoop2Message buildOp2Message(byte[] bytes, MessageType messageType) throws Exception {
  1033.         MimeHeaders mhs = new MimeHeaders();
  1034.         mhs.addHeader(HttpConstants.CONTENT_TYPE, MessageType.SOAP_11.equals(messageType) ? HttpConstants.CONTENT_TYPE_SOAP_1_1 : HttpConstants.CONTENT_TYPE_SOAP_1_2);
  1035.         OpenSPCoop2Message msg = null;
  1036.         try(ByteArrayInputStream bin = new ByteArrayInputStream(bytes)){
  1037.             if(MessageType.SOAP_11.equals(messageType)){
  1038.                 msg = new OpenSPCoop2Message_saaj_11_impl(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), mhs, bin);
  1039.             }
  1040.             else {
  1041.                 msg = new OpenSPCoop2Message_saaj_12_impl(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), mhs, bin);
  1042.             }
  1043.         }
  1044.         return msg;
  1045.     }
  1046.     
  1047.     public boolean isSoapHeaderOptimizable() {
  1048.         return SOAP_HEADER_OPTIMIZATION_ENABLED && this.soapHeaderOptimizable;
  1049.     }
  1050.     
  1051.     public void writeOptimizedHeaderTo(InputStream is, OutputStream osParam, boolean consumeHeader) throws Exception {
  1052.         if(!this.soapHeaderOptimizable) {
  1053.             throw new Exception("SOAPHeader not optimizable");
  1054.         }
  1055.         
  1056.         if(this._headerMsgCompleto==null) {
  1057.             throw new Exception("SOAPMessage Optimized undefined");
  1058.         }
  1059.         SOAPHeader soapHeader = this._headerMsgCompleto.castAsSoap().getSOAPHeader();
  1060.         if(soapHeader==null) {
  1061.             throw new Exception("SOAPHeader undefined");
  1062.         }
  1063.         
  1064.         TransformerConfig xmlConfig = new TransformerConfig();
  1065.         xmlConfig.setOmitXMLDeclaration(true);
  1066.         xmlConfig.setCharset(this.isCharset);
  1067.                 
  1068.         long indexBody = this.startBodyOffset;
  1069.         if(this.endHeaderOffset>0) {
  1070.             indexBody = this.endHeaderOffset+1;
  1071.         }
  1072.         
  1073.         // first
  1074.         byte[] buffer = new byte[Utilities.DIMENSIONE_BUFFER];
  1075.         int letti = 0;
  1076.         long index = 0;
  1077.         boolean writeHeader = false;
  1078.         
  1079.         boolean debug = false;
  1080.         OutputStream os = null;
  1081.         if(debug) {
  1082.             os = new ByteArrayOutputStream();
  1083.         }
  1084.         else {
  1085.             os = osParam;
  1086.         }
  1087.         while( (letti=is.read(buffer, 0, Utilities.DIMENSIONE_BUFFER)) != -1 ){
  1088.             
  1089.             if(index<this.startHeaderOffset) {
  1090.                 for (int i=0; i < letti; i++) {
  1091.                     if(!writeHeader || index>=indexBody) {
  1092.                         os.write(buffer[i]);
  1093.                     }
  1094.                     index++;
  1095.                     
  1096.                     if(index==this.startHeaderOffset) {
  1097.                         if(debug) {
  1098.                             os.flush();
  1099.                             //System.out.println("SCRITTO FINO A HEADER ["+os.toString()+"]");
  1100.                         }
  1101.                         
  1102.                         //os.write(OpenSPCoop2MessageFactory.getAsByte(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), this._header, true));
  1103.                         os.write(org.openspcoop2.message.xml.MessageXMLUtils.getInstance(OpenSPCoop2MessageFactory.getDefaultMessageFactory()).toByteArray(soapHeader, xmlConfig));
  1104.                         writeHeader = true;
  1105.                         if(debug) {
  1106.                             os.flush();
  1107.                             //System.out.println("SCRITTO HEADER ["+os.toString()+"]");
  1108.                         }
  1109.                     }
  1110.                 }
  1111.             }
  1112.             else {
  1113.                 if(!writeHeader) {
  1114.                     //os.write(OpenSPCoop2MessageFactory.getAsByte(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), this._header, true));
  1115.                     os.write(org.openspcoop2.message.xml.MessageXMLUtils.getInstance(OpenSPCoop2MessageFactory.getDefaultMessageFactory()).toByteArray(soapHeader, xmlConfig));
  1116.                     writeHeader = true;
  1117.                     if(debug) {
  1118.                         os.flush();
  1119.                         //System.out.println("SCRITTO HEADER GIRO SUCCESSIVO ["+os.toString()+"]");
  1120.                     }
  1121.                 }
  1122.                 if(index>=indexBody) {
  1123.                     os.write(buffer, 0, letti);
  1124.                     index = index+letti;
  1125.                 }
  1126.                 else {
  1127.                     for (int i=0; i < letti; i++) {
  1128.                         if(index>=indexBody) {
  1129.                             os.write(buffer[i]);
  1130.                         }
  1131.                         index++;
  1132.                     }
  1133.                 }
  1134.                 if(debug) {
  1135.                     os.flush();
  1136.                     //System.out.println("SCRITTO PEZZO ["+os.toString()+"]");
  1137.                 }
  1138.             }
  1139.             
  1140.         }
  1141.                 
  1142.         if(debug) {
  1143.             os.flush();
  1144.             //System.out.println("SCRITTO TUTTO ["+os.toString()+"]");
  1145.         }
  1146.         
  1147.         
  1148.         // flush
  1149.         os.flush();
  1150.         
  1151.         // ** rilascio memoria **
  1152.         if(consumeHeader) {
  1153.             this._headerMsgCompleto = null;
  1154.             this.soapHeaderOptimizable=false;
  1155.             this.bufferedInputStream = null;
  1156.         }
  1157.     }
  1158. }
Created with JaCoCo 0.8.8.202204050719