Re: [OpenSPCoop-Dev] AGGIORNAMENTO: corretti bug su WSSReceiver emodificata interfaccia autorizzazione

[Andrea Poli <apoli@link.it>]

Montebove Luciano wrote:
> Rispetto alla versione di ieri sera:
>
> 1)Ho corretto un bug su WSSReceiver che non estraeva correttamente
> Servizio ed Azione da passare al modulo di autorizzazione
> 2)modificata l'interfaccia di autorizzazione aggiungendo
> l'identificativo parte del mittente (parametro mittente
> dell'interfaccia):
> public boolean authorize(String principal, String mittente,String
> servizio, String azione) throws Exception;
> 3)Aggiunta scrittura a console dei parametri ricevuti nelle classi di
> autorizzazione demo.
>
> Ciao
>
> Luciano
>   
> ------------------------------------------------------------------------
>
> _______________________________________________
> Sviluppatori mailing list
> Sviluppatori@openspcoop.org
> http://www.openspcoop.org/mailman/listinfo/sviluppatori
>   
Ciao Luciano,
        scusami per la tardiva risposta.
Ho provato le classi e funzionano perfettamente. Ho effettuato qualche 
modifica :

1) Aggiunto metodi e variabili 'codiceErrore' e 'msgError' che indicano 
il motivo di un eventuale errore che si verifica all'interno del metodo 
process().
Questo metodo ritorna false in caso avvengano degli errori. Come puoi 
notare ho utilizzato dei codici di errore prestabiliti dalla specifica 
SPCoop (definiti in Costanti.java), in particolar modo ne esiste uno 
specifico per il mittente non autorizzato.

2) Al WSSReceiver, ho passato l'oggetto Busta che contiene i valori di 
una busta ricevuta dalla porta di dominio, e quindi anche il servizio, 
l'azione ed il mittente.
Puoi usare questo oggetto senza dover navigare l'header SOAP.


Ti allego i file WSS modificati e le due classi base dove vengono 
utilizzate.
La pubblicazione sul cvs la faro' tra qualche giorno, nel frattempo 
fammi sapere cosa ne pensi.

Andrea.
/*
 * Copyright 2005 Link.it srl, http://link.it.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


package org.openspcoop.wssecurity;

import java.io.File;
import java.io.FileWriter;

import java.text.SimpleDateFormat;

import java.util.Date;
import java.util.Hashtable;
import java.util.Vector;

import javax.xml.namespace.QName;
import javax.xml.soap.Text;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import javax.xml.soap.SOAPElement;
import org.apache.axis.AxisFault;
import org.apache.axis.Message;
import org.apache.axis.MessageContext;
import org.apache.axis.message.SOAPBody;
import org.apache.axis.message.SOAPEnvelope;


import org.apache.axis.message.SOAPHeader;
import org.apache.axis.message.SOAPHeaderElement;
import org.apache.axis.utils.XMLUtils;
import org.apache.ws.axis.security.WSDoAllReceiver;
import org.apache.ws.security.WSConstants;
import org.apache.ws.security.WSSecurityEngineResult;
import org.apache.ws.security.handler.WSHandlerConstants;
import org.apache.ws.security.handler.WSHandlerResult;

import org.openspcoop.egov.Busta;
import org.openspcoop.egov.Costanti;


/**
 * Classe per la gestione della WS-Security (WSDoAllReceiver).
 *
 * @author Spadafora Marcello <Ma.Spadafora@finsiel.it>
 * @author Montebove Luciano <L.Montebove@finsiel.it>
 * @version 0.6, 20/04/06
 */
public class WSSReceiver {

    /** Eventuale messaggio di errore avvenuto durante il processo di 
validazione */
    private String msgErrore;
    /** Eventuale codice di errore avvenuto durante il processo di validazione  
*/
    private String codiceErrore;
    /** Contiene il message Context */
    private WSSBaseUtils baseUtilsWSS;

    public WSSReceiver(Hashtable wssProperties, WSSBaseUtils baseWSS) {
        baseUtilsWSS = baseWSS;
        baseUtilsWSS.setMessageContext(wssProperties);
    }

    
    public boolean process(Message axisMessage,Busta busta) {
        try{
            SimpleDateFormat dt;
            dt = new SimpleDateFormat("yy-MM-dd HH-mm-ss SSS");
            if (baseUtilsWSS.getMessageContext() != null) {
                baseUtilsWSS.getMessageContext().setCurrentMessage(axisMessage);
                WSDoAllReceiver recever = new WSDoAllReceiver();
                String authClass = null;
                authClass = 
(String)baseUtilsWSS.getMessageContext().getProperty("authorizationClass");
                String actor = null;
                actor = 
(String)baseUtilsWSS.getMessageContext().getProperty(WSHandlerConstants.ACTOR);
                if (actor != null)
                    recever.setOption(WSHandlerConstants.ACTOR, actor);
                SOAPEnvelope envelope = null;
                /*
                  envelope = axisMessage.getSOAPEnvelope();
                  FileWriter out;
                  try {
                  out = new FileWriter(new File("c:/" + dt.format(new Date()) +
                  " beforeReceiver" + ".xml"));
                  out.write(envelope.getAsString());
                  out.close();
                  } catch (Exception e) {
                  e.printStackTrace();
                  }
                */
                recever.invoke(baseUtilsWSS.getMessageContext());
                
                envelope = axisMessage.getSOAPEnvelope();
                if (authClass != null) {
                    if (!authorize(envelope, authClass, actor , busta)) {
                        this.msgErrore =  "Mittente della busta non autorizzato 
ad invocare il servizio ["+busta.getServizio()+"]";
                        this.codiceErrore = Costanti.MittenteNonAutorizzato;
                        return false;
                    }
                }
                clean(envelope,actor);
                
                /*
                  out = new FileWriter(new File("c:/" + dt.format(new Date()) +
                  " afterReceiver" + ".xml"));
                  XMLUtils.PrettyElementToWriter(envelope.getAsDOM(), out);
                  out.close();
                */

                axisMessage.saveChanges();
            }
        }catch (AxisFault af) {
            this.msgErrore =  "Generatosi errore durante il processamento 
WS-Security(Sender) [code: "
                +af.getFaultCode()+"]\n"+af.getFaultString();
            this.codiceErrore = Costanti.ErrorePoliticaSicurezzaServizio;
            return false;
        } catch (Exception e) {
            this.msgErrore =  "Generatosi errore durante il processamento 
WS-Security(Sender)";
            this.codiceErrore = Costanti.ErrorePoliticaSicurezzaServizio;
            return false;
        }
        
        return true;
    }

    /**
     * In caso di avvenuto errore durante il processo di validazione, 
     * questo metodo ritorna il motivo dell'errore.
     *
     * @return motivo dell'errore (se avvenuto).
     * @since 0.6
     */
    public String getMsgErrore(){
        return this.msgErrore;
    }

    /**
     * In caso di avvenuto errore, questo metodo ritorna il codice dell'errore.
     *
     * @return codice dell'errore (se avvenuto).
     * @since 0.6
     */
    public String getCodiceErrore(){
        return this.codiceErrore;
    }


    public boolean authorize(SOAPEnvelope envelope, String authClass,String 
actor,Busta busta) throws AxisFault {
        boolean status=false;
        try {
            SOAPHeader header = (SOAPHeader)envelope.getHeader();
            String principal=getPrincipal(actor);
            Class cl = Class.forName(authClass);
            Authorization auth = (Authorization)cl.newInstance();
            status = 
auth.authorize(principal,busta.getMittente(),busta.getServizio(),busta.getAzione());
            return status;
        }
        catch (Exception e) {
            e.printStackTrace();
            throw new AxisFault("Errore di Processamento: " + e.getMessage());
        }
    }

    public void clean(SOAPEnvelope envelope, String actor) throws AxisFault {
        try {
            //elimina header WSS per specifico attore se indicato od in generale
            SOAPHeader header = (SOAPHeader)envelope.getHeader();
            if (actor == null) {
                SOAPHeaderElement element = 
                    (SOAPHeaderElement)header.getChildElement(new 
QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";,
 
                                                                        
"Security"));
                element.detachNode();
            } else {
                header.extractHeaderElements(actor);
            }
            header = (SOAPHeader)envelope.getHeader();
            SOAPHeaderElement element = null;
            element = 
                (SOAPHeaderElement)header.getChildElement(new 
QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";,
 
                                                                    
"Security"));
            if (element == null) {
                SOAPBody body = (SOAPBody)envelope.getBody();
                
body.removeAttributeNS("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";,
 
                                       "Id");
                
body.removeNamespaceDeclaration("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new AxisFault("Errore di Processamento: " + e.getMessage());
        }
    }


    public String getPrincipal(String actor) {
        MessageContext msgContext = baseUtilsWSS.getMessageContext();
        String principal = null;
        Vector results = 
            (Vector)msgContext.getProperty(WSHandlerConstants.RECV_RESULTS);
        //System.out.println("Potential number of usernames: " + 
results.size());
        for (int i = 0; results != null && i < results.size(); i++) {
            WSHandlerResult hResult = (WSHandlerResult)results.get(i);
            if (actor != null) {
                //prendo solo i risultati dell'actor in config.xml
                if (hResult.getActor().compareTo(actor) == 0) {
                    Vector hResults = hResult.getResults();
                    for (int j = 0; j < hResults.size(); j++) {
                        WSSecurityEngineResult eResult = 
                            (WSSecurityEngineResult)hResults.get(j);
                        // An encryption or timestamp action does not have an 
associated principal,
                        // only Signature and UsernameToken actions return a 
principal
                        if ((eResult.getAction() == WSConstants.SIGN) || 
                            (eResult.getAction() == WSConstants.UT)) {
                            principal = eResult.getPrincipal().getName();
                            // Signature and UsernameToken actions return a 
principal
                            //System.out.println("Principal's name: " + 
principal);
                        }
                    }
                }
            } else {
                Vector hResults = hResult.getResults();
                for (int j = 0; j < hResults.size(); j++) {
                    WSSecurityEngineResult eResult = 
                        (WSSecurityEngineResult)hResults.get(j);
                    // An encryption or timestamp action does not have an 
associated principal,
                    // only Signature and UsernameToken actions return a 
principal
                    if ((eResult.getAction() == WSConstants.SIGN) || 
                        (eResult.getAction() == WSConstants.UT)) {
                        principal = eResult.getPrincipal().getName();
                        // Signature and UsernameToken actions return a 
principal
                        //System.out.println("Principal's name: " + principal);
                    }
                }
            }
        }
        return principal;
    }

}

/*
 * Copyright 2005 Link.it srl, http://link.it.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.openspcoop.wssecurity;

import java.util.Hashtable;
import org.apache.axis.AxisFault;
import org.apache.axis.Message;
import org.apache.ws.axis.security.WSDoAllSender;

import org.openspcoop.egov.Costanti;

/**
 * Classe per la gestione della WS-Security (WSDoAllSender).
 *
 * @author Spadafora Marcello <Ma.Spadafora@finsiel.it>
 * @version 0.6, 20/04/06
 */

public class WSSSender {

    /** Eventuale messaggio di errore avvenuto durante il processo di 
validazione */
    private String msgErrore;
    /** Eventuale codice di errore avvenuto durante il processo di validazione  
*/
    private String codiceErrore;
    /** Contiene il message Context */
    private WSSBaseUtils baseUtilsWSS;

    public WSSSender(Hashtable wssProperties,WSSBaseUtils baseWSS) {
        baseUtilsWSS = baseWSS;
        baseUtilsWSS.setMessageContext(wssProperties);  
    }

    public boolean process(Message axisMessage) {
        try{
            if (baseUtilsWSS.getMessageContext() != null) {
                baseUtilsWSS.getMessageContext().setCurrentMessage(axisMessage);
                WSDoAllSender sender = new WSDoAllSender();
                sender.invoke(baseUtilsWSS.getMessageContext());
            }
        }catch (AxisFault af) {
            this.msgErrore =  "Generatosi errore durante il processamento 
WS-Security(Sender) [code: "
                +af.getFaultCode()+"]\n"+af.getFaultString();
            this.codiceErrore = Costanti.ErrorePoliticaSicurezzaServizio;
            return false;
        } catch (Exception e) {
            this.msgErrore =  "Generatosi errore durante il processamento 
WS-Security(Sender)";
            this.codiceErrore = Costanti.ErrorePoliticaSicurezzaServizio;
            return false;
        }
        
        return true;
    }

    /**
     * In caso di avvenuto errore durante il processo di validazione, 
     * questo metodo ritorna il motivo dell'errore.
     *
     * @return motivo dell'errore (se avvenuto).
     * @since 0.6
     */
    public String getMsgErrore(){
        return this.msgErrore;
    }

    /**
     * In caso di avvenuto errore, questo metodo ritorna il codice dell'errore.
     *
     * @return codice dell'errore (se avvenuto).
     * @since 0.6
     */
    public String getCodiceErrore(){
        return this.codiceErrore;
    }
}

/*
 * Copyright 2005 Link.it srl, http://link.it.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.openspcoop.pdd.mdb;

import javax.ejb.MessageDrivenBean;
import javax.ejb.MessageDrivenContext;
import javax.ejb.EJBException;

import java.sql.Timestamp;
import javax.jms.JMSException;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.Queue;
import javax.jms.Message;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.QueueConnection;
import javax.jms.MessageListener;

import java.io.IOException;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

import java.util.Date;

import java.net.HttpURLConnection;
import java.net.URLConnection;
import java.net.URL;

import javax.xml.soap.AttachmentPart;
import javax.xml.soap.SOAPMessage;
import javax.xml.soap.SOAPBody;
import javax.xml.soap.SOAPHeaderElement;
import javax.xml.soap.SOAPHeader;
import javax.xml.soap.SOAPEnvelope;
import javax.xml.soap.SOAPFault;

import javax.xml.transform.stream.StreamSource;

import java.sql.SQLException;

import org.w3c.dom.Element;

import org.apache.axis.AxisFault; 

import org.openspcoop.utils.SoapUtils;
import org.openspcoop.utils.AttachmentsUtils;
import org.openspcoop.egov.XMLUtils;
import org.openspcoop.egov.Busta;
import org.openspcoop.egov.History;
import org.openspcoop.egov.RollbackEGov;
import org.openspcoop.egov.Eccezione;
import org.openspcoop.egov.IDServizio;
import org.openspcoop.egov.IDSoggetto;
import org.openspcoop.egov.Costanti;
import org.openspcoop.egov.ConnectorProperties;
import org.openspcoop.egov.ValidatoreSPCoop;
import org.openspcoop.registry.QueryEGovImpl;
import org.openspcoop.pdd.output.MsgDiagnostico;
import org.openspcoop.pdd.config.ConfigReaderImpl;
import org.openspcoop.pdd.config.DBManager;
import org.openspcoop.pdd.config.QueueManager;
import org.openspcoop.pdd.config.OpenSPCoopProperties;
import org.openspcoop.pdd.config.ClassNameProperties;
import org.openspcoop.pdd.config.RichiestaDelegata;
import org.openspcoop.pdd.utils.Connettore;
import org.openspcoop.pdd.utils.ConnettoreHTTP;
import org.openspcoop.pdd.utils.ConnettoreMsg;
import org.openspcoop.pdd.utils.PdDUtils;
import org.openspcoop.wssecurity.WSSBaseUtils;
import org.openspcoop.wssecurity.WSSSender;
import org.openspcoop.wssecurity.WSSReceiver;


/**
 * Contiene la definizione di un Message Driven Bean 'InoltroBuste_eGov', il 
quale e' un
 * modulo dell'infrastruttura OpenSPCoop.
 * <p>
 * Inoltre la classe contiene due MessageFactory per la costruzione di un 
oggetto {@link InoltroBuste_eGov_Message}
 * utilizzato per la spedizione di messaggi JMS al mdb, tramita una coda JMS 
utilizzata in ricezione.
 *
 *
 * @author Poli Andrea (apoli@link.it)
 * @version 0.6, 11/04/06
 */

public class InoltroBuste_eGov implements MessageDrivenBean, MessageListener {

 

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

    /** Variabile che indica il Nome del modulo dell'architettura di OpenSPCoop 
rappresentato da questa classe */
    public final static String idModulo = "InoltroBuste_eGov";

    
    /* ********  F I E L D S  P R I V A T I   ******** */
 
    /** Message Driven Context */
    private MessageDrivenContext ctxMDB;
    /** Properties Reader */
    private OpenSPCoopProperties propertiesReader;



    /* ********  M E T O D I   ******** */

    /**
     * Imposta il Contesto del Message Driven Bean.
     * Metodo necessario per l'implementazione dell'interfaccia 
<code>MessageDrivenBean</code>.
     *
     * @param mdc Contesto del Message Driven Bean.
     * @since 0.2
     */
    public void setMessageDrivenContext(MessageDrivenContext mdc) throws 
EJBException { 
        ctxMDB = mdc;
    }
    
 

    /**
     * Metodo necessario per l'implementazione dell'interfaccia 
<code>MessageDrivenBean</code>.
     *
     * @since 0.2
     */
    public void ejbCreate() {
        propertiesReader = new OpenSPCoopProperties();
    }


  
    /**
     * Metodo necessario per l'implementazione dell'interfaccia 
<code>MessageDrivenBean</code>.
     * @since 0.2
     */
    public void ejbRemove() {}
    


    /**
     * Attivato,  quando viene ricevuto sulla coda associata al mdb (coda 
RequestOUT_eGov)
     * un messaggio JMS. Questo metodo implementa la logica del modulo 
InoltroBuste_eGov
     * dell'infrastruttura OpenSPCoop.
     * @since 0.2
     */
    public void onMessage(Message message) {
        if(message instanceof ObjectMessage) {

            /* ------------ Controllo inizializzazione config e registro 
-------------------- */
            if( (ConfigReaderImpl.isInitialize() == false) ||
                (QueryEGovImpl.isInitialize() == false) ){
                ctxMDB.setRollbackOnly();
                return;
            }



                    

           

            

 
     

            
            /* ------------  Lettura parametri della richiesta  ------------- */
            
            // Logger dei messaggi diagnostici
            MsgDiagnostico msgDiag = new MsgDiagnostico(idModulo);

            msgDiag.highDebug("Ricezione richiesta 
(InoltroBuste_eGov_Message)");       
            ObjectMessage received = (ObjectMessage)message;
            InoltroBuste_eGov_Message request = null;
            try{
                request = (InoltroBuste_eGov_Message)received.getObject();
            }   catch(javax.jms.JMSException e){ 
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
ricezione dell'oggetto InoltroBuste_eGov_Message : \n\n"+e.toString());
                return; 
            }   
            
            // ID per Sessioni sulle code JMS
            long idJMS = 0;
            try{
                idJMS = received.getLongProperty("ID");
            }   catch(javax.jms.JMSException e){ 
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la lettura 
dell'header 'ID' del messaggio JMS : \n\n"+e.toString());
                return;
            }
            
            // RichiestaDelegata
            RichiestaDelegata idPD = request.getIDPortaDelegata();

            // IDServizio
            IDServizio idService = request.getIDServizio();

            // Identificatore del Soggetto Fruitore
            IDSoggetto soggettoSPCoop = idPD.getSoggetto();
            String dominio = soggettoSPCoop.getCodicePorta();
            msgDiag.setDominioSPCoop(dominio); // imposto il dominio del 
richiedente

            // Identificatore del servizio applicativo
            String servizioApplicativo = idPD.getServizioApplicativo();

            // Informazioni per la gestione della busta da inviare
            String profiloDiCollaborazione = 
request.getInfoBusta().getProfiloDiCollaborazione();
            String id_eGov = request.getInfoBusta().getID_eGov();
            Date scadenza = request.getInfoBusta().getScadenza();
            boolean eliminaMessaggio = 
request.getInfoBusta().getEliminaMessaggio();
            byte [] headerEGov = request.getInfoBusta().getHeaderEGov();

            // ID associato al messaggio di richiesta salvato su fileSystem/DB
            String idMessaggioRichiesta = idJMS + "_" + id_eGov;

            //  Identificatore della coda del modulo OpenSPCoop che ha gestito 
la richiesta, e su cui sta aspettando la risposta
            String queueForResponse = request.getQueueForResponse();

            // ConnectorProperties ...
            ConnectorProperties connettore = 
QueryEGovImpl.getConnettore(idService);

         
            

           
           










        
            /* ------------------ Inizializzazione Risorse utilizzate Prima 
della spedizione  --------------- */

            // Get Connessione al DB
            java.sql.Connection connectionDB = 
DBManager.getOscpDBConnection(dominio,idModulo);
            if(connectionDB == null){
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
richiesta di una connessione al DB.");   
                ctxMDB.setRollbackOnly();
                return;
            }

            // Get Connection Queue
            Queue queueRisposteEGov = 
QueueManager.getQueue(dominio,idModulo,"queue/toSbustamentoRisposte");
            Queue queueRisposteSOAP = null;
            if( queueForResponse !=null ) 
                queueRisposteSOAP = 
QueueManager.getQueue(dominio,idModulo,queueForResponse);
            QueueConnection connectionQueue = 
QueueManager.getQueueConnection(dominio,idModulo);
            if(  (queueRisposteEGov == null) || (connectionQueue == null)  ){   
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
creazione della connessione (o delle code) al broker JMS.");
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);       
                ctxMDB.setRollbackOnly();
                return;
            }           
            QueueSession qs = 
QueueManager.getQueueTransactionSession(dominio,idModulo,connectionQueue);
            if( qs == null ){   
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
creazione della sessione della connessione al broker JMS.");
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);       
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                ctxMDB.setRollbackOnly();
                return;
            }
            QueueSender senderToAccettazioneRichiesteInterne = null;
            try {
                if( queueRisposteSOAP != null )
                    senderToAccettazioneRichiesteInterne = 
qs.createSender(queueRisposteSOAP);
            } catch (javax.jms.JMSException e) {        
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
creazione della sessione (o dei sender) JMS : \n\n"+e.toString());
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                ctxMDB.setRollbackOnly();
                return;
            }












            // Punto di inizio per la transazione.
            try{




                /* ------------  Controllo Scadenza Busta  ------------- */
                if(scadenza != null){

                    Timestamp now = new Timestamp(System.currentTimeMillis());
                    if (scadenza.before(now)) {
                        // Busta scaduta
                        msgDiag.errorOpenSPCoop("Riscontrato errore durante 
l'inoltro della busta: Busta SPCoop Scaduta.");
                        if(  
profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono) ){
                            byte [] error = 
                                
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                                
  "Server.BustaScaduta",
                                                                                
  PdDUtils.erroreProcessamento,
                                                                                
  Costanti.EccezioneProcessamento);
                            
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,dominio,
                                                    
idModulo,senderToAccettazioneRichiesteInterne,qs);
                        }
                        
RollbackEGov.rollbackPD_All(id_eGov,connectionDB,propertiesReader.getWorkingDirectory());
                        
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,connectionDB,
                                                    
connectionQueue,qs,ctxMDB,idJMS,dominio,idModulo,
                                                    
propertiesReader.getWorkingDirectory());
                        return;
                    }
                }
                
                

                
                







        





                

                /* ------------  Ricostruzione Messaggio Soap da spedire 
------------- */

                msgDiag.highDebug("Ricostruzione SOAPEnvelope di richiesta");
                // Il messaggio viene solo letto dal DB. Sara' eliminato una 
volta usato sicuramente (fine della transazione)
                org.apache.axis.Message requestSOAP = 
                    
SoapUtils.readMessage_appendEGov(idMessaggioRichiesta,propertiesReader.getWorkingDirectory(),connectionDB,headerEGov,false);

                if(requestSOAP == null){
                    msgDiag.errorOpenSPCoop("Riscontrato errore durante la 
ricostruzione del messaggio Soap da Spedire.");
                    if(  
profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono) ){
                        byte [] error = 
                            
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                              
"Server.ReadingRequestMessageError",
                                                                              
PdDUtils.erroreProcessamento,
                                                                              
Costanti.EccezioneProcessamento);
                        
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,dominio,
                                                         
idModulo,senderToAccettazioneRichiesteInterne,qs);
                    }
                    
RollbackEGov.rollbackPD_All(id_eGov,connectionDB,propertiesReader.getWorkingDirectory());
                    
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,connectionDB,
                                                
connectionQueue,qs,ctxMDB,idJMS,dominio,idModulo,
                                                
propertiesReader.getWorkingDirectory());
                    return;
                }       
                
                
                
            







                /* ------------  Gestione WS-Security ------------- */
                // ottiene le proprieta' WS-Security relative alla porta 
delegata (WSS del sender)
                java.util.Hashtable wssPropertiesRequest= 
ConfigReaderImpl.getPD_WSSForSender(idPD);    
                WSSBaseUtils baseWSS = null;
                if(wssPropertiesRequest!=null){
                    if(wssPropertiesRequest.size() > 0){
                        // Imposto un context di Base (utilizzato per la 
successiva spedizione)
                        baseWSS = new WSSBaseUtils();
                        WSSSender wssSender = new 
WSSSender(wssPropertiesRequest,baseWSS);
                        if(wssSender.process(requestSOAP) == false){
                            msgDiag.errorOpenSPCoop("Riscontrato errore durante 
la costruzione dell'header WSS sul messaggio Soap da Spedire: "
                                                    +wssSender.getMsgErrore());
                            if(  
profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono) ){
                                Eccezione ecc = new Eccezione();
                                
ecc.setContestoCodifica(Costanti.Eccezione_ContestoCodifica);
                                
ecc.setCodiceEccezione(wssSender.getCodiceErrore());
                                ecc.setRilevanza(Costanti.GRAVE);
                                ecc.setPosizione(wssSender.getMsgErrore());
                                byte [] error = 
                                        
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,ecc);
                                
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,dominio,
                                                                 
idModulo,senderToAccettazioneRichiesteInterne,qs);
                                
RollbackEGov.rollbackPD_ProfiloSincronoRicezione(id_eGov,connectionDB);
                                
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                            
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,
                                                            
idModulo,propertiesReader.getWorkingDirectory());
                            }else{
                                if(eliminaMessaggio){
                                    // Se non e' indicato di eliminare il 
messaggio, in caso di errori,
                                    // non deve essere fatto poiche' sara' 
riutilizzato dal Thread che re-invia la busta
                                    // NON SERVE ROLLBACK (RISCONTRI NON 
SALVATI!!)
                                    
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                                
connectionDB,connectionQueue,qs,ctxMDB,idJMS,
                                                                dominio,
                                                                
idModulo,propertiesReader.getWorkingDirectory());
                                }
                            }
                            return;
                        }
                    }
                }
                
        









                




                /* ------------------- 
                   Rilascio Risorse (Le riprendero' dopo aver ottenuto la 
risposta, se necessario) 
                   Le informazioni nel DB sono state utilizzate fino a questo 
punto solo in lettura.
                   Eventuali spedizioni JMS sono state effettuate e le risorse 
gia' rilasciate (non arrivero a questo punto)
                   -----------------------*/
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);














                /* ------------------- Spedizione Messaggio Soap 
-----------------------*/
            
                String tipoConnector = connettore.getTipoConnettore();
                ConnettoreMsg connettoreMsg = new 
ConnettoreMsg(tipoConnector,requestSOAP,connettore.getConnectorProperties());
                org.apache.axis.Message responseSOAP = null;
                boolean errorConsegna = false;
                String motivoErroreConsegna = null;
                Connettore connectorSender = null;;
                boolean invokerNonSupportato = false;

                // Ricerco connettore nel className.properties
                ClassNameProperties prop = new ClassNameProperties();
                String connectorClass = prop.getConnettore(tipoConnector);
                if(connectorClass == null){
                    msgDiag.errorOpenSPCoop("Riscontrato errore durante il 
caricamento del connettore: connettore non registrato.");
                    invokerNonSupportato = true;
                }
                
                // Carico connettore richiesto
                if(invokerNonSupportato==false){
                    try{
                        Class c = Class.forName(connectorClass);
                        connectorSender = (Connettore) c.newInstance();
                    }catch(ClassNotFoundException e){
                        msgDiag.errorOpenSPCoop("Riscontrato errore durante il 
caricamento del connettore specificato: "+e.toString());
                        invokerNonSupportato = true;
                    }
                    if( (invokerNonSupportato == false) && (connectorSender == 
null)){
                        msgDiag.errorOpenSPCoop("Riscontrato errore durante il 
caricamento del connettore specificato.");
                        invokerNonSupportato = true;
                    }
                }

                // Utilizzo Connettore
                if(invokerNonSupportato==false){
                    errorConsegna = !(connectorSender.send(connettoreMsg));
                    if(errorConsegna){
                        motivoErroreConsegna = connectorSender.getError();
                    }else{
                        responseSOAP = connectorSender.getResponse();
                    }
                }


                
        
                



















                /* ------------------ Inizializzazione Risorse utilizzate Dopo 
la spedizione  --------------- */
                
                String resourceError = null;
                // Get Connessione al DB
                connectionDB = DBManager.getOscpDBConnection(dominio,idModulo);
                if(connectionDB == null){
                    resourceError = "Riscontrato errore durante la richiesta di 
una connessione al DB.";                            
                }

                // Get Connection Queue
                if(resourceError==null){
                    connectionQueue = 
QueueManager.getQueueConnection(dominio,idModulo);
                    if( connectionQueue == null  ){
                        resourceError = "Riscontrato errore durante la 
creazione della connessione al broker JMS.";
                        
                    }           
                }
                if(resourceError==null){
                    qs = 
QueueManager.getQueueTransactionSession(dominio,idModulo,connectionQueue);
                    if( qs == null ){
                        resourceError = "Riscontrato errore durante la 
creazione della sessione della connessione al broker JMS.";
                    }
                }
                QueueSender senderRisposteToSbustamento = null;
                if(resourceError==null){
                    try {
                        senderRisposteToSbustamento = 
qs.createSender(queueRisposteEGov);
                        if( queueRisposteSOAP != null )
                            senderToAccettazioneRichiesteInterne = 
qs.createSender(queueRisposteSOAP);
                    } catch (javax.jms.JMSException e) {
                        resourceError = "Riscontrato errore durante la 
creazione della sessione (o dei sender) JMS : \n\n"+e.toString();               
 
                    }
                }
                if( resourceError != null ){
                    msgDiag.fatalOpenSPCoop("Riscontrato errore durante 
l'ottenimento delle risorse necessarie per gestire la risposta: "
                                            +resourceError);
                    if(  
profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono) ){
                        byte [] error = 
                            
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                              
"Server.ResourceError",
                                                                              
PdDUtils.erroreProcessamento,
                                                                              
Costanti.EccezioneProcessamento);
                        
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,dominio,
                                                         
idModulo,senderToAccettazioneRichiesteInterne,qs);
                        
RollbackEGov.rollbackPD_ProfiloSincronoRicezione(id_eGov,connectionDB);
                        
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                    
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,
                                                    
idModulo,propertiesReader.getWorkingDirectory());
                    }else{
                        
MDBUtils.releaseResourceMDBWithError(connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,idModulo);
 
                    }
                    return;
                }
                
                













                /* ------------------------- Gestione Errori Consegna 
---------------------------- */
                // Invoker Non Supportato
                if(invokerNonSupportato == true){
                    if(  
profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono) ){
                        byte [] error = 
                            
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                              
"Server.InvokerNonSupportato",
                                                                              
PdDUtils.erroreProcessamento,
                                                                              
Costanti.EccezioneProcessamento);
                        
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,
                                                         dominio,idModulo,
                                                         
senderToAccettazioneRichiesteInterne,qs);
                    } 
                    
RollbackEGov.rollbackPD_All(id_eGov,connectionDB,propertiesReader.getWorkingDirectory());
                    
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,connectionDB,
                                                
connectionQueue,qs,ctxMDB,idJMS,dominio,
                                                
idModulo,propertiesReader.getWorkingDirectory());
                    return;
                }
                
                // Errori avvenuti durante la consegna
                if(errorConsegna){
                    msgDiag.errorOpenSPCoop("Riscontrato errore durante la 
spedizione della busta con identificativo ["+id_eGov+
                                            "] inviato alla parte destinataria 
["+idService.getSoggetto().getNome()+"] mediante connector["+
                                            tipoConnector+"]: 
"+motivoErroreConsegna);
                    if(  
profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono) ){
                        byte [] error = 
                            
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                              
"Server.SendHTTPRequestError",
                                                                              
PdDUtils.erroreProcessamento,
                                                                              
Costanti.EccezioneProcessamento);
                        // TO DO 
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,dominio,idModulo,senderToAccettazioneRichiesteInterne,qs);
                        
RollbackEGov.rollbackPD_ProfiloSincronoRicezione(id_eGov,connectionDB);
                        
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                    
connectionDB,connectionQueue,qs,ctxMDB,idJMS,
                                                    
dominio,idModulo,propertiesReader.getWorkingDirectory());
                    }else{
                        
MDBUtils.releaseResourceMDBWithError(connectionDB,connectionQueue,qs,ctxMDB,
                                                             
idJMS,dominio,idModulo); 
                    }
                    return;
                }else{ 
                    msgDiag.infoSPCoop("Messaggio SPCoop con identificativo 
["+id_eGov+"] inviato alla parte destinataria ["+
                                       idService.getSoggetto().getNome()+"] 
mediante Connector["+tipoConnector+"].");
                }
                
            
            



























                /* ---------------- Gestione Risposta  (operazioni comuni per 
tutti i profili) ------------------- */ 
                SOAPFault fault = null;
                boolean presenzaRispostaSPCoop = false;
                ValidatoreSPCoop validator = null;
                boolean isMessaggioSPCoopErrore = false;
                String idEGovRisposta = null;
                java.util.Vector<Eccezione> errors = null;
                SbustamentoRisposte_Message sbustamentoRisposteMSG = null;
                if(responseSOAP != null ){
                    
                    // potenziale Fault
                    if(responseSOAP.getSOAPBody().hasFault()){
                        fault = responseSOAP.getSOAPBody().getFault();
                    }
                    
                    // Validazione potenziale busta
                    validator = new 
ValidatoreSPCoop(responseSOAP,ConfigReaderImpl.isLivelloValidazioneRigido());
                    presenzaRispostaSPCoop  = validator.valida();
                }
                if(presenzaRispostaSPCoop){

                    // Gestione Specifica per Buste SPCoop
                    Busta busta_eGov = validator.getBusta();
                    errors = validator.getEccezioni();
                    idEGovRisposta = busta_eGov.getID();
                    isMessaggioSPCoopErrore = validator.isSPCoopErrore();
                    
                    // WS-Security
                    if( errors.size() == 0 ){
                        java.util.Hashtable wssPropertiesResponse = 
ConfigReaderImpl.getPD_WSSForReceiver(idPD);                    
                        if(wssPropertiesResponse!=null){
                            if(wssPropertiesResponse.size() > 0){
                                WSSReceiver wssReceiver = new 
WSSReceiver(wssPropertiesResponse,baseWSS);
                                if(wssReceiver.process(responseSOAP,busta_eGov) 
== false){   
                                    Eccezione ecc = new Eccezione();
                                    
ecc.setContestoCodifica(Costanti.Eccezione_ContestoCodifica);
                                    
ecc.setCodiceEccezione(wssReceiver.getCodiceErrore());
                                    ecc.setRilevanza(Costanti.GRAVE);
                                    
ecc.setPosizione(wssReceiver.getMsgErrore());
                                    errors.add(ecc);
                                }
                            }   
                        }
                    }
                    
                    // Validazione Attachments!
                    if( errors.size() == 0 ){
                        ;// TODO
                    }

                    // Estrazione header busta SPCoop
                    // Prelevo l'headerElement dall'header
                    //if( erroreProcessamentoBustaSPCoop==null ){
                    // if( 
org.openspcoop.egov.Sbustamento.prelevaHeaderEGov(headerRisposta) == false  ){
                    //  erroreProcessamentoBustaSPCoop="Generatosi errore 
durante l'estrazione dell'header SPCoop";
                    //}
                    //}
                                    
                    // Costruzione oggetto da spedire al modulo 
'SbustamentoRisposte'
                    sbustamentoRisposteMSG = SbustamentoRisposte.createBean();
                    sbustamentoRisposteMSG.setRichiestaDelegata(idPD);
                    sbustamentoRisposteMSG.setIDServizio(idService);
                    sbustamentoRisposteMSG.setBusta(busta_eGov);
                    sbustamentoRisposteMSG.setErrors(errors);
                    
sbustamentoRisposteMSG.setIsSPCoopErrore(isMessaggioSPCoopErrore);
                    
sbustamentoRisposteMSG.setQueueForResponse(queueForResponse);
                }
                
                











                
                /* -------------------- 
                   Profilo OneWay :
                   Puo' trovarsi nella seguente situazione :
                   1) Ricevere niente, carico HTTP Reply vuoto (o SoapEnvelope 
non fault da non considerare) 
                   2) Ricevere un MessaggioSPCoop Errore
                   3) Ricevere una Busta normale contenente :
                   a) Riscontro
                   4) Ricevere un SoapFault senza una busta eGov associata
                       --------------- */ 
                
if(profiloDiCollaborazione.equals(Costanti.Profilo_MessaggioSingoloOneWay)){

                    // 1) Carico HTTP Reply vuoto
                    if (responseSOAP == null ) 
                        ;// TODO NIENTE!

                    // 2) e 3) Busta egov presente
                    if ( presenzaRispostaSPCoop ){

                        if(isMessaggioSPCoopErrore){    
                            
                            // 2) Ricevuto Messaggio SPCoopErrore da spedire al 
modulo Sbustamento.
                            msgDiag.errorOpenSPCoop("Ricevuto 
MessaggioSPCoopErrore["+idEGovRisposta
                                                    +"] da smistare al modulo 
'SbustamentoRisposte'");
                            
                        }else{
                            
                            // 3) Ricevuto Messaggio SPCoop (Puo' contenere un 
riscontro o qualcos'altro...) 
                            msgDiag.infoOpenSPCoop("Ricevuto 
MessaggioSPCoop["+idEGovRisposta
                                                   +"] da smistare al modulo 
'SbustamentoRisposte'");
                        }
                        
                        // Consegna al modulo SbustamentoRisposte
                        
sbustamentoRisposteMSG.setProfiloDiCollaborazione(Costanti.Profilo_MessaggioSingoloOneWay);
                        ObjectMessage messageR = 
qs.createObjectMessage(sbustamentoRisposteMSG);
                        messageR.setLongProperty("ID", idJMS);
                        senderRisposteToSbustamento.send(messageR);
                            
                        // Se non e' indicato di eliminare il messaggio, in 
caso di errori,
                        // non deve essere fatto poiche' sara' riutilizzato dal 
Thread che re-invia la busta
                        if( isMessaggioSPCoopErrore ){
                            if(eliminaMessaggio)
                                
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                            
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,
                                                            
idModulo,propertiesReader.getWorkingDirectory());
                            else
                                
MDBUtils.releaseResourceMDB(false,queueForResponse,null,
                                                            
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,
                                                            
idModulo,propertiesReader.getWorkingDirectory());
                            return;
                        }
                                                
                    }else{      
                        
                        if(fault!=null){
                            
                            // 4) Ricevuto SOAP Fault senza busta Associata     
                    
                            msgDiag.errorOpenSPCoop("Ricevuto un SOAPFault 
[code: "+fault.getFaultCode()
                                                    +"] in seguito all'invio 
della busta.\nFaultString : "+fault.getFaultString());
                            // Se non e' indicato di eliminare il messaggio, in 
caso di errori,
                            // non deve essere fatto poiche' sara' riutilizzato 
dal Thread che re-invia la busta
                            if(eliminaMessaggio)
                                
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                            
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,idModulo,
                                                            
propertiesReader.getWorkingDirectory());
                            else
                                
MDBUtils.releaseResourceMDB(false,queueForResponse,null,
                                                            
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,idModulo,
                                                            
propertiesReader.getWorkingDirectory());
                            return;
                            
                        }
                    }
        
                }

                















                /* -------------------- 
                   Profilo Sincrono :
                   Puo' trovarsi nella seguente situazione :
                   1) Ricevere un MessaggioSPCoop Errore
                   2) Ricevere una Busta contenente il risultato applicativo 
(piu' eventuali riscontri,....)
                   3) Ricevere un SoapFault o niente senza una busta eGov 
associata
                   --------------- */ 
                
if(profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono)){
                    
                    // 3) Carico HTTP Reply vuoto
                    if( responseSOAP == null ){
                        msgDiag.errorOpenSPCoop("Risposta su carico HTTP non 
ricevuta, nonostante sia presente un profilo sincrono.");
                        byte [] error = 
                            
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                              
"Server.ReplyHTTPEmpty",
                                                                              
PdDUtils.erroreProcessamento,
                                                                              
Costanti.EccezioneProcessamento);
                        
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,
                                                         
idJMS,dominio,idModulo,senderToAccettazioneRichiesteInterne,qs);
                        
RollbackEGov.rollbackPD_ProfiloSincronoRicezione(id_eGov,connectionDB);
                        
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                    
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,idModulo,
                                                    
propertiesReader.getWorkingDirectory());
                        return;
                    }

                    
                    // 1) e 2) Busta egov presente
                    if ( presenzaRispostaSPCoop ){
                        
                        if(isMessaggioSPCoopErrore){    
                            
                            // 1) Ricevuto Messaggio SPCoopErrore da spedire al 
modulo Sbustamento.
                            msgDiag.errorOpenSPCoop("Ricevuto 
MessaggioSPCoopErrore["+idEGovRisposta
                                                    +"] da smistare al modulo 
'SbustamentoRisposte'");
                            
                        }else{
                            
                            // 2) Ricevuto Messaggio SPCoop (Puo' contenere 
oltre alla risposta un riscontro o qualcos'altro...) 
                            msgDiag.infoOpenSPCoop("Ricevuto 
MessaggioSPCoop["+idEGovRisposta
                                                   +"] da smistare al modulo 
'SbustamentoRisposte'");
                        }
                        
                        // Salvataggio risposta (se non ci sono stati errori di 
validazione)
                        if(errors.size() == 0){
                            String idMessaggioRisposta = idJMS + "_" 
+idEGovRisposta ;
                            
                            boolean saveOK = 
                                
SoapUtils.saveMessage_sbustamentoEGov(responseSOAP,idMessaggioRisposta,
                                                                      
propertiesReader.getWorkingDirectory(),connectionDB);
                            if(saveOK == false){
                                msgDiag.errorOpenSPCoop("Riscontrato errore 
durante il salvataggio del messaggio ricevuto.");
                                byte [] error = 
                                    
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                                
      "Server.SaveResponse",
                                                                                
      PdDUtils.erroreProcessamento,
                                                                                
      Costanti.EccezioneProcessamento);
                                
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,
                                                                 
dominio,idModulo,senderToAccettazioneRichiesteInterne,qs);
                                
RollbackEGov.rollbackPD_ProfiloSincronoRicezione(id_eGov,connectionDB);
                                
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,
                                                            
connectionDB,connectionQueue,qs,ctxMDB,idJMS,dominio,
                                                            
idModulo,propertiesReader.getWorkingDirectory());
                                return;
                            }
                        }
                            
                        // Consegna al modulo SbustamentoRisposte
                        
sbustamentoRisposteMSG.setProfiloDiCollaborazione(Costanti.Profilo_ServizioSincrono);
                        ObjectMessage messageR = 
qs.createObjectMessage(sbustamentoRisposteMSG);
                        messageR.setLongProperty("ID", idJMS);
                        senderRisposteToSbustamento.send(messageR);
                    }
                    else{       
                        
                        if(fault!=null){
                            
                            // 1) Ricevuto SOAP Fault
                            
                            msgDiag.errorOpenSPCoop("Ricevuto un SOAPFault 
[code: "+fault.getFaultCode()
                                                    +"] in seguito all'invio 
della busta.\nFaultString : "+fault.getFaultString());
                            
                        }else{
                            msgDiag.errorOpenSPCoop("Ricevuto un messaggio 
SOAP, che non contiene una busta eGov, come risposta  all'invio della busta.");
                        }
                        
                        byte [] error = 
                            
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                              
"Server.ReplyHTTPError",
                                                                              
PdDUtils.erroreProcessamento,
                                                                              
Costanti.EccezioneProcessamento);
                        
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,dominio,idModulo,
                                                         
senderToAccettazioneRichiesteInterne,qs);
                        
RollbackEGov.rollbackPD_ProfiloSincronoRicezione(id_eGov,connectionDB);
                        
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,connectionDB,
                                                    
connectionQueue,qs,ctxMDB,idJMS,dominio,idModulo,
                                                    
propertiesReader.getWorkingDirectory());
                        return;
                    }
                    
                }

           

                







            
                /* ---------- Gestione Transazione Modulo ---------------- */
            
                // Avanzamento Stato
                // CAPIRE A MODO QUANDO FINISCE LO STATO O SE SI VA IN 
SBUSTAMENTO RISPOSTE!!!
                // SE finise
                // deleteState()
                // else
                ;//updateNextState();

                // Elimino il messaggio precedentemente salvato dal DB.
                // Il delete dal fileSystem viene effettuato solo dopo il 
commit JDBC, cosicche' l'eliminazione
                // sara' effettuata quando openspcoop ha avanzato sicuramente 
il proprio stato di processamento della richiesta,
                // e quanto eliminato dal fileSystem non sara' sicuramente piu' 
riutilizzato. 
                // Al massimo se il sistema ha un crash dopo il commit JDBC 
(caso raro), il modulo MDB
                // scartara' il messaggio ricevuto poiche' si trova in uno 
stato di avanzamento successivo, 
                // e quindi il file eliminato non sara' riutilizzato. 
                
AttachmentsUtils.deleteAttachmentsFromDB(idMessaggioRichiesta,connectionDB);

                // Commit JMS
                qs.commit();
                
                // Commit JDBC
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); // 
connectionDB.commit
                    
                // Rilascio risorse
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                
//DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); // Da fare 
quando ci sara' il commit.

                // Elimino il messaggio precedentemente salvato dal fileSystem.
                
SoapUtils.deleteMessageFromFileSystem(idMessaggioRichiesta,propertiesReader.getWorkingDirectory());

                msgDiag.mediumDebug("Lavoro Terminato.");
                return;

                

                
            }catch(Exception e){
                msgDiag.errorOpenSPCoop("Riscontrato errore durante la gestione 
della spedizione/ricezione Busta (ErroreGenerale): "+e.toString());
                
                if(  
profiloDiCollaborazione.equals(Costanti.Profilo_ServizioSincrono) ){
                    byte [] error = 
                        
org.openspcoop.egov.XMLUtils.buildBytes_Eccezione(dominio,idModulo,
                                                                          
"Server.CrashModulo",
                                                                          
PdDUtils.erroreProcessamento,
                                                                           
Costanti.EccezioneProcessamento);
                    try{
                        
MDBUtils.sendRispostaApplicativa(error,servizioApplicativo,idService,idJMS,dominio,
                                                         
idModulo,senderToAccettazioneRichiesteInterne,qs);
                    }catch(Exception er){
                        msgDiag.errorOpenSPCoop("Riscontrato errore durante la 
spedizione dell'errore (profilo Sincrono)");
                        
MDBUtils.releaseResourceMDBWithError(connectionDB,connectionQueue,qs,ctxMDB,
                                                             
idJMS,dominio,idModulo); 
                        return;
                    }
                    
RollbackEGov.rollbackPD_ProfiloSincronoRicezione(id_eGov,connectionDB);
                    
MDBUtils.releaseResourceMDB(true,queueForResponse,idMessaggioRichiesta,connectionDB,
                                                
connectionQueue,qs,ctxMDB,idJMS,dominio,
                                                
idModulo,propertiesReader.getWorkingDirectory());
                }else{               
                    
MDBUtils.releaseResourceMDBWithError(connectionDB,connectionQueue,qs,ctxMDB,idJMS,
                                                         dominio,idModulo); 
                }
                return;
            }
        }
        
    }
    
    
    /**
     * MessageFactory per la costruzione di un oggetto {@link 
InoltroBuste_eGov_Message}
     * utilizzato per la spedizione di messaggi JMS al mdb definito in questa 
classe, 
     * tramita una coda JMS utilizzata in ricezione.
     *
     * @return un oggetto di tipo {@link InoltroBuste_eGov_Message} non 
inizializzato.
     * @since 0.2
     */
    public static InoltroBuste_eGov_Message createBean(){
        return new InoltroBuste_eGov_Message();
    }
        
  
}

/*
 * Copyright 2005 Link.it srl, http://link.it.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.openspcoop.pdd.services;

import org.apache.axis.AxisFault;
import org.apache.axis.Message;
import org.apache.axis.MessageContext;

import org.apache.axis.message.SOAPEnvelope;

import javax.jms.ObjectMessage;
import javax.jms.QueueReceiver;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.QueueConnection;
import javax.jms.Queue;
import javax.jms.Session;

import java.sql.Connection;
import java.sql.SQLException;

import org.openspcoop.pdd.mdb.Sbustamento_Message;
import org.openspcoop.pdd.mdb.Sbustamento;
import org.openspcoop.utils.SoapUtils;
import org.openspcoop.utils.AttachmentsUtils;
import org.openspcoop.egov.ValidatoreSPCoop;
import org.openspcoop.egov.XMLUtils;
import org.openspcoop.egov.Costanti;
import org.openspcoop.egov.Imbustamento;
import org.openspcoop.egov.Eccezione;
import org.openspcoop.egov.Busta;
import org.openspcoop.egov.IDSoggetto;
import org.openspcoop.egov.IDServizio;
import org.openspcoop.registry.QueryEGovImpl;
import org.openspcoop.pdd.output.MsgDiagnostico;
import org.openspcoop.pdd.output.Tracciamento;
import org.openspcoop.pdd.config.ConfigReaderImpl;
import org.openspcoop.pdd.config.DBManager;
import org.openspcoop.pdd.config.QueueManager;
import org.openspcoop.pdd.config.RichiestaApplicativa;
import org.openspcoop.pdd.config.OpenSPCoopProperties;
import org.openspcoop.pdd.utils.PdDUtils;
import org.openspcoop.wssecurity.WSSBaseUtils;
import org.openspcoop.wssecurity.WSSSender;
import org.openspcoop.wssecurity.WSSReceiver;



/**
 * Contiene la definizione di un servizio axis  'RicezioneBusteEGov', il quale 
e' un
 * modulo dell'infrastruttura OpenSPCoop.
 * <p>
 * Inoltre la classe contiene due MessageFactory per la costruzione di un 
oggetto {@link RicezioneBusteEGov_Message}
 * utilizzato per la spedizione di messaggi JMS al servizio axis, tramita una 
coda JMS utilizzata in ricezione.
 *
 *
 * @author Poli Andrea (apoli@link.it)
 * @version 0.6, 13/04/06
 */

public class RicezioneBusteEGovSOAP {


    /* ********  F I E L D S  P R I V A T I S T A T I C I  ******** */
 
    /** Variabile che indica il Nome del modulo dell'architettura di OpenSPCoop 
rappresentato da questa classe */
    public final static String idModulo = "RicezioneBusteEGovSOAP";
    /** Identifica il timeout di ricezione sulla connesione jms (3,5 minuti) */
    public final static long timeoutJMS = 5 * 60 * 1000;
    
    


    /* ********  M E T O D I   ******** */

    /**
     * Metodo contenente la definizione di un servizio axis , che si occupa di 
ricevere buste eGov, 
     * per poi inoltrarle all'infrastruttura OpenSPCoop.
     * Prima di inoltrare la busta, viene effettuata una autenticazione 
http-based, e una lettura di eventuali 
     * attachments presenti all'interno della busta egov ricevuta. Se sono 
presenti attachments, questi vengono
     * mappati in oggetti di tipo {@link org.openspcoop.utils.Attachment}.
     * Il messaggio Soap ricevuto viene mappato in un oggetto  {@link 
org.openspcoop.utils.SoapMessage}.
     * <p>
     * Il servizio in questione, si occupa anche di aspettare una risposta 
dall'infrastruttura OpenSPCoop. per
     * poi consegnarla alla porta di dominio mittente, nel caso di profilo di 
collaborazione Sincrono.
     *
     * @param req SoapEnvelope della richiesta ricevuta dal servizio.
     * @param res SoapEnvelope della risposta che dovra' essere consegnata al 
servizio.
     * @since 0.2
     */
    public void OpenSPCoop_PA(SOAPEnvelope req,SOAPEnvelope res) throws 
AxisFault {
        

        /* ------------  Lettura parametri della busta ricevuta ------------- */
        MessageContext msgContext = MessageContext.getCurrentContext();
        org.apache.axis.Message requestAxisMessage = 
msgContext.getRequestMessage();
        
        // Logger dei messaggi diagnostici
        MsgDiagnostico msgDiag = new MsgDiagnostico(idModulo);
                







        /* ------------- Inizializzazione Database  ------------------- */
        
        java.sql.Connection connectionDB = null;
        String errorInitializeDB = null;
        try{
            // Get Connessione al DB
            connectionDB = 
DBManager.getOscpDBConnection(PdDUtils.openspcoopPdD,idModulo);
            if(connectionDB == null){
                errorInitializeDB = "Riscontrato errore durante la richiesta di 
una connessione al DB.";
            }
        }catch(Exception e){
            errorInitializeDB = "Riscontrato errore durante la richiesta di una 
connessione al DB: " + e.toString();
        }
        if(errorInitializeDB !=null){
            msgDiag.fatalOpenSPCoop(errorInitializeDB); 
            msgContext.setResponseMessage(msgErrore("DBConnetionError"));
            return;
        }












        /* ------------  Processamento Busta Ricevuta ------------- */  

        ValidatoreSPCoop validator = new 
ValidatoreSPCoop(requestAxisMessage,ConfigReaderImpl.isLivelloValidazioneRigido());
        if(validator.valida() == false){
            msgDiag.errorOpenSPCoop("Riscontrato errore durante la validazione 
della busta ricevuta. " +validator.getMsgErrore());
            
msgContext.setResponseMessage(msgErrore(validator.getCodiceErrore()));
            
DBManager.releaseOscpDBConnection(PdDUtils.openspcoopPdD,idModulo,connectionDB);
            return;
        }
        Busta busta_eGov = validator.getBusta();
        java.util.Vector<Eccezione> errors = validator.getEccezioni();
        String idEGov = busta_eGov.getID();
        boolean isMessaggioSPCoopErrore = validator.isSPCoopErrore();
        IDSoggetto soggettoSPCoop = validator.getSoggettoMittente();
        IDServizio idServizio = validator.getIDServizio();

        // MsgDiag e Tracer per il tracciamento di Buste
        String dominio = QueryEGovImpl.getDominio(idServizio.getSoggetto());
        if(dominio==null){
            dominio = PdDUtils.openspcoopPdD;
        }
        idServizio.getSoggetto().setCodicePorta(dominio); 
        msgDiag.setDominioSPCoop(dominio); // imposto il dominio del ricevente  

        // Controllo bustaDiServizio
        boolean bustaDiServizio = false;
        try{
            bustaDiServizio = PdDUtils.bustaSenzaCarico(requestAxisMessage);
        }catch(Exception e){
            msgDiag.errorOpenSPCoop("Il processo di controllo 'bustaDiServizio' 
ha comportato un errore di processamento.");
            
msgContext.setResponseMessage(msgErrore("ErroreRiconoscimentoBustaDiServizio"));
            DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
            return;
        }

        // Tracciamento Busta Ricevuta
        Tracciamento tracciamento = new Tracciamento(dominio);
        tracciamento.registraRichiesta(busta_eGov);
        if(isMessaggioSPCoopErrore)
            msgDiag.errorSPCoop("Ricevuto messaggio SPCoop Errore con 
identificativo ["+busta_eGov.getID()+
                                 "] inviata dalla parte mittente 
["+busta_eGov.getMittente()+"] .");
        else
            msgDiag.infoSPCoop("Ricevuto messaggio SPCoop con identificativo 
["+busta_eGov.getID()
                               +"] inviata dalla parte mittente 
["+busta_eGov.getMittente()+"] .");
        
        // Richiesta Applicativa
        RichiestaApplicativa idPA = new 
RichiestaApplicativa(soggettoSPCoop,idServizio);    
        
        // WSSecurity
        // Imposto un context di Base (utilizzato anche  per la successiva 
spedizione della risposta)
        WSSBaseUtils baseWSS = new WSSBaseUtils();      
        // ottiene le proprieta' WS-Security relative alla porta applicativa 
(WSS del receiver)
        java.util.Hashtable wssPropertiesRequest = 
ConfigReaderImpl.getPA_WSSForReceiver(idPA);
        if(wssPropertiesRequest!=null){   
            if(wssPropertiesRequest.size() > 0){
                WSSReceiver wssReceiver = new 
WSSReceiver(wssPropertiesRequest,baseWSS);
                if(wssReceiver.process(requestAxisMessage,busta_eGov) == 
false){   
                    msgDiag.errorOpenSPCoop(wssReceiver.getMsgErrore());
                    
msgContext.setResponseMessage(Imbustamento.msgErroreValidazioneSPCoop(connectionDB,dominio,idModulo,busta_eGov,
                                                                                
          wssReceiver.getMsgErrore(),
                                                                                
          wssReceiver.getCodiceErrore()));
                    //  Tracciamento Busta Ritornata 
                    tracciamento.registraRisposta(busta_eGov);
                    
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
                    return;
                }
            }
        }       

        // Validazione Attachments!     
        ;// TODO
       
        // Estrazione header busta SPCoop
        // Prelevo l'headerElement dall'header
        /*if( erroreProcessamentoBustaSPCoop==null  ){
          if( org.openspcoop.egov.Sbustamento.prelevaHeaderEGov(headerBusta) == 
false  ){
          erroreProcessamentoBustaSPCoop="Generatosi errore durante 
l'estrazione dell'header SPCoop";
          }
          }*/
        
        
        // capire se sara' attesa una risposta SPCoop o meno.
        boolean richiestaRispostaSPCoop = true;
        if( 
Costanti.Profilo_MessaggioSingoloOneWay.equals(busta_eGov.getProfiloDiCollaborazione())
 &&
            busta_eGov.getConfermaRicezione().equalsIgnoreCase("false") ){
            richiestaRispostaSPCoop = false;
        }else if ( busta_eGov.getIndirizzoTelematicoMittente()!=null  ){
            richiestaRispostaSPCoop = false;
        }else if ( bustaDiServizio  ) {
            richiestaRispostaSPCoop = false;
        }else if ( isMessaggioSPCoopErrore  ) {
            richiestaRispostaSPCoop = false;
        }










       






        /* ---------------- Inizializzazione Variabili e Connessioni a code  
--------------------- */

        OpenSPCoopProperties propertiesReader = new OpenSPCoopProperties();

        // risorse inizializzate nel try-catch seguente.
        QueueConnection connectionQueue = null;
        QueueSession qs = null;
        QueueSender sender = null;
        QueueReceiver receiver = null;
        long idJMS = -1;        
        try{
            // Costruzione ID per Sessioni sulle code JMS
            idJMS = PdDUtils.buildID_JMS(connectionDB);
            if(idJMS==-1){
                msgDiag.fatalOpenSPCoop("Errore verificatosi durante la 
costruzione dell'identificativo JMS.");
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                                
        busta_eGov,
                                                                                
        "Riscontrato errore durante la costruzione dell'ID JMS"
                                                                                
        ,"WSSRequestError"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
                return;
            }

            // Get Connection Queue
            Queue queueRequest = 
QueueManager.getQueue(dominio,idModulo,"queue/toSbustamento");
            Queue queueResponse = 
QueueManager.getQueue(dominio,idModulo,"queue/toRicezioneBusteEGovSOAP");
            connectionQueue = QueueManager.getQueueConnection(dominio,idModulo);
            if(  (queueRequest == null) || (queueResponse == null) || 
(connectionQueue == null)  ){     
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
creazione della connessione (o delle code) al broker JMS.");
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                                
        busta_eGov,
                                                                                
        "Riscontrato errore durante la creazione della connessione (o delle 
code) al broker JMS."
                                                                                
        ,"ErrorConnectionJMS"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
                return;
            }           
            qs = 
QueueManager.getQueueTransactionSession(dominio,idModulo,connectionQueue);
            if( qs == null ){   
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
creazione della sessione della connessione al broker JMS.");
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                                
        busta_eGov,
                                                                                
        "Riscontrato errore durante la creazione della sessione JMS.",
                                                                                
        "ErrorSessioneJMS"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);       
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                return;
            }
            try {
                sender = qs.createSender(queueRequest);
                String strMessageSelector = "ID = "+idJMS;
                receiver = qs.createReceiver(queueResponse,strMessageSelector);
            } catch (javax.jms.JMSException e) {        
                msgDiag.fatalOpenSPCoop("Riscontrato errore durante la 
creazione dei sender/receiver JMS : \n\n"+e.toString());
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                           
busta_eGov,
                                                                           
"Riscontrato errore durante la creazione dei sender/receiver JMS.",
                                                                           
"ErrorSenderReceiverJMS"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);          
                return;
            }   

        }catch(Exception e){
            msgDiag.errorOpenSPCoop("Riscontrato errore durante la gestione 
della richiesta pervenuta (ErroreGenerale): "+e.toString());
            
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                       
busta_eGov,
                                                                       
"Riscontrato errore durante l'inizializzazione delle risorse (Errore 
Generale).",
                                                                       
"ErrorInitializeResource"));
           
            //  Tracciamento Busta Ritornata 
            tracciamento.registraRisposta(busta_eGov);
            if(connectionDB != null)
                
DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB);
            if(connectionQueue != null)
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
            return;
        }
        










        /* ----------------  Salvo messaggio ricevuto su FileSystem (con 
sbustamento SPCoop)  --------------------- */
        if( bustaDiServizio == false  ){
            String saveRequestError = null;
            try{
                String idMessaggio = idJMS + "_" + idEGov;
                if( 
SoapUtils.saveMessage_sbustamentoEGov(requestAxisMessage,idMessaggio,propertiesReader.getWorkingDirectory(),connectionDB)
 == false ){
                    saveRequestError = "Riscontrato errore durante la gestione 
della richiesta pervenuta: salvataggio su fileSystem/DB non riuscito";
                }
            }catch(Exception e){
                saveRequestError = "Riscontrato errore durante la gestione 
della richiesta pervenuta: salvataggio su fileSystem/DB non 
riuscito:\n"+e.toString();
            }
            if(saveRequestError != null){
                msgDiag.errorOpenSPCoop(saveRequestError);
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                           
busta_eGov,
                                                                           
saveRequestError,"ErrorSaveMessaggioSPCoop"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
//DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); 
JDBC.Rollback();
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                return;
            }
        }










        /* ------------  Spedizione a modulo Sbustamento ------------- */

        String sendJMSRequestError = null;
        try{
            // Creazione Sbustamento_Message e spedizione via JMS Queue
            msgDiag.highDebug("Creazione ObjectMessage for send via JMS.....");
            Sbustamento_Message sbustamentoMSG = 
org.openspcoop.pdd.mdb.Sbustamento.createBean();
            sbustamentoMSG.setRichiestaApplicativa(idPA);
            sbustamentoMSG.setBusta(busta_eGov);
            sbustamentoMSG.setErrors(errors);
            sbustamentoMSG.setIsSPCoopErrore(isMessaggioSPCoopErrore);
            sbustamentoMSG.setIsBustaDiServizio(bustaDiServizio);
            
sbustamentoMSG.setQueueForResponse("queue/toRicezioneBusteEGovSOAP");
            ObjectMessage message = qs.createObjectMessage(sbustamentoMSG);
            message.setLongProperty("ID", idJMS);
            sender.send(message);
            msgDiag.highDebug("ObjectMessage send via JMS.");
        } catch (javax.jms.JMSException e) {    
            sendJMSRequestError = "Riscontrato errore durante la 
creazione/spedizione di un Messaggio JMS : \n"+e.toString();
        }
        if(sendJMSRequestError != null){
            msgDiag.errorOpenSPCoop(sendJMSRequestError);
            
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                       
busta_eGov,
                                                                       
sendJMSRequestError,"ErrorSpedizioneJMS"));
            //  Tracciamento Busta Ritornata 
            tracciamento.registraRisposta(busta_eGov);
            //DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); 
JDBC.Rollback();
            QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
            return;
        }
            
        // Transazione 
        try{
            qs.commit();
        }catch(Exception e){
            msgDiag.errorOpenSPCoop("Riscontrato errore durante la spedizione 
del messaggio JMS");
            
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                       
busta_eGov,
                                                                       
"Transazione JMS non riuscita",
                                                                       
"ErrorCommitJMS"));
            //  Tracciamento Busta Ritornata 
            tracciamento.registraRisposta(busta_eGov);
            //DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); 
JDBC.Rollback();
            QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
            return;
        }
        DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); 
//JDBC.commit();













            







        try{

            /* ------------ Gestione Risposta -------------- */

            try {       
                connectionQueue.start();
            } catch (javax.jms.JMSException e) {        
                msgDiag.errorOpenSPCoop("Riscontrato errore durante l'avvio 
(start) della connessione JMS : \n\n"+e.toString());
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                           
busta_eGov,
                                                                           
"Riscontrato errore durante lo start della connessione JMS",
                                                                           
"GetDBConnectionError"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                return;
            }



            // TIMEOUT RICEZIONE JMS
            msgDiag.highDebug("Aspect Receiving response with ID "+idJMS);
            ObjectMessage received = (ObjectMessage) 
receiver.receive(timeoutJMS);

            // Re-ottengo Connessione al DB
            connectionDB = DBManager.getOscpDBConnection(dominio,idModulo);
            if(connectionDB == null){
                msgDiag.errorOpenSPCoop("Riscontrato errore durante la 
richiesta di una connessione al DB (risposta)");
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                           
busta_eGov,
                                                                           
"Riscontrato errore durante la connessione al Database",
                                                                           
"GetDBConnectionError"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                return;
            }

            // Controllo che non sia scattato prima il timeout
            if (received == null) {     
                msgDiag.errorOpenSPCoop("Timeout sulla ricezione della coda JMS 
scaduto : Si sono verificati errori nei moduli interni di OpenSPCoop");
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                           
busta_eGov,
                                                                           
"Timeout sulla Ricezione JMS scaduta",
                                                                           
"TimeoutRicezioneJMSScaduto"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                return;
            }   



            // CONTROLLO RISPOSTA RITORNATA SE IL PROFILO LO RICHIEDE
            // Controllo presenza contenuto nel Messaggio di risposta 
            // (che non sia un semplice messaggio di sblocco per il nodo) 
            boolean contenutoRispostaPresente = 
received.getBooleanProperty("ContenutoRispostaPresente");
            if( richiestaRispostaSPCoop && (contenutoRispostaPresente==false)  
){
                msgDiag.errorOpenSPCoop("Risposta SPCoop attesa e non 
ritornata: Si sono verificati errori nei moduli interni di OpenSPCoop");
                
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                           
busta_eGov,
                                                                           
"Risposta SPCoop non ricevuta",
                                                                           
"RispostaSPCoopNonRicevuta"));
                //  Tracciamento Busta Ritornata 
                tracciamento.registraRisposta(busta_eGov);
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                return;
            }

            /* ------------ Gestione Risposta -------------- */
            String idMessaggioRisposta = null;
            if(contenutoRispostaPresente){

                msgDiag.highDebug("Manage response 
(RicezioneBusteEGov_Message)");
                RicezioneBusteEGov_Message sr = 
(RicezioneBusteEGov_Message)received.getObject();
                // Lettura Contenuto Messaggio (mapping in AxisMessage)
                org.apache.axis.Message responseAxisMessage = null;
                byte [] byteRispostaSPCoop = sr.getResponseMessage();   
                String idEGovRisposta = sr.getIDEGov();
                idMessaggioRisposta = idJMS + "_" +idEGovRisposta ;
                byte [] headerSPCoop = sr.getHeaderEGov();
                if( byteRispostaSPCoop != null  ){
                    responseAxisMessage = new 
org.apache.axis.Message(byteRispostaSPCoop);
                }
                else{
                    // Il messaggio viene solo letto dal DB. Sara' eliminato 
una volta usato sicuramente (fine della transazione)
                    responseAxisMessage = 
SoapUtils.readMessage_appendEGov(idMessaggioRisposta,
                                                                           
propertiesReader.getWorkingDirectory(),
                                                                           
connectionDB,headerSPCoop,false);
                }
                if( responseAxisMessage == null  ){
                    msgDiag.errorOpenSPCoop("Riscontrato errore durante la 
ricezione di un Messaggio JMS : Risposta NULL");
                    
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                               
busta_eGov,
                                                                               
"Riscontrato errore durante la ricezione della risposta SPCoop",
                                                                               
"ReadRispostaSPCoopError"));
                    //  Tracciamento Busta Ritornata 
                    tracciamento.registraRisposta(busta_eGov);
                    
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                    return;
                }
                
                // WS-Security
                // ottiene le proprieta' WS-Security relative alla porta 
applicativa (WSS del sender)
                java.util.Hashtable wssPropertiesResponse = 
ConfigReaderImpl.getPA_WSSForSender(idPA);  
                if(wssPropertiesResponse != null){
                    if(wssPropertiesResponse.size() > 0){
                        WSSSender wssSender = new 
WSSSender(wssPropertiesResponse,baseWSS);
                        if(wssSender.process(responseAxisMessage) == false){
                            msgDiag.errorOpenSPCoop(wssSender.getMsgErrore());
                            
msgContext.setResponseMessage(Imbustamento.msgErroreValidazioneSPCoop(connectionDB,dominio,idModulo,
                                                                                
                  busta_eGov,
                                                                                
                  wssSender.getMsgErrore(),
                                                                                
                  wssSender.getCodiceErrore()));
                            //  Tracciamento Busta Ritornata 
                            tracciamento.registraRisposta(busta_eGov);
                            
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
                            return;
                        }
                    }
                }
           

                // Consegno ad Axis la risposta
                msgContext.setResponseMessage(responseAxisMessage);
        
            }



            


            /* ---------- Gestione Transazione Modulo ---------------- */
                    
            // Delete Stato
            ;//deleteState();
                   
            if(contenutoRispostaPresente){
                // Elimino il messaggio precedentemente salvato dal DB.
                // Il delete dal fileSystem viene effettuato solo dopo il 
commit JDBC, cosicche' l'eliminazione
                // sara' effettuata quando openspcoop ha avanzato sicuramente 
il proprio stato di processamento della richiesta,
                // e quanto eliminato dal fileSystem non sara' sicuramente piu' 
riutilizzato. 
                // Al massimo se il sistema ha un crash dopo il commit JDBC 
(caso raro), il modulo MDB
                // scartara' il messaggio ricevuto poiche' si trova in uno 
stato di avanzamento successivo, 
                // e quindi il file eliminato non sara' riutilizzato.
                
AttachmentsUtils.deleteAttachmentsFromDB(idMessaggioRisposta,connectionDB);
            }

 
            // Commit JMS
            qs.commit();
            
                // Commit JDBC
            DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); 
// connectionDB.commit
            
            // Rilascio risorse
            QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
            //DBManager.releaseOscpDBConnection(dominio,idModulo,connectionDB); 
// Da fare quando ci sara' il commit.
            
            if(contenutoRispostaPresente){
                // Elimino il messaggio precedentemente salvato dal fileSystem.
                
SoapUtils.deleteMessageFromFileSystem(idMessaggioRisposta,propertiesReader.getWorkingDirectory());
            }

            msgDiag.mediumDebug("Lavoro Terminato.");
            return;







           
         
            
            // PULIZIA CODE!!! 
            /*
            Queue queueClean = 
QueueManager.getQueue(dominio,idModulo,"queue/ResponseOUT_eGov");
            connectionQueue = QueueManager.getQueueConnection(dominio,idModulo);
            QueueSession qsClean = 
QueueManager.getQueueSession(dominio,idModulo,connectionQueue);
            if( qsClean == null ){      
                
OpenSPCoopLogger.writeMsgDiagnostico(XMLUtils.buildString_Diagnostico(dominio,idModulo,LogLevels.LivelloSeverita_ErrorOpenSPCoop,("Riscontrato
 errore durante la creazione della sessione della connessione al broker 
JMS.")));
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qsClean);
                return;
            }
            QueueReceiver receiverClean;
            try {
                receiverClean = qsClean.createReceiver(queueClean);
            } catch (javax.jms.JMSException e) {        
                
OpenSPCoopLogger.writeMsgDiagnostico(XMLUtils.buildString_Diagnostico(dominio,idModulo,LogLevels.LivelloSeverita_ErrorOpenSPCoop,("Riscontrato
 errore durante la creazione della sessione CLEAN  (o dei sender/receiver) JMS 
: \n\n"+e.toString())));
                
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qsClean);
                return;
            }           
            while(true){ 
                try { 
                    ObjectMessage receivedT = null;
                    receivedT = (ObjectMessage) receiverClean.receiveNoWait();
                    if (receivedT == null)
                        break;
                } catch (Exception e) { 
                    
OpenSPCoopLogger.writeMsgDiagnostico(XMLUtils.buildString_Diagnostico(dominio,idModulo,LogLevels.LivelloSeverita_InfoOpenSPCoop,"ERRORE
 ["+e.toString()+"]"));
                    return;
                }
                
OpenSPCoopLogger.writeMsgDiagnostico(XMLUtils.buildString_Diagnostico(dominio,idModulo,LogLevels.LivelloSeverita_InfoOpenSPCoop,"PULIZIAAAAAAAAAA
 EGOV"));
            } 
            
QueueManager.releaseResource(dominio,idModulo,connectionQueue,qsClean);
            */




        } catch (Exception e) {
        
            msgDiag.errorOpenSPCoop("Riscontrato errore durante la ricezione di 
un Messaggio JMS : \n\n"+e.toString());
            
msgContext.setResponseMessage(Imbustamento.msgErroreProcessamentoSPCoop(connectionDB,dominio,idModulo,
                                                                                
    busta_eGov,
                                                                                
    "Ricezione JMS non riuscita",
                                                                                
    "ErrorRicezioneJMS" ));
            //  Tracciamento Busta Ritornata 
            tracciamento.registraRisposta(busta_eGov);
            try{
                qs.rollback();
            }catch (Exception er){}
            QueueManager.releaseResource(dominio,idModulo,connectionQueue,qs);
            return;
        }
  
        
    }
    
    /**
     * MessageFactory per la costruzione di un oggetto {@link 
RicezioneBusteEGov_Message}
     * utilizzato per la spedizione di messaggi JMS al servizio axis, tramita 
una coda JMS utilizzata in ricezione.
     *
     * @return un oggetto di tipo {@link RicezioneBusteEGov_Message} non 
inizializzato.
     * @since 0.2
     */
    public static RicezioneBusteEGov_Message createBean(){
        return new RicezioneBusteEGov_Message();
    }



    /**
     * Costruisce un messaggio axis contenente una risposta SOAPFault di 
errore. 
     *
     * @param codErrore Codice di errore
     * @return un messaggio Axis.
     * @since 0.6
     */
    public static org.apache.axis.Message msgErrore(String codErrore){
        
        try{
            return new 
org.apache.axis.Message(SoapUtils.build_Server_Error(RicezioneBusteEGovSOAP.idModulo,codErrore));
        }catch(Exception e){
            return new org.apache.axis.Message(new 
AxisFault("ErroreDiProcessamento"));
        }
    }

   




}