safety: pointer related bugfixes

[muzarski]

This PR introduces multiple fixes around pointer manipulation in the driver. These bugs were found thanks to the CassPtr which will be introduced in a follow-up PR.

Pre-review checklist

• I have split my patch into logically separate commits.
• All commit messages clearly explain what they change and why.
• PR description sums up the changes and reasons why they should be introduced.
• I have implemented Rust unit tests for the features/changes introduced.
• [ ] I have enabled appropriate tests in .github/workflows/build.yml in gtest_filter.
• [ ] I have enabled appropriate tests in .github/workflows/cassandra.yml in gtest_filter.

[wprzytula]

❓ What do we achieve by passing *mut Self alongside &Self? Can't we just cast &Self to *mut Self in set_callback's body?

[muzarski]

This is explained in commit message. It's preparation for CassPtr introduction. This *mut CassFuture will be replaced by CassPtr.

I don't want expose an API to convert a reference to CassPtr via ArcFFI. I want to be sure that ArcFFI creates CassPtr which are backed by Arc allocation. We don't have such guarantee if we allow to create a pointer from just ref (&).

Here is a snippet from the follow-up PR. These are the only methods on ArcFFI that convert rust reference primitives to pointers:

pub trait ArcFFI: Sized {
    /// Creates a pointer from a valid reference to Arc-allocated data.
    /// Holder of the pointer borrows the pointee.
    fn as_ptr<'a>(self: &'a Arc<Self>) -> CassPtr<'a, Self, (Const,)> {
        #[allow(clippy::disallowed_methods)]
        let ptr = Arc::as_ptr(self);

        // SAFETY:
        // 1. validity guarantee - pointer is valid, since it's obtained from Arc allocation
        // 2. pointer's lifetime - pointer inherits the lifetime of provided Arc's borrow.
        //    What's important is that the returned pointer borrows the data, and is not the
        //    shared owner. Thus, user cannot call ArcFFI::free() on such pointer.
        // 3. mutability - we always create a `Const` pointer.
        unsafe { CassPtr::from_raw(ptr) }
    }

    /// Creates a pointer from a valid Arc allocation.
    fn into_ptr(self: Arc<Self>) -> CassPtr<'static, Self, (Const,)> {
        #[allow(clippy::disallowed_methods)]
        let ptr = Arc::into_raw(self);

        // SAFETY:
        // 1. validity guarantee - pointer is valid, since it's obtained from Arc allocation
        // 2. pointer's lifetime - returned pointer has a 'static lifetime. It is a shared
        //    owner of the pointee. User has to decrease the RC of the pointer (and potentially free the memory)
        //    via ArcFFI::free().
        // 3. mutability - we always create a `Const` pointer.
        unsafe { CassPtr::from_raw(ptr) }
    }
}

Notice that if we expose a method like fn as_ptr_from_ref(&self) -> CassPtr<'_, Self, (Const,)>, we lose the guarantee that this reference originates from some Arc allocation.

Why do we need such guarantee? An example:

struct Foo;
impl ArcFFI for Foo {}

let foo = Foo;
let ptr: CassPtr = ArcFFI::as_ptr_from_ref(&foo);

// We try to increase RC of a pointer that is not Arc-allocated.
let arced: Arc<Foo> = ArcFFI::cloned_from_ptr(ptr);

[muzarski]

I can make this commit a part of follow-up PR, so there is more context why this change makes sense.

[muzarski]

v1.1: Dropped future: pass future pointer to callback directly commit. It will be part of follow-up PR.