SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, new TrustManager[] { tm }, null); return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose); return sslContext.getSocketFactory().createSocket();
public static void makeDGCCall ( String hostname, int port, Object payloadObject ) throws IOException, UnknownHostException, SocketException { InetSocketAddress isa = new InetSocketAddress(hostname, port); Socket s = null; DataOutputStream dos = null; try { s = SocketFactory.getDefault().createSocket(hostname, port); s.setKeepAlive(true); s.setTcpNoDelay(true); OutputStream os = s.getOutputStream(); dos = new DataOutputStream(os);
/** * Check whether the given TCP port is available. * * @param currentPort The port * @return True if it is */ public static boolean isTcpPortAvailable(int currentPort) { try { Socket socket = SocketFactory.getDefault().createSocket(InetAddress.getLocalHost(), currentPort); socket.close(); return false; } catch (Throwable e) { return true; } }
@Override protected void before() throws Throwable { Socket socket = SocketFactory.getDefault().createSocket(); try { socket.connect(new InetSocketAddress(host, port), Math.toIntExact(timeout.toMillis())); } catch (IOException e) { throw new AssumptionViolatedException( String.format("Couchbase not available on on %s:%d. Skipping tests.", host, port), e); } finally { socket.close(); } } }
public class MyServer { public static final int PORT = 12345; public static void main(String[] args) throws IOException, InterruptedException { ServerSocket ss = ServerSocketFactory.getDefault().createServerSocket(PORT); Socket s = ss.accept(); Thread.sleep(5000); ss.close(); s.close(); } } public class MyClient { public static void main(String[] args) throws IOException, InterruptedException { Socket s = SocketFactory.getDefault().createSocket("localhost", MyServer.PORT); System.out.println(" connected: " + s.isConnected()); Thread.sleep(10000); System.out.println(" connected: " + s.isConnected()); } }
return delegate.getDefaultCipherSuites(); return delegate.getSupportedCipherSuites(); return makeSocketSafe(delegate.createSocket(s, host, port, autoClose)); return makeSocketSafe(delegate.createSocket(host, port)); return makeSocketSafe(delegate.createSocket(host, port, localHost, localPort)); return makeSocketSafe(delegate.createSocket(host, port)); return makeSocketSafe(delegate.createSocket(address, port, localAddress, localPort)); if (protocols != null && protocols.length == 1 && "SSLv3".equals(protocols[0])) { return delegate.getSupportedCipherSuites(); return delegate.getEnabledCipherSuites(); delegate.bind(localAddr); delegate.close(); delegate.connect(remoteAddr);
boolean isNewSocket = false; if (socketFactory != null) { socket = socketFactory.createSocket(); } else if( socket == null ) { socket = new Socket( proxy ); isNewSocket = true; } else if( socket.isClosed() ) { throw new IOException(); socket.setTcpNoDelay( isTcpNoDelay() ); socket.setReuseAddress( isReuseAddr() ); if( !socket.isBound() ) { socket.connect( new InetSocketAddress( uri.getHost(), getPort() ), connectTimeout ); SSLContext sslContext = SSLContext.getInstance("TLSv1.2"); sslContext.init(null, null, null); SSLSocketFactory factory = sslContext.getSocketFactory(); socket = factory.createSocket(socket, uri.getHost(), getPort(), true);
public void connect(InetAddress host, int port, InetAddress localAddr, int localPort) throws IOException { socket = socketFactory.createSocket(); socket.bind(new InetSocketAddress(localAddr, localPort)); socket.connect(new InetSocketAddress(host, port), connectTimeout); onConnect(); }
SSLContext context = SSLContext.getInstance("TLS"); context.init(null, new TrustManager[] { new EasyX509TrustManager(null) }, null); return context; InetSocketAddress remoteAddress = new InetSocketAddress(host, port); SSLSocket sslsock = (SSLSocket) ((sock != null) ? sock : createSocket()); InetSocketAddress isa = new InetSocketAddress(localAddress, localPort); sslsock.bind(isa); sslsock.connect(remoteAddress, connTimeout); sslsock.setSoTimeout(soTimeout); return sslsock; return getSSLContext().getSocketFactory().createSocket(); UnknownHostException return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
SocketAddress sockaddr = new InetSocketAddress(host, port); if (factory instanceof SSLSocketFactory) { Socket tempsocket = new Socket(); tempsocket.connect(sockaddr, conTimeout*1000); socket = ((SSLSocketFactory)factory).createSocket(tempsocket, host, port, true); } else { socket = factory.createSocket(); socket.connect(sockaddr, conTimeout*1000);
localAddress = new InetSocketAddress(InetAddress.getByName(localLocation.getHost()), localLocation.getPort()); remoteAddress = new InetSocketAddress(host, remoteLocation.getPort()); socket.bind(localAddress); socket.connect(remoteAddress, connectionTimeout); } else { socket.connect(remoteAddress); socket = socketFactory.createSocket(remoteAddress.getAddress(), remoteAddress.getPort(), localAddress.getAddress(), localAddress.getPort()); } else { socket = socketFactory.createSocket(remoteAddress.getAddress(), remoteAddress.getPort());
public Socket connect() throws GeneralSecurityException, IOException { Socket socket; SocketAddress sockaddr = new InetSocketAddress(host, port); if (isSsl()) { final SSLContext sslContext = getSSLContextInstance(); final KeyManager[] keyManagers = getKeyManagers(); final TrustManager[] trustManagers = getTrustManagers(); sslContext.init(keyManagers, trustManagers, null /* use the default secure random */); javax.net.SocketFactory socketFactory = sslContext.getSocketFactory(); socket = socketFactory.createSocket(); socket.connect(sockaddr, Math.max(timeout, 0)); if (socket instanceof SSLSocket) { SSLSocket sslSocket = (SSLSocket) socket; sslSocket.setUseClientMode(true); sslSocket.setEnableSessionCreation(true); if (timeout > 0) { sslSocket.setSoTimeout(timeout); socket = new Socket(); socket.connect(sockaddr, Math.max(timeout, 0));
socket = sf.createSocket(); if (socket == null) { if (socksHost != null) { socket = new Socket( new java.net.Proxy(java.net.Proxy.Type.SOCKS, new InetSocketAddress(socksHost, socksPort))); } else if (PropUtil.getBooleanProperty(props, prefix + ".usesocketchannels", false)) { socket = SocketChannel.open().socket(); } else socket = new Socket(); socket.setSoTimeout(to); ssf = (SSLSocketFactory)sf; else ssf = (SSLSocketFactory)SSLSocketFactory.getDefault(); socket = ssf.createSocket(socket, host, port, true); sf = ssf;
SocketFactory socket_factory = SSLSocketFactory.getDefault(); SocketAddress address = new InetSocketAddress( InetAddress.getByName(hostname), port sock = socket_factory.createSocket(); sock.connect(address, SOCKET_TIMEOUT); sock.setSoTimeout(SOCKET_TIMEOUT); reader = new ReaderGuacamoleReader(new InputStreamReader(sock.getInputStream(), "UTF-8")); writer = new WriterGuacamoleWriter(new OutputStreamWriter(sock.getOutputStream(), "UTF-8"));
@Override OutputStream openNewOutputStream() throws IOException { final Socket socket = socketFactory.createSocket(); // Prevent automatic closing of the connection during periods of inactivity. socket.setKeepAlive(true); // Important not to cache `InetAddress` in case the host moved to a new IP address. socket.connect(new InetSocketAddress(InetAddress.getByName(host), port), connectionTimeoutMs); return new BufferedOutputStream(socket.getOutputStream(), sendBufferSize); } }
public static Channel openChannel ( InetSocketAddress isa ) throws IOException, SocketException { System.err.println("* Opening socket " + isa); Socket s = SocketFactory.getDefault().createSocket(isa.getAddress(), isa.getPort()); s.setKeepAlive(true); s.setTcpNoDelay(true); System.err.println("* Opening channel"); OutputStream outputStream = s.getOutputStream(); DataOutputStream dos = new DataOutputStream(outputStream); dos.writeUTF("Protocol:CLI-connect"); ExecutorService cp = Executors.newCachedThreadPool(new ThreadFactory() { public Thread newThread ( Runnable r ) { Thread t = new Thread(r, "Channel"); t.setDaemon(true); return t; } }); Channel c = new ChannelBuilder("EXPLOIT", cp).withMode(Mode.BINARY).build(s.getInputStream(), outputStream); System.err.println("* Channel open"); return c; } }
try { System.err.println("* Opening JRMP socket " + isa); s = SocketFactory.getDefault().createSocket(isa.getAddress(), isa.getPort()); s.setKeepAlive(true); s.setTcpNoDelay(true); OutputStream os = s.getOutputStream(); dos = new DataOutputStream(os);
boolean sslConnection) throws IOException { Socket socket = null; SocketAddress sockaddr = new InetSocketAddress(inetadd, port); printConfig(); try { "SSL not configured correctly, Please look at previous error"); SocketFactory sf = this.sslContext.getSocketFactory(); socket = sf.createSocket(); socket.setKeepAlive(ENABLE_TCP_KEEP_ALIVE); socket.setReceiveBufferSize(socketBufferSize); optionalWatcher.beforeConnect(socket); socket.connect(sockaddr, Math.max(timeout, 0)); configureClientSSLSocket(socket, timeout); return socket;
socket = socketFactory.createSocket(host, port); socket = new Socket(); socket.connect(new InetSocketAddress(host, port), connectionTimeout); sslSocket = (SSLSocket) ((SSLSocketFactory)socketFactory).createSocket(socket, host, port, true); sslSocket = (SSLSocket) (getDefaultSSLSocketFactory(trustAll)).createSocket(socket, host, port, true); sslSocket.setEnabledProtocols(values); sslSocket.setSSLParameters(sslParams);
SSLSocketFactory factory = m_ctx.getSocketFactory(); SSLSocket ss = (SSLSocket)factory.createSocket(s, host, port, autoClose); SSLSocketFactory factory = m_ctx.getSocketFactory(); SSLSocket ss = (SSLSocket)factory.createSocket(address, port, localAddress, localPort); SSLSocketFactory factory = m_ctx.getSocketFactory(); SSLSocket ss = (SSLSocket)factory.createSocket(host, port, localHost, localPort); ss.setEnabledProtocols(m_protocols); SSLSocketFactory factory = m_ctx.getSocketFactory(); SSLSocket ss = (SSLSocket)factory.createSocket(host, port); ss.setEnabledProtocols(m_protocols); SSLSocketFactory factory = m_ctx.getSocketFactory(); SSLSocket ss = (SSLSocket)factory.createSocket(host, port); ss.setEnabledProtocols(m_protocols); SSLSocketFactory factory = m_ctx.getSocketFactory(); socket = (SSLSocket)factory.createSocket(); availableProtocols = socket.getSupportedProtocols(); socket.close();