gdbc 0.1.0

comprehensive terminal-based GDB client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use clap::Parser;
use gdbc::{Command, Error, GdbClient};
use rustyline::history::History;
use rustyline::{DefaultEditor, error::ReadlineError};
use std::path::PathBuf;
use std::str::FromStr;

#[derive(Parser, Debug)]
#[command(name = "gdbc")]
#[command(author = "Your Name <your.email@example.com>")]
#[command(version = "0.1.0")]
#[command(about = "A GDB client for terminal", long_about = None)]
struct Cli {
    /// Host to connect to
    #[arg(short = 'H', long, default_value = "localhost")]
    host: String,

    /// Port to connect to
    #[arg(short, long, default_value_t = 55555)]
    port: u16,

    /// Single instruction to execute
    #[arg(short, long)]
    instruction: Option<String>,

    /// Disable colored output
    #[arg(long, default_value_t = false)]
    no_color: bool,

    /// Enable debug output
    #[arg(short, long, default_value_t = false)]
    debug: bool,
}

fn main() -> Result<(), Error> {
    // Parse command line arguments
    let cli = Cli::parse();

    // Initialize logger
    if cli.debug {
        env_logger::init();
    }

    // Initialize GDB client
    let mut client = GdbClient::new();
    let use_colors = !cli.no_color;

    // Single instruction mode
    if let Some(instruction) = cli.instruction {
        let cmd = Command::from_str(&instruction)?;

        // Connect first if needed
        if !matches!(cmd, Command::Connect(_, _)) {
            // Try to connect with the provided host/port
            let addr = format!("{}:{}", cli.host, cli.port);
            match client.connect(addr) {
                Ok(_) => println!("Connected to GDB server at {}:{}", cli.host, cli.port),
                Err(e) => {
                    eprintln!("Failed to connect to GDB server: {}", e);
                    return Err(e);
                }
            }
        }

        // Execute single instruction
        gdbc::commands::execute_command(cmd, &mut client, use_colors)?;

        // Disconnect if still connected
        if client.is_connected() {
            client.disconnect()?;
        }

        return Ok(());
    }

    // Interactive mode
    println!("GDB Client (gdbc) v0.1.0");
    println!("Type 'help' for available commands, 'quit' to exit");

    // Try to connect if host/port provided
    if cli.host != "localhost" || cli.port != 55555 {
        let addr = format!("{}:{}", cli.host, cli.port);
        match client.connect(addr) {
            Ok(_) => println!("Connected to GDB server at {}:{}", cli.host, cli.port),
            Err(e) => eprintln!("Failed to connect to GDB server: {}", e),
        }
    }

    // Initialize readline
    let mut rl = DefaultEditor::new().map_err(|e| Error::Unknown(e.to_string()))?;

    let history_file = PathBuf::from(dirs::home_dir().unwrap_or_default()).join(".gdbc_history");

    if history_file.exists() {
        let _ = rl.history_mut().load(&history_file);
    }

    // Main loop
    loop {
        let prompt = if client.is_connected() {
            "gdb> "
        } else {
            "gdb (not connected)> "
        };

        match rl.readline(prompt) {
            Ok(line) => {
                let line = line.trim();
                if !line.is_empty() {
                    rl.add_history_entry(line)
                        .map_err(|e| Error::Unknown(e.to_string()))?;

                    match Command::from_str(line) {
                        Ok(cmd) => {
                            if let Err(e) =
                                gdbc::commands::execute_command(cmd, &mut client, use_colors)
                            {
                                eprintln!("Error: {}", e);
                            }
                        }
                        Err(e) => {
                            eprintln!("Parse error: {}", e);
                        }
                    }
                }
            }
            Err(ReadlineError::Interrupted) => {
                println!("Press Ctrl+D or type 'quit' to exit");
            }
            Err(ReadlineError::Eof) => {
                println!("Exiting...");
                if client.is_connected() {
                    let _ = client.disconnect();
                }
                break;
            }
            Err(e) => {
                eprintln!("Error: {}", e);
                break;
            }
        }
    }

    // Save history
    let _ = rl.save_history(&history_file);

    Ok(())
}