@Override protected void onSecured(LocalSocket socket) throws IOException { LeakyBufferedInputStream leakyIn = new LeakyBufferedInputStream( socket.getInputStream(), SENSING_BUFFER_SIZE); if (mHandlers.isEmpty()) { throw new IllegalStateException("No handlers added"); } for (int i = 0, N = mHandlers.size(); i < N; i++) { HandlerInfo handlerInfo = mHandlers.get(i); leakyIn.mark(SENSING_BUFFER_SIZE); boolean matches = handlerInfo.magicMatcher.matches(leakyIn); leakyIn.reset(); if (matches) { SocketLike socketLike = new SocketLike(socket, leakyIn); handlerInfo.handler.onAccepted(socketLike); return; } } throw new IOException("No matching handler, firstByte=" + leakyIn.read()); }
@Override public void run() { try { DataInputStream input = new DataInputStream(socket.getInputStream()); DataOutputStream output = new DataOutputStream(socket.getOutputStream()); try { handle(input, output); } finally { try { input.close(); } catch (IOException ignore) { } try { output.close(); } catch (IOException ignore) { } } } catch (IOException e) { if (Log.isLoggable(Logging.LOG_TAG, Log.VERBOSE)) { Log.v(Logging.LOG_TAG, "Fatal error receiving messages", e); } } }
@Override public void run() { try { mSocketHandler.onAccepted(mSocket); } catch (IOException ex) { LogUtil.w("I/O error: %s", ex); } finally { try { mSocket.close(); } catch (IOException ignore) { } } } }
@Override public void close() { try { if (localSocket.getFileDescriptor() != null) { // close the streams to interrupt pending read and writes localSocket.shutdownInput(); localSocket.shutdownOutput(); } localSocket.close(); } catch (IOException e) { // what could we do? throw new RuntimeException(e); } } }
public void connect() throws IOException { localSocket.connect(new LocalSocketAddress(LOCAL_ABSTRACT_NAME)); readClientId(localSocket.getInputStream()); }
try { LocalSocket sender = new LocalSocket(); sender.connect(new LocalSocketAddress("MyAddress")); String data = "Hello world!"; Log.d("SENT DATA", data); sender.getOutputStream().write(data.getBytes()); sender.getOutputStream().close(); sender.close(); } catch (IOException ex) { Log.wtf("IOEXCEPTION", ex); }
localSocketSend = new LocalSocket(); localSocketSend.connect(new LocalSocketAddress(socketName)); localSocketRecv = localServerSocket.accept(); this.originalSocket = original; LocalProxyWorker lpw1 = new LocalProxyWorker(localSocketRecv.getInputStream(), originalSocket.getOutputStream(), "to"); LocalProxyWorker lpw2 = new LocalProxyWorker(originalSocket.getInputStream(), localSocketRecv.getOutputStream(), "from"); Thread t1 = new Thread(lpw1); Thread t2 = new Thread(lpw2); FileDescriptor fd = localSocketSend.getFileDescriptor(); SocketImpl socketImpl = (SocketImpl) Class.forName("java.net.PlainSocketImpl").getConstructor(FileDescriptor.class).newInstance(fd); Field implField = this.getClass().getSuperclass().getDeclaredField("impl"); super.close(); originalSocket.close(); localSocketRecv.close(); LOG.debug("LocalProxySocket", "close() called", new Throwable()); public String toString() { LOG.debug("LocalProxySocket", "toString() called", new Throwable()); return "LocalProxySocket : " + super.toString() + " - " + originalSocket.toString() + " - " + localSocketSend.toString(); LOG.debug("LocalProxySocket", "shutdownInput() called", new Throwable()); originalSocket.shutdownInput(); localSocketRecv.shutdownInput(); LOG.debug("LocalProxySocket", "shutdownOutput() called", new Throwable());
receiver = new LocalSocket(); try { localServerSocket = new LocalServerSocket("<your_socket_addr>"); receiver.connect(new LocalSocketAddress("<your_socket_addr>")); receiver.setReceiveBufferSize(4096); receiver.setSendBufferSize(4096); sender = localServerSocket.accept(); sender.setReceiveBufferSize(4096); sender.setSendBufferSize(4096); } catch (IOException e1) { throw new IOException("Can't create local socket !"); setOutputFile(sender.getFileDescriptor()); out = receiver.getInputStream(); } catch (IOException e) { try { localServerSocket.close(); sender.close(); receiver.close();
@Override public void run() { try { socketHandler.handle(socket.getInputStream(), socket.getOutputStream()); } catch (IOException e) { Log.e(LOG_TAG, "Worker thread error", e); } finally { try { socket.close(); } catch (IOException e) { Log.w(LOG_TAG, "Unable to close socket"); } } } }
protected void createSockets() throws IOException { final String LOCAL_ADDR = "net.majorkernelpanic.streaming-"; for (int i=0;i<10;i++) { try { mSocketId = new Random().nextInt(); mLss = new LocalServerSocket(LOCAL_ADDR+mSocketId); break; } catch (IOException e1) {} } mReceiver = new LocalSocket(); mReceiver.connect( new LocalSocketAddress(LOCAL_ADDR+mSocketId)); mReceiver.setReceiveBufferSize(500000); mReceiver.setSoTimeout(3000); mSender = mLss.accept(); mSender.setSendBufferSize(500000); }
mMediaRecorder.setOutputFile(mSender.getFileDescriptor()); mPacketizer.setInputStream(mReceiver.getInputStream()); mPacketizer.start(); mStreaming = true;
// Create a MediaRecorder MediaRecorder mr = new MediaRecorder(); // (Initialize mr as usual) // Create a LocalServerSocket LocalServerSocket lss = new LocalServerSocket("foobar"); // Connect both end of this socket LocalSocket sender = lss.accept(); LocalSocket receiver = new LocalSocket(); receiver.connect(new LocalSocketAddress("foobar")); // Set the output of the MediaRecorder to the sender socket file descriptor mr.setOutputFile(sender.getFileDescriptor()); // Start the video recording: mr.start(); // Launch a background thread that will loop, // reading from the receiver socket, // and creating a RTP packet out of read data. RtpSocket rtpSocket = new RtpSocket(); InputStream in = receiver.getInputStream(); while(true) { fis.read(buffer, ...); // Here some data manipulation on the received buffer ... RtpPacket rtp = new RtpPacket(buffer, ...); rtpSocket.send(rtpPacket); }
public OutputStream getOutput() throws IOException { return mSocket.getOutputStream(); } }
try (LocalSocket outputSocket = new LocalSocket()) { outputSocket.connect(new LocalSocketAddress(this.outputSocketAddress)); try (PrintWriter writer = new PrintWriter(outputSocket.getOutputStream())) {
LocalSocket ls = new LocalSocket(); ls.connect(serverSocket.getLocalSocketAddress()); ls.close(); } catch (IOException e) { Log.e(TAG, "stopSocketServer failed", e);
public boolean openManagementInterface(@NonNull Context c) { // Could take a while to open connection int tries = 8; String socketName = (c.getCacheDir().getAbsolutePath() + "/" + "mgmtsocket"); // The mServerSocketLocal is transferred to the LocalServerSocket, ignore warning LocalSocket mServerSocketLocal = new LocalSocket(); while (tries > 0 && !mServerSocketLocal.isBound()) { try { mServerSocketLocal.bind(new LocalSocketAddress(socketName, LocalSocketAddress.Namespace.FILESYSTEM)); } catch (IOException e) { // wait 300 ms before retrying try { Thread.sleep(300); } catch (InterruptedException ignored) { } } tries--; } try { mServerSocket = new LocalServerSocket(mServerSocketLocal.getFileDescriptor()); return true; } catch (IOException e) { VpnStatus.logException(e); } return false; }
InputStream instream = mSocket.getInputStream(); FileDescriptor[] fds = null; try { fds = mSocket.getAncillaryFileDescriptors(); } catch (IOException e) { VpnStatus.logException("Error reading fds from socket", e);
try { socketName = new File(context.getFilesDir(), "socket").getAbsolutePath(); ls = new LocalSocket(); ls.bind(new LocalSocketAddress(socketName, LocalSocketAddress.Namespace.FILESYSTEM)); serverSocket = new LocalServerSocket(ls.getFileDescriptor()); socketName = "unix:" + socketName; log(socketName);
/** * @throws IOException * @throws UnsupportedOperationException always */ DomainSocket(String name) throws IOException { mLocalSocket = new LocalSocket(); mLocalSocket.connect(new LocalSocketAddress(name)); }
mLocalServer = new LocalServerSocket(LOCAL_SOCKET_ADDRESS); mLocalReceiver = new LocalSocket(); mLocalReceiver.connect(new LocalSocketAddress(LOCAL_SOCKET_ADDRESS)); mLocalSender = mLocalServer.accept(); if (mLocalReceiver != null) { mInputStream = mLocalReceiver.getInputStream(); }