zerothlaw / oaidl-safe

Extracted types to wrap common Windows data structures - SAFEARRAY, VARIANT

oaidl

![Crates.io]![docs.rs(https://docs.rs/oaidl/badge.svg)]

A crate to convert common Rust types to common COM/OLE types, primarily for use in FFI - BSTR, SAFEARRAY, and VARIANT are the three implemented here.

This crate provides traits and trait implementations to make it easy and safe to convert between Rust types and the FFI-compatible data types.

For reference, a SAFEARRAY of VARIANTs corresponds to a C# object[]. A VARIANT is considered an object by C# interop.

Documentation

• Crate API Reference

License

This project is distributed under the terms of the MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

Contributing

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be licensed as above, without any additional terms or conditions.

oaidl-safe's Issues

Some format strings use decimal for HRESULT

Some fail display format strings use 0x{}:

oaidl-safe/src/errors.rs

Line 51 in 97e9c15

#[fail(display = "SafeArrayPutElement failed with HRESULT = 0x{}", hr)]

while others use the (I believe correct) 0x{:x} to print in hexadecimal:

oaidl-safe/src/errors.rs

Line 16 in 97e9c15

#[fail(display = "SafeArrayGetElement failed with HRESULT=0x{:x}", hr)]

Another option is to use {:#x}, which includes the 0x.

Ergonomics papercuts with use of Variant APIs

Thank you for your hard work with developing this crate! Also, ignore the title, because I don't have a full grasp of what I'm doing with my project, or what you have planned with this crate. I've been busy for the past month or so, but returned to your crate to see how best I could use it in my little project. I'm currently using the develop branch in my project because I like the introduction of the VariantWrapper trait, which enables dynamic dispatch. I had to abandon this line of attack - possibly because I'm not using the APIs in the best way - because the only type that implements VariantWrapper is Variants, and I therefore cannot return Variants from functions or methods, which I think would be a good thing to be able to do. What are your thoughts on this?

My next thought process was to enable method calls like what is demonstrated here. I'm having trouble with that because I can't seem to find the way to make conversion from a raw Rust type to its equivalent VARIANT so that users don't have to make the conversion before they give the method its argument. Are there any insights you can give on this?

Unsound BStringExt APIs

These functions should be marked unsafe:

oaidl-safe/src/bstr.rs

Lines 35 to 40 in 97e9c15

	/// Manually and correct free the memory allocated via Sys* methods
	fn deallocate_bstr(bstr: Ptr<u16>);
	/// Convenience method for conversion to a good intermediary type
	fn from_bstr(bstr: *mut u16) -> U16String;
	/// Convenience method for conversion to a good intermediary type
	fn from_pbstr(bstr: Ptr<u16>) -> U16String;

They are public and can be passed invalid pointers without any unsafe in calling code:

use oaidl::BStringExt;

fn main() {
    let explode = widestring::U16String::from_bstr(42 as _);
}