MTOMProcessor.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.  */
  20. package org.openspcoop2.pdd.core;

  22. import org.slf4j.Logger;
  23. import org.openspcoop2.core.config.constants.MTOMProcessorType;
  24. import org.openspcoop2.core.constants.Costanti;
  25. import org.openspcoop2.core.constants.TipoPdD;
  26. import org.openspcoop2.message.OpenSPCoop2Message;
  27. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  28. import org.openspcoop2.message.constants.MessageRole;
  29. import org.openspcoop2.message.constants.ServiceBinding;
  30. import org.openspcoop2.pdd.config.MTOMProcessorConfig;
  31. import org.openspcoop2.pdd.config.MessageSecurityConfig;
  32. import org.openspcoop2.pdd.core.transazioni.Transaction;
  33. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  34. import org.openspcoop2.pdd.core.transazioni.TransactionNotExistsException;
  35. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  36. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  37. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;

  39. /**
  40.  * MTOMProcessor
  41.  *
  42.  * @author Andrea Poli (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  */
  46. public class MTOMProcessor {

  48.     private MTOMProcessorConfig config;
  49.     private MessageSecurityConfig secConfig;
  50.     private TipoPdD tipoPdD;
  51.     private MsgDiagnostico msgDiag;
  52.     private Logger log;
  53.     private PdDContext pddContext;
  54.     private Transaction transactionNullable;
  55.     
  56.     public MTOMProcessor(MTOMProcessorConfig config, MessageSecurityConfig secConfig, TipoPdD tipoPdD, 
  57.             MsgDiagnostico msgDiag, Logger log, PdDContext pddContext){
  58.         this.config = config;
  59.         this.secConfig = secConfig;
  60.         this.tipoPdD = tipoPdD;
  61.         this.msgDiag = msgDiag;
  62.         this.log = log;
  63.         this.pddContext = pddContext;
  64.         if(this.pddContext!=null && this.pddContext.containsKey(Costanti.ID_TRANSAZIONE)) {
  65.             String idTransazione = (String) this.pddContext.getObject(Costanti.ID_TRANSAZIONE);
  66.             try {
  67.                 this.transactionNullable = TransactionContext.getTransaction(idTransazione);
  68.             }catch(TransactionNotExistsException e) {
  69.                 // Puo' succedere nelle comunicazioni stateful
  70.             }
  71.         }
  72.     }
  73.     
  74.     
  75.     public MTOMProcessorType getMTOMProcessorType(){
  76.         if(this.config!=null)
  77.             return this.config.getMtomProcessorType();
  78.         else
  79.             return null;
  80.     }
  81.     
  82.     public void mtomBeforeSecurity(OpenSPCoop2Message msg,RuoloMessaggio tipo) throws Exception{
  83.         
  84.         if(msg==null) {
  85.             return;
  86.         }
  87.         if(!ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  88.             return;
  89.         }
  90.         
  91.         boolean emitDiagDisabled = false;
  92.         
  93.         if(this.isEngineEnabled()){
  94.             
  95.             if(this.isMTOMBeforeSecurity(tipo)){
  96.                 
  97.                 if(this.transactionNullable!=null) {
  98.                     switch (tipo) {
  99.                     case RICHIESTA:
  100.                         this.transactionNullable.getTempiElaborazione().startGestioneAttachmentsRichiesta();
  101.                         break;
  102.                     case RISPOSTA:
  103.                         this.transactionNullable.getTempiElaborazione().startGestioneAttachmentsRisposta();
  104.                         break;
  105.                     }
  106.                 }
  107.                 try {
  108.                 
  109.                     this.setProcessorTypeIntoDiagnostic(tipo);
  110.                     
  111.                     this.emitDiagnostic(tipo, 
  112.                             "mtom.processamentoRichiestaInCorso",
  113.                             "mtom.processamentoRispostaInCorso");
  114.                     
  115.                     try{
  116.                         
  117.                         this.mtomApply(msg.castAsSoap());
  118.                         
  119.                         this.emitDiagnostic(tipo, 
  120.                                 "mtom.processamentoRichiestaEffettuato",
  121.                                 "mtom.processamentoRispostaEffettuato");
  122.                         
  123.                     }catch(Exception e){
  124.                         
  125.                         if(MessageRole.REQUEST.equals(msg.getMessageRole())) {
  126.                             this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_ALLEGATI_MESSAGGIO_RICHIESTA, "true");
  127.                         }
  128.                         else {
  129.                             this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_ALLEGATI_MESSAGGIO_RISPOSTA, "true");
  130.                         }
  131.                         
  132.                         this.msgDiag.addKeywordErroreProcessamento(e);
  133.                         this.log.error("[MTOM BeforeSecurity "+tipo.getTipo()+"] "+e.getMessage(),e);
  134.                         
  135.                         this.emitDiagnostic(tipo, 
  136.                                 "mtom.processamentoRichiestaInErrore",
  137.                                 "mtom.processamentoRispostaInErrore");
  138.                         
  139.                         throw e;
  140.                     }
  141.                     
  142.                 }
  143.                 finally {
  144.                     if(this.transactionNullable!=null) {
  145.                         switch (tipo) {
  146.                         case RICHIESTA:
  147.                             this.transactionNullable.getTempiElaborazione().endGestioneAttachmentsRichiesta();
  148.                             break;
  149.                         case RISPOSTA:
  150.                             this.transactionNullable.getTempiElaborazione().endGestioneAttachmentsRisposta();
  151.                             break;
  152.                         }
  153.                     }   
  154.                 }
  155.                 
  156.             }
  157.             else{
  158.                 emitDiagDisabled = true;
  159.             }
  160.             
  161.         }
  162.         else{
  163.             emitDiagDisabled = true;
  164.         }
  165.         
  166.         if(emitDiagDisabled){
  167.             this.emitDiagnostic(tipo, 
  168.                     "mtom.beforeSecurity.processamentoRichiestaDisabilitato", 
  169.                     "mtom.beforeSecurity.processamentoRispostaDisabilitato");           
  170.         }
  171.         
  172.     }
  173.     
  174.     public void mtomAfterSecurity(OpenSPCoop2Message msg,RuoloMessaggio tipo) throws Exception{
  175.         
  176.         if(msg==null) {
  177.             return;
  178.         }
  179.         if(!ServiceBinding.SOAP.equals(msg.getServiceBinding())){
  180.             return;
  181.         }
  182.         
  183.         boolean emitDiagDisabled = false;
  184.         
  185.         if(this.isEngineEnabled()){
  186.             
  187.             if(this.isMTOMBeforeSecurity(tipo)==false){
  188.                 
  189.                 if(this.transactionNullable!=null) {
  190.                     switch (tipo) {
  191.                     case RICHIESTA:
  192.                         this.transactionNullable.getTempiElaborazione().startGestioneAttachmentsRichiesta();
  193.                         break;
  194.                     case RISPOSTA:
  195.                         this.transactionNullable.getTempiElaborazione().startGestioneAttachmentsRisposta();
  196.                         break;
  197.                     }
  198.                 }
  199.                 try {
  200.                     
  201.                     this.setProcessorTypeIntoDiagnostic(tipo);
  202.                     
  203.                     this.emitDiagnostic(tipo, 
  204.                             "mtom.processamentoRichiestaInCorso",
  205.                             "mtom.processamentoRispostaInCorso");
  206.                     
  207.                     try{
  208.                         
  209.                         this.mtomApply(msg.castAsSoap());
  210.                         
  211.                         this.emitDiagnostic(tipo, 
  212.                                 "mtom.processamentoRichiestaEffettuato",
  213.                                 "mtom.processamentoRispostaEffettuato");
  214.                         
  215.                     }catch(Exception e){
  216.                         
  217.                         this.msgDiag.addKeywordErroreProcessamento(e);
  218.                         this.log.error("[MTOM AfterSecurity "+tipo.getTipo()+"] "+e.getMessage(),e);
  219.                         
  220.                         this.emitDiagnostic(tipo, 
  221.                                 "mtom.processamentoRichiestaInErrore",
  222.                                 "mtom.processamentoRispostaInErrore");
  223.                         
  224.                         throw e;
  225.                     }
  226.                 
  227.                 }
  228.                 finally {
  229.                     if(this.transactionNullable!=null) {
  230.                         switch (tipo) {
  231.                         case RICHIESTA:
  232.                             this.transactionNullable.getTempiElaborazione().endGestioneAttachmentsRichiesta();
  233.                             break;
  234.                         case RISPOSTA:
  235.                             this.transactionNullable.getTempiElaborazione().endGestioneAttachmentsRisposta();
  236.                             break;
  237.                         }
  238.                     }   
  239.                 }
  240.             }
  241.             else{
  242.                 emitDiagDisabled = true;
  243.             }
  244.             
  245.         }
  246.         else{
  247.             emitDiagDisabled = true;
  248.         }
  249.         
  250.         if(emitDiagDisabled){
  251.             this.emitDiagnostic(tipo, 
  252.                     "mtom.afterSecurity.processamentoRichiestaDisabilitato", 
  253.                     "mtom.afterSecurity.processamentoRispostaDisabilitato");            
  254.         }
  255.         
  256.     }
  257.     
  258.     
  259.     /* **** UTILITIES INTERNE ***** */
  260.     
  261.     private void setProcessorTypeIntoDiagnostic(RuoloMessaggio tipo){
  262.         switch (tipo) {
  263.         case RICHIESTA:
  264.             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_PROCESSAMENTO_MTOM_RICHIESTA, this.config.getMtomProcessorType().getValue());
  265.             this.pddContext.addObject(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RICHIESTA, this.config.getMtomProcessorType().getValue());
  266.             break;
  267.         case RISPOSTA:
  268.             this.msgDiag.addKeyword(CostantiPdD.KEY_TIPO_PROCESSAMENTO_MTOM_RISPOSTA, this.config.getMtomProcessorType().getValue());
  269.             this.pddContext.addObject(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RISPOSTA, this.config.getMtomProcessorType().getValue());
  270.             break;
  271.         }   
  272.     }
  273.     
  274.     private void emitDiagnostic(RuoloMessaggio tipo, String idDiagnosticRichiesta, String idDiagnosticRisposta){
  275.         
  276.         // Il set del prefisso viene fatto poichè il processor viene usato anche in moduli (es. LocalForward) dove non è correttamente impostato
  277.         
  278.         String originalPrefix = this.msgDiag.getPrefixMsgPersonalizzati();
  279.         try{
  280.             switch (this.tipoPdD) {
  281.             case DELEGATA:
  282.                 this.msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_INOLTRO_BUSTE);
  283.                 break;
  284.             case APPLICATIVA:
  285.                 this.msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  286.                 break;
  287.             default:
  288.                 return; // nessun diagnostico
  289.             }
  290.             
  291.             switch (tipo) {
  292.             case RICHIESTA:
  293.                 this.msgDiag.logPersonalizzato(idDiagnosticRichiesta);
  294.                 break;
  295.             case RISPOSTA:
  296.                 this.msgDiag.logPersonalizzato(idDiagnosticRisposta);
  297.                 break;
  298.             }   
  299.         }finally{
  300.             this.msgDiag.setPrefixMsgPersonalizzati(originalPrefix);
  301.         }
  302.     }
  303.     
  304.     private void mtomApply(OpenSPCoop2SoapMessage msg) throws Exception{
  305.         switch (this.config.getMtomProcessorType()) {
  306.         case PACKAGING:
  307.             
  308.             if(this.config.getInfo()!=null && this.config.getInfo().size()>0){
  309.                 msg.mtomPackaging(this.config.getInfo());
  310.             }
  311.             
  312.             break;
  313.             
  314.         case UNPACKAGING:
  315.             
  316.             msg.mtomUnpackaging();
  317.             
  318.             break;
  319.             
  320.         case VERIFY:
  321.             
  322.             if(this.config.getInfo()!=null && this.config.getInfo().size()>0){
  323.                 msg.mtomVerify(this.config.getInfo());
  324.             }
  325.             
  326.             break;

  328.         default:
  329.             break;
  330.         }
  331.     }
  332.     
  333.     private boolean isMTOMBeforeSecurity(RuoloMessaggio tipoTraccia) throws Exception{
  334.         
  335.         MTOMProcessorType processorType = null;
  336.         if(this.config!=null && this.config.getMtomProcessorType()!=null){
  337.             processorType = this.config.getMtomProcessorType();
  338.         }
  339.         else{
  340.             processorType = MTOMProcessorType.DISABLE;
  341.         }
  342.         
  343.         // NOTA: per default la sicurezza viene sempre applicato prima del processo di packaging 
  344.         //      e dopo il processo di unpackaging trattando di fatto l'MTOM come un mero trasporto.
  345.         Boolean applyToMtom = null;
  346.         if(this.secConfig!=null && this.secConfig.getApplyToMtom()!=null){
  347.             applyToMtom = this.secConfig.getApplyToMtom();
  348.         }
  349.         
  350.         
  351.         switch (this.tipoPdD) {
  352.         
  353.         case DELEGATA:
  354.         
  355.             switch (tipoTraccia) {
  356.             
  357.             case RICHIESTA:
  358.                 
  359.                 switch (processorType) {
  360.                 
  361.                 case DISABLE:
  362.                     // caso che non puo' avvenire grazie al metodo isEngineEnabled
  363.                     throw new Exception("Caso non previsto ["+processorType+"] Delegata.richiesta.disabile");
  364.                     
  365.                 case PACKAGING:
  366.                     if(applyToMtom==null){
  367.                         return false; // (role:sender) primo cifro/firmo e poi applico packaging, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  368.                     }
  369.                     else if(applyToMtom){
  370.                         return true; // (role:sender) prima applico il packaging in modo da applicare la sicurezza sul messaggio mtom
  371.                     }else{
  372.                         return false; // (role:sender) prima cifro/firmo e poi applico packaging, in pratica mtom e' un mero trasporto
  373.                     }
  374.                     
  375.                 case UNPACKAGING:
  376.                     if(applyToMtom==null){
  377.                         return false; // (role:sender) primo cifro/firmo e poi applico packaging, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  378.                     }
  379.                     else if(applyToMtom){
  380.                         return false; // (role:sender) primo cifro/firmo e poi effettuo unpacking. Scenario senza senso !!!!
  381.                     }else{
  382.                         return true; // (role:sender) prima applico unpackaging poi cifro e firmo, in pratica mtom e' un mero trasporto (Sembra poco indicato al contesto della PdD)
  383.                     }
  384.                     
  385.                 case VERIFY: 
  386.                     return true; // (role:sender) prima verifico le references e poi applico la sicurezza (in modo da leggere eventuali elementi che saranno poi cifrati)

  388.                 default:
  389.                     throw new Exception("Caso non previsto Delegata.richiesta.["+processorType+"]");
  390.                 }
  391.                 
  392.             case RISPOSTA:
  393.                 
  394.                 switch (processorType) {
  395.                 
  396.                 case DISABLE:
  397.                     // caso che non puo' avvenire grazie al metodo isEngineEnabled
  398.                     throw new Exception("Caso non previsto ["+processorType+"] Delegata.risposta.disabile");
  399.                     
  400.                 case PACKAGING:
  401.                     if(applyToMtom==null){
  402.                         return true; // (role:receiver) prima applico il packaging e solo dopo verifico firma cifratura, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  403.                     }
  404.                     else if(applyToMtom){
  405.                         return true; // (role:receiver) prima applico il packaging e solo dopo verifico firma e cifratura
  406.                     }else{
  407.                         return false;  // (role:receiver) prima verifico firma cifratura, poi applico il packaging
  408.                     }
  409.                     
  410.                 case UNPACKAGING:
  411.                     if(applyToMtom==null){
  412.                         return true; // (role:receiver) primo applico l'unpackaging e solo dopo verifico firma cifratura, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  413.                     }
  414.                     else if(applyToMtom){
  415.                         return false; // (role:receiver) prima verifico firma cifratura, poi applico il l'unpackaging
  416.                     }else{
  417.                         return true; // (role:receiver) prima applico l'unpackaging e solo dopo verifico firma e cifratura
  418.                     }
  419.                     
  420.                 case VERIFY:
  421.                     return true; // (role:receiver) prima applico la sicurezza e solo dopo verifico (in modo da leggere eventuali elementi cifrati)

  423.                 default:
  424.                     throw new Exception("Caso non previsto Delegata.risposta.["+processorType+"]");
  425.                 }
  426.                     
  427.             default:
  428.                 throw new Exception("Tipo non gestito ["+tipoTraccia+"] in Delegata.risposta");
  429.             }
  430.             
  431.             
  432.         case APPLICATIVA:
  433.             
  434.             switch (tipoTraccia) {
  435.             
  436.             case RICHIESTA:
  437.                 
  438.                 switch (processorType) {
  439.                 
  440.                 case DISABLE:
  441.                     // caso che non puo' avvenire grazie al metodo isEngineEnabled
  442.                     throw new Exception("Caso non previsto ["+processorType+"] Applicativa.richiesta.disabile");
  443.                     
  444.                 case PACKAGING:
  445.                     if(applyToMtom==null){
  446.                         return true; // (role:receiver) prima applico il packaging e solo dopo verifico firma cifratura, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  447.                     }
  448.                     else if(applyToMtom){
  449.                         return true; // (role:receiver) prima applico il packaging e solo dopo verifico firma e cifratura
  450.                     }else{
  451.                         return false;  // (role:receiver) prima verifico firma cifratura, poi applico il packaging
  452.                     }
  453.                     
  454.                 case UNPACKAGING:
  455.                     if(applyToMtom==null){
  456.                         return true; // (role:receiver) primo applico l'unpackaging e solo dopo verifico firma cifratura, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  457.                     }
  458.                     else if(applyToMtom){
  459.                         return false; // (role:receiver) prima verifico firma cifratura, poi applico il l'unpackaging
  460.                     }else{
  461.                         return true; // (role:receiver) prima applico l'unpackaging e solo dopo verifico firma e cifratura
  462.                     }
  463.                     
  464.                 case VERIFY:
  465.                     return true; // (role:receiver) prima applico la sicurezza e solo dopo verifico (in modo da leggere eventuali elementi cifrati)

  467.                 default:
  468.                     throw new Exception("Caso non previsto Applicativa.richiesta.["+processorType+"]");
  469.                 }
  470.                 
  471.             case RISPOSTA:
  472.                 
  473.                 switch (processorType) {
  474.                 
  475.                 case DISABLE:
  476.                     // caso che non puo' avvenire grazie al metodo isEngineEnabled
  477.                     throw new Exception("Caso non previsto ["+processorType+"] Applicativa.risposta.disabile");
  478.                     
  479.                 case PACKAGING:
  480.                     if(applyToMtom==null){
  481.                         return false; // (role:sender) primo cifro/firmo e poi applico packaging, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  482.                     }
  483.                     else if(applyToMtom){
  484.                         return true; // (role:sender) prima applico il packaging in modo da applicare la sicurezza sul messaggio mtom
  485.                     }else{
  486.                         return false; // (role:sender) prima cifro/firmo e poi applico packaging, in pratica mtom e' un mero trasporto
  487.                     }
  488.                     
  489.                 case UNPACKAGING:
  490.                     if(applyToMtom==null){
  491.                         return false; // (role:sender) primo cifro/firmo e poi applico packaging, in pratica mtom e' un mero trasporto (come se venisse chiamato sul connettore)
  492.                     }
  493.                     else if(applyToMtom){
  494.                         return false; // (role:sender) primo cifro/firmo e poi effettuo unpacking. Scenario senza senso !!!!
  495.                     }else{
  496.                         return true; // (role:sender) prima applico unpackaging poi cifro e firmo, in pratica mtom e' un mero trasporto (Sembra poco indicato al contesto della PdD)
  497.                     }
  498.                     
  499.                 case VERIFY: 
  500.                     return true; // (role:sender) prima verifico le references e poi applico la sicurezza (in modo da leggere eventuali elementi che saranno poi cifrati)

  502.                 default:
  503.                     throw new Exception("Caso non previsto Applicativa.risposta.["+processorType+"]");
  504.                 }
  505.                     
  506.             default:
  507.                 throw new Exception("Tipo non gestito ["+tipoTraccia+"] in Applicativa.risposta");
  508.             }
  509.             
  510.         case INTEGRATION_MANAGER:
  511.         case ROUTER:
  512.         default:
  513.                 throw new Exception("Ruolo ["+this.tipoPdD+"] non gestito");
  514.             
  515.         }
  516.         
  517.         
  518.     }
  519.     
  520.     private boolean isEngineEnabled(){
  521.         if(!TipoPdD.DELEGATA.equals(this.tipoPdD) && !TipoPdD.APPLICATIVA.equals(this.tipoPdD)){
  522.             return false;
  523.         }
  524.         if(this.config!=null && this.config.getMtomProcessorType()!=null && !MTOMProcessorType.DISABLE.equals(this.config.getMtomProcessorType())){
  525.             return true;
  526.         }
  527.         return false;
  528.     }
  529. }
Created with JaCoCo 0.8.8.202204050719