Creating FFI Bindings for a Simple C Library in Rust

This challenge focuses on creating Foreign Function Interface (FFI) bindings in Rust to interact with a simple C library. FFI allows Rust code to call functions written in other languages, like C, enabling interoperability and leveraging existing C libraries. This is a crucial skill for integrating Rust into larger systems or utilizing established C codebases.

Problem Description

You are tasked with creating Rust FFI bindings for a C library named libsimplemath.so (or libsimplemath.dll on Windows). This library provides a single function: int add(int a, int b). Your goal is to write a Rust program that can call this add function and print the result.

What needs to be achieved:

1. Create a Rust module that declares the external add function using the extern "C" block.
2. Load the libsimplemath.so (or .dll) library dynamically.
3. Obtain a function pointer to the add function from the loaded library.
4. Call the add function using the obtained function pointer with some sample input.
5. Print the result returned by the add function.

Key Requirements:

• The Rust code must compile and run without errors.
• The Rust code must correctly call the C add function.
• The Rust code must handle potential errors during library loading and function pointer retrieval.
• The code should be reasonably well-structured and readable.

Expected Behavior:

The program should load the libsimplemath.so (or .dll) library, call the add function with arguments 5 and 3, and print the result (8) to the console. If the library fails to load or the function pointer cannot be obtained, the program should print an appropriate error message and exit gracefully.

Edge Cases to Consider:

• The C library might not be present in the expected location.
• The C library might be corrupted or incompatible.
• The add function might not be exported from the C library.
• The C library might use a different calling convention than expected. (This challenge assumes the standard C calling convention.)

Examples

Example 1:

Input: C library `libsimplemath.so` (or `.dll`) with the `add` function defined as:
```c
int add(int a, int b) {
    return a + b;
}

Rust code calls add(5, 3) Output: 8 Explanation: The Rust code successfully loads the C library, obtains the add function pointer, calls it with 5 and 3, and prints the returned value 8.

Example 2:

Input: C library `libsimplemath.so` (or `.dll`) is not found in the expected location.
Output: "Error: Could not load library libsimplemath.so" (or equivalent error message)
Explanation: The Rust code attempts to load the library but fails, printing an error message and exiting.

## Constraints

*   The C library `libsimplemath.so` (or `.dll`) must be available during runtime. You'll need to compile a simple C program to create this library.
*   The `add` function in the C library must take two integers as input and return an integer.
*   The Rust code should handle errors gracefully and avoid panicking.
*   The solution should be reasonably efficient; excessive error handling or unnecessary allocations are discouraged.
*   The Rust code should be compatible with a recent stable version of Rust (e.g., 1.65 or later).

## Notes

*   You'll need to use the `dlopen`, `dlsym`, and `dlclose` functions from the `libc` crate to load the library and obtain the function pointer.
*   Consider using `unsafe` blocks where necessary when interacting with FFI.
*   Remember to handle potential errors when calling `dlopen` and `dlsym`.
*   The exact error messages might vary depending on the operating system and Rust version.
*   You may need to adjust the library path depending on your system configuration.  On Linux, you might need to use `LD_LIBRARY_PATH`. On Windows, you might need to add the library's directory to the PATH environment variable.
*   Creating the `libsimplemath.so` (or `.dll`) is outside the scope of this challenge; assume it exists and is correctly compiled.  A simple C program to create it is provided below for reference.



```c
// simplemath.c
#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

// Optional:  For testing purposes, you can include a main function
// int main() {
//     printf("Result of 5 + 3: %d\n", add(5, 3));
//     return 0;
// }

Compile the C code: gcc -shared -o libsimplemath.so simplemath.c (Linux) or gcc -shared -o libsimplemath.dll simplemath.c (Windows).