Interacting with C Libraries: Implementing extern Functions in Rust

This challenge focuses on Rust's ability to interface with code written in other languages, specifically C, using the extern keyword. You'll be tasked with creating a Rust program that calls functions defined in a hypothetical C library, demonstrating how to declare and use foreign functions correctly. This is crucial for leveraging existing C codebases within Rust projects and building bridges between different programming ecosystems.

Problem Description

You need to implement a Rust program that calls two functions defined in a hypothetical C library named libmyc.so (or myc.dll on Windows). The C library provides the following functions:

1. int add(int a, int b);: This function takes two integers as input and returns their sum.
2. char* greet(const char* name);: This function takes a string (C-style character array) as input, allocates memory for a greeting string, constructs a greeting message including the provided name, and returns a pointer to the allocated memory. Important: The caller (your Rust code) is responsible for freeing the memory allocated by greet.

Your Rust program should:

1. Declare the extern "C" block containing the signatures of the add and greet functions.
2. Call the add function with two integer arguments and print the result.
3. Call the greet function with the string "Alice" as input.
4. Print the greeting string returned by greet.
5. Crucially: Free the memory allocated by the greet function using free (also declared as an extern "C" function). Failure to do so will result in a memory leak.

Examples

Example 1:

Input:  Rust program calling add(5, 3)
Output: 8
Explanation: The add function in the C library is called with 5 and 3, and the result (8) is printed.

Example 2:

Input: Rust program calling greet("Bob")
Output: Hello, Bob!
Explanation: The greet function in the C library is called with "Bob". It allocates memory, creates the string "Hello, Bob!", and returns a pointer to that memory. The Rust program then prints this string and frees the allocated memory.

Example 3: (Edge Case - Empty Name)

Input: Rust program calling greet("")
Output: Hello, !
Explanation: The greet function handles an empty name gracefully, producing "Hello, !"

Constraints

• You must use the extern "C" block to declare the C functions.
• You must correctly handle memory allocation and deallocation performed by the C library's greet function. Memory leaks will be considered a failure.
• The C library (libmyc.so or myc.dll) is assumed to exist and be accessible during runtime. You do not need to implement the C library itself.
• The free function from libc must be used to deallocate memory.
• The program must compile and run without panicking.

Notes

• You'll need to link against the C library when compiling your Rust code. The exact linking process depends on your operating system and build environment. For example, on Linux, you might use -L/path/to/library -lmyc during compilation.
• Consider using unsafe blocks where necessary when interacting with foreign functions.
• The libc crate provides access to standard C library functions like free. You'll need to add it to your Cargo.toml.
• Remember that C strings are null-terminated. Rust's &str type is not directly compatible with C strings, so you'll need to convert between them appropriately. The CStr and CString types from the std::ffi module can be helpful.
• Error handling is not explicitly required for this challenge, but consider how you might handle potential errors in a real-world scenario.