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); }
@Override public void run() { while(true) { try { final LocalSocket socket = localServerSocket.accept(); final WorkerThread workerThread = new WorkerThread(socket, socketHandler); workerThread.setName("SuasUnixSocket " + threadId.incrementAndGet()); workerThread.setDaemon(true); workerThread.start(); } catch (IOException e) { Log.e(LOG_TAG, "Server thread error", e); e.printStackTrace(); break; } } }
@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) { LogUtil.d("Matches!" + handlerInfo.handler.getClass().getSimpleName()); SocketLike socketLike = new SocketLike(socket, leakyIn); handlerInfo.handler.onAccepted(socketLike); return; } } throw new IOException("No matching handler, firstByte=" + leakyIn.read()); }
private static void enforcePermission(Context context, LocalSocket peer) throws IOException, PeerAuthorizationException { Credentials credentials = peer.getPeerCredentials(); int uid = credentials.getUid(); int pid = credentials.getPid(); if (LogUtil.isLoggable(Log.VERBOSE)) { LogUtil.v("Got request from uid=%d, pid=%d", uid, pid); } String requiredPermission = Manifest.permission.DUMP; int checkResult = context.checkPermission(requiredPermission, pid, uid); if (checkResult != PackageManager.PERMISSION_GRANTED) { throw new PeerAuthorizationException( "Peer pid=" + pid + ", uid=" + uid + " does not have " + requiredPermission); } }
@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()); }
private static void write(final LocalSocket socket) { new Thread() { @Override public void run() { super.run(); try { final int VERSION = 2; BufferedOutputStream outputStream = new BufferedOutputStream(socket.getOutputStream()); while (true) { Bitmap bitmap = screenshot(); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); bitmap.compress(Bitmap.CompressFormat.JPEG, 60, byteArrayOutputStream); outputStream.write(2); writeInt(outputStream, byteArrayOutputStream.size()); outputStream.write(byteArrayOutputStream.toByteArray()); outputStream.flush(); } } catch (Exception e) { e.printStackTrace(); } } }.start(); }
public void init() { try { localLoop = new LocalServerSocket("videoserver"); localReceiver = new LocalSocket(); localReceiver.connect(localLoop.getLocalSocketAddress()); localReceiver.setReceiveBufferSize(LOCAL_BUFF_SIZE); localReceiver.setSendBufferSize(LOCAL_BUFF_SIZE); localSender = localLoop.accept(); localSender.setReceiveBufferSize(LOCAL_BUFF_SIZE); localSender.setSendBufferSize(LOCAL_BUFF_SIZE); Log.d(LOG_TAG, "Done: init()"); }catch(IOException e) { Log.e(LOG_TAG, "Error in initializing local socket: " + e); } }
/** * Sends data to the socket. * * @param data Data to send. Data size is defined by the length of the * array. * @throws IOException */ public void send(byte[] data) throws IOException { // Use local copy of the socket, ensuring it's not going to NULL while // we're working with it. If it gets closed, while we're in the middle // of data transfer - it's OK, since it will produce an exception, and // the caller will gracefully handle it. // // Same technique is used everywhere in this class where mSocket member // is touched. LocalSocket socket = mSocket; if (socket == null) { Logw("'send' request on closed Socket " + mChannelName); throw new ClosedChannelException(); } socket.getOutputStream().write(data); }
/** * Closes the socket. * * @return true if socket has been closed in this call, or false if it had * been already closed when this method has been called. */ public boolean close() { // This is the only place in this class where we will null the socket // object. Since this method can be called concurrently from different // threads, lets do this under the lock. LocalSocket socket; synchronized (this) { socket = mSocket; mSocket = null; } if (socket != null) { try { // Force all I/O to stop before closing the socket. socket.shutdownInput(); socket.shutdownOutput(); socket.close(); if (DEBUG) Log.d(TAG, "Socket is closed for " + mChannelName); return true; } catch (IOException e) { Loge("Exception " + e + " while closing Socket for " + mChannelName); } } return false; }
private void processRequestsUntilStopped(LocalSocket fdrecv, ReadableByteChannel status, Writer control) throws IOException, InterruptedException { FdReq fileOps; while ((fileOps = intake.take()) != FdReq.STOP) { FdResp response = null; try { try { response = sendFdRequest(fileOps, control, status, fdrecv); if (!responses.offer(response, IO_TIMEOUT, TimeUnit.MILLISECONDS)) FdCompat.closeDescriptor(response.fd); } catch (IOException ioe) { responses.offer(new FdResp(fileOps, ioe.getMessage(), null), IO_TIMEOUT, TimeUnit.MILLISECONDS); throw ioe; } } catch (InterruptedException ie) { if (response != null) FdCompat.closeDescriptor(response.fd); throw ie; } } }
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(1000000); mReceiver.setSoTimeout(3000); mSender = mLss.accept(); mSender.setSendBufferSize(1000000); }
protected void createSockets() throws IOException { final String LOCAL_ADDR = "edu.ucsb.cs.capstone.letmypeoplecode.smartrover.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); }
@Test(timeout = 1000) public void simplestGet() throws IOException, InterruptedException { // given Service service = startService(); // when LocalSocket clientSocket = new LocalSocket(); clientSocket.connect(new LocalSocketAddress("doesn't matter now")); OutputStream os = clientSocket.getOutputStream(); os.write(GET_1.getBytes()); os.close(); // then InputStream is = clientSocket.getInputStream(); String response = IOUtils.toString(is); System.out.println("response: " + response); String expectedBody = new Test1().test(); assertThat(response, containsString(expectedBody)); }
@Test(timeout = 1000) public void simplestPost() throws IOException, InterruptedException { // given Service service = startService(); // when LocalSocket clientSocket = new LocalSocket(); clientSocket.connect(new LocalSocketAddress("doesn't matter now")); OutputStream os = clientSocket.getOutputStream(); os.write(POST_1.getBytes()); os.close(); // then InputStream is = clientSocket.getInputStream(); String response = IOUtils.toString(is); System.out.println("response: " + response); String expectedBody = new TestPost().post(11, "somename"); assertThat(response, containsString(expectedBody)); }
@Test(timeout = 1000) public void shouldParseLongGetRequests() throws IOException { // given Service service = startService(); // when LocalSocket clientSocket = new LocalSocket(); clientSocket.connect(new LocalSocketAddress("doesn't matter now")); OutputStream os = clientSocket.getOutputStream(); os.write(GET_LONG_1.getBytes()); // two long requests os.write(GET_LONG_1.getBytes()); os.close(); // then InputStream is = clientSocket.getInputStream(); String response = IOUtils.toString(is); System.out.println("response: " + response); String expectedBody = new Test1().test(); assertThat(response, containsString(expectedBody)); }
@Test(timeout = 1000) public void headersShouldBeDecoded() throws IOException { // given Service service = new Service(); service.onCreate(); service.onStartCommand(new Intent(), 0, 0); // when LocalSocket clientSocket = new LocalSocket(); clientSocket.connect(new LocalSocketAddress("doesn't matter now")); OutputStream os = clientSocket.getOutputStream(); os.write(GET_1.getBytes()); os.close(); // then InputStream is = clientSocket.getInputStream(); String response = IOUtils.toString(is); System.out.println("response: " + response); assertThat(response, containsString("localhost")); assertThat(response, containsString("b=2")); assertThat(response, containsString("a=1")); }
@Test(timeout = 1000) public void cookieShouldBeReturned() throws IOException, InterruptedException { // given Service service = new Service(); service.onCreate(); service.onStartCommand(new Intent(), 0, 0); // when LocalSocket clientSocket = new LocalSocket(); clientSocket.connect(new LocalSocketAddress("doesn't matter now")); OutputStream os = clientSocket.getOutputStream(); os.write(GET_1.getBytes()); os.close(); // then InputStream is = clientSocket.getInputStream(); String response = IOUtils.toString(is); System.out.println("response: " + response); String expectedBody = "Set-Cookie: COOKIE_NAME=cookieValuecookieValue"; assertThat(response, containsString(expectedBody)); }
@Test(timeout = 1000) public void cookieShouldBeAccepted() throws IOException, InterruptedException { // given Service service = new Service(); service.onCreate(); service.onStartCommand(new Intent(), 0, 0); // when LocalSocket clientSocket = new LocalSocket(); clientSocket.connect(new LocalSocketAddress("doesn't matter now")); OutputStream os = clientSocket.getOutputStream(); os.write(GET_2.getBytes()); os.close(); // then InputStream is = clientSocket.getInputStream(); String response = IOUtils.toString(is); System.out.println("response: " + response); String expectedBody = "cookieValuecookieValue"; assertThat(response, containsString(expectedBody)); }
public LocalProxySocket(Socket original) throws TorException { super(); try { // Prepare LocalSocket which will be used to trick the SSLSocket (or any other one) localSocketSend = new LocalSocket(); // Local socket name String socketName = "local" + UUID.randomUUID(); localServerSocket = new LocalServerSocket(socketName); localSocketSend.connect(new LocalSocketAddress(socketName)); localSocketRecv = localServerSocket.accept(); this.originalSocket = original; // Create 2 Threads which are taking care of the communication between the LocalSocket and the original Socket 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); t1.start(); t2.start(); // Prepare this Socket to contain the FileDescriptor of the LocalSocket FileDescriptor fd = localSocketSend.getFileDescriptor(); SocketImpl socketImpl = (SocketImpl) Class.forName("java.net.PlainSocketImpl").getConstructor(FileDescriptor.class).newInstance(fd); Field implField = this.getClass().getSuperclass().getDeclaredField("impl"); implField.setAccessible(true); implField.set(this, socketImpl); } catch (Exception e) { LOG.debug("Got Exception while trying to create LocalProxySocket", e); throw new TorException("could not create LocalProxySocket", e); } }
protected void createSockets() throws IOException { if (sPipeApi == PIPE_API_LS) { final String LOCAL_ADDR = "com.galuu.ev3videocontrol.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); } else { Log.e(TAG, "parcelFileDescriptors createPipe version = Lollipop"); mParcelFileDescriptors = ParcelFileDescriptor.createPipe(); mParcelRead = new ParcelFileDescriptor(mParcelFileDescriptors[0]); mParcelWrite = new ParcelFileDescriptor(mParcelFileDescriptors[1]); } }
public SocketSession(String name, LocalSocket socket, SocketBinder binder) throws IOException { mName = name; mSocket = socket; mBinder = binder; mInputStream = new DataInputStream(mSocket.getInputStream()); mOutputStream = new DataOutputStream(mSocket.getOutputStream()); mBinder.setLocalSocket(socket); }
public SocketLike(LocalSocket socket, LeakyBufferedInputStream leakyInput) { OutputStream temp = null; try { temp = socket.getOutputStream(); } catch (IOException e) { e.printStackTrace(); } outputStream = temp; mLeakyInput = leakyInput; }
@Override public final void onAccepted(LocalSocket socket) throws IOException { try { enforcePermission(mContext, socket); onSecured(socket); } catch (PeerAuthorizationException e) { LogUtil.e("Unauthorized request: " + e.getMessage()); } }
private void listenOnAddress(String address) throws IOException { mServerSocket = bindToSocket(address); LogUtil.i("Listening on @" + address); while (!Thread.interrupted()) { try { // Use previously accepted socket the first time around, otherwise wait to // accept another. LocalSocket socket = mServerSocket.accept(); // Start worker thread Thread t = new WorkerThread(socket, mSocketHandler); t.setName( WORKER_THREAD_NAME_PREFIX + "-" + mFriendlyName + "-" + mThreadId.incrementAndGet()); t.setDaemon(true); t.start(); } catch (SocketException se) { // ignore exception if interrupting the thread if (Thread.interrupted()) { break; } LogUtil.w(se, "I/O error"); } catch (InterruptedIOException ex) { break; } catch (IOException e) { LogUtil.w(e, "I/O error initialising connection thread"); break; } } LogUtil.i("Server shutdown on @" + address); }
protected void createSockets() throws IOException { if (sPipeApi == PIPE_API_LS) { 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); } else { Log.e(TAG, "parcelFileDescriptors createPipe version = Lollipop"); mParcelFileDescriptors = ParcelFileDescriptor.createPipe(); mParcelRead = new ParcelFileDescriptor(mParcelFileDescriptors[0]); mParcelWrite = new ParcelFileDescriptor(mParcelFileDescriptors[1]); } }
/** * Wakes I/O looper waiting on connection with the emulator. * * @param socket Server socket waiting on connection. */ private void wakeIOLooper(LocalServerSocket socket) { // We wake the looper by connecting to the socket. LocalSocket waker = new LocalSocket(); try { waker.connect(socket.getLocalSocketAddress()); } catch (IOException e) { Loge("Exception " + e + " in SdkControllerConnection while waking up the I/O looper."); } }
/** * Loops on the local socket, handling emulator connection attempts. */ private void runIOLooper() { if (DEBUG) Log.d(TAG, "In SdkControllerConnection I/O looper."); do { try { // Create non-blocking server socket that would listen for connections, // and bind it to the given port on the local host. mServerSocket = new LocalServerSocket(SDK_CONTROLLER_PORT); LocalServerSocket socket = mServerSocket; while (socket != null) { final LocalSocket sk = socket.accept(); if (mServerSocket != null) { onAccept(sk); } else { break; } socket = mServerSocket; } } catch (IOException e) { Loge("Exception " + e + "SdkControllerConnection I/O looper."); } if (DEBUG) Log.d(TAG, "Exiting SdkControllerConnection I/O looper."); // If we're exiting the internal loop for reasons other than an explicit // disconnect request, we should reconnect again. } while (disconnect()); }
/** * Sends data to the socket. * * @param data Data to send. * @param offset The start position in data from where to get bytes. * @param len The number of bytes from data to write to this socket. * @throws IOException */ public void send(byte[] data, int offset, int len) throws IOException { LocalSocket socket = mSocket; if (socket == null) { Logw("'send' request on closed Socket " + mChannelName); throw new ClosedChannelException(); } socket.getOutputStream().write(data, offset, len); }
