* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements.  See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

  public static final int MAX_STACK_DEPTH = 256;

  public static final long MAX_TERMINATE_WAIT_MILLIS = 10000;

  private Socket        m_socket;

  private DProtocol      m_protocol;

  private DManager      m_manager;

  private IDebuggerCallbacks  m_debuggerCallbacks;

  private Process        m_process;

  private Map<String, Object> m_prefs; // WARNING -- accessed from multiple threads

  private static final String  s_newline = System.getProperty("line.separator"); //$NON-NLS-1$

  private volatile boolean m_isConnected; // WARNING -- accessed from multiple threads

  private volatile boolean m_isHalted; // WARNING -- accessed from multiple threads

  private volatile boolean m_incoming; // WARNING -- accessed from multiple threads

  private volatile boolean m_lastResponse;  // whether there was a reponse from the last message to the Player

  private volatile HashMap<Integer, PlayerSessionIsolateStatus> m_isolateStatus = new HashMap<Integer, PlayerSessionIsolateStatus>();

 

  private int        m_watchTransactionTag;

  private Boolean      m_playerCanCallFunctions;

  private Boolean      m_playerSupportsWatchpoints;

  private Boolean      m_playerCanBreakOnAllExceptions;

  private Boolean      m_playerSupportsConcurrency;

  private Boolean      m_playerSupportsWideLine;

 

  private ILauncher launcher;

  /**

   * The URL that was launched, or <code>null</code> if not known.  Note:

   * This is NOT the value returned by getURI().  getURI() returns the

   * URL that came from the Player, and is therefore probably the URI of

   * the SWF; but m_launchedUrl contains the URL that we tried to launch,

   * which might be an HTML wrapper, e.g. http://localhost/myapp.html

   */

  private String        m_launchUrl;

  private AIRLaunchInfo  m_airLaunchInfo; // null if this is not an AIR app

  static volatile boolean  m_debugMsgOn;    // debug ONLY; turned on with "set $debug_messages = 1"

  volatile int      m_debugMsgSize;    // debug ONLY; controlled with "set $debug_message_size = NNN"

  static volatile boolean  m_debugMsgFileOn;  // debug ONLY for file dump; turned on with "set $debug_message_file = 1"

  volatile int      m_debugMsgFileSize;  // debug ONLY for file dump; controlled with "set $debug_message_file_size = NNN"

  //FIXME: Make this concurrency aware

  /**

   * A simple cache of previous "is" and "instanceof" queries, in order to

   * avoid having to send redundant messages to the player.

   */

  private Map<String, Boolean> m_evalIsAndInstanceofCache = new HashMap<String, Boolean>();

 

  private volatile int m_lastPreIsolate = Isolate.DEFAULT_ID;

 

  private final Map<Integer, IsolateSession> m_isolateSessions;

  private static final String DEBUG_MESSAGES = "$debug_messages"; //$NON-NLS-1$

  private static final String DEBUG_MESSAGE_SIZE = "$debug_message_size"; //$NON-NLS-1$

  private static final String DEBUG_MESSAGE_FILE = "$debug_message_file"; //$NON-NLS-1$

  private static final String DEBUG_MESSAGE_FILE_SIZE = "$debug_message_file_size"; //$NON-NLS-1$

  private static final String CONSOLE_ERRORS = "$console_errors"; //$NON-NLS-1$

  private static final String FLASH_PREFIX = "$flash_"; //$NON-NLS-1$

 

  PlayerSession(Socket s, DProtocol proto, DManager manager, IDebuggerCallbacks debuggerCallbacks)

  {

    m_isConnected = false;

    m_isHalted = false;

    m_socket = s;

    m_protocol = proto;

    m_manager = manager;

    m_prefs = Collections.synchronizedMap(new HashMap<String, Object>());

    m_incoming = false;

    m_debugMsgOn = false;

    m_debugMsgSize = 16;

    m_debugMsgFileOn = false;

    m_debugMsgFileSize = 128;

    m_watchTransactionTag = 1;  // number that is sent for each watch transaction that occurs

    m_playerCanCallFunctions = null;

    m_debuggerCallbacks = debuggerCallbacks;

    m_isolateSessions = Collections.synchronizedMap(new HashMap<Integer, IsolateSession>());

  }

 

  private static PlayerSession createFromSocketHelper(Socket s, IDebuggerCallbacks debuggerCallbacks, DProtocol proto) throws IOException

  {

    // let the manager hear incoming messages

    DManager manager = new DManager();

    PlayerSession session = new PlayerSession(s, proto, manager, debuggerCallbacks);

    return session;

  }

  /**

   * @deprecated Use createFromSocketWithOptions

   * @param s

   * @param debuggerCallbacks

   * @return

   * @throws java.io.IOException

   */

  public static PlayerSession createFromSocket(Socket s, IDebuggerCallbacks debuggerCallbacks) throws IOException

  {

    DProtocol proto = DProtocol.createFromSocket(s);

    return createFromSocketHelper(s, debuggerCallbacks, proto);

  }

 

  /**

   * Creates a session from the socket. Sets session specific

   * socket settings and stores the callback object.

   * @param s

   * @param debuggerCallbacks

   * @param sessionManager

   * @return

   * @throws java.io.IOException

   */

  public static PlayerSession createFromSocketWithOptions(Socket s, IDebuggerCallbacks debuggerCallbacks, SessionManager sessionManager) throws IOException

  {

    DProtocol proto = DProtocol.createFromSocket(s, sessionManager);

    return createFromSocketHelper(s, debuggerCallbacks, proto);

  }

  /* getter */

  public DMessageCounter    getMessageCounter()    { return m_protocol.getMessageCounter(); }

  public String        getURI()        { return m_manager.getURI(); }

  public boolean        playerSupportsGet()    { return m_manager.isGetSupported(); }

    public int                  playerVersion()         { return m_manager.getVersion(); }

    public SourceLocator        getSourceLocator()      { return m_manager.getSourceLocator(); }

  /*

   * @see flash.tools.debugger.Session#setSourceLocator(flash.tools.debugger.SourceLocator)

   */

  public void setSourceLocator(SourceLocator sourceLocator)

  {

    m_manager.setSourceLocator(sourceLocator);

  }

  /**

   * If the manager started the process for us, then note it here. We will attempt to kill

   * it when we go down

   */

  void setProcess(Process proc)

  {

    m_process = proc;

  }

  /*

   * @see flash.tools.debugger.Session#getLaunchProcess()

   */

  public Process getLaunchProcess()

  {

    return m_process;

  }

  /**

   * Set preference

   * If an invalid preference is passed, it will be silently ignored.

   */

  public void      setPreferences(Map<String, ? extends Object> map)  { m_prefs.putAll(map); mapBack(); }

  public Set<String>  keySet()                { return m_prefs.keySet(); }

  public Object    getPreferenceAsObject(String pref)    { return m_prefs.get(pref); }

  /**

   * Set a property. Special logic for debug message boolean

   */

  public void setPreference(String pref, int value)

  {

    m_prefs.put(pref, new Integer(value));

    mapBack();

    // change in console messages?

    if (pref.equals(CONSOLE_ERRORS))

      sendConsoleErrorsAsTrace(value == 1);

    // generic message for flash player wherein "$flash_xxx" causes "xxx" to be sent

    if (pref.startsWith(FLASH_PREFIX))

      sendOptionMessage(pref.substring(FLASH_PREFIX.length()), Integer.toString(value));

  }

  // helper for mapBack()

  private int mapBackOnePreference(String preferenceName, int defaultValue)

  {

    Object prefValue = getPreferenceAsObject(preferenceName);

    if (prefValue != null)

      return ((Integer)prefValue).intValue();

    else

      return defaultValue;

  }

  // helper for mapBack()

  private boolean mapBackOnePreference(String preferenceName, boolean defaultValue)

  {

    Object prefValue = getPreferenceAsObject(preferenceName);

    if (prefValue != null)

      return ((Integer)prefValue).intValue() != 0 ? true : false;

    else

      return defaultValue;

  }

  // look for preferences, that map back to variables

  private void mapBack()

  {

    m_debugMsgOn = mapBackOnePreference(DEBUG_MESSAGES, m_debugMsgOn);

    m_debugMsgSize = mapBackOnePreference(DEBUG_MESSAGE_SIZE, m_debugMsgSize);

    m_debugMsgFileOn = mapBackOnePreference(DEBUG_MESSAGE_FILE, m_debugMsgFileOn);

    m_debugMsgFileSize = mapBackOnePreference(DEBUG_MESSAGE_FILE_SIZE, m_debugMsgFileSize);

  }

  public int getPreference(String pref)

  {

    int val = 0;

    Integer i = (Integer)m_prefs.get(pref);

    if (i == null)

      throw new NullPointerException();

    else

      val = i.intValue();

    return val;

  }

  /*

   * @see flash.tools.debugger.Session#isConnected()

   */

  public boolean isConnected()

  {

    return m_isConnected;

  }

  /*

   * @see flash.tools.debugger.Session#isSuspended()

   */

  public boolean isSuspended() throws NotConnectedException

  {

    if (!isConnected())

      throw new NotConnectedException();

    return m_isHalted;

  }

 

  /*

   * @see flash.tools.debugger.Session#isIsolateSuspended()

   */

  public boolean isWorkerSuspended(int isolateId) throws NotConnectedException

  {

    if (isolateId == Isolate.DEFAULT_ID)

      return isSuspended();

   

    if (!isConnected())

      throw new NotConnectedException();

   

    if (m_isolateStatus.containsKey(isolateId)) {

      return m_isolateStatus.get(isolateId).m_isHalted;

    }

   

    return false;

  }

  /**

   * Start up the session listening for incoming messages on the socket

   */

  public boolean bind() throws VersionException

  {

    boolean bound = false;

    if (m_isConnected)

      return false;

   

    // mark that we are connected

    m_isConnected = true;

    // attach us to the pipe (we are last to ensure that DManager and msg counter

    // get updated first

    m_protocol.addListener(ListenerIndex.PlayerSession, this);

    // start up the receiving thread

    bound = m_protocol.bind();

    // transmit our first few adjustment messages

    sendStopWarning();

    sendStopOnFault();

    sendEnumerateOverride();

    sendFailureNotify();

    sendInvokeSetters();

    sendSwfloadNotify();

    sendGetterTimeout();

    sendSetterTimeout();

    boolean responded = sendSquelch(true, Isolate.DEFAULT_ID);

    // now note in our preferences whether get is working or not.

    setPreference(SessionManager.PLAYER_SUPPORTS_GET, playerSupportsGet() ? 1 : 0);

    if (supportsConcurrency()) {

      sendConcurrentDebugger();

    }

   

    if (supportsWideLineNumbers()) {

      sendWideLineDebugger();

    }

    // Spawn a background thread which fetches the SWF and SWD

    // from the Player and uses them to build function name tables

    // for each source file

    Thread t = new Thread(this, "SWF/SWD reader"); //$NON-NLS-1$

    t.setDaemon(true);

    t.start();

    // we're probably using a bad version

    if (!responded)

      throw new VersionException();

    return bound;

  }

  /**

   * Permanently stops the debugging session and breaks the

   * connection to the Player

   */

  public void unbind()

  {

    unbind(false);

  }

  /**

   * @param requestTerminate

   *            if true, and if the player to which we are attached is capable

   *            of terminating itself (e.g. Adobe AIR), then the player will

   *            be told to terminate.

   * @return true if the player is capable of terminating itself and has been

   *         told to do so

   */

  private boolean unbind(boolean requestTerminate)

  {

    // If the caller asked us to terminate the player, then we first check

    // whether the player to which we are connected is capable of that.

    // (The web-based players are not; Adobe AIR is.)

    requestTerminate = requestTerminate && playerCanTerminate();

    DMessage dm = DMessageCache.alloc(1);

    dm.setType(DMessage.OutExit);

    dm.putByte((byte)(requestTerminate ? 1 : 0));

    sendMessage(dm);

    // unbind from the socket, so that we don't receive any more messages

    m_protocol.unbind();

    // kill the socket

    try { m_socket.close(); } catch(IOException io) {}

    m_isConnected = false;

    m_isHalted = false;

    return requestTerminate; // true if player was told to terminate

  }

  /**

   * Execute the specified AppleScript by passing it to /usr/bin/osascript.

   *

   * @param appleScript

   *            the AppleScript to execute, as a series of lines

   * @param argv

   *            any arguments; these can be accessed from within your

   *            AppleScript via "item 1 or argv", "item 2 of argv", etc.

   * @return any text which was sent to stdout by /usr/bin/osascript, with the

   *         trailing \n already removed

   */

  private String executeAppleScript(String[] appleScript, String[] argv)

  {

    StringBuilder retval = new StringBuilder();

    try

    {

      List<String> execArgs = new LinkedList<String>();

      // "osascript" is the command-line way of executing AppleScript.

      execArgs.add("/usr/bin/osascript"); //$NON-NLS-1$

      execArgs.add("-"); //$NON-NLS-1$

      if (argv != null)

      {

        for (int i=0; i<argv.length; ++i)

          execArgs.add(argv[i]);

      }

      Process osascript = Runtime.getRuntime().exec(execArgs.toArray(new String[execArgs.size()]));

      // feed our AppleScript code to osascript's stdin

      OutputStream outputStream = osascript.getOutputStream();

      PrintWriter writer = new PrintWriter(outputStream, true);

      writer.println("on run argv"); //$NON-NLS-1$ // this gives the name "argv" to the command-line args

      for (int i=0; i<appleScript.length; ++i)

        writer.println(appleScript[i]);

      writer.println("end run"); //$NON-NLS-1$

      writer.close();

      InputStreamReader reader = new InputStreamReader(osascript.getInputStream());

      int ch;

      while ( (ch=reader.read()) != -1 )

        retval.append((char)ch);

    }

    catch (IOException e)

    {

      // ignore

    }

    return retval.toString().replaceAll("\n$", ""); //$NON-NLS-1$ //$NON-NLS-2$

  }

  /**

   * Execute the specified AppleScript by passing it to /usr/bin/osascript.

   *

   * @param appleScriptFilename

   *            The name of the file containing AppleScript to execute.  This

   *            must be relative to PlayerSession.java.

   * @param argv

   *            any arguments; these can be accessed from within your

   *            AppleScript via "item 1 or argv", "item 2 of argv", etc.

   * @return any text which was sent to stdout by /usr/bin/osascript, with the

   *         trailing \n already removed

   * @throws java.io.IOException

   */

  private String executeAppleScript(String appleScriptFilename, String[] argv) throws IOException

  {

    InputStream stm = null;

    try {

      stm = PlayerSession.class.getResourceAsStream(appleScriptFilename);

      BufferedReader reader = new BufferedReader(new InputStreamReader(stm));

      String line;

      List<String> appleScriptLines = new ArrayList<String>();

      while ( (line=reader.readLine()) != null )

        appleScriptLines.add(line);

      String[] lines = appleScriptLines.toArray(new String[appleScriptLines.size()]);

      return executeAppleScript(lines, argv);

    } finally {

      if (stm != null) {

        stm.close();

      }

    }

  }

  /**

   * Checks whether the specified Macintosh web browser is currently

   * running.  You should only call this function if you have already

   * checked that you are running on a Mac.

   *

   * @param browserName a name, e.g. "Safari", "Firefox", "Camino"

   * @return true if currently running

   */

  private Set<String> runningApplications()

  {

    String running = executeAppleScript(

      new String[]

          {

        "tell application \"System Events\"", //$NON-NLS-1$

        "  name of processes", //$NON-NLS-1$

        "end tell" //$NON-NLS-1$

          },

          null

    );

    String[] apps = running.split(", "); //$NON-NLS-1$

    Set<String> retval = new HashSet<String>();

    for (int i=0; i<apps.length; ++i)

      retval.add(apps[i]);

    return retval;

  }

  /**

   * Destroys all objects related to the connection

   * including the process that was tied to this

   * session via SessionManager.launch(), if it

   * exists.

   */

  public void terminate()

  {

    boolean playerWillTerminateItself = false;

    // unbind first

    try

    {

      // Tell player to end session.  Note that this is just a hint, and will often

      // do nothing.  For example, the Flash player running in a browser will

      // currently never terminate when you tell it to, but the AIR player will

      // terminate.

      playerWillTerminateItself = unbind(true);

    } catch(Exception e)