ConnettoreBaseWithResponse.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.pdd.core.connettori;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.FileInputStream;
  25. import java.io.InputStream;
  26. import java.util.List;
  27. import java.util.Map;

  29. import org.apache.commons.io.input.CountingInputStream;
  30. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  31. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  32. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  33. import org.openspcoop2.message.constants.MessageRole;
  34. import org.openspcoop2.message.constants.MessageType;
  35. import org.openspcoop2.message.exception.ParseExceptionUtils;
  36. import org.openspcoop2.message.soap.AbstractOpenSPCoop2Message_soap_impl;
  37. import org.openspcoop2.message.soap.SoapUtils;
  38. import org.openspcoop2.message.soap.TunnelSoapUtils;
  39. import org.openspcoop2.pdd.core.CostantiPdD;
  40. import org.openspcoop2.pdd.core.controllo_traffico.DimensioneMessaggiUtils;
  41. import org.openspcoop2.pdd.core.controllo_traffico.LimitExceededNotifier;
  42. import org.openspcoop2.pdd.core.controllo_traffico.ReadTimeoutConfigurationUtils;
  43. import org.openspcoop2.pdd.core.controllo_traffico.ReadTimeoutContextParam;
  44. import org.openspcoop2.pdd.core.controllo_traffico.SogliaReadTimeout;
  45. import org.openspcoop2.pdd.core.controllo_traffico.TimeoutNotifier;
  46. import org.openspcoop2.pdd.core.controllo_traffico.TimeoutNotifierType;
  47. import org.openspcoop2.pdd.logger.DiagnosticInputStream;
  48. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  49. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  50. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  51. import org.openspcoop2.protocol.sdk.ProtocolException;
  52. import org.openspcoop2.utils.CopyStream;
  53. import org.openspcoop2.utils.LimitedInputStream;
  54. import org.openspcoop2.utils.TimeoutInputStream;
  55. import org.openspcoop2.utils.Utilities;
  56. import org.openspcoop2.utils.dch.MailcapActivationReader;
  57. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  58. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  59. import org.openspcoop2.utils.transport.TransportResponseContext;
  60. import org.openspcoop2.utils.transport.TransportUtils;
  61. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  62. import org.openspcoop2.utils.transport.http.HttpConstants;

  64. /**
  65.  * ConnettoreBaseWithResponse
  66.  *
  67.  *
  68.  * @author Poli Andrea (apoli@link.it)
  69.  * @author $Author$
  70.  * @version $Rev$, $Date$
  71.  */

  73. public abstract class ConnettoreBaseWithResponse extends ConnettoreBase {

  75.     /** InputStream Risposta */
  76.     protected InputStream isResponse = null;
  77.     
  78.     /** MessageType Risposta */
  79.     protected MessageType messageTypeResponse = null;
  80.     
  81.     /** ContentType Risposta */
  82.     protected String tipoRisposta = null;
  83.     
  84.     /** Check ContentType */
  85.     protected boolean checkContentType = true;
  86.     
  87.     /** NotifierInputStreamParams */
  88.     protected NotifierInputStreamParams notifierInputStreamParams;
  89.     
  90.     /** Imbustamento SOAP */
  91.     protected boolean imbustamentoConAttachment;
  92.     protected String mimeTypeAttachment;
  93.     
  94.     /** acceptOnlyReturnCode_202_200 SOAP */
  95.     protected boolean acceptOnlyReturnCode_202_200 = true;
  96.             
  97.     protected void normalizeInputStreamResponse(int timeout, boolean configurazioneGlobale) throws Exception{
  98.         //Se non e' null, controllo che non sia vuoto.
  99.         if(this.isResponse!=null){
  100.             this.isResponse = Utilities.normalizeStream(this.isResponse, false);
  101.         }
  102.         else{
  103.             this.logger.info("Stream di risposta (return-code:"+this.codice+") is null",true);
  104.         }
  105.         
  106.         if(this.isResponse!=null && this.useLimitedInputStream) {
  107.             if(this.limitBytes!=null && this.limitBytes.getSogliaKb()>0) {
  108.                 LimitExceededNotifier notifier = new LimitExceededNotifier(this.getPddContext(), this.limitBytes, this.logger.getLogger());
  109.                 
  110.                 if(this.limitBytes.isUseContentLengthHeader()) {
  111.                     List<String> l = TransportUtils.getValues(this.propertiesTrasportoRisposta, HttpConstants.CONTENT_LENGTH);
  112.                     if(l!=null && !l.isEmpty()) {
  113.                         DimensioneMessaggiUtils.verifyByContentLength(this.logger.getLogger(), l, this.limitBytes, notifier, this.getPddContext(), DimensioneMessaggiUtils.RESPONSE);
  114.                     }
  115.                 }
  116.                 
  117.                 long limitBytes = this.limitBytes.getSogliaKb()*1024; // trasformo kb in bytes
  118.                 this.isResponse = new LimitedInputStream(this.isResponse, limitBytes, 
  119.                         CostantiPdD.PREFIX_LIMITED_RESPONSE,
  120.                         this.getPddContext(),
  121.                         notifier);
  122.             }
  123.         }
  124.         if(this.isResponse!=null && this.useTimeoutInputStream) {
  125.             if(timeout>0) {
  126.                 TimeoutNotifier notifier = getTimeoutNotifier(timeout, configurazioneGlobale, TimeoutNotifierType.RECEIVE_RESPONSE);
  127.                 this.isResponse = new TimeoutInputStream(this.isResponse, timeout, 
  128.                         CostantiPdD.PREFIX_TIMEOUT_RESPONSE,
  129.                         this.getPddContext(),
  130.                         notifier);
  131.             }
  132.         }
  133.         if(this.isResponse!=null && this.useDiagnosticInputStream && this.msgDiagnostico!=null) {
  134.             String idModuloFunzionale = 
  135.                     ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo) ? 
  136.                             MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI : MsgDiagnosticiProperties.MSG_DIAG_INOLTRO_BUSTE;
  137.             this.isResponse = new DiagnosticInputStream(this.isResponse, idModuloFunzionale, "letturaPayloadRisposta", false, this.msgDiagnostico, 
  138.                     (this.logger!=null && this.logger.getLogger()!=null) ? this.logger.getLogger() : OpenSPCoop2Logger.getLoggerOpenSPCoopCore(),
  139.                     this.getPddContext());
  140.         }
  141.     }
  142.     
  143.     protected TimeoutNotifier getTimeoutNotifier(int timeout, boolean configurazioneGlobale, TimeoutNotifierType type) throws DriverConfigurazioneException, ProtocolException {
  144.         SogliaReadTimeout soglia = null;
  145.         if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo) || this.pa!=null) {
  146.             soglia = (this.pa!=null) ? 
  147.                     ReadTimeoutConfigurationUtils.buildSogliaResponseTimeout(timeout, configurazioneGlobale, this.pa, this.nomeConnettoreAsincrono, this.policyTimeoutConfig,
  148.                             new ReadTimeoutContextParam(this.requestInfo, this.getProtocolFactory(), this.getPddContext(), this.state)) : 
  149.                         ReadTimeoutConfigurationUtils.buildSogliaResponseTimeout(timeout, false, this.getProtocolFactory());
  150.         }
  151.         else {
  152.             soglia = (this.pd!=null) ? 
  153.                     ReadTimeoutConfigurationUtils.buildSogliaResponseTimeout(timeout, configurazioneGlobale, this.pd, this.policyTimeoutConfig,
  154.                             new ReadTimeoutContextParam(this.requestInfo, this.getProtocolFactory(), this.getPddContext(), this.state)) : 
  155.                         ReadTimeoutConfigurationUtils.buildSogliaResponseTimeout(timeout, true, this.getProtocolFactory());
  156.         }
  157.         boolean saveInContext = !(this.policyTimeoutConfig!=null && 
  158.                                     (this.policyTimeoutConfig.getAttributeAuthority()!=null || this.policyTimeoutConfig.getAttributeAuthorityResponseJwt()!=null)
  159.                                 );
  160.         return new TimeoutNotifier(this.getPddContext(), this.getProtocolFactory(), 
  161.                 soglia, type, this.logger.getLogger(), saveInContext);
  162.     }
  163.     
  164.     public static boolean isReadTimeoutException(Exception e, String message){
  165.         return "Read timed out".equals(message) && (e instanceof java.net.SocketTimeoutException);
  166.     }
  167.     public static boolean containsReadTimeoutException(Exception e, String message){
  168.         return message!=null && message.contains("Read timed out") && (e instanceof java.net.SocketTimeoutException || Utilities.existsInnerException(e, java.net.SocketTimeoutException.class));
  169.     }
  170.     protected void processReadTimeoutException(int timeout, boolean configurazioneGlobale, Exception e, String message) {
  171.         try {
  172.             if(timeout>0 && isReadTimeoutException(e, message)) {
  173.                 TimeoutNotifier notifier = getTimeoutNotifier(timeout, configurazioneGlobale, TimeoutNotifierType.WAIT_RESPONSE);
  174.                 notifier.notify(timeout);
  175.             }
  176.         }catch(Exception error) {
  177.             if(this.logger!=null) {
  178.                 this.logger.error("Errore avvenuto durante la registrazione dell'evento di read timeout: "+error.getMessage(),error);
  179.             }
  180.         }
  181.     }
  182.     
  183.     public static boolean isConnectionTimeoutException(Exception e, String message){
  184.         return "connect timed out".equals(message) && (e instanceof java.net.SocketTimeoutException);
  185.     }
  186.     public static boolean containsConnectionTimeoutException(Exception e, String message){
  187.         return message!=null && message.contains("connect timed out") && (e instanceof java.net.SocketTimeoutException || Utilities.existsInnerException(e, java.net.SocketTimeoutException.class));
  188.     }
  189.     protected void processConnectionTimeoutException(int timeout, boolean configurazioneGlobale, Exception e, String message) {
  190.         try {
  191.             if(timeout>0 && isConnectionTimeoutException(e, message)) {
  192.                 TimeoutNotifier notifier = getTimeoutNotifier(timeout, configurazioneGlobale, TimeoutNotifierType.CONNECTION);
  193.                 notifier.notify(timeout);
  194.             }
  195.         }catch(Exception error) {
  196.             if(this.logger!=null) {
  197.                 this.logger.error("Errore avvenuto durante la registrazione dell'evento di connection timeout: "+error.getMessage(),error);
  198.             }
  199.         }
  200.     }
  201.     
  202.     protected void initCheckContentTypeConfiguration(){     
  203.         this.checkContentType = true;
  204.         if(this.idModulo!=null){
  205.             if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  206.                 this.checkContentType = this.openspcoopProperties.isControlloContentTypeAbilitatoRicezioneBuste();
  207.             }else{
  208.                 this.checkContentType = this.openspcoopProperties.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi();
  209.             }
  210.         }
  211.     }
  212.     
  213.     protected void initConfigurationAcceptOnlyReturnCode_202_200(){
  214.         this.acceptOnlyReturnCode_202_200 = true;
  215.         if(this.isRest){
  216.             this.acceptOnlyReturnCode_202_200 = false;
  217.         }
  218.         else{
  219.             if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  220.                 this.acceptOnlyReturnCode_202_200 = this.openspcoopProperties.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi();
  221.             }
  222.             else{
  223.                 // InoltroBuste e InoltroRisposte
  224.                 this.acceptOnlyReturnCode_202_200 = this.openspcoopProperties.isAcceptOnlyReturnCode_200_202_inoltroBuste();
  225.             }
  226.         }
  227.     }
  228.     
  229.     protected boolean dumpResponse(Map<String, List<String>> trasporto) throws Exception{
  230.         
  231.         Exception exceptionCheck = null;
  232.         try {
  233.             if(this.isRest){
  234.                 checkRestResponseMessageType();
  235.             }
  236.             else {
  237.                 checkSoapResponseMessageType();
  238.             }
  239.         }catch(Exception e) {
  240.             exceptionCheck = e;
  241.         }
  242.         
  243.         boolean returnValue = false;
  244.         try {
  245.             returnValue = _dumpResponse(trasporto);
  246.         }
  247.         catch(Exception e) {
  248.             if(exceptionCheck!=null) {
  249.                 throw exceptionCheck;
  250.             }
  251.             else {
  252.                 throw e;
  253.             }
  254.         }
  255.         
  256.         if(exceptionCheck!=null) {
  257.             throw exceptionCheck;
  258.         }
  259.         else {
  260.             return returnValue;
  261.         }

  263.     }
  264.     
  265.     
  266.     private DumpByteArrayOutputStream readResponseForDump() throws Exception{
  267.         DumpByteArrayOutputStream bout = null;
  268.         try {
  269.             bout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  270.                     TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO.getValue());
  271.             
  272.             this.emitDiagnosticStartDumpBinarioRispostaIngresso();
  273.             
  274. //              byte [] readB = new byte[Utilities.DIMENSIONE_BUFFER];
  275. //              int readByte = 0;
  276. //              while((readByte = this.isResponse.read(readB))!= -1){
  277. //                  bout.write(readB,0,readByte);
  278. //              }
  279.             //System.out.println("READ FROM ["+this.isResponse.getClass().getName()+"] ...");
  280.             CopyStream.copy(this.isResponse, bout);
  281.             //System.out.println("READ FROM ["+this.isResponse.getClass().getName()+"] complete");
  282.             this.isResponse.close();
  283.         }finally {
  284.             try {
  285.                 if(bout!=null) {
  286.                     bout.flush();
  287.                 }
  288.             }catch(Throwable t) {
  289.                 // ignore
  290.             }
  291.             try {
  292.                 if(bout!=null) {
  293.                     bout.close();
  294.                 }
  295.             }catch(Throwable t) {
  296.                 // ignore
  297.             }
  298.         }
  299.         return bout;
  300.     }
  301.     
  302.     private boolean _dumpResponse(Map<String, List<String>> trasporto) throws Exception{
  303.         if(this.isResponse!=null){
  304.             
  305.             this.emitDiagnosticResponseRead(this.isResponse);
  306.             
  307.             // Registro Debug.
  308.             DumpByteArrayOutputStream bout = null;
  309.             try {
  310.                 bout = readResponseForDump();
  311.                 if(this.debug) {
  312.                     this.logger.info("Messaggio ricevuto (ContentType:"+this.tipoRisposta+") :\n"+bout.toString(),false);
  313.                 }
  314.                 // Creo nuovo inputStream
  315.                 if(bout.isSerializedOnFileSystem()) {
  316.                     this.isResponse = new FileInputStream(bout.getSerializedFile());
  317.                 }
  318.                 else {
  319.                     this.isResponse = new ByteArrayInputStream(bout.toByteArray());
  320.                 }
  321.                 
  322.                 this.dumpBinarioRispostaIngresso(bout, this.messageTypeResponse, trasporto);
  323.             }finally {
  324.                 try {
  325.                     if(bout!=null) {
  326.                         bout.clearResources();
  327.                     }
  328.                 }catch(Throwable t) {
  329.                     this.logger.error("Release resources failed: "+t.getMessage(),t);
  330.                 }
  331.             }
  332.         }
  333.         else {
  334.             if(this.debug) {
  335.                 if(this.tipoRisposta!=null) {
  336.                     this.logger.info("Messaggio ricevuto (ContentType:"+this.tipoRisposta+") senza contenuto nell'http-reply",false);
  337.                 }
  338.                 else {
  339.                     this.logger.info("Messaggio ricevuto senza contenuto nell'http-reply",false);
  340.                 }
  341.             }
  342.             
  343.             // devo registrare almeno gli header HTTP
  344.             this.emitDiagnosticStartDumpBinarioRispostaIngresso();
  345.             this.dumpBinarioRispostaIngresso(null, null, trasporto);
  346.         }
  347.         
  348.         return true;
  349.     }
  350.     
  351.     private void checkRestResponseMessageType() throws Exception{
  352.         
  353.         if(this.messageTypeResponse!=null) {
  354.             return; // gia' calcolato
  355.         }
  356.         
  357.         String msgErrore = null;
  358.         Exception exErrore = null;
  359.                 
  360.         String contentTypeString = "N.D.";
  361.         if(this.tipoRisposta!=null && !"".equals(this.tipoRisposta)){
  362.             contentTypeString = this.tipoRisposta;
  363.             
  364.             // Verifico correttezza Content-Type
  365.             try {
  366.                 ContentTypeUtilities.validateContentType(contentTypeString);
  367.             }catch(Exception error){
  368.                 exErrore = error;
  369.                 msgErrore = "Content-Type '"+contentTypeString+"' presente nella risposta non valido: "+error.getMessage();
  370.             }
  371.         }
  372.         
  373.         if(msgErrore==null) {
  374.             try{
  375.                 this.messageTypeResponse = this.requestInfo.getBindingConfig().getResponseMessageType(this.requestMsg.getServiceBinding(), 
  376.                         this.requestMsg.getTransportRequestContext(),
  377.                         this.tipoRisposta, 
  378.                         this.codice>0?this.codice:null);                
  379.                 if(this.messageTypeResponse==null){
  380.                     String ctConosciuti = this.requestInfo.getBindingConfig().getContentTypesSupportedAsString(this.requestMsg.getServiceBinding(), MessageRole.RESPONSE, 
  381.                             this.requestMsg.getTransportRequestContext());
  382.                     if(this.tipoRisposta==null){
  383.                         throw new Exception("Header Content-Type non risulta definito nell'http reply e non esiste una configurazione che supporti tale casistica. Content-Type conosciuti: "+ctConosciuti);
  384.                     }
  385.                     else {
  386.                         throw new Exception("Header Content-Type definito nell'http reply non è tra quelli conosciuti: "+ctConosciuti);
  387.                     }
  388.                     
  389.                 }
  390.             }catch(Exception e){
  391.                 exErrore = e;
  392.                 msgErrore = "Non è stato possibile comprendere come trattare il messaggio ricevuto (Content-Type: "+contentTypeString+"): "+e.getMessage();
  393.             }
  394.         }
  395.         
  396.         if(msgErrore!=null){
  397.             if(this.checkContentType){
  398.                 //if(exErrore!=null){
  399.                 this.logger.error(msgErrore,exErrore);
  400.                 //}
  401.                 //else{
  402.                 //  this.logger.error(msgErrore);
  403.                 //}
  404.                 Exception e = new Exception(msgErrore);
  405.                 this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  406.                 this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION,
  407.                         ParseExceptionUtils.buildParseException(e, MessageRole.RESPONSE));
  408.                 throw e;
  409.             }else{
  410.                 msgErrore = msgErrore+"; viene utilizzata forzatamente la tipologia "+MessageType.BINARY.name() +" come modalità di gestione del messaggio";
  411.                 //if(exErrore!=null){
  412.                 this.logger.warn(msgErrore,exErrore);
  413.                 //}
  414.                 //else{
  415.                 //  this.logger.warn(msgErrore);
  416.                 //}
  417.                 this.messageTypeResponse = MessageType.BINARY;
  418.             }
  419.         }
  420.     }
  421.     
  422.     protected boolean doRestResponse() throws Exception{
  423.         if(this.debug)
  424.             this.logger.debug("gestione REST in corso ...");
  425.         
  426.         checkRestResponseMessageType();
  427.         
  428.         InputStream isParam = null;
  429.         if(this.contentLength>=0){
  430.             isParam = this.isResponse;
  431.             if(this.contentLength==0){
  432.                 isParam = null;
  433.             }
  434.         }
  435.         else{
  436.             //non ho trovato ContentLength. Devo scoprire se c'e' un payload.
  437.             isParam = this.isResponse; // è stato normalizzato, quindi se non c'è un contenuto è null
  438.         }
  439.         
  440.         TransportResponseContext responseContext = new TransportResponseContext(this.logger.getLogger());
  441.         responseContext.setCodiceTrasporto(this.codice+"");
  442.         responseContext.setContentLength(this.contentLength);
  443.         responseContext.setHeaders(this.propertiesTrasportoRisposta);
  444.         
  445.         if(isParam!=null) {
  446.             this.emitDiagnosticResponseRead(isParam);
  447.         }
  448.         
  449.         OpenSPCoop2MessageParseResult pr = org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo,MessageRole.RESPONSE).
  450.                 createMessage(this.messageTypeResponse,responseContext,
  451.                         isParam,this.notifierInputStreamParams,
  452.                         this.openspcoopProperties.getAttachmentsProcessingMode());  
  453.         if(pr.getParseException()!=null){
  454.             this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  455.         }
  456.         try{
  457.             this.responseMsg = pr.getMessage_throwParseException();
  458.         }catch(Exception e){
  459.             this.responseMsg=null;
  460.             // L'errore 'premature end of file' consiste solo nel fatto che una risposta non e' stata ricevuta.
  461.             boolean result2XX = (this.codice>=200 && this.codice<=299);
  462.             boolean premature =  Utilities.existsInnerMessageException(e, "Premature end of file", true) && result2XX;
  463.             // Se non ho un premature, ed un errore di lettura in 200, allora devo segnalare l'errore, altrimenti comunque 
  464.             // il msg ritornato e' null e nel codiceStato vi e' l'errore.
  465.             
  466.             if( premature == false ){
  467.                 this.eccezioneProcessamento = e;
  468.                 this.errore = "Errore avvenuto durante il parsing della risposta: " + this.readExceptionMessageFromException(e);
  469.                 this.logger.error("Errore avvenuto durante il parsing della risposta: " + this.readExceptionMessageFromException(e),e);
  470.                 if(result2XX){
  471.                     return false;
  472.                 }
  473.             }
  474.         }
  475.         
  476.         return true;
  477.     }
  478.     
  479.     private void checkSoapResponseMessageType() throws Exception{
  480.         
  481.         if(this.messageTypeResponse!=null) {
  482.             return; // gia' calcolato
  483.         }
  484.         
  485.         this.contentTypeMessaggioOriginale_tunnelSoap = this.tipoRisposta; // serve per funzionalità TunnelSOAP
  486.         
  487.         if(this.isResponse!=null){
  488.             
  489.             if(this.sbustamentoSoap==false){
  490.                 
  491.                 String msgErrore = null;
  492.                 Exception exErrore = null;
  493.                                 
  494.                 String contentTypeString = "N.D.";
  495.                 if(this.tipoRisposta!=null && !"".equals(this.tipoRisposta)){
  496.                     contentTypeString = this.tipoRisposta;
  497.                     
  498.                     // Verifico correttezza Content-Type
  499.                     try {
  500.                         ContentTypeUtilities.validateContentType(contentTypeString);
  501.                     }catch(Exception error){
  502.                         exErrore = error;
  503.                         msgErrore = "Content-Type '"+contentTypeString+"' presente nella risposta non valido: "+error.getMessage();
  504.                     }
  505.                 }
  506.                 
  507.                 if(msgErrore==null) {
  508.                     try{
  509.                     
  510.                         if(this.tipoRisposta==null){
  511.                             // obbligatorio in SOAP
  512.                             msgErrore = "Header Content-Type non definito nell'http reply";
  513.                         }
  514.                         else{
  515.                             if(this.requestInfo==null) {
  516.                                 throw new Exception("BindingConfig is null");
  517.                             }
  518.                             if(this.requestInfo.getBindingConfig()==null) {
  519.                                 throw new Exception("BindingConfig is null");
  520.                             }
  521.                             if(this.requestMsg==null) {
  522.                                 throw new Exception("RequestMsg is null");
  523.                             }
  524.                             this.messageTypeResponse = this.requestInfo.getBindingConfig().getResponseMessageType(this.requestMsg.getServiceBinding(), 
  525.                                     this.requestMsg.getTransportRequestContext(),
  526.                                     this.tipoRisposta, 
  527.                                     this.codice>0?this.codice:null);
  528.                         }   
  529.                     
  530.                         if(this.messageTypeResponse==null){
  531.                             
  532.                             String ctConosciuti = this.requestInfo.getBindingConfig().getContentTypesSupportedAsString(this.requestMsg.getServiceBinding(), MessageRole.RESPONSE, 
  533.                                     this.requestMsg.getTransportRequestContext());
  534.                             
  535.                             if(this.tipoRisposta==null){
  536.                                 throw new Exception("Header Content-Type non risulta definito nell'http reply e non esiste una configurazione che supporti tale casistica. Content-Type conosciuti: "+ctConosciuti);
  537.                             }
  538.                             else {
  539.                                 throw new Exception("Header Content-Type definito nell'http reply non è tra quelli conosciuti: "+ctConosciuti);
  540.                             }
  541.                         }
  542.                         else{
  543.                             if(this.requestMsg.getMessageType().equals(this.messageTypeResponse)==false){
  544.                                 msgErrore = "Header Content-Type definito nell'http reply associato ad un tipo ("+this.messageTypeResponse.name()
  545.                                             +") differente da quello associato al messaggio di richiesta ("+this.requestMsg.getMessageType().name()+")";
  546.                             }
  547.                         }
  548.                     }catch(Exception e){
  549.                         exErrore = e;
  550.                         msgErrore = "Non è stato possibile comprendere come trattare il messaggio ricevuto (Content-Type: "+contentTypeString+"): "+e.getMessage();
  551.                     }
  552.                 }
  553.                 
  554.                 if(msgErrore!=null){
  555.                     if(this.checkContentType){
  556.                         Exception e = null;
  557.                         if(exErrore!=null){
  558.                             this.logger.error(msgErrore,exErrore);
  559.                             e = new Exception(msgErrore, exErrore);
  560.                         }
  561.                         else{
  562.                             this.logger.error(msgErrore);
  563.                             e = new Exception(msgErrore);
  564.                         }
  565.                         this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  566.                         this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION,
  567.                                 ParseExceptionUtils.buildParseException(e, MessageRole.RESPONSE));
  568.                         throw e;
  569.                     }else{
  570.                         this.messageTypeResponse = MessageType.SOAP_11;
  571.                         this.tipoRisposta = SoapUtils.getSoapContentTypeForMessageWithoutAttachments(this.messageTypeResponse);
  572.                         msgErrore = msgErrore+"; per trattare il messaggio viene utilizzato forzatamente il content-type "+this.tipoRisposta+" e la tipologia "+MessageType.SOAP_11.name();
  573.                         if(exErrore!=null){
  574.                             this.logger.warn(msgErrore,exErrore);
  575.                         }
  576.                         else{
  577.                             this.logger.warn(msgErrore);
  578.                         }                       
  579.                     }
  580.                 }
  581.             }
  582.             else{
  583.                 this.messageTypeResponse = this.requestMsg.getMessageType();
  584.                 this.tipoRisposta = SoapUtils.getSoapContentTypeForMessageWithoutAttachments(this.messageTypeResponse);
  585.             }
  586.         }
  587.     }
  588.     
  589.     private String contentTypeMessaggioOriginale_tunnelSoap = null; // serve per funzionalità TunnelSOAP;
  590.     
  591.     protected boolean doSoapResponse() throws Exception{

  593.         String tipoLetturaRisposta = null;
  594.         
  595.         // gestione ordinaria via WS/SOAP
  596.         
  597.         if(this.debug)
  598.             this.logger.debug("gestione WS/SOAP in corso ...");
  599.         
  600.         checkSoapResponseMessageType();
  601.         
  602.         if(this.isResponse!=null){
  603.             
  604.             TransportResponseContext responseContext = new TransportResponseContext(this.logger.getLogger());
  605.             responseContext.setCodiceTrasporto(this.codice+"");
  606.             responseContext.setContentLength(this.contentLength);
  607.             responseContext.setHeaders(this.propertiesTrasportoRisposta);
  608.             
  609.             this.emitDiagnosticResponseRead(this.isResponse);
  610.             
  611.             try{
  612.                 
  613.                 if(this.sbustamentoSoap==false){
  614.                     if(this.debug)
  615.                         this.logger.debug("Ricostruzione normale...");
  616.                     
  617.                     // Ricostruzione messaggio soap: secondo parametro a false, indica che il messaggio e' gia un SOAPMessage
  618.                     tipoLetturaRisposta = "Parsing Risposta SOAP";
  619.                         
  620.                     if(this.contentLength>0){
  621.                         OpenSPCoop2MessageParseResult pr = org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo,MessageRole.RESPONSE).
  622.                                 createMessage(this.messageTypeResponse,responseContext,
  623.                                         this.isResponse,this.notifierInputStreamParams,
  624.                                         this.openspcoopProperties.getAttachmentsProcessingMode());  
  625.                         if(pr.getParseException()!=null){
  626.                             this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  627.                         }
  628.                         this.responseMsg = pr.getMessage_throwParseException();
  629.                     }
  630.                     else if(this.contentLength==0){
  631.                         this.responseMsg = null;
  632.                     }
  633.                     else{
  634.                         // non ho trovato ContentLength. Devo scoprire se c'e' un payload.
  635.                         // L'inputstream è stato normalizzato, quindi se non c'è un contenuto è null
  636.                         // Devo scoprire se c'e' un payload. Costruisco il messaggio e poi provo ad accedere all'envelope
  637.                         try{
  638.                             OpenSPCoop2MessageParseResult pr = org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo,MessageRole.RESPONSE)
  639.                                     .createMessage(this.messageTypeResponse,responseContext,
  640.                                             this.isResponse,this.notifierInputStreamParams,
  641.                                             this.openspcoopProperties.getAttachmentsProcessingMode());
  642.                             if(pr.getParseException()!=null){
  643.                                 this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  644.                             }
  645.                             this.responseMsg = pr.getMessage_throwParseException();
  646.                         }catch(Exception e){
  647.                             this.responseMsg=null;
  648.                             // L'errore 'premature end of file' consiste solo nel fatto che una risposta non e' stata ricevuta.
  649.                             boolean result2XX = (this.codice>=200 && this.codice<=299);
  650.                             boolean premature =  Utilities.existsInnerMessageException(e, "Premature end of file", true) && result2XX;
  651.                             // Se non ho un premature, ed un errore di lettura in 200, allora devo segnalare l'errore, altrimenti comunque 
  652.                             // il msg ritornato e' null e nel codiceStato vi e' l'errore.
  653.                             
  654.                             if( premature == false ){
  655.                                 this.eccezioneProcessamento = e;
  656.                                 this.errore = "Errore avvenuto durante il parsing della risposta: " + this.readExceptionMessageFromException(e);
  657.                                 this.logger.error("Errore avvenuto durante il parsing della risposta: " + this.readExceptionMessageFromException(e),e);
  658.                                 if(result2XX){
  659.                                     return false;
  660.                                 }
  661.                             }
  662.                         }
  663.                     }
  664.                     
  665.                 }else{
  666.                     InputStream isParam = null;
  667.                     if(this.contentLength>=0){
  668.                         isParam = this.isResponse;
  669.                         if(this.contentLength==0){
  670.                             isParam = null;
  671.                         }
  672.                     }
  673.                     else{
  674.                         //non ho trovato ContentLength. Devo scoprire se c'e' un payload.
  675.                         isParam = this.isResponse; // è stato normalizzato, quindi se non c'è un contenuto è null
  676.                     }
  677.                     if(isParam!=null){
  678.                     
  679.                         CountingInputStream cis = null;
  680.                         try{
  681.                             cis = new CountingInputStream(isParam);
  682.                             
  683.                             if(this.imbustamentoConAttachment){
  684.                                 if(this.debug)
  685.                                     this.logger.debug("Imbustamento con attachments...");
  686.                                 
  687.                                 // Imbustamento per Tunnel OpenSPCoop
  688.                                 tipoLetturaRisposta = "Costruzione messaggio SOAP per Tunnel con mimeType "+this.mimeTypeAttachment;
  689.                                 this.responseMsg = TunnelSoapUtils.imbustamentoMessaggioConAttachment(org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo,MessageRole.RESPONSE),
  690.                                         this.messageTypeResponse,MessageRole.RESPONSE, 
  691.                                         cis,this.mimeTypeAttachment,
  692.                                         MailcapActivationReader.existsDataContentHandler(this.mimeTypeAttachment),this.contentTypeMessaggioOriginale_tunnelSoap, 
  693.                                         this.openspcoopProperties.getHeaderSoapActorIntegrazione());
  694.                             }else{
  695.                                 if(this.debug)
  696.                                     this.logger.debug("Imbustamento messaggio...");
  697.                                 tipoLetturaRisposta = "Imbustamento messaggio in un messaggio SOAP";
  698.                                 
  699.                                 // Per ottenere il corretto content length in questo caso devo leggere tutto il messaggio
  700.                                 // ALtrimenti dopo effettuando la close, nel caso di saaj instreaming otterrei un errore (o il msg non viene cmq costruito)
  701.                                 byte[] msg = Utilities.getAsByteArray(cis);
  702.                                 if(msg==null || msg.length<=0){
  703.                                     throw new Exception("Contenuto messaggio da imbustare non presente");
  704.                                 }
  705.                                 this.isResponse.close();
  706.                                 // Creo nuovo inputStream
  707.                                 this.isResponse = new ByteArrayInputStream(msg);
  708.                                 
  709.                                 OpenSPCoop2MessageParseResult pr = org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo,MessageRole.RESPONSE).
  710.                                         envelopingMessage(this.messageTypeResponse, this.tipoRisposta, this.soapAction, responseContext, 
  711.                                                 this.isResponse, this.notifierInputStreamParams, 
  712.                                                 this.openspcoopProperties.getAttachmentsProcessingMode(),
  713.                                                 true,
  714.                                                 this.openspcoopProperties.useSoapMessageReader(), this.openspcoopProperties.getSoapMessageReaderBufferThresholdKb());
  715.                                 if(pr.getParseException()!=null){
  716.                                     this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  717.                                 }
  718.                                 this.responseMsg = pr.getMessage_throwParseException();
  719.     
  720.                             }
  721.                             
  722.                             if(this.responseMsg!=null){
  723.                                 this.responseMsg.updateIncomingMessageContentLength(cis.getByteCount());
  724.                             }
  725.                             
  726.                         }finally{
  727.                             try{
  728.                                 if(cis!=null){
  729.                                     cis.close();
  730.                                 }
  731.                             }catch(Exception eClose){
  732.                                 // close
  733.                             }
  734.                         }
  735.                     }
  736.                     
  737.                 }
  738.                 try{
  739.                     if(this.responseMsg!=null){
  740.                         if(this.responseMsg instanceof AbstractOpenSPCoop2Message_soap_impl) {
  741.                             AbstractOpenSPCoop2Message_soap_impl<?> soap = (AbstractOpenSPCoop2Message_soap_impl<?>) this.responseMsg;
  742.                             if(!soap.hasContent()) {
  743.                                 this.responseMsg = null;
  744.                             }
  745.                         }
  746.                         else {
  747.                             this.responseMsg.castAsSoap().getSOAPPart().getEnvelope();
  748.                         }
  749.                     }
  750.                 }
  751.                 catch(Exception e){
  752.                     this.responseMsg=null;
  753.                     // L'errore 'premature end of file' consiste solo nel fatto che una risposta non e' stata ricevuta.
  754.                     boolean result2XX = (this.codice>=200 && this.codice<=299);
  755.                     boolean premature =  Utilities.existsInnerMessageException(e, "Premature end of file", true) && result2XX;
  756.                     // Se non ho un premature, ed un errore di lettura in 200, allora devo segnalare l'errore, altrimenti comunque 
  757.                     // il msg ritornato e' null e nel codiceStato vi e' l'errore.
  758.                     
  759.                     if( premature == false ){
  760.                         this.eccezioneProcessamento = e;
  761.                         this.errore = "Errore avvenuto durante il parsing della risposta: " + this.readExceptionMessageFromException(e);
  762.                         this.logger.error("Errore avvenuto durante il parsing della risposta: " + this.readExceptionMessageFromException(e),e);
  763.                         if(result2XX){
  764.                             return false;
  765.                         }
  766.                     }
  767.                 }
  768.             }catch(Exception e){
  769.                 this.eccezioneProcessamento = e;
  770.                 String msgErrore = this.readExceptionMessageFromException(e);
  771.                 this.errore = "Errore avvenuto durante il processamento della risposta ("+tipoLetturaRisposta+"): " + msgErrore;
  772.                 this.logger.error("Errore avvenuto durante il processamento della risposta ("+tipoLetturaRisposta+"): " + msgErrore,e);
  773.                 return false;
  774.             }

  776.             

  778.             // save Msg
  779.             if(this.debug)
  780.                 this.logger.debug("Save messaggio...");
  781.             try{
  782.                 if(this.responseMsg!=null){
  783.                     // save changes.
  784.                     // N.B. il countAttachments serve per il msg con attachments come saveMessage!
  785.                     if(this.responseMsg.castAsSoap().hasAttachments()) {
  786.                         if(this.responseMsg.castAsSoap().countAttachments()==0){
  787.                             this.responseMsg.castAsSoap().getSOAPPart();
  788.                         }
  789.                     }
  790.                 }
  791.             }catch(Exception e){
  792.                 this.eccezioneProcessamento = e;
  793.                 this.errore = "Errore avvenuto durante il salvataggio della risposta: " + this.readExceptionMessageFromException(e);
  794.                 this.logger.error("Errore avvenuto durante il salvataggio della risposta: " + this.readExceptionMessageFromException(e),e);
  795.                 return false;
  796.             }

  798.         }
  799.         
  800.         return true;
  801.     }
  802. }
Created with JaCoCo 0.8.8.202204050719