aya-obj: reduce indirection in section parsing

Remove repetition of permitted cgroup attach types. Make optionality of
name more explicit rather than pretending both kind and name are equal
to section.

aya-obj/src/obj.rs

@@ -267,8 +267,8 @@ impl FromStr for ProgramSection {
         // parse the common case, eg "xdp/program_name" or
         // "sk_skb/stream_verdict/program_name"
         let (kind, name) = match section.rsplit_once('/') {
-            None => (section, section),
+            None => (section, None),
-            Some((kind, name)) => (kind, name),
+            Some((kind, name)) => (kind, Some(name)),
         };
 
         Ok(match kind {
@@ -285,8 +285,8 @@ impl FromStr for ProgramSection {
             "socket" => SocketFilter,
             "sk_msg" => SkMsg,
             "sk_skb" => match name {
-                "stream_parser" => SkSkbStreamParser,
+                Some("stream_parser") => SkSkbStreamParser,
-                "stream_verdict" => SkSkbStreamVerdict,
+                Some("stream_verdict") => SkSkbStreamVerdict,
                 _ => {
                     return Err(ParseError::InvalidProgramSection {
                         section: section.to_owned(),
@@ -298,8 +298,8 @@ impl FromStr for ProgramSection {
             "sockops" => SockOps,
             "classifier" => SchedClassifier,
             "cgroup_skb" => match name {
-                "ingress" => CgroupSkbIngress,
+                Some("ingress") => CgroupSkbIngress,
-                "egress" => CgroupSkbEgress,
+                Some("egress") => CgroupSkbEgress,
                 _ => {
                     return Err(ParseError::InvalidProgramSection {
                         section: section.to_owned(),
@@ -321,39 +321,71 @@ impl FromStr for ProgramSection {
                 attach_type: CgroupSockoptAttachType::Set,
             },
             "cgroup" => match name {
-                "skb" => CgroupSkb,
+                Some("skb") => CgroupSkb,
-                "sysctl" => CgroupSysctl,
+                Some("sysctl") => CgroupSysctl,
-                "dev" => CgroupDevice,
+                Some("dev") => CgroupDevice,
-                "getsockopt" | "setsockopt" => {
+                Some("getsockopt") => CgroupSockopt {
-                    if let Ok(attach_type) = CgroupSockoptAttachType::try_from(name) {
+                    attach_type: CgroupSockoptAttachType::Get,
-                        CgroupSockopt { attach_type }
+                },
-                    } else {
+                Some("setsockopt") => CgroupSockopt {
-                        return Err(ParseError::InvalidProgramSection {
+                    attach_type: CgroupSockoptAttachType::Set,
-                            section: section.to_owned(),
+                },
-                        });
+                Some("sock") => CgroupSock {
-                    }
-                }
-                "sock" => CgroupSock {
                     attach_type: CgroupSockAttachType::default(),
                 },
-                "post_bind4" | "post_bind6" | "sock_create" | "sock_release" => {
+                Some("post_bind4") => CgroupSock {
-                    if let Ok(attach_type) = CgroupSockAttachType::try_from(name) {
+                    attach_type: CgroupSockAttachType::PostBind4,
-                        CgroupSock { attach_type }
+                },
-                    } else {
+                Some("post_bind6") => CgroupSock {
-                        return Err(ParseError::InvalidProgramSection {
+                    attach_type: CgroupSockAttachType::PostBind6,
-                            section: section.to_owned(),
+                },
-                        });
+                Some("sock_create") => CgroupSock {
-                    }
+                    attach_type: CgroupSockAttachType::SockCreate,
-                }
+                },
-                name => {
+                Some("sock_release") => CgroupSock {
-                    if let Ok(attach_type) = CgroupSockAddrAttachType::try_from(name) {
+                    attach_type: CgroupSockAttachType::SockRelease,
-                        CgroupSockAddr { attach_type }
+                },
-                    } else {
+                Some("bind4") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::Bind4,
+                },
+                Some("bind6") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::Bind6,
+                },
+                Some("connect4") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::Connect4,
+                },
+                Some("connect6") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::Connect6,
+                },
+                Some("getpeername4") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::GetPeerName4,
+                },
+                Some("getpeername6") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::GetPeerName6,
+                },
+                Some("getsockname4") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::GetSockName4,
+                },
+                Some("getsockname6") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::GetSockName6,
+                },
+                Some("sendmsg4") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::UDPSendMsg4,
+                },
+                Some("sendmsg6") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::UDPSendMsg6,
+                },
+                Some("recvmsg4") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::UDPRecvMsg4,
+                },
+                Some("recvmsg6") => CgroupSockAddr {
+                    attach_type: CgroupSockAddrAttachType::UDPRecvMsg6,
+                },
+                _ => {
                     return Err(ParseError::InvalidProgramSection {
                         section: section.to_owned(),
                     });
                 }
-                }
             },
             "cgroup/post_bind4" => CgroupSock {
                 attach_type: CgroupSockAttachType::PostBind4,

aya-obj/src/programs/cgroup_sock.rs

@@ -1,6 +1,4 @@
 //! Cgroup socket programs.
-use alloc::{borrow::ToOwned, string::String};
-
 use crate::generated::bpf_attach_type;
 
 #[cfg(not(feature = "std"))]
@@ -30,19 +28,3 @@ impl From<CgroupSockAttachType> for bpf_attach_type {
         }
     }
 }
-
-#[derive(Debug, thiserror::Error)]
-#[error("{0} is not a valid attach type for a CGROUP_SOCK program")]
-pub(crate) struct InvalidAttachType(String);
-
-impl CgroupSockAttachType {
-    pub(crate) fn try_from(value: &str) -> Result<CgroupSockAttachType, InvalidAttachType> {
-        match value {
-            "post_bind4" => Ok(CgroupSockAttachType::PostBind4),
-            "post_bind6" => Ok(CgroupSockAttachType::PostBind6),
-            "sock_create" => Ok(CgroupSockAttachType::SockCreate),
-            "sock_release" => Ok(CgroupSockAttachType::SockRelease),
-            _ => Err(InvalidAttachType(value.to_owned())),
-        }
-    }
-}

aya-obj/src/programs/cgroup_sock_addr.rs

@@ -1,6 +1,4 @@
 //! Cgroup socket address programs.
-use alloc::{borrow::ToOwned, string::String};
-
 use crate::generated::bpf_attach_type;
 
 #[cfg(not(feature = "std"))]
@@ -53,27 +51,3 @@ impl From<CgroupSockAddrAttachType> for bpf_attach_type {
         }
     }
 }
-
-#[derive(Debug, thiserror::Error)]
-#[error("{0} is not a valid attach type for a CGROUP_SOCK_ADDR program")]
-pub(crate) struct InvalidAttachType(String);
-
-impl CgroupSockAddrAttachType {
-    pub(crate) fn try_from(value: &str) -> Result<CgroupSockAddrAttachType, InvalidAttachType> {
-        match value {
-            "bind4" => Ok(CgroupSockAddrAttachType::Bind4),
-            "bind6" => Ok(CgroupSockAddrAttachType::Bind6),
-            "connect4" => Ok(CgroupSockAddrAttachType::Connect4),
-            "connect6" => Ok(CgroupSockAddrAttachType::Connect6),
-            "getpeername4" => Ok(CgroupSockAddrAttachType::GetPeerName4),
-            "getpeername6" => Ok(CgroupSockAddrAttachType::GetPeerName6),
-            "getsockname4" => Ok(CgroupSockAddrAttachType::GetSockName4),
-            "getsockname6" => Ok(CgroupSockAddrAttachType::GetSockName6),
-            "sendmsg4" => Ok(CgroupSockAddrAttachType::UDPSendMsg4),
-            "sendmsg6" => Ok(CgroupSockAddrAttachType::UDPSendMsg6),
-            "recvmsg4" => Ok(CgroupSockAddrAttachType::UDPRecvMsg4),
-            "recvmsg6" => Ok(CgroupSockAddrAttachType::UDPRecvMsg6),
-            _ => Err(InvalidAttachType(value.to_owned())),
-        }
-    }
-}

aya-obj/src/programs/cgroup_sockopt.rs

@@ -1,6 +1,4 @@
 //! Cgroup socket option programs.
-use alloc::{borrow::ToOwned, string::String};
-
 use crate::generated::bpf_attach_type;
 
 #[cfg(not(feature = "std"))]
@@ -23,17 +21,3 @@ impl From<CgroupSockoptAttachType> for bpf_attach_type {
         }
     }
 }
-
-#[derive(Debug, thiserror::Error)]
-#[error("{0} is not a valid attach type for a CGROUP_SOCKOPT program")]
-pub(crate) struct InvalidAttachType(String);
-
-impl CgroupSockoptAttachType {
-    pub(crate) fn try_from(value: &str) -> Result<CgroupSockoptAttachType, InvalidAttachType> {
-        match value {
-            "getsockopt" => Ok(CgroupSockoptAttachType::Get),
-            "setsockopt" => Ok(CgroupSockoptAttachType::Set),
-            _ => Err(InvalidAttachType(value.to_owned())),
-        }
-    }
-}