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


  22. package org.openspcoop2.pdd.services;

  24. import java.io.ByteArrayOutputStream;
  25. import java.security.SecureRandom;
  26. import java.util.Enumeration;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.Objects;
  30. import java.util.Properties;

  32. import javax.servlet.http.HttpServletRequest;
  33. import javax.wsdl.Binding;
  34. import javax.wsdl.Port;
  35. import javax.wsdl.PortType;
  36. import javax.xml.soap.SOAPEnvelope;
  37. import javax.xml.soap.SOAPHeader;

  39. import org.apache.commons.io.output.NullOutputStream;
  40. import org.openspcoop2.core.config.CorsConfigurazione;
  41. import org.openspcoop2.core.config.PortaApplicativa;
  42. import org.openspcoop2.core.config.PortaDelegata;
  43. import org.openspcoop2.core.config.constants.RuoloContesto;
  44. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  45. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  46. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  47. import org.openspcoop2.core.constants.Costanti;
  48. import org.openspcoop2.core.constants.TipoPdD;
  49. import org.openspcoop2.core.constants.TransferLengthModes;
  50. import org.openspcoop2.core.id.IDAccordo;
  51. import org.openspcoop2.core.id.IDPortaApplicativa;
  52. import org.openspcoop2.core.id.IDPortaDelegata;
  53. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  54. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  55. import org.openspcoop2.core.registry.constants.TipologiaServizio;
  56. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  57. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  58. import org.openspcoop2.core.registry.wsdl.AccordoServizioWrapper;
  59. import org.openspcoop2.core.registry.wsdl.AccordoServizioWrapperUtilities;
  60. import org.openspcoop2.generic_project.dao.jdbc.JDBCServiceManagerBase;
  61. import org.openspcoop2.message.OpenSPCoop2Message;
  62. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  63. import org.openspcoop2.message.OpenSPCoop2MessageProperties;
  64. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  65. import org.openspcoop2.message.constants.MessageType;
  66. import org.openspcoop2.message.constants.ServiceBinding;
  67. import org.openspcoop2.message.exception.MessageException;
  68. import org.openspcoop2.message.exception.MessageNotSupportedException;
  69. import org.openspcoop2.message.exception.ParseExceptionUtils;
  70. import org.openspcoop2.message.soap.SoapUtils;
  71. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  72. import org.openspcoop2.message.xml.MessageXMLUtils;
  73. import org.openspcoop2.monitor.sdk.transaction.FaseTracciamento;
  74. import org.openspcoop2.pdd.config.CachedConfigIntegrationReader;
  75. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  76. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  77. import org.openspcoop2.pdd.config.UrlInvocazioneAPI;
  78. import org.openspcoop2.pdd.core.CORSFilter;
  79. import org.openspcoop2.pdd.core.CORSWrappedHttpServletResponse;
  80. import org.openspcoop2.pdd.core.CostantiPdD;
  81. import org.openspcoop2.pdd.core.PdDContext;
  82. import org.openspcoop2.pdd.core.controllo_traffico.CostantiControlloTraffico;
  83. import org.openspcoop2.pdd.core.handlers.HandlerException;
  84. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  85. import org.openspcoop2.pdd.core.integrazione.UtilitiesIntegrazione;
  86. import org.openspcoop2.pdd.core.integrazione.peer.HeaderMap;
  87. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  88. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  89. import org.openspcoop2.pdd.services.connector.ConnectorException;
  90. import org.openspcoop2.pdd.services.connector.ConnectorUtils;
  91. import org.openspcoop2.pdd.services.connector.messages.ConnectorInMessage;
  92. import org.openspcoop2.pdd.services.connector.messages.ConnectorOutMessage;
  93. import org.openspcoop2.protocol.basic.BasicComponentFactory;
  94. import org.openspcoop2.protocol.basic.registry.ServiceIdentificationReader;
  95. import org.openspcoop2.protocol.registry.CachedRegistryReader;
  96. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  97. import org.openspcoop2.protocol.sdk.Context;
  98. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  99. import org.openspcoop2.protocol.sdk.ProtocolException;
  100. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  101. import org.openspcoop2.protocol.sdk.builder.InformazioniErroriInfrastrutturali;
  102. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  103. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  104. import org.openspcoop2.protocol.sdk.constants.IDService;
  105. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  106. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;
  107. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  108. import org.openspcoop2.protocol.sdk.registry.RegistryNotFound;
  109. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  110. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  111. import org.openspcoop2.protocol.utils.EsitiProperties;
  112. import org.openspcoop2.protocol.utils.IDSerialGenerator;
  113. import org.openspcoop2.utils.LimitExceededIOException;
  114. import org.openspcoop2.utils.NameValue;
  115. import org.openspcoop2.utils.TimeoutIOException;
  116. import org.openspcoop2.utils.Utilities;
  117. import org.openspcoop2.utils.UtilsException;
  118. import org.openspcoop2.utils.UtilsRuntimeException;
  119. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  120. import org.openspcoop2.utils.transport.TransportUtils;
  121. import org.openspcoop2.utils.transport.http.CORSRequestType;
  122. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  123. import org.openspcoop2.utils.transport.http.HttpConstants;
  124. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  125. import org.openspcoop2.utils.transport.http.HttpUtilities;
  126. import org.openspcoop2.utils.transport.http.WrappedHttpServletResponse;
  127. import org.openspcoop2.utils.wsdl.DefinitionWrapper;
  128. import org.openspcoop2.utils.wsdl.WSDLUtilities;
  129. import org.slf4j.Logger;


  132. /**
  133.  * Libreria utilizzata dalle servlet contenente metodi che implementano 
  134.  * le funzioni precedentemente implementate negli Handler.
  135.  * 
  136.  *
  137.  * @author Nardi Lorenzo (nardi@link.it)
  138.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  139.  * @author $Author$
  140.  * @version $Rev$, $Date$
  141.  */
  142. public class ServicesUtils {
  143.     
  144.     private ServicesUtils() {}

  146.     private static java.util.Random internalRnd = null;
  147.     private static synchronized void initRandom() {
  148.         if(internalRnd==null) {
  149.             internalRnd = new SecureRandom();
  150.         }
  151.     }
  152.     public static java.util.Random getRandom() {
  153.         if(internalRnd==null) {
  154.             initRandom();
  155.         }
  156.         return internalRnd;
  157.     }
  158.     
  159.     
  160.     public static ServiceIdentificationReader getServiceIdentificationReader(Logger logCore, RequestInfo requestInfo,
  161.             RegistroServiziManager registroServiziManager, ConfigurazionePdDManager configurazionePdDManager) throws Exception{
  162.         if(requestInfo==null) {
  163.             throw new Exception("Param requestInfo is null");
  164.         }
  165.         IRegistryReader registryReader = new CachedRegistryReader(logCore, requestInfo.getProtocolFactory(), registroServiziManager, requestInfo);
  166.         IConfigIntegrationReader configIntegrationReader = new CachedConfigIntegrationReader(logCore, requestInfo.getProtocolFactory(), configurazionePdDManager, requestInfo);
  167.         return new ServiceIdentificationReader(registryReader, configIntegrationReader, requestInfo.getProtocolFactory(), logCore);
  168.     }
  169.     
  170.     
  171.     public static boolean isConnessioneClientNonDisponibile(Throwable t){
  172.         if(t instanceof java.net.SocketException){
  173.             return true;
  174.         }
  175.         else if(Utilities.existsInnerException(t, java.net.SocketException.class)){
  176.             return true;
  177.         }
  178.         else if(Utilities.existsInnerException(t, java.io.IOException.class)){
  179.             Throwable tInner = Utilities.getInnerException(t, java.io.IOException.class);
  180.             if(tInner!=null && tInner.getMessage()!=null && tInner.getMessage().contains("Broken pipe")) {
  181.                 return true;
  182.             }
  183.         }
  184.         
  185.         return false;
  186.     }
  187.     
  188.     public static boolean isConnessioneServerReadTimeout(Throwable t){
  189.         
  190.         try {
  191.             java.net.SocketTimeoutException e = null;
  192.             if(t instanceof java.net.SocketTimeoutException){
  193.                 e = (java.net.SocketTimeoutException) t;
  194.             }
  195.             else if(Utilities.existsInnerException(t, java.net.SocketTimeoutException.class)){
  196.                 e = (java.net.SocketTimeoutException) Utilities.getInnerInstanceException(t, java.net.SocketTimeoutException.class, true);
  197.             }
  198.             
  199.             if(e!=null && e.getMessage()!=null && OpenSPCoop2Properties.getInstance().isServiceUnavailableReadTimedOut(e.getMessage())){
  200.                 return true;
  201.             }
  202.             else if(TimeoutIOException.isTimeoutIOException(t) && t.getMessage()!=null && t.getMessage().startsWith(CostantiPdD.PREFIX_TIMEOUT_RESPONSE)) {
  203.                 return true;
  204.             }
  205.             
  206.         }catch(Throwable tIgnore) {
  207.             // ignore
  208.         }
  209.         
  210.         return false;
  211.     }
  212.     
  213.     public static boolean isResponsePayloadTooLarge(Throwable t){
  214.         try {
  215.             if(LimitExceededIOException.isLimitExceededIOException(t) && t.getMessage()!=null && t.getMessage().startsWith(CostantiPdD.PREFIX_LIMITED_RESPONSE)) {
  216.                 return true;
  217.             }
  218.         }catch(Throwable tIgnore) {
  219.             // ignore
  220.         }
  221.         
  222.         return false;
  223.     }
  224.     
  225.     public static InformazioniErroriInfrastrutturali readInformazioniErroriInfrastrutturali(PdDContext pddContext){
  226.         
  227.         InformazioniErroriInfrastrutturali informazioniErrori = new InformazioniErroriInfrastrutturali();
  228.         
  229.         boolean erroreUtilizzoConnettore = false;
  230.         if(pddContext!=null){
  231.             Object o = pddContext.getObject(org.openspcoop2.core.constants.Costanti.ERRORE_UTILIZZO_CONNETTORE);
  232.             if(o instanceof Boolean){
  233.                 erroreUtilizzoConnettore = (Boolean) o;
  234.             }
  235.         }
  236.         informazioniErrori.setErroreUtilizzoConnettore(erroreUtilizzoConnettore);

  238.         boolean erroreSOAPFaultServerPortaDelegata = false;
  239.         if(pddContext!=null){
  240.             Object o = pddContext.getObject(org.openspcoop2.core.constants.Costanti.ERRORE_SOAP_FAULT_SERVER);
  241.             if(o instanceof Boolean){
  242.                 erroreSOAPFaultServerPortaDelegata = (Boolean) o;
  243.             }
  244.         }
  245.         informazioniErrori.setRicevutoSoapFaultServerPortaDelegata(erroreSOAPFaultServerPortaDelegata);
  246.         
  247.         boolean erroreContenutoRichiestaNonRiconosciuto = false;
  248.         if(pddContext!=null){
  249.             Object o = pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO);
  250.             if(o instanceof Boolean){
  251.                 erroreContenutoRichiestaNonRiconosciuto = (Boolean) o;
  252.             }
  253.         }
  254.         informazioniErrori.setContenutoRichiestaNonRiconosciuto(erroreContenutoRichiestaNonRiconosciuto);
  255.         
  256.         boolean erroreContenutoRispostaNonRiconosciuto = false;
  257.         if(pddContext!=null){
  258.             Object o = pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO);
  259.             if(o instanceof Boolean){
  260.                 erroreContenutoRispostaNonRiconosciuto = (Boolean) o;
  261.             }
  262.         }
  263.         informazioniErrori.setContenutoRispostaNonRiconosciuto(erroreContenutoRispostaNonRiconosciuto);
  264.         
  265.         return informazioniErrori;
  266.     }
  267.     
  268.     


  271.     public static String checkMustUnderstand(OpenSPCoop2SoapMessage message,IProtocolFactory<?> protocolFactory) throws MessageException{
  272.         SOAPEnvelope envelope = null;
  273.         SOAPHeader header = null;
  274.         try {
  275.             OpenSPCoop2Properties openspcoopProperties = OpenSPCoop2Properties.getInstance();

  277.             if(openspcoopProperties!=null){
  278.                 if(openspcoopProperties.isBypassFilterMustUnderstandEnabledForAllHeaders()){
  279.                     return null;
  280.                 }else{
  281.                     
  282.                     envelope = message.getSOAPPart().getEnvelope();
  283.                     header = envelope.getHeader();
  284.                     
  285.                     //Se non c'e' l'header il controllo e' inutile
  286.                     if(header == null) return null;
  287.                     
  288.                     List<NameValue> filtri = openspcoopProperties.getBypassFilterMustUnderstandProperties(protocolFactory.getProtocol());
  289.                     if(filtri!=null && !filtri.isEmpty()){
  290.                         return ServicesUtils.checkMustUnderstandHeaderElement(message.getMessageType(),header,filtri);
  291.                     }
  292.                 }
  293.             }

  295.         } catch (Exception ex) {
  296.             
  297.             Throwable t = ParseExceptionUtils.getParseException(ex);
  298.             if(t!=null){
  299.                 throw new MessageException(ex);
  300.             }
  301.             
  302.             if(Utilities.existsInnerException(ex, "com.ctc.wstx.exc.WstxUnexpectedCharException") || Utilities.existsInnerException(ex, "com.ctc.wstx.exc.WstxParsingException"))
  303.                 throw new MessageException(ex);
  304.             else
  305.                 throw new MessageException("BypassMustUnderstand, errore durante il set processed degli header con mustUnderstand='1' e actor non presente: "+ex.getMessage(), 
  306.                     ex);
  307.         }  finally{
  308.             // *** GB ***
  309.             header = null;
  310.             envelope = null;
  311.             // *** GB ***
  312.         }       
  313.         return null;
  314.     }
  315.     private static String checkMustUnderstandHeaderElement(MessageType messageType, SOAPHeader header,List<NameValue> filtri) throws UtilsException{
  316.         
  317.         try{
  318.             StringBuilder bfError = new StringBuilder();
  319.             if(!SoapUtils.checkMustUnderstandHeaderElement(messageType, header, filtri, bfError)){
  320.                 return bfError.toString();
  321.             }
  322.             return null;
  323.         }catch(Exception e){
  324.             throw new UtilsException(e.getMessage(),e);
  325.         }
  326.         
  327.     }
  328.     
  329.     public static String checkSOAPEnvelopeNamespace(OpenSPCoop2SoapMessage message, MessageType messageType) throws MessageException{
  330.         try {
  331.             if(!SoapUtils.checkSOAPEnvelopeNamespace(message, messageType)){
  332.                 
  333.                 OpenSPCoop2MessageSoapStreamReader reader = message.getSoapReader();
  334.                 String envelopeNamespace = null;
  335.                 if(reader!=null) {
  336.                     envelopeNamespace = reader.getNamespace();
  337.                 }
  338.                 if(envelopeNamespace==null) {
  339.                     return message.getSOAPPart().getEnvelope().getNamespaceURI();
  340.                 }
  341.                 else {
  342.                     return envelopeNamespace;
  343.                 }
  344.                 
  345.             }
  346.             return null;
  347.         } catch (Exception ex) {
  348.             throw new MessageException("CheckSoapEnvelopeNamespace, errore durante il controllo del namespace del soap envelope: "+ex.getMessage(),ex);
  349.         } 
  350.     }

  352.     
  353.     public static void checkCharset(String contentType, List<String> ctDefault, MsgDiagnostico msgDiag, boolean request, TipoPdD tipoPdD) throws MessageException {
  354.         try {
  355.             if(contentType!=null && contentType.contains(HttpConstants.CONTENT_TYPE_PARAMETER_CHARSET)){
  356.                 String charset = null;
  357.                 if(ContentTypeUtilities.isMultipartContentType(contentType)) {
  358.                     String ct = ContentTypeUtilities.getInternalMultipartContentType(charset);
  359.                     if(ct!=null) {
  360.                         charset = ContentTypeUtilities.readCharsetFromContentType(ct);
  361.                     }
  362.                 }
  363.                 else {
  364.                     charset = ContentTypeUtilities.readCharsetFromContentType(contentType);
  365.                 }
  366.                 if(charset!=null) {
  367.                     if(charset.startsWith("\"") && charset.length()>1) {
  368.                         charset = charset.substring(1);
  369.                     }
  370.                     if(charset.endsWith("\"") && charset.length()>1) {
  371.                         charset = charset.substring(0,charset.length()-1);
  372.                     }
  373.                 }
  374.                 boolean find = false;
  375.                 for (String def : ctDefault) {
  376.                     if(def.equalsIgnoreCase(charset)) {
  377.                         find = true;
  378.                         break;
  379.                     }
  380.                 }
  381.                 if(!find) {
  382.                     msgDiag.addKeyword(CostantiPdD.KEY_CONTENT_TYPE, contentType);
  383.                     StringBuilder sb = new StringBuilder();
  384.                     for (String def : ctDefault) {
  385.                         if(sb.length()>0) {
  386.                             sb.append(",");
  387.                         }
  388.                         sb.append(def);
  389.                     }
  390.                     msgDiag.addKeyword(CostantiPdD.KEY_CHARSET_DEFAULT, sb.toString());
  391.                     String idModuloFunzionale = TipoPdD.DELEGATA.equals(tipoPdD) ? MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI : MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE;
  392.                     String idDiagnostico = request ? "richiesta.warningCharsetDifferenteDefault" : "risposta.warningCharsetDifferenteDefault";
  393.                     msgDiag.logPersonalizzato(idModuloFunzionale, idDiagnostico);
  394.                 }
  395.             }
  396.         } catch (Exception ex) {
  397.             throw new MessageException(ex.getMessage(),ex);
  398.         }
  399.     }

  401.     
  402.     public static boolean verificaRispostaRelazioneCodiceTrasporto202(IProtocolFactory<?> protocolFactory,OpenSPCoop2Properties openSPCoopProperties,
  403.             OpenSPCoop2Message responseMessage,boolean gestioneLatoPortaDelegata) throws ProtocolException, MessageException, MessageNotSupportedException {
  404.         
  405.         if(responseMessage==null){
  406.             return false;
  407.         }
  408.         
  409.         IProtocolManager protocolManager = protocolFactory.createProtocolManager(); 
  410.         
  411.         boolean rispostaPresente = true;
  412.         if(protocolManager.isHttpEmptyResponseOneWay()){
  413.             if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())){
  414.                 OpenSPCoop2SoapMessage soap = responseMessage.castAsSoap();
  415.                 
  416.                 if(soap.hasAttachments()) {
  417.                     rispostaPresente = true;
  418.                 }
  419.                 else {
  420.                     if(!soap.isSOAPBodyEmpty()) {
  421.                         rispostaPresente = true;
  422.                     }
  423.                     else {
  424.                     
  425.                         //potenziale msg inutile.
  426.                         Object h = null;
  427.                         SOAPHeader header = null;
  428.                         h = soap.getSOAPHeader();
  429.                         if(h!=null){
  430.                             header = (SOAPHeader) h;
  431.                         }
  432.                         if(h==null || header==null ||  SoapUtils.getFirstNotEmptyChildNode(responseMessage.getFactory(), header,false)==null ){
  433.                             /**System.out.println("MESSAGGIO INUTILE");*/
  434.                             rispostaPresente = false;
  435.                         }else{
  436.                             if(gestioneLatoPortaDelegata &&
  437.                                 !protocolManager.isHttpOneWay_PD_HTTPEmptyResponse() ) {
  438.                                 // E' possibile impostare una opzione che non torni nulla anche in questo caso
  439.                                 rispostaPresente = false;
  440.                             }
  441.                         }

  443.                         
  444.                         // *** GB ***
  445.                         header = null;
  446.                         h = null;
  447.                         // *** GB ***
  448.                     }
  449.                 }
  450.             }
  451.             else{
  452.                 /**OpenSPCoop2RestMessage<?> rest = responseMessage.castAsRest();
  453.                 if(rest.hasContent()==false){
  454.                     //System.out.println("MESSAGGIO VUOTO");
  455.                     rispostaPresente = false;
  456.                 }*/
  457.                 rispostaPresente = true; // La gestione del return code in REST è indipendente dal fatto se vi è o meno un contenuto
  458.             }
  459.         }
  460.         
  461.         return rispostaPresente;
  462.     }
  463.         
  464.     
  465.     
  466.     public static void setTransferLength(TransferLengthModes transferLengthMode,
  467.             ConnectorInMessage connectorInMessage, ConnectorOutMessage connectorOutMessage,
  468.             OpenSPCoop2Message message) throws ConnectorException, MessageException {
  469.         String requestProtocoll = connectorInMessage.getProtocol();
  470.         if(requestProtocoll!=null && requestProtocoll.endsWith("1.1")){
  471.             if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(transferLengthMode)){
  472.                 connectorOutMessage.setHeader(HttpConstants.TRANSFER_ENCODING,HttpConstants.TRANSFER_ENCODING_VALUE_CHUNCKED);
  473.             }
  474.             else if(TransferLengthModes.CONTENT_LENGTH.equals(transferLengthMode) &&
  475.                 message!=null){
  476.                 message.writeTo(NullOutputStream.INSTANCE, false);
  477.                 connectorOutMessage.setContentLength((int)message.getOutgoingMessageContentLength());
  478.             }
  479.         }
  480.     }
  481.     public static void setTransferLength(TransferLengthModes transferLengthMode,
  482.             ConnectorInMessage connectorInMessage, ConnectorOutMessage connectorOutMessage,
  483.             Long length) throws ConnectorException {
  484.         String requestProtocoll = connectorInMessage.getProtocol();
  485.         if(requestProtocoll!=null && requestProtocoll.endsWith("1.1")){
  486.             if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(transferLengthMode)){
  487.                 connectorOutMessage.setHeader(HttpConstants.TRANSFER_ENCODING,HttpConstants.TRANSFER_ENCODING_VALUE_CHUNCKED);
  488.             }
  489.             else if(TransferLengthModes.CONTENT_LENGTH.equals(transferLengthMode) &&
  490.                 length!=null){
  491.                 connectorOutMessage.setContentLength(length.intValue());
  492.             }
  493.         }
  494.     }
  495.     
  496.     
  497.     public static void setContentType(OpenSPCoop2Message message, ConnectorOutMessage connectorOutMessage) throws ConnectorException{
  498.         try{
  499.             if(CostantiPdD.isEnabledAddSWAStartParameterIfNotPresent(message)) {
  500.                 SoapUtils.addSWAStartParameterIfNotPresent(message);
  501.             }
  502.             
  503.             String contentTypeRisposta = message.getContentType();
  504.             if (contentTypeRisposta != null) {
  505.                 connectorOutMessage.setContentType(contentTypeRisposta);
  506.             }else {
  507.                 if(ServiceBinding.SOAP.equals(message.getServiceBinding())){
  508.                     throw new MessageException("Risposta errore senza Content-type");
  509.                 }
  510.                 else{
  511.                     if(message.castAsRest().hasContent()){
  512.                         throw new MessageException("Risposta errore senza Content-type");
  513.                     }
  514.                 }
  515.             }
  516.         }catch(Exception e){
  517.             throw new ConnectorException(e.getMessage(),e);
  518.         }   
  519.     }
  520.     
  521.     
  522.     public static void setGovWayHeaderResponse(ServiceBinding serviceBindingRequest, OpenSPCoop2Message msg, OpenSPCoop2Properties openspcoopProperties,
  523.             Map<String, List<String>> propertiesTrasporto, Logger logCore, boolean portaDelegata, PdDContext pddContext, RequestInfo requestInfo) {
  524.                 
  525.         UtilitiesIntegrazione utilitiesIntegrazione = null;
  526.         try {                       
  527.             if(portaDelegata) {
  528.                 utilitiesIntegrazione = UtilitiesIntegrazione.getInstancePDResponse(logCore);
  529.             }
  530.             else {
  531.                 utilitiesIntegrazione = UtilitiesIntegrazione.getInstancePAResponse(logCore);
  532.             }
  533.             
  534.             List<String> idTransazioneValues = TransportUtils.getRawObject(propertiesTrasporto, Costanti.ID_TRANSAZIONE.getValue());
  535.             
  536.             if(idTransazioneValues==null || idTransazioneValues.isEmpty()) {
  537.                 String idTransazione = (String) pddContext.getObject(Costanti.ID_TRANSAZIONE);
  538.                 HeaderIntegrazione hdr = new HeaderIntegrazione(idTransazione);
  539.                 utilitiesIntegrazione.setTransportProperties(hdr,propertiesTrasporto,null);
  540.             }
  541.             else {
  542.                 utilitiesIntegrazione.setInfoProductTransportProperties(propertiesTrasporto);
  543.             }
  544.         }catch(Exception e){
  545.             logCore.error("Set header di integrazione fallito: "+e.getMessage(),e);
  546.         }
  547.         if(pddContext.containsKey(CostantiControlloTraffico.PDD_CONTEXT_HEADER_RATE_LIMITING)) {
  548.             Properties pHeaderRateLimiting = (Properties) pddContext.getObject(CostantiControlloTraffico.PDD_CONTEXT_HEADER_RATE_LIMITING);
  549.             if(pHeaderRateLimiting.size()>0) {
  550.                 java.util.Enumeration<?> en = pHeaderRateLimiting.keys();
  551.                 while(en.hasMoreElements()){
  552.                     String key = (String) en.nextElement();
  553.                     TransportUtils.setHeader(propertiesTrasporto,key, pHeaderRateLimiting.getProperty(key));
  554.                 }   
  555.             }
  556.         }
  557.                 
  558.         setCORSAllowOrigin(propertiesTrasporto, logCore, portaDelegata, pddContext, requestInfo);
  559.             
  560.         // ------ inserisco gli headers peer -------
  561.         HeaderMap extraHeaders = Objects.requireNonNullElse(
  562.                 (HeaderMap) pddContext.getObject(CostantiPdD.EXTRA_HEADERS_RESPONSE),
  563.                 new HeaderMap());
  564.         extraHeaders.forEach((key, value) ->
  565.             TransportUtils.setHeader(propertiesTrasporto, key, value)
  566.         );
  567.         
  568.         try {
  569.                 
  570.             OpenSPCoop2MessageProperties forwardHeader = null;
  571.             if(msg!=null &&
  572.                     openspcoopProperties!=null // Puo' non essere inizializzato
  573.                     ) {
  574.                 if(ServiceBinding.REST.equals(msg.getServiceBinding())) {
  575.                     forwardHeader = msg.getForwardTransportHeader(openspcoopProperties.getRESTServicesHeadersForwardConfig(false));
  576.                 }
  577.                 else {
  578.                     forwardHeader = msg.getForwardTransportHeader(openspcoopProperties.getSOAPServicesHeadersForwardConfig(false));
  579.                 }
  580.             }
  581.             
  582.             try {
  583.                 if(utilitiesIntegrazione!=null) {
  584.                     ServiceBinding sb = msg!=null ? msg.getServiceBinding() : serviceBindingRequest;
  585.                     utilitiesIntegrazione.setSecurityHeaders(sb, requestInfo, propertiesTrasporto, forwardHeader);
  586.                 }
  587.             }catch(Exception e){
  588.                 logCore.error("Set security headers fallito: "+e.getMessage(),e);
  589.             }
  590.             
  591.             if(propertiesTrasporto!=null && !propertiesTrasporto.isEmpty()) {
  592.                 if(forwardHeader!=null && forwardHeader.size()>0) {
  593.                     for (String key : propertiesTrasporto.keySet()) {
  594.                         forwardHeader.removePropertyValues(key);
  595.                     }
  596.                 }
  597.             }
  598.             
  599.         }catch(Exception e){
  600.             logCore.error("Pulizia forward header, rispetto a quelli generati da GovWay, fallito: "+e.getMessage(),e);
  601.         }
  602.     }
  603.     
  604.     
  605.     
  606.     private static void setCORSAllowOrigin(Map<String, List<String>> propertiesTrasporto, Logger logCore, boolean portaDelegata, PdDContext pddContext, RequestInfo requestInfo) {
  607.         try {
  608.             
  609.             Object nomePortaObject = pddContext.getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  610.             String nomePorta = null;
  611.             if(nomePortaObject instanceof String) {
  612.                 nomePorta = (String) nomePortaObject;
  613.             }
  614.             
  615.             CorsConfigurazione cors = null;
  616.             HttpServletRequest httpServletRequest = null;
  617.             URLProtocolContext protocolContext = null;
  618.             if(requestInfo!=null) {
  619.                 protocolContext = requestInfo.getProtocolContext();
  620.             }
  621.             if(protocolContext!=null) {
  622.                 httpServletRequest = protocolContext.getHttpServletRequest();   
  623.                 if(nomePorta==null) {
  624.                     nomePorta = protocolContext.getInterfaceName();
  625.                 }
  626.             }
  627.             
  628.             if(httpServletRequest!=null) {
  629.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance();
  630.                 if(nomePorta!=null) {
  631.                     if(portaDelegata) {
  632.                         IDPortaDelegata idPD = new IDPortaDelegata();
  633.                         idPD.setNome(nomePorta);
  634.                         PortaDelegata pdDefault = configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  635.                         cors = configurazionePdDManager.getConfigurazioneCORS(pdDefault);
  636.                     }
  637.                     else {
  638.                         IDPortaApplicativa idPA = new IDPortaApplicativa();
  639.                         idPA.setNome(nomePorta);
  640.                         PortaApplicativa paDefault = configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  641.                         cors = configurazionePdDManager.getConfigurazioneCORS(paDefault);                       
  642.                     }
  643.                 }
  644.                 if(cors==null) {
  645.                     cors = configurazionePdDManager.getConfigurazioneCORS();
  646.                 }
  647.             }
  648.             else {
  649.                 cors = new CorsConfigurazione();
  650.                 cors.setStato(StatoFunzionalita.DISABILITATO);
  651.             }
  652.             
  653.             if(StatoFunzionalita.ABILITATO.equals(cors.getStato()) && TipoGestioneCORS.GATEWAY.equals(cors.getTipo())) {
  654.                 // verifico che non siamo in una preflight già gestita
  655.                 boolean preflightRequest = pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY);
  656.                 if(!preflightRequest) {
  657.                     CORSFilter corsFilter = new CORSFilter(logCore, cors);
  658.                     CORSWrappedHttpServletResponse res = new CORSWrappedHttpServletResponse(false);
  659.                     corsFilter.doCORS(httpServletRequest, res, CORSRequestType.ACTUAL, true);
  660.                     propertiesTrasporto.putAll(res.getHeadersValues());
  661.                 }
  662.             }
  663.             
  664.         }catch(Exception e){
  665.             logCore.error("Set cors origin: "+e.getMessage(),e);
  666.         }

  668.     }
  669.     
  670.     
  671.     public static boolean isRequestWsdl(ConnectorInMessage reqParam, Logger logCore) {
  672.         
  673.         try {
  674.         
  675.             if(reqParam==null || reqParam.getURLProtocolContext()==null || reqParam.getURLProtocolContext().getHttpServletRequest()==null) {
  676.                 return false;
  677.             }
  678.             HttpServletRequest req = reqParam.getURLProtocolContext().getHttpServletRequest();
  679.             
  680.             if(HttpRequestMethod.GET.equals(req.getMethod())){
  681.                 Enumeration<?> parameters = req.getParameterNames();
  682.                 while(parameters.hasMoreElements()){
  683.                     String key = (String) parameters.nextElement();
  684.                     String value = req.getParameter(key);
  685.                     if("wsdl".equalsIgnoreCase(key) && (value==null || "".equals(value)) ){
  686.                         return true;
  687.                     }
  688.                 }
  689.             }
  690.             
  691.         }catch(Exception e){
  692.             logCore.error("IsRequestWsdl fallita: "+e.getMessage(),e);
  693.         }
  694.         
  695.         return false;
  696.     }
  697.     
  698.     public static void writeWsdl(ConnectorOutMessage response,RequestInfo requestInfo, 
  699.             IDService idService, ServiceIdentificationReader serviceIdentificationReader, Logger logCore) throws ConnectorException {
  700.         try {
  701.             
  702.             boolean generazioneWsdlEnabled = false;
  703.             if(IDService.PORTA_APPLICATIVA.equals(idService)) {
  704.                 generazioneWsdlEnabled = OpenSPCoop2Properties.getInstance().isGenerazioneWsdlPortaApplicativaEnabled();
  705.             }
  706.             else {
  707.                 generazioneWsdlEnabled = OpenSPCoop2Properties.getInstance().isGenerazioneWsdlPortaDelegataEnabled();
  708.             }
  709.             if(!generazioneWsdlEnabled) {
  710.                 response.setStatus(404);
  711.                 response.sendResponse(DumpByteArrayOutputStream.newInstance(ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeWsdlUnsupported(idService)).getBytes()));
  712.                 return;
  713.             }
  714.             
  715.             byte [] wsdl = null;
  716.             if(requestInfo!=null && requestInfo.getIdServizio()!=null) {
  717.                 AccordoServizioParteSpecifica asps = null;
  718.                 AccordoServizioParteComune aspc = null;
  719.                 byte [] wsdlLogico = null;
  720.                 try {
  721.                     asps = serviceIdentificationReader.getRegistryReader().getAccordoServizioParteSpecifica(requestInfo.getIdServizio(), false);
  722.                 }catch(RegistryNotFound notFound) {}
  723.                 if(asps!=null) {
  724.                     try {
  725.                         IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  726.                         aspc = serviceIdentificationReader.getRegistryReader().getAccordoServizioParteComune(idAccordo, true, true);
  727.                     }catch(RegistryNotFound notFound) {}
  728.                 }
  729.                 if(aspc!=null) {
  730.                     if(TipologiaServizio.CORRELATO.equals(asps.getTipologiaServizio())){
  731.                         wsdlLogico = aspc.getByteWsdlLogicoFruitore();
  732.                     }
  733.                     else {
  734.                         wsdlLogico = aspc.getByteWsdlLogicoErogatore();
  735.                     }
  736.                 }
  737.                 if(wsdlLogico!=null) {
  738.                     // wsdl logico utilizzato dentro wsdlWrapperUtilities
  739.                     MessageXMLUtils xmlUtils = MessageXMLUtils.DEFAULT;
  740.                     WSDLUtilities wsdlUtilities = new WSDLUtilities(xmlUtils);
  741.                     AccordoServizioWrapperUtilities wsdlWrapperUtilities = new AccordoServizioWrapperUtilities(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), logCore);
  742.                     wsdlWrapperUtilities.setAccordoServizio(new AccordoServizioWrapper());
  743.                     wsdlWrapperUtilities.getAccordoServizioWrapper().setAccordoServizio(aspc);
  744.                     javax.wsdl.Definition wsdlDefinition = null;
  745.                     if(TipologiaServizio.CORRELATO.equals(asps.getTipologiaServizio())){
  746.                         wsdlWrapperUtilities.getAccordoServizioWrapper().setBytesWsdlImplementativoFruitore(asps.getByteWsdlImplementativoFruitore());
  747.                         wsdlDefinition = wsdlWrapperUtilities.buildWsdlFruitoreFromBytes();
  748.                     }
  749.                     else {
  750.                         wsdlWrapperUtilities.getAccordoServizioWrapper().setBytesWsdlImplementativoErogatore(asps.getByteWsdlImplementativoErogatore());
  751.                         wsdlDefinition = wsdlWrapperUtilities.buildWsdlErogatoreFromBytes();
  752.                     }
  753.                     
  754.                     if(asps.getPortType()!=null && requestInfo.getProtocolContext()!=null) {
  755.                         
  756.                         UrlInvocazioneAPI urlInvocazioneApi = ConfigurazionePdDManager.getInstance().getConfigurazioneUrlInvocazione(requestInfo.getProtocolFactory(), 
  757.                                  IDService.PORTA_APPLICATIVA.equals(idService) ? RuoloContesto.PORTA_APPLICATIVA : RuoloContesto.PORTA_DELEGATA,
  758.                                  requestInfo.getIntegrationServiceBinding(),
  759.                                  requestInfo.getProtocolContext().getInterfaceName(),
  760.                                  requestInfo.getIdentitaPdD(),
  761.                                  aspc, 
  762.                                  requestInfo);       
  763.                         String prefixGatewayUrl = urlInvocazioneApi.getBaseUrl();
  764.                         String contesto = urlInvocazioneApi.getContext();
  765.                         prefixGatewayUrl = Utilities.buildUrl(prefixGatewayUrl, contesto);
  766.                         DefinitionWrapper wrapper = new DefinitionWrapper(wsdlDefinition, xmlUtils);
  767.                         PortType ptWSDL = wrapper.getPortType(asps.getPortType());
  768.                         if(ptWSDL!=null && ptWSDL.getQName()!=null && ptWSDL.getQName().getLocalPart()!=null) {
  769.                             Binding bindingWSDL = wrapper.getBindingByPortType(ptWSDL.getQName().getLocalPart());
  770.                             if(bindingWSDL!=null && bindingWSDL.getQName()!=null && bindingWSDL.getQName().getLocalPart()!=null) {
  771.                                 Port portWSDL = wrapper.getServicePortByBindingName(bindingWSDL.getQName().getLocalPart());
  772.                                 if(portWSDL!=null) {
  773.                                     wrapper.updateLocation(portWSDL, prefixGatewayUrl);
  774.                                 }
  775.                             }
  776.                         }
  777.                     }
  778.                     
  779.                     
  780.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  781.                     wsdlUtilities.writeWsdlTo(wsdlDefinition, bout);
  782.                     bout.flush();
  783.                     bout.close();
  784.                     wsdl = bout.toByteArray();
  785.                 }
  786.             }
  787.             
  788.             if(wsdl!=null) {
  789.                 HttpUtilities.setOutputFile(new ConnectorHttpServletResponse(response), true, "interface.wsdl");    
  790.                 response.setStatus(200);
  791.                 response.sendResponse(DumpByteArrayOutputStream.newInstance(wsdl));
  792.             }
  793.             else {
  794.                 response.setStatus(404);
  795.                 response.sendResponse(DumpByteArrayOutputStream.newInstance(ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeWsdlNotDefined(idService)).getBytes()));
  796.             }
  797.             
  798.         }catch(Exception e){
  799.             logCore.error("Lettura wsdl fallita: "+e.getMessage(),e);
  800.             throw new ConnectorException("Lettura wsdl fallita: "+e.getMessage(),e);
  801.         }
  802.     }
  803.     
  804.     
  805.     public static void processTrackingException(Exception e, Logger log, FaseTracciamento fase, Context context) throws HandlerException {
  806.         HandlerException he = null;
  807.         if(e instanceof HandlerException) {
  808.             he = (HandlerException) e;
  809.             if(he.getIntegrationFunctionError()==null) {
  810.                 he.setIntegrationFunctionError(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE);
  811.                 String msg = "Tracciamento '"+fase.name()+"' fallito: "+e.getMessage();
  812.                 log.error(msg,e);
  813.             }
  814.         }
  815.         else {
  816.             he = new HandlerException();
  817.             he.setIntegrationFunctionError(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE);
  818.             String msg = "Tracciamento '"+fase.name()+"' fallito: "+e.getMessage();
  819.             log.error(msg,e);
  820.         }
  821.         context.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_TRACCIAMENTO, "true");
  822.         throw he;
  823.     }
  824.     
  825.     public static EsitoTransazione updateEsitoConAnomalie(EsitoTransazione esito, Logger log, IProtocolFactory<?> protocolFactory) {
  826.         try {
  827.             if(EsitoTransazioneName.OK.equals(esito.getName())) {
  828.                 EsitiProperties esitiProperties = EsitiProperties.getInstance(log, protocolFactory);
  829.                 esito = esitiProperties.convertToEsitoTransazione(EsitoTransazioneName.OK_PRESENZA_ANOMALIE, esito.getContextType()); 
  830.             }
  831.         }catch(Exception e) {
  832.             String msg = "Update esito con anomalie fallito: "+e.getMessage();
  833.             log.error(msg,e);
  834.         }
  835.         return esito;
  836.     }
  837.     
  838.     public static void initCheckConnectionDB(Logger logR, boolean checkIsClosed, boolean checkAutoCommit) {
  839.         DriverConfigurazioneDB.setCheckLogger(logR);
  840.         DriverConfigurazioneDB.setCheckIsClosed(checkIsClosed);
  841.         DriverConfigurazioneDB.setCheckAutocommit(checkAutoCommit);
  842.         DriverRegistroServiziDB.setCheckLogger(logR);
  843.         DriverRegistroServiziDB.setCheckIsClosed(checkIsClosed);
  844.         DriverRegistroServiziDB.setCheckAutocommit(checkAutoCommit);
  845.         JDBCServiceManagerBase.setCheckLogger(logR);
  846.         JDBCServiceManagerBase.setCheckIsClosed(checkIsClosed);
  847.         JDBCServiceManagerBase.setCheckAutocommit(checkAutoCommit);
  848.         BasicComponentFactory.setCheckLogger(logR);
  849.         BasicComponentFactory.setCheckIsClosed(checkIsClosed);
  850.         BasicComponentFactory.setCheckAutocommit(checkAutoCommit);
  851.         IDSerialGenerator.setCheckLogger(logR);
  852.         IDSerialGenerator.setCheckIsClosed(checkIsClosed);
  853.         IDSerialGenerator.setCheckAutocommit(checkAutoCommit);
  854.         org.openspcoop2.utils.datasource.DataSource.setCheckLogger(logR);
  855.         org.openspcoop2.utils.datasource.DataSource.setCheckIsClosed(checkIsClosed);
  856.         org.openspcoop2.utils.datasource.DataSource.setCheckAutocommit(checkAutoCommit);
  857.     }
  858. }

  860. class ConnectorHttpServletResponse extends WrappedHttpServletResponse {

  862.     @Override
  863.     public void setContentType(String type) {
  864.         try {
  865.             this.outMessage.setContentType(type);
  866.         }catch(Exception e) {
  867.             throw new UtilsRuntimeException(e.getMessage(),e);
  868.         }
  869.     }

  871.     @Override
  872.     public void setDateHeader(String arg0, long arg1) {
  873.         try {
  874.             this.outMessage.setHeader(arg0, arg1+"");
  875.         }catch(Exception e) {
  876.             throw new UtilsRuntimeException(e.getMessage(),e);
  877.         }
  878.     }

  880.     @Override
  881.     public void setHeader(String arg0, String arg1) {
  882.         try {
  883.             this.outMessage.setHeader(arg0, arg1);
  884.         }catch(Exception e) {
  885.             throw new UtilsRuntimeException(e.getMessage(),e);
  886.         }
  887.     }
  888.     
  889.     @Override
  890.     public void addHeader(String arg0, String arg1) {
  891.         try {
  892.             this.outMessage.addHeader(arg0, arg1);
  893.         }catch(Exception e) {
  894.             throw new UtilsRuntimeException(e.getMessage(),e);
  895.         }
  896.     }

  898.     private ConnectorOutMessage outMessage;
  899.     
  900.     public ConnectorHttpServletResponse(ConnectorOutMessage outMessage) {
  901.         super(null);
  902.         this.outMessage = outMessage;
  903.     }
  904.     
  905. }
Created with JaCoCo 0.8.8.202204050719