diff --git a/.gitignore b/.gitignore
index b60de5b..3674824 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 **/target
+tmp
diff --git a/Cargo.lock b/Cargo.lock
index 91d2198..4d5f8ee 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -776,7 +776,7 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "zeroconf"
-version = "0.16.0"
+version = "0.17.0"
 dependencies = [
  "avahi-sys",
  "bonjour-sys",
@@ -805,7 +805,7 @@ dependencies = [
 
 [[package]]
 name = "zeroconf-macros"
-version = "0.1.4"
+version = "0.2.0"
 dependencies = [
  "quote",
  "syn 2.0.110",
diff --git a/Cargo.toml b/Cargo.toml
index bfbc808..7229289 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,4 +1,5 @@
 [workspace]
+resolver = "3"
 members = [
     "zeroconf",
     "zeroconf-macros",
diff --git a/examples/browser/Cargo.toml b/examples/browser/Cargo.toml
index 1ec9b01..97f659b 100644
--- a/examples/browser/Cargo.toml
+++ b/examples/browser/Cargo.toml
@@ -2,7 +2,7 @@
 name = "zeroconf-browser-example"
 version = "0.1.0"
 authors = ["Walker Crouse <walkercrouse@hotmail.com>"]
-edition = "2018"
+edition = "2024"
 
 [dependencies]
 zeroconf = { path = "../../zeroconf" }
diff --git a/examples/service/Cargo.toml b/examples/service/Cargo.toml
index dc0b60e..0c0fe84 100644
--- a/examples/service/Cargo.toml
+++ b/examples/service/Cargo.toml
@@ -2,7 +2,7 @@
 name = "zeroconf-service-example"
 version = "0.1.0"
 authors = ["Walker Crouse <walkercrouse@hotmail.com>"]
-edition = "2018"
+edition = "2024"
 
 [dependencies]
 zeroconf = { path = "../../zeroconf" }
diff --git a/zeroconf-macros/Cargo.toml b/zeroconf-macros/Cargo.toml
index e4c9d34..7461823 100644
--- a/zeroconf-macros/Cargo.toml
+++ b/zeroconf-macros/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "zeroconf-macros"
-version = "0.1.4"
+version = "0.2.0"
 authors = ["Walker Crouse <walkercrouse@hotmail.com>"]
-edition = "2018"
+edition = "2024"
 description = "Macros for zeroconf crate"
 readme = "../README.md"
 homepage = "https://github.com/windy1/zeroconf-rs"
diff --git a/zeroconf-macros/src/lib.rs b/zeroconf-macros/src/lib.rs
index b41d58c..323f09c 100644
--- a/zeroconf-macros/src/lib.rs
+++ b/zeroconf-macros/src/lib.rs
@@ -13,11 +13,11 @@ fn impl_from_raw(ast: &DeriveInput) -> TokenStream {
     let name = &ast.ident;
     let generics = &ast.generics;
 
-    let gen = quote! {
+    let result = quote! {
         impl #generics crate::ffi::FromRaw<#name #generics> for #name #generics {}
     };
 
-    gen.into()
+    result.into()
 }
 
 #[proc_macro_derive(CloneRaw)]
@@ -29,11 +29,11 @@ fn impl_clone_raw(ast: &DeriveInput) -> TokenStream {
     let name = &ast.ident;
     let generics = &ast.generics;
 
-    let gen = quote! {
+    let result = quote! {
         impl #generics crate::ffi::CloneRaw<#name #generics> for #name #generics {}
     };
 
-    gen.into()
+    result.into()
 }
 
 #[proc_macro_derive(AsRaw)]
@@ -45,11 +45,11 @@ fn impl_as_raw(ast: &DeriveInput) -> TokenStream {
     let name = &ast.ident;
     let generics = &ast.generics;
 
-    let gen = quote! {
+    let result = quote! {
         impl #generics crate::ffi::AsRaw for #name #generics {}
     };
 
-    gen.into()
+    result.into()
 }
 
 #[proc_macro_derive(BuilderDelegate)]
@@ -65,9 +65,9 @@ fn impl_builder_delegate(ast: &DeriveInput) -> TokenStream {
 
     let generics = &ast.generics;
 
-    let gen = quote! {
+    let result = quote! {
         impl #generics crate::prelude::BuilderDelegate<#builder #generics> for #name #generics {}
     };
 
-    gen.into()
+    result.into()
 }
diff --git a/zeroconf/Cargo.toml b/zeroconf/Cargo.toml
index 474c910..7c927c8 100644
--- a/zeroconf/Cargo.toml
+++ b/zeroconf/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "zeroconf"
-version = "0.16.0"
+version = "0.17.0"
 authors = ["Walker Crouse <walkercrouse@hotmail.com>"]
-edition = "2018"
+edition = "2024"
 description = "cross-platform library that wraps ZeroConf/mDNS implementations like Bonjour or Avahi"
 readme = "../README.md"
 homepage = "https://github.com/windy1/zeroconf-rs"
@@ -25,7 +25,7 @@ derive_builder = "0.9.0"
 derive-new = "0.5.9"
 log = "0.4.20"
 libc = "0.2.148"
-zeroconf-macros = { path = "../zeroconf-macros", version = "0.1.4" }
+zeroconf-macros = { path = "../zeroconf-macros", version = "0.2.0" }
 
 [dev-dependencies]
 env_logger = "0.10.0"
diff --git a/zeroconf/src/avahi/avahi_util.rs b/zeroconf/src/avahi/avahi_util.rs
index a683cd4..2c54185 100644
--- a/zeroconf/src/avahi/avahi_util.rs
+++ b/zeroconf/src/avahi/avahi_util.rs
@@ -2,8 +2,8 @@
 
 use crate::ffi::c_str;
 use avahi_sys::{
-    avahi_address_snprint, avahi_alternative_service_name, avahi_strerror, AvahiAddress,
-    AvahiClient,
+    AvahiAddress, AvahiClient, avahi_address_snprint, avahi_alternative_service_name,
+    avahi_strerror,
 };
 use libc::c_char;
 use std::ffi::CStr;
@@ -22,11 +22,13 @@ pub unsafe fn avahi_address_to_string(addr: *const AvahiAddress) -> String {
 
     let addr_str = c_string!(alloc(avahi_sys::AVAHI_ADDRESS_STR_MAX as usize));
 
-    avahi_address_snprint(
-        addr_str.as_ptr() as *mut c_char,
-        avahi_sys::AVAHI_ADDRESS_STR_MAX as usize,
-        addr,
-    );
+    unsafe {
+        avahi_address_snprint(
+            addr_str.as_ptr() as *mut c_char,
+            avahi_sys::AVAHI_ADDRESS_STR_MAX as usize,
+            addr,
+        );
+    }
 
     String::from(c_str::to_str(&addr_str))
         .trim_matches(char::from(0))
@@ -38,9 +40,11 @@ pub unsafe fn avahi_address_to_string(addr: *const AvahiAddress) -> String {
 /// # Safety
 /// This function is unsafe because of internal Avahi calls.
 pub unsafe fn get_error<'a>(code: i32) -> &'a str {
-    CStr::from_ptr(avahi_strerror(code))
-        .to_str()
-        .expect("could not fetch Avahi error string")
+    unsafe {
+        CStr::from_ptr(avahi_strerror(code))
+            .to_str()
+            .expect("could not fetch Avahi error string")
+    }
 }
 
 /// Returns the last error message associated with the specified `*mut AvahiClient`.
@@ -48,7 +52,7 @@ pub unsafe fn get_error<'a>(code: i32) -> &'a str {
 /// # Safety
 /// This function is unsafe because of internal Avahi calls.
 pub unsafe fn get_last_error<'a>(client: *mut AvahiClient) -> &'a str {
-    get_error(avahi_sys::avahi_client_errno(client))
+    unsafe { get_error(avahi_sys::avahi_client_errno(client)) }
 }
 
 /// Converts the specified [`NetworkInterface`] to the Avahi expected value.
@@ -77,7 +81,7 @@ pub unsafe fn sys_exec<F: FnOnce() -> i32>(func: F, message: &str) -> Result<()>
     let err = func();
 
     if err < 0 {
-        Err(format!("{}: `{}`", message, get_error(err)).into())
+        Err(format!("{}: `{}`", message, unsafe { get_error(err) }).into())
     } else {
         Ok(())
     }
@@ -98,7 +102,9 @@ pub fn format_browser_type(service_type: &ServiceType) -> String {
     }
 
     if sub_types.len() > 1 {
-        warn!("browsing by multiple sub-types is not supported on Avahi devices, using first sub-type only");
+        warn!(
+            "browsing by multiple sub-types is not supported on Avahi devices, using first sub-type only"
+        );
     }
 
     format_sub_type(&sub_types[0], &kind)
@@ -119,15 +125,15 @@ pub fn format_sub_type(sub_type: &str, kind: &str) -> String {
 /// # Safety
 /// This function is unsafe because of the call to `avahi_alternative_service_name`.
 pub unsafe fn alternative_service_name(name: &CStr) -> &CStr {
-    CStr::from_ptr(avahi_alternative_service_name(name.as_ptr()))
+    unsafe { CStr::from_ptr(avahi_alternative_service_name(name.as_ptr())) }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use avahi_sys::{
-        AvahiAddress__bindgen_ty_1, AvahiIPv4Address, AvahiIPv6Address, AVAHI_PROTO_INET,
-        AVAHI_PROTO_INET6,
+        AVAHI_PROTO_INET, AVAHI_PROTO_INET6, AvahiAddress__bindgen_ty_1, AvahiIPv4Address,
+        AvahiIPv6Address,
     };
 
     #[test]
diff --git a/zeroconf/src/avahi/browser.rs b/zeroconf/src/avahi/browser.rs
index 9c8601b..cdffbf0 100644
--- a/zeroconf/src/avahi/browser.rs
+++ b/zeroconf/src/avahi/browser.rs
@@ -10,9 +10,9 @@ use super::{
     },
     string_list::ManagedAvahiStringList,
 };
-use crate::ffi::{c_str, AsRaw, FromRaw};
-use crate::prelude::*;
 use crate::Result;
+use crate::ffi::{AsRaw, FromRaw, c_str};
+use crate::prelude::*;
 use crate::{
     BrowserEvent, EventLoop, NetworkInterface, ServiceBrowserCallback, ServiceDiscovery,
     ServiceRemoval, ServiceType, TxtRecord,
@@ -157,31 +157,33 @@ unsafe extern "C" fn client_callback(
     state: AvahiClientState,
     userdata: *mut c_void,
 ) {
-    let context = AvahiBrowserContext::from_raw(userdata);
+    let context = unsafe { AvahiBrowserContext::from_raw(userdata) };
 
     if state == avahi_sys::AvahiClientState_AVAHI_CLIENT_FAILURE {
-        context.invoke_callback(Err(avahi_util::get_last_error(client).into()));
+        context.invoke_callback(Err(unsafe { avahi_util::get_last_error(client) }.into()));
     }
 }
 
 unsafe fn create_browser(context: &mut AvahiBrowserContext) -> Result<()> {
-    context.browser = Some(ManagedAvahiServiceBrowser::new(
-        ManagedAvahiServiceBrowserParams::builder()
-            .interface(context.interface_index)
-            .protocol(avahi_sys::AVAHI_PROTO_UNSPEC)
-            .kind(context.kind.as_ptr())
-            .domain(ptr::null_mut())
-            .flags(0)
-            .callback(Some(browse_callback))
-            .userdata(context.as_raw())
-            .client(Arc::clone(
-                context
-                    .client
-                    .as_ref()
-                    .ok_or("could not get client as ref")?,
-            ))
-            .build()?,
-    )?);
+    context.browser = Some(unsafe {
+        ManagedAvahiServiceBrowser::new(
+            ManagedAvahiServiceBrowserParams::builder()
+                .interface(context.interface_index)
+                .protocol(avahi_sys::AVAHI_PROTO_UNSPEC)
+                .kind(context.kind.as_ptr())
+                .domain(ptr::null_mut())
+                .flags(0)
+                .callback(Some(browse_callback))
+                .userdata(context.as_raw())
+                .client(Arc::clone(
+                    context
+                        .client
+                        .as_ref()
+                        .ok_or("could not get client as ref")?,
+                ))
+                .build()?,
+        )?
+    });
 
     Ok(())
 }
@@ -197,11 +199,13 @@ unsafe extern "C" fn browse_callback(
     _flags: AvahiLookupResultFlags,
     userdata: *mut c_void,
 ) {
-    let context = AvahiBrowserContext::from_raw(userdata);
+    let context = unsafe { AvahiBrowserContext::from_raw(userdata) };
 
     match event {
         avahi_sys::AvahiBrowserEvent_AVAHI_BROWSER_NEW => {
-            if let Err(e) = handle_browser_new(context, interface, protocol, name, kind, domain) {
+            if let Err(e) =
+                unsafe { handle_browser_new(context, interface, protocol, name, kind, domain) }
+            {
                 context.invoke_callback(Err(e));
             }
         }
@@ -209,7 +213,7 @@ unsafe extern "C" fn browse_callback(
             context.invoke_callback(Err("browser failure".into()))
         }
         avahi_sys::AvahiBrowserEvent_AVAHI_BROWSER_REMOVE => {
-            handle_browser_remove(context, name, kind, domain);
+            unsafe { handle_browser_remove(context, name, kind, domain) };
         }
         _ => {}
     };
@@ -230,20 +234,22 @@ unsafe fn handle_browser_new(
         .as_ref()
         .ok_or("expected initialized client")?;
 
-    context.resolvers.insert(ManagedAvahiServiceResolver::new(
-        ManagedAvahiServiceResolverParams::builder()
-            .client(client.clone())
-            .interface(interface)
-            .protocol(protocol)
-            .name(name)
-            .kind(kind)
-            .domain(domain)
-            .aprotocol(avahi_sys::AVAHI_PROTO_UNSPEC)
-            .flags(0)
-            .callback(Some(resolve_callback))
-            .userdata(raw_context)
-            .build()?,
-    )?);
+    context.resolvers.insert(unsafe {
+        ManagedAvahiServiceResolver::new(
+            ManagedAvahiServiceResolverParams::builder()
+                .client(client.clone())
+                .interface(interface)
+                .protocol(protocol)
+                .name(name)
+                .kind(kind)
+                .domain(domain)
+                .aprotocol(avahi_sys::AVAHI_PROTO_UNSPEC)
+                .flags(0)
+                .callback(Some(resolve_callback))
+                .userdata(raw_context)
+                .build()?,
+        )?
+    });
 
     Ok(())
 }
@@ -254,9 +260,9 @@ unsafe fn handle_browser_remove(
     regtype: *const c_char,
     domain: *const c_char,
 ) {
-    let name = c_str::raw_to_str(name);
-    let regtype = c_str::raw_to_str(regtype);
-    let domain = c_str::raw_to_str(domain);
+    let name = unsafe { c_str::raw_to_str(name) };
+    let regtype = unsafe { c_str::raw_to_str(regtype) };
+    let domain = unsafe { c_str::raw_to_str(domain) };
 
     ctx.invoke_callback(Ok(BrowserEvent::Remove(
         ServiceRemoval::builder()
@@ -283,11 +289,11 @@ unsafe extern "C" fn resolve_callback(
     _flags: AvahiLookupResultFlags,
     userdata: *mut c_void,
 ) {
-    let name = c_str::raw_to_str(name);
-    let kind = c_str::raw_to_str(kind);
-    let domain = c_str::raw_to_str(domain);
+    let name = unsafe { c_str::raw_to_str(name) };
+    let kind = unsafe { c_str::raw_to_str(kind) };
+    let domain = unsafe { c_str::raw_to_str(domain) };
 
-    let context = AvahiBrowserContext::from_raw(userdata);
+    let context = unsafe { AvahiBrowserContext::from_raw(userdata) };
 
     match event {
         avahi_sys::AvahiResolverEvent_AVAHI_RESOLVER_FAILURE => {
@@ -298,16 +304,18 @@ unsafe extern "C" fn resolve_callback(
             .into()));
         }
         avahi_sys::AvahiResolverEvent_AVAHI_RESOLVER_FOUND => {
-            let result = handle_resolver_found(
-                context,
-                c_str::raw_to_str(host_name),
-                addr,
-                name,
-                kind,
-                domain,
-                port,
-                txt,
-            );
+            let result = unsafe {
+                handle_resolver_found(
+                    context,
+                    c_str::raw_to_str(host_name),
+                    addr,
+                    name,
+                    kind,
+                    domain,
+                    port,
+                    txt,
+                )
+            };
 
             if let Err(e) = result {
                 context.invoke_callback(Err(e));
@@ -330,12 +338,14 @@ unsafe fn handle_resolver_found(
     port: u16,
     txt: *mut AvahiStringList,
 ) -> Result<()> {
-    let address = avahi_util::avahi_address_to_string(addr);
+    let address = unsafe { avahi_util::avahi_address_to_string(addr) };
 
     let txt = if txt.is_null() {
         None
     } else {
-        Some(TxtRecord::from(ManagedAvahiStringList::clone_raw(txt)))
+        Some(TxtRecord::from(unsafe {
+            ManagedAvahiStringList::clone_raw(txt)
+        }))
     };
 
     let result = ServiceDiscovery::builder()
diff --git a/zeroconf/src/avahi/client.rs b/zeroconf/src/avahi/client.rs
index ecc6075..6d27dde 100644
--- a/zeroconf/src/avahi/client.rs
+++ b/zeroconf/src/avahi/client.rs
@@ -3,11 +3,11 @@
 use std::sync::Arc;
 
 use super::{avahi_util, poll::ManagedAvahiSimplePoll};
-use crate::ffi::c_str;
 use crate::Result;
+use crate::ffi::c_str;
 use avahi_sys::{
-    avahi_client_free, avahi_client_get_host_name, avahi_client_new, avahi_simple_poll_get,
-    AvahiClient, AvahiClientCallback, AvahiClientFlags,
+    AvahiClient, AvahiClientCallback, AvahiClientFlags, avahi_client_free,
+    avahi_client_get_host_name, avahi_client_new, avahi_simple_poll_get,
 };
 use libc::{c_int, c_void};
 
@@ -37,13 +37,15 @@ impl ManagedAvahiClient {
     ) -> Result<Self> {
         let mut err: c_int = 0;
 
-        let inner = avahi_client_new(
-            avahi_simple_poll_get(poll.inner()),
-            flags,
-            callback,
-            userdata,
-            &mut err,
-        );
+        let inner = unsafe {
+            avahi_client_new(
+                avahi_simple_poll_get(poll.inner()),
+                flags,
+                callback,
+                userdata,
+                &mut err,
+            )
+        };
 
         if inner.is_null() {
             return Err("could not initialize AvahiClient".into());
@@ -51,10 +53,9 @@ impl ManagedAvahiClient {
 
         match err {
             0 => Ok(Self { inner, _poll: poll }),
-            _ => Err(format!(
-                "could not initialize AvahiClient: {}",
+            _ => Err(format!("could not initialize AvahiClient: {}", unsafe {
                 avahi_util::get_error(err)
-            )
+            })
             .into()),
         }
     }
@@ -66,7 +67,7 @@ impl ManagedAvahiClient {
     /// # Safety
     /// This function is unsafe because of the raw pointer dereference.
     pub unsafe fn host_name<'a>(&self) -> Result<&'a str> {
-        get_host_name(self.inner)
+        unsafe { get_host_name(self.inner) }
     }
 }
 
@@ -94,10 +95,10 @@ pub struct ManagedAvahiClientParams {
 
 pub(super) unsafe fn get_host_name<'a>(client: *mut AvahiClient) -> Result<&'a str> {
     assert_not_null!(client);
-    let host_name = avahi_client_get_host_name(client);
+    let host_name = unsafe { avahi_client_get_host_name(client) };
 
     if !host_name.is_null() {
-        Ok(c_str::raw_to_str(host_name))
+        Ok(unsafe { c_str::raw_to_str(host_name) })
     } else {
         Err("could not get host name from AvahiClient".into())
     }
diff --git a/zeroconf/src/avahi/entry_group.rs b/zeroconf/src/avahi/entry_group.rs
index d759b62..76c227f 100644
--- a/zeroconf/src/avahi/entry_group.rs
+++ b/zeroconf/src/avahi/entry_group.rs
@@ -3,14 +3,14 @@
 use std::sync::Arc;
 
 use super::{client::ManagedAvahiClient, string_list::ManagedAvahiStringList};
+use crate::Result;
 use crate::avahi::avahi_util;
 use crate::ffi::UnwrapMutOrNull;
-use crate::Result;
 use avahi_sys::{
-    avahi_client_errno, avahi_entry_group_add_service_strlst,
+    AvahiClient, AvahiEntryGroup, AvahiEntryGroupCallback, AvahiIfIndex, AvahiProtocol,
+    AvahiPublishFlags, avahi_client_errno, avahi_entry_group_add_service_strlst,
     avahi_entry_group_add_service_subtype, avahi_entry_group_commit, avahi_entry_group_free,
-    avahi_entry_group_is_empty, avahi_entry_group_new, avahi_entry_group_reset, AvahiClient,
-    AvahiEntryGroup, AvahiEntryGroupCallback, AvahiIfIndex, AvahiProtocol, AvahiPublishFlags,
+    avahi_entry_group_is_empty, avahi_entry_group_new, avahi_entry_group_reset,
 };
 use libc::{c_char, c_void};
 
@@ -37,10 +37,10 @@ impl ManagedAvahiEntryGroup {
             userdata,
         }: ManagedAvahiEntryGroupParams,
     ) -> Result<Self> {
-        let inner = avahi_entry_group_new(client.inner, callback, userdata);
+        let inner = unsafe { avahi_entry_group_new(client.inner, callback, userdata) };
 
         if inner.is_null() {
-            let err = avahi_util::get_error(avahi_client_errno(client.inner));
+            let err = unsafe { avahi_util::get_error(avahi_client_errno(client.inner)) };
             Err(format!("could not initialize AvahiEntryGroup: {}", err).into())
         } else {
             Ok(Self {
@@ -57,7 +57,7 @@ impl ManagedAvahiEntryGroup {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_entry_group_is_empty()`.
     pub unsafe fn is_empty(&self) -> bool {
-        avahi_entry_group_is_empty(self.inner) != 0
+        unsafe { avahi_entry_group_is_empty(self.inner) != 0 }
     }
 
     /// Delegate function for [`avahi_entry_group_add_service()`].
@@ -82,23 +82,25 @@ impl ManagedAvahiEntryGroup {
             txt,
         }: AddServiceParams,
     ) -> Result<()> {
-        avahi_util::sys_exec(
-            || {
-                avahi_entry_group_add_service_strlst(
-                    self.inner,
-                    interface,
-                    protocol,
-                    flags,
-                    name,
-                    kind,
-                    domain,
-                    host,
-                    port,
-                    txt.map(|t| t.inner()).unwrap_mut_or_null(),
-                )
-            },
-            "could not register service",
-        )
+        unsafe {
+            avahi_util::sys_exec(
+                || {
+                    avahi_entry_group_add_service_strlst(
+                        self.inner,
+                        interface,
+                        protocol,
+                        flags,
+                        name,
+                        kind,
+                        domain,
+                        host,
+                        port,
+                        txt.map(|t| t.inner()).unwrap_mut_or_null(),
+                    )
+                },
+                "could not register service",
+            )
+        }
     }
 
     /// Delegate function for [`avahi_entry_group_add_service_subtype()`].
@@ -121,14 +123,16 @@ impl ManagedAvahiEntryGroup {
             subtype,
         }: AddServiceSubtypeParams,
     ) -> Result<()> {
-        avahi_util::sys_exec(
-            || {
-                avahi_entry_group_add_service_subtype(
-                    self.inner, interface, protocol, flags, name, kind, domain, subtype,
-                )
-            },
-            "could not register service subtype",
-        )
+        unsafe {
+            avahi_util::sys_exec(
+                || {
+                    avahi_entry_group_add_service_subtype(
+                        self.inner, interface, protocol, flags, name, kind, domain, subtype,
+                    )
+                },
+                "could not register service subtype",
+            )
+        }
     }
 
     /// Delegate function for [`avahi_entry_group_commit()`].
@@ -140,10 +144,12 @@ impl ManagedAvahiEntryGroup {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_entry_group_commit()`.
     pub unsafe fn commit(&mut self) -> Result<()> {
-        avahi_util::sys_exec(
-            || avahi_entry_group_commit(self.inner),
-            "could not commit service",
-        )
+        unsafe {
+            avahi_util::sys_exec(
+                || avahi_entry_group_commit(self.inner),
+                "could not commit service",
+            )
+        }
     }
 
     /// Delegate function for [`avahi_entry_group_reset()`].
@@ -153,7 +159,7 @@ impl ManagedAvahiEntryGroup {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_entry_group_reset()`.
     pub unsafe fn reset(&mut self) {
-        avahi_entry_group_reset(self.inner);
+        unsafe { avahi_entry_group_reset(self.inner) };
     }
 
     /// Delegate function for [`avahi_entry_group_get_client()`].
@@ -162,7 +168,7 @@ impl ManagedAvahiEntryGroup {
     /// This function is unsafe because it returns a raw pointer to
     /// the underlying `AvahiClient`.
     pub unsafe fn get_client(&self) -> *mut AvahiClient {
-        avahi_sys::avahi_entry_group_get_client(self.inner)
+        unsafe { avahi_sys::avahi_entry_group_get_client(self.inner) }
     }
 }
 
diff --git a/zeroconf/src/avahi/event_loop.rs b/zeroconf/src/avahi/event_loop.rs
index db62b78..7263b23 100644
--- a/zeroconf/src/avahi/event_loop.rs
+++ b/zeroconf/src/avahi/event_loop.rs
@@ -1,8 +1,8 @@
 //! Event loop for running a `MdnsService` or `MdnsBrowser`.
 
 use super::poll::ManagedAvahiSimplePoll;
-use crate::event_loop::TEventLoop;
 use crate::Result;
+use crate::event_loop::TEventLoop;
 use std::sync::Arc;
 use std::time::Duration;
 
diff --git a/zeroconf/src/avahi/poll.rs b/zeroconf/src/avahi/poll.rs
index 6a5096b..fee5a8a 100644
--- a/zeroconf/src/avahi/poll.rs
+++ b/zeroconf/src/avahi/poll.rs
@@ -3,8 +3,8 @@
 use crate::Result;
 use crate::{avahi::avahi_util, error::Error};
 use avahi_sys::{
-    avahi_simple_poll_free, avahi_simple_poll_iterate, avahi_simple_poll_loop,
-    avahi_simple_poll_new, AvahiSimplePoll,
+    AvahiSimplePoll, avahi_simple_poll_free, avahi_simple_poll_iterate, avahi_simple_poll_loop,
+    avahi_simple_poll_new,
 };
 use std::{convert::TryInto, time::Duration};
 
@@ -22,7 +22,7 @@ impl ManagedAvahiSimplePoll {
     /// # Safety
     /// This function is unsafe because of the raw pointer dereference.
     pub unsafe fn new() -> Result<Self> {
-        let poll = avahi_simple_poll_new();
+        let poll = unsafe { avahi_simple_poll_new() };
         if poll.is_null() {
             Err("could not initialize AvahiSimplePoll".into())
         } else {
@@ -37,10 +37,12 @@ impl ManagedAvahiSimplePoll {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_simple_poll_loop()`.
     pub unsafe fn start_loop(&self) -> Result<()> {
-        avahi_util::sys_exec(
-            || avahi_simple_poll_loop(self.0),
-            "could not start AvahiSimplePoll",
-        )
+        unsafe {
+            avahi_util::sys_exec(
+                || avahi_simple_poll_loop(self.0),
+                "could not start AvahiSimplePoll",
+            )
+        }
     }
 
     /// Delegate function for [`avahi_simple_poll_iterate()`].
@@ -56,7 +58,7 @@ impl ManagedAvahiSimplePoll {
             .unwrap_or(i32::MAX); // if converting to an i32 overflows, just use the largest number we can.
 
         // Returns -1 on error, 0 on success and 1 if a quit request has been scheduled
-        match avahi_simple_poll_iterate(self.0, sleep_time) {
+        match unsafe { avahi_simple_poll_iterate(self.0, sleep_time) } {
             0 | 1 => Ok(()),
             -1 => Err(Error::from(
                 "avahi_simple_poll_iterate(..) threw an error result",
diff --git a/zeroconf/src/avahi/raw_browser.rs b/zeroconf/src/avahi/raw_browser.rs
index edf1286..502fc13 100644
--- a/zeroconf/src/avahi/raw_browser.rs
+++ b/zeroconf/src/avahi/raw_browser.rs
@@ -4,9 +4,9 @@ use std::sync::Arc;
 
 use crate::Result;
 use avahi_sys::{
-    avahi_service_browser_free, avahi_service_browser_get_client, avahi_service_browser_new,
     AvahiClient, AvahiIfIndex, AvahiLookupFlags, AvahiProtocol, AvahiServiceBrowser,
-    AvahiServiceBrowserCallback,
+    AvahiServiceBrowserCallback, avahi_service_browser_free, avahi_service_browser_get_client,
+    avahi_service_browser_new,
 };
 use libc::{c_char, c_void};
 
@@ -40,16 +40,18 @@ impl ManagedAvahiServiceBrowser {
             userdata,
         }: ManagedAvahiServiceBrowserParams,
     ) -> Result<Self> {
-        let inner = avahi_service_browser_new(
-            client.inner,
-            interface,
-            protocol,
-            kind,
-            domain,
-            flags,
-            callback,
-            userdata,
-        );
+        let inner = unsafe {
+            avahi_service_browser_new(
+                client.inner,
+                interface,
+                protocol,
+                kind,
+                domain,
+                flags,
+                callback,
+                userdata,
+            )
+        };
 
         if inner.is_null() {
             Err("could not initialize Avahi service browser".into())
@@ -67,7 +69,7 @@ impl ManagedAvahiServiceBrowser {
     /// This function leaks the internal raw pointer, useful for accessing within callbacks where
     /// you are sure the pointer is still valid.
     pub unsafe fn get_client(&self) -> *mut AvahiClient {
-        avahi_service_browser_get_client(self.inner)
+        unsafe { avahi_service_browser_get_client(self.inner) }
     }
 }
 
diff --git a/zeroconf/src/avahi/resolver.rs b/zeroconf/src/avahi/resolver.rs
index 587cabf..12e669b 100644
--- a/zeroconf/src/avahi/resolver.rs
+++ b/zeroconf/src/avahi/resolver.rs
@@ -2,8 +2,8 @@
 
 use crate::Result;
 use avahi_sys::{
-    avahi_service_resolver_free, avahi_service_resolver_new, AvahiIfIndex, AvahiLookupFlags,
-    AvahiProtocol, AvahiServiceResolver, AvahiServiceResolverCallback,
+    AvahiIfIndex, AvahiLookupFlags, AvahiProtocol, AvahiServiceResolver,
+    AvahiServiceResolverCallback, avahi_service_resolver_free, avahi_service_resolver_new,
 };
 use libc::{c_char, c_void};
 use std::{collections::HashMap, sync::Arc};
@@ -41,18 +41,20 @@ impl ManagedAvahiServiceResolver {
             userdata,
         }: ManagedAvahiServiceResolverParams,
     ) -> Result<Self> {
-        let inner = avahi_service_resolver_new(
-            client.inner,
-            interface,
-            protocol,
-            name,
-            kind,
-            domain,
-            aprotocol,
-            flags,
-            callback,
-            userdata,
-        );
+        let inner = unsafe {
+            avahi_service_resolver_new(
+                client.inner,
+                interface,
+                protocol,
+                name,
+                kind,
+                domain,
+                aprotocol,
+                flags,
+                callback,
+                userdata,
+            )
+        };
 
         if inner.is_null() {
             Err("could not initialize AvahiServiceResolver".into())
diff --git a/zeroconf/src/avahi/service.rs b/zeroconf/src/avahi/service.rs
index 3f908cf..2a14d6f 100644
--- a/zeroconf/src/avahi/service.rs
+++ b/zeroconf/src/avahi/service.rs
@@ -6,7 +6,7 @@ use super::entry_group::{
     AddServiceParams, AddServiceSubtypeParams, ManagedAvahiEntryGroup, ManagedAvahiEntryGroupParams,
 };
 use super::poll::ManagedAvahiSimplePoll;
-use crate::ffi::{c_str, AsRaw, FromRaw, UnwrapOrNull};
+use crate::ffi::{AsRaw, FromRaw, UnwrapOrNull, c_str};
 use crate::prelude::*;
 use crate::{
     EventLoop, NetworkInterface, Result, ServiceRegisteredCallback, ServiceRegistration,
@@ -209,13 +209,13 @@ unsafe extern "C" fn client_callback(
     state: AvahiClientState,
     userdata: *mut c_void,
 ) {
-    let context = AvahiServiceContext::from_raw(userdata);
+    let context = unsafe { AvahiServiceContext::from_raw(userdata) };
 
     match state {
         avahi_sys::AvahiServerState_AVAHI_SERVER_INVALID
         | avahi_sys::AvahiServerState_AVAHI_SERVER_COLLISION
         | avahi_sys::AvahiServerState_AVAHI_SERVER_FAILURE => {
-            context.invoke_callback(Err(avahi_util::get_last_error(client).into()))
+            context.invoke_callback(Err(unsafe { avahi_util::get_last_error(client) }.into()))
         }
         _ => {}
     }
@@ -223,11 +223,13 @@ unsafe extern "C" fn client_callback(
 
 unsafe fn create_service(context: &mut AvahiServiceContext) -> Result<()> {
     if context.name.is_none() {
-        let host_name = context
-            .client
-            .as_ref()
-            .ok_or("expected initialized client")?
-            .host_name()?;
+        let host_name = unsafe {
+            context
+                .client
+                .as_ref()
+                .ok_or("expected initialized client")?
+                .host_name()?
+        };
 
         context.name = Some(c_string!(host_name.to_string()));
     }
@@ -235,18 +237,20 @@ unsafe fn create_service(context: &mut AvahiServiceContext) -> Result<()> {
     if context.group.is_none() {
         debug!("Creating group");
 
-        context.group = Some(ManagedAvahiEntryGroup::new(
-            ManagedAvahiEntryGroupParams::builder()
-                .client(Arc::clone(
-                    context
-                        .client
-                        .as_ref()
-                        .ok_or("could not get client as ref")?,
-                ))
-                .callback(Some(entry_group_callback))
-                .userdata(context.as_raw())
-                .build()?,
-        )?);
+        context.group = Some(unsafe {
+            ManagedAvahiEntryGroup::new(
+                ManagedAvahiEntryGroupParams::builder()
+                    .client(Arc::clone(
+                        context
+                            .client
+                            .as_ref()
+                            .ok_or("could not get client as ref")?,
+                    ))
+                    .callback(Some(entry_group_callback))
+                    .userdata(context.as_raw())
+                    .build()?,
+            )?
+        });
     }
 
     let group = context
@@ -254,7 +258,7 @@ unsafe fn create_service(context: &mut AvahiServiceContext) -> Result<()> {
         .as_mut()
         .ok_or("could not borrow group as mut")?;
 
-    if !group.is_empty() {
+    if unsafe { !group.is_empty() } {
         return Ok(());
     }
 
@@ -264,7 +268,7 @@ unsafe fn create_service(context: &mut AvahiServiceContext) -> Result<()> {
         .ok_or("could not get name as ref")?
         .clone();
 
-    add_services(context, &name)
+    unsafe { add_services(context, &name) }
 }
 
 unsafe fn add_services(context: &mut AvahiServiceContext, name: &CStr) -> Result<()> {
@@ -287,7 +291,7 @@ unsafe fn add_services(context: &mut AvahiServiceContext, name: &CStr) -> Result
         .txt(context.txt_record.as_ref().map(|t| t.inner()))
         .build()?;
 
-    group.add_service(params)?;
+    unsafe { group.add_service(params)? };
 
     for sub_type in &context.sub_types {
         debug!("Adding service subtype: {}", sub_type.to_string_lossy());
@@ -302,10 +306,10 @@ unsafe fn add_services(context: &mut AvahiServiceContext, name: &CStr) -> Result
             .subtype(sub_type.as_ptr())
             .build()?;
 
-        group.add_service_subtype(params)?;
+        unsafe { group.add_service_subtype(params)? };
     }
 
-    group.commit()
+    unsafe { group.commit() }
 }
 
 unsafe extern "C" fn entry_group_callback(
@@ -313,7 +317,7 @@ unsafe extern "C" fn entry_group_callback(
     state: AvahiEntryGroupState,
     userdata: *mut c_void,
 ) {
-    let context = AvahiServiceContext::from_raw(userdata);
+    let context = unsafe { AvahiServiceContext::from_raw(userdata) };
 
     let client = context
         .client
@@ -322,11 +326,11 @@ unsafe extern "C" fn entry_group_callback(
 
     match state {
         avahi_sys::AvahiEntryGroupState_AVAHI_ENTRY_GROUP_ESTABLISHED => {
-            context.invoke_callback(handle_group_established(context))
-        }
-        avahi_sys::AvahiEntryGroupState_AVAHI_ENTRY_GROUP_FAILURE => {
-            context.invoke_callback(Err(avahi_util::get_last_error(client.inner).into()))
+            context.invoke_callback(unsafe { handle_group_established(context) })
         }
+        avahi_sys::AvahiEntryGroupState_AVAHI_ENTRY_GROUP_FAILURE => context.invoke_callback(Err(
+            unsafe { avahi_util::get_last_error(client.inner) }.into(),
+        )),
         avahi_sys::AvahiEntryGroupState_AVAHI_ENTRY_GROUP_COLLISION => {
             let name = context
                 .name
@@ -334,8 +338,8 @@ unsafe extern "C" fn entry_group_callback(
                 .expect("expected initialized name")
                 .clone();
 
-            let new_name = avahi_util::alternative_service_name(name.as_c_str());
-            let result = add_services(context, new_name);
+            let new_name = unsafe { avahi_util::alternative_service_name(name.as_c_str()) };
+            let result = unsafe { add_services(context, new_name) };
 
             context.name = Some(new_name.into());
 
@@ -350,19 +354,21 @@ unsafe extern "C" fn entry_group_callback(
 unsafe fn handle_group_established(context: &AvahiServiceContext) -> Result<ServiceRegistration> {
     debug!("Group established");
 
-    let name = c_str::copy_raw(
-        context
-            .name
-            .as_ref()
-            .ok_or("could not get name as ref")?
-            .as_ptr(),
-    );
+    let name = unsafe {
+        c_str::copy_raw(
+            context
+                .name
+                .as_ref()
+                .ok_or("could not get name as ref")?
+                .as_ptr(),
+        )
+    };
 
     Ok(ServiceRegistration::builder()
         .name(name)
-        .service_type(ServiceType::from_str(&c_str::copy_raw(
-            context.kind.as_ptr(),
-        ))?)
+        .service_type(ServiceType::from_str(&unsafe {
+            c_str::copy_raw(context.kind.as_ptr())
+        })?)
         .domain("local".to_string())
         .build()?)
 }
diff --git a/zeroconf/src/avahi/string_list.rs b/zeroconf/src/avahi/string_list.rs
index 90c0a35..b46a77e 100644
--- a/zeroconf/src/avahi/string_list.rs
+++ b/zeroconf/src/avahi/string_list.rs
@@ -2,10 +2,10 @@
 
 use crate::ffi::c_str;
 use avahi_sys::{
-    avahi_free, avahi_string_list_add_pair, avahi_string_list_copy, avahi_string_list_equal,
-    avahi_string_list_find, avahi_string_list_free, avahi_string_list_get_next,
-    avahi_string_list_get_pair, avahi_string_list_length, avahi_string_list_new,
-    avahi_string_list_to_string, AvahiStringList,
+    AvahiStringList, avahi_free, avahi_string_list_add_pair, avahi_string_list_copy,
+    avahi_string_list_equal, avahi_string_list_find, avahi_string_list_free,
+    avahi_string_list_get_next, avahi_string_list_get_pair, avahi_string_list_length,
+    avahi_string_list_new, avahi_string_list_to_string,
 };
 use libc::{c_char, c_void};
 use std::marker::PhantomData;
@@ -23,7 +23,7 @@ impl ManagedAvahiStringList {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_string_list_new()`.
     pub unsafe fn new() -> Self {
-        Self(avahi_string_list_new(ptr::null()))
+        Self(unsafe { avahi_string_list_new(ptr::null()) })
     }
 
     /// Delegate function for [`avahi_string_list_add_pair()`].
@@ -34,7 +34,7 @@ impl ManagedAvahiStringList {
     ///
     /// [`avahi_string_list_add_pair()`]: https://avahi.org/doxygen/html/strlst_8h.html#a72e1b0f724f0c29b5e3c8792f385223f
     pub unsafe fn add_pair(&mut self, key: *const c_char, value: *const c_char) {
-        self.0 = avahi_string_list_add_pair(self.0, key, value);
+        self.0 = unsafe { avahi_string_list_add_pair(self.0, key, value) };
     }
 
     /// Delegate function for [`avahi_string_list_find()`]. Returns a new `AvahiStringListNode`.
@@ -45,7 +45,7 @@ impl ManagedAvahiStringList {
     ///
     /// [`avahi_string_list_find()`]: https://avahi.org/doxygen/html/strlst_8h.html#aafc54c009a2a1608b517c15a7cf29944
     pub unsafe fn find(&mut self, key: *const c_char) -> Option<AvahiStringListNode<'_>> {
-        let node = avahi_string_list_find(self.0, key);
+        let node = unsafe { avahi_string_list_find(self.0, key) };
 
         if !node.is_null() {
             Some(AvahiStringListNode::new(node))
@@ -61,7 +61,7 @@ impl ManagedAvahiStringList {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_string_list_length()`.
     pub unsafe fn length(&self) -> u32 {
-        avahi_string_list_length(self.0)
+        unsafe { avahi_string_list_length(self.0) }
     }
 
     /// Delegate function for [`avahi_string_list_to_string()`].
@@ -71,7 +71,7 @@ impl ManagedAvahiStringList {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_string_list_to_string()`.
     pub unsafe fn to_string(&self) -> AvahiString {
-        avahi_string_list_to_string(self.0).into()
+        unsafe { avahi_string_list_to_string(self.0).into() }
     }
 
     /// Returns the first node in the list.
@@ -84,11 +84,11 @@ impl ManagedAvahiStringList {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_string_list_copy()`.
     pub unsafe fn clone(&self) -> Self {
-        Self::clone_raw(self.0)
+        unsafe { Self::clone_raw(self.0) }
     }
 
     pub(super) unsafe fn clone_raw(raw: *mut AvahiStringList) -> Self {
-        Self(avahi_string_list_copy(raw))
+        Self(unsafe { avahi_string_list_copy(raw) })
     }
 
     pub(super) fn inner(&self) -> *mut AvahiStringList {
@@ -129,7 +129,7 @@ impl<'a> AvahiStringListNode<'a> {
     /// # Safety
     /// This function is unsafe because of the call to `avahi_string_list_get_next()`.
     pub unsafe fn next(self) -> Option<AvahiStringListNode<'a>> {
-        let next = avahi_string_list_get_next(self.list);
+        let next = unsafe { avahi_string_list_get_next(self.list) };
 
         if next.is_null() {
             None
@@ -147,7 +147,9 @@ impl<'a> AvahiStringListNode<'a> {
         let mut value: *mut c_char = ptr::null_mut();
         let mut value_size: usize = 0;
 
-        avahi_string_list_get_pair(self.list, &mut key, &mut value, &mut value_size);
+        unsafe {
+            avahi_string_list_get_pair(self.list, &mut key, &mut value, &mut value_size);
+        }
 
         AvahiPair::new(key.into(), value.into(), value_size)
     }
@@ -175,7 +177,7 @@ impl AvahiString {
         if self.0.is_null() {
             None
         } else {
-            Some(c_str::raw_to_str(self.0))
+            Some(unsafe { c_str::raw_to_str(self.0) })
         }
     }
 }
diff --git a/zeroconf/src/avahi/txt_record.rs b/zeroconf/src/avahi/txt_record.rs
index 55210a0..5d25424 100644
--- a/zeroconf/src/avahi/txt_record.rs
+++ b/zeroconf/src/avahi/txt_record.rs
@@ -1,8 +1,8 @@
 //! Avahi implementation for cross-platform TXT record.
 
 use super::string_list::{AvahiStringListNode, ManagedAvahiStringList};
-use crate::txt_record::TTxtRecord;
 use crate::Result;
+use crate::txt_record::TTxtRecord;
 use libc::c_char;
 use std::cell::UnsafeCell;
 
diff --git a/zeroconf/src/bonjour/bonjour_util.rs b/zeroconf/src/bonjour/bonjour_util.rs
index 511ccaf..535b149 100644
--- a/zeroconf/src/bonjour/bonjour_util.rs
+++ b/zeroconf/src/bonjour/bonjour_util.rs
@@ -3,7 +3,7 @@
 use std::{ffi::CString, str::FromStr};
 
 use super::constants;
-use crate::{check_valid_characters, lstrip_underscore, NetworkInterface, Result, ServiceType};
+use crate::{NetworkInterface, Result, ServiceType, check_valid_characters, lstrip_underscore};
 use bonjour_sys::DNSServiceErrorType;
 
 /// Normalizes the specified domain `&str` to conform to a standard enforced by this crate.
diff --git a/zeroconf/src/bonjour/browser.rs b/zeroconf/src/bonjour/browser.rs
index a84161c..bebf7aa 100644
--- a/zeroconf/src/bonjour/browser.rs
+++ b/zeroconf/src/bonjour/browser.rs
@@ -5,7 +5,7 @@ use super::service_ref::{
 };
 use super::txt_record_ref::ManagedTXTRecordRef;
 use super::{bonjour_util, constants};
-use crate::ffi::{c_str, AsRaw, FromRaw};
+use crate::ffi::{AsRaw, FromRaw, c_str};
 use crate::prelude::*;
 use crate::{BrowserEvent, ServiceBrowserCallback, ServiceDiscovery, ServiceRemoval};
 use crate::{EventLoop, NetworkInterface, Result, ServiceType, TxtRecord};
@@ -131,7 +131,7 @@ unsafe extern "system" fn browse_callback(
     domain: *const c_char,
     context: *mut c_void,
 ) {
-    let ctx = BonjourBrowserContext::from_raw(context);
+    let ctx = unsafe { BonjourBrowserContext::from_raw(context) };
 
     if error != 0 {
         ctx.invoke_callback(Err(format!(
@@ -143,11 +143,11 @@ unsafe extern "system" fn browse_callback(
     }
 
     if flags & bonjour_sys::kDNSServiceFlagsAdd != 0 {
-        if let Err(e) = handle_browse_add(ctx, name, regtype, domain, interface_index) {
+        if let Err(e) = unsafe { handle_browse_add(ctx, name, regtype, domain, interface_index) } {
             ctx.invoke_callback(Err(e));
         }
     } else {
-        handle_browse_remove(ctx, name, regtype, domain);
+        unsafe { handle_browse_remove(ctx, name, regtype, domain) };
     }
 }
 
@@ -158,21 +158,23 @@ unsafe fn handle_browse_add(
     domain: *const c_char,
     interface_index: u32,
 ) -> Result<()> {
-    ctx.resolved_name = Some(c_str::copy_raw(name));
-    ctx.resolved_kind = Some(c_str::copy_raw(regtype));
-    ctx.resolved_domain = Some(c_str::copy_raw(domain));
-
-    ManagedDNSServiceRef::default().resolve_service(
-        ServiceResolveParams::builder()
-            .flags(bonjour_sys::kDNSServiceFlagsForceMulticast)
-            .interface_index(interface_index)
-            .name(name)
-            .regtype(regtype)
-            .domain(domain)
-            .callback(Some(resolve_callback))
-            .context(ctx.as_raw())
-            .build()?,
-    )
+    ctx.resolved_name = Some(unsafe { c_str::copy_raw(name) });
+    ctx.resolved_kind = Some(unsafe { c_str::copy_raw(regtype) });
+    ctx.resolved_domain = Some(unsafe { c_str::copy_raw(domain) });
+
+    unsafe {
+        ManagedDNSServiceRef::default().resolve_service(
+            ServiceResolveParams::builder()
+                .flags(bonjour_sys::kDNSServiceFlagsForceMulticast)
+                .interface_index(interface_index)
+                .name(name)
+                .regtype(regtype)
+                .domain(domain)
+                .callback(Some(resolve_callback))
+                .context(ctx.as_raw())
+                .build()?,
+        )
+    }
 }
 
 unsafe fn handle_browse_remove(
@@ -181,9 +183,9 @@ unsafe fn handle_browse_remove(
     regtype: *const c_char,
     domain: *const c_char,
 ) {
-    let name = c_str::raw_to_str(name);
-    let regtype = c_str::raw_to_str(regtype);
-    let domain = c_str::raw_to_str(domain);
+    let name = unsafe { c_str::raw_to_str(name) };
+    let regtype = unsafe { c_str::raw_to_str(regtype) };
+    let domain = unsafe { c_str::raw_to_str(domain) };
 
     // Remove the "." suffix to be consistent with the Avahi implementation.
     let regtype = regtype.strip_suffix(".").unwrap_or(domain);
@@ -211,17 +213,19 @@ unsafe extern "system" fn resolve_callback(
     txt_record: *const c_uchar,
     context: *mut c_void,
 ) {
-    let ctx = BonjourBrowserContext::from_raw(context);
-
-    let result = handle_resolve(
-        ctx,
-        error,
-        port,
-        interface_index,
-        host_target,
-        txt_len,
-        txt_record,
-    );
+    let ctx = unsafe { BonjourBrowserContext::from_raw(context) };
+
+    let result = unsafe {
+        handle_resolve(
+            ctx,
+            error,
+            port,
+            interface_index,
+            host_target,
+            txt_len,
+            txt_record,
+        )
+    };
 
     if let Err(e) = result {
         ctx.invoke_callback(Err(e));
@@ -244,23 +248,25 @@ unsafe fn handle_resolve(
     ctx.resolved_port = port;
 
     ctx.resolved_txt = if txt_len > 1 {
-        Some(TxtRecord::from(ManagedTXTRecordRef::clone_raw(
-            txt_record, txt_len,
-        )?))
+        Some(TxtRecord::from(unsafe {
+            ManagedTXTRecordRef::clone_raw(txt_record, txt_len)?
+        }))
     } else {
         None
     };
 
-    ManagedDNSServiceRef::default().get_address_info(
-        GetAddressInfoParams::builder()
-            .flags(bonjour_sys::kDNSServiceFlagsForceMulticast)
-            .interface_index(interface_index)
-            .protocol(0)
-            .hostname(host_target)
-            .callback(Some(get_address_info_callback))
-            .context(ctx.as_raw())
-            .build()?,
-    )
+    unsafe {
+        ManagedDNSServiceRef::default().get_address_info(
+            GetAddressInfoParams::builder()
+                .flags(bonjour_sys::kDNSServiceFlagsForceMulticast)
+                .interface_index(interface_index)
+                .protocol(0)
+                .hostname(host_target)
+                .callback(Some(get_address_info_callback))
+                .context(ctx.as_raw())
+                .build()?,
+        )
+    }
 }
 
 unsafe extern "system" fn get_address_info_callback(
@@ -273,8 +279,8 @@ unsafe extern "system" fn get_address_info_callback(
     _ttl: u32,
     context: *mut c_void,
 ) {
-    let ctx = BonjourBrowserContext::from_raw(context);
-    if let Err(e) = handle_get_address_info(ctx, error, address, hostname) {
+    let ctx = unsafe { BonjourBrowserContext::from_raw(context) };
+    if let Err(e) = unsafe { handle_get_address_info(ctx, error, address, hostname) } {
         ctx.invoke_callback(Err(e));
     }
 }
@@ -306,7 +312,7 @@ unsafe fn handle_get_address_info(
     let ip = {
         let address = address as *const sockaddr_in;
         assert_not_null!(address);
-        let s_addr = (*address).sin_addr.s_addr.to_le_bytes();
+        let s_addr = unsafe { (*address).sin_addr.s_addr.to_le_bytes() };
         IpAddr::from(s_addr).to_string()
     };
 
@@ -314,12 +320,12 @@ unsafe fn handle_get_address_info(
     let ip = {
         let address = address as *const sockaddr_in;
         assert_not_null!(address);
-        let s_un = (*address).sin_addr.S_un.S_un_b;
+        let s_un = unsafe { (*address).sin_addr.S_un.S_un_b };
         let s_addr = [s_un.s_b1, s_un.s_b2, s_un.s_b3, s_un.s_b4];
         IpAddr::from(s_addr).to_string()
     };
 
-    let hostname = c_str::copy_raw(hostname);
+    let hostname = unsafe { c_str::copy_raw(hostname) };
 
     let domain = bonjour_util::normalize_domain(
         &ctx.resolved_domain
diff --git a/zeroconf/src/bonjour/event_loop.rs b/zeroconf/src/bonjour/event_loop.rs
index 9209dcb..170d386 100644
--- a/zeroconf/src/bonjour/event_loop.rs
+++ b/zeroconf/src/bonjour/event_loop.rs
@@ -2,7 +2,7 @@
 
 use super::service_ref::ManagedDNSServiceRef;
 use crate::event_loop::TEventLoop;
-use crate::{ffi, Result};
+use crate::{Result, ffi};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
diff --git a/zeroconf/src/bonjour/service.rs b/zeroconf/src/bonjour/service.rs
index 0cf2b9b..7f5ddf2 100644
--- a/zeroconf/src/bonjour/service.rs
+++ b/zeroconf/src/bonjour/service.rs
@@ -177,8 +177,8 @@ unsafe extern "system" fn register_callback(
     domain: *const c_char,
     context: *mut c_void,
 ) {
-    let context = BonjourServiceContext::from_raw(context);
-    if let Err(e) = handle_register(context, error, domain, name, regtype) {
+    let context = unsafe { BonjourServiceContext::from_raw(context) };
+    if let Err(e) = unsafe { handle_register(context, error, domain, name, regtype) } {
         context.invoke_callback(Err(e));
     }
 }
@@ -194,11 +194,11 @@ unsafe fn handle_register(
         return Err(format!("register_callback() reported error (code: {0})", error).into());
     }
 
-    let domain = bonjour_util::normalize_domain(c_str::raw_to_str(domain));
-    let kind = bonjour_util::normalize_domain(c_str::raw_to_str(regtype));
+    let domain = bonjour_util::normalize_domain(unsafe { c_str::raw_to_str(domain) });
+    let kind = bonjour_util::normalize_domain(unsafe { c_str::raw_to_str(regtype) });
 
     let result = ServiceRegistration::builder()
-        .name(c_str::copy_raw(name))
+        .name(unsafe { c_str::copy_raw(name) })
         .service_type(bonjour_util::parse_regtype(&kind)?)
         .domain(domain)
         .build()
diff --git a/zeroconf/src/bonjour/service_ref.rs b/zeroconf/src/bonjour/service_ref.rs
index c7cd928..e28849e 100644
--- a/zeroconf/src/bonjour/service_ref.rs
+++ b/zeroconf/src/bonjour/service_ref.rs
@@ -1,11 +1,11 @@
 //! Low level interface for interacting with `DNSserviceRef`
 
-use crate::{bonjour::bonjour_util, Result};
+use crate::{Result, bonjour::bonjour_util};
 use bonjour_sys::{
-    dnssd_sock_t, DNSServiceBrowse, DNSServiceBrowseReply, DNSServiceFlags, DNSServiceGetAddrInfo,
+    DNSServiceBrowse, DNSServiceBrowseReply, DNSServiceFlags, DNSServiceGetAddrInfo,
     DNSServiceGetAddrInfoReply, DNSServiceProcessResult, DNSServiceProtocol, DNSServiceRef,
     DNSServiceRefDeallocate, DNSServiceRefSockFD, DNSServiceRegister, DNSServiceRegisterReply,
-    DNSServiceResolve, DNSServiceResolveReply,
+    DNSServiceResolve, DNSServiceResolveReply, dnssd_sock_t,
 };
 use libc::{c_char, c_void};
 use std::ptr;
@@ -51,7 +51,7 @@ impl ManagedDNSServiceRef {
         }: RegisterServiceParams,
     ) -> Result<()> {
         bonjour_util::sys_exec(
-            || {
+            || unsafe {
                 DNSServiceRegister(
                     &mut self.0 as *mut DNSServiceRef,
                     flags,
@@ -89,7 +89,7 @@ impl ManagedDNSServiceRef {
         }: BrowseServicesParams,
     ) -> Result<()> {
         bonjour_util::sys_exec(
-            || {
+            || unsafe {
                 DNSServiceBrowse(
                     &mut self.0 as *mut DNSServiceRef,
                     flags,
@@ -123,7 +123,7 @@ impl ManagedDNSServiceRef {
         }: ServiceResolveParams,
     ) -> Result<()> {
         bonjour_util::sys_exec(
-            || {
+            || unsafe {
                 DNSServiceResolve(
                     &mut self.0 as *mut DNSServiceRef,
                     flags,
@@ -138,7 +138,7 @@ impl ManagedDNSServiceRef {
             "DNSServiceResolve() reported error",
         )?;
 
-        self.process_result()
+        unsafe { self.process_result() }
     }
 
     /// Delegate function for [`DNSServiceGetAddrInfo`].
@@ -159,7 +159,7 @@ impl ManagedDNSServiceRef {
         }: GetAddressInfoParams,
     ) -> Result<()> {
         bonjour_util::sys_exec(
-            || {
+            || unsafe {
                 DNSServiceGetAddrInfo(
                     &mut self.0 as *mut DNSServiceRef,
                     flags,
@@ -173,7 +173,7 @@ impl ManagedDNSServiceRef {
             "DNSServiceGetAddrInfo() reported error",
         )?;
 
-        self.process_result()
+        unsafe { self.process_result() }
     }
 
     /// Delegate function for [`DNSServiceProcessResult`].
@@ -184,7 +184,7 @@ impl ManagedDNSServiceRef {
     /// This function is unsafe because it calls a C function.
     pub unsafe fn process_result(&self) -> Result<()> {
         bonjour_util::sys_exec(
-            || DNSServiceProcessResult(self.0),
+            || unsafe { DNSServiceProcessResult(self.0) },
             "could not process service result",
         )
     }
@@ -196,7 +196,7 @@ impl ManagedDNSServiceRef {
     /// # Safety
     /// This function is unsafe because it calls a C function.
     pub unsafe fn sock_fd(&self) -> dnssd_sock_t {
-        DNSServiceRefSockFD(self.0)
+        unsafe { DNSServiceRefSockFD(self.0) }
     }
 }
 
diff --git a/zeroconf/src/bonjour/txt_record.rs b/zeroconf/src/bonjour/txt_record.rs
index ccb9aba..87ce17b 100644
--- a/zeroconf/src/bonjour/txt_record.rs
+++ b/zeroconf/src/bonjour/txt_record.rs
@@ -1,9 +1,9 @@
 //! Bonjour implementation for cross-platform TXT record.
 
 use super::txt_record_ref::ManagedTXTRecordRef;
+use crate::Result;
 use crate::ffi::c_str;
 use crate::txt_record::TTxtRecord;
-use crate::Result;
 use libc::{c_char, c_void};
 use std::ffi::CString;
 use std::{ptr, slice};
@@ -37,7 +37,7 @@ impl TTxtRecord for BonjourTxtRecord {
 
         let value_raw = unsafe {
             self.0
-                .get_value_ptr(c_str.as_ptr() as *const c_char, &mut value_len)
+                .get_value_ptr(c_str.as_ptr() as *mut c_char, &mut value_len)
         };
 
         if value_raw.is_null() {
@@ -126,7 +126,7 @@ impl Iterator for Iter<'_> {
             return None;
         }
 
-        let raw_key: CString = unsafe { c_string!(alloc(Iter::KEY_LEN as usize)) };
+        let raw_key: CString = c_string!(alloc(Iter::KEY_LEN as usize));
         let mut value_len: u8 = 0;
         let mut value: *const c_void = ptr::null_mut();
 
@@ -181,6 +181,6 @@ impl Iterator for Values<'_> {
 
 unsafe fn read_value(value: *const c_void, value_len: u8) -> String {
     let value_len = value_len as usize;
-    let value_raw = slice::from_raw_parts(value as *const u8, value_len);
+    let value_raw = unsafe { slice::from_raw_parts(value as *const u8, value_len) };
     String::from_utf8(value_raw.to_vec()).expect("could not read value")
 }
diff --git a/zeroconf/src/bonjour/txt_record_ref.rs b/zeroconf/src/bonjour/txt_record_ref.rs
index eb7e201..9ed1862 100644
--- a/zeroconf/src/bonjour/txt_record_ref.rs
+++ b/zeroconf/src/bonjour/txt_record_ref.rs
@@ -23,8 +23,8 @@ impl ManagedTXTRecordRef {
     /// # Safety
     /// This function is unsafe because it calls a C function.
     pub unsafe fn new() -> Self {
-        let mut record: TXTRecordRef = mem::zeroed();
-        TXTRecordCreate(&mut record, 0, ptr::null_mut());
+        let mut record: TXTRecordRef = unsafe { mem::zeroed() };
+        unsafe { TXTRecordCreate(&mut record, 0, ptr::null_mut()) };
         Self(record)
     }
 
@@ -35,7 +35,7 @@ impl ManagedTXTRecordRef {
     /// # Safety
     /// This function is unsafe because it makes no guarantees about the raw pointer arguments
     pub unsafe fn get_bytes_ptr(&self) -> *const c_void {
-        TXTRecordGetBytesPtr(&self.0)
+        unsafe { TXTRecordGetBytesPtr(&self.0) }
     }
 
     /// Delegate function for [`TXTRecordGetLength()`].
@@ -45,7 +45,7 @@ impl ManagedTXTRecordRef {
     /// # Safety
     /// This function is unsafe because it makes no guarantees about the raw pointer arguments
     pub unsafe fn get_length(&self) -> u16 {
-        TXTRecordGetLength(&self.0)
+        unsafe { TXTRecordGetLength(&self.0) }
     }
 
     /// Delegate function for [`TXTRecordRemoveValue()`].
@@ -57,7 +57,7 @@ impl ManagedTXTRecordRef {
     /// [`TXTRecordRemoveValue()`]: https://developer.apple.com/documentation/dnssd/1804721-txtrecordremovevalue?language=objc
     pub unsafe fn remove_value(&mut self, key: *const c_char) -> Result<()> {
         bonjour_util::sys_exec(
-            || TXTRecordRemoveValue(&mut self.0, key),
+            || unsafe { TXTRecordRemoveValue(&mut self.0, key) },
             "could not remove TXT record value",
         )
     }
@@ -76,7 +76,7 @@ impl ManagedTXTRecordRef {
         value: *const c_void,
     ) -> Result<()> {
         bonjour_util::sys_exec(
-            || TXTRecordSetValue(&mut self.0, key, value_size, value),
+            || unsafe { TXTRecordSetValue(&mut self.0, key, value_size, value) },
             "could not set TXT record value",
         )
     }
@@ -89,7 +89,7 @@ impl ManagedTXTRecordRef {
     ///
     /// [`TXTRecordContainsKey`]: https://developer.apple.com/documentation/dnssd/1804705-txtrecordcontainskey?language=objc
     pub unsafe fn contains_key(&self, key: *const c_char) -> bool {
-        TXTRecordContainsKey(self.get_length(), self.get_bytes_ptr(), key) == 1
+        unsafe { TXTRecordContainsKey(self.get_length(), self.get_bytes_ptr(), key) == 1 }
     }
 
     /// Delegate function for [`TXTRecordGetCount`].
@@ -99,7 +99,7 @@ impl ManagedTXTRecordRef {
     /// # Safety
     /// This function is unsafe because it makes no guarantees about it's raw pointer arguments
     pub unsafe fn get_count(&self) -> u16 {
-        _get_count(self.get_length(), self.get_bytes_ptr())
+        unsafe { _get_count(self.get_length(), self.get_bytes_ptr()) }
     }
 
     /// Delegate function for [`TXTRecordGetItemAtIndex`].
@@ -117,15 +117,17 @@ impl ManagedTXTRecordRef {
         value_len: *mut u8,
         value: *mut *const c_void,
     ) -> Result<()> {
-        _get_item_at_index(
-            self.get_length(),
-            self.get_bytes_ptr(),
-            item_index,
-            key_buf_len,
-            key,
-            value_len,
-            value,
-        )
+        unsafe {
+            _get_item_at_index(
+                self.get_length(),
+                self.get_bytes_ptr(),
+                item_index,
+                key_buf_len,
+                key,
+                value_len,
+                value,
+            )
+        }
     }
 
     /// Delegate function for [`TXTRecordGetValuePtr`].
@@ -135,8 +137,8 @@ impl ManagedTXTRecordRef {
     /// that are dereferenced.
     ///
     /// [`TXTRecordGetValuePtr`]: https://developer.apple.com/documentation/dnssd/1804709-txtrecordgetvalueptr?language=objc
-    pub unsafe fn get_value_ptr(&self, key: *const c_char, value_len: *mut u8) -> *const c_void {
-        TXTRecordGetValuePtr(self.get_length(), self.get_bytes_ptr(), key, value_len)
+    pub unsafe fn get_value_ptr(&self, key: *mut c_char, value_len: &mut u8) -> *const c_void {
+        unsafe { TXTRecordGetValuePtr(self.get_length(), self.get_bytes_ptr(), key, value_len) }
     }
 
     /// Returns a copy of the TXT record.
@@ -144,33 +146,35 @@ impl ManagedTXTRecordRef {
     /// # Safety
     /// This function is unsafe because it makes no guarantees about the raw pointer arguments
     pub unsafe fn clone(&self) -> Self {
-        Self::clone_raw(self.get_bytes_ptr() as *const c_uchar, self.get_length())
+        unsafe { Self::clone_raw(self.get_bytes_ptr() as *const c_uchar, self.get_length()) }
             .expect("could not clone TXT record")
     }
 
     pub(crate) unsafe fn clone_raw(raw: *const c_uchar, size: u16) -> Result<Self> {
         let chars = c_string!(alloc(size as usize)).into_raw() as *mut c_uchar;
-        ptr::copy(raw, chars, size as usize);
-        let chars = CString::from_raw(chars as *mut c_char);
+        unsafe { ptr::copy(raw, chars, size as usize) };
+        let chars = unsafe { CString::from_raw(chars as *mut c_char) };
 
-        let mut record = Self::new();
+        let mut record = unsafe { Self::new() };
 
-        for i in 0.._get_count(size, chars.as_ptr() as *const c_void) {
+        for i in 0..unsafe { _get_count(size, chars.as_ptr() as *const c_void) } {
             let key = c_string!(alloc(256));
             let mut value_len: u8 = 0;
             let mut value: *const c_void = ptr::null_mut();
 
-            _get_item_at_index(
-                size,
-                chars.as_ptr() as *const c_void,
-                i,
-                256,
-                key.as_ptr() as *mut c_char,
-                &mut value_len,
-                &mut value,
-            )?;
-
-            record.set_value(key.as_ptr() as *mut c_char, value_len, value)?;
+            unsafe {
+                _get_item_at_index(
+                    size,
+                    chars.as_ptr() as *const c_void,
+                    i,
+                    256,
+                    key.as_ptr() as *mut c_char,
+                    &mut value_len,
+                    &mut value,
+                )
+            }?;
+
+            unsafe { record.set_value(key.as_ptr() as *mut c_char, value_len, value) }?;
         }
 
         Ok(record)
@@ -192,7 +196,7 @@ impl fmt::Debug for ManagedTXTRecordRef {
 unsafe impl Send for ManagedTXTRecordRef {}
 
 unsafe fn _get_count(length: u16, data: *const c_void) -> u16 {
-    TXTRecordGetCount(length, data)
+    unsafe { TXTRecordGetCount(length, data) }
 }
 
 unsafe fn _get_item_at_index(
@@ -205,7 +209,9 @@ unsafe fn _get_item_at_index(
     value: *mut *const c_void,
 ) -> Result<()> {
     bonjour_util::sys_exec(
-        || TXTRecordGetItemAtIndex(length, data, item_index, key_buf_len, key, value_len, value),
+        || unsafe {
+            TXTRecordGetItemAtIndex(length, data, item_index, key_buf_len, key, value_len, value)
+        },
         "could get item at index for TXT record",
     )
 }
@@ -235,8 +241,7 @@ mod tests {
         let mut value_len: u8 = 0;
         let result = unsafe {
             c_str::raw_to_str(
-                record.get_value_ptr(key.as_ptr() as *const c_char, &mut value_len)
-                    as *const c_char,
+                record.get_value_ptr(key.as_ptr() as *mut c_char, &mut value_len) as *const c_char,
             )
         };
 
@@ -256,7 +261,7 @@ mod tests {
         }
 
         let mut value_len: u8 = 0;
-        let result = unsafe { record.get_value_ptr(key.as_ptr() as *const c_char, &mut value_len) };
+        let result = unsafe { record.get_value_ptr(key.as_ptr() as *mut c_char, &mut value_len) };
 
         assert!(result.is_null());
     }
@@ -281,7 +286,7 @@ mod tests {
         }
 
         let mut value_len: u8 = 0;
-        let result = unsafe { record.get_value_ptr(key.as_ptr() as *const c_char, &mut value_len) };
+        let result = unsafe { record.get_value_ptr(key.as_ptr() as *mut c_char, &mut value_len) };
 
         assert!(result.is_null());
     }
@@ -358,7 +363,7 @@ mod tests {
                 .unwrap();
         }
 
-        let key = unsafe { c_string!(alloc(256)) };
+        let key = c_string!(alloc(256));
         let mut value_len: u8 = 0;
         let mut value: *const c_void = ptr::null_mut();
 
diff --git a/zeroconf/src/ffi/c_str.rs b/zeroconf/src/ffi/c_str.rs
index acde68c..2854706 100644
--- a/zeroconf/src/ffi/c_str.rs
+++ b/zeroconf/src/ffi/c_str.rs
@@ -25,9 +25,11 @@ impl AsCChars for Option<&CString> {
 /// [`CStr::from_ptr()`]: https://doc.rust-lang.org/std/ffi/struct.CStr.html#method.from_ptr
 pub unsafe fn raw_to_str<'a>(s: *const c_char) -> &'a str {
     assert_not_null!(s);
-    CStr::from_ptr(s)
-        .to_str()
-        .expect("could not convert raw to str")
+    unsafe {
+        CStr::from_ptr(s)
+            .to_str()
+            .expect("could not convert raw to str")
+    }
 }
 
 /// Copies the specified `*const c_char` into a `String`.
@@ -38,7 +40,7 @@ pub unsafe fn raw_to_str<'a>(s: *const c_char) -> &'a str {
 /// [`raw_to_str()`]: fn.raw_to_str.html
 pub unsafe fn copy_raw(s: *const c_char) -> String {
     assert_not_null!(s);
-    String::from(raw_to_str(s))
+    String::from(unsafe { raw_to_str(s) })
 }
 
 /// Converts the specified [`CString`] to a `&str`.
diff --git a/zeroconf/src/ffi/mod.rs b/zeroconf/src/ffi/mod.rs
index acd3147..6ff1458 100644
--- a/zeroconf/src/ffi/mod.rs
+++ b/zeroconf/src/ffi/mod.rs
@@ -13,7 +13,7 @@ pub trait FromRaw<T> {
     /// This function is unsafe due to the dereference of the specified raw pointer.
     unsafe fn from_raw<'a>(raw: *mut c_void) -> &'a mut T {
         assert_not_null!(raw);
-        &mut *(raw as *mut T)
+        unsafe { &mut *(raw as *mut T) }
     }
 }
 
@@ -64,22 +64,24 @@ pub(crate) mod bonjour {
     /// # Safety
     /// This function is unsafe because it directly interfaces with C-library system calls.
     pub unsafe fn read_select(sock_fd: i32, timeout: Duration) -> Result<u32> {
-        let mut read_flags: fd_set = mem::zeroed();
+        let mut read_flags: fd_set = unsafe { mem::zeroed() };
 
-        libc::FD_ZERO(&mut read_flags);
-        libc::FD_SET(sock_fd, &mut read_flags);
+        unsafe { libc::FD_ZERO(&mut read_flags) };
+        unsafe { libc::FD_SET(sock_fd, &mut read_flags) };
 
         let tv_sec = timeout.as_secs() as time_t;
         let tv_usec = timeout.subsec_micros() as suseconds_t;
         let mut timeout = timeval { tv_sec, tv_usec };
 
-        let result = libc::select(
-            sock_fd + 1,
-            &mut read_flags,
-            ptr::null_mut(),
-            ptr::null_mut(),
-            &mut timeout,
-        );
+        let result = unsafe {
+            libc::select(
+                sock_fd + 1,
+                &mut read_flags,
+                ptr::null_mut(),
+                ptr::null_mut(),
+                &mut timeout,
+            )
+        };
 
         if result < 0 {
             Err("select(): returned error status".into())
@@ -121,7 +123,7 @@ pub(crate) mod bonjour {
         };
         set.fd_array[0] = sock_fd;
 
-        let result = select(0, &mut set, ptr::null_mut(), &mut set, &timeout);
+        let result = unsafe { select(0, &mut set, ptr::null_mut(), &mut set, &timeout) };
 
         if result < 0 {
             Err("select(): returned error status".into())
diff --git a/zeroconf/src/macros.rs b/zeroconf/src/macros.rs
index d5ee975..211d69f 100644
--- a/zeroconf/src/macros.rs
+++ b/zeroconf/src/macros.rs
@@ -8,7 +8,7 @@ macro_rules! assert_not_null {
 
 macro_rules! c_string {
     (alloc($len:expr)) => {
-        ::std::ffi::CString::from_vec_unchecked(vec![0; $len])
+        unsafe { ::std::ffi::CString::from_vec_unchecked(vec![0; $len]) }
     };
     ($x:expr) => {
         ::std::ffi::CString::new($x).expect("could not create new CString")
diff --git a/zeroconf/src/service_type.rs b/zeroconf/src/service_type.rs
index 7d1be22..84403bd 100644
--- a/zeroconf/src/service_type.rs
+++ b/zeroconf/src/service_type.rs
@@ -2,7 +2,7 @@
 
 use std::str::FromStr;
 
-use crate::{error::Error, Result};
+use crate::{Result, error::Error};
 
 /// Data type for constructing a service type to register as an mDNS service.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]