tests/DumpRenderTree2/src/com/android/dumprendertree2/forwarder/Forwarder.java

   1 /*
   2  * Copyright (C) 2010 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.dumprendertree2.forwarder;
  18
  19 import android.util.Log;
  20
  21 import java.io.IOException;
  22 import java.net.ServerSocket;
  23 import java.net.Socket;
  24 import java.util.HashSet;
  25 import java.util.Set;
  26
  27 /**
  28  * A port forwarding server. Listens on localhost on specified port and forwards the tcp
  29  * communications to external socket via adb networking proxy.
  30  */
  31 public class Forwarder extends Thread {
  32     private static final String LOG_TAG = "Forwarder";
  33
  34     private int mPort;
  35     private String mRemoteMachineIpAddress;
  36
  37     private ServerSocket mServerSocket;
  38
  39     private Set<ConnectionHandler> mConnectionHandlers = new HashSet<ConnectionHandler>();
  40
  41     public Forwarder(int port, String remoteMachineIpAddress) {
  42         mPort = port;
  43         mRemoteMachineIpAddress = remoteMachineIpAddress;
  44     }
  45
  46     @Override
  47     public void start() {
  48         Log.i(LOG_TAG, "start(): Starting fowarder on port: " + mPort);
  49
  50         try {
  51             mServerSocket = new ServerSocket(mPort);
  52         } catch (IOException e) {
  53             Log.e(LOG_TAG, "mPort=" + mPort, e);
  54             return;
  55         }
  56
  57         super.start();
  58     }
  59
  60     @Override
  61     public void run() {
  62         while (true) {
  63             Socket localSocket;
  64             try {
  65                 localSocket = mServerSocket.accept();
  66             } catch (IOException e) {
  67                 /** This most likely means that mServerSocket is already closed */
  68                 Log.w(LOG_TAG, "mPort=" + mPort, e);
  69                 break;
  70             }
  71
  72             Socket remoteSocket = null;
  73             final ConnectionHandler connectionHandler;
  74             try {
  75                 remoteSocket = AdbUtils.createSocket();
  76                 connectionHandler = new ConnectionHandler(
  77                         mRemoteMachineIpAddress, mPort, localSocket, remoteSocket);
  78             } catch (IOException exception) {
  79                 try {
  80                     localSocket.close();
  81                 } catch (IOException e) {
  82                     Log.e(LOG_TAG, "mPort=" + mPort, e);
  83                 }
  84                 if (remoteSocket != null) {
  85                     try {
  86                         remoteSocket.close();
  87                     } catch (IOException e) {
  88                         Log.e(LOG_TAG, "mPort=" + mPort, e);
  89                     }
  90                 }
  91                 continue;
  92             }
  93
  94             /**
  95              * We have to close the sockets after the ConnectionHandler finishes, so we
  96              * don't get "Too may open files" exception. We also remove the ConnectionHandler
  97              * from the collection to avoid memory issues.
  98              * */
  99             ConnectionHandler.OnFinishedCallback callback =
 100                     new ConnectionHandler.OnFinishedCallback() {
 101                 @Override
 102                 public void onFinished() {
 103                     synchronized (this) {
 104                         if (!mConnectionHandlers.remove(connectionHandler)) {
 105                             assert false : "removeConnectionHandler(): not in the collection";
 106                         }
 107                     }
 108                 }
 109             };
 110             connectionHandler.registerOnConnectionHandlerFinishedCallback(callback);
 111
 112             synchronized (this) {
 113                 mConnectionHandlers.add(connectionHandler);
 114             }
 115             connectionHandler.start();
 116         }
 117
 118         synchronized (this) {
 119             for (ConnectionHandler connectionHandler : mConnectionHandlers) {
 120                 connectionHandler.stop();
 121             }
 122         }
 123     }
 124
 125     public void finish() {
 126         try {
 127             mServerSocket.close();
 128         } catch (IOException e) {
 129             Log.e(LOG_TAG, "mPort=" + mPort, e);
 130         }
 131     }
 132 }