/*

 * Copyright 2000-2004 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

package sun.jvm.hotspot.debugger.win32;

import java.io.*;

import java.net.*;

import java.util.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.debugger.x86.*;

import sun.jvm.hotspot.debugger.win32.coff.*;

import sun.jvm.hotspot.debugger.cdbg.*;

import sun.jvm.hotspot.debugger.cdbg.basic.BasicDebugEvent;

import sun.jvm.hotspot.utilities.*;

import sun.jvm.hotspot.utilities.memo.*;

/** <P> An implementation of the JVMDebugger interface which talks to

    the Free Windows Debug Server (FwDbgSrv) over a socket to

    implement attach/detach and read from process memory. All DLL and

    symbol table management is done in Java. </P>

    <P> <B>NOTE</B> that since we have the notion of fetching "Java

    primitive types" from the remote process (which might have

    different sizes than we expect) we have a bootstrapping

    problem. We need to know the sizes of these types before we can

    fetch them. The current implementation solves this problem by

    requiring that it be configured with these type sizes before they

    can be fetched. The readJ(Type) routines here will throw a

    RuntimeException if they are called before the debugger is

    configured with the Java primitive type sizes. </P> */

public class Win32DebuggerLocal extends DebuggerBase implements Win32Debugger {

  private Socket debuggerSocket;

  private boolean attached;

  // FIXME: update when core files supported

  private long pid;

  // Communication with debug server

  private PrintWriter out;

  private DataOutputStream rawOut;

  private InputLexer in;

  private static final int PORT = 27000;

  private PageCache cache;

  private static final long SHORT_TIMEOUT = 2000;

  private static final long LONG_TIMEOUT = 20000;

  // Symbol lookup support

  // This is a map of library names to DLLs

  private Map nameToDllMap;

  // C/C++ debugging support

  private List/*<LoadObject>*/ loadObjects;

  private CDebugger cdbg;

  // ProcessControl support

  private boolean suspended;

  // Maps Long objects (addresses) to Byte objects (original instructions)

  // (Longs used instead of Addresses to properly represent breakpoints at 0x0 if needed)

  private Map     breakpoints;

  // Current debug event, if any

  private DebugEvent curDebugEvent;

  //--------------------------------------------------------------------------------

  // Implementation of Debugger interface

  //

  /** <P> machDesc may not be null. </P>

      <P> useCache should be set to true if debugging is being done

      locally, and to false if the debugger is being created for the

      purpose of supporting remote debugging. </P> */

  public Win32DebuggerLocal(MachineDescription machDesc,

                            boolean useCache) throws DebuggerException {

    this.machDesc = machDesc;

    utils = new DebuggerUtilities(machDesc.getAddressSize(), machDesc.isBigEndian());

    if (useCache) {

      // Cache portion of the remote process's address space.

      // Fetching data over the socket connection to dbx is slow.

      // Might be faster if we were using a binary protocol to talk to

      // dbx, but would have to test. For now, this cache works best

      // if it covers the entire heap of the remote process. FIXME: at

      // least should make this tunable from the outside, i.e., via

      // the UI. This is a cache of 4096 4K pages, or 16 MB. The page

      // size must be adjusted to be the hardware's page size.

      // (FIXME: should pick this up from the debugger.)

      initCache(4096, parseCacheNumPagesProperty(4096));

    }

    // FIXME: add instantiation of thread factory

    try {

      connectToDebugServer();

    } catch (IOException e) {

      throw new DebuggerException(e);

    }

  }

  /** From the Debugger interface via JVMDebugger */

  public boolean hasProcessList() throws DebuggerException {

    return true;

  }

  /** From the Debugger interface via JVMDebugger */

  public List getProcessList() throws DebuggerException {

    List processes = new ArrayList();

    try {

      printlnToOutput("proclist");

      int num = in.parseInt();

      for (int i = 0; i < num; i++) {

        int pid = in.parseInt();

        String name = parseString();

        // NOTE: Win32 hack

        if (name.equals("")) {

          name = "System Idle Process";

        }

        processes.add(new ProcessInfo(name, pid));

      }

      return processes;

    }

    catch (IOException e) {

      throw new DebuggerException(e);

    }

  }

  /** From the Debugger interface via JVMDebugger */

  public synchronized void attach(int processID) throws DebuggerException {

    if (attached) {

      // FIXME: update when core files supported

      throw new DebuggerException("Already attached to process " + pid);

    }

    try {

      printlnToOutput("attach " + processID);

      if (!in.parseBoolean()) {

        throw new DebuggerException("Error attaching to process, or no such process");

      }

      attached = true;

      pid = processID;

      suspended = true;

      breakpoints = new HashMap();

      curDebugEvent = null;

      nameToDllMap = null;

      loadObjects = null;

    }

    catch (IOException e) {

        throw new DebuggerException(e);

    }

  }

  /** From the Debugger interface via JVMDebugger */

  public synchronized void attach(String executableName, String coreFileName) throws DebuggerException {

    throw new DebuggerException("Core files not yet supported on Win32");

  }

  /** From the Debugger interface via JVMDebugger */

  public synchronized boolean detach() {

    if (!attached) {

      return false;

    }

    attached = false;

    suspended = false;

    breakpoints = null;

    // Close all open DLLs

    if (nameToDllMap != null) {

      for (Iterator iter = nameToDllMap.values().iterator(); iter.hasNext(); ) {

        DLL dll = (DLL) iter.next();

        dll.close();

      }

      nameToDllMap = null;

      loadObjects = null;

    }

    cdbg = null;

    clearCache();

    try {

      printlnToOutput("detach");

      return in.parseBoolean();

    }

    catch (IOException e) {

      throw new DebuggerException(e);

    }

  }

  /** From the Debugger interface via JVMDebugger */

  public Address parseAddress(String addressString) throws NumberFormatException {

    return newAddress(utils.scanAddress(addressString));

  }

  /** From the Debugger interface via JVMDebugger */

  public String getOS() {

    return PlatformInfo.getOS();

  }

  /** From the Debugger interface via JVMDebugger */

  public String getCPU() {

    return PlatformInfo.getCPU();

  }

  public boolean hasConsole() throws DebuggerException {

    return false;

  }

  public String consoleExecuteCommand(String cmd) throws DebuggerException {

    throw new DebuggerException("No debugger console available on Win32");

  }

  public String getConsolePrompt() throws DebuggerException {

    return null;

  }

  public CDebugger getCDebugger() throws DebuggerException {

    if (cdbg == null) {

      cdbg = new Win32CDebugger(this);

    }

    return cdbg;

  }

  /** From the SymbolLookup interface via Debugger and JVMDebugger */

  public synchronized Address lookup(String objectName, String symbol) {

    if (!attached) {

      return null;

    }

    return newAddress(lookupInProcess(objectName, symbol));

  }

  /** From the SymbolLookup interface via Debugger and JVMDebugger */

  public synchronized OopHandle lookupOop(String objectName, String symbol) {

    Address addr = lookup(objectName, symbol);

    if (addr == null) {

      return null;

    }

    return addr.addOffsetToAsOopHandle(0);

  }

  /** From the Debugger interface */

  public MachineDescription getMachineDescription() {

    return machDesc;

  }

  //--------------------------------------------------------------------------------

  // Implementation of ThreadAccess interface

  //

  /** From the ThreadAccess interface via Debugger and JVMDebugger */

  public ThreadProxy getThreadForIdentifierAddress(Address addr) {

    return new Win32Thread(this, addr);

  }

  public ThreadProxy getThreadForThreadId(long handle) {

    return new Win32Thread(this, handle);

  }

  //----------------------------------------------------------------------

  // Overridden from DebuggerBase because we need to relax alignment

  // constraints on x86

  public long readJLong(long address)

    throws UnmappedAddressException, UnalignedAddressException {

    checkJavaConfigured();

    // FIXME: allow this to be configurable. Undesirable to add a

    // dependency on the runtime package here, though, since this

    // package should be strictly underneath it.

    //    utils.checkAlignment(address, jlongSize);

    utils.checkAlignment(address, jintSize);

    byte[] data = readBytes(address, jlongSize);

    return utils.dataToJLong(data, jlongSize);

  }

  //--------------------------------------------------------------------------------

  // Internal routines (for implementation of Win32Address).

  // These must not be called until the MachineDescription has been set up.

  //

  /** From the Win32Debugger interface */

  public String addressValueToString(long address) {

    return utils.addressValueToString(address);

  }

  /** From the Win32Debugger interface */

  public Win32Address readAddress(long address)

    throws UnmappedAddressException, UnalignedAddressException {

    return (Win32Address) newAddress(readAddressValue(address));

  }

  /** From the Win32Debugger interface */

  public Win32OopHandle readOopHandle(long address)

    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {

    long value = readAddressValue(address);

    return (value == 0 ? null : new Win32OopHandle(this, value));

  }

  /** From the Win32Debugger interface */

  public void writeAddress(long address, Win32Address value) {

    writeAddressValue(address, getAddressValue(value));

  }

  /** From the Win32Debugger interface */

  public void writeOopHandle(long address, Win32OopHandle value) {

    writeAddressValue(address, getAddressValue(value));

  }

  //--------------------------------------------------------------------------------

  // Thread context access

  //

  public synchronized long[] getThreadIntegerRegisterSet(int threadHandleValue,

                                                         boolean mustDuplicateHandle)

    throws DebuggerException {

    if (!suspended) {

      throw new DebuggerException("Process not suspended");

    }

    try {

      int handle = threadHandleValue;

      if (mustDuplicateHandle) {

        printlnToOutput("duphandle 0x" + Integer.toHexString(threadHandleValue));

        if (!in.parseBoolean()) {

          throw new DebuggerException("Error duplicating thread handle 0x" + threadHandleValue);

        }

        handle = (int) in.parseAddress(); // Must close to avoid leaks

      }

      printlnToOutput("getcontext 0x" + Integer.toHexString(handle));

      if (!in.parseBoolean()) {

        if (mustDuplicateHandle) {

          printlnToOutput("closehandle 0x" + Integer.toHexString(handle));

        }

        String failMessage = "GetThreadContext failed for thread handle 0x" +

                             Integer.toHexString(handle);

        if (mustDuplicateHandle) {

          failMessage = failMessage + ", duplicated from thread handle " +

                        Integer.toHexString(threadHandleValue);

        }

        throw new DebuggerException(failMessage);

      }

      // Otherwise, parse all registers. See

      // src/os/win32/agent/README-commands.txt for the format.

      // Note the array we have to return has to match that specified by

      // X86ThreadContext.java.

      int numRegs = 22;

      long[] winRegs = new long[numRegs];

      for (int i = 0; i < numRegs; i++) {

        winRegs[i] = in.parseAddress();

      }

      if (mustDuplicateHandle) {

        // Clean up after ourselves

        printlnToOutput("closehandle 0x" + Integer.toHexString(handle));

      }

      // Now create the real return value

      long[] retval = new long[X86ThreadContext.NPRGREG];

      retval[X86ThreadContext.EAX] = winRegs[0];

      retval[X86ThreadContext.EBX] = winRegs[1];

      retval[X86ThreadContext.ECX] = winRegs[2];

      retval[X86ThreadContext.EDX] = winRegs[3];

      retval[X86ThreadContext.ESI] = winRegs[4];

      retval[X86ThreadContext.EDI] = winRegs[5];

      retval[X86ThreadContext.EBP] = winRegs[6];

      retval[X86ThreadContext.ESP] = winRegs[7];

      retval[X86ThreadContext.EIP] = winRegs[8];

      retval[X86ThreadContext.DS]  = winRegs[9];

      retval[X86ThreadContext.ES]  = winRegs[10];

      retval[X86ThreadContext.FS]  = winRegs[11];

      retval[X86ThreadContext.GS]  = winRegs[12];

      retval[X86ThreadContext.CS]  = winRegs[13];

      retval[X86ThreadContext.SS]  = winRegs[14];

      retval[X86ThreadContext.EFL] = winRegs[15];

      retval[X86ThreadContext.DR0] = winRegs[16];

      retval[X86ThreadContext.DR1] = winRegs[17];

      retval[X86ThreadContext.DR2] = winRegs[18];

      retval[X86ThreadContext.DR3] = winRegs[19];

      retval[X86ThreadContext.DR6] = winRegs[20];

      retval[X86ThreadContext.DR7] = winRegs[21];

      return retval;

    } catch (IOException e) {

      throw new DebuggerException(e);

    }

  }

  public synchronized void setThreadIntegerRegisterSet(int threadHandleValue,

                                                       boolean mustDuplicateHandle,

                                                       long[] context)

    throws DebuggerException {

    if (!suspended) {

      throw new DebuggerException("Process not suspended");

    }

    try {

      int handle = threadHandleValue;

      if (mustDuplicateHandle) {

        printlnToOutput("duphandle 0x" + Integer.toHexString(threadHandleValue));

        if (!in.parseBoolean()) {

          throw new DebuggerException("Error duplicating thread handle 0x" + threadHandleValue);

        }

        handle = (int) in.parseAddress(); // Must close to avoid leaks

      }

      // Change order of registers to match that of debug server

      long[] winRegs = new long[context.length];

      winRegs[0] = context[X86ThreadContext.EAX];

      winRegs[1] = context[X86ThreadContext.EBX];

      winRegs[2] = context[X86ThreadContext.ECX];

      winRegs[3] = context[X86ThreadContext.EDX];

      winRegs[4] = context[X86ThreadContext.ESI];

      winRegs[5] = context[X86ThreadContext.EDI];

      winRegs[6] = context[X86ThreadContext.EBP];

      winRegs[7] = context[X86ThreadContext.ESP];

      winRegs[8] = context[X86ThreadContext.EIP];

      winRegs[9] = context[X86ThreadContext.DS];

      winRegs[10] = context[X86ThreadContext.ES];

      winRegs[11] = context[X86ThreadContext.FS];

      winRegs[12] = context[X86ThreadContext.GS];

      winRegs[13] = context[X86ThreadContext.CS];

      winRegs[14] = context[X86ThreadContext.SS];

      winRegs[15] = context[X86ThreadContext.EFL];

      winRegs[16] = context[X86ThreadContext.DR0];

      winRegs[17] = context[X86ThreadContext.DR1];

      winRegs[18] = context[X86ThreadContext.DR2];

      winRegs[19] = context[X86ThreadContext.DR3];

      winRegs[20] = context[X86ThreadContext.DR6];

      winRegs[21] = context[X86ThreadContext.DR7];

      StringBuffer cmd = new StringBuffer();

      cmd.append("setcontext 0x");

      cmd.append(Integer.toHexString(threadHandleValue));

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

        cmd.append(" 0x");

        cmd.append(Long.toHexString(winRegs[i]));

      }

      printlnToOutput(cmd.toString());

      boolean res = in.parseBoolean();

      if (mustDuplicateHandle) {

        printlnToOutput("closehandle 0x" + Integer.toHexString(handle));

      }

      if (!res) {

        String failMessage = "SetThreadContext failed for thread handle 0x" +

          Integer.toHexString(handle);

        if (mustDuplicateHandle) {

          failMessage = failMessage + ", duplicated from thread handle " +

            Integer.toHexString(threadHandleValue);

        }

        throw new DebuggerException(failMessage);

      }

    } catch (IOException e) {

      throw new DebuggerException(e);

    }

  }

  /** Fetches the Win32 LDT_ENTRY for the given thread and selector.

      This data structure allows the conversion of a segment-relative

      address to a linear virtual address. For example, it allows the

      expression of operations like "mov eax, fs:[18h]", which fetches

      the thread information block, allowing access to the thread

      ID. */

  public synchronized Win32LDTEntry getThreadSelectorEntry(int threadHandleValue,

                                                           boolean mustDuplicateHandle,

                                                           int selector)

    throws DebuggerException {

    try {

      int handle = threadHandleValue;

      if (mustDuplicateHandle) {

        printlnToOutput("duphandle 0x" + Integer.toHexString(threadHandleValue));

        if (!in.parseBoolean()) {

          throw new DebuggerException("Error duplicating thread handle 0x" + threadHandleValue);

        }

        handle = (int) in.parseAddress(); // Must close to avoid leaks

      }

      printlnToOutput("selectorentry 0x" + Integer.toHexString(handle) + " " + selector);

      if (!in.parseBoolean()) {

        if (mustDuplicateHandle) {

          printlnToOutput("closehandle 0x" + Integer.toHexString(handle));

        }

        throw new DebuggerException("GetThreadContext failed for thread handle 0x" + handle +

                                    ", duplicated from thread handle " + threadHandleValue);

      }

      // Parse result. See

      // src/os/win32/agent/README-commands.txt for the format.

      short limitLow = (short) in.parseAddress();

      short baseLow  = (short) in.parseAddress();

      byte  baseMid  = (byte)  in.parseAddress();

      byte  flags1   = (byte)  in.parseAddress();

      byte  flags2   = (byte)  in.parseAddress();

      byte  baseHi   = (byte)  in.parseAddress();

      return new Win32LDTEntry(limitLow, baseLow, baseMid, flags1, flags2, baseHi);

    } catch (IOException e) {

      throw new DebuggerException(e);

    }

  }

  public synchronized List getThreadList() throws DebuggerException {

    if (!suspended) {

      throw new DebuggerException("Process not suspended");

    }

    try {

      printlnToOutput("threadlist");

      List ret = new ArrayList();

      int numThreads = in.parseInt();