/*

 * Copyright 2000-2003 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.

 *

 */

// A Simple Windows Debug Server.

//

// This software provides a socket-based debug server which uses

// mostly ASCII protocols to communicate with its clients. Since the

// Windows security model is largely based around being able to run

// programs on the machine, this server only accepts connections

// coming from localhost.

//

// When run as a service (under Windows NT), this software provides

// clients the ability to attach to and detach from processes without

// killing those processes. Ordinarily this is forbidden by the

// Windows debugging APIs (although more recent debugging environments

// from Microsoft seem to have circumvented this restriction, perhaps

// in a different way). This is achieved by forking a persistent

// subprocess for each debugging session which remains alive as long

// as the target process is.

//

// At this point the client can read information out of the target

// process's address space. Future work includes exposing more

// functionality like writing to the remote address space and

// suspending and resuming threads.

#include <iostream>

#include <vector>

#include <stdlib.h>

// Must come before everything else

#include <winsock2.h>

#include <assert.h>

#include "Dispatcher.hpp"

#include "Handler.hpp"

#include "initWinsock.hpp"

#include "ioUtils.hpp"

#include "isNT4.hpp"

#include "Message.hpp"

#include "nt4internals.hpp"

#include "ports.h"

#include "procList.hpp"

#include "serverLists.hpp"

#include "Reaper.hpp"

// Uncomment the #define below to get messages on stderr

// #define DEBUGGING

using namespace std;

static ChildList childList;

static ClientList clientList;

static Reaper* reaper = NULL;

// Needed prototypes

void shutdownChild(ChildInfo* childInfo);

void detachClient(ClientInfo* clientInfo);

void shutdownClient(ClientInfo* clientInfo);

char *

longToDotFormat(long addr)

{

  char *temp_s = new char[20];

  sprintf(temp_s, "%d.%d.%d.%d", ((addr & 0xff000000) >> 24),

          ((addr & 0x00ff0000) >> 16), ((addr & 0x0000ff00) >> 8),

          (addr & 0x000000ff));

  return temp_s;

}

// NOTE that we do this query every time. It is a bad idea to cache IP

// addresses. For example, we might be hosted on a machine using DHCP

// and the connection addresses might change over time. (Yes, this

// actually happened.)

bool

isConnectionOkay(ULONG connAddr) {

  if (connAddr == INADDR_LOOPBACK) {

    return true;

  }

  const int MAXNAME = 1024;

  char myname[MAXNAME];

  gethostname(myname, MAXNAME);

  struct hostent* myInfo = gethostbyname(myname);

  if (myInfo == NULL) {

#ifdef DEBUGGING

    cerr << "My host information was null" << endl;

#endif

  } else {

    // Run down the list of IP addresses for myself

    assert(myInfo->h_length == sizeof(ULONG));

#ifdef DEBUGGING

    cerr << "My known IP addresses: " << endl;

#endif

    for (char** pp = myInfo->h_addr_list; *pp != NULL; pp++) {

      char* p = *pp;

      ULONG altAddr = ntohl(*((ULONG*) p));

#ifdef DEBUGGING

      char* name = longToDotFormat(altAddr);

      cerr << name << endl;

      delete[] name;

#endif

      if (altAddr == connAddr) {

#ifdef DEBUGGING

        cerr << "FOUND" << endl;

#endif

        return true;

      }

    }

#ifdef DEBUGGING

    cerr << "Done." << endl;

#endif

  }

  return false;

}

SOCKET

setupListeningSocket(short port) {

  SOCKET listening = socket(AF_INET, SOCK_STREAM, 0);

  if (listening == INVALID_SOCKET) {

    cerr << "Error creating listening socket" << endl;

    exit(1);

  }

  int reuseAddress = 1;

  if (setsockopt(listening, SOL_SOCKET, SO_REUSEADDR,

                 (char *)&reuseAddress, sizeof(reuseAddress)) == -1) {

    cerr << "Error reusing address" << endl;

    exit(1);

  }

  struct sockaddr_in serverInfo;

  memset((char *)&serverInfo, 0, sizeof(serverInfo));

  serverInfo.sin_addr.s_addr = INADDR_ANY;

  serverInfo.sin_family = AF_INET;

  serverInfo.sin_port = htons(port);

  if (bind(listening, (struct sockaddr *) &serverInfo, sizeof(serverInfo)) < 0) {

    cerr << "Error binding socket" << endl;

    exit(1);

  }

  if (listen(listening, 5) < 0) {

    cerr << "Error listening" << endl;

    exit(1);

  }

  return listening;

}

/** Accepts a connection from the given listening socket, but only if

    the connection came from localhost. Returns INVALID_SOCKET if the

    connection came from any other IP address or if an error occurred

    during the call to accept(). */

SOCKET

acceptFromLocalhost(SOCKET listening) {

  struct sockaddr_in peerAddr;

  int peerAddrLen = sizeof(peerAddr);

  SOCKET fd = accept(listening, (sockaddr*) &peerAddr, &peerAddrLen);

  if (fd == INVALID_SOCKET) {

    return fd;

  }

  if (!isConnectionOkay(ntohl(peerAddr.sin_addr.s_addr))) {

    // Reject connections from other machines for security purposes.

    // The Windows security model seems to assume one user per

    // machine, and that security is compromised if another user is

    // able to run executables on the given host. (If these

    // assumptions are not strict enough, we will have to change

    // this.)

    shutdown(fd, SD_BOTH);

    closesocket(fd);

    return INVALID_SOCKET;

  }

  // Disable TCP buffering on all sockets. We send small amounts of

  // data back and forth and don't want buffering.

  int buffer_val = 1;

  if (setsockopt(fd, IPPROTO_IP, TCP_NODELAY,

                 (char *) &buffer_val, sizeof(buffer_val)) < 0) {

    shutdown(fd, SD_BOTH);

    closesocket(fd);

  }

  return fd;

}

void

reapCB(void* arg) {

  ChildInfo* info = (ChildInfo*) arg;

  ListsLocker ll;

  DWORD pid = info->getPid();

  shutdownChild(info);

#ifdef DEBUGGING

  cerr << "Reaped child for process " << pid << endl;

#endif

}

/** Starts a child process with stdin and stdout redirected to pipes,

    handles to which are returned. auxHandle1 and auxHandle2 should be

    closed as well when the child process exits. Returns false if

    process creation failed. */

bool

startChildProcess(DWORD pidToDebug,

                  DWORD childStdinBufSize,

                  DWORD childStdoutBufSize,

                  LPHANDLE childProcessHandle,

                  LPHANDLE writeToStdinHandle,

                  LPHANDLE readFromStdoutHandle,

                  LPHANDLE auxHandle1,

                  LPHANDLE auxHandle2) {

  // Code adapted from Microsoft example

  // "Creating a Child Process with Redirected Input and Output"

  SECURITY_ATTRIBUTES saAttr;

  BOOL fSuccess;

  HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup,

    hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup,

    hSaveStdin, hSaveStdout;

  // Set the bInheritHandle flag so pipe handles are inherited.

  saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);

  saAttr.bInheritHandle = TRUE;

  saAttr.lpSecurityDescriptor = NULL;

  // The steps for redirecting child process's STDOUT:

  //   1. Save current STDOUT, to be restored later.

  //   2. Create anonymous pipe to be STDOUT for child process.

  //   3. Set STDOUT of the parent process to be write handle to

  //      the pipe, so it is inherited by the child process.

  //   4. Create a noninheritable duplicate of the read handle and

  //      close the inheritable read handle.

  // Save the handle to the current STDOUT.

  hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE);

  // Create a pipe for the child process's STDOUT.

  if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, childStdoutBufSize)) {

    return false;

  }

  // Set a write handle to the pipe to be STDOUT.

  if (! SetStdHandle(STD_OUTPUT_HANDLE, hChildStdoutWr)) {

    return false;

  }

  // Create noninheritable read handle and close the inheritable read

  // handle.

  fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd,

                             GetCurrentProcess(), &hChildStdoutRdDup,

                             0, FALSE,

                             DUPLICATE_SAME_ACCESS);

  if( !fSuccess ) {

    return false;

  }

  CloseHandle(hChildStdoutRd);

  // The steps for redirecting child process's STDIN:

  //   1.  Save current STDIN, to be restored later.

  //   2.  Create anonymous pipe to be STDIN for child process.

  //   3.  Set STDIN of the parent to be the read handle to the

  //       pipe, so it is inherited by the child process.

  //   4.  Create a noninheritable duplicate of the write handle,

  //       and close the inheritable write handle.

  // Save the handle to the current STDIN.

  hSaveStdin = GetStdHandle(STD_INPUT_HANDLE);

  // Create a pipe for the child process's STDIN.

  if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, childStdinBufSize)) {

    return false;

  }

  // Set a read handle to the pipe to be STDIN.

  if (! SetStdHandle(STD_INPUT_HANDLE, hChildStdinRd)) {

    return false;

  }

  // Duplicate the write handle to the pipe so it is not inherited.

  fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr,

                             GetCurrentProcess(), &hChildStdinWrDup, 0,

                             FALSE,                  // not inherited

                             DUPLICATE_SAME_ACCESS);

  if (! fSuccess) {

    return false;

  }

  CloseHandle(hChildStdinWr);

  // Create the child process

  char cmdLine[256];

  sprintf(cmdLine, "SwDbgSub.exe %u", pidToDebug);

  PROCESS_INFORMATION procInfo;

  STARTUPINFO startInfo;

  memset((char*) &startInfo, 0, sizeof(startInfo));

  startInfo.cb = sizeof(startInfo);

  BOOL res = CreateProcess(NULL,

                           cmdLine,

                           NULL,

                           NULL,

                           TRUE, // inherit handles: important

                           0,

                           NULL,

                           NULL,

                           &startInfo,

                           &procInfo);

  if (!res) {

    return false;

  }

  // After process creation, restore the saved STDIN and STDOUT.

  if (! SetStdHandle(STD_INPUT_HANDLE, hSaveStdin)) {

    return false;

  }

  if (! SetStdHandle(STD_OUTPUT_HANDLE, hSaveStdout)) {

    return false;

  }

  // hChildStdinWrDup can be used to write to the child's stdin

  // hChildStdoutRdDup can be used to read from the child's stdout

  // NOTE: example code closes hChildStdoutWr before reading from

  // hChildStdoutRdDup. "Close the write end of the pipe before

  // reading from the read end of the pipe"??? Looks like this is

  // example-specific.

  // Set up return arguments

  // hChildStdoutRd and hChildStdinWr are already closed at this point

  *childProcessHandle = procInfo.hProcess;

  *writeToStdinHandle = hChildStdinWrDup;

  *readFromStdoutHandle = hChildStdoutRdDup;

  *auxHandle1 = hChildStdinRd;

  *auxHandle2 = hChildStdoutWr;

  return true;

}

/** Clears the event and writes the message to the child process */

bool

sendMessage(ChildInfo* child, Message* message) {

  DWORD numBytesWritten;

  if (!WriteFile(child->getWriteToStdinHandle(),

                 message, sizeof(Message), &numBytesWritten, NULL)) {

    return false;

  }

  if (numBytesWritten != sizeof(Message)) {

    return false;

  }

  // Follow up "poke" messages with the raw data

  if (message->type == Message::POKE) {

    if (!WriteFile(child->getWriteToStdinHandle(),

                   message->pokeArg.data, message->pokeArg.numBytes, &numBytesWritten, NULL)) {

      return false;

    }

    if (numBytesWritten != message->pokeArg.numBytes) {

      return false;

    }

  }

  return true;

}

/** Copies data from child's stdout to the client's IOBuf and sends it

    along */

bool

forwardReplyToClient(ChildInfo* child, ClientInfo* client) {

  DWORD total = 0;

  IOBuf::FillState ret;

  do {

    DWORD temp;

    ret = client->getIOBuf()->fillFromFileHandle(child->getReadFromStdoutHandle(),

                                                 &temp);

    if (ret == IOBuf::DONE || ret == IOBuf::MORE_DATA_PENDING) {

      if (!client->getIOBuf()->flush()) {

#ifdef DEBUGGING

        cerr << "Forward failed because flush failed" << endl;

#endif

        return false;

      }

      total += temp;

    }

  } while (ret == IOBuf::MORE_DATA_PENDING);

  return (ret == IOBuf::FAILED) ? false : true;

}

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

// Server Handler

//

class ServerHandler : public Handler {

public:

  ServerHandler();

  // Starts up in Unicode mode by default

  bool getASCII();

  void setIOBuf(IOBuf* ioBuf);

  void procList(char* arg);

  // Must be called before calling one of the routines below

  void setClientInfo(ClientInfo* info);

  // Indicates to outer loop that exit was called or that an error

  // occurred and that the client exited.

  bool exited();

  // Clears this state

  void clearExited();

  void ascii(char* arg);

  void unicode(char* arg);

  void attach(char* arg);

  void detach(char* arg);

  void libInfo(char* arg);

  void peek(char* arg);

  void poke(char* arg);

  void threadList(char* arg);

  void dupHandle(char* arg);

  void closeHandle(char* arg);

  void getContext(char* arg);

  void setContext(char* arg);

  void selectorEntry(char* arg);

  void suspend(char* arg);

  void resume(char* arg);

  void pollEvent(char* arg);

  void continueEvent(char* arg);

  void exit(char* arg);

  // This is pretty gross. Needed to make the target process know

  // about clients that have disconnected unexpectedly while attached.

  friend void shutdownClient(ClientInfo*);

private:

  // Writes: charSize <space> numChars <space> <binary string>

  // Handles both ASCII and UNICODE modes

  void writeString(USHORT len, WCHAR* str);

  // Handles only ASCII mode

  void writeString(USHORT len, char* str);

  ClientInfo* clientInfo;

  IOBuf* ioBuf;

  bool _exited;

  bool _ascii;

};

static ServerHandler* handler;

ServerHandler::ServerHandler() {

  _exited = false;

  _ascii = false;

  ioBuf = NULL;

}

bool

ServerHandler::getASCII() {

  return _ascii;

}

void

ServerHandler::setIOBuf(IOBuf* buf) {

  ioBuf = buf;

}

void

ServerHandler::setClientInfo(ClientInfo* info) {

  clientInfo = info;

}

bool

ServerHandler::exited() {

  return _exited;

}

void

ServerHandler::clearExited() {

  _exited = false;

}

void

ServerHandler::ascii(char* arg) {

  _ascii = true;

}

void

ServerHandler::unicode(char* arg) {

  _ascii = false;

}

void

ServerHandler::procList(char* arg) {

#ifdef DEBUGGING

  cerr << "proclist" << endl;

#endif

  ProcEntryList processes;

  ::procList(processes);

  ioBuf->writeInt(processes.size());

  for (ProcEntryList::iterator iter = processes.begin();

       iter != processes.end(); iter++) {

    ProcEntry& entry = *iter;

    ioBuf->writeSpace();

    ioBuf->writeUnsignedInt(entry.getPid());

    ioBuf->writeSpace();

    writeString(entry.getNameLength(), entry.getName());

  }

  ioBuf->writeEOL();

  ioBuf->flush();

}

void

ServerHandler::attach(char* arg) {