### Quick Start: Analyze Binary with idax in Rust

Source: https://crates.io/crates/idax/index

A practical example demonstrating the basic usage of the idax crate to initialize the IDA library, open a binary, query file metadata, iterate through functions, and list segments. It includes error handling using `idax::Result` and ensures database cleanup.

```rust
use idax::{database, function, segment};

fn main() -> idax::Result<()> {
    // Initialize the IDA library
    database::init()?;

    // Open a binary for analysis
    database::open("/path/to/binary", true)?;

    // Query metadata
    let path = database::input_file_path()?;
    let md5 = database::input_md5()?;
    println!("Analyzing: {path} (MD5: {md5})");

    // Iterate functions
    let count = function::count()?;
    for i in 0..count {
        let func = function::by_index(i)?;
        println!("  {:#x}: {}", func.start, func.name);
    }

    // Iterate segments
    let seg_count = segment::count()?;
    for i in 0..seg_count {
        let seg = segment::by_index(i)?;
        println!("  {}: {:#x}..{:#x}", seg.name, seg.start, seg.end);
    }

    database::close(false)?;
    Ok(())
}

```

--------------------------------

### Installation

Source: https://crates.io/crates/idax/index

Instructions on how to add the IDAX crate to your Rust project using Cargo.

```APIDOC
## Install

Run the following Cargo command in your project directory:

```bash
cargo add idax
```

Or add the following line to your `Cargo.toml`:

```toml
idax = "0.2.2"
```
```

--------------------------------

### IDAX Error Handling

Source: https://crates.io/crates/idax/index

Details on how IDAX handles errors, including the structure of the `Error` type and a usage example.

```APIDOC
## IDAX Error Handling

All fallible operations in IDAX return `idax::Result<T>` (an alias for `std::result::Result<T, idax::Error>`) or `idax::Status` (an alias for `Result<()>`).

The `idax::Error` type contains the following fields:

*   **`category`**: An `ErrorCategory` enum indicating the type of error (e.g., `Validation`, `NotFound`, `Conflict`, `Unsupported`, `SdkFailure`, `Internal`).
*   **`code`**: A numeric error code (0 if unspecified).
*   **`message`**: A human-readable description of the error.
*   **`context`**: Additional context, such as which SDK function failed.

### Example Usage

```rust
use idax::{function, Error};
use idax::error::ErrorCategory;

match function::at(0xDEAD) {
    Ok(func) => println!("Found: {}", func.name),
    Err(e) if e.category == ErrorCategory::NotFound => {
        println!("No function at that address");
    }
    Err(e) => return Err(e),
}
```
```

--------------------------------

### Install idax Crate for Rust Projects

Source: https://crates.io/crates/idax/index

This snippet shows how to add the idax crate as a dependency in your Rust project's Cargo.toml file. Ensure you are using Rust 2024 edition (nightly or stable 1.85+).

```toml
[dependencies]
idax = "0.2"

```

--------------------------------

### RAII and Drop Implementation

Source: https://crates.io/crates/idax/index

Explanation of Resource Acquisition Is Initialization (RAII) and the `Drop` trait implementation for managing SDK resources.

```APIDOC
## RAII / Drop

Types that manage SDK resources implement the `Drop` trait for automatic cleanup when they go out of scope.

| Type             | Module     | Releases           |
|------------------|------------|--------------------|
| `TypeInfo`       | `types`    | Opaque type handle |
| `Node`           | `storage`  | Netnode handle     |
| `DecompiledFunction` | `decompiler` | Decompilation result |
| `Graph`          | `graph`    | Interactive graph handle |
| `ScopedSubscription` | `event`, `decompiler`, `debugger` | Unsubscribes on drop |
```

--------------------------------

### IDAX Modules and Capabilities

Source: https://crates.io/crates/idax/index

Overview of the core modules within the IDAX API and their key capabilities.

```APIDOC
## IDAX Modules and Capabilities

### Advanced Modules

*   **`decompiler`**: Provides access to the Hex-Rays decompiler, including pseudocode generation and ctree traversal.
*   **`debugger`**: Offers control over the debugger, including process lifecycle, breakpoints, memory access, and thread management.
*   **`storage`**: Manages Netnode storage for typed values like altval, supval, hashval, and blobs.
*   **`lumina`**: Interface for the Lumina server for data synchronization.
*   **`analysis`**: Controls the auto-analysis engine, including enabling, disabling, and scheduling analysis tasks.
*   **`event`**: Handles IDB event subscriptions for various database events.

### Extension Points

*   **`plugin`**: Facilitates plugin lifecycle management and action registration.
*   **`loader`**: Enables the creation of custom loader modules.
*   **`processor`**: Allows for the implementation of custom processor modules.
*   **`graph`**: Supports the creation of custom interactive graphs.
*   **`ui`**: Provides utilities for interacting with the user interface, such as dialogs and input prompts.
*   **`lines`**: Offers utilities for handling color tags in text.
*   **`diagnostics`**: Includes logging and performance counter functionalities.
```

--------------------------------

### IDAX Architecture

Source: https://crates.io/crates/idax/index

Diagram illustrating the architectural layers of IDAX, from the IDA SDK up to the Rust code.

```APIDOC
## Architecture

```
  Your Rust code
       |
  [ idax ]          safe, idiomatic Rust API
       |
  [ idax-sys ]      raw extern "C" FFI bindings (generated by bindgen)
       |
  [ C shim ]        idax_shim.h / idax_shim.cpp (thin C bridge)
       |
  [ libidax.a ]     idax C++ wrapper library
       |
  [ IDA SDK ]       ida.dylib / ida.so / ida.dll
```
```

--------------------------------

### Handle Function Not Found Error in Rust

Source: https://crates.io/crates/idax/index

Demonstrates how to use a `match` statement to handle the `Ok` and `Err` variants of `idax::Result<T>` when looking for a function. Specifically, it shows how to check for the `ErrorCategory::NotFound` variant.

```rust
use idax::{function, Error};
use idax::error::ErrorCategory;

match function::at(0xDEAD) {
    Ok(func) => println!("Found: {}", func.name),
    Err(e) if e.category == ErrorCategory::NotFound => {
        println!("No function at that address");
    }
    Err(e) => return Err(e),
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.