diff --git a/Cargo.toml b/Cargo.toml
index 404d376..0aa783c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ description = "netlink packet types"
 [dependencies]
 anyhow = "1.0.31"
 byteorder = "1.3.2"
-netlink-packet-utils = "0.5.2"
+netlink-packet-utils = "0.6.0"
 
 [dev-dependencies]
 netlink-packet-route = "0.13.0"
diff --git a/src/done.rs b/src/done.rs
index f81507c..1cba4d6 100644
--- a/src/done.rs
+++ b/src/done.rs
@@ -97,10 +97,10 @@ impl Emitable for DoneMessage {
     }
 }
 
-impl<'buffer, T: AsRef<[u8]> + 'buffer> Parseable<DoneBuffer<&'buffer T>>
-    for DoneMessage
-{
-    fn parse(buf: &DoneBuffer<&'buffer T>) -> Result<DoneMessage, DecodeError> {
+impl<T: AsRef<[u8]>> Parseable<DoneBuffer<&T>> for DoneMessage {
+    type Error = DecodeError;
+
+    fn parse(buf: &DoneBuffer<&T>) -> Result<DoneMessage, Self::Error> {
         Ok(DoneMessage {
             code: buf.code(),
             extended_ack: buf.extended_ack().to_vec(),
diff --git a/src/error.rs b/src/error.rs
index f7951f7..df510c1 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -115,12 +115,10 @@ impl Emitable for ErrorMessage {
     }
 }
 
-impl<'buffer, T: AsRef<[u8]> + 'buffer> Parseable<ErrorBuffer<&'buffer T>>
-    for ErrorMessage
-{
-    fn parse(
-        buf: &ErrorBuffer<&'buffer T>,
-    ) -> Result<ErrorMessage, DecodeError> {
+impl<T: AsRef<[u8]>> Parseable<ErrorBuffer<&T>> for ErrorMessage {
+    type Error = DecodeError;
+
+    fn parse(buf: &ErrorBuffer<&T>) -> Result<ErrorMessage, Self::Error> {
         // FIXME: The payload of an error is basically a truncated packet, which
         // requires custom logic to parse correctly. For now we just
         // return it as a Vec<u8> let header: NetlinkHeader = {
diff --git a/src/header.rs b/src/header.rs
index 22e2445..dd37753 100644
--- a/src/header.rs
+++ b/src/header.rs
@@ -54,10 +54,10 @@ impl Emitable for NetlinkHeader {
     }
 }
 
-impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NetlinkBuffer<&'a T>>
-    for NetlinkHeader
-{
-    fn parse(buf: &NetlinkBuffer<&'a T>) -> Result<NetlinkHeader, DecodeError> {
+impl<T: AsRef<[u8]> + ?Sized> Parseable<NetlinkBuffer<&T>> for NetlinkHeader {
+    type Error = DecodeError;
+
+    fn parse(buf: &NetlinkBuffer<&T>) -> Result<NetlinkHeader, Self::Error> {
         Ok(NetlinkHeader {
             length: buf.length(),
             message_type: buf.message_type(),
diff --git a/src/message.rs b/src/message.rs
index 4bc7dda..b3b0541 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -2,7 +2,6 @@
 
 use std::fmt::Debug;
 
-use anyhow::Context;
 use netlink_packet_utils::DecodeError;
 
 use crate::{
@@ -83,40 +82,41 @@ where
     }
 }
 
-impl<'buffer, B, I> Parseable<NetlinkBuffer<&'buffer B>> for NetlinkMessage<I>
+impl<B, I> Parseable<NetlinkBuffer<&B>> for NetlinkMessage<I>
 where
-    B: AsRef<[u8]> + 'buffer,
+    B: AsRef<[u8]>,
     I: NetlinkDeserializable,
 {
-    fn parse(buf: &NetlinkBuffer<&'buffer B>) -> Result<Self, DecodeError> {
+    type Error = DecodeError;
+
+    fn parse(buf: &NetlinkBuffer<&B>) -> Result<Self, Self::Error> {
         use self::NetlinkPayload::*;
 
         let header =
-            <NetlinkHeader as Parseable<NetlinkBuffer<&'buffer B>>>::parse(buf)
-                .context("failed to parse netlink header")?;
+            <NetlinkHeader as Parseable<NetlinkBuffer<&B>>>::parse(buf)?;
 
         let bytes = buf.payload();
         let payload = match header.message_type {
             NLMSG_ERROR => {
                 let msg = ErrorBuffer::new_checked(&bytes)
-                    .and_then(|buf| ErrorMessage::parse(&buf))
-                    .context("failed to parse NLMSG_ERROR")?;
+                    .and_then(|buf| ErrorMessage::parse(&buf))?;
                 Error(msg)
             }
             NLMSG_NOOP => Noop,
             NLMSG_DONE => {
                 let msg = DoneBuffer::new_checked(&bytes)
-                    .and_then(|buf| DoneMessage::parse(&buf))
-                    .context("failed to parse NLMSG_DONE")?;
+                    .and_then(|buf| DoneMessage::parse(&buf))?;
                 Done(msg)
             }
             NLMSG_OVERRUN => Overrun(bytes.to_vec()),
-            message_type => {
-                let inner_msg = I::deserialize(&header, bytes).context(
-                    format!("Failed to parse message with type {message_type}"),
-                )?;
-                InnerMessage(inner_msg)
-            }
+            message_type => match I::deserialize(&header, bytes) {
+                Err(e) => {
+                    return Err(DecodeError::Other(
+                            format!("Failed to parse message with type {message_type}: {e}").into()),
+                    );
+                }
+                Ok(inner_msg) => InnerMessage(inner_msg),
+            },
         };
         Ok(NetlinkMessage { header, payload })
     }