rust bindgen unaligned tcache chunk error

Question

I am working on binding for the avahi lib in rust, and I am encountering a runtime error:

malloc(): unaligned tcache chunk detected    

the code at fault:

    pub fn register_service(
        &mut self,
        name: String,
        svc_type: String,
        port: u16,
        txt: &[String],
    ) -> Result<(), AvahiError> {
        let group = match self.group {
            Some(group) => group,
            None => {
                let group = unsafe {
                    ffi::avahi_entry_group_new(
                        self.client_inner,
                        Some(group_callback),
                        std::ptr::null_mut() as *mut c_void,
                    )
                };
                if group.is_null() {
                    return Err(AvahiError::GroupCreateError);
                }
                self.group.replace(group);
                return self.register_service(name, svc_type, port, txt);
            }
        };

// avahi_entry_group_is_empty or any other function that uses group causes this error
        if unsafe { ffi::avahi_entry_group_is_empty(group) != 0 } {
            let name = CString::new(name).unwrap();
            let svc_type = CString::new(svc_type).unwrap();
            let ret = unsafe {
                ffi::avahi_entry_group_add_service(
                    group,
                    ffi::AVAHI_IF_UNSPEC,
                    ffi::AVAHI_PROTO_UNSPEC,
                    0,
                    name.as_ptr(),
                    svc_type.as_ptr(),
                    std::ptr::null_mut(),
                    std::ptr::null_mut(),
                    port,
                    std::ptr::null_mut() as *mut i8,
                )
            };
            if ret < 0 {
                let msg = unsafe { ffi::avahi_strerror(ret) };
                return Err(AvahiError::CreateService(unsafe {
                    CString::from_raw(msg as *mut i8)
                        .to_str()
                        .unwrap()
                        .to_owned()
                }));
            }
           if unsafe { ffi::avahi_entry_group_commit(group) == 0 } {
              return Err(AvahiError::EntryGroupCommit);
           }
        }

        
        Ok(())
    }

I am using this this example as reference, and I got it to work in C, so I think the error must be comming from the bindings. I am not sure to understand what this error is either.

What am I doing wrong?