Add TypeRefCreator trait

[tokatoka]

No description provided.

[tokatoka]

like this? @addisoncrump

[tokatoka]

i didn't implement it for all the struct but just implemented for what is needed now

[domenukk]

I would do a get(&ref) and have the ref take the name as well.
Also, this again isn't a Has, it should just be impl TypeRef I think

[addisoncrump]

Can I modify this @tokatoka? There's a nicer way to do this that requires fewer modifications

[tokatoka]

yes

[addisoncrump]

Now it should just automagically work for all types that get entered into tuples and searched by match_name.

[tokatoka]

great 👍

[addisoncrump]

https://openssf.org/blog/2024/04/15/open-source-security-openssf-and-openjs-foundations-issue-alert-for-social-engineering-takeovers-of-open-source-projects/

[tokatoka]

deleted

[addisoncrump]

😂 Just messing with you. We should probably gitignore these.

[tokatoka]

but how do we check if it's executable

[addisoncrump]

No, I mean these exact file names. You just did cargo make or something, right?

[domenukk]

How about calling the guy Referencable? It gives the struct the trait that it can be referenced

[domenukk]

Also, as mentioned before, I think the ref should directly contain the name, So a real Reference instead of a TypeRef

[tokatoka]

@addisoncrump
can you do the CoW stuff?
I don't know what your desired change is

[addisoncrump]

Sure thing.

[addisoncrump]

Note that the Named trait now requires alloc. This is to allow for avoiding a clone whenever using Named, but maybe this is not a reasonable change.

[tokatoka]

this is ready?

[tokatoka]

this guy got deleted for mistake?

[addisoncrump]

Nope, not accidental -- this one should not be publicly exposed.

[addisoncrump]

@tokatoka It's not ready, no, I'm working through CI fixes.

[domenukk]

Referenceable?

[tokatoka]

can you finish this @addisoncrump
or i shoud just fix them?

[tokatoka]

then alloc shouldn't be a feature anymore?
because what can we do without a name now??

[tokatoka]

@domenukk

I think the ref should directly contain the name, So a real Reference instead of a TypeRef

This makes it hard to use.

For example if we do like this

#[derive(Debug, Clone, Copy)]
#[cfg(feature = "alloc")]
pub struct TypeRef<'a, T: ?Sized> {
    name: &'a Cow<'static, str>,
    phantom: PhantomData<T>,
}

Then this code from forkserver_libafl_cc won't compile

    let observer_ref = edges_observer.type_ref();

    let mut tokens = Tokens::new();
    let mut executor = ForkserverExecutor::builder()
        .program(opt.executable)
        .debug_child(debug_child)
        .shmem_provider(&mut shmem_provider)
        .autotokens(&mut tokens)
        .parse_afl_cmdline(args)
        .coverage_map_size(MAP_SIZE)
        .timeout(Duration::from_millis(opt.timeout))
        .kill_signal(opt.signal)
        .build(tuple_list!(time_observer, edges_observer))
        .unwrap();

    if let Some(dynamic_map_size) = executor.coverage_map_size() {
        executor
            .observers_mut()
            .match_by_ref_mut(observer_ref)
            .unwrap()
            .as_mut()
            .truncate(dynamic_map_size);
    }

because edges_observer is moved to the executor then we can't use observer_ref later in match_by_ref_mut()

[addisoncrump]

@tokatoka in that case, you can clone the Cow and only if necessary will it create a memory reference. It can be safely held without reference to the original observer.

#[derive(Debug, Clone)]
#[cfg(feature = "alloc")]
pub struct TypeRef<T: ?Sized> {
    name: Cow<'static, str>,
    phantom: PhantomData<T>,
}

[addisoncrump]

And yes, please finish this without me, I am currently rushing a paper submission 😵‍💫

[domenukk]

ReReference? :D