//===-- GDBServer.cpp -------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include <sys/socket.h>
#include <sys/types.h>
#include <errno.h>
#include <getopt.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/sysctl.h>
#include <string>
#include <vector>
#include <asl.h>

#include "GDBServerLog.h"
#include "GDBRemoteSession.h"

using namespace lldb;

//----------------------------------------------------------------------
// Run loop modes which determine which run loop function will be called
//----------------------------------------------------------------------
typedef enum
{
    eDCGSRunLoopModeInvalid = 0,
    eDCGSRunLoopModeGetStartModeFromRemoteProtocol,
    eDCGSRunLoopModeInferiorAttaching,
    eDCGSRunLoopModeInferiorLaunching,
    eDCGSRunLoopModeInferiorExecuting,
    eDCGSRunLoopModeInferiorKillOrDetach,
    eDCGSRunLoopModeExit
} GSRunLoopMode;

typedef enum
{
    eLaunchFlavorDefault = 0,
    eLaunchFlavorPosixSpawn,
#if defined (__arm__)
    eLaunchFlavorSpringBoard,
#endif
    eLaunchFlavorForkExec,
} GSLaunchFlavor;

typedef lldb::shared_ptr<GDBRemoteSession> GDBRemoteSP;

typedef struct HandleBroadcastEventInfo
{
    TargetSP target_sp;
    GDBRemoteSP remote_sp;
    GSRunLoopMode mode;

    Target *
    GetTarget ()
    {
        return target_sp.get();
    }

    Process *
    GetProcess()
    {
        if (target_sp.get())
            return target_sp->GetProcess().get();
        return NULL;
    }

    GDBRemoteSession *
    GetRemote ()
    {
        return remote_sp.get();
    }

};


//----------------------------------------------------------------------
// Global Variables
//----------------------------------------------------------------------
static int g_lockdown_opt  = 0;
static int g_applist_opt = 0;
static GSLaunchFlavor g_launch_flavor = eLaunchFlavorDefault;
int g_isatty = 0;

//----------------------------------------------------------------------
// Run Loop function prototypes
//----------------------------------------------------------------------
void GSRunLoopGetStartModeFromRemote (HandleBroadcastEventInfo *info);
void GSRunLoopInferiorExecuting (HandleBroadcastEventInfo *info);


//----------------------------------------------------------------------
// Get our program path and arguments from the remote connection.
// We will need to start up the remote connection without a PID, get the
// arguments, wait for the new process to finish launching and hit its
// entry point,  and then return the run loop mode that should come next.
//----------------------------------------------------------------------
void
GSRunLoopGetStartModeFromRemote (HandleBroadcastEventInfo *info)
{
    std::string packet;

    Target *target = info->GetTarget();
    GDBRemoteSession *remote = info->GetRemote();
    if (target != NULL && remote != NULL)
    {
        // Spin waiting to get the A packet.
        while (1)
        {
            gdb_err_t err = gdb_err;
            GDBRemoteSession::PacketEnum type;

            err = remote->HandleReceivedPacket (&type);

            // check if we tried to attach to a process
            if (type == GDBRemoteSession::vattach || type == GDBRemoteSession::vattachwait)
            {
                if (err == gdb_success)
                {
                    info->mode = eDCGSRunLoopModeInferiorExecuting;
                    return;
                }
                else
                {
                    Log::STDERR ("error: attach failed.");
                    info->mode = eDCGSRunLoopModeExit;
                    return;
                }
            }

            if (err == gdb_success)
            {
                // If we got our arguments we are ready to launch using the arguments
                // and any environment variables we received.
                if (type == GDBRemoteSession::set_argv)
                {
                    info->mode = eDCGSRunLoopModeInferiorLaunching;
                    return;
                }
            }
            else if (err == gdb_not_connected)
            {
                Log::STDERR ("error: connection lost.");
                info->mode = eDCGSRunLoopModeExit;
                return;
            }
            else
            {
                // a catch all for any other gdb remote packets that failed
                GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s Error getting packet.",__FUNCTION__);
                continue;
            }

            GDBServerLog::LogIf (GS_LOG_MINIMAL, "#### %s", __FUNCTION__);
        }
    }
    info->mode = eDCGSRunLoopModeExit;
}


//----------------------------------------------------------------------
// This run loop mode will wait for the process to launch and hit its
// entry point. It will currently ignore all events except for the
// process state changed event, where it watches for the process stopped
// or crash process state.
//----------------------------------------------------------------------
GSRunLoopMode
GSRunLoopLaunchInferior (HandleBroadcastEventInfo *info)
{
    // The Process stuff takes a c array, the GSContext has a vector...
    // So make up a c array.
    Target *target = info->GetTarget();
    GDBRemoteSession *remote = info->GetRemote();
    Process* process = info->GetProcess();

    if (process == NULL)
        return eDCGSRunLoopModeExit;

    GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s Launching '%s'...", __FUNCTION__, target->GetExecutableModule()->GetFileSpec().GetFilename().AsCString());

    // Our launch type hasn't been set to anything concrete, so we need to
    // figure our how we are going to launch automatically.

    GSLaunchFlavor launch_flavor = g_launch_flavor;
    if (launch_flavor == eLaunchFlavorDefault)
    {
        // Our default launch method is posix spawn
        launch_flavor = eLaunchFlavorPosixSpawn;

#if defined (__arm__)
        // Check if we have an app bundle, if so launch using SpringBoard.
        if (strstr(inferior_argv[0], ".app"))
        {
            launch_flavor = eLaunchFlavorSpringBoard;
        }
#endif
    }

    //ctx.SetLaunchFlavor(launch_flavor);

    const char *stdio_file = NULL;
    lldb::pid_t pid = process->Launch (remote->GetARGV(), remote->GetENVP(), stdio_file, stdio_file, stdio_file);

    if (pid == LLDB_INVALID_PROCESS_ID)
    {
        Log::STDERR ("error: process launch failed: %s", process->GetError().AsCString());
    }
    else
    {
        if (remote->IsConnected())
        {
            // It we are connected already, the next thing gdb will do is ask
            // whether the launch succeeded, and if not, whether there is an
            // error code.  So we need to fetch one packet from gdb before we wait
            // on the stop from the target.
            gdb_err_t err = gdb_err;
            GDBRemoteSession::PacketEnum type;

            err = remote->HandleReceivedPacket (&type);

            if (err != gdb_success)
            {
                GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s Error getting packet.", __FUNCTION__);
                return eDCGSRunLoopModeExit;
            }
            if (type != GDBRemoteSession::query_launch_success)
            {
                GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s Didn't get the expected qLaunchSuccess packet.", __FUNCTION__);
            }
        }
    }

    Listener listener("GSRunLoopLaunchInferior");
    listener.StartListeningForEvents (process, Process::eBroadcastBitStateChanged);
    while (process->GetID() != LLDB_INVALID_PROCESS_ID)
    {
        uint32_t event_mask = 0;
        while (listener.WaitForEvent(NULL, &event_mask))
        {
            if (event_mask & Process::eBroadcastBitStateChanged)
            {
                Event event;
                StateType event_state;
                while ((event_state = process->GetNextEvent (&event)))
                if (StateIsStoppedState(event_state))
                {
                    GDBServerLog::LogIf (GS_LOG_EVENTS, "%s process %4.4x stopped with state %s", __FUNCTION__, pid, StateAsCString(event_state));

                    switch (event_state)
                    {
                    default:
                    case eStateInvalid:
                    case eStateUnloaded:
                    case eStateAttaching:
                    case eStateLaunching:
                    case eStateSuspended:
                        break;  // Ignore

                    case eStateRunning:
                    case eStateStepping:
                        // Still waiting to stop at entry point...
                        break;

                    case eStateStopped:
                    case eStateCrashed:
                        return eDCGSRunLoopModeInferiorExecuting;

                    case eStateDetached:
                    case eStateExited:
                        pid = LLDB_INVALID_PROCESS_ID;
                        return eDCGSRunLoopModeExit;
                    }
                }

                if (event_state = eStateInvalid)
                    break;
            }
        }
    }

    return eDCGSRunLoopModeExit;
}


//----------------------------------------------------------------------
// This run loop mode will wait for the process to launch and hit its
// entry point. It will currently ignore all events except for the
// process state changed event, where it watches for the process stopped
// or crash process state.
//----------------------------------------------------------------------
GSRunLoopMode
GSRunLoopLaunchAttaching (HandleBroadcastEventInfo *info, lldb::pid_t& pid)
{
    Process* process = info->GetProcess();

    GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s Attaching to pid %i...", __FUNCTION__, pid);
    pid = process->Attach(pid);

    if (pid == LLDB_INVALID_PROCESS_ID)
        return eDCGSRunLoopModeExit;
    return eDCGSRunLoopModeInferiorExecuting;
}

//----------------------------------------------------------------------
// Watch for signals:
// SIGINT: so we can halt our inferior. (disabled for now)
// SIGPIPE: in case our child process dies
//----------------------------------------------------------------------
lldb::pid_t g_pid;
int g_sigpipe_received = 0;
void
signal_handler(int signo)
{
    GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s (%s)", __FUNCTION__, Host::GetSignalAsCString(signo));

    switch (signo)
    {
//  case SIGINT:
//      DNBProcessKill (g_pid, signo);
//      break;

    case SIGPIPE:
        g_sigpipe_received = 1;
        break;
    }
}

// Return the new run loop mode based off of the current process state
void
HandleProcessStateChange (HandleBroadcastEventInfo *info, bool initialize)
{
    Process *process = info->GetProcess();
    if (process == NULL)
    {
        info->mode = eDCGSRunLoopModeExit;
        return;
    }

    if (process->GetID() == LLDB_INVALID_PROCESS_ID)
    {
        GDBServerLog::LogIf (GS_LOG_MINIMAL, "#### %s error: pid invalid, exiting...", __FUNCTION__);
        info->mode = eDCGSRunLoopModeExit;
        return;
    }
    StateType pid_state = process->GetState ();

    GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s (info, initialize=%i)  pid_state = %s", __FUNCTION__, (int)initialize, StateAsCString(pid_state));

    switch (pid_state)
    {
    case eStateInvalid:
    case eStateUnloaded:
        // Something bad happened
        info->mode = eDCGSRunLoopModeExit;
        return;

    case eStateAttaching:
    case eStateLaunching:
        info->mode = eDCGSRunLoopModeInferiorExecuting;
        return;

    case eStateSuspended:
    case eStateCrashed:
    case eStateStopped:
        if (initialize == false)
        {
            // Compare the last stop count to our current notion of a stop count
            // to make sure we don't notify more than once for a given stop.
            static uint32_t g_prev_stop_id = 0;
            uint32_t stop_id = process->GetStopID();
            bool pid_stop_count_changed = g_prev_stop_id != stop_id;
            if (pid_stop_count_changed)
            {
                info->GetRemote()->FlushSTDIO();

                if (stop_id == 1)
                {
                    GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %u (old %u)) Notify??? no, first stop...", __FUNCTION__, (int)initialize, StateAsCString (pid_state), stop_id, g_prev_stop_id);
                }
                else
                {

                    GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %u (old %u)) Notify??? YES!!!", __FUNCTION__, (int)initialize, StateAsCString (pid_state), stop_id, g_prev_stop_id);
                    info->GetRemote()->NotifyThatProcessStopped ();
                }
            }
            else
            {
                GDBServerLog::LogIf (GS_LOG_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %u (old %u)) Notify??? skipping...", __FUNCTION__, (int)initialize, StateAsCString (pid_state), stop_id, g_prev_stop_id);
            }
        }
        info->mode = eDCGSRunLoopModeInferiorExecuting;
        return;

    case eStateStepping:
    case eStateRunning:
        info->mode = eDCGSRunLoopModeInferiorExecuting;
        return;

    case eStateExited:
        info->GetRemote()->HandlePacket_last_signal (NULL);
        info->mode = eDCGSRunLoopModeExit;
        return;

    }

    // Catch all...
    info->mode = eDCGSRunLoopModeExit;
}

bool
CommunicationHandleBroadcastEvent (Broadcaster *broadcaster, uint32_t event_mask, void *baton)
{
    HandleBroadcastEventInfo *info = (HandleBroadcastEventInfo *)baton;
    Process *process = info->GetProcess();

    if (process == NULL)
    {
        info->mode = eDCGSRunLoopModeExit;
        return true;
    }

    if (event_mask & Communication::eBroadcastBitPacketAvailable)
    {
        if (process->IsRunning())
        {
            if (info->GetRemote()->HandleAsyncPacket() == gdb_not_connected)
                info->mode = eDCGSRunLoopModeExit;
        }
        else
        {
            if (info->GetRemote()->HandleReceivedPacket() == gdb_not_connected)
                info->mode = eDCGSRunLoopModeExit;
        }
    }
    if (event_mask & Communication::eBroadcastBitReadThreadDidExit)
    {
        info->mode = eDCGSRunLoopModeExit;
    }
    if (event_mask & Communication::eBroadcastBitDisconnected)
    {
        info->mode = eDCGSRunLoopModeExit;
    }

    return true;

}

bool
ProcessHandleBroadcastEvent (Broadcaster *broadcaster, uint32_t event_mask, void *baton)
{
    HandleBroadcastEventInfo *info = (HandleBroadcastEventInfo *)baton;
    Process *process = info->GetProcess();
    if (process == NULL)
    {
        info->mode = eDCGSRunLoopModeExit;
        return true;
    }

    if (event_mask & Process::eBroadcastBitStateChanged)
    {
        // Consume all available process events with no timeout
        Event event;
        StateType process_state;
        while ((process_state = process->GetNextEvent (&event)) != eStateInvalid)
        {
            if (StateIsStoppedState(process_state))
                info->GetRemote()->FlushSTDIO();
            HandleProcessStateChange (info, false);

            if (info->mode != eDCGSRunLoopModeInferiorExecuting)
                break;
        }
    }
    else
    if (event_mask & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitSTDERR))
    {
        info->GetRemote()->FlushSTDIO();
    }
    return true;
}

// This function handles the case where our inferior program is stopped and
// we are waiting for gdb remote protocol packets. When a packet occurs that
// makes the inferior run, we need to leave this function with a new state
// as the return code.
void
GSRunLoopInferiorExecuting (HandleBroadcastEventInfo *info)
{
    GDBServerLog::LogIf (GS_LOG_MINIMAL, "#### %s", __FUNCTION__);

    // Init our mode and set 'is_running' based on the current process state
    HandleProcessStateChange (info, true);

    uint32_t desired_mask, acquired_mask;
    Listener listener("GSRunLoopInferiorExecuting");

    desired_mask =  Communication::eBroadcastBitPacketAvailable |
                    Communication::eBroadcastBitReadThreadDidExit  |
                    Communication::eBroadcastBitDisconnected;

    acquired_mask = listener.StartListeningForEvents (&(info->GetRemote()->GetPacketComm()),
                                      desired_mask,
                                      CommunicationHandleBroadcastEvent,
                                      info);

    assert (acquired_mask == desired_mask);
    desired_mask = GDBRemotePacket::eBroadcastBitPacketAvailable;

    acquired_mask = listener.StartListeningForEvents (&(info->GetRemote()->GetPacketComm()),
                                            desired_mask,
                                            CommunicationHandleBroadcastEvent,
                                            info);

    assert (acquired_mask == desired_mask);

    desired_mask =  Process::eBroadcastBitStateChanged |
                    Process::eBroadcastBitSTDOUT |
                    Process::eBroadcastBitSTDERR ;
    acquired_mask = listener.StartListeningForEvents (info->GetProcess (),
                                      desired_mask,
                                      ProcessHandleBroadcastEvent,
                                      info);

    assert (acquired_mask == desired_mask);

    Process *process = info->GetProcess();

    while (process->IsAlive())
    {
        if (!info->GetRemote()->IsConnected())
        {
            info->mode = eDCGSRunLoopModeInferiorKillOrDetach;
            break;
        }

        // We want to make sure we consume all process state changes and have
        // whomever is notifying us to wait for us to reset the event bit before
        // continuing.
        //ctx.Events().SetResetAckMask (GSContext::event_proc_state_changed);
        uint32_t event_mask = 0;
        Broadcaster *broadcaster = listener.WaitForEvent(NULL, &event_mask);
        if (broadcaster)
        {
            listener.HandleBroadcastEvent(broadcaster, event_mask);
        }
    }
}


//----------------------------------------------------------------------
// Convenience function to set up the remote listening port
// Returns 1 for success 0 for failure.
//----------------------------------------------------------------------

static bool
StartListening (HandleBroadcastEventInfo *info, int listen_port)
{
    if (!info->GetRemote()->IsConnected())
    {
        Log::STDOUT ("Listening to port %i...\n", listen_port);
        char connect_url[256];
        snprintf(connect_url, sizeof(connect_url), "listen://%i", listen_port);

        Communication &comm = info->remote_sp->GetPacketComm();
        comm.SetConnection (new ConnectionFileDescriptor);

        if (comm.Connect (connect_url))
        {
            if (comm.StartReadThread())
                return true;

            Log::STDERR ("Failed to start the communication read thread.\n", connect_url);
            comm.Disconnect();
        }
        else
        {
            Log::STDERR ("Failed to connection to %s.\n", connect_url);
        }
        return false;
    }
    return true;
}

//----------------------------------------------------------------------
// ASL Logging callback that can be registered with DNBLogSetLogDCScriptInterpreter::Type
//----------------------------------------------------------------------
//void
//ASLLogDCScriptInterpreter::Type(void *baton, uint32_t flags, const char *format, va_list args)
//{
//    if (format == NULL)
//      return;
//    static aslmsg g_aslmsg = NULL;
//    if (g_aslmsg == NULL)
//    {
//        g_aslmsg = ::asl_new (ASL_TYPE_MSG);
//        char asl_key_sender[PATH_MAX];
//        snprintf(asl_key_sender, sizeof(asl_key_sender), "com.apple.dc-gdbserver-%g", dc_gdbserverVersionNumber);
//        ::asl_set (g_aslmsg, ASL_KEY_SENDER, asl_key_sender);
//    }
//
//    int asl_level;
//    if (flags & DNBLOG_FLAG_FATAL)        asl_level = ASL_LEVEL_CRIT;
//    else if (flags & DNBLOG_FLAG_ERROR)   asl_level = ASL_LEVEL_ERR;
//    else if (flags & DNBLOG_FLAG_WARNING) asl_level = ASL_LEVEL_WARNING;
//    else if (flags & DNBLOG_FLAG_VERBOSE) asl_level = ASL_LEVEL_WARNING; //ASL_LEVEL_INFO;
//    else                                  asl_level = ASL_LEVEL_WARNING; //ASL_LEVEL_DEBUG;
//
//    ::asl_vlog (NULL, g_aslmsg, asl_level, format, args);
//}

//----------------------------------------------------------------------
// FILE based Logging callback that can be registered with
// DNBLogSetLogDCScriptInterpreter::Type
//----------------------------------------------------------------------
void
FileLogDCScriptInterpreter::Type(void *baton, uint32_t flags, const char *format, va_list args)
{
    if (baton == NULL || format == NULL)
      return;

    ::vfprintf ((FILE *)baton, format, args);
    ::fprintf ((FILE *)baton, "\n");
}

//----------------------------------------------------------------------
// option descriptors for getopt_long()
//----------------------------------------------------------------------
static struct option g_long_options[] =
{
    { "arch",       required_argument,  NULL,               'c' },
    { "attach",     required_argument,  NULL,               'a' },
    { "debug",      no_argument,        NULL,               'g' },
    { "verbose",    no_argument,        NULL,               'v' },
    { "lockdown",   no_argument,        &g_lockdown_opt,    1   },  // short option "-k"
    { "applist",    no_argument,        &g_applist_opt,     1   },  // short option "-t"
    { "log-file",   required_argument,  NULL,               'l' },
    { "log-flags",  required_argument,  NULL,               'f' },
    { "launch",     required_argument,  NULL,               'x' },  // Valid values are "auto", "posix-spawn", "fork-exec", "springboard" (arm only)
    { "waitfor",    required_argument,  NULL,               'w' },  // Wait for a process whose namet starts with ARG
    { "waitfor-interval", required_argument,    NULL,       'i' },  // Time in usecs to wait between sampling the pid list when waiting for a process by name
    { "waitfor-duration", required_argument,    NULL,       'd' },  // The time in seconds to wait for a process to show up by name
    { NULL,         0,                  NULL,               0   }
};

extern const double dc_gdbserverVersionNumber;
int
main (int argc, char *argv[])
{
    Initialize();
    Host::ThreadCreated ("[main]");

    g_isatty = ::isatty (STDIN_FILENO);

//  signal (SIGINT, signal_handler);
    signal (SIGPIPE, signal_handler);

    Log *log = GDBServerLog::GetLogIfAllCategoriesSet(GS_LOG_ALL);
    const char *this_exe_name = argv[0];
    int i;
    int attach_pid = LLDB_INVALID_PROCESS_ID;
    for (i=0; i<argc; i++)
        GDBServerLog::LogIf(GS_LOG_DEBUG, "argv[%i] = %s", i, argv[i]);

    FILE* log_file = NULL;
    uint32_t log_flags = 0;
    // Parse our options
    int ch;
    int long_option_index = 0;
    int debug = 0;
    std::string waitfor_pid_name;           // Wait for a process that starts with this name
    std::string attach_pid_name;
    useconds_t waitfor_interval = 1000;     // Time in usecs between process lists polls when waiting for a process by name, default 1 msec.
    useconds_t waitfor_duration = 0;        // Time in seconds to wait for a process by name, 0 means wait forever.
    ArchSpec arch;
    GSRunLoopMode start_mode = eDCGSRunLoopModeExit;

    while ((ch = getopt_long(argc, argv, "a:c:d:gi:vktl:f:w:x:", g_long_options, &long_option_index)) != -1)
    {
//      DNBLogDebug("option: ch == %c (0x%2.2x) --%s%c%s\n",
//                    ch, (uint8_t)ch,
//                    g_long_options[long_option_index].name,
//                    g_long_options[long_option_index].has_arg ? '=' : ' ',
//                    optarg ? optarg : "");
        switch (ch)
        {
        case 0:   // Any optional that auto set themselves will return 0
            break;

        case 'c':
            arch.SetArch(optarg);
            if (!arch.IsValid())
            {
                Log::STDERR ("error: invalid arch string '%s'\n", optarg);
                exit (8);
            }
            break;

        case 'a':
            if (optarg && optarg[0])
            {
                if (isdigit(optarg[0]))
                {
                    char *end = NULL;
                    attach_pid = strtoul(optarg, &end, 0);
                    if (end == NULL || *end != '\0')
                    {
                        Log::STDERR ("error: invalid pid option '%s'\n", optarg);
                        exit (4);
                    }
                }
                else
                {
                    attach_pid_name = optarg;
                }
                start_mode = eDCGSRunLoopModeInferiorAttaching;
            }
            break;

        // --waitfor=NAME
        case 'w':
            if (optarg && optarg[0])
            {
                waitfor_pid_name = optarg;
                start_mode = eDCGSRunLoopModeInferiorAttaching;
            }
            break;

        // --waitfor-interval=USEC
        case 'i':
            if (optarg && optarg[0])
            {
                char *end = NULL;
                waitfor_interval = strtoul(optarg, &end, 0);
                if (end == NULL || *end != '\0')
                {
                    Log::STDERR ("error: invalid waitfor-interval option value '%s'.\n", optarg);
                    exit (6);
                }
            }
            break;

        // --waitfor-duration=SEC
        case 'd':
            if (optarg && optarg[0])
            {
                char *end = NULL;
                waitfor_duration = strtoul(optarg, &end, 0);
                if (end == NULL || *end != '\0')
                {
                    Log::STDERR ("error: invalid waitfor-duration option value '%s'.\n", optarg);
                    exit (7);
                }
            }
            break;

        case 'x':
            if (optarg && optarg[0])
            {
                if (strcasecmp(optarg, "auto") == 0)
                    g_launch_flavor = eLaunchFlavorDefault;
                else if (strcasestr(optarg, "posix") == optarg)
                    g_launch_flavor = eLaunchFlavorPosixSpawn;
                else if (strcasestr(optarg, "fork") == optarg)
                    g_launch_flavor = eLaunchFlavorForkExec;
#if defined (__arm__)
                else if (strcasestr(optarg, "spring") == optarg)
                    g_launch_flavor = eLaunchFlavorSpringBoard;
#endif
                else
                {
                    Log::STDERR ("error: invalid TYPE for the --launch=TYPE (-x TYPE) option: '%s'\n", optarg);
                    Log::STDERR ("Valid values TYPE are:\n");
                    Log::STDERR ("  auto    Auto-detect the best launch method to use.\n");
                    Log::STDERR ("  posix   Launch the executable using posix_spawn.\n");
                    Log::STDERR ("  fork    Launch the executable using fork and exec.\n");
#if defined (__arm__)
                    Log::STDERR ("  spring  Launch the executable through Springboard.\n");
#endif
                    exit (5);
                }
            }
            break;

        case 'l': // Set Log File
            if (optarg && optarg[0])
            {
                if (strcasecmp(optarg, "stdout") == 0)
                    log_file = stdout;
                else if (strcasecmp(optarg, "stderr") == 0)
                    log_file = stderr;
                else
                    log_file = fopen(optarg, "w+");

                if (log_file == NULL)
                {
                    const char *errno_str = strerror(errno);
                    Log::STDERR ("Failed to open log file '%s' for writing: errno = %i (%s)", optarg, errno, errno_str ? errno_str : "unknown error");
                }
            }
            break;

        case 'f': // Log Flags
            if (optarg && optarg[0])
                log_flags = strtoul(optarg, NULL, 0);
            break;

        case 'g':
            debug = 1;
            //DNBLogSetDebug(1);
            break;

        case 't':
            g_applist_opt = 1;
            break;

        case 'k':
            g_lockdown_opt = 1;
            break;

        case 'v':
            //DNBLogSetVerbose(1);
            break;
        }
    }

    // Skip any options we consumed with getopt_long
    argc -= optind;
    argv += optind;

    // It is ok for us to set NULL as the logfile (this will disable any logging)

//    if (log_file != NULL)
//    {
//        DNBLogSetLogDCScriptInterpreter::Type(FileLogDCScriptInterpreter::Type, log_file);
//        // If our log file was set, yet we have no log flags, log everything!
//        if (log_flags == 0)
//            log_flags = LOG_ALL | LOG_DCGS_ALL;
//
//        DNBLogSetLogMask (log_flags);
//    }
//    else
//    {
//        // Enable DNB logging
//        DNBLogSetLogDCScriptInterpreter::Type(ASLLogDCScriptInterpreter::Type, NULL);
//        DNBLogSetLogMask (log_flags);
//
//    }

    // as long as we're dropping remotenub in as a replacement for gdbserver,
    // explicitly note that this is not gdbserver.

    Log::STDOUT ("debugserver-%g \n", dc_gdbserverVersionNumber);
    int listen_port = -1;
    if (g_lockdown_opt == 0 && g_applist_opt == 0)
    {
        // Make sure we at least have port
        if (argc < 1)
        {
            Log::STDERR ("Usage: %s host:port [program-name program-arg1 program-arg2 ...]\n", this_exe_name);
            exit (1);
        }
        // accept 'localhost:' prefix on port number

        std::string host_str;
        std::string port_str(argv[0]);

        // We just used the host:port arg...
        argc--;
        argv++;

        size_t port_idx = port_str.find(':');
        if (port_idx != std::string::npos)
        {
            host_str.assign(port_str, 0, port_idx);
            port_str.erase(0, port_idx + 1);
        }

        if (port_str.empty())
        {
            Log::STDERR ("error: no port specified\nUsage: %s host:port [program-name program-arg1 program-arg2 ...]\n", this_exe_name);
            exit (2);
        }
        else if (port_str.find_first_not_of("0123456789") != std::string::npos)
        {
            Log::STDERR ("error: port must be an integer: %s\nUsage: %s host:port [program-name program-arg1 program-arg2 ...]\n", port_str.c_str(), this_exe_name);
            exit (3);
        }
        //DNBLogDebug("host_str = '%s'  port_str = '%s'", host_str.c_str(), port_str.c_str());
        listen_port = atoi (port_str.c_str());
    }


    // We must set up some communications now.

    FileSpec exe_spec;
    if (argv[0])
        exe_spec.SetFile (argv[0]);

    HandleBroadcastEventInfo info;
    info.target_sp = TargetList::SharedList().CreateTarget(&exe_spec, &arch);
    ProcessSP process_sp (info.target_sp->CreateProcess ());
    info.remote_sp.reset (new GDBRemoteSession (process_sp));

    info.remote_sp->SetLog (log);
    StreamString sstr;
    sstr.Printf("ConnectionFileDescriptor(%s)", argv[0]);

    if (info.remote_sp.get() == NULL)
    {
        Log::STDERR ("error: failed to create a GDBRemoteSession class\n");
        return -1;
    }



    //  If we know we're waiting to attach, we don't need any of this other info.
    if (start_mode != eDCGSRunLoopModeInferiorAttaching)
    {
        if (argc == 0 || g_lockdown_opt)
        {
            if (g_lockdown_opt != 0)
            {
                // Work around for SIGPIPE crashes due to posix_spawn issue. We have to close
                // STDOUT and STDERR, else the first time we try and do any, we get SIGPIPE and
                // die as posix_spawn is doing bad things with our file descriptors at the moment.
                int null = open("/dev/null", O_RDWR);
                dup2(null, STDOUT_FILENO);
                dup2(null, STDERR_FILENO);
            }
            else if (g_applist_opt != 0)
            {
//                // List all applications we are able to see
//                std::string applist_plist;
//                int err = ListApplications(applist_plist, false, false);
//                if (err == 0)
//                {
//                    fputs (applist_plist.c_str(), stdout);
//                }
//                else
//                {
//                    Log::STDERR ("error: ListApplications returned error %i\n", err);
//                }
//                // Exit with appropriate error if we were asked to list the applications
//                // with no other args were given (and we weren't trying to do this over
//                // lockdown)
//                return err;
                return 0;
            }

            //DNBLogDebug("Get args from remote protocol...");
            start_mode = eDCGSRunLoopModeGetStartModeFromRemoteProtocol;
        }
        else
        {
            start_mode = eDCGSRunLoopModeInferiorLaunching;
            // Fill in the argv array in the context from the rest of our args.
            // Skip the name of this executable and the port number
            info.remote_sp->SetArguments (argc, argv);
        }
    }

    if (start_mode == eDCGSRunLoopModeExit)
      return -1;

    info.mode = start_mode;

    while (info.mode != eDCGSRunLoopModeExit)
    {
        switch (info.mode)
        {
        case eDCGSRunLoopModeGetStartModeFromRemoteProtocol:
 #if defined (__arm__)
            if (g_lockdown_opt)
            {
                if (!info.remote_sp->GetCommunication()->IsConnected())
                {
                    if (info.remote_sp->GetCommunication()->ConnectToService () != gdb_success)
                    {
                        Log::STDERR ("Failed to get connection from a remote gdb process.\n");
                        info.mode = eDCGSRunLoopModeExit;
                    }
                    else if (g_applist_opt != 0)
                    {
                        // List all applications we are able to see
                        std::string applist_plist;
                        if (ListApplications(applist_plist, false, false) == 0)
                        {
                            //DNBLogDebug("Task list: %s", applist_plist.c_str());

                            info.remote_sp->GetCommunication()->Write(applist_plist.c_str(), applist_plist.size());
                            // Issue a read that will never yield any data until the other side
                            // closes the socket so this process doesn't just exit and cause the
                            // socket to close prematurely on the other end and cause data loss.
                            std::string buf;
                            info.remote_sp->GetCommunication()->Read(buf);
                        }
                        info.remote_sp->GetCommunication()->Disconnect(false);
                        info.mode = eDCGSRunLoopModeExit;
                        break;
                    }
                    else
                    {
                        // Start watching for remote packets
                        info.remote_sp->StartReadRemoteDataThread();
                    }
                }
            }
            else
#endif
            {
                if (StartListening (&info, listen_port))
                    Log::STDOUT ("Got a connection, waiting for process information for launching or attaching.\n");
                else
                    info.mode = eDCGSRunLoopModeExit;
            }

            if (info.mode != eDCGSRunLoopModeExit)
                GSRunLoopGetStartModeFromRemote (&info);
            break;

        case eDCGSRunLoopModeInferiorAttaching:
            if (!waitfor_pid_name.empty())
            {
                // Set our end wait time if we are using a waitfor-duration
                // option that may have been specified

                TimeValue attach_timeout_abstime;
                if (waitfor_duration != 0)
                {
                    attach_timeout_abstime = TimeValue::Now();
                    attach_timeout_abstime.OffsetWithSeconds (waitfor_duration);
                }
                GSLaunchFlavor launch_flavor = g_launch_flavor;
                if (launch_flavor == eLaunchFlavorDefault)
                {
                    // Our default launch method is posix spawn
                    launch_flavor = eLaunchFlavorPosixSpawn;

#if defined (__arm__)
                    // Check if we have an app bundle, if so launch using SpringBoard.
                    if (waitfor_pid_name.find (".app") != std::string::npos)
                    {
                        launch_flavor = eLaunchFlavorSpringBoard;
                    }
#endif
                }

                //ctx.SetLaunchFlavor(launch_flavor);


                lldb::pid_t pid = info.GetProcess()->Attach (waitfor_pid_name.c_str());
                if (pid == LLDB_INVALID_PROCESS_ID)
                {
                    info.GetRemote()->GetLaunchError() = info.GetProcess()->GetError();
                    Log::STDERR ("error: failed to attach to process named: \"%s\" %s", waitfor_pid_name.c_str(), info.GetRemote()->GetLaunchError().AsCString());
                    info.mode = eDCGSRunLoopModeExit;
                }
                else
                {
                    info.mode = eDCGSRunLoopModeInferiorExecuting;
                }
            }
            else if (attach_pid != LLDB_INVALID_PROCESS_ID)
            {
                Log::STDOUT ("Attaching to process %i...\n", attach_pid);
                info.mode = GSRunLoopLaunchAttaching (&info, attach_pid);
                if (info.mode != eDCGSRunLoopModeInferiorExecuting)
                {
                    const char *error_str = info.GetRemote()->GetLaunchError().AsCString();
                    Log::STDERR ("error: failed to attach process %i: %s\n", attach_pid, error_str ? error_str : "unknown error.");
                    info.mode = eDCGSRunLoopModeExit;
                }
            }
            else if (!attach_pid_name.empty ())
            {
                lldb::pid_t pid = info.GetProcess()->Attach (waitfor_pid_name.c_str());
                if (pid == LLDB_INVALID_PROCESS_ID)
                {
                    info.GetRemote()->GetLaunchError() = info.GetProcess()->GetError();
                    Log::STDERR ("error: failed to attach to process named: \"%s\" %s", waitfor_pid_name.c_str(), info.GetRemote()->GetLaunchError().AsCString());
                    info.mode = eDCGSRunLoopModeExit;
                }
                else
                {
                    info.mode = eDCGSRunLoopModeInferiorExecuting;
                }
            }
            else
            {
                Log::STDERR ("error: asked to attach with empty name and invalid PID.");
                info.mode = eDCGSRunLoopModeExit;
            }

            if (info.mode != eDCGSRunLoopModeExit)
            {
                if (StartListening (&info, listen_port))
                    Log::STDOUT ("Got a connection, waiting for debugger instructions for process %d.\n", attach_pid);
                else
                    info.mode = eDCGSRunLoopModeExit;
            }
            break;

        case eDCGSRunLoopModeInferiorLaunching:
            info.mode = GSRunLoopLaunchInferior (&info);

            if (info.mode == eDCGSRunLoopModeInferiorExecuting)
            {
                if (StartListening (&info, listen_port))
                    Log::STDOUT ("Got a connection, waiting for debugger instructions for task \"%s\".\n", argv[0]);
                else
                    info.mode = eDCGSRunLoopModeExit;
            }
            else
            {
                Log::STDERR ("error: failed to launch process %s: %s\n", argv[0], info.GetRemote()->GetLaunchError().AsCString());
            }
            break;

        case eDCGSRunLoopModeInferiorExecuting:
            GSRunLoopInferiorExecuting (&info);
            break;

        case eDCGSRunLoopModeInferiorKillOrDetach:
            {
                Process *process = info.GetProcess();
                if (process && process->IsAlive())
                {
                    process->Kill(SIGCONT);
                    process->Kill(SIGKILL);
                }
            }
            info.mode = eDCGSRunLoopModeExit;
            break;

        default:
          info.mode = eDCGSRunLoopModeExit;
        case eDCGSRunLoopModeExit:
            break;
        }
    }

    return 0;
}