Java tutorial
/* Copyright (C) 2007 Flix Garca Borrego (borrego at gmail.com) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */ package org.viafirma.cliente; import java.net.MalformedURLException; import java.net.URL; import java.rmi.NotBoundException; import java.rmi.RemoteException; import java.util.List; import java.util.Map; import java.util.Set; import javax.jws.WebMethod; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.xml.namespace.QName; import javax.xml.ws.Service; import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.viafirma.cliente.exception.CodigoError; import org.viafirma.cliente.exception.InternalException; import org.viafirma.cliente.firma.TypeFile; import org.viafirma.cliente.firma.TypeFormatSign; import org.viafirma.cliente.firma.rmi.FirmaClienteRMI; import org.viafirma.cliente.openid.OpenIdHandler; import org.viafirma.cliente.util.Constantes; import org.viafirma.cliente.util.TypeRequest; import org.viafirma.cliente.vo.FirmaInfoViafirma; import org.viafirma.cliente.vo.UsuarioGenericoViafirma; /** * Cliente de Viafirma. * Instancia que utilizan los clientes para solicitar los servicios bsicos que ofrece la plataforma. * Para crear una instancia de esta clase utilice ViafirmaClientFactory * Para ms informacin consulte: http://www.viafirma.org/api_cliente.html * @author Felix Garcia Borrego (borrego at gmail.com) * @author Alexis Castilla Armero (Pencerval at gmail.com) * @see ViafirmaClientFactory */ public class ViafirmaClient { // *************************************** // Mtodos para la autenticacin de usuario // *************************************** /** * Inicia el proceso de autenticacin utilizando el protocolo OpenID. El * Identificador OpenId es autogenerado basado en * PARAMETER_URL_DEFAULT_AUTHENTICATION_PROVIDER Tras generar el * identificador llama al metodo public void autenticar(String urlId, * HttpServletRequest request, HttpServletResponse response) throws * InternalException. * * @param request * @param response * @throws InternalException */ public void autenticar(HttpServletRequest request, HttpServletResponse response) throws InternalException { // identificador de sessin String sessionId = request.getSession().getId(); // creamos la url String urlId = urlDefaultAuthenticationProvider.replace(MASK_URL_ID, sessionId); if (log.isDebugEnabled()) log.debug("URl OpenId a autenticar: " + urlId); // generamos el urlId(OpenId) autenticar(urlId, request, response); } /** * Procesa el resultado de la autenticacin para extraer los datos del * usuario y devolverlos. * * @param httpRequest * @param httpResponse * @throws InternalException */ public Map<String, String> processResponseAuthentication(HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws InternalException { // recuperos el resultado de la autenticacin if (log.isDebugEnabled()) log.debug("Recuperando el resultado de la autenticacin para :" + httpRequest.getRequestURI()); return openIdHandler.processResponseAuthentication(httpRequest, httpResponse); } /** * Indica si la peticin contiene los datos de respuesta OpenId. * * @param request * @return boolean */ public boolean isResponseAuthentication(HttpServletRequest request) { return openIdHandler.isResponseAuthentication(request); } /** * Indica si la respuesta OpenId ha sido cancelada. * * @param request * @return */ public boolean isResponseCancel(HttpServletRequest request) { return openIdHandler.isResponseCancel(request); } /** * Inicia el proceso de autenticacin utilizando el protocolo OpenID. * * @param urlId * - url OpenId(utilizada) * @param request * @param response * @throws InternalException */ public void autenticar(String urlId, HttpServletRequest request, HttpServletResponse response) throws InternalException { openIdHandler.autenticar(urlId, requestAutenticationProperties, request, response); } // *************************************** // Mtodos para la firma de ficheros // *************************************** /** * Enva el fichero que deseamos firmar y devuelve un identificador temporal * ( No es el identificador final de la firma ). * * @param tituloFile * ( Titulo del fichero ) * @param tipoFichero * ( Extension del fichero ) * @param Formato de la firma a realizar * @param bytesToSign * ( Byte array de los datos del fichero ) * @return Identificador asignado al proceso de firma(este indentificador * tendra validez de 10 mins). * @throws InternalException */ public String prepareFirmaWithTypeFileAndFormatSign(String tituloFile, TypeFile typoFichero, TypeFormatSign formatoFirma, byte[] bytesToSign) throws InternalException { // sube los datos por rmi al conector de firma1 try { if (tituloFile == null || typoFichero == null || bytesToSign == null) { if (tituloFile == null) { throw new InternalException(CodigoError.ERROR_CAMPOS_NULL, " Titulo del archivo "); } else if (typoFichero == null) { throw new InternalException(CodigoError.ERROR_CAMPOS_NULL, " Tipo de archivo "); } throw new InternalException(CodigoError.ERROR_CAMPOS_NULL, " Contenido archivo "); } else { log.info("Iniciando el proceso de firma del fichero:" + tituloFile); return getRemoteObject().prepareFirmaWithTypeFileAndFormatSign(tituloFile, typoFichero, formatoFirma, bytesToSign); } } catch (RemoteException e) { // excepcin remota log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Enva el fichero que deseamos firmar y devuelve un identificador temporal * ( No es el identificador final de la firma ). * * @param tituloFile * ( Titulo del fichero ) * @param typoFichero * ( Extension del fichero ) * @param bytesToSign * ( Byte array de los datos del fichero ) * @return Identificador asignado al proceso de firma(este indentificador * tendra validez de 10 mins). * @throws InternalException */ public String prepareFirma(String tituloFile, TypeFile typoFichero, byte[] bytesToSign) throws InternalException { // sube los datos por rmi al conector de firma1 try { if (tituloFile == null || typoFichero == null || bytesToSign == null) { if (tituloFile == null) { throw new InternalException(CodigoError.ERROR_CAMPOS_NULL, " Titulo del archivo "); } else if (typoFichero == null) { throw new InternalException(CodigoError.ERROR_CAMPOS_NULL, " Tipo de archivo "); } throw new InternalException(CodigoError.ERROR_CAMPOS_NULL, " Contenido archivo "); } else { log.info("Iniciando el proceso de firma del fichero:" + tituloFile); return getRemoteObject().prepareFirma(tituloFile, typoFichero, bytesToSign); } } catch (RemoteException e) { // excepcin remota log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Procesa el resultado de la firma para extraer los datos del usuario. * * @param httpRequest * @param httpResponse * @return Map<String, String> Con los datos de la firma. * @throws InternalException */ public Map<String, String> processResponseFirma(HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws InternalException { // recuperos el resultado de la autenticacin if (log.isDebugEnabled()) log.debug("Recuperando el resultado de la firma para :" + httpRequest.getRequestURI()); return openIdHandler.processResponseAuthentication(httpRequest, httpResponse); } /** * Envia al usurio a la pantalla de firma donde se cargara el Applet de * firma.Se firmara el documento enviado anteriormente. * * @param idFirma * temporal * @param request * @param response * @throws InternalException */ public void solicitarFirma(String idFirma, HttpServletRequest request, HttpServletResponse response) throws InternalException { solicitarFirma(idFirma, request, response, null); } /** * Envia al usurio a la pantalla de firma donde se cargara el Applet de * firma. Se firmara el documento enviado anteriormente. * * @param idFirma * @param request * @param response * @param uriRetorno * ( si es null sera autogenerada ) * @throws InternalException */ public void solicitarFirma(String idFirma, HttpServletRequest request, HttpServletResponse response, String uriRetorno) throws InternalException { // redirecciona al usuario a viafirma para que firme el documento // enviado anteriormente. // el proceso tambien se basa en el protocolo OpenID pero utilizando una // url diferente y // como identificador el idfirma // creamos la url String urlId = urlDefaultSignProvider.replace(MASK_URL_ID, idFirma); if (log.isDebugEnabled()) log.debug("URl OpenId para la firma :" + urlId); // generamos el urlId(OpenId) y redireccionamos al usuario a la url // indicada openIdHandler.firmar(urlId, requestFirmaProperties, request, response, uriRetorno); } /** * Genera una representacin de un usuario desde el map de datos recuperado. * * @param result * @return UsuarioGenericoViafirma */ public UsuarioGenericoViafirma digest(Map<String, String> result) { UsuarioGenericoViafirma usuario = new UsuarioGenericoViafirma(); return digest(result, usuario); } /** * Genera una representacin de un usuario desde el map de datos recuperado. * * @param result * @return UsuarioGenericoViafirma */ @SuppressWarnings("unchecked") private UsuarioGenericoViafirma digest(Map<String, String> result, UsuarioGenericoViafirma usuario) { usuario.setProperties(result); try { for (String key : result.keySet()) { // recupero el valor Object value = result.get(key); if (value instanceof List) { // solo tenemos en cuenta el primer valor recuperado de cada // tipo. value = ((List) value).get(0); } // si es un String lo asignamos if (value instanceof String) { if (TypeRequest.OIDS.getAlias().equals(key)) { usuario.getProperties().put(key, (String) value); } else { BeanUtils.copyProperty(usuario, key, value); } } else { log.warn("Ignorando el valor " + key + "= " + value); } } } catch (Exception e) { log.error("No se puede generar el usuario." + e.getMessage()); } return usuario; } /** * Genera una representacin del resultado de firma desde el map de datos * recuperado desde OpenID. * * @param result * @return FirmaInfoViafirma */ @SuppressWarnings("unchecked") public FirmaInfoViafirma digestFirma(Map<String, String> result) { FirmaInfoViafirma firma = new FirmaInfoViafirma(); // Recuperamos la posible informacin del firmante. digest(result, firma); // Procesamos el resto de parametros relacionados con la firma. firma.setProperties(result); try { for (String key : result.keySet()) { // recupero el valor Object value = result.get(key); if (value instanceof List) { // solo tenemos en cuenta el primer valor recuperado de cada // tipo. value = ((List) value).get(0); } // si es un String lo asignamos if (value instanceof String) { if (TypeRequest.OIDS.getAlias().equals(key)) { firma.getProperties().put(key, (String) value); } else { BeanUtils.copyProperty(firma, key, value); } } else { log.warn("Ignorando el valor " + key + "= " + value); } } } catch (Exception e) { log.error("No se puede generar el usuario." + e.getMessage()); } return firma; } /** * Firma los datos utilizando un certificado almacenado en el servidor. Para * la utilizacion de este metodo es necesario tener un certificado de * usuario dentro del Cacert de Java. Nota: Este mtodo no requiere * intervencion del usuario. * * @param datosToSign * datos a firmar * @param alias * Nombre del alias utilizado para realizar la firma. * @return El cdigo de firma asignado a este documento firmado. * @throws InternalException * Problemas al realizar la firma o al conectar con el servidor. */ public String signByServer(byte[] datosToSign, String alias, String password) throws InternalException { // sube los datos por rmi al conector de firma1 try { if (datosToSign.length < this.tamanyoMaximoDocumento) { return getRemoteObject().signByServer(datosToSign, alias, password); } else { // excepcin remota log.error( "No se puede preparar la firma. El archivo supera el tamao maximo permitido por el servidor"); throw new InternalException(CodigoError.ERROR_EXCEDIDO_TAMANYO_MAXIMO_POR_ARCHIVO, CodigoError.ERROR_EXCEDIDO_TAMANYO_MAXIMO_POR_ARCHIVO.getMensaje()); } } catch (RemoteException e) { // excepcin remota log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Firma los datos utilizando un certificado almacenado en el servidor. Para * la utilizacion de este metodo es necesario tener un certificado de * usuario dentro del Cacert de Java. Nota: Este mtodo no requiere * intervencion del usuario. * * @param datosToSign * datos a firmar * @param alias * Nombre del alias utilizado para realizar la firma. * @param type * Tipo de firma realizada en servidor * @return El cdigo de firma asignado a este documento firmado. * @throws InternalException * Problemas al realizar la firma o al conectar con el servidor. */ @Deprecated public String signByServerWithType(byte[] datosToSign, String alias, String password, TypeFormatSign type) throws InternalException { // sube los datos por rmi al conector de firma1 try { if (datosToSign.length < this.tamanyoMaximoDocumento) { return getRemoteObject().signByServerWithType(datosToSign, alias, password, type); } else { // excepcin remota log.error( "No se puede preparar la firma. El archivo supera el tamao maximo permitido por el servidor"); throw new InternalException(CodigoError.ERROR_EXCEDIDO_TAMANYO_MAXIMO_POR_ARCHIVO, CodigoError.ERROR_EXCEDIDO_TAMANYO_MAXIMO_POR_ARCHIVO.getMensaje()); } } catch (RemoteException e) { // excepcin remota log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Firma los datos utilizando un certificado almacenado en el servidor. Para * la utilizacion de este metodo es necesario tener un certificado de * usuario dentro del Cacert de Java. Nota: Este mtodo no requiere * intervencion del usuario. * * @param nombredocumento nombre del documento original * @param datosToSign datos a firmar * @param alias Nombre del alias utilizado para realizar la firma. * @param password clave del certificado utilizado. * @param tipofirma Tipo de firma realizada en servidor * @param tipoFichero Tipo de formato del fichero firmado. * @return El cdigo de firma asignado a este documento firmado. * @throws InternalException * Problemas al realizar la firma o al conectar con el servidor. */ public String signByServerWithTypeFileAndFormatSign(String nombredocumento, byte[] datosToSign, String alias, String password, TypeFile tipoFichero, TypeFormatSign tipofirma) throws InternalException { // sube los datos por rmi al conector de firma1 try { if (datosToSign.length < this.tamanyoMaximoDocumento) { return getRemoteObject().signByServerWithTypeFileAndFormatSign(nombredocumento, datosToSign, alias, password, tipoFichero, tipofirma); } else { // excepcin remota log.error( "No se puede preparar la firma. El archivo supera el tamao maximo permitido por el servidor"); throw new InternalException(CodigoError.ERROR_EXCEDIDO_TAMANYO_MAXIMO_POR_ARCHIVO, CodigoError.ERROR_EXCEDIDO_TAMANYO_MAXIMO_POR_ARCHIVO.getMensaje()); } } catch (RemoteException e) { // excepcin remota log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Retorna una imagen png con el cdigo de barras y QR code del documento * custodiado. * * @param codFirma * cdigo de firma del documento. * @return imagen png * @throws InternalException * Problemas al realizar la firma o al conectar con el servidor. */ public byte[] buildInfoQRBarCode(String codFirma) throws InternalException { try { // conectamos con el servidor para recuperar el png return getRemoteObject().buildInfoQRBarCode(codFirma); } catch (RemoteException e) { // excepcin remota log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Retorna el document originalo que ha sido firmado. * * @param codFirma * @return byte array del documento. * @throws InternalException */ public byte[] getDocumentoCustodiado(String codFirma) throws InternalException { try { // return getRemoteObject().getDocumentoCustodiado(codFirma); } catch (RemoteException e) { // log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Permite el envo de emails firmados digitalmente. Necesita tambien un * certificado de usuario dentro del Cacerts de Java. * * @param Subject * Asunto del mensaje * @param mailTo * Destinatario * @param texto * texto del mensaje a enviar * @param textoHtml * Texto en formato html del mensaje (optativo) * @param alias * Alias del certificado utilizado en la firma * @param password * Password del certificado utilizado en la firma * @return El proceso de firma se ha realizado correctamente. * @throws RemoteException * Problemas al enviar el email firmado. */ public boolean sendSignMailByServer(String subject, String mailTo, String texto, String htmlTexto, String alias, String password) throws InternalException { try { // return getRemoteObject().sendSignMailByServer(subject, mailTo, texto, htmlTexto, alias, password); } catch (RemoteException e) { // log.error("No se puede preparar la firma " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Devuelve un XMLSignature asociado al idenficidador de firma indicado. * * @param codFirma * @return String con el documento en XML. * @throws InternalException */ public String getXMLDocument(String codFirma) throws InternalException { try { return getRemoteObject().getXMLDocument(codFirma); } catch (RemoteException e) { log.error("No se puede recuperar el XMLSig " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Chequea la validez del documento original indicado. Los datos deben * corresponder a los datos que inicialmente se enviaron para su firma a la * plataforma, Viafirma en primer lugar comprueba que el hash de los bytes * indicados coinciden con el hash del documento referenciado que ha sido * custodiado, y que a su vez el documento custodiado es vlido. En el caso * de que el documento sea un XAdes, comprueba que el documento XML ( que ya * contiene la firma ) es vlido. * * @param originalData * @param id * @return FirmaInfoViafirma * @throws InternalException * @throws RemoteException */ public FirmaInfoViafirma checkOrignalDocumentSigned(byte[] originalData, String id) throws InternalException { try { // return getRemoteObject().checkOrignalDocumentSigned(originalData, id); } catch (RemoteException e) { // log.error("No se puede recuperar el XMLSig " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Chequea la validez del documento. Los datos deben corresponder a los * datos que inicialmente se enviaron para su firma a la plataforma, * Viafirma en primer lugar comprueba que el hash de los bytes indicados * coinciden con el hash del documento referenciado que ha sido custodiado, * y que a su vez el documento custodiado es vlido. En el caso de que el * documento sea un XAdes, comprueba que el documento XML ( que ya contiene * la firma ) es vlido. * * @param originalData * @param id * @return * @throws InternalException * @throws RemoteException */ public FirmaInfoViafirma checkDocumentSigned(byte[] originalData, String id) throws InternalException { try { // return getRemoteObject().checkOrignalDocumentSigned(originalData, id); } catch (RemoteException e) { // log.error("No se puede recuperar el XMLSig " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Activa la multifirma para el documento actual. * @param idFirma * @return */ public String enabledMultiSign(String idFirma) throws InternalException { try { return getRemoteObject().enabledMultiSign(idFirma); } catch (RemoteException e) { // log.error("No se puede activar la multifirma para el documetno:" + idFirma + " " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * Desactiva la multifirma para el documento indicado. * @param idFirma * @throws InternalException */ @WebMethod public void disabledMultiSign(String idFirma) throws InternalException { try { getRemoteObject().disabledMultiSign(idFirma); } catch (RemoteException e) { // log.error("No se puede activar la multifirma para el documetno:" + idFirma + " " + e.getMessage(), e); throw new InternalException(CodigoError.ERROR_PROTOCOLO_FIRMA, e.getMessage(), e); } } /** * * Valida si un documento esta correctamente firmado * @throws InternalException * */ public boolean checkSignedDocumentValidity(byte[] signedDocument) throws InternalException { try { return getRemoteObject().checkSignedDocumentValidity(signedDocument); } catch (RemoteException e) { throw new InternalException(CodigoError.ERROR_VALIDANDO_FIRMA, "Error interno al validar el XML"); } } /** * Crea una instancia del cliente. * * @param openIdHandler * Handler utilizado para el manejo del protocolo OpenId cuando * deseamos realizar * @param clienteRMI2 * @param urlDefaultAuthenticationProvider * Url del proveedor de autenticacin por defecto * @param urlDefaultSignProvider * Url del proveedor de firma utilizado por defecto * @param requestProperties * Conjunto de propiedades que se solicitaran(ej email,nif, * nombre,etc) * @param requestFirmaProperties * */ ViafirmaClient(long tamanyoMaximoDocumento, OpenIdHandler openIdHandler, String urlRMI, String urlDefaultAuthenticationProvider, String urlDefaultSignProvider, Set<String> requestProperties, Set<String> requestFirmaProperties) { this.openIdHandler = openIdHandler; this.requestAutenticationProperties = requestProperties; this.requestFirmaProperties = requestFirmaProperties; this.urlDefaultAuthenticationProvider = urlDefaultAuthenticationProvider; this.urlDefaultSignProvider = urlDefaultSignProvider; this.urlRMI = urlRMI; this.tamanyoMaximoDocumento = tamanyoMaximoDocumento; } // *************************************** // Atributos internos // *************************************** /** * Manejador del protocolo OpenId utilizado. */ private OpenIdHandler openIdHandler; /** * Conjunto de propiedades que se solicitaran. */ private Set<String> requestAutenticationProperties; /** * Conjunto de propiedades que se solicitan al firmar un documento. */ private Set<String> requestFirmaProperties; /** * Tamao maximo permitido por documento en bytes. */ private long tamanyoMaximoDocumento; /** * Mascara utilizada sobre PARAMETER_URL_DEFAULT_AUTHENTICATION_PROVIDER * para contruir la url del usuario. Su valor #ID# sera remplazado el el * identificador del usuario. */ public final static String MASK_URL_ID = "#ID#"; /** * Url del proveedor de autenticacin(Openid) utilizado por defecto. Su * valor se toma al inicial la aplicacin del parametro * URL_DEFAULT_AUTHENTICATION_PROVIDER y es utilizado al iniciar la * aplicacin. ej: http://www.viafirma.org/pip/#ID# o * http://#ID#.viafirma.org */ private String urlDefaultAuthenticationProvider; /** * Instancia remota utilizada para el envio de fichero usando RMI. * * private FirmaClienteRMI clienteRMI; */ /** * Url del proveedor de firma(basado enOpenid) utilizado por defecto. Su * valor se toma al inicial la aplicacin del parametro * URL_DEFAULT_SIGN_PROVIDER y es utilizado al iniciar la aplicacin. ej: * http://www.viafirma.org/sign/#ID# */ private String urlDefaultSignProvider; /** * Url del objeto RMI al que se conecta la aplicacin. */ String urlRMI; public FirmaClienteRMI getRemoteObject() { try { if (urlRMI.startsWith("rmi")) { if (log.isDebugEnabled()) log.debug("Recuperando el cliente rmi desde: " + urlRMI); return (FirmaClienteRMI) java.rmi.Naming.lookup(urlRMI); } else if (urlRMI.startsWith("http")) { if (log.isDebugEnabled()) log.debug("Recuperando el cliente WS desde: " + urlRMI); // QName qNamePort=new // QName("http://viafirma.org/client/","clientPort"); QName qNameService = new QName("http://viafirma.org/client", "ConectorFirmaRMIService"); URL wsdl = new URL(urlRMI + "?wsdl"); Service service = Service.create(wsdl, qNameService); FirmaClienteRMI clienteProxy = service.getPort(FirmaClienteRMI.class); // probando la conexin web service. // utilizamos el conector WebServices. // Service serviceModel = new // ObjectServiceFactory().create(FirmaClienteRMI.class); // serviceModel.setProperty(SoapConstants.MTOM_ENABLED, "true"); // recuperamos la interfaz webservice. // return (FirmaClienteRMI) new // XFireProxyFactory().create(serviceModel, urlRMI); return clienteProxy; } else { throw new ExceptionInInitializerError( "Protocolo no soportado para '" + Constantes.PARAM_URL_CONECTOR_FIRMA_RMI + "'= " + urlRMI); } } catch (MalformedURLException e) { throw new ExceptionInInitializerError("La url indicada en '" + Constantes.PARAM_URL_CONECTOR_FIRMA_RMI + "'= " + urlRMI + " no es correcta." + e.getMessage()); } catch (RemoteException e) { throw new ExceptionInInitializerError("Error al conectar con '" + Constantes.PARAM_URL_CONECTOR_FIRMA_RMI + "'= " + urlRMI + " ," + e.getMessage()); } catch (NotBoundException e) { throw new ExceptionInInitializerError("Error al conectar con '" + Constantes.PARAM_URL_CONECTOR_FIRMA_RMI + "'= " + urlRMI + " ," + e.getMessage()); } } /** * Sistema de log */ private static Log log = LogFactory.getLog(ViafirmaClient.class); /** * * Get del tamao maximo del archivo para poder controlarlo desde el * controler */ public long getTamanyoMaximoDocumento() { return tamanyoMaximoDocumento; } }