machine-uid

https://docs.rs/machine-uid/latest
Admin
machine-uid is a Rust crate that retrieves the native operating system machine ID without requiring...
Tokens:3,796
Snippets:47
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get Machine ID

Source: https://docs.rs/machine-uid/latest/machine_uid

This snippet demonstrates how to use the `get` function from the `machine_uid` crate to retrieve the machine ID as a String. It handles potential errors by unwrapping the result.

```APIDOC
## Get Machine ID

### Description
Retrieves the operating system's native machine ID.

### Method
`machine_uid::get()`

### Parameters
None

### Returns
A `Result<String, _>` where `Ok(String)` contains the machine ID and `Err(_)` indicates an error.

### Usage Example
```rust
extern crate machine_uid;

fn main() {
    let id: String = machine_uid::get().unwrap();
    println!("{}", id);
}
```
```

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

### get

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

An alias for `get_machine_id`, providing a convenient way to access the machine ID retrieval function.

```APIDOC
## get

### Description
An alias for the `get_machine_id` function, providing a unified entry point for retrieving the machine ID.

### Method
Rust function call

### Parameters
None

### Response
- `Result<String, Box<dyn Error>>`: Ok containing the machine ID string, or an Err containing an error if retrieval fails.
```

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

### Linux Machine ID Source

Source: https://docs.rs/machine-uid/latest/machine_uid

On Linux systems using systemd, the machine ID can be found in these files. This is a command-line example.

```bash
cat /var/lib/dbus/machine-id # or /etc/machine-id
```

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

### Get Machine ID on Windows

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

This snippet shows the necessary imports for accessing the Windows Registry to retrieve the MachineGuid. The actual implementation for reading the registry is not shown here.

```Rust
use std::error::Error;

use windows_registry::LOCAL_MACHINE;
use windows_sys::Win32::Foundation::GetLastError;
use windows_sys::Win32::System::Registry::{KEY_READ, KEY_WOW64_64KEY};
use windows_sys::Win32::System::Threading::{GetCurrentProcess, IsWow64Process};

```

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

### Get Machine ID on BSD Systems

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Retrieves the machine ID on BSD-based systems by first trying to read `/etc/hostid` and then falling back to the `kenv` command for `smbios.system.uuid`.

```Rust
use super::read_file;
use std::error::Error;
use std::process::Command;

const HOST_ID_PATH: &str = "/etc/hostid";

/// Return machine id
pub fn get_machine_id() -> Result<String, Box<dyn Error>> {
    match read_file(HOST_ID_PATH) {
        Ok(machine_id) => Ok(machine_id),
        Err(_) => Ok(read_from_kenv()?),
    }
}

fn read_from_kenv() -> Result<String, Box<dyn Error>> {
    let output = Command::new("kenv")
        .args(&["-q", "smbios.system.uuid"])
        .output()?;
    let content = String::from_utf8_lossy(&output.stdout);
    Ok(content.trim().to_string())
}
```

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

### Get Machine ID on Linux

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Retrieves the machine ID on Linux systems by attempting to read from `/var/lib/dbus/machine-id` and falling back to `/etc/machine-id`.

```Rust
use super::read_file;
use std::error::Error;

// dbusPath is the default path for dbus machine id.
const DBUS_PATH: &str = "/var/lib/dbus/machine-id";
// or when not found (e.g. Fedora 20)
const DBUS_PATH_ETC: &str = "/etc/machine-id";

/// Return machine id
pub fn get_machine_id() -> Result<String, Box<dyn Error>> {
    match read_file(DBUS_PATH) {
        Ok(machine_id) => Ok(machine_id),
        Err(_) => Ok(read_file(DBUS_PATH_ETC)?),
    }
}
```

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

### Get Machine ID

Source: https://docs.rs/machine-uid/latest/machine_uid/index.html

This function retrieves the operating system's native machine ID. It is re-exported as `get` from the `machine_id` module.

```APIDOC
## Function: get

### Description
Retrieves the OS native machine ID without requiring root permissions.

### Usage
```rust
extern crate machine_uid;

fn main() {
    let id: String = machine_uid::get().unwrap();
    println!("{}", id);
}
```

### Returns
A `Result` containing the machine ID as a `String` on success, or an error if the ID cannot be retrieved.
```

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

### Get Machine ID

Source: https://docs.rs/machine-uid/latest/index.html

This snippet demonstrates how to use the `machine_uid::get()` function to retrieve the machine's unique identifier as a String. It handles potential errors by unwrapping the result, assuming the operation will succeed in a typical environment.

```APIDOC
## Get Machine ID

### Description
Retrieves the operating system's native machine ID.

### Function Signature
`pub fn get() -> Result<String, Error>`

### Usage
```rust
extern crate machine_uid;

fn main() {
    let id: String = machine_uid::get().unwrap();
    println!("{}", id);
}
```

### Return Value
- `Ok(String)`: A string containing the machine ID if successful.
- `Err(Error)`: An error if the machine ID cannot be retrieved.
```

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

### Get Machine ID on Illumos

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Retrieves the machine ID on Illumos systems by calling the libc::gethostid function.

```rust
pub mod machine_id {
    use std::error::Error;

    /// Return machine id
    pub fn get_machine_id() -> Result<String, Box<dyn Error>> {
        Ok(format!("{:x}", unsafe { libc::gethostid() }))
    }
}
```

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

### Get Machine ID on macOS

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Retrieves the machine ID on macOS by executing the `ioreg` command and parsing its output to find the `IOPlatformUUID`.

```Rust
use std::error::Error;
use std::process::Command;

/// Return machine id
pub fn get_machine_id() -> Result<String, Box<dyn Error>> {
    let output = Command::new("ioreg")
        .args(&["-rd1", "-c", "IOPlatformExpertDevice"])
        .output()?;
    let content = String::from_utf8_lossy(&output.stdout);
    extract_id(&content)
}

fn extract_id(content: &str) -> Result<String, Box<dyn Error>> {
    let lines = content.split('\n');
    for line in lines {
        if line.contains("IOPlatformUUID") {
            let k: Vec<&str> = line.rsplitn(2, '=').collect();
            let id = k[0].trim_matches(|c: char| c == '"' || c.is_whitespace());
            return Ok(id.to_string());
        }
    }
    Err(From::from("No matching IOPlatformUUID in `ioreg -rd1 -c IOPlatformExpertDevice` command."))
}
```

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

### Get Machine ID on Windows

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Retrieves the machine ID from the Windows registry. It adjusts access flags based on whether the system is WOW64 and the target pointer width.

```rust
fn machine_uid_is_wow64() -> Result<bool, Box<dyn Error>> {
        unsafe {
            let mut is_wow64: i32 = 0;
            if IsWow64Process(GetCurrentProcess(), &mut is_wow64) == 0 {
                return Err(From::from(format!("Failed to determine whether the specified process is running under WOW64 or an Intel64 of x64 processor: {}", GetLastError())));
            }

            Ok(is_wow64 == 1)
        }
    }

    /// Return machine id
    pub fn get_machine_id() -> Result<String, Box<dyn Error>> {
        let flag = if machine_uid_is_wow64()? && cfg!(target_pointer_width = "32") {
            KEY_READ | KEY_WOW64_64KEY
        } else {
            KEY_READ
        };

        let key = LOCAL_MACHINE
            .options()
            .access(flag)
            .open("SOFTWARE\Microsoft\Cryptography")?;
        let id = key.get_string("MachineGuid")?;

        Ok(id.trim().to_string())
    }
```

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

### Get Machine ID in Rust

Source: https://docs.rs/machine-uid/latest/machine_uid

This snippet demonstrates how to use the machine_uid crate to retrieve the machine ID. Ensure the crate is added to your Cargo.toml.

```rust
extern crate machine_uid;

fn main() {
    let id: String = machine_uid::get().unwrap();
    println!("{}", id);
}
```

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

### Get Machine ID Function Signature

Source: https://docs.rs/machine-uid/latest/machine_uid/machine_id/fn.get_machine_id.html

This is the function signature for get_machine_id. It returns a Result containing a String (the machine ID) or a Boxed Error.

```rust
pub fn get_machine_id() -> Result<String, Box<dyn Error>>
```

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

### BSD Machine ID Source

Source: https://docs.rs/machine-uid/latest/machine_uid

On BSD systems, the machine ID can be retrieved using the 'cat' command on '/etc/hostid' or 'kenv' for the SMBIOS UUID.

```bash
cat /etc/hostid # or kenv -q smbios.system.uuid
```

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

### get_machine_id (Windows)

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Retrieves the machine ID from the Windows registry. It handles WOW64 (Windows 32-bit on Windows 64-bit) scenarios to ensure the correct registry view is accessed.

```APIDOC
## get_machine_id

### Description
Retrieves the machine ID from the Windows registry.

### Method
Rust function call

### Parameters
None

### Response
- `Result<String, Box<dyn Error>>`: Ok containing the machine ID string, or an Err containing an error if retrieval fails.
```

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

### illumos Machine ID Source

Source: https://docs.rs/machine-uid/latest/machine_uid

On illumos systems, the machine ID can be obtained using the gethostid(3C) system call.

```bash
gethostid(3C)
```

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

### Read File Content in Rust

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

A helper function to read the content of a file and return it as a trimmed string. Used internally by the library to read machine ID files.

```Rust
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;

fn read_file(file_path: &str) -> Result<String, Box<dyn Error>> {
    let mut fd = File::open(file_path)?;
    let mut content = String::new();
    fd.read_to_string(&mut content)?;
    Ok(content.trim().to_string())
}
```

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

### get_machine_id (illumos)

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Retrieves the machine ID on illumos systems using the `gethostid()` system call.

```APIDOC
## get_machine_id

### Description
Retrieves the machine ID on illumos systems using the `gethostid()` system call.

### Method
Rust function call

### Parameters
None

### Response
- `Result<String, Box<dyn Error>>`: Ok containing the machine ID as a hexadecimal string, or an Err containing an error if retrieval fails.
```

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

### macOS Machine ID Source

Source: https://docs.rs/machine-uid/latest/machine_uid

On macOS, the machine ID (IOPlatformUUID) can be extracted using the 'ioreg' command and filtering the output.

```bash
ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID
```

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

### Windows Machine ID Source

Source: https://docs.rs/machine-uid/latest/machine_uid

On Windows, the machine ID (MachineGuid) is retrieved from the registry using PowerShell.

```powershell
(Get-ItemProperty -Path Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography).MachineGuid
```

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

### get_machine_id

Source: https://docs.rs/machine-uid/latest/machine_uid/all.html

Retrieves the unique machine identifier.

```APIDOC
## get_machine_id

### Description
Retrieves the unique machine identifier for the current system.

### Function Signature
`machine_id::get_machine_id()`

### Returns
- `String` - The unique machine identifier.
```

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

### get_machine_id

Source: https://docs.rs/machine-uid/latest/machine_uid/machine_id/fn.get_machine_id.html

Retrieves the unique identifier for the machine.

```APIDOC
## Function get_machine_id

### Description
Return machine id

### Signature
```rust
pub fn get_machine_id() -> Result<String, Box<dyn Error>>
```

### Returns
A `Result` containing the machine ID as a `String` on success, or a `Box<dyn Error>` on failure.
```

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

### get_machine_id

Source: https://docs.rs/machine-uid/latest/machine_uid/machine_id/index.html

Retrieves the unique identifier for the machine.

```APIDOC
## Function get_machine_id

### Description
Returns machine id.

### Signature
`fn get_machine_id() -> String`
```

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

### Re-export get_machine_id

Source: https://docs.rs/machine-uid/latest/src/machine_uid/lib.rs.html

Provides a convenient alias for the get_machine_id function.

```rust
pub use machine_id::get_machine_id as get;
```
Tokens:
Raw