jsse

16:38:14.966 INFO  jd.cli.Main - Decompiling jsse.jar
package javax.net;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.SocketException;

public abstract class ServerSocketFactory
{
  private static ServerSocketFactory theFactory;
  
  public static ServerSocketFactory getDefault()
  {
    synchronized (ServerSocketFactory.class)
    {
      if (theFactory == null) {
        theFactory = new DefaultServerSocketFactory();
      }
    }
    return theFactory;
  }
  
  public ServerSocket createServerSocket()
    throws IOException
  {
    throw new SocketException("Unbound server sockets not implemented");
  }
  
  public abstract ServerSocket createServerSocket(int paramInt)
    throws IOException;
  
  public abstract ServerSocket createServerSocket(int paramInt1, int paramInt2)
    throws IOException;
  
  public abstract ServerSocket createServerSocket(int paramInt1, int paramInt2, InetAddress paramInetAddress)
    throws IOException;
}

/* Location:
 * Qualified Name:     javax.net.ServerSocketFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;

class DefaultServerSocketFactory
  extends ServerSocketFactory
{
  public ServerSocket createServerSocket()
    throws IOException
  {
    return new ServerSocket();
  }
  
  public ServerSocket createServerSocket(int paramInt)
    throws IOException
  {
    return new ServerSocket(paramInt);
  }
  
  public ServerSocket createServerSocket(int paramInt1, int paramInt2)
    throws IOException
  {
    return new ServerSocket(paramInt1, paramInt2);
  }
  
  public ServerSocket createServerSocket(int paramInt1, int paramInt2, InetAddress paramInetAddress)
    throws IOException
  {
    return new ServerSocket(paramInt1, paramInt2, paramInetAddress);
  }
}

/* Location:
 * Qualified Name:     javax.net.DefaultServerSocketFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net;

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;

public abstract class SocketFactory
{
  private static SocketFactory theFactory;
  
  public static SocketFactory getDefault()
  {
    synchronized (SocketFactory.class)
    {
      if (theFactory == null) {
        theFactory = new DefaultSocketFactory();
      }
    }
    return theFactory;
  }
  
  public Socket createSocket()
    throws IOException
  {
    UnsupportedOperationException localUnsupportedOperationException = new UnsupportedOperationException();
    SocketException localSocketException = new SocketException("Unconnected sockets not implemented");
    localSocketException.initCause(localUnsupportedOperationException);
    throw localSocketException;
  }
  
  public abstract Socket createSocket(String paramString, int paramInt)
    throws IOException, UnknownHostException;
  
  public abstract Socket createSocket(String paramString, int paramInt1, InetAddress paramInetAddress, int paramInt2)
    throws IOException, UnknownHostException;
  
  public abstract Socket createSocket(InetAddress paramInetAddress, int paramInt)
    throws IOException;
  
  public abstract Socket createSocket(InetAddress paramInetAddress1, int paramInt1, InetAddress paramInetAddress2, int paramInt2)
    throws IOException;
}

/* Location:
 * Qualified Name:     javax.net.SocketFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net;

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

class DefaultSocketFactory
  extends SocketFactory
{
  public Socket createSocket()
  {
    return new Socket();
  }
  
  public Socket createSocket(String paramString, int paramInt)
    throws IOException, UnknownHostException
  {
    return new Socket(paramString, paramInt);
  }
  
  public Socket createSocket(InetAddress paramInetAddress, int paramInt)
    throws IOException
  {
    return new Socket(paramInetAddress, paramInt);
  }
  
  public Socket createSocket(String paramString, int paramInt1, InetAddress paramInetAddress, int paramInt2)
    throws IOException, UnknownHostException
  {
    return new Socket(paramString, paramInt1, paramInetAddress, paramInt2);
  }
  
  public Socket createSocket(InetAddress paramInetAddress1, int paramInt1, InetAddress paramInetAddress2, int paramInt2)
    throws IOException
  {
    return new Socket(paramInetAddress1, paramInt1, paramInetAddress2, paramInt2);
  }
}

/* Location:
 * Qualified Name:     javax.net.DefaultSocketFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.cert.CertPathParameters;

public class CertPathTrustManagerParameters
  implements ManagerFactoryParameters
{
  private final CertPathParameters parameters;
  
  public CertPathTrustManagerParameters(CertPathParameters paramCertPathParameters)
  {
    parameters = ((CertPathParameters)paramCertPathParameters.clone());
  }
  
  public CertPathParameters getParameters()
  {
    return (CertPathParameters)parameters.clone();
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.CertPathTrustManagerParameters
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

public abstract interface ManagerFactoryParameters {}

/* Location:
 * Qualified Name:     javax.net.ssl.ManagerFactoryParameters
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.Principal;
import java.security.cert.Certificate;
import java.util.EventObject;

public class HandshakeCompletedEvent
  extends EventObject
{
  private static final long serialVersionUID = 7914963744257769778L;
  private transient SSLSession session;
  
  public HandshakeCompletedEvent(SSLSocket paramSSLSocket, SSLSession paramSSLSession)
  {
    super(paramSSLSocket);
    session = paramSSLSession;
  }
  
  public SSLSession getSession()
  {
    return session;
  }
  
  public String getCipherSuite()
  {
    return session.getCipherSuite();
  }
  
  public Certificate[] getLocalCertificates()
  {
    return session.getLocalCertificates();
  }
  
  public Certificate[] getPeerCertificates()
    throws SSLPeerUnverifiedException
  {
    return session.getPeerCertificates();
  }
  
  public javax.security.cert.X509Certificate[] getPeerCertificateChain()
    throws SSLPeerUnverifiedException
  {
    return session.getPeerCertificateChain();
  }
  
  public Principal getPeerPrincipal()
    throws SSLPeerUnverifiedException
  {
    Object localObject;
    try
    {
      localObject = session.getPeerPrincipal();
    }
    catch (AbstractMethodError localAbstractMethodError)
    {
      Certificate[] arrayOfCertificate = getPeerCertificates();
      localObject = ((java.security.cert.X509Certificate)arrayOfCertificate[0]).getSubjectX500Principal();
    }
    return (Principal)localObject;
  }
  
  public Principal getLocalPrincipal()
  {
    Object localObject;
    try
    {
      localObject = session.getLocalPrincipal();
    }
    catch (AbstractMethodError localAbstractMethodError)
    {
      localObject = null;
      Certificate[] arrayOfCertificate = getLocalCertificates();
      if (arrayOfCertificate != null) {
        localObject = ((java.security.cert.X509Certificate)arrayOfCertificate[0]).getSubjectX500Principal();
      }
    }
    return (Principal)localObject;
  }
  
  public SSLSocket getSocket()
  {
    return (SSLSocket)getSource();
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.HandshakeCompletedEvent
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.Principal;
import java.security.cert.Certificate;
import javax.security.cert.X509Certificate;

public abstract interface SSLSession
{
  public abstract byte[] getId();
  
  public abstract SSLSessionContext getSessionContext();
  
  public abstract long getCreationTime();
  
  public abstract long getLastAccessedTime();
  
  public abstract void invalidate();
  
  public abstract boolean isValid();
  
  public abstract void putValue(String paramString, Object paramObject);
  
  public abstract Object getValue(String paramString);
  
  public abstract void removeValue(String paramString);
  
  public abstract String[] getValueNames();
  
  public abstract Certificate[] getPeerCertificates()
    throws SSLPeerUnverifiedException;
  
  public abstract Certificate[] getLocalCertificates();
  
  public abstract X509Certificate[] getPeerCertificateChain()
    throws SSLPeerUnverifiedException;
  
  public abstract Principal getPeerPrincipal()
    throws SSLPeerUnverifiedException;
  
  public abstract Principal getLocalPrincipal();
  
  public abstract String getCipherSuite();
  
  public abstract String getProtocol();
  
  public abstract String getPeerHost();
  
  public abstract int getPeerPort();
  
  public abstract int getPacketBufferSize();
  
  public abstract int getApplicationBufferSize();
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLSession
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public abstract class SSLSocket
  extends Socket
{
  protected SSLSocket() {}
  
  protected SSLSocket(String paramString, int paramInt)
    throws IOException, UnknownHostException
  {
    super(paramString, paramInt);
  }
  
  protected SSLSocket(InetAddress paramInetAddress, int paramInt)
    throws IOException
  {
    super(paramInetAddress, paramInt);
  }
  
  protected SSLSocket(String paramString, int paramInt1, InetAddress paramInetAddress, int paramInt2)
    throws IOException, UnknownHostException
  {
    super(paramString, paramInt1, paramInetAddress, paramInt2);
  }
  
  protected SSLSocket(InetAddress paramInetAddress1, int paramInt1, InetAddress paramInetAddress2, int paramInt2)
    throws IOException
  {
    super(paramInetAddress1, paramInt1, paramInetAddress2, paramInt2);
  }
  
  public abstract String[] getSupportedCipherSuites();
  
  public abstract String[] getEnabledCipherSuites();
  
  public abstract void setEnabledCipherSuites(String[] paramArrayOfString);
  
  public abstract String[] getSupportedProtocols();
  
  public abstract String[] getEnabledProtocols();
  
  public abstract void setEnabledProtocols(String[] paramArrayOfString);
  
  public abstract SSLSession getSession();
  
  public abstract void addHandshakeCompletedListener(HandshakeCompletedListener paramHandshakeCompletedListener);
  
  public abstract void removeHandshakeCompletedListener(HandshakeCompletedListener paramHandshakeCompletedListener);
  
  public abstract void startHandshake()
    throws IOException;
  
  public abstract void setUseClientMode(boolean paramBoolean);
  
  public abstract boolean getUseClientMode();
  
  public abstract void setNeedClientAuth(boolean paramBoolean);
  
  public abstract boolean getNeedClientAuth();
  
  public abstract void setWantClientAuth(boolean paramBoolean);
  
  public abstract boolean getWantClientAuth();
  
  public abstract void setEnableSessionCreation(boolean paramBoolean);
  
  public abstract boolean getEnableSessionCreation();
  
  public SSLParameters getSSLParameters()
  {
    SSLParameters localSSLParameters = new SSLParameters();
    localSSLParameters.setCipherSuites(getEnabledCipherSuites());
    localSSLParameters.setProtocols(getEnabledProtocols());
    if (getNeedClientAuth()) {
      localSSLParameters.setNeedClientAuth(true);
    } else if (getWantClientAuth()) {
      localSSLParameters.setWantClientAuth(true);
    }
    return localSSLParameters;
  }
  
  public void setSSLParameters(SSLParameters paramSSLParameters)
  {
    String[] arrayOfString = paramSSLParameters.getCipherSuites();
    if (arrayOfString != null) {
      setEnabledCipherSuites(arrayOfString);
    }
    arrayOfString = paramSSLParameters.getProtocols();
    if (arrayOfString != null) {
      setEnabledProtocols(arrayOfString);
    }
    if (paramSSLParameters.getNeedClientAuth()) {
      setNeedClientAuth(true);
    } else if (paramSSLParameters.getWantClientAuth()) {
      setWantClientAuth(true);
    } else {
      setWantClientAuth(false);
    }
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLSocket
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.io.IOException;

public class SSLException
  extends IOException
{
  private static final long serialVersionUID = 4511006460650708967L;
  
  public SSLException(String paramString)
  {
    super(paramString);
  }
  
  public SSLException(String paramString, Throwable paramThrowable)
  {
    super(paramString);
    initCause(paramThrowable);
  }
  
  public SSLException(Throwable paramThrowable)
  {
    super(paramThrowable == null ? null : paramThrowable.toString());
    initCause(paramThrowable);
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLException
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.util.Enumeration;

public abstract interface SSLSessionContext
{
  public abstract SSLSession getSession(byte[] paramArrayOfByte);
  
  public abstract Enumeration<byte[]> getIds();
  
  public abstract void setSessionTimeout(int paramInt)
    throws IllegalArgumentException;
  
  public abstract int getSessionTimeout();
  
  public abstract void setSessionCacheSize(int paramInt)
    throws IllegalArgumentException;
  
  public abstract int getSessionCacheSize();
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLSessionContext
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.util.EventListener;

public abstract interface HandshakeCompletedListener
  extends EventListener
{
  public abstract void handshakeCompleted(HandshakeCompletedEvent paramHandshakeCompletedEvent);
}

/* Location:
 * Qualified Name:     javax.net.ssl.HandshakeCompletedListener
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

public class SSLParameters
{
  private String[] cipherSuites;
  private String[] protocols;
  private boolean wantClientAuth;
  private boolean needClientAuth;
  
  public SSLParameters() {}
  
  public SSLParameters(String[] paramArrayOfString)
  {
    setCipherSuites(paramArrayOfString);
  }
  
  public SSLParameters(String[] paramArrayOfString1, String[] paramArrayOfString2)
  {
    setCipherSuites(paramArrayOfString1);
    setProtocols(paramArrayOfString2);
  }
  
  private static String[] clone(String[] paramArrayOfString)
  {
    return paramArrayOfString == null ? null : (String[])paramArrayOfString.clone();
  }
  
  public String[] getCipherSuites()
  {
    return clone(cipherSuites);
  }
  
  public void setCipherSuites(String[] paramArrayOfString)
  {
    cipherSuites = clone(paramArrayOfString);
  }
  
  public String[] getProtocols()
  {
    return clone(protocols);
  }
  
  public void setProtocols(String[] paramArrayOfString)
  {
    protocols = clone(paramArrayOfString);
  }
  
  public boolean getWantClientAuth()
  {
    return wantClientAuth;
  }
  
  public void setWantClientAuth(boolean paramBoolean)
  {
    wantClientAuth = paramBoolean;
    needClientAuth = false;
  }
  
  public boolean getNeedClientAuth()
  {
    return needClientAuth;
  }
  
  public void setNeedClientAuth(boolean paramBoolean)
  {
    wantClientAuth = false;
    needClientAuth = paramBoolean;
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLParameters
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

public abstract interface HostnameVerifier
{
  public abstract boolean verify(String paramString, SSLSession paramSSLSession);
}

/* Location:
 * Qualified Name:     javax.net.ssl.HostnameVerifier
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

class HttpsURLConnection$DefaultHostnameVerifier
  implements HostnameVerifier
{
  public boolean verify(String paramString, SSLSession paramSSLSession)
  {
    return false;
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.HttpsURLConnection.DefaultHostnameVerifier
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

class HttpsURLConnection$1 {}

/* Location:
 * Qualified Name:     javax.net.ssl.HttpsURLConnection.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.net.HttpURLConnection;
import java.net.URL;
import java.security.Principal;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import sun.net.www.protocol.https.DefaultHostnameVerifier;

public abstract class HttpsURLConnection
  extends HttpURLConnection
{
  private static HostnameVerifier defaultHostnameVerifier;
  protected HostnameVerifier hostnameVerifier = defaultHostnameVerifier;
  private static SSLSocketFactory defaultSSLSocketFactory = null;
  private SSLSocketFactory sslSocketFactory = getDefaultSSLSocketFactory();
  
  protected HttpsURLConnection(URL paramURL)
  {
    super(paramURL);
  }
  
  public abstract String getCipherSuite();
  
  public abstract Certificate[] getLocalCertificates();
  
  public abstract Certificate[] getServerCertificates()
    throws SSLPeerUnverifiedException;
  
  public Principal getPeerPrincipal()
    throws SSLPeerUnverifiedException
  {
    Certificate[] arrayOfCertificate = getServerCertificates();
    return ((X509Certificate)arrayOfCertificate[0]).getSubjectX500Principal();
  }
  
  public Principal getLocalPrincipal()
  {
    Certificate[] arrayOfCertificate = getLocalCertificates();
    if (arrayOfCertificate != null) {
      return ((X509Certificate)arrayOfCertificate[0]).getSubjectX500Principal();
    }
    return null;
  }
  
  public static void setDefaultHostnameVerifier(HostnameVerifier paramHostnameVerifier)
  {
    if (paramHostnameVerifier == null) {
      throw new IllegalArgumentException("no default HostnameVerifier specified");
    }
    SecurityManager localSecurityManager = System.getSecurityManager();
    if (localSecurityManager != null) {
      localSecurityManager.checkPermission(new SSLPermission("setHostnameVerifier"));
    }
    defaultHostnameVerifier = paramHostnameVerifier;
  }
  
  public static HostnameVerifier getDefaultHostnameVerifier()
  {
    return defaultHostnameVerifier;
  }
  
  public void setHostnameVerifier(HostnameVerifier paramHostnameVerifier)
  {
    if (paramHostnameVerifier == null) {
      throw new IllegalArgumentException("no HostnameVerifier specified");
    }
    hostnameVerifier = paramHostnameVerifier;
  }
  
  public HostnameVerifier getHostnameVerifier()
  {
    return hostnameVerifier;
  }
  
  public static void setDefaultSSLSocketFactory(SSLSocketFactory paramSSLSocketFactory)
  {
    if (paramSSLSocketFactory == null) {
      throw new IllegalArgumentException("no default SSLSocketFactory specified");
    }
    SecurityManager localSecurityManager = System.getSecurityManager();
    if (localSecurityManager != null) {
      localSecurityManager.checkSetFactory();
    }
    defaultSSLSocketFactory = paramSSLSocketFactory;
  }
  
  public static SSLSocketFactory getDefaultSSLSocketFactory()
  {
    if (defaultSSLSocketFactory == null) {
      defaultSSLSocketFactory = (SSLSocketFactory)SSLSocketFactory.getDefault();
    }
    return defaultSSLSocketFactory;
  }
  
  public void setSSLSocketFactory(SSLSocketFactory paramSSLSocketFactory)
  {
    if (paramSSLSocketFactory == null) {
      throw new IllegalArgumentException("no SSLSocketFactory specified");
    }
    SecurityManager localSecurityManager = System.getSecurityManager();
    if (localSecurityManager != null) {
      localSecurityManager.checkSetFactory();
    }
    sslSocketFactory = paramSSLSocketFactory;
  }
  
  public SSLSocketFactory getSSLSocketFactory()
  {
    return sslSocketFactory;
  }
  
  static
  {
    try
    {
      defaultHostnameVerifier = new DefaultHostnameVerifier();
    }
    catch (NoClassDefFoundError localNoClassDefFoundError)
    {
      defaultHostnameVerifier = new DefaultHostnameVerifier(null);
    }
  }
  
  private static class DefaultHostnameVerifier
    implements HostnameVerifier
  {
    public boolean verify(String paramString, SSLSession paramSSLSession)
    {
      return false;
    }
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.HttpsURLConnection
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.PrivilegedAction;
import java.security.Security;

final class SSLSocketFactory$1
  implements PrivilegedAction<String>
{
  SSLSocketFactory$1(String paramString) {}
  
  public String run()
  {
    String str = Security.getProperty(val$name);
    if (str != null)
    {
      str = str.trim();
      if (str.length() == 0) {
        str = null;
      }
    }
    return str;
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLSocketFactory.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.security.AccessController;
import java.security.NoSuchAlgorithmException;
import java.security.PrivilegedAction;
import java.security.Security;
import javax.net.SocketFactory;
import sun.security.action.GetPropertyAction;

public abstract class SSLSocketFactory
  extends SocketFactory
{
  private static SSLSocketFactory theFactory;
  private static boolean propertyChecked;
  static final boolean DEBUG;
  
  private static void log(String paramString)
  {
    if (DEBUG) {
      System.out.println(paramString);
    }
  }
  
  public static synchronized SocketFactory getDefault()
  {
    if (theFactory != null) {
      return theFactory;
    }
    if (!propertyChecked)
    {
      propertyChecked = true;
      String str = getSecurityProperty("ssl.SocketFactory.provider");
      if (str != null)
      {
        log("setting up default SSLSocketFactory");
        try
        {
          Class localClass = null;
          try
          {
            localClass = Class.forName(str);
          }
          catch (ClassNotFoundException localClassNotFoundException)
          {
            ClassLoader localClassLoader = ClassLoader.getSystemClassLoader();
            if (localClassLoader != null) {
              localClass = localClassLoader.loadClass(str);
            }
          }
          log("class " + str + " is loaded");
          SSLSocketFactory localSSLSocketFactory = (SSLSocketFactory)localClass.newInstance();
          log("instantiated an instance of class " + str);
          theFactory = localSSLSocketFactory;
          return localSSLSocketFactory;
        }
        catch (Exception localException)
        {
          log("SSLSocketFactory instantiation failed: " + localException.toString());
          theFactory = new DefaultSSLSocketFactory(localException);
          return theFactory;
        }
      }
    }
    try
    {
      return SSLContext.getDefault().getSocketFactory();
    }
    catch (NoSuchAlgorithmException localNoSuchAlgorithmException)
    {
      return new DefaultSSLSocketFactory(localNoSuchAlgorithmException);
    }
  }
  
  static String getSecurityProperty(String paramString)
  {
    (String)AccessController.doPrivileged(new PrivilegedAction()
    {
      public String run()
      {
        String str = Security.getProperty(val$name);
        if (str != null)
        {
          str = str.trim();
          if (str.length() == 0) {
            str = null;
          }
        }
        return str;
      }
    });
  }
  
  public abstract String[] getDefaultCipherSuites();
  
  public abstract String[] getSupportedCipherSuites();
  
  public abstract Socket createSocket(Socket paramSocket, String paramString, int paramInt, boolean paramBoolean)
    throws IOException;
  
  static
  {
    String str = ((String)AccessController.doPrivileged(new GetPropertyAction("javax.net.debug", ""))).toLowerCase();
    DEBUG = (str.contains("all")) || (str.contains("ssl"));
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLSocketFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

public abstract interface KeyManager {}

/* Location:
 * Qualified Name:     javax.net.ssl.KeyManager
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.PrivilegedAction;
import java.security.Security;

final class KeyManagerFactory$1
  implements PrivilegedAction
{
  public Object run()
  {
    return Security.getProperty("ssl.KeyManagerFactory.algorithm");
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.KeyManagerFactory.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.AccessController;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivilegedAction;
import java.security.Provider;
import java.security.Security;
import java.security.UnrecoverableKeyException;
import sun.security.jca.GetInstance;
import sun.security.jca.GetInstance.Instance;

public class KeyManagerFactory
{
  private Provider provider;
  private KeyManagerFactorySpi factorySpi;
  private String algorithm;
  
  public static final String getDefaultAlgorithm()
  {
    String str = (String)AccessController.doPrivileged(new PrivilegedAction()
    {
      public Object run()
      {
        return Security.getProperty("ssl.KeyManagerFactory.algorithm");
      }
    });
    if (str == null) {
      str = "SunX509";
    }
    return str;
  }
  
  protected KeyManagerFactory(KeyManagerFactorySpi paramKeyManagerFactorySpi, Provider paramProvider, String paramString)
  {
    factorySpi = paramKeyManagerFactorySpi;
    provider = paramProvider;
    algorithm = paramString;
  }
  
  public final String getAlgorithm()
  {
    return algorithm;
  }
  
  public static final KeyManagerFactory getInstance(String paramString)
    throws NoSuchAlgorithmException
  {
    GetInstance.Instance localInstance = GetInstance.getInstance("KeyManagerFactory", KeyManagerFactorySpi.class, paramString);
    return new KeyManagerFactory((KeyManagerFactorySpi)impl, provider, paramString);
  }
  
  public static final KeyManagerFactory getInstance(String paramString1, String paramString2)
    throws NoSuchAlgorithmException, NoSuchProviderException
  {
    GetInstance.Instance localInstance = GetInstance.getInstance("KeyManagerFactory", KeyManagerFactorySpi.class, paramString1, paramString2);
    return new KeyManagerFactory((KeyManagerFactorySpi)impl, provider, paramString1);
  }
  
  public static final KeyManagerFactory getInstance(String paramString, Provider paramProvider)
    throws NoSuchAlgorithmException
  {
    GetInstance.Instance localInstance = GetInstance.getInstance("KeyManagerFactory", KeyManagerFactorySpi.class, paramString, paramProvider);
    return new KeyManagerFactory((KeyManagerFactorySpi)impl, provider, paramString);
  }
  
  public final Provider getProvider()
  {
    return provider;
  }
  
  public final void init(KeyStore paramKeyStore, char[] paramArrayOfChar)
    throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException
  {
    factorySpi.engineInit(paramKeyStore, paramArrayOfChar);
  }
  
  public final void init(ManagerFactoryParameters paramManagerFactoryParameters)
    throws InvalidAlgorithmParameterException
  {
    factorySpi.engineInit(paramManagerFactoryParameters);
  }
  
  public final KeyManager[] getKeyManagers()
  {
    return factorySpi.engineGetKeyManagers();
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.KeyManagerFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.InvalidAlgorithmParameterException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;

public abstract class KeyManagerFactorySpi
{
  protected abstract void engineInit(KeyStore paramKeyStore, char[] paramArrayOfChar)
    throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException;
  
  protected abstract void engineInit(ManagerFactoryParameters paramManagerFactoryParameters)
    throws InvalidAlgorithmParameterException;
  
  protected abstract KeyManager[] engineGetKeyManagers();
}

/* Location:
 * Qualified Name:     javax.net.ssl.KeyManagerFactorySpi
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.KeyStore.Builder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class KeyStoreBuilderParameters
  implements ManagerFactoryParameters
{
  private final List<KeyStore.Builder> parameters;
  
  public KeyStoreBuilderParameters(KeyStore.Builder paramBuilder)
  {
    parameters = Collections.singletonList(paramBuilder);
  }
  
  public KeyStoreBuilderParameters(List<KeyStore.Builder> paramList)
  {
    parameters = Collections.unmodifiableList(new ArrayList(paramList));
    if (parameters.isEmpty()) {
      throw new IllegalArgumentException();
    }
  }
  
  public List<KeyStore.Builder> getParameters()
  {
    return parameters;
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.KeyStoreBuilderParameters
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Provider;
import java.security.SecureRandom;
import sun.security.jca.GetInstance;
import sun.security.jca.GetInstance.Instance;

public class SSLContext
{
  private final Provider provider;
  private final SSLContextSpi contextSpi;
  private final String protocol;
  private static SSLContext defaultContext;
  
  protected SSLContext(SSLContextSpi paramSSLContextSpi, Provider paramProvider, String paramString)
  {
    contextSpi = paramSSLContextSpi;
    provider = paramProvider;
    protocol = paramString;
  }
  
  public static synchronized SSLContext getDefault()
    throws NoSuchAlgorithmException
  {
    if (defaultContext == null) {
      defaultContext = getInstance("Default");
    }
    return defaultContext;
  }
  
  public static synchronized void setDefault(SSLContext paramSSLContext)
  {
    if (paramSSLContext == null) {
      throw new NullPointerException();
    }
    SecurityManager localSecurityManager = System.getSecurityManager();
    if (localSecurityManager != null) {
      localSecurityManager.checkPermission(new SSLPermission("setDefaultSSLContext"));
    }
    defaultContext = paramSSLContext;
  }
  
  public static SSLContext getInstance(String paramString)
    throws NoSuchAlgorithmException
  {
    GetInstance.Instance localInstance = GetInstance.getInstance("SSLContext", SSLContextSpi.class, paramString);
    return new SSLContext((SSLContextSpi)impl, provider, paramString);
  }
  
  public static SSLContext getInstance(String paramString1, String paramString2)
    throws NoSuchAlgorithmException, NoSuchProviderException
  {
    GetInstance.Instance localInstance = GetInstance.getInstance("SSLContext", SSLContextSpi.class, paramString1, paramString2);
    return new SSLContext((SSLContextSpi)impl, provider, paramString1);
  }
  
  public static SSLContext getInstance(String paramString, Provider paramProvider)
    throws NoSuchAlgorithmException
  {
    GetInstance.Instance localInstance = GetInstance.getInstance("SSLContext", SSLContextSpi.class, paramString, paramProvider);
    return new SSLContext((SSLContextSpi)impl, provider, paramString);
  }
  
  public final String getProtocol()
  {
    return protocol;
  }
  
  public final Provider getProvider()
  {
    return provider;
  }
  
  public final void init(KeyManager[] paramArrayOfKeyManager, TrustManager[] paramArrayOfTrustManager, SecureRandom paramSecureRandom)
    throws KeyManagementException
  {
    contextSpi.engineInit(paramArrayOfKeyManager, paramArrayOfTrustManager, paramSecureRandom);
  }
  
  public final SSLSocketFactory getSocketFactory()
  {
    return contextSpi.engineGetSocketFactory();
  }
  
  public final SSLServerSocketFactory getServerSocketFactory()
  {
    return contextSpi.engineGetServerSocketFactory();
  }
  
  public final SSLEngine createSSLEngine()
  {
    try
    {
      return contextSpi.engineCreateSSLEngine();
    }
    catch (AbstractMethodError localAbstractMethodError)
    {
      UnsupportedOperationException localUnsupportedOperationException = new UnsupportedOperationException("Provider: " + getProvider() + " doesn't support this operation");
      localUnsupportedOperationException.initCause(localAbstractMethodError);
      throw localUnsupportedOperationException;
    }
  }
  
  public final SSLEngine createSSLEngine(String paramString, int paramInt)
  {
    try
    {
      return contextSpi.engineCreateSSLEngine(paramString, paramInt);
    }
    catch (AbstractMethodError localAbstractMethodError)
    {
      UnsupportedOperationException localUnsupportedOperationException = new UnsupportedOperationException("Provider: " + getProvider() + " does not support this operation");
      localUnsupportedOperationException.initCause(localAbstractMethodError);
      throw localUnsupportedOperationException;
    }
  }
  
  public final SSLSessionContext getServerSessionContext()
  {
    return contextSpi.engineGetServerSessionContext();
  }
  
  public final SSLSessionContext getClientSessionContext()
  {
    return contextSpi.engineGetClientSessionContext();
  }
  
  public final SSLParameters getDefaultSSLParameters()
  {
    return contextSpi.engineGetDefaultSSLParameters();
  }
  
  public final SSLParameters getSupportedSSLParameters()
  {
    return contextSpi.engineGetSupportedSSLParameters();
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLContext
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.SecureRandom;

public abstract class SSLContextSpi
{
  protected abstract void engineInit(KeyManager[] paramArrayOfKeyManager, TrustManager[] paramArrayOfTrustManager, SecureRandom paramSecureRandom)
    throws KeyManagementException;
  
  protected abstract SSLSocketFactory engineGetSocketFactory();
  
  protected abstract SSLServerSocketFactory engineGetServerSocketFactory();
  
  protected abstract SSLEngine engineCreateSSLEngine();
  
  protected abstract SSLEngine engineCreateSSLEngine(String paramString, int paramInt);
  
  protected abstract SSLSessionContext engineGetServerSessionContext();
  
  protected abstract SSLSessionContext engineGetClientSessionContext();
  
  private SSLSocket getDefaultSocket()
  {
    try
    {
      SSLSocketFactory localSSLSocketFactory = engineGetSocketFactory();
      return (SSLSocket)localSSLSocketFactory.createSocket();
    }
    catch (IOException localIOException)
    {
      throw new UnsupportedOperationException("Could not obtain parameters", localIOException);
    }
  }
  
  protected SSLParameters engineGetDefaultSSLParameters()
  {
    SSLSocket localSSLSocket = getDefaultSocket();
    return localSSLSocket.getSSLParameters();
  }
  
  protected SSLParameters engineGetSupportedSSLParameters()
  {
    SSLSocket localSSLSocket = getDefaultSocket();
    SSLParameters localSSLParameters = new SSLParameters();
    localSSLParameters.setCipherSuites(localSSLSocket.getSupportedCipherSuites());
    localSSLParameters.setProtocols(localSSLSocket.getSupportedProtocols());
    return localSSLParameters;
  }
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLContextSpi
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

public abstract interface TrustManager {}

/* Location:
 * Qualified Name:     javax.net.ssl.TrustManager
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.io.PrintStream;
import java.security.NoSuchAlgorithmException;
import javax.net.ServerSocketFactory;

public abstract class SSLServerSocketFactory
  extends ServerSocketFactory
{
  private static SSLServerSocketFactory theFactory;
  private static boolean propertyChecked;
  
  private static void log(String paramString)
  {
    if (SSLSocketFactory.DEBUG) {
      System.out.println(paramString);
    }
  }
  
  public static synchronized ServerSocketFactory getDefault()
  {
    if (theFactory != null) {
      return theFactory;
    }
    if (!propertyChecked)
    {
      propertyChecked = true;
      String str = SSLSocketFactory.getSecurityProperty("ssl.ServerSocketFactory.provider");
      if (str != null)
      {
        log("setting up default SSLServerSocketFactory");
        try
        {
          Class localClass = null;
          try
          {
            localClass = Class.forName(str);
          }
          catch (ClassNotFoundException localClassNotFoundException)
          {
            ClassLoader localClassLoader = ClassLoader.getSystemClassLoader();
            if (localClassLoader != null) {
              localClass = localClassLoader.loadClass(str);
            }
          }
          log("class " + str + " is loaded");
          SSLServerSocketFactory localSSLServerSocketFactory = (SSLServerSocketFactory)localClass.newInstance();
          log("instantiated an instance of class " + str);
          theFactory = localSSLServerSocketFactory;
          return localSSLServerSocketFactory;
        }
        catch (Exception localException)
        {
          log("SSLServerSocketFactory instantiation failed: " + localException);
          theFactory = new DefaultSSLServerSocketFactory(localException);
          return theFactory;
        }
      }
    }
    try
    {
      return SSLContext.getDefault().getServerSocketFactory();
    }
    catch (NoSuchAlgorithmException localNoSuchAlgorithmException)
    {
      return new DefaultSSLServerSocketFactory(localNoSuchAlgorithmException);
    }
  }
  
  public abstract String[] getDefaultCipherSuites();
  
  public abstract String[] getSupportedCipherSuites();
}

/* Location:
 * Qualified Name:     javax.net.ssl.SSLServerSocketFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package javax.net.ssl;

import java.nio.ByteBuffer;

public abstract class SSLEngine
{
  private String peerHost = null;
  private int peerPort = -1;
  
  protected SSLEngine() {}
  
  protected SSLEngine(String paramString, int paramInt)
  {
    peerHost = paramString;
    peerPort = paramInt;
  }
  
  public String getPeerHost()
  {
    return peerHost;
  }
  
  public int getPeerPort()
  {
    return peerPort;
  }
  
  public SSLEngineResult wrap(ByteBuffer paramByteBuffer1, ByteBuffer paramByteBuffer2)
    throws SSLException
  {
    return wrap(new ByteBuffer[] { paramByteBuffer1 }, 0, 1, paramByteBuffer2);
  }
  
  public SSLEngineResult wrap(ByteBuffer[] paramArrayOfByteBuffer, ByteBuffer paramByteBuffer)
    throws SSLException
  {
    if (paramArrayOfByteBuffer == null) {
      throw new IllegalArgumentException("src == null");
    }
    return wrap(paramArrayOfByteBuffer, 0, paramArrayOfByteBuffer.length, paramByteBuffer);
  }
  
  public abstract SSLEngineResult wrap(ByteBuffer[] paramArrayOfByteBuffer, int paramInt1, int paramInt2, ByteBuffer paramByteBuffer)
    throws SSLException;
  
  pub
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd