Novos WS da NFCe para a Sefaz do RS - inutilização e cancelamento não conectam

JavaC Membro Membro desde: 12/11/2011 11:14:27 Mensagens: 68 Offline

Fala galera, a sefaz do RS andou alterando a estrutura dos WS da NFe, CTe, NFCe e MDFe, a NFe somente troquei os links para os novos WS e todos serviços funcionaram. Porém a NFCe apenas funcionou o de Autorização, sendo que o de cancelamento e inutilização não estão funcionando, sempre me retorna o erro Connection Reset...
Até tentei gerar as classes do WS novamente porém acontece o mesmo erro.
Os novos WS agora são separados dos WS da NFe, tendo um pra NFe e outro pra NFCe (antes eram os 2 juntos). Pelo que consta no site da sefaz, os novos endereços são:

Alguém enfrentou o mesmo problema ou sabe como resolver?

JavaC Membro Membro desde: 12/11/2011 11:14:27 Mensagens: 68 Offline

...

JavaC Membro Membro desde: 12/11/2011 11:14:27 Mensagens: 68 Offline

Galera resolvido o problema, a solução está nesse post:
http://www.guj.com.br/43008-erro-ocasional-ao-transmitir-nfce-nos-novos-webservices-da-sefaz-do-rs---connection-reset

basicamente o que foi feito é trocar o método de conexão dentro do socket factory, de "TLS" para "TLSv1".
Segue minha classe de socket factory.

import java.io.FileInputStream;  
import java.io.IOException;  
import java.net.InetAddress;  
import java.net.InetSocketAddress;  
import java.net.Socket;  
import java.net.SocketAddress;  
import java.net.UnknownHostException;  
import java.security.KeyManagementException;  
import java.security.KeyStore;  
import java.security.KeyStoreException;  
import java.security.NoSuchAlgorithmException;  
import java.security.Principal;  
import java.security.PrivateKey;  
import java.security.cert.CertificateException;  
import java.security.cert.X509Certificate;  
  
import javax.net.SocketFactory;  
import javax.net.ssl.KeyManager;  
import javax.net.ssl.SSLContext;  
import javax.net.ssl.TrustManager;  
import javax.net.ssl.TrustManagerFactory;  
import javax.net.ssl.X509KeyManager;  
import org.apache.commons.httpclient.params.HttpConnectionParams;  
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;  
  
public class SocketFactoryDinamico implements ProtocolSocketFactory {  
    private SSLContext ssl = null;  
    private X509Certificate certificate;  
    private PrivateKey privateKey;
  
    public SocketFactoryDinamico(X509Certificate certificate,  
            PrivateKey privateKey) {  
        this.certificate = certificate;  
        this.privateKey = privateKey;  
    }  
  
    private SSLContext createSSLContext() {  
        try {  
            KeyManager[] keyManagers = createKeyManagers();  
            TrustManager[] trustManagers = createTrustManagers();  
            SSLContext sslContext = SSLContext.getInstance("TLSv1");
            sslContext.init(keyManagers, trustManagers, null);  
  
            return sslContext;  
        } catch (KeyManagementException | KeyStoreException | NoSuchAlgorithmException | CertificateException | IOException e) {
            throw new RuntimeException(e);
        }
    }  
  
    private SSLContext getSSLContext() {  
        if (ssl == null) {  
            ssl = createSSLContext();  
        }  
        return ssl;  
    }  
  
    public Socket createSocket(String host, int port, InetAddress localAddress,  
            int localPort, HttpConnectionParams params){
        Socket socket=null;
        try{
            if (params == null) {  
                throw new IllegalArgumentException("Parameters may not be null");  
            }
            int timeout = params.getConnectionTimeout();
            SocketFactory socketfactory = getSSLContext().getSocketFactory();
            if (timeout == 0) {  
                return socketfactory.createSocket(host, port, localAddress,  
                        localPort);  
            }

socket = socketfactory.createSocket();
            SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);  
            SocketAddress remoteaddr = new InetSocketAddress(host, port);  
            socket.bind(localaddr);
            socket.connect(remoteaddr, timeout);
        }catch(Exception e){
            throw new RuntimeException(e);
        }
  
        return socket;  
    }  
  
    public Socket createSocket(String host, int port, InetAddress clientHost,  
            int clientPort) throws IOException, UnknownHostException {  
        return getSSLContext().getSocketFactory().createSocket(host, port,  
                clientHost, clientPort);  
    }  
  
    public Socket createSocket(String host, int port) throws IOException,  
            UnknownHostException {  
        return getSSLContext().getSocketFactory().createSocket(host, port);  
    }  
  
    public Socket createSocket(Socket socket, String host, int port,  
            boolean autoClose) throws IOException, UnknownHostException {  
        return getSSLContext().getSocketFactory().createSocket(socket, host,  
                port, autoClose);  
    }  
  
    public KeyManager[] createKeyManagers() {  
        HSKeyManager keyManager = new HSKeyManager(certificate, privateKey);  
  
        return new KeyManager[] { keyManager };  
    }  
  
    public TrustManager[] createTrustManagers() throws KeyStoreException,  
            NoSuchAlgorithmException, CertificateException, IOException {  
        KeyStore trustStore = KeyStore.getInstance("JKS");  
  
        trustStore.load(SocketFactoryDinamico.class.getResourceAsStream("/br/com/atualy/nfce/webservices/NFeCacerts"), "changeit".toCharArray());
        TrustManagerFactory trustManagerFactory = TrustManagerFactory  
                .getInstance(TrustManagerFactory.getDefaultAlgorithm());  
        trustManagerFactory.init(trustStore);
        return trustManagerFactory.getTrustManagers();  
    }  
  
    class HSKeyManager implements X509KeyManager {  
  
        private X509Certificate certificate;  
        private PrivateKey privateKey;  
  
        public HSKeyManager(X509Certificate certificate, PrivateKey privateKey) {  
            this.certificate = certificate;  
            this.privateKey = privateKey;  
        }  
  
        public String chooseClientAlias(String[] arg0, Principal[] arg1,  
                Socket arg2) {  
            return certificate.getIssuerDN().getName();  
        }  
  
        public String chooseServerAlias(String arg0, Principal[] arg1,  
                Socket arg2) {  
            return null;  
        }  
  
        public X509Certificate[] getCertificateChain(String arg0) {  
            return new X509Certificate[] { certificate };  
        }  
  
        public String[] getClientAliases(String arg0, Principal[] arg1) {  
            return new String[] { certificate.getIssuerDN().getName() };  
        }  
  
        public PrivateKey getPrivateKey(String arg0) {  
            return privateKey;  
        }  
  
        public String[] getServerAliases(String arg0, Principal[] arg1) {  
            return null;  
        }  
    }
  
}