ConnettoreHTTP.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.  */




  24. package org.openspcoop2.pdd.core.connettori;

  26. import java.io.FileInputStream;
  27. import java.io.OutputStream;
  28. import java.net.Authenticator;
  29. import java.net.HttpURLConnection;
  30. import java.net.InetSocketAddress;
  31. import java.net.PasswordAuthentication;
  32. import java.net.Proxy;
  33. import java.net.URL;
  34. import java.net.URLConnection;
  35. import java.util.ArrayList;
  36. import java.util.HashMap;
  37. import java.util.Iterator;
  38. import java.util.List;
  39. import java.util.Map;

  41. import javax.net.ssl.HostnameVerifier;
  42. import javax.net.ssl.HttpsURLConnection;
  43. import javax.net.ssl.SSLSocketFactory;

  45. import org.apache.commons.lang.StringUtils;
  46. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  47. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  48. import org.openspcoop2.core.constants.CostantiConnettori;
  49. import org.openspcoop2.core.constants.TipiConnettore;
  50. import org.openspcoop2.core.constants.TransferLengthModes;
  51. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  52. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  53. import org.openspcoop2.message.constants.Costanti;
  54. import org.openspcoop2.message.constants.MessageType;
  55. import org.openspcoop2.message.soap.TunnelSoapUtils;
  56. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  57. import org.openspcoop2.utils.NameValue;
  58. import org.openspcoop2.utils.Utilities;
  59. import org.openspcoop2.utils.UtilsException;
  60. import org.openspcoop2.utils.date.DateManager;
  61. import org.openspcoop2.utils.io.Base64Utilities;
  62. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  63. import org.openspcoop2.utils.transport.TransportUtils;
  64. import org.openspcoop2.utils.transport.http.HttpBodyParameters;
  65. import org.openspcoop2.utils.transport.http.HttpConstants;
  66. import org.openspcoop2.utils.transport.http.HttpUtilities;
  67. import org.openspcoop2.utils.transport.http.RFC2047Utilities;
  68. import org.openspcoop2.utils.transport.http.SSLUtilities;
  69. import org.openspcoop2.utils.transport.http.WrappedLogSSLSocketFactory;



  73. /**
  74.  * Classe utilizzata per effettuare consegne di messaggi Soap, attraverso
  75.  * l'invocazione di un server http. 
  76.  *
  77.  *
  78.  * @author Poli Andrea (apoli@link.it)
  79.  * @author $Author$
  80.  * @version $Rev$, $Date$
  81.  */

  83. public class ConnettoreHTTP extends ConnettoreBaseHTTP {

  85.     // NOTA: HttpMethod PATCH/LINK/UNLINK funziona solo con java 8
  86.     // Con java7 si ottiene l'errore:
  87.     // Caused by: java.net.ProtocolException: HTTP method PATCH doesn't support output
  88.     //    at sun.net.www.protocol.http.HttpURLConnection.getOutputStream(HttpURLConnection.java:1081)


  91.     
  92.     /* ********  F I E L D S  P R I V A T I  ******** */

  94.     /** Proxy Configuration */
  95.     protected Proxy.Type proxyType = null;
  96.     protected String proxyHostname = null;
  97.     protected int proxyPort;
  98.     protected String proxyUsername;
  99.     protected String proxyPassword;
  100.     
  101.     /** Redirect */
  102.     protected boolean followRedirects = false;
  103.     protected String routeRedirect = null;
  104.     protected int numberRedirect = 0;
  105.     protected int maxNumberRedirects = 5;
  106.     protected String redirectLocation = null;
  107.     protected String originalAbsolutePrefixForRelativeRedirectLocation = null;
  108.     
  109.     /** TransferMode */
  110.     protected TransferLengthModes tlm = null;
  111.     protected int chunkLength = -1;
  112.     
  113.     /** Connessione */
  114.     protected HttpURLConnection httpConn = null;
  115.     
  116.     /** KeepAlive */
  117.     protected boolean keepAlive = false;
  118.             
  119.     /* Costruttori */
  120.     public ConnettoreHTTP(){
  121.         this.connettoreHttps = false;
  122.     }
  123.     public ConnettoreHTTP(boolean https){
  124.         this.connettoreHttps = https;
  125.     }
  126.     
  127.     
  128.     
  129.     /* ********  METODI  ******** */
  130.     
  131.     @Override
  132.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  133.         return this.initialize(request, true, responseCachingConfig);
  134.     }
  135.     
  136.     @Override
  137.     protected boolean send(ConnettoreMsg request) {

  139.         // HTTPS
  140.         try{
  141.             this.setSSLContext();
  142.         }catch(Exception e){
  143.             this.eccezioneProcessamento = e;
  144.             this.logger.error("[HTTPS error]"+ this.readExceptionMessageFromException(e),e);
  145.             this.errore = "[HTTPS error]"+ this.readExceptionMessageFromException(e);
  146.             return false;
  147.         }
  148.     
  149.         // Proxy
  150.         if(this.properties.get(CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE)!=null){
  151.             
  152.             String tipo = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE).trim();
  153.             if(CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE_VALUE_HTTP.equals(tipo)){
  154.                 this.proxyType = Proxy.Type.HTTP;
  155.             }
  156.             else if(CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE_VALUE_HTTPS.equals(tipo)){
  157.                 this.proxyType = Proxy.Type.HTTP;
  158.             }
  159.             else{
  160.                 this.errore = "Proprieta' '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE
  161.                         +"' non corretta. Impostato un tipo sconosciuto ["+tipo+"] (valori ammessi: "+CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE_VALUE_HTTP
  162.                         +","+CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE_VALUE_HTTPS+")";
  163.                 return false;
  164.             }
  165.             
  166.             this.proxyHostname = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME);
  167.             if(this.proxyHostname!=null){
  168.                 this.proxyHostname = this.proxyHostname.trim();
  169.             }else{
  170.                 this.errore = "Proprieta' '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_HOSTNAME+
  171.                         "' non impostata, obbligatoria in presenza della proprietà '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE+"'";
  172.                 return false;
  173.             }
  174.             
  175.             String proxyPortTmp = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT);
  176.             if(proxyPortTmp!=null){
  177.                 proxyPortTmp = proxyPortTmp.trim();
  178.             }else{
  179.                 this.errore = "Proprieta' '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT+
  180.                         "' non impostata, obbligatoria in presenza della proprietà '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_TYPE+"'";
  181.                 return false;
  182.             }
  183.             try{
  184.                 this.proxyPort = Integer.parseInt(proxyPortTmp);
  185.             }catch(Exception e){
  186.                 this.errore = "Proprieta' '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_PORT+"' non corretta: "+this.readExceptionMessageFromException(e);
  187.                 return false;
  188.             }
  189.             
  190.             
  191.             this.proxyUsername = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_PROXY_USERNAME);
  192.             if(this.proxyUsername!=null){
  193.                 this.proxyUsername = this.proxyUsername.trim();
  194.             }
  195.             
  196.             this.proxyPassword = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD);
  197.             if(this.proxyPassword!=null){
  198.                 this.proxyPassword = this.proxyPassword.trim();
  199.             }else{
  200.                 if(this.proxyUsername!=null){
  201.                     this.errore = "Proprieta' '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_PASSWORD
  202.                             +"' non impostata, obbligatoria in presenza della proprietà '"+CostantiConnettori.CONNETTORE_HTTP_PROXY_USERNAME+"'";
  203.                     return false;
  204.                 }
  205.             }
  206.         }
  207.                 
  208.         // TransferMode
  209.         if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  210.             this.tlm = this.openspcoopProperties.getTransferLengthModes_consegnaContenutiApplicativi();
  211.             this.chunkLength = this.openspcoopProperties.getChunkLength_consegnaContenutiApplicativi();
  212.         }
  213.         else{
  214.             // InoltroBuste e InoltroRisposte
  215.             this.tlm = this.openspcoopProperties.getTransferLengthModes_inoltroBuste();
  216.             this.chunkLength = this.openspcoopProperties.getChunkLength_inoltroBuste();
  217.         }
  218.         String tlmTmp = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_DATA_TRANSFER_MODE);
  219.         if(tlmTmp!=null){
  220.             tlmTmp = tlmTmp.trim();
  221.             try{
  222.                 this.tlm = TransferLengthModes.getTransferLengthModes(tlmTmp);
  223.             }catch(Exception e){
  224.                 this.errore = "Proprieta' '"+CostantiConnettori.CONNETTORE_HTTP_DATA_TRANSFER_MODE
  225.                         +"' non impostata correttamente: "+e.getMessage();
  226.                 return false;
  227.             }
  228.         }
  229.         if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(this.tlm)){
  230.             tlmTmp = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_DATA_TRANSFER_MODE_CHUNK_SIZE);
  231.             //this.log.info("PROPERTY! ("+redirectTmp+")");
  232.             if(tlmTmp!=null){
  233.                 tlmTmp = tlmTmp.trim();
  234.                 this.chunkLength = Integer.parseInt(tlmTmp);
  235.             }
  236.         }
  237.         
  238.         // Redirect
  239.         if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  240.             if(this.isSoap) {
  241.                 this.followRedirects = this.openspcoopProperties.isFollowRedirects_consegnaContenutiApplicativi_soap();
  242.             }else {
  243.                 this.followRedirects = this.openspcoopProperties.isFollowRedirects_consegnaContenutiApplicativi_rest();
  244.             }
  245.             this.maxNumberRedirects = this.openspcoopProperties.getFollowRedirectsMaxHop_consegnaContenutiApplicativi();
  246.         }
  247.         else{
  248.             // InoltroBuste e InoltroRisposte
  249.             if(this.isSoap) {
  250.                 this.followRedirects = this.openspcoopProperties.isFollowRedirects_inoltroBuste_soap();
  251.             }
  252.             else {
  253.                 this.followRedirects = this.openspcoopProperties.isFollowRedirects_inoltroBuste_rest();
  254.             }
  255.             this.maxNumberRedirects = this.openspcoopProperties.getFollowRedirectsMaxHop_inoltroBuste();
  256.         }

  258.         String redirectTmp = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_REDIRECT_FOLLOW);
  259.         if(redirectTmp!=null){
  260.             redirectTmp = redirectTmp.trim();
  261.             this.followRedirects = "true".equalsIgnoreCase(redirectTmp) || CostantiConfigurazione.ABILITATO.getValue().equalsIgnoreCase(redirectTmp);
  262.         }
  263.         //this.log.info("FOLLOW! ("+this.followRedirects+")");
  264.         if(this.followRedirects){
  265.             
  266.             redirectTmp = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_REDIRECT_MAX_HOP);
  267.             //this.log.info("PROPERTY! ("+redirectTmp+")");
  268.             if(redirectTmp!=null){
  269.                 redirectTmp = redirectTmp.trim();
  270.                 this.maxNumberRedirects = Integer.parseInt(redirectTmp);
  271.             }
  272.             
  273.             redirectTmp = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_REDIRECT_NUMBER);
  274.             //this.log.info("PROPERTY! ("+redirectTmp+")");
  275.             if(redirectTmp!=null){
  276.                 redirectTmp = redirectTmp.trim();
  277.                 this.numberRedirect = Integer.parseInt(redirectTmp);
  278.             }
  279.             
  280.             redirectTmp = this.properties.get(CostantiConnettori.CONNETTORE_HTTP_REDIRECT_ROUTE);
  281.             //this.log.info("PROPERTY! ("+redirectTmp+")");
  282.             if(redirectTmp!=null){
  283.                 redirectTmp = redirectTmp.trim();
  284.                 this.routeRedirect = redirectTmp;
  285.             }
  286.         }
  287.             
  288.         return sendHTTP(request);

  290.     }

  292.     /**
  293.      * Si occupa di effettuare la consegna HTTP_POST (sbustando il messaggio SOAP).
  294.      * Si aspetta di ricevere una risposta non sbustata.
  295.      *
  296.      * @return true in caso di consegna con successo, false altrimenti
  297.      * 
  298.      */
  299.     
  300.     protected boolean sendHTTP(ConnettoreMsg request){
  301.         
  302.         int connectionTimeout = -1;
  303.         boolean connectionTimeoutConfigurazioneGlobale = true;
  304.         int readConnectionTimeout = -1;
  305.         boolean readConnectionTimeoutConfigurazioneGlobale = true;
  306.         try{

  308.             // Creazione URL
  309.             if(this.debug)
  310.                 this.logger.debug("Creazione URL...");
  311.             this.buildLocation();       
  312.             if(this.debug)
  313.                 this.logger.debug("Creazione URL ["+this.location+"]...");
  314.             URL url = new URL( this.location ); 

  316.             
  317.             // Collezione header di trasporto per dump
  318.             Map<String, List<String>> propertiesTrasportoDebug = null;
  319.             if(this.isDumpBinarioRichiesta()) {
  320.                 propertiesTrasportoDebug = new HashMap<>();
  321.             }

  323.             
  324.             // Creazione Connessione
  325.             URLConnection connection = null;
  326.             if(this.proxyType==null){
  327.                 if(this.debug)
  328.                     this.logger.info("Creazione connessione alla URL ["+this.location+"]...",false);
  329.                 connection = url.openConnection();
  330.             }
  331.             else{
  332.                 if(this.debug)
  333.                     this.logger.info("Creazione connessione alla URL ["+this.location+"] (via proxy "+
  334.                                 this.proxyHostname+":"+this.proxyPort+") (username["+this.proxyUsername+"] password["+this.proxyPassword+"])...",false);
  335.                     
  336.                 if(this.proxyUsername!=null){
  337.                     //The problem with the 2nd code is that it sets a new default Authenticator and 
  338.                     // I don't want to do that, because this proxy is only used by a part of the application 
  339.                     // and a different part of the application could be using a different proxy.
  340.                     // Vedi articolo: http://stackoverflow.com/questions/34877470/basic-proxy-authentification-for-https-urls-returns-http-1-0-407-proxy-authentic
  341.                     // Authenticator.setDefault(new HttpAuthenticator(this.proxyUsername, this.proxyPassword));
  342.                     
  343.                     // Soluzione attuale:
  344.                     // Dopo aver instaurato la connesione, più sotto nel codice, viene creato l'header Proxy-Authorization
  345.                     // NOTA: Works for HTTP only! Doesn't work for HTTPS!
  346.                 }
  347.                 
  348.                 Proxy proxy = new Proxy(this.proxyType, new InetSocketAddress(this.proxyHostname, this.proxyPort));
  349.                 connection = url.openConnection(proxy);
  350.             }
  351.             this.httpConn = (HttpURLConnection) connection; 
  352.             
  353.             
  354.             // Imposta Contesto SSL se attivo
  355.             if(this.sslContextProperties!=null){
  356.                 HttpsURLConnection httpsConn = (HttpsURLConnection) this.httpConn;
  357.                 SSLSocketFactory sslSocketFactory = buildSSLContextFactory();
  358.                 if(this.debug) {
  359.                     String clientCertificateConfigurated = this.sslContextProperties.getKeyStoreLocation();
  360.                     sslSocketFactory = new WrappedLogSSLSocketFactory(sslSocketFactory, 
  361.                             this.logger.getLogger(), this.logger.buildMsg(""),
  362.                             clientCertificateConfigurated);
  363.                 }       
  364.                 httpsConn.setSSLSocketFactory(sslSocketFactory);
  365.                 
  366.                 StringBuilder bfLog = new StringBuilder();
  367.                 HostnameVerifier hostnameVerifier = SSLUtilities.generateHostnameVerifier(this.sslContextProperties, bfLog, 
  368.                         this.logger.getLogger(), this.loader);
  369.                 if(this.debug)
  370.                     this.logger.debug(bfLog.toString());
  371.                 if(hostnameVerifier!=null){
  372.                     httpsConn.setHostnameVerifier(hostnameVerifier);
  373.                 }
  374.             }
  375.             else {
  376.                 if(this.debug && (this.httpConn instanceof HttpsURLConnection)) {
  377.                     HttpsURLConnection httpsConn = (HttpsURLConnection) this.httpConn;
  378.                     if(httpsConn.getSSLSocketFactory()!=null) {
  379.                         SSLSocketFactory sslSocketFactory = httpsConn.getSSLSocketFactory();
  380.                         String clientCertificateConfigurated = SSLUtilities.getJvmHttpsClientCertificateConfigurated();
  381.                         sslSocketFactory = new WrappedLogSSLSocketFactory(sslSocketFactory, 
  382.                                 this.logger.getLogger(), this.logger.buildMsg(""),
  383.                                 clientCertificateConfigurated);
  384.                         httpsConn.setSSLSocketFactory(sslSocketFactory);
  385.                     }
  386.                 }
  387.             }

  389.             
  390.             // Gestione automatica del redirect
  391.             // The HttpURLConnection‘s follow redirect is just an indicator, in fact it won’t help you to do the “real” http redirection, you still need to handle it manually.
  392.             /*
  393.             if(followRedirect){
  394.                 this.httpConn.setInstanceFollowRedirects(true);
  395.             }
  396.             */
  397.             // Deve essere impostato a false, altrimenti nel caso si intenda leggere gli header o l'input stream di un 302
  398.             // si ottiene il seguente errore:
  399.             //    java.net.HttpRetryException: cannot retry due to redirection, in streaming mode
  400.             this.httpConn.setInstanceFollowRedirects(false);

  402.             
  403.             
  404.             // Tipologia di servizio
  405.             MessageType requestMessageType = this.requestMsg.getMessageType();
  406.             OpenSPCoop2SoapMessage soapMessageRequest = null;
  407.             if(this.debug)
  408.                 this.logger.debug("Tipologia Servizio: "+this.requestMsg.getServiceBinding());
  409.             if(this.isSoap){
  410.                 soapMessageRequest = this.requestMsg.castAsSoap();
  411.             }
  412.             
  413.             
  414.             // Alcune implementazioni richiedono di aggiornare il Content-Type
  415.             this.requestMsg.updateContentType();
  416.             
  417.             
  418.             
  419.             // Proxy Authentication BASIC
  420.             if(this.proxyType!=null && this.proxyUsername!=null){
  421.                 if(this.debug)
  422.                     this.logger.debug("Impostazione autenticazione per proxy (username["+this.proxyUsername+"] password["+this.proxyPassword+"]) ...");
  423.                 if(this.proxyUsername!=null && this.proxyPassword!=null){
  424.                     String authentication = this.proxyUsername + ":" + this.proxyPassword;
  425.                     authentication = HttpConstants.AUTHORIZATION_PREFIX_BASIC + Base64Utilities.encodeAsString(authentication.getBytes());
  426.                     setRequestHeader(HttpConstants.PROXY_AUTHORIZATION,authentication, propertiesTrasportoDebug);
  427.                     if(this.debug)
  428.                         this.logger.info("Impostazione autenticazione per proxy (username["+this.proxyUsername+"] password["+this.proxyPassword+"]) ["+authentication+"]",false);
  429.                 }
  430.             }
  431.             
  432.             
  433.                     
  434.             // Impostazione Content-Type della Spedizione su HTTP           
  435.             String contentTypeRichiesta = null;
  436.             if(this.debug)
  437.                 this.logger.debug("Impostazione content type...");
  438.             if(this.isSoap){
  439.                 if(this.sbustamentoSoap && soapMessageRequest.countAttachments()>0 && TunnelSoapUtils.isTunnelOpenSPCoopSoap(soapMessageRequest)){
  440.                     contentTypeRichiesta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(soapMessageRequest.getSOAPBody());
  441.                 }else{
  442.                     contentTypeRichiesta = this.requestMsg.getContentType();
  443.                 }
  444.                 if(contentTypeRichiesta==null){
  445.                     throw new Exception("Content-Type del messaggio da spedire non definito");
  446.                 }
  447.             }
  448.             else{
  449.                 contentTypeRichiesta = this.requestMsg.getContentType();
  450.                 // Content-Type non obbligatorio in REST
  451.             }
  452.             if(this.debug)
  453.                 this.logger.info("Impostazione http Content-Type ["+contentTypeRichiesta+"]",false);
  454.             if(contentTypeRichiesta!=null){
  455.                 setRequestHeader(HttpConstants.CONTENT_TYPE,contentTypeRichiesta, propertiesTrasportoDebug);
  456.             }
  457.             
  458.             
  459.             // HttpMethod
  460.             if(this.httpMethod==null){
  461.                 throw new Exception("HttpRequestMethod non definito");
  462.             }

  464.             
  465.             // Impostazione transfer-length
  466.             if(this.debug)
  467.                 this.logger.debug("Impostazione transfer-length...");           
  468.             if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(this.tlm)){
  469.                 HttpUtilities.setChunkedStreamingMode(this.httpConn, this.chunkLength, this.httpMethod, contentTypeRichiesta);
  470.                 //this.httpConn.setChunkedStreamingMode(chunkLength);
  471.             }
  472.             if(this.debug)
  473.                 this.logger.info("Impostazione transfer-length effettuata (chunkLength:"+this.chunkLength+"): "+this.tlm,false);
  474.             
  475.             
  476.             // Impostazione timeout
  477.             if(this.debug)
  478.                 this.logger.debug("Impostazione timeout...");
  479.             if(this.properties.get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)!=null){
  480.                 try{
  481.                     connectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT));
  482.                     connectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT_GLOBALE);
  483.                 }catch(Exception e){
  484.                     this.logger.error("Parametro '"+CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT+"' errato",e);
  485.                 }
  486.             }
  487.             if(connectionTimeout==-1){
  488.                 connectionTimeout = HttpUtilities.HTTP_CONNECTION_TIMEOUT;
  489.             }
  490.             if(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)!=null){
  491.                 try{
  492.                     readConnectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT));
  493.                     readConnectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE);
  494.                 }catch(Exception e){
  495.                     this.logger.error("Parametro "+CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT+" errato",e);
  496.                 }
  497.             }
  498.             if(readConnectionTimeout==-1){
  499.                 readConnectionTimeout = HttpUtilities.HTTP_READ_CONNECTION_TIMEOUT;
  500.             }
  501.             if(this.debug)
  502.                 this.logger.info("Impostazione http timeout CT["+connectionTimeout+"] RT["+readConnectionTimeout+"]",false);
  503.             this.httpConn.setConnectTimeout(connectionTimeout);
  504.             this.httpConn.setReadTimeout(readConnectionTimeout);


  507.             
  508.             // Authentication BASIC
  509.             if(this.debug)
  510.                 this.logger.debug("Impostazione autenticazione...");
  511.             String user = null;
  512.             String password = null;
  513.             if(this.credenziali!=null){
  514.                 user = this.credenziali.getUser();
  515.                 password = this.credenziali.getPassword();
  516.             }else{
  517.                 user = this.properties.get(CostantiConnettori.CONNETTORE_USERNAME);
  518.                 password = this.properties.get(CostantiConnettori.CONNETTORE_PASSWORD);
  519.             }
  520.             if(user!=null && password!=null){
  521.                 String authentication = user + ":" + password;
  522.                 authentication = HttpConstants.AUTHORIZATION_PREFIX_BASIC + Base64Utilities.encodeAsString(authentication.getBytes());
  523.                 setRequestHeader(HttpConstants.AUTHORIZATION,authentication, propertiesTrasportoDebug);
  524.                 if(this.debug)
  525.                     this.logger.info("Impostazione autenticazione (username:"+user+" password:"+password+") ["+authentication+"]",false);
  526.             }

  528.             
  529.             // Authentication Token
  530.             NameValue nv = this.getTokenHeader();
  531.             if(nv!=null) {
  532.                 if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null) {
  533.                     this.requestMsg.getTransportRequestContext().removeHeader(nv.getName()); // Fix: senno sovrascriveva il vecchio token
  534.                 }
  535.                 setRequestHeader(nv.getName(),nv.getValue(), propertiesTrasportoDebug);
  536.                 if(this.debug)
  537.                     this.logger.info("Impostazione autenticazione token (header-name '"+nv.getName()+"' value '"+nv.getValue()+"')",false);
  538.             }
  539.             
  540.             
  541.             
  542.             // Authentication Api Key
  543.             String apiKey = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY);
  544.             if(apiKey!=null && StringUtils.isNotEmpty(apiKey)){
  545.                 String apiKeyHeader = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY_HEADER);
  546.                 if(apiKeyHeader==null || StringUtils.isEmpty(apiKeyHeader)) {
  547.                     apiKeyHeader = CostantiConnettori.DEFAULT_HEADER_API_KEY;
  548.                 }
  549.                 setRequestHeader(apiKeyHeader,apiKey, propertiesTrasportoDebug);
  550.                 if(this.debug)
  551.                     this.logger.info("Impostazione autenticazione api key ["+apiKeyHeader+"]=["+apiKey+"]",false);
  552.                 
  553.                 String appId = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY_APPID);
  554.                 if(appId!=null && StringUtils.isNotEmpty(appId)){
  555.                     String appIdHeader = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY_APPID_HEADER);
  556.                     if(appIdHeader==null || StringUtils.isEmpty(appIdHeader)) {
  557.                         appIdHeader = CostantiConnettori.DEFAULT_HEADER_APP_ID;
  558.                     }
  559.                     setRequestHeader(appIdHeader,appId, propertiesTrasportoDebug);
  560.                     if(this.debug)
  561.                         this.logger.info("Impostazione autenticazione api key (app id) ["+appIdHeader+"]=["+appId+"]",false);
  562.                 }
  563.             }
  564.             
  565.             
  566.             // ForwardProxy
  567.             if(this.forwardProxy_headerName!=null && this.forwardProxy_headerValue!=null) {
  568.                 if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null) {
  569.                     this.requestMsg.getTransportRequestContext().removeHeader(this.forwardProxy_headerName); // Fix: senno sovrascriveva il vecchio token
  570.                 }
  571.                 setRequestHeader(this.forwardProxy_headerName,this.forwardProxy_headerValue, propertiesTrasportoDebug);
  572.                 if(this.debug)
  573.                     this.logger.info("Impostazione ForwardProxy (header-name '"+this.forwardProxy_headerName+"' value '"+this.forwardProxy_headerValue+"')",false);
  574.             }
  575.             
  576.             
  577.             // Impostazione Proprieta del trasporto
  578.             if(this.debug)
  579.                 this.logger.debug("Impostazione header di trasporto...");
  580.             this.forwardHttpRequestHeader();
  581.             if(this.propertiesTrasporto != null){
  582.                 Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  583.                 while (keys.hasNext()) {
  584.                     String key = (String) keys.next();
  585.                     List<String> values = this.propertiesTrasporto.get(key);
  586.                     if(this.debug) {
  587.                         if(values!=null && !values.isEmpty()) {
  588.                             for (String value : values) {
  589.                                 this.logger.info("Set Transport Header ["+key+"]=["+value+"]",false);
  590.                             }
  591.                         }
  592.                     }
  593.                     
  594.                     if(this.encodingRFC2047){
  595.                         List<String> valuesEncoded = new ArrayList<>();
  596.                         if(values!=null && !values.isEmpty()) {
  597.                             for (String value : values) {
  598.                                 if(RFC2047Utilities.isAllCharactersInCharset(value, this.charsetRFC2047)==false){
  599.                                     String encoded = RFC2047Utilities.encode(new String(value), this.charsetRFC2047, this.encodingAlgorithmRFC2047);
  600.                                     //System.out.println("@@@@ CODIFICA ["+value+"] in ["+encoded+"]");
  601.                                     if(this.debug)
  602.                                         this.logger.info("RFC2047 Encoded value in ["+encoded+"] (charset:"+this.charsetRFC2047+" encoding-algorithm:"+this.encodingAlgorithmRFC2047+")",false);
  603.                                     valuesEncoded.add(encoded);
  604.                                 }
  605.                                 else{
  606.                                     valuesEncoded.add(value);
  607.                                 }
  608.                             }
  609.                         }
  610.                         setRequestHeader(this.validazioneHeaderRFC2047, key, valuesEncoded, this.logger, propertiesTrasportoDebug);
  611.                     }
  612.                     else{
  613.                         setRequestHeader(this.validazioneHeaderRFC2047, key, values, this.logger, propertiesTrasportoDebug);
  614.                     }
  615.                 }
  616.             }
  617.             
  618.             
  619.             // Aggiunga del SoapAction Header in caso di richiesta SOAP
  620.             // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  621.             if(this.isSoap && this.sbustamentoSoap == false){
  622.                 if(this.debug)
  623.                     this.logger.debug("Impostazione soap action...");
  624.                 boolean existsTransportProperties = false;
  625.                 if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  626.                     this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  627.                     existsTransportProperties = (this.soapAction!=null);
  628.                 }
  629.                 if(!existsTransportProperties) {
  630.                     this.soapAction = soapMessageRequest.getSoapAction();
  631.                 }
  632.                 if(this.soapAction==null){
  633.                     this.soapAction="\"OpenSPCoop\"";
  634.                 }
  635.                 if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  636.                     // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  637.                     setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, propertiesTrasportoDebug);
  638.                 }
  639.                 if(this.debug)
  640.                     this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  641.             }
  642.             
  643.             
  644.             
  645.             // Impostazione Metodo
  646.             if(this.debug)
  647.                 this.logger.info("Impostazione "+this.httpMethod+"...",false);
  648.             HttpUtilities.setStream(this.httpConn, this.httpMethod, contentTypeRichiesta);
  649.             HttpBodyParameters httpBody = new  HttpBodyParameters(this.httpMethod, contentTypeRichiesta);
  650. //          this.httpConn.setRequestMethod( method );
  651. //          this.httpConn.setDoOutput(false);
  652. //          this.httpConn.setDoInput(true);

  654.             
  655.             // Spedizione byte
  656.             boolean httpBody_isDoOutput = httpBody.isDoOutput();
  657.             if(!httpBody.isDoOutput() && request.isForceSendContent()) {
  658.                 this.httpConn.setDoOutput(true);
  659.                 httpBody_isDoOutput = true;
  660.             }
  661.             if(httpBody_isDoOutput){
  662.                 boolean consumeRequestMessage = true;
  663.                 if(this.followRedirects){
  664.                     consumeRequestMessage = false;
  665.                 }
  666.                 if(this.debug)
  667.                     this.logger.debug("Spedizione byte (consume-request-message:"+consumeRequestMessage+")...");
  668.                 OutputStream out = this.httpConn.getOutputStream();
  669.                 if(this.isDumpBinarioRichiesta()) {
  670.                     DumpByteArrayOutputStream bout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  671.                             TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  672.                     try {
  673.                         this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  674.                         
  675.                         if(this.isSoap && this.sbustamentoSoap){
  676.                             this.logger.debug("Sbustamento...");
  677.                             TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,bout);
  678.                         }else{
  679.                             this.requestMsg.writeTo(bout, consumeRequestMessage);
  680.                         }
  681.                         bout.flush();
  682.                         bout.close();

  684.                         if(bout.isSerializedOnFileSystem()) {
  685.                             try(FileInputStream fin = new FileInputStream(bout.getSerializedFile())) {
  686.                                 Utilities.copy(fin, out);
  687.                             }
  688.                         }
  689.                         else {
  690.                             out.write(bout.toByteArray());
  691.                         }
  692.                         
  693.                         out.flush();
  694.                         out.close();
  695.                         
  696.                         this.dataRichiestaInoltrata = DateManager.getDate();
  697.                         
  698.                         this.dumpBinarioRichiestaUscita(bout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  699.                     }finally {
  700.                         try {
  701.                             bout.clearResources();
  702.                         }catch(Throwable t) {
  703.                             this.logger.error("Release resources failed: "+t.getMessage(),t);
  704.                         }
  705.                     }
  706.                 }else{
  707.                     if(this.isSoap && this.sbustamentoSoap){
  708.                         if(this.debug)
  709.                             this.logger.debug("Sbustamento...");
  710.                         TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,out);
  711.                     }else{
  712.                         this.requestMsg.writeTo(out, consumeRequestMessage);
  713.                     }
  714.                     
  715.                     out.flush();
  716.                     out.close();
  717.                     
  718.                     this.dataRichiestaInoltrata = DateManager.getDate();
  719.                 }

  721.             }
  722.             else {
  723.                 if(this.isDumpBinarioRichiesta()) {
  724.                     // devo registrare almeno gli header HTTP
  725.                     this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  726.                     this.dumpBinarioRichiestaUscita(null, null, null, this.location, propertiesTrasportoDebug);
  727.                 }
  728.             }
  729.             

  731.             // Analisi MimeType e ContentLocation della risposta
  732.             if(this.debug)
  733.                 this.logger.debug("Analisi risposta...");
  734.             Map<String, List<String>> mapHeaderHttpResponse = this.httpConn.getHeaderFields();
  735.             boolean protocolHttp10 = false;
  736.             if(mapHeaderHttpResponse!=null && mapHeaderHttpResponse.size()>0){
  737.                 if(this.propertiesTrasportoRisposta==null){
  738.                     this.propertiesTrasportoRisposta = new HashMap<>();
  739.                 }
  740.                 Iterator<String> itHttpResponse = mapHeaderHttpResponse.keySet().iterator();
  741.                 while(itHttpResponse.hasNext()){
  742.                     String keyHttpResponse = itHttpResponse.next();
  743.                     List<String> valueHttpResponse = mapHeaderHttpResponse.get(keyHttpResponse);
  744.                     if(valueHttpResponse!=null) {
  745.                         for(int i=0;i<valueHttpResponse.size();i++){
  746.                             if(this.debug)
  747.                                 this.logger.debug("HTTP risposta ["+keyHttpResponse+"] ["+valueHttpResponse.get(i)+"]...");
  748.                         }
  749.                     }
  750.                     if(keyHttpResponse==null){ // Check per evitare la coppia che ha come chiave null e come valore HTTP OK 200
  751.                         keyHttpResponse=HttpConstants.RETURN_CODE;
  752.                         // es. HTTP/1.1 200 OK
  753.                         if(valueHttpResponse!=null && valueHttpResponse.contains("/1.0")) {
  754.                             protocolHttp10 = true;
  755.                         }
  756.                     }
  757.                     this.propertiesTrasportoRisposta.put(keyHttpResponse, valueHttpResponse);
  758.                 }
  759.             }
  760.             
  761.             // KeepAlive
  762.             this.setKeepAlive(protocolHttp10, TransportUtils.getObjectAsString(mapHeaderHttpResponse, HttpConstants.CONNECTION));
  763.             
  764.             // TipoRisposta
  765.             this.tipoRisposta = TransportUtils.getObjectAsString(mapHeaderHttpResponse, HttpConstants.CONTENT_TYPE);
  766.             
  767.             // ContentLength della risposta
  768.             String contentLenghtString = TransportUtils.getObjectAsString(mapHeaderHttpResponse, HttpConstants.CONTENT_LENGTH);
  769.             if(contentLenghtString!=null){
  770.                 this.contentLength = Integer.valueOf(contentLenghtString);
  771.             }
  772.             else{
  773.                 if(this.httpConn.getContentLength()>0){
  774.                     this.contentLength = this.httpConn.getContentLength();
  775.                 }
  776.             }       
  777.             
  778.         
  779.             // Parametri di imbustamento
  780.             if(this.isSoap){
  781.                 this.imbustamentoConAttachment = false;
  782.                 if("true".equals(TransportUtils.getObjectAsString(mapHeaderHttpResponse, this.openspcoopProperties.getTunnelSOAPKeyWord_headerTrasporto()))){
  783.                     this.imbustamentoConAttachment = true;
  784.                 }
  785.                 this.mimeTypeAttachment = TransportUtils.getObjectAsString(mapHeaderHttpResponse, this.openspcoopProperties.getTunnelSOAPKeyWordMimeType_headerTrasporto());
  786.                 if(this.mimeTypeAttachment==null)
  787.                     this.mimeTypeAttachment = HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP;
  788.                 //System.out.println("IMB["+imbustamentoConAttachment+"] MIME["+mimeTypeAttachment+"]");
  789.             }

  791.             // Ricezione Risposta
  792.             if(this.debug)
  793.                 this.logger.debug("Analisi risposta input stream e risultato http...");
  794.             this.initConfigurationAcceptOnlyReturnCode_202_200();
  795.             
  796.             // return code
  797.             this.codice = this.httpConn.getResponseCode();
  798.             this.resultHTTPMessage = this.httpConn.getResponseMessage();
  799.             
  800.             if(this.codice>=400){
  801.                 this.isResponse = this.httpConn.getErrorStream();
  802.             }
  803.             else{
  804.                 if(this.codice>299){
  805.                     
  806.                     String redirectLocation = TransportUtils.getObjectAsString(mapHeaderHttpResponse, HttpConstants.REDIRECT_LOCATION);
  807.                     
  808.                     // 3XX
  809.                     if(this.followRedirects){
  810.                                 
  811.                         if(redirectLocation==null){
  812.                             throw new Exception("Non è stato rilevato l'header HTTP ["+HttpConstants.REDIRECT_LOCATION+"] necessario alla gestione del Redirect (code:"+this.codice+")"); 
  813.                         }
  814.                         
  815.                         TransportUtils.removeObject(request.getConnectorProperties(), CostantiConnettori.CONNETTORE_LOCATION);
  816.                         TransportUtils.removeObject(request.getConnectorProperties(), CostantiConnettori.CONNETTORE_HTTP_REDIRECT_NUMBER);
  817.                         TransportUtils.removeObject(request.getConnectorProperties(), CostantiConnettori.CONNETTORE_HTTP_REDIRECT_ROUTE);
  818.                         request.getConnectorProperties().put(CostantiConnettori.CONNETTORE_LOCATION, redirectLocation);
  819.                         request.getConnectorProperties().put(CostantiConnettori.CONNETTORE_HTTP_REDIRECT_NUMBER, (this.numberRedirect+1)+"" );
  820.                         if(this.routeRedirect!=null){
  821.                             request.getConnectorProperties().put(CostantiConnettori.CONNETTORE_HTTP_REDIRECT_ROUTE, this.routeRedirect+" -> "+redirectLocation );
  822.                         }else{
  823.                             request.getConnectorProperties().put(CostantiConnettori.CONNETTORE_HTTP_REDIRECT_ROUTE, redirectLocation );
  824.                         }
  825.                         if(this.originalAbsolutePrefixForRelativeRedirectLocation==null) {
  826.                             this.originalAbsolutePrefixForRelativeRedirectLocation = url.getProtocol()+"://"+url.getHost()+":"+url.getPort();
  827.                         }
  828.                         this.redirectLocation = redirectLocation; // per la prossima build()
  829.                         if(this.redirectLocation.startsWith("/")) {
  830.                             // relative
  831.                             this.redirectLocation = this.originalAbsolutePrefixForRelativeRedirectLocation + this.redirectLocation;
  832.                         }
  833.                         
  834.                         this.logger.warn("(hope:"+(this.numberRedirect+1)+") Redirect verso ["+redirectLocation+"] ...");
  835.                         
  836.                         if(this.numberRedirect==this.maxNumberRedirects){
  837.                             throw new Exception("Gestione redirect (code:"+this.codice+" "+HttpConstants.REDIRECT_LOCATION+":"+redirectLocation+") non consentita ulteriormente, sono già stati gestiti "+this.maxNumberRedirects+" redirects: "+this.routeRedirect);
  838.                         }
  839.                         
  840.                         boolean acceptOnlyReturnCode_307 = false;
  841.                         if(this.isSoap) {
  842.                             if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  843.                                 acceptOnlyReturnCode_307 = this.openspcoopProperties.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi();
  844.                             }
  845.                             else{
  846.                                 // InoltroBuste e InoltroRisposte
  847.                                 acceptOnlyReturnCode_307 = this.openspcoopProperties.isAcceptOnlyReturnCode_307_inoltroBuste();
  848.                             }
  849.                         }
  850.                         if(acceptOnlyReturnCode_307){
  851.                             if(this.codice!=307){
  852.                                 throw new Exception("Return code ["+this.codice+"] (redirect "+HttpConstants.REDIRECT_LOCATION+":"+redirectLocation+") non consentito dal WS-I Basic Profile (http://www.ws-i.org/Profiles/BasicProfile-1.1-2004-08-24.html#HTTP_Redirect_Status_Codes)");
  853.                             }
  854.                         }
  855.                         // Annullo precedente immagine
  856.                         this.clearRequestHeader();
  857.                         if(this.propertiesTrasportoRisposta!=null) {
  858.                             this.propertiesTrasportoRisposta.clear();
  859.                         }
  860.                         this.contentLength = -1;
  861.                         try {
  862.                             return this.send(request); // caching ricorsivo non serve
  863.                         }finally {
  864.                             /*System.out.println("CHECK ["+redirectLocation+"]");
  865.                             if(this.responseMsg!=null) {
  866.                                 System.out.println("MSG ["+this.responseMsg.getContentType()+"]");
  867.                                 this.responseMsg.writeTo(System.out, false);
  868.                             }*/
  869.                         }
  870.                         
  871.                     }else{
  872.                         if(this.isSoap) {
  873.                             throw new Exception("Gestione redirect (code:"+this.codice+" "+HttpConstants.REDIRECT_LOCATION+":"+redirectLocation+") non attiva");
  874.                         }
  875.                         else {
  876.                             this.logger.debug("Gestione redirect (code:"+this.codice+" "+HttpConstants.REDIRECT_LOCATION+":"+redirectLocation+") non attiva");
  877.                             
  878.                             if(this.location!=null && redirectLocation!=null){
  879.                                 this.location = this.location+" [redirect-location: "+redirectLocation+"]";
  880.                             }
  881.                             
  882.                             if(httpBody.isDoInput()){
  883.                                 this.isResponse = this.httpConn.getInputStream();
  884.                                 if(this.isResponse==null) {
  885.                                     this.isResponse = this.httpConn.getErrorStream();
  886.                                 }
  887.                             }
  888.                         }
  889.                     }
  890.                 }
  891.                 else{
  892.                     if(this.isSoap && this.acceptOnlyReturnCode_202_200){
  893.                         if(this.codice!=200 && this.codice!=202){
  894.                             throw new Exception("Return code ["+this.codice+"] non consentito dal WS-I Basic Profile (http://www.ws-i.org/Profiles/BasicProfile-1.1-2004-08-24.html#HTTP_Success_Status_Codes)");
  895.                         }
  896.                     }
  897.                     if(httpBody.isDoInput()){
  898.                         this.isResponse = this.httpConn.getInputStream();
  899.                     }
  900.                 }
  901.             }
  902.             

  904.             
  905.             /* ------------  PostOutRequestHandler ------------- */
  906.             this.postOutRequest();
  907.             
  908.             
  909.             
  910.             
  911.             /* ------------  PreInResponseHandler ------------- */
  912.             this.preInResponse();
  913.             
  914.             // Lettura risposta parametri NotifierInputStream per la risposta
  915.             this.notifierInputStreamParams = null;
  916.             if(this.preInResponseContext!=null){
  917.                 this.notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  918.             }
  919.             
  920.             
  921.             /* ------------  Gestione Risposta ------------- */
  922.             
  923.             this.normalizeInputStreamResponse(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale);
  924.             
  925.             this.initCheckContentTypeConfiguration();
  926.             
  927.             if(this.isDumpBinarioRisposta()){
  928.                 if(!this.dumpResponse(this.propertiesTrasportoRisposta)) {
  929.                     return false;
  930.                 }
  931.             }
  932.             
  933.             if(this.isRest){
  934.                             
  935.                 if(this.doRestResponse()==false){
  936.                     return false;
  937.                 }
  938.                 
  939.             }
  940.             else{
  941.             
  942.                 if(this.doSoapResponse()==false){
  943.                     return false;
  944.                 }
  945.                 
  946.             }

  948.             if(this.debug)
  949.                 this.logger.info("Gestione invio/risposta http effettuata con successo",false);
  950.             
  951.             return true;

  953.         }  catch(Exception e){ 
  954.             this.eccezioneProcessamento = e;
  955.             String msgErrore = this.readExceptionMessageFromException(e);
  956.             if(this.generateErrorWithConnectorPrefix) {
  957.                 this.errore = "Errore avvenuto durante la consegna HTTP: "+msgErrore;
  958.             }
  959.             else {
  960.                 this.errore = msgErrore;
  961.             }
  962.             this.logger.error("Errore avvenuto durante la consegna HTTP: "+msgErrore,e);

  964.             this.processConnectionTimeoutException(connectionTimeout, connectionTimeoutConfigurazioneGlobale, e, msgErrore);
  965.             
  966.             this.processReadTimeoutException(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale, e, msgErrore);
  967.             
  968.             return false;
  969.         } 
  970.     }
  971.     
  972.     /**
  973.      * Effettua la disconnessione 
  974.      */
  975.     @Override
  976.     public void disconnect() throws ConnettoreException{
  977.         List<Throwable> listExceptionChiusura = new ArrayList<Throwable>();
  978.         try{
  979.             // Gestione finale della connessione
  980.             if(this.isResponse!=null){
  981.                 if(this.debug && this.logger!=null)
  982.                     this.logger.debug("Chiusura socket...");
  983.                 try {
  984.                     this.isResponse.close();
  985.                 }
  986.                 catch(Throwable t) {
  987.                     if(this.logger!=null) {
  988.                         this.logger.debug("Chiusura socket fallita: "+t.getMessage(),t);
  989.                     }
  990.                     listExceptionChiusura.add(t);
  991.                 }
  992.             }
  993.     
  994.             // fine HTTP.
  995.             if(this.httpConn!=null){
  996.                 if(this.debug && this.logger!=null)
  997.                     this.logger.debug("Chiusura connessione...");
  998.                 try {
  999.                     // FIX: https://docs.oracle.com/javase/8/docs/technotes/guides/net/http-keepalive.html
  1000.                     /*
  1001.                      * Do not abandon a connection by ignoring the response body. Doing so may results in idle TCP connections. That needs to be garbage collected when they are no longer referenced. 
  1002.                      * If getInputStream() successfully returns, read the entire response body.
  1003.                      * When calling getInputStream() from HttpURLConnection, if an IOException occurs, catch the exception and call getErrorStream() to get the response body (if there is any).
  1004.                      * Reading the response body cleans up the connection even if you are not interested in the response content itself. But if the response body is long and you are not interested in the rest of it after seeing the beginning, you can close the InputStream. 
  1005.                      * But you need to be aware that more data could be on its way. Thus the connection may not be cleared for reuse.
  1006.                      * 
  1007.                      * (Quindi se keepAlive == true)
  1008.                      * If client called HttpURLConnection.getInputSteam().close(), 
  1009.                      *    the later call to HttpURLConnection.disconnect() will NOT close the Socket. i.e. The Socket is reused (cached)
  1010.                      * If client does not call close(), call disconnect() will close the InputStream and close the Socket.
  1011.                      * 
  1012.                      * !!! So in order to reuse the Socket, just call InputStream.close(). Do not call HttpURLConnection.disconnect().
  1013.                      * 
  1014.                      * */
  1015.                     if(!this.keepAlive) {
  1016.                         this.httpConn.disconnect();
  1017.                     }
  1018.                 }catch(Throwable t) {
  1019.                     if(this.logger!=null) {
  1020.                         this.logger.debug("Chiusura connessione fallita: "+t.getMessage(),t);
  1021.                     }
  1022.                     listExceptionChiusura.add(t);
  1023.                 }
  1024.             }
  1025.             
  1026.             // super.disconnect (Per risorse base)
  1027.             try {
  1028.                 super.disconnect();
  1029.             }catch(Throwable t) {
  1030.                 if(this.logger!=null) {
  1031.                     this.logger.debug("Chiusura risorse fallita: "+t.getMessage(),t);
  1032.                 }
  1033.                 listExceptionChiusura.add(t);
  1034.             }
  1035.             
  1036.         }catch(Exception e){
  1037.             throw new ConnettoreException("Chiusura connessione non riuscita: "+e.getMessage(),e);
  1038.         }
  1039.         
  1040.         if(listExceptionChiusura!=null && !listExceptionChiusura.isEmpty()) {
  1041.             org.openspcoop2.utils.UtilsMultiException multiException = new org.openspcoop2.utils.UtilsMultiException(listExceptionChiusura.toArray(new Throwable[1]));
  1042.             throw new ConnettoreException("Chiusura connessione non riuscita: "+multiException.getMessage(),multiException);
  1043.         }
  1044.     }

  1046.     
  1047.     private void setKeepAlive(boolean protocolHttp10, String connectionHeaderValue) {
  1048.         /* https://tools.ietf.org/html/rfc7230#section-6.3 */
  1049.         /*
  1050.         A recipient determines whether a connection is persistent or not
  1051.            based on the most recently received message's protocol version and
  1052.            Connection header field (if any):

  1054.            -  If the "close" connection option is present, the connection will
  1055.               not persist after the current response; else,

  1057.            -  If the received protocol is HTTP/1.1 (or later), the connection
  1058.               will persist after the current response; else,

  1060.            -  If the received protocol is HTTP/1.0, the "keep-alive" connection
  1061.               option is present, the recipient is not a proxy, and the recipient
  1062.               wishes to honor the HTTP/1.0 "keep-alive" mechanism, the
  1063.               connection will persist after the current response; otherwise,

  1065.            -  The connection will close after the current response.
  1066.          */
  1067.         
  1068.         if(HttpConstants.CONNECTION_VALUE_CLOSE.equalsIgnoreCase(connectionHeaderValue)) {
  1069.             this.keepAlive = false;
  1070.         }
  1071.         else if(!protocolHttp10) {
  1072.             this.keepAlive = true;
  1073.         }
  1074.         else if(connectionHeaderValue!=null){
  1075.             this.keepAlive = HttpConstants.CONNECTION_VALUE_KEEP_ALIVE.equalsIgnoreCase(connectionHeaderValue);
  1076.         }
  1077.         else {
  1078.             this.keepAlive = false;
  1079.         }
  1080.     }
  1081.     
  1082.     /**
  1083.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  1084.      * 
  1085.      * @return location di inoltro del messaggio
  1086.      */
  1087.     @Override
  1088.     public String getLocation(){
  1089.         if(this.location==null){
  1090.             // può darsi che per un errore non sia ancora stata inizializzata la location
  1091.             try{
  1092.                 this.buildLocation();
  1093.             }catch(Throwable t){}
  1094.         }
  1095.         if(this.location!=null){
  1096.             String l = new String(this.location);
  1097.             if(this.routeRedirect!=null){
  1098.                 l = l+" [redirects route path: "+this.routeRedirect+"]";
  1099.             }
  1100.             if(this.proxyType!=null){
  1101.                 l = l+" [proxy: "+this.proxyHostname+":"+this.proxyPort+"]";
  1102.             }
  1103. //          if(this.forwardProxy!=null && this.forwardProxy.isEnabled()) {
  1104. //              l = l+" [govway-proxy]";
  1105. //          }
  1106.             return l;
  1107.         }
  1108.         return null;
  1109.     }
  1110.     private void buildLocation() throws ConnettoreException {
  1111.         if(this.redirectLocation!=null) {
  1112.             this.location = this.redirectLocation;
  1113.         }
  1114.         else {
  1115.             this.location = TransportUtils.getObjectAsString(this.properties,CostantiConnettori.CONNETTORE_LOCATION);
  1116.         }
  1117.         NameValue nv = this.getTokenQueryParameter();
  1118.         if(nv!=null) {
  1119.             if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null) {
  1120.                 this.requestMsg.getTransportRequestContext().removeParameter(nv.getName()); // Fix: senno sovrascriveva il vecchio token
  1121.             }
  1122.             if(this.propertiesUrlBased==null) {
  1123.                 this.propertiesUrlBased = new HashMap<>();
  1124.             }
  1125.             TransportUtils.setParameter(this.propertiesUrlBased, nv.getName(), nv.getValue());
  1126.         }
  1127.         if(this.redirectLocation==null) {
  1128.             this.location = ConnettoreUtils.buildLocationWithURLBasedParameter(this.logger!=null ? this.logger.getLogger() : null, this.requestMsg, 
  1129.                     this.connettoreHttps ? TipiConnettore.HTTPS.toString() : TipiConnettore.HTTP.toString(), 
  1130.                     this.propertiesUrlBased, this.location,
  1131.                     this.getProtocolFactory(), this.idModulo);
  1132.         }
  1133.         
  1134.         this.updateLocation_forwardProxy(this.location);
  1135.     }
  1136.     

  1138.     private void setRequestHeader(boolean validazioneHeaderRFC2047, String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  1139.         
  1140.         if(validazioneHeaderRFC2047){
  1141.             try{
  1142.                 RFC2047Utilities.validHeader(key, values);
  1143.                 setRequestHeader(key, values, propertiesTrasportoDebug);
  1144.             }catch(UtilsException e){
  1145.                 logger.error(e.getMessage(),e);
  1146.             }
  1147.         }
  1148.         else{
  1149.             setRequestHeader(key,values, propertiesTrasportoDebug);
  1150.         }
  1151.         
  1152.     }
  1153.     
  1154.     @Override
  1155.     protected void setRequestHeader(String key,List<String> values) throws Exception {
  1156.         if(values!=null && !values.isEmpty()) {
  1157.             for (String value : values) {
  1158.                 this.httpConn.addRequestProperty(key,value);        
  1159.             }
  1160.         }
  1161.     }

  1163. }


  1166. class HttpAuthenticator extends Authenticator{
  1167.     
  1168.     private String username;
  1169.     private String password;
  1170.     
  1171.     HttpAuthenticator(String u,String p){
  1172.         super();
  1173.         this.username = u;
  1174.         this.password = p;
  1175.     }
  1176.     
  1177.     @Override
  1178.     public PasswordAuthentication getPasswordAuthentication(){
  1179.         return new PasswordAuthentication(this.username, this.password.toCharArray());
  1180.     }
  1181. }



Created with JaCoCo 0.8.8.202204050719