SPCoopSbustamento.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.protocol.spcoop.builder;

  23. import java.io.ByteArrayInputStream;
  24. import java.io.ByteArrayOutputStream;
  25. import java.io.InputStream;
  26. import java.io.SequenceInputStream;
  27. import java.util.ArrayList;
  28. import java.util.Collections;
  29. import java.util.List;

  31. import javax.xml.soap.AttachmentPart;
  32. import javax.xml.soap.MimeHeaders;
  33. import javax.xml.soap.SOAPBody;
  34. import javax.xml.soap.SOAPElement;
  35. import javax.xml.soap.SOAPHeader;
  36. import javax.xml.soap.SOAPHeaderElement;

  38. import org.openspcoop2.message.OpenSPCoop2Message;
  39. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  40. import org.openspcoop2.message.constants.MessageType;
  41. import org.openspcoop2.message.soap.DumpSoapMessageUtils;
  42. import org.openspcoop2.message.soap.SoapUtils;
  43. import org.openspcoop2.message.xml.MessageXMLUtils;
  44. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  45. import org.openspcoop2.protocol.sdk.ProtocolException;
  46. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  47. import org.openspcoop2.protocol.sdk.state.IState;
  48. import org.openspcoop2.protocol.spcoop.SPCoopBustaRawContent;
  49. import org.openspcoop2.protocol.spcoop.config.SPCoopProperties;
  50. import org.openspcoop2.protocol.spcoop.constants.SPCoopCostanti;
  51. import org.openspcoop2.protocol.spcoop.validator.SPCoopValidazioneSintattica;
  52. import org.openspcoop2.utils.UtilsMultiException;
  53. import org.slf4j.Logger;
  54. import org.w3c.dom.Document;
  55. import org.w3c.dom.Element;
  56. import org.w3c.dom.NodeList;
  57. import org.w3c.dom.Text;

  59. /**
  60.  * Classe utilizzata per Sbustare un SOAPEnvelope dell'header eGov.
  61.  *
  62.  *
  63.  * @author Poli Andrea (apoli@link.it)
  64.  * @author $Author$
  65.  * @version $Rev$, $Date$
  66.  */

  68. public class SPCoopSbustamento {

  70.     private Logger log;
  71.     private IProtocolFactory<?> protocolFactory;
  72.     private SPCoopValidazioneSintattica validazioneSintattica = null;
  73.     private SPCoopProperties spcoopProperties = null;
  74.     private IState state;
  75.     
  76.     public SPCoopSbustamento(IProtocolFactory<?> protocolFactory,IState state) throws ProtocolException{
  77.         this.protocolFactory = protocolFactory;
  78.         this.log = protocolFactory.getLogger();
  79.         this.spcoopProperties = SPCoopProperties.getInstance(this.log);
  80.         
  81.         this.state = state;
  82.         
  83.         this.validazioneSintattica = (SPCoopValidazioneSintattica) this.protocolFactory.createValidazioneSintattica(this.state);
  84.         
  85.     }
  86.     
  87.     /**
  88.      * Effettua lo sbustamento eGov
  89.      *  
  90.      * @param msg Messaggio in cui deve essere estratto un header eGov.
  91.      * 
  92.      */
  93.     public SOAPHeaderElement sbustamentoEGov(OpenSPCoop2Message msg,ProprietaManifestAttachments proprietaManifestAttachments) throws ProtocolException{    

  95.         SOAPHeader headerSOAP = null;
  96.         SOAPHeaderElement header = null;
  97.         try{

  99.             OpenSPCoop2SoapMessage soapMsg = msg.castAsSoap();
  100.             
  101.             // Estraggo header
  102.             this.validazioneSintattica.setMsg(soapMsg);
  103.             this.validazioneSintattica.setReadQualifiedAttribute(proprietaManifestAttachments.isReadQualifiedAttribute());
  104.             headerSOAP = soapMsg.getSOAPHeader();
  105.             SPCoopBustaRawContent bustaElement = this.validazioneSintattica.getHeaderEGov(msg.getFactory(), headerSOAP);
  106.             if(bustaElement == null){
  107.                 throw new Exception ("Header eGov non presente");
  108.             }
  109.             header = bustaElement.getElement();
  110.             if(header == null){
  111.                 throw new Exception ("Header eGov non presente");
  112.             }

  114.             soapMsg.removeHeaderElement(headerSOAP, header);
  115.             
  116.             // Remove Manifest
  117.             if(proprietaManifestAttachments.isGestioneManifest() && soapMsg.countAttachments()>0){
  118.                 this.remove_eGovManifest(msg,proprietaManifestAttachments);
  119.             }

  121.             return header;
  122.             
  123.         }catch(Exception e){    
  124.             this.log.error("SbustamentoEGov non riuscito: "+e.getMessage(),e);
  125.             throw new ProtocolException("SbustamentoEGov non riuscito: "+e.getMessage(),e);     
  126.         }
  127.         finally{
  128.             // *** GB ***
  129.             if(this.validazioneSintattica!=null){
  130.                 this.validazioneSintattica.setHeaderSOAP(null);
  131.             }
  132.             headerSOAP = null;
  133.             header = null;
  134.             // *** GB ***
  135.         }
  136.     }


  139.     public OpenSPCoop2Message remove_eGovManifest(OpenSPCoop2Message msgParam,ProprietaManifestAttachments proprietaManifestAttachments) throws ProtocolException{ 
  140.         try{
  141.             OpenSPCoop2SoapMessage msg = msgParam.castAsSoap();
  142.             
  143.             MessageXMLUtils xmlUtils = MessageXMLUtils.getInstance(msg.getFactory());
  144.             
  145.             SOAPBody body = msg.getSOAPBody();
  146.             
  147.             // dopo la modifica del commit '185e2d7ba1db561d769128aadbee493103963ac9' per la validazione dei contenuti si ottiene l'errore: class org.apache.xerces.dom.ElementNSImpl cannot be cast to class javax.xml.soap.SOAPElement
  148.             // uso metodo getFirstSOAPElement in cui รจ stato ripristinato il vecchio codice
  149.             /**Element e = msg.getFirstChildElement(body);*/
  150.             /**System.out.println("CLASSE ["+e.getClass().getName()+"] ["+msg.getAsString(e, false)+"]");*/
  151.             Element e = SoapUtils.getFirstSOAPElement(body); 
  152.             
  153.             SOAPElement descrizione = (SOAPElement) e;
  154.             java.util.Iterator<?> it = descrizione.getChildElements();
  155.             String idMsg = null;
  156.             while(it.hasNext()){
  157.                 Object element = it.next();
  158.                 if(!(element instanceof SOAPElement)){
  159.                     continue;
  160.                 }
  161.                 SOAPElement descrizioneMessaggio = (SOAPElement) element;
  162.                 
  163.                 // uguale a sopra il motivo
  164.                 /**SOAPElement riferimento = (SOAPElement)msg.getFirstChildElement(descrizioneMessaggio);*/
  165.                 SOAPElement riferimento = SoapUtils.getFirstSOAPElement(descrizioneMessaggio); 
  166.                 
  167.                 if(riferimento.getAttribute("role").equalsIgnoreCase(this.spcoopProperties.getRoleRichiestaManifest())){
  168.                     idMsg = riferimento.getAttribute("href");
  169.                     break;
  170.                 }else if(riferimento.getAttribute("role").equalsIgnoreCase(this.spcoopProperties.getRoleRispostaManifest())){
  171.                     idMsg = riferimento.getAttribute("href");
  172.                     break;
  173.                 }       
  174.             }
  175.             if(idMsg==null){
  176.                 throw new Exception("DescrizioneMessaggio con ruolo "+this.spcoopProperties.getRoleRichiestaManifest()
  177.                         +" o "+this.spcoopProperties.getRoleRispostaManifest()+" non trovato.");
  178.             }
  179.             
  180.             if(idMsg.startsWith("cid:"))
  181.                 idMsg = idMsg.substring("cid:".length());
  182.             MimeHeaders mhs = new MimeHeaders();
  183.             mhs.addHeader("Content-ID", idMsg);
  184.             AttachmentPart ap = (AttachmentPart) msg.getAttachments(mhs).next();
  185.             msg.removeAttachments(mhs);
  186.             

  188.             // Leggo body originale presente nell'attachment
  189.             java.io.InputStream inputDH = getInputStream(msg, ap);
  190.             
  191.             // Ripristino body Originale
  192.             msg.getSOAPBody().removeContents();
  193.             
  194.             // Check eventuale <?xml instruction
  195.             byte[]bytePotenzialiXML = new byte[5]; // <?xml
  196.             int readByte = inputDH.read(bytePotenzialiXML);
  197.             boolean xmlContentPresente = false;
  198.             if( (readByte==5) && 
  199.                 (((char)bytePotenzialiXML[0])=='<') && 
  200.                 (((char)bytePotenzialiXML[1])=='?') &&
  201.                 (((char)bytePotenzialiXML[2])=='x') &&
  202.                 (((char)bytePotenzialiXML[3])=='m') &&
  203.                 (((char)bytePotenzialiXML[4])=='l') ){
  204.                 readByte = inputDH.read();
  205.                 while( (((char)readByte)!='>') && (readByte!=-1)  ){
  206.                     readByte = inputDH.read();
  207.                 }
  208.                 if(((char)readByte)=='>'){
  209.                     xmlContentPresente = true;
  210.                 }
  211.             }
  212.             
  213.             // Se il body allegato e' vuoto mi fermo.
  214.             // Parsare uno stream vuoto da errore con AXIOM.
  215.             if(readByte == -1) return msg;
  216.             
  217.             // Costruzione isBody
  218.             InputStream isBody = null;
  219.             if(xmlContentPresente == false){
  220.                 //isBody = dh.getInputStream();
  221.                 isBody = getInputStream(msg, ap);
  222.             }else{
  223.                 isBody = inputDH;
  224.             }
  225.             
  226.             // Puo' darsi che siano piu' elementi nello stream senza un unico rootelement.
  227.             // Questo fa arrabbiare il parser.
  228.             // Aggiungo un WrapperElement per farmi costruire l'elemento e poi ne cerco i figli.
  229.             
  230.             List<InputStream> iss = new ArrayList<InputStream>();
  231.             iss.add(new ByteArrayInputStream("<OpenSPCoopWrapper>".getBytes()));
  232.             iss.add(isBody);
  233.             iss.add(new ByteArrayInputStream("</OpenSPCoopWrapper>".getBytes()));
  234.             InputStream is = new SequenceInputStream(Collections.enumeration(iss));
  235.                 
  236.             Document doc = xmlUtils.newDocument(is);
  237.             NodeList nl = doc.getDocumentElement().getChildNodes();
  238.             for(int i = 0; i < nl.getLength(); i++) {
  239.                 org.w3c.dom.Node n = nl.item(i);
  240.                 if(n instanceof Element) {
  241.                     Element element = (Element) n;
  242.                     if(SPCoopCostanti.LOCAL_NAME_MANIFEST_EGOV_EMPTY_BODY.equals(element.getLocalName()) && 
  243.                             SPCoopCostanti.NAMESPACE_MANIFEST_EGOV_EMPTY_BODY.equals(element.getNamespaceURI())){
  244.                         // Body Empty
  245.                         //System.out.println("SBUSTAMENTO EMPTY PATCH");
  246.                         continue;
  247.                     }
  248.                     msg.getSOAPBody().addChildElement(SoapUtils.getSoapFactory(msg.getFactory(), MessageType.SOAP_11).createElement(element));
  249.                 }
  250.                 if(n instanceof Text) {
  251.                     msg.getSOAPBody().addTextNode(n.getTextContent());
  252.                 }

  254.             }
  255.             
  256.             return msg;
  257.             
  258.         } catch(Exception e) {
  259.             this.log.error("Rimozione Manifest degli Attachments non riuscita: "+e.getMessage(),e);
  260.             throw new ProtocolException("Rimozione Manifest degli Attachments non riuscita: "+e.getMessage(),e);        
  261.         }   
  262.     }
  263.     
  264.     private InputStream getInputStream(OpenSPCoop2SoapMessage msg, AttachmentPart ap) throws Exception {
  265.         java.io.InputStream inputDH = null;
  266.         try {
  267.             // Provo con codiceOriginale ma in jboss non funziona sempre
  268.             javax.activation.DataHandler dh = ap.getDataHandler();
  269.             inputDH = dh.getInputStream();
  270.         }catch(Exception e) {
  271.             try {
  272.                 inputDH = new ByteArrayInputStream(DumpSoapMessageUtils.dumpAttachmentAsByteArray(msg, ap));
  273.             }catch(Exception eInternal) {
  274.                 throw new UtilsMultiException(e, eInternal);
  275.             }
  276.         }
  277.         return inputDH;
  278.     }
  279.     
  280.     /**
  281.      * Metodo che si occupa di eliminare dal SOAPHeader, passato col parametro <var>header</var>
  282.      * l'header eGov.
  283.      *
  284.      * @param header bytes del SOAPHeader, contenente la busta eGov da estrarre.
  285.      * @return bytes del SOAPHeader, in cui e' stato estratto l'header eGov.
  286.      * 
  287.      */
  288.     @Deprecated public byte[] removeSPCoop(byte [] header) throws ProtocolException{

  290.         ByteArrayOutputStream reqByteSbustata = null;
  291.         try{
  292.             String headerSTR = new String(header);

  294.             // Ricerco header EGov
  295.             int endIntestazione = 0;
  296.             int start = 0;
  297.             while(true){
  298.                 int indexOfEGov = headerSTR.indexOf(SPCoopCostanti.ACTOR_EGOV,start);
  299.                 if(indexOfEGov == -1)
  300.                     break;
  301.                 StringBuilder rovesciata = new StringBuilder();
  302.                 for(int i = indexOfEGov-1; i>0 ; i-- ){
  303.                     rovesciata.append(((char)header[i]));
  304.                     if( ((char)header[i]) == '<' ){
  305.                         start = i;
  306.                         break;
  307.                     }
  308.                 }
  309.                 StringBuilder rigaCompleta = new StringBuilder();
  310.                 rovesciata.reverse();
  311.                 rigaCompleta.append(rovesciata.toString());
  312.                 rigaCompleta.append(SPCoopCostanti.ACTOR_EGOV);
  313.                 for(int i = (indexOfEGov+SPCoopCostanti.ACTOR_EGOV.length()); i<header.length ; i++ ){
  314.                     rigaCompleta.append(((char)header[i]));
  315.                     if( ((char)header[i]) == '>' ){
  316.                         break;
  317.                     }
  318.                 }
  319.                 if(rigaCompleta.toString().indexOf("Intestazione") != -1){
  320.                     endIntestazione = start -1 + rigaCompleta.length();
  321.                     break;
  322.                 }else{
  323.                     start = start -1 + rigaCompleta.length();
  324.                 }
  325.             }


  328.             // Elimino Header
  329.             if(start == 0){
  330.                 return null;
  331.             }
  332.             int end =  headerSTR.indexOf("Intestazione>",endIntestazione) + "Intestazione>".length();
  333.             if(end == -1){
  334.                 return null;
  335.             }
  336.             if(end <= start){
  337.                 return null;
  338.             }
  339.             reqByteSbustata = new ByteArrayOutputStream();
  340.             for(int i=0; i<start ; i++)
  341.                 reqByteSbustata.write(header[i]);
  342.             boolean eraserSpaziDopoEGov = false;
  343.             for(int i=end; i<header.length ; i++){
  344.                 if( (eraserSpaziDopoEGov==false) && ((char)header[i]=='<' )  ){
  345.                     eraserSpaziDopoEGov=true;
  346.                     reqByteSbustata.write(header[i]);
  347.                 }else if (eraserSpaziDopoEGov)
  348.                     reqByteSbustata.write(header[i]);
  349.             }

  351.             byte[] bustaSenzaEGov = reqByteSbustata.toByteArray();
  352.             reqByteSbustata.close();
  353.             return bustaSenzaEGov;

  355.         } catch(Exception e) {
  356.             try{
  357.                 if(reqByteSbustata!=null)
  358.                     reqByteSbustata.close();
  359.             }catch(Exception eis){
  360.                 // close
  361.             }
  362.             this.log.error("RimozioneHeaderSPCoop non riuscita: "+e.getMessage(),e);
  363.             throw new ProtocolException("RimozioneHeaderSPCoop non riuscita: "+e.getMessage(),e);       
  364.         }   
  365.     }

  367.     public IProtocolFactory<?> getProtocolFactory() {
  368.         return this.protocolFactory;
  369.     }

  371.     public SOAPHeaderElement sbustamento(OpenSPCoop2Message msg,
  372.             ProprietaManifestAttachments proprietaManifestAttachments)
  373.             throws ProtocolException {
  374.         return this.sbustamentoEGov(msg, proprietaManifestAttachments);
  375.     }

  377. }




Created with JaCoCo 0.8.8.202204050719