main.cpp

Go to the documentation of this file.

 
#include "http_server.h"
#include "json.h"
#include "lldb_controller.h"
#include <ascii-chat/util/parsing.h>
 
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <climits>
 
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
 
namespace {
 
// Global controller and server (for signal handling)
ascii_query::LLDBController *g_controller = nullptr;
ascii_query::HttpServer *g_server = nullptr;
volatile sig_atomic_t g_shutdown_requested = 0;
 
void signalHandler(int sig) {
  (void)sig;
  g_shutdown_requested = 1;
  if (g_server) {
    g_server->stop();
  }
}
 
void printUsage(const char *program) {
  fprintf(stderr, "Usage: %s [options]\n\n", program);
  fprintf(stderr, "Options:\n");
  fprintf(stderr, "  --attach <pid>         Attach to process by PID\n");
  fprintf(stderr, "  --attach-name <name>   Attach to process by name\n");
  fprintf(stderr, "  --wait                 Wait for process to start (with --attach-name)\n");
  fprintf(stderr, "  --port <port>          HTTP server port (default: 9999)\n");
  fprintf(stderr, "  --help                 Show this help\n");
  fprintf(stderr, "\nExamples:\n");
  fprintf(stderr, "  %s --attach 12345 --port 9999\n", program);
  fprintf(stderr, "  %s --attach-name ascii-chat --wait\n", program);
  fprintf(stderr, "\nQuery endpoints:\n");
  fprintf(stderr, "  GET  /                 Status page\n");
  fprintf(stderr, "  GET  /process          Process information\n");
  fprintf(stderr, "  GET  /threads          Thread list\n");
  fprintf(stderr, "  GET  /frames           Stack frames (when stopped)\n");
  fprintf(stderr, "  GET  /query            Query a variable\n");
  fprintf(stderr, "  POST /continue         Resume execution\n");
  fprintf(stderr, "  POST /step             Single step\n");
  fprintf(stderr, "  POST /detach           Detach from process\n");
}
 
// Convert ProcessState to string
const char *processStateToString(ascii_query::ProcessState state) {
  switch (state) {
  case ascii_query::ProcessState::Invalid:
    return "invalid";
  case ascii_query::ProcessState::Running:
    return "running";
  case ascii_query::ProcessState::Stopped:
    return "stopped";
  case ascii_query::ProcessState::Exited:
    return "exited";
  case ascii_query::ProcessState::Crashed:
    return "crashed";
  case ascii_query::ProcessState::Detached:
    return "detached";
  }
  return "unknown";
}
 
// Build JSON for ThreadInfo
ascii_query::json::JsonObject threadToJson(const ascii_query::ThreadInfo &thread) {
  ascii_query::json::JsonObject obj;
  obj.set("id", thread.id);
  obj.set("index", static_cast<int64_t>(thread.index));
  obj.set("name", thread.name);
  obj.set("stop_reason", thread.stop_reason);
  obj.set("function", thread.function);
  obj.set("file", thread.file);
  obj.set("line", static_cast<int64_t>(thread.line));
  obj.set("selected", thread.is_selected);
  return obj;
}
 
// Build JSON for FrameInfo
ascii_query::json::JsonObject frameToJson(const ascii_query::FrameInfo &frame) {
  ascii_query::json::JsonObject obj;
  obj.set("index", static_cast<int64_t>(frame.index));
  obj.set("function", frame.function);
  obj.set("file", frame.file);
  obj.set("line", static_cast<int64_t>(frame.line));
  obj.set("pc", frame.pc);
  obj.set("fp", frame.fp);
  return obj;
}
 
// Build JSON for VariableInfo
ascii_query::json::JsonObject variableToJson(const ascii_query::VariableInfo &var, int max_depth = 3) {
  ascii_query::json::JsonObject obj;
  obj.set("name", var.name);
  obj.set("type", var.type);
  obj.set("value", var.value);
  if (!var.summary.empty()) {
    obj.set("summary", var.summary);
  }
  obj.set("address", var.address);
  obj.set("size", static_cast<int64_t>(var.size));
  obj.set("valid", var.is_valid);
  obj.set("pointer", var.is_pointer);
  obj.set("aggregate", var.is_aggregate);
 
  if (!var.children.empty() && max_depth > 0) {
    ascii_query::json::JsonArray children;
    for (const auto &child : var.children) {
      children.add(variableToJson(child, max_depth - 1));
    }
    obj.set("children", children);
  }
 
  return obj;
}
 
// Build JSON for BreakpointInfo
ascii_query::json::JsonObject breakpointToJson(const ascii_query::BreakpointInfo &bp) {
  ascii_query::json::JsonObject obj;
  obj.set("id", static_cast<int64_t>(bp.id));
  obj.set("file", bp.file);
  obj.set("line", static_cast<int64_t>(bp.line));
  obj.set("condition", bp.condition);
  obj.set("hit_count", static_cast<int64_t>(bp.hit_count));
  obj.set("enabled", bp.enabled);
  obj.set("resolved", bp.resolved);
  return obj;
}
 
// Setup HTTP routes
void setupRoutes(ascii_query::HttpServer &server, ascii_query::LLDBController &controller) {
  using namespace ascii_query;
  using namespace ascii_query::json;
 
  // GET / - Status page (plain text for terminal users)
  server.addRoute("GET", "/", [&controller](const HttpRequest &) {
    ProcessState state = controller.state();
    std::string state_str = processStateToString(state);
 
    std::string text = "ascii-query-server\n";
    text += "==================\n\n";
    text += "Target PID:   " + std::to_string(controller.targetPid()) + "\n";
    text += "Target Name:  " + controller.targetName() + "\n";
    text += "State:        " + state_str + "\n";
    text += "\n";
    text += "Endpoints:\n";
    text += "  GET  /                 Status page (this)\n";
    text += "  GET  /process          Process information (JSON)\n";
    text += "  GET  /threads          Thread list (JSON)\n";
    text += "  GET  /frames           Stack frames when stopped (JSON)\n";
    text += "  GET  /query?name=VAR   Query a variable (JSON)\n";
    text += "  GET  /breakpoints      List breakpoints (JSON)\n";
    text += "  POST /continue         Resume execution\n";
    text += "  POST /stop             Stop execution\n";
    text += "  POST /step             Single step (add ?over or ?out)\n";
    text += "  POST /detach           Detach from process\n";
    text += "\n";
    text += "Examples:\n";
    text += "  curl localhost:9999/process\n";
    text += "  curl localhost:9999/query?name=frame.width\n";
    text += "  curl 'localhost:9999/query?file=server.c&line=100&name=client_count&break'\n";
    text += "  curl -X POST localhost:9999/continue\n";
 
    return HttpResponse::text(text);
  });
 
  // GET /process - Process information
  server.addRoute("GET", "/process", [&controller](const HttpRequest &) {
    JsonObject obj;
    obj.set("pid", static_cast<int64_t>(controller.targetPid()));
    obj.set("name", controller.targetName());
    obj.set("state", processStateToString(controller.state()));
    obj.set("attached", controller.isAttached());
    if (!controller.lastError().empty()) {
      obj.set("last_error", controller.lastError());
    }
    return HttpResponse::json(obj.toString());
  });
 
  // GET /threads - Thread list
  server.addRoute("GET", "/threads", [&controller](const HttpRequest &) {
    auto threads = controller.getThreads();
    JsonArray arr;
    for (const auto &thread : threads) {
      arr.add(threadToJson(thread));
    }
    JsonObject obj;
    obj.set("count", static_cast<int64_t>(threads.size()));
    obj.set("threads", arr);
    return HttpResponse::json(obj.toString());
  });
 
  // GET /frames - Stack frames
  server.addRoute("GET", "/frames", [&controller](const HttpRequest &req) {
    int max_frames = req.paramInt("max", 50);
    auto frames = controller.getFrames(static_cast<uint32_t>(max_frames));
    JsonArray arr;
    for (const auto &frame : frames) {
      arr.add(frameToJson(frame));
    }
    JsonObject obj;
    obj.set("count", static_cast<int64_t>(frames.size()));
    obj.set("frames", arr);
    return HttpResponse::json(obj.toString());
  });
 
  // GET /query - Query a variable
  server.addRoute("GET", "/query", [&controller](const HttpRequest &req) {
    std::string file = req.param("file");
    int line = req.paramInt("line", 0);
    std::string name = req.param("name");
    int frame_index = req.paramInt("frame", 0);
    int expand_depth = req.paramInt("depth", 0);
    bool should_break = req.hasParam("break");
    int timeout_ms = req.paramInt("timeout", 5000);
 
    if (name.empty()) {
      return HttpResponse::badRequest("Missing 'name' parameter");
    }
 
    ProcessState state = controller.state();
    bool is_stopped = (state == ProcessState::Stopped);
 
    // If we have file:line and need to break, set breakpoint
    if (!file.empty() && line > 0 && should_break && !is_stopped) {
      int bp_id = controller.setBreakpoint(file, static_cast<uint32_t>(line));
      if (bp_id < 0) {
        JsonObject obj;
        obj.set("status", "error");
        obj.set("error", "breakpoint_failed");
        obj.set("message", "Failed to set breakpoint at " + file + ":" + std::to_string(line));
        return HttpResponse::json(obj.toString());
      }
 
      bool hit = controller.waitForBreakpoint(static_cast<uint32_t>(timeout_ms));
      if (!hit) {
        controller.removeBreakpoint(bp_id);
        JsonObject obj;
        obj.set("status", "error");
        obj.set("error", "timeout");
        obj.set("message", "Breakpoint not hit within " + std::to_string(timeout_ms) + "ms");
        return HttpResponse::json(obj.toString());
      }
      is_stopped = true;
    }
 
    // Read the variable
    int actual_expand = expand_depth > 0 ? expand_depth : (req.hasParam("expand") ? 3 : 0);
    auto var = controller.readVariable(name, static_cast<uint32_t>(frame_index), static_cast<uint32_t>(actual_expand));
 
    if (!var) {
      JsonObject obj;
      obj.set("status", "error");
      obj.set("error", "not_found");
      obj.set("message", "Variable '" + name + "' not found");
      obj.set("stopped", is_stopped);
      return HttpResponse::json(obj.toString());
    }
 
    JsonObject obj;
    obj.set("status", "ok");
    obj.set("stopped", is_stopped);
    obj.set("result", variableToJson(*var, actual_expand > 0 ? actual_expand : 3));
    return HttpResponse::json(obj.toString());
  });
 
  // GET /breakpoints - List breakpoints
  server.addRoute("GET", "/breakpoints", [&controller](const HttpRequest &) {
    auto breakpoints = controller.getBreakpoints();
    JsonArray arr;
    for (const auto &bp : breakpoints) {
      arr.add(breakpointToJson(bp));
    }
    JsonObject obj;
    obj.set("count", static_cast<int64_t>(breakpoints.size()));
    obj.set("breakpoints", arr);
    return HttpResponse::json(obj.toString());
  });
 
  // POST /breakpoints - Set breakpoint
  server.addRoute("POST", "/breakpoints", [&controller](const HttpRequest &req) {
    std::string file = req.param("file");
    int line = req.paramInt("line", 0);
    std::string condition = req.param("condition");
 
    if (file.empty() || line <= 0) {
      return HttpResponse::badRequest("Missing 'file' and 'line' parameters");
    }
 
    int bp_id = controller.setBreakpoint(file, static_cast<uint32_t>(line), condition);
    if (bp_id < 0) {
      JsonObject obj;
      obj.set("status", "error");
      obj.set("message", controller.lastError());
      return HttpResponse::json(obj.toString());
    }
 
    auto bp = controller.getBreakpoint(bp_id);
    JsonObject obj;
    obj.set("status", "ok");
    if (bp) {
      obj.set("breakpoint", breakpointToJson(*bp));
    }
    return HttpResponse::json(obj.toString());
  });
 
  // DELETE /breakpoints - Remove breakpoint
  server.addRoute("DELETE", "/breakpoints", [&controller](const HttpRequest &req) {
    int bp_id = req.paramInt("id", -1);
    if (bp_id < 0) {
      return HttpResponse::badRequest("Missing 'id' parameter");
    }
    bool removed = controller.removeBreakpoint(static_cast<int32_t>(bp_id));
    JsonObject obj;
    obj.set("status", removed ? "ok" : "error");
    if (!removed) {
      obj.set("message", "Breakpoint not found");
    }
    return HttpResponse::json(obj.toString());
  });
 
  // POST /continue - Resume execution
  server.addRoute("POST", "/continue", [&controller](const HttpRequest &) {
    bool resumed = controller.resume();
    JsonObject obj;
    obj.set("status", resumed ? "running" : "error");
    if (!resumed) {
      obj.set("error", controller.lastError());
    }
    return HttpResponse::json(obj.toString());
  });
 
  // POST /stop - Stop execution
  server.addRoute("POST", "/stop", [&controller](const HttpRequest &) {
    bool stopped = controller.stop();
    JsonObject obj;
    obj.set("status", stopped ? "stopped" : "error");
    if (!stopped) {
      obj.set("error", controller.lastError());
    }
    return HttpResponse::json(obj.toString());
  });
 
  // POST /step - Single step
  server.addRoute("POST", "/step", [&controller](const HttpRequest &req) {
    bool over = req.hasParam("over");
    bool out = req.hasParam("out");
    bool success = out ? controller.stepOut() : (over ? controller.stepOver() : controller.stepInto());
    JsonObject obj;
    obj.set("status", success ? "ok" : "error");
    if (!success) {
      obj.set("error", controller.lastError());
    }
    return HttpResponse::json(obj.toString());
  });
 
  // POST /detach - Detach from process
  server.addRoute("POST", "/detach", [&controller](const HttpRequest &) {
    controller.detach();
    JsonObject obj;
    obj.set("status", "detached");
    return HttpResponse::json(obj.toString());
  });
}
 
} // namespace
 
int main(int argc, char *argv[]) {
  // Parse command line arguments
  pid_t attach_pid = 0;
  std::string attach_name;
  bool wait_for = false;
  uint16_t port = 9999;
 
  for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
      printUsage(argv[0]);
      return 0;
    } else if (strcmp(argv[i], "--attach") == 0 && i + 1 < argc) {
      // Parse PID using safe parsing utility
      unsigned long pid_val = 0;
      if (parse_ulong(argv[++i], &pid_val, 1, ULONG_MAX) != ASCIICHAT_OK) {
        fprintf(stderr, "Error: Invalid PID value\n");
        return 1;
      }
      attach_pid = static_cast<pid_t>(pid_val);
    } else if (strcmp(argv[i], "--attach-name") == 0 && i + 1 < argc) {
      attach_name = argv[++i];
    } else if (strcmp(argv[i], "--wait") == 0) {
      wait_for = true;
    } else if (strcmp(argv[i], "--port") == 0 && i + 1 < argc) {
      // Parse port using safe parsing utility with proper range validation
      if (parse_port(argv[++i], &port) != ASCIICHAT_OK) {
        fprintf(stderr, "Error: Invalid port number (must be 1-65535)\n");
        return 1;
      }
    } else {
      fprintf(stderr, "Unknown option: %s\n", argv[i]);
      printUsage(argv[0]);
      return 1;
    }
  }
 
  // Validate arguments
  if (attach_pid == 0 && attach_name.empty()) {
    fprintf(stderr, "Error: Must specify --attach <pid> or --attach-name <name>\n\n");
    printUsage(argv[0]);
    return 1;
  }
 
  // Setup signal handlers
  signal(SIGINT, signalHandler);
  signal(SIGTERM, signalHandler);
#ifndef _WIN32
  signal(SIGPIPE, SIG_IGN);
#endif
 
  // Initialize LLDB controller
  ascii_query::LLDBController controller;
  g_controller = &controller;
 
  if (!controller.initialize()) {
    fprintf(stderr, "Error: Failed to initialize LLDB: %s\n", controller.lastError().c_str());
    return 1;
  }
 
  // Attach to target
  fprintf(stderr, "[ascii-query-server] Attaching to ");
  if (attach_pid > 0) {
    fprintf(stderr, "PID %llu...\n", static_cast<unsigned long long>(attach_pid));
    if (!controller.attach(attach_pid)) {
      fprintf(stderr, "Error: Failed to attach: %s\n", controller.lastError().c_str());
      return 1;
    }
  } else {
    fprintf(stderr, "process '%s'%s...\n", attach_name.c_str(), wait_for ? " (waiting)" : "");
    if (!controller.attachByName(attach_name, wait_for)) {
      fprintf(stderr, "Error: Failed to attach: %s\n", controller.lastError().c_str());
      return 1;
    }
  }
 
  fprintf(stderr, "[ascii-query-server] Attached to %s (PID %llu)\n", controller.targetName().c_str(),
          static_cast<unsigned long long>(controller.targetPid()));
 
  // Resume the target (it's stopped after attach)
  if (controller.state() == ascii_query::ProcessState::Stopped) {
    fprintf(stderr, "[ascii-query-server] Resuming target...\n");
    controller.resume();
  }
 
  // Setup HTTP server
  ascii_query::HttpServer server;
  g_server = &server;
 
  setupRoutes(server, controller);
 
  // Start HTTP server
  if (!server.start(port)) {
    fprintf(stderr, "Error: Failed to start HTTP server: %s\n", server.lastError().c_str());
    controller.detach();
    return 1;
  }
 
  fprintf(stderr, "[ascii-query-server] HTTP server listening on http://localhost:%d\n", port);
  fprintf(stderr, "[ascii-query-server] Press Ctrl+C to stop\n");
 
  // Wait for shutdown
  while (!g_shutdown_requested && controller.isAttached()) {
#ifdef _WIN32
    Sleep(100);
#else
    usleep(100000);
#endif
    ascii_query::ProcessState state = controller.state();
    if (state == ascii_query::ProcessState::Exited || state == ascii_query::ProcessState::Crashed) {
      fprintf(stderr, "[ascii-query-server] Target %s, shutting down\n",
              state == ascii_query::ProcessState::Exited ? "exited" : "crashed");
      break;
    }
  }
 
  // Cleanup
  fprintf(stderr, "[ascii-query-server] Shutting down...\n");
  server.stop();
  controller.detach();
  controller.shutdown();
 
  fprintf(stderr, "[ascii-query-server] Done\n");
  return 0;
}