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



  23. package org.openspcoop2.protocol.engine.validator;

  25. import java.util.ArrayList;
  26. import java.util.Iterator;
  27. import java.util.List;

  29. import org.openspcoop2.core.id.IDServizio;
  30. import org.openspcoop2.core.id.IDSoggetto;
  31. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  32. import org.openspcoop2.core.transazioni.utils.TempiElaborazione;
  33. import org.openspcoop2.message.OpenSPCoop2Message;
  34. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  35. import org.openspcoop2.message.constants.MessageType;
  36. import org.openspcoop2.message.constants.ServiceBinding;
  37. import org.openspcoop2.protocol.engine.Configurazione;
  38. import org.openspcoop2.protocol.sdk.Busta;
  39. import org.openspcoop2.protocol.sdk.BustaRawContent;
  40. import org.openspcoop2.protocol.sdk.Context;
  41. import org.openspcoop2.protocol.sdk.Eccezione;
  42. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  43. import org.openspcoop2.protocol.sdk.ProtocolException;
  44. import org.openspcoop2.protocol.sdk.SecurityInfo;
  45. import org.openspcoop2.protocol.sdk.Servizio;
  46. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  47. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  48. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  49. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  50. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  51. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  52. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  53. import org.openspcoop2.protocol.sdk.state.IState;
  54. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  55. import org.openspcoop2.protocol.sdk.validator.IValidatoreErrori;
  56. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  57. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  58. import org.openspcoop2.security.message.MessageSecurityContext;
  59. import org.openspcoop2.security.message.SubErrorCodeSecurity;
  60. import org.openspcoop2.utils.LoggerWrapperFactory;
  61. import org.openspcoop2.utils.digest.IDigestReader;
  62. import org.slf4j.Logger;




  67. /**
  68.  * Classe utilizzata per effettuare la validazione di una busta
  69.  *
  70.  * @author Poli Andrea (apoli@link.it)
  71.  * @author Tronci Fabio (tronci@link.it)
  72.  * @author Lorenzo Nardi (nardi@link.it)
  73.  * @author $Author$
  74.  * @version $Rev$, $Date$
  75.  */

  77. public class Validatore  {


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

  82.     /** Se IState e' un'istanza di StatefulMessage possiede una Connessione SQL in autoCommit mode su cui effettuare query 
  83.      *  Altrimenti, e' un'istanza di StatelessMessage e nn necessita di connessioni  */
  84.     private IState state;
  85.     
  86.     
  87.     /** Messaggio. */
  88.     private OpenSPCoop2Message msg;
  89.     private Context context;
  90.     /** Proprieta di Validazione. */
  91.     private ProprietaValidazione proprietaValidazione;
  92.     /** Eventuale errore avvenuto durante il processo di validazione */
  93.     ErroreCooperazione errore;
  94.     IntegrationFunctionError errore_integrationFunctionError;
  95.     /** Errori di validazione riscontrati sulla busta */
  96.     private java.util.List<Eccezione> erroriValidazione = new ArrayList<>();
  97.     /** Errori di processamento riscontrati sulla busta */
  98.     private java.util.List<Eccezione> erroriProcessamento = new ArrayList<>();
  99.     private String erroreProcessamento_internalMessage; 
  100.     /** Indicazione se la busta validata e' un messaggio errore */
  101.     private boolean isMessaggioErrore;
  102.     private boolean isMessaggioErroreIntestazione;
  103.     private boolean isMessaggioErroreProcessamento;
  104.     /** Indicazione se la busta validata e' una busta di servizio.
  105.      * Una busta e' una busta di servizio, se:
  106.      * - non possiede un servizio (non e' quindi una richiesta)
  107.      * - non possiede un riferimentoMsg (non e' quindi una risposta) 
  108.      **/
  109.     private boolean isBustaDiServizio;
  110.     /** Oggetto Busta contenente i valori della busta ricevuta */
  111.     private Busta busta;
  112.     /** Soggetto Mittente della busta */
  113.     private IDSoggetto mittente;
  114.     /** Servizio richiesto nella busta */
  115.     private IDServizio servizio;
  116.     /** ValidazioneSintattica */
  117.     private ValidazioneSintattica validatoreSintattico;
  118.     public ValidazioneSintattica getValidatoreSintattico() {
  119.         return this.validatoreSintattico;
  120.     }
  121.     public void setValidatoreSintattico(ValidazioneSintattica validator) {
  122.         this.validatoreSintattico = validator;
  123.     }
  124.     
  125.     /** ServizioCorrelato */
  126.     private String servizioCorrelato;
  127.     /** Tipo ServizioCorrelato */
  128.     private String tipoServizioCorrelato;
  129.     /** Versione ServizioCorrelato */
  130.     private Integer versioneServizioCorrelato;
  131.     /** informazioni Servizio */
  132.     private Servizio infoServizio = null;
  133.     /** Profilo di Gestione */
  134.     private String versioneProtocollo = null;
  135.     /** RuoloBusta */
  136.     private RuoloBusta ruoloBustaRicevuta = null;
  137.     /** SecurityInfo */
  138.     private SecurityInfo securityInfo = null;
  139.     
  140.     /** Indicazione se leggere gli attributi qualificati */
  141.     private boolean readQualifiedAttribute;

  143.     
  144.     /** Logger utilizzato per debug. */
  145.     private org.slf4j.Logger log = null;
  146.     private IProtocolFactory<?> protocolFactory;
  147.     private IProtocolManager protocolManager;
  148.     /** bustaErroreHeaderIntestazione: generata solo quando la busta arrivata non contiene gli elementi principali */
  149.     private Busta bustaErroreHeaderIntestazione = null;
  150.     public Busta getBustaErroreHeaderIntestazione() {
  151.         return this.bustaErroreHeaderIntestazione;
  152.     }

  154.     /**
  155.      * Costruttore
  156.      *
  157.      * @param aMsg Messaggio da validare.
  158.      * @param aValidazione tipo di validazione.
  159.      * @param state Oggetto che rappresenta lo stato di una busta
  160.      * @throws ProtocolException 
  161.      * 
  162.      */
  163.     public Validatore(OpenSPCoop2Message aMsg,Context ctx,ProprietaValidazione aValidazione, IState state,boolean readQualifiedAttribute, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  164.         this(aMsg,ctx,aValidazione,state,Configurazione.getLibraryLog(),readQualifiedAttribute, protocolFactory);
  165.     }
  166.     /**
  167.      * Costruttore
  168.      *
  169.      * @param aMsg Messaggio da validare.
  170.      * @param aValidazione tipo di validazione.
  171.      * @param state Oggetto che rappresenta lo stato di una busta
  172.      * @throws ProtocolException 
  173.      * 
  174.      */
  175.     public Validatore(OpenSPCoop2Message aMsg,Context ctx,ProprietaValidazione aValidazione,IState state,Logger alog,boolean readQualifiedAttribute, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  176.         this.msg = aMsg;
  177.         this.context = ctx;
  178.         if(aValidazione == null)
  179.             this.proprietaValidazione = new ProprietaValidazione();
  180.         else
  181.             this.proprietaValidazione = aValidazione;
  182.         this.state = state;
  183.         if(alog!=null){
  184.             this.log = alog;
  185.         }else{
  186.             this.log = LoggerWrapperFactory.getLogger(Validatore.class);
  187.         }
  188.         this.readQualifiedAttribute = readQualifiedAttribute;
  189.         this.protocolFactory = protocolFactory;
  190.         this.protocolManager = this.protocolFactory.createProtocolManager();
  191.     }

  193.     /**
  194.      * Costruttore
  195.      *
  196.      * @param aMsg Messaggio da validare.
  197.      * @throws ProtocolException 
  198.      * 
  199.      */
  200.     public Validatore(OpenSPCoop2Message aMsg,Context ctx,IState state,Logger alog, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  201.         this(aMsg,ctx,null,state,alog,false, protocolFactory);
  202.     }


  205.     public void updateState(IState state){
  206.         this.state = state;
  207.     }
  208.     
  209.     /**
  210.      * Avvia il processo di lettura di una busta ricevuta.
  211.      * Viene effettuata una validazione sintattica
  212.      * Vengono effettuati i seguenti passi:
  213.      * <ul>
  214.      * <li> Controllo header
  215.      * </ul>
  216.      * 
  217.      *
  218.      * @return true in caso di identificazione con successo, false altrimenti.
  219.      * 
  220.      */
  221.     public boolean validazioneSintattica() {
  222.         return validazioneSintattica(null, null);
  223.     }
  224.     
  225.     /**
  226.      * Per la validazione puo' essere necessaria la busta qualora le informazioni di cooperazione non siano dentro al messaggio.
  227.      * 
  228.      * @param busta
  229.      * @return true se la struttura del messaggio e' corretta
  230.      */
  231.     
  232.     public boolean validazioneSintattica(Busta busta, Boolean isRichiestaParam) {

  234.         boolean request = (isRichiestaParam==null) || (isRichiestaParam.booleanValue());
  235.         try{
  236.             /** (Controllo presenza Busta) */
  237.             this.validatoreSintattico = new ValidazioneSintattica(this.context, this.state,this.msg, busta, isRichiestaParam, this.log,this.readQualifiedAttribute, this.protocolFactory);
  238.             if (this.validatoreSintattico.valida() == false){
  239.                 this.errore = this.validatoreSintattico.getErrore();
  240.                 this.errore_integrationFunctionError = this.validatoreSintattico.getErrore_integrationFunctionError();
  241.                 if(this.errore_integrationFunctionError==null) {
  242.                     if(request){
  243.                         this.errore_integrationFunctionError = IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_REQUEST;
  244.                     }
  245.                     else {
  246.                         this.errore_integrationFunctionError = IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_RESPONSE;
  247.                     }
  248.                 }
  249.                 this.bustaErroreHeaderIntestazione = this.validatoreSintattico.getBustaErroreHeaderIntestazione();
  250.                 return false;
  251.             }
  252.             
  253.             this.errore_integrationFunctionError = this.validatoreSintattico.getErrore_integrationFunctionError();
  254.             
  255.             this.busta = this.validatoreSintattico.getBusta();
  256.             IValidatoreErrori validatoreErrori = this.protocolFactory.createValidatoreErrori(this.state);
  257.             ProprietaValidazioneErrori pValidazioneErrori = new ProprietaValidazioneErrori();
  258.             pValidazioneErrori.setIgnoraEccezioniNonGravi(this.protocolManager.isIgnoraEccezioniNonGravi());
  259.             this.isMessaggioErrore = validatoreErrori.isBustaErrore(this.busta,this.msg,pValidazioneErrori);
  260.             this.isMessaggioErroreIntestazione = validatoreErrori.isBustaErroreIntestazione(this.busta, this.msg,pValidazioneErrori);
  261.             this.isMessaggioErroreProcessamento = validatoreErrori.isBustaErroreProcessamento(this.busta, this.msg,pValidazioneErrori);
  262.                             
  263.             this.isBustaDiServizio = this.protocolFactory.createProtocolManager().isBustaServizio(this.busta);

  265.             if(this.isMessaggioErrore){
  266.                 addListaEccezioni(this.validatoreSintattico.getErroriTrovatiSullaListaEccezioni(),this.erroriValidazione);
  267.             }
  268.             else{
  269.                 addListaEccezioni(this.validatoreSintattico.getEccezioniValidazione(),this.erroriValidazione);
  270.             }
  271.             addListaEccezioni(this.validatoreSintattico.getEccezioniProcessamento(),this.erroriProcessamento);
  272.             this.erroreProcessamento_internalMessage = this.validatoreSintattico.getErroreProcessamento_internalMessage();
  273.             
  274.             // Se comunque e' arrivata un busta di servizio, che non possiede nemmeno uno delle seguenti cose:
  275.             // - lista eccezioni
  276.             // - lista riscontri
  277.             // Allora non si tratta di una busta di servizio bensi' di una busta malformata
  278.             if((this.isBustaDiServizio) && (this.busta.sizeListaEccezioni()<=0) && (this.busta.sizeListaRiscontri()<=0)){
  279.                 Eccezione ec = Eccezione.getEccezioneValidazione(ErroriCooperazione.SERVIZIO_SCONOSCIUTO.getErroreCooperazione(), this.protocolFactory);
  280.                 this.erroriValidazione.add(ec);
  281.                 this.isBustaDiServizio = false;
  282.             }
  283.             
  284.             // Costruzione IDMittente e IDServizio
  285.             if(this.busta.getTipoMittente()!=null && this.busta.getMittente()!=null){
  286.                 this.mittente = new IDSoggetto(this.busta.getTipoMittente(),this.busta.getMittente());
  287.                 this.mittente.setCodicePorta(this.busta.getIdentificativoPortaMittente());
  288.             }
  289.             if(this.isBustaDiServizio==false) {
  290.                 try {
  291.                     this.servizio = IDServizioFactory.getInstance().getIDServizioFromValues(this.busta.getTipoServizio(),this.busta.getServizio(), 
  292.                             this.busta.getTipoDestinatario(),this.busta.getDestinatario(),
  293.                             this.busta.getVersioneServizio());
  294.                 }catch(Exception e) {
  295.                     this.log.debug("Generazione IDServizio non possibile: "+ e.getMessage());
  296.                 }
  297.                 if(this.servizio!=null) {
  298.                     this.servizio.setAzione(this.busta.getAzione());
  299.                     if(this.servizio!=null && this.servizio.getSoggettoErogatore()!=null) {
  300.                         this.servizio.getSoggettoErogatore().setCodicePorta(this.busta.getIdentificativoPortaDestinatario());
  301.                     }
  302.                 }
  303.             }
  304.             
  305.             //  Se la lettura precedente ha riscontrato anomalie, ho gia' finito
  306.             if( ( (this.erroriValidazione!=null) && (this.erroriValidazione.size()>0) ) 
  307.                     || 
  308.                 ( (this.erroriProcessamento!=null) && (this.erroriProcessamento.size()>0) )
  309.                 )
  310.                 return true; // riscontrati errori durante la validazione sintattica.
  311.             
  312.             return true;
  313.             
  314.         }catch(Exception e){
  315.             this.log.error("validazioneSintattica",e);
  316.             this.eccezioneProcessamentoValidazioneSintattica = e;
  317.             this.errore = ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento("Errore di processamento: " +e.getMessage());
  318.             if(request){
  319.                 this.errore_integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  320.             }
  321.             else {
  322.                 this.errore_integrationFunctionError = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  323.             }
  324.             return false;
  325.         }   
  326.     }
  327.     private Exception eccezioneProcessamentoValidazioneSintattica = null;
  328.     public Exception getEccezioneProcessamentoValidazioneSintattica() {
  329.         return this.eccezioneProcessamentoValidazioneSintattica;
  330.     }


  333.     /**
  334.      * Avvia il processo di validazione.
  335.      * Vengono effettuati i seguenti passi:
  336.      * <ul>
  337.      * <li> Message-Security
  338.      * <li> Controllo eventuale SOAPFault di un messaggio Errore
  339.      * <li> Controllo eventuale di un manifest degli attachments
  340.      * <li> Controllo con schema xsd
  341.      * <li> Validazione Semantica
  342.      * </ul>
  343.      *
  344.      * @param messageSecurityContext MessageSecurityContext utilizzato per l'applicazione di un header di MessageSecurity
  345.      * @return true in caso di validazione effettuata (con o senza errori), false in caso di errori di processamento
  346.      * 
  347.      */
  348.     private boolean rilevatiErroriDuranteValidazioneSemantica = false;
  349.     public boolean isRilevatiErroriDuranteValidazioneSemantica() {
  350.         return this.rilevatiErroriDuranteValidazioneSemantica;
  351.     }
  352.     public boolean validazioneSemantica_beforeMessageSecurity(ServiceBinding serviceBinding, boolean rispostaConnectionReply,String profiloGestione, RequestInfo requestInfo) {
  353.         try{
  354.             this.rilevatiErroriDuranteValidazioneSemantica = true; // in fondo se arrivo corretto lo re-imposto a false
  355.             
  356.             if(this.validatoreSintattico == null){
  357.                 this.errore = ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento("Errore di processamento: Analisi sintattica richiesta e validatoreSintattico non risulta inizializzato");
  358.                 return false;
  359.             }
  360.         
  361.             // Tipo Busta (Servizio,Richiesta,Risposta,Ricevuta)
  362.             if(this.ruoloBustaRicevuta==null)
  363.                 this.ruoloBustaRicevuta = ValidazioneSemantica.getTipoBustaDaValidare(serviceBinding, this.busta, this.protocolFactory, rispostaConnectionReply,this.state,this.log);
  364.             //log.info("Validazione tipoBusta ["+tipoBusta+"]...");
  365.         
  366.             // Riconoscimento Profilo di Gestione per servizio erogato.
  367.             try{
  368.                 if(rispostaConnectionReply){
  369.                     this.versioneProtocollo = profiloGestione;
  370.                 }else{
  371.                     if(this.busta!=null && this.busta.getMittente()!=null && this.busta.getTipoMittente()!=null){
  372.                         this.versioneProtocollo = ValidazioneSemantica.riconoscimentoVersioneProtocolloServizioErogato(this.busta, this.protocolFactory.createTraduttore(), this.ruoloBustaRicevuta, this.state, requestInfo);
  373.                     }
  374.                     else{
  375.                         // caso di protocollo che non richiedono l'autenticazione del soggetto
  376.                         this.versioneProtocollo = profiloGestione;
  377.                     }
  378.                 }
  379.             }catch(Exception e){
  380.                 // L'eventuale errore, e' dovuto al non riconoscimento nel registro dei servizi del soggetto mittente o destinatario.
  381.                 // L'errore verra' riportato poi nel resto della validazione se il messaggio non era un messaggio Errore
  382.                 // Se invece era gia' stato marcato come messaggio Errore, molto probabilmente uno dei motivi era quello!
  383.                 this.log.error("Riconoscimento profilo di gestione non riuscito",e);
  384.             }


  387.             if(this.protocolFactory.createProtocolVersionManager(this.versioneProtocollo).isEccezioniLivelloInfoAbilitato()){
  388.                 // Eventuali eccezioni trovate in buste errore, di livello INFO, non marcano il msg come BustaErrore, rieffettuo il test
  389.                 if(this.isMessaggioErrore){
  390.                     IValidatoreErrori validatoreErrori = this.protocolFactory.createValidatoreErrori(this.state);
  391.                     ProprietaValidazioneErrori pValidazioneErrori = new ProprietaValidazioneErrori();
  392.                     pValidazioneErrori.setIgnoraEccezioniNonGravi(this.protocolManager.isIgnoraEccezioniNonGravi());
  393.                     pValidazioneErrori.setVersioneProtocollo(this.versioneProtocollo);
  394.                     this.isMessaggioErrore = validatoreErrori.isBustaErrore(this.busta,this.msg,pValidazioneErrori);
  395.                     this.isMessaggioErroreIntestazione = validatoreErrori.isBustaErroreIntestazione(this.busta, this.msg,pValidazioneErrori);
  396.                     this.isMessaggioErroreProcessamento = validatoreErrori.isBustaErroreProcessamento(this.busta, this.msg,pValidazioneErrori);
  397.                 }
  398.             }

  400.             // Se la lettura precedente (readBusta) ha riscontrato anomalie, ho gia' finito
  401.             boolean ignoraEccezioniLivelloNonGravi = this.protocolFactory.createProtocolVersionManager(this.versioneProtocollo).isIgnoraEccezioniLivelloNonGrave();
  402.             int sizeErroriValidazione = countErrori(ignoraEccezioniLivelloNonGravi, this.erroriValidazione);
  403.             int sizeErroriProcessamento = countErrori(ignoraEccezioniLivelloNonGravi, this.erroriProcessamento);                
  404.             if( sizeErroriValidazione>0 || sizeErroriProcessamento>0 )
  405.                 return true; // riscontrati errori durante la validazione sintattica.

  407.         }catch(Exception e){
  408.             this.log.error("validazioneSemantica (validazioneSemantica_beforeMessageSecurity)",e);
  409.             this.eccezioneProcessamentoValidazioneSemantica = e;
  410.             this.errore = ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione();
  411.             return false;
  412.         }

  414.         this.rilevatiErroriDuranteValidazioneSemantica = false;
  415.         return true;    
  416.     }
  417.     
  418.     public boolean validazioneSemantica_messageSecurity_readSecurityInfo(MessageSecurityContext messageSecurityContext) {
  419.         try{
  420.             this.rilevatiErroriDuranteValidazioneSemantica = true; // in fondo se arrivo corretto lo re-imposto a false
  421.                 
  422.             /** Leggo contesto sicurezza prima di processare la parte MessageSecurity */
  423.             IDigestReader digestReader = null;
  424.             if(messageSecurityContext != null) {
  425.                 digestReader = messageSecurityContext.getDigestReader(this.msg!=null ? this.msg.getFactory() : OpenSPCoop2MessageFactory.getDefaultMessageFactory());
  426.             }
  427.             if(messageSecurityContext!= null && digestReader!=null){
  428.                 this.securityInfo = this.protocolFactory.createValidazioneSemantica(this.state).readSecurityInformation(digestReader,
  429.                         this.msg);
  430.             }       

  432.         }catch(Exception e){
  433.             this.log.error("validazioneSemantica (validazioneSemantica_messageSecurity_readSecurityInfo)",e);
  434.             this.eccezioneProcessamentoValidazioneSemantica = e;
  435.             this.errore = ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione();
  436.             return false;
  437.         }

  439.         this.rilevatiErroriDuranteValidazioneSemantica = false;
  440.         return true;    
  441.     }
  442.     
  443.     public boolean validazioneSemantica_messageSecurity_process(MessageSecurityContext messageSecurityContext, StringBuilder errore, TempiElaborazione tempiElaborazione, boolean request) {
  444.         try{
  445.             this.rilevatiErroriDuranteValidazioneSemantica = true; // in fondo se arrivo corretto lo re-imposto a false
  446.                 

  448.             /** Applicazione Message-Security (eventualmente per decriptare il body applicativo: utile anche per il SoapFault del MessaggioErrore) */
  449.             if(messageSecurityContext!= null && messageSecurityContext.getIncomingProperties() != null && messageSecurityContext.getIncomingProperties().size() > 0){
  450.                 boolean existsHeaderMessageSecurity = messageSecurityContext.existsSecurityHeader(this.msg, messageSecurityContext.getActor());
  451.                 if(messageSecurityContext.processIncoming(this.msg,this.busta,this.context, tempiElaborazione) == false){  
  452.                     List<Eccezione> eccezioniSicurezza = new ArrayList<>();
  453.                     if(messageSecurityContext.getListaSubCodiceErrore()!=null && messageSecurityContext.getListaSubCodiceErrore().size()>0){
  454.                         List<SubErrorCodeSecurity> subCodiciErrore = messageSecurityContext.getListaSubCodiceErrore();
  455.                         for (Iterator<?> iterator = subCodiciErrore.iterator(); iterator.hasNext();) {
  456.                             SubErrorCodeSecurity subCodiceErrore = (SubErrorCodeSecurity) iterator.next();
  457.                             Eccezione ecc = new Eccezione(ErroriCooperazione.MESSAGE_SECURITY.getErroreMessageSecurity(subCodiceErrore.getMsgErrore(), messageSecurityContext.getCodiceErrore()),true,null, this.protocolFactory);
  458.                             ecc.setSubCodiceEccezione(subCodiceErrore);
  459.                             eccezioniSicurezza.add(ecc);
  460.                         }
  461.                     }else{
  462.                         Eccezione ecc = new Eccezione(ErroriCooperazione.MESSAGE_SECURITY.getErroreMessageSecurity(messageSecurityContext.getMsgErrore(),messageSecurityContext.getCodiceErrore()), true, null, this.protocolFactory);
  463.                         eccezioniSicurezza.add(ecc);
  464.                     }
  465.                     if(request) {
  466.                         this.errore_integrationFunctionError=IntegrationFunctionError.MESSAGE_SECURITY_REQUEST_FAILED;
  467.                     }
  468.                     else {
  469.                         this.errore_integrationFunctionError=IntegrationFunctionError.MESSAGE_SECURITY_RESPONSE_FAILED;
  470.                     }
  471.                     if(this.isMessaggioErrore){
  472.                         // NOTA: il message security header puo' non essere presente se l'altra porta di dominio, ha generato un messaggio Busta Errore.
  473.                         //       La porta di dominio riesce ad aggiungere l'header di sicurezza solo se riesce ad identificare la PortaApplicativa/Delegata,
  474.                         //       altrimenti genera un msg di Busta Errore chiaramente senza header di sicurezza.
  475.                         if(existsHeaderMessageSecurity){
  476.                             for (Iterator<?> iterator = eccezioniSicurezza.iterator(); iterator.hasNext();) {
  477.                                 Eccezione ecc = (Eccezione) iterator.next();
  478.                                 this.erroriValidazione.add(ecc);    
  479.                                 
  480.                                 if(errore.length()>0){
  481.                                     errore.append("\n");
  482.                                 }
  483.                                 errore.append(ecc.getDescrizione(this.protocolFactory));
  484.                             }
  485.                             return true; // riscontrati errori durante la validazione Message Security
  486.                         }
  487.                         else{
  488.                             StringBuilder bf = new StringBuilder();
  489.                             for (Iterator<?> iterator = eccezioniSicurezza.iterator(); iterator.hasNext();) {
  490.                                 Eccezione ecc = (Eccezione) iterator.next();
  491.                                 if(bf.length()>0){
  492.                                     bf.append(" ; ");
  493.                                 }
  494.                                 bf.append(ecc.toString(this.protocolFactory));
  495.                             }
  496.                             this.log.debug("MessageSecurityHeader not exists: "+bf.toString());
  497.                         }
  498.                     }else{
  499.                         for (Iterator<?> iterator = eccezioniSicurezza.iterator(); iterator.hasNext();) {
  500.                             Eccezione ecc = (Eccezione) iterator.next();
  501.                             this.erroriValidazione.add(ecc);
  502.                             
  503.                             if(errore.length()>0){
  504.                                 errore.append("\n");
  505.                             }
  506.                             errore.append(ecc.getDescrizione(this.protocolFactory));
  507.                         }
  508.                         return true; // riscontrati errori durante la validazione Message Security
  509.                     }
  510.                 }
  511.             }

  513.         }catch(Exception e){
  514.             
  515.             if(errore.length()>0){
  516.                 errore.append("\n");
  517.             }
  518.             errore.append(e.getMessage());
  519.             
  520.             this.log.error("validazioneSemantica (validazioneSemantica_messageSecurity_process)",e);
  521.             this.eccezioneProcessamentoValidazioneSemantica = e;
  522.             this.errore = ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione();
  523.             return false;
  524.         }

  526.         this.rilevatiErroriDuranteValidazioneSemantica = false;
  527.         return true;    
  528.     }
  529.     
  530.     public boolean validazioneSemantica_afterMessageSecurity(ProprietaManifestAttachments proprietaManifestAttachments,boolean validazioneIdentificativiCompleta, RequestInfo requestInfo) {
  531.         try{
  532.             this.rilevatiErroriDuranteValidazioneSemantica = true; // in fondo se arrivo corretto lo re-imposto a false

  534.             /** Se ho ricevuto un messaggio Busta Errore, devo controllare il SOAPFault ricevuto 
  535.              * Deve essere fatta dopo Message-Security per il Body (attachments manifest)
  536.              */
  537.             if(this.isMessaggioErrore){
  538.                 this.validatoreSintattico.validazioneFault(this.msg);
  539.                 addListaEccezioni(this.validatoreSintattico.getErroriTrovatiSullaListaEccezioni(),this.erroriValidazione);
  540.                 addListaEccezioni(this.validatoreSintattico.getEccezioniProcessamento(),this.erroriProcessamento);
  541.                 if( ( (this.erroriValidazione!=null) && (this.erroriValidazione.size()>0) ) 
  542.                         || 
  543.                     ( (this.erroriProcessamento!=null) && (this.erroriProcessamento.size()>0) )
  544.                     )
  545.                     return true; // riscontrati errori durante la validazione
  546.             }

  548.             // Controllo se il messaggio ha attachments
  549.             boolean hasAttachments = false;
  550.             if(ServiceBinding.SOAP.equals(this.msg.getServiceBinding())){
  551.                 hasAttachments = this.msg.castAsSoap().hasAttachments();
  552.             }
  553.             else if(MessageType.MIME_MULTIPART.equals(this.msg.getMessageType())){
  554.                 hasAttachments = true;
  555.             }
  556.             
  557.             /** Se ho ricevuto un messaggio con Attachments devo controllare il manifest
  558.              * Deve essere fatta dopo Message-Security per il Body (attachments manifest)
  559.              */
  560.             // Questa validazione non deve essere effettuata per messaggi Busta Errore
  561.             if(this.isMessaggioErrore==false){
  562.                 if(this.proprietaValidazione.isValidazioneManifestAttachments()){                   
  563.                     if(hasAttachments){
  564.                         this.validatoreSintattico.validazioneManifestAttachments(this.msg,proprietaManifestAttachments);
  565.                         addListaEccezioni(this.validatoreSintattico.getEccezioniValidazione(),this.erroriValidazione);
  566.                         addListaEccezioni(this.validatoreSintattico.getEccezioniProcessamento(),this.erroriProcessamento);
  567.                         if( ( (this.erroriValidazione!=null) && (this.erroriValidazione.size()>0) ) 
  568.                                 || 
  569.                             ( (this.erroriProcessamento!=null) && (this.erroriProcessamento.size()>0) )
  570.                             )
  571.                             return true; // riscontrati errori durante la validazione
  572.                     }
  573.                 }
  574.             }

  576.             /** Validazione semantica */
  577.             // Questa validazione non deve essere effettuata per messaggi Busta Errore
  578.             if(this.isMessaggioErrore==false){
  579.                 ValidazioneSemantica registryValidator = new ValidazioneSemantica(this.busta,this.context,this.state,validazioneIdentificativiCompleta,this.log, this.protocolFactory);
  580.                 registryValidator.valida(this.msg,this.proprietaValidazione,this.ruoloBustaRicevuta,this.versioneProtocollo, requestInfo);
  581.                 addListaEccezioni(registryValidator.getEccezioniValidazione(),this.erroriValidazione);
  582.                 addListaEccezioni(registryValidator.getEccezioniProcessamento(),this.erroriProcessamento);
  583.                 this.servizioCorrelato = registryValidator.getServizioCorrelato();
  584.                 this.tipoServizioCorrelato = registryValidator.getTipoServizioCorrelato();
  585.                 this.versioneServizioCorrelato = registryValidator.getVersioneServizioCorrelato();
  586.                 this.infoServizio = registryValidator.getInfoServizio();
  587.                 this.errore_integrationFunctionError = registryValidator.getErrore_integrationFunctionError();
  588.                 if( ( (this.erroriValidazione!=null) && (this.erroriValidazione.size()>0) ) 
  589.                         || 
  590.                     ( (this.erroriProcessamento!=null) && (this.erroriProcessamento.size()>0) )
  591.                     )
  592.                     return true; // riscontrati errori durante la validazione sul registro.
  593.             }

  595.             /** Validazione con SCHEMA (Opzionale): deve essere fatta dopo Message-Security per il Body (attachments manifest)*/
  596.             // Questa validazione deve essere effettuata anche per messaggi Busta Errore
  597.             if( this.proprietaValidazione.isValidazioneConSchema() ){
  598.                 ValidazioneConSchema schemaValidator = new ValidazioneConSchema(this.msg,
  599.                         this.isMessaggioErroreProcessamento, this.isMessaggioErroreIntestazione,
  600.                         this.proprietaValidazione.isValidazioneManifestAttachments(), this.log, this.protocolFactory,
  601.                         this.state);
  602.                 schemaValidator.valida(hasAttachments);
  603.                 addListaEccezioni(schemaValidator.getEccezioniValidazione(),this.erroriValidazione);
  604.                 addListaEccezioni(schemaValidator.getEccezioniProcessamento(),this.erroriProcessamento);
  605.                 if( ( (this.erroriValidazione!=null) && (this.erroriValidazione.size()>0) ) 
  606.                         || 
  607.                     ( (this.erroriProcessamento!=null) && (this.erroriProcessamento.size()>0) )
  608.                     )
  609.                     return true; // riscontrati errori durante la validazione
  610.             }


  613.         }catch(Exception e){
  614.             this.log.error("validazioneSemantica (validazioneSemantica_afterMessageSecurity)",e);
  615.             this.eccezioneProcessamentoValidazioneSemantica = e;
  616.             this.errore = ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione();
  617.             return false;
  618.         }

  620.         this.rilevatiErroriDuranteValidazioneSemantica = false;
  621.         return true;    
  622.     }
  623.     
  624.     private Exception eccezioneProcessamentoValidazioneSemantica = null;
  625.     public Exception getEccezioneProcessamentoValidazioneSemantica() {
  626.         return this.eccezioneProcessamentoValidazioneSemantica;
  627.     }

  629.     /**
  630.      * In caso di avvenuto errore durante il processo di validazione, 
  631.      * questo metodo ritorna l'errore.
  632.      *
  633.      * @return errore (se avvenuto).
  634.      * 
  635.      */
  636.     public ErroreCooperazione getErrore(){
  637.         return this.errore;
  638.     }
  639.     public IntegrationFunctionError getErrore_integrationFunctionError() {
  640.         return this.errore_integrationFunctionError;
  641.     }

  643.     /**
  644.      * Indicazione se la validazione della busta ha riscontrato eccezioni
  645.      *
  646.      * @return true in caso la validazione abbia riscontrato eccezioni.
  647.      * 
  648.      */
  649.     public boolean validazioneConEccezioni(){
  650.         if( ( (this.erroriValidazione!=null) && (this.erroriValidazione.size()>0) ) 
  651.                 || 
  652.             ( (this.erroriProcessamento!=null) && (this.erroriProcessamento.size()>0) )
  653.             )
  654.             return true;
  655.         else
  656.             return false;
  657.     }

  659.     /**
  660.      * Ritorna un List contenente eventuali eccezioni di validazione riscontrate nella busta.   
  661.      *
  662.      * @return Eccezioni riscontrate nella busta.
  663.      * 
  664.      */
  665.     public java.util.List<Eccezione> getEccezioniValidazione(){
  666.         if(this.erroriValidazione!=null)
  667.             return this.erroriValidazione;
  668.         else
  669.             return new java.util.ArrayList<Eccezione>();
  670.     }
  671.     /**
  672.      * Ritorna un List contenente eventuali eccezioni di processamento riscontrate nella busta.   
  673.      *
  674.      * @return Eccezioni riscontrate nella busta.
  675.      * 
  676.      */
  677.     public java.util.List<Eccezione> getEccezioniProcessamento(){
  678.         if(this.erroriProcessamento!=null)
  679.             return this.erroriProcessamento;
  680.         else
  681.             return new java.util.ArrayList<Eccezione>();
  682.     }
  683.     
  684.     public String getErroreProcessamento_internalMessage() {
  685.         return this.erroreProcessamento_internalMessage;
  686.     }

  688.     /**
  689.      * Indicazione se la busta processata e' un messaggio Errore.
  690.      *
  691.      * @return true se la busta e' un messaggio errore.
  692.      * 
  693.      */
  694.     public boolean isErroreProtocollo(){
  695.         return this.isMessaggioErrore;
  696.     }
  697.     public boolean isMessaggioErroreIntestazione() {
  698.         return this.isMessaggioErroreIntestazione;
  699.     }
  700.     public boolean isMessaggioErroreProcessamento() {
  701.         return this.isMessaggioErroreProcessamento;
  702.     }

  704.     /**
  705.      * Indicazione se la busta processata e' una busta di servizio
  706.      *
  707.      * @return true se la busta e' una busta di servizio
  708.      * 
  709.      */
  710.     public boolean isBustaDiServizio(){
  711.         return this.isBustaDiServizio;
  712.     }

  714.     /**
  715.      * Oggetto Busta contenente i valori della busta ricevuta.
  716.      *
  717.      * @return busta.
  718.      * 
  719.      */
  720.     public Busta getBusta(){
  721.         return this.busta;
  722.     }


  725.     /**
  726.      * Soggetto Mittente.
  727.      *
  728.      * @return soggetto Mittente.
  729.      * 
  730.      */
  731.     public IDSoggetto getSoggettoMittente(){
  732.         return this.mittente;
  733.     }

  735.     public void setMittente(IDSoggetto mittente) {
  736.         this.mittente = mittente;
  737.     }
  738.     
  739.     /**
  740.      * Identificativo del servizio presente nella busta.
  741.      *
  742.      * @return identificativo del servizio richiesto.
  743.      * 
  744.      */
  745.     public IDServizio getIDServizio(){
  746.         return this.servizio;
  747.     }

  749.     /**
  750.      * Eventuale servizio correlato associato al servizio presente nella busta.
  751.      *
  752.      * @return Eventuale servizio correlato associato al servizio presente nella busta.
  753.      * 
  754.      */
  755.     public String getServizioCorrelato() {
  756.         return this.servizioCorrelato;
  757.     }

  759.     /**
  760.      * Eventuale tipo di servizio correlato associato al servizio presente nella busta.
  761.      *
  762.      * @return Eventuale tipo di servizio correlato associato al servizio presente nella busta.
  763.      * 
  764.      */
  765.     public String getTipoServizioCorrelato() {
  766.         return this.tipoServizioCorrelato;
  767.     }
  768.     
  769.     public Integer getVersioneServizioCorrelato() {
  770.         return this.versioneServizioCorrelato;
  771.     }
  772.     
  773.     public Servizio getInfoServizio() {
  774.         return this.infoServizio;
  775.     }

  777.     public String getProfiloGestione() {
  778.         return this.versioneProtocollo;
  779.     }
  780.     public void setProfiloGestione(String profiloGestione) {
  781.         this.versioneProtocollo = profiloGestione;
  782.     }

  784.     public RuoloBusta getRuoloBustaRicevuta(ServiceBinding serviceBinding, boolean rispostaConnectionReply) throws ProtocolException {
  785.         if(this.ruoloBustaRicevuta==null)
  786.             this.ruoloBustaRicevuta= ValidazioneSemantica.getTipoBustaDaValidare(serviceBinding, this.busta, this.protocolFactory, rispostaConnectionReply,this.state,this.log);
  787.         return this.ruoloBustaRicevuta;
  788.     }

  790.     public void setProprietaValidazione(ProprietaValidazione proprietaValidazione) {
  791.         this.proprietaValidazione = proprietaValidazione;
  792.     }
  793.     
  794.     public BustaRawContent<?> getHeaderProtocollo() {
  795.         return this.validatoreSintattico.getProtocolHeader();
  796.     }
  797.     
  798.     public BustaRawContent<?> getHeaderProtocollo_senzaControlli() throws ProtocolException{
  799.         this.validatoreSintattico = new ValidazioneSintattica(this.context, this.state,this.msg,this.log, this.protocolFactory);
  800.         return this.validatoreSintattico.getHeaderProtocollo_senzaControlli();
  801.     }

  803.     private void addListaEccezioni(List<Eccezione> from,List<Eccezione> to){
  804.         if(from!=null){
  805.             to.addAll(from);
  806.         }
  807.     }
  808.     public SecurityInfo getSecurityInfo() {
  809.         return this.securityInfo;
  810.     }
  811.     
  812.     
  813.     private int countErrori(boolean ignoraEccezioniNonGravi,List<Eccezione> list){
  814.         int size = 0;
  815.         if(list!=null){
  816.             for (Eccezione eccezione : list) {
  817.                 if(eccezione.getRilevanza()!=null && ignoraEccezioniNonGravi){
  818.                     if(LivelloRilevanza.isEccezioneLivelloGrave(eccezione.getRilevanza())){
  819.                         size++;
  820.                     }
  821.                 }
  822.                 else{
  823.                     size++;
  824.                 }
  825.             }
  826.         }
  827.         return size;
  828.     }
  829.     
  830.     public void updateMsg(OpenSPCoop2Message msg) throws ProtocolException {
  831.         String msgClassName = msg.getClass().getName()+ "";
  832.         boolean update = !msgClassName.equals(this.msg.getClass().getName());
  833.         if(update){
  834.             this.msg = msg;
  835.             if(this.validatoreSintattico!=null){
  836.                 this.validatoreSintattico.updateMsg(msg);
  837.             }
  838.         }
  839.     }
  840. }





Created with JaCoCo 0.8.8.202204050719