diff --git a/code_generator/src/main.rs b/code_generator/src/main.rs
index 68f0ebc..63141fd 100644
--- a/code_generator/src/main.rs
+++ b/code_generator/src/main.rs
@@ -210,9 +210,6 @@ pub const {type_identifier}: AVPType = {type_value};
 pub fn delete_{method_identifier}(packet: &mut Packet) {{
     packet.delete({type_identifier});
 }}
-pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<&AVP> {{
-    packet.lookup_all({type_identifier})
-}}
 ",
         method_identifier = attr_name.to_snake_case(),
         type_identifier = type_identifier,
@@ -233,6 +230,13 @@ fn generate_string_attribute_code(
 pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<String, AVPError>> {{
     packet.lookup({type_identifier}).map(|v| v.decode_string())
 }}
+pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<String>, AVPError> {{
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all({type_identifier}) {{
+        vec.push(avp.decode_string()?)
+    }}
+    Ok(vec)
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -253,6 +257,13 @@ fn generate_user_password_attribute_code(
 pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {{
     packet.lookup({type_identifier}).map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator()))
 }}
+pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {{
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all({type_identifier}) {{
+        vec.push(avp.decode_user_password(packet.get_secret(), packet.get_authenticator())?)
+    }}
+    Ok(vec)
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -272,6 +283,13 @@ fn generate_octets_attribute_code(
 pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Vec<u8>> {{
     packet.lookup({type_identifier}).map(|v| v.decode_bytes())
 }}
+pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<Vec<u8>> {{
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all({type_identifier}) {{
+        vec.push(avp.decode_bytes())
+    }}
+    vec
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -291,6 +309,13 @@ fn generate_ipaddr_attribute_code(
 pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {{
     packet.lookup({type_identifier}).map(|v| v.decode_ipv4())
 }}
+pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {{
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all({type_identifier}) {{
+        vec.push(avp.decode_ipv4()?)
+    }}
+    Ok(vec)
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -310,6 +335,13 @@ fn generate_integer_attribute_code(
 pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<u32, AVPError>> {{
     packet.lookup({type_identifier}).map(|v| v.decode_u32())
 }}
+pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<u32>, AVPError> {{
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all({type_identifier}) {{
+        vec.push(avp.decode_u32()?)
+    }}
+    Ok(vec)
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -330,6 +362,13 @@ fn generate_value_defined_integer_attribute_code(
 pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<{value_type}, AVPError>> {{
     packet.lookup({type_identifier}).map(|v| Ok(v.decode_u32()? as {value_type}))
 }}
+pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<{value_type}>, AVPError> {{
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all({type_identifier}) {{
+        vec.push(avp.decode_u32()? as {value_type})
+    }}
+    Ok(vec)
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
diff --git a/src/rfc2865.rs b/src/rfc2865.rs
index af755e9..367c3bf 100644
--- a/src/rfc2865.rs
+++ b/src/rfc2865.rs
@@ -83,23 +83,24 @@ pub const USER_NAME_TYPE: AVPType = 1;
 pub fn delete_user_name(packet: &mut Packet) {
     packet.delete(USER_NAME_TYPE);
 }
-pub fn lookup_all_user_name(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(USER_NAME_TYPE)
-}
 pub fn add_user_name(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(USER_NAME_TYPE, value));
 }
 pub fn lookup_user_name(packet: &Packet) -> Option<Result<String, AVPError>> {
     packet.lookup(USER_NAME_TYPE).map(|v| v.decode_string())
 }
+pub fn lookup_all_user_name(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(USER_NAME_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const USER_PASSWORD_TYPE: AVPType = 2;
 pub fn delete_user_password(packet: &mut Packet) {
     packet.delete(USER_PASSWORD_TYPE);
 }
-pub fn lookup_all_user_password(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(USER_PASSWORD_TYPE)
-}
 pub fn add_user_password(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     packet.add(AVP::encode_user_password(
         USER_PASSWORD_TYPE,
@@ -114,56 +115,72 @@ pub fn lookup_user_password(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>
         .lookup(USER_PASSWORD_TYPE)
         .map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator()))
 }
+pub fn lookup_all_user_password(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(USER_PASSWORD_TYPE) {
+        vec.push(avp.decode_user_password(packet.get_secret(), packet.get_authenticator())?)
+    }
+    Ok(vec)
+}
 
 pub const CHAP_PASSWORD_TYPE: AVPType = 3;
 pub fn delete_chap_password(packet: &mut Packet) {
     packet.delete(CHAP_PASSWORD_TYPE);
 }
-pub fn lookup_all_chap_password(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(CHAP_PASSWORD_TYPE)
-}
 pub fn add_chap_password(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(CHAP_PASSWORD_TYPE, value));
 }
 pub fn lookup_chap_password(packet: &Packet) -> Option<Vec<u8>> {
     packet.lookup(CHAP_PASSWORD_TYPE).map(|v| v.decode_bytes())
 }
+pub fn lookup_all_chap_password(packet: &Packet) -> Vec<Vec<u8>> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(CHAP_PASSWORD_TYPE) {
+        vec.push(avp.decode_bytes())
+    }
+    vec
+}
 
 pub const NAS_IP_ADDRESS_TYPE: AVPType = 4;
 pub fn delete_nas_ip_address(packet: &mut Packet) {
     packet.delete(NAS_IP_ADDRESS_TYPE);
 }
-pub fn lookup_all_nas_ip_address(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(NAS_IP_ADDRESS_TYPE)
-}
 pub fn add_nas_ip_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(NAS_IP_ADDRESS_TYPE, value));
 }
 pub fn lookup_nas_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
     packet.lookup(NAS_IP_ADDRESS_TYPE).map(|v| v.decode_ipv4())
 }
+pub fn lookup_all_nas_ip_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(NAS_IP_ADDRESS_TYPE) {
+        vec.push(avp.decode_ipv4()?)
+    }
+    Ok(vec)
+}
 
 pub const NAS_PORT_TYPE: AVPType = 5;
 pub fn delete_nas_port(packet: &mut Packet) {
     packet.delete(NAS_PORT_TYPE);
 }
-pub fn lookup_all_nas_port(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(NAS_PORT_TYPE)
-}
 pub fn add_nas_port(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(NAS_PORT_TYPE, value));
 }
 pub fn lookup_nas_port(packet: &Packet) -> Option<Result<u32, AVPError>> {
     packet.lookup(NAS_PORT_TYPE).map(|v| v.decode_u32())
 }
+pub fn lookup_all_nas_port(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(NAS_PORT_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const SERVICE_TYPE_TYPE: AVPType = 6;
 pub fn delete_service_type(packet: &mut Packet) {
     packet.delete(SERVICE_TYPE_TYPE);
 }
-pub fn lookup_all_service_type(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(SERVICE_TYPE_TYPE)
-}
 pub fn add_service_type(packet: &mut Packet, value: ServiceType) {
     packet.add(AVP::encode_u32(SERVICE_TYPE_TYPE, value as u32));
 }
@@ -172,14 +189,18 @@ pub fn lookup_service_type(packet: &Packet) -> Option<Result<ServiceType, AVPErr
         .lookup(SERVICE_TYPE_TYPE)
         .map(|v| Ok(v.decode_u32()? as ServiceType))
 }
+pub fn lookup_all_service_type(packet: &Packet) -> Result<Vec<ServiceType>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(SERVICE_TYPE_TYPE) {
+        vec.push(avp.decode_u32()? as ServiceType)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_PROTOCOL_TYPE: AVPType = 7;
 pub fn delete_framed_protocol(packet: &mut Packet) {
     packet.delete(FRAMED_PROTOCOL_TYPE);
 }
-pub fn lookup_all_framed_protocol(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_PROTOCOL_TYPE)
-}
 pub fn add_framed_protocol(packet: &mut Packet, value: FramedProtocol) {
     packet.add(AVP::encode_u32(FRAMED_PROTOCOL_TYPE, value as u32));
 }
@@ -188,14 +209,18 @@ pub fn lookup_framed_protocol(packet: &Packet) -> Option<Result<FramedProtocol,
         .lookup(FRAMED_PROTOCOL_TYPE)
         .map(|v| Ok(v.decode_u32()? as FramedProtocol))
 }
+pub fn lookup_all_framed_protocol(packet: &Packet) -> Result<Vec<FramedProtocol>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_PROTOCOL_TYPE) {
+        vec.push(avp.decode_u32()? as FramedProtocol)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_IP_ADDRESS_TYPE: AVPType = 8;
 pub fn delete_framed_ip_address(packet: &mut Packet) {
     packet.delete(FRAMED_IP_ADDRESS_TYPE);
 }
-pub fn lookup_all_framed_ip_address(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_IP_ADDRESS_TYPE)
-}
 pub fn add_framed_ip_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(FRAMED_IP_ADDRESS_TYPE, value));
 }
@@ -204,14 +229,18 @@ pub fn lookup_framed_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPE
         .lookup(FRAMED_IP_ADDRESS_TYPE)
         .map(|v| v.decode_ipv4())
 }
+pub fn lookup_all_framed_ip_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_IP_ADDRESS_TYPE) {
+        vec.push(avp.decode_ipv4()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_IP_NETMASK_TYPE: AVPType = 9;
 pub fn delete_framed_ip_netmask(packet: &mut Packet) {
     packet.delete(FRAMED_IP_NETMASK_TYPE);
 }
-pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_IP_NETMASK_TYPE)
-}
 pub fn add_framed_ip_netmask(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(FRAMED_IP_NETMASK_TYPE, value));
 }
@@ -220,14 +249,18 @@ pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<Result<Ipv4Addr, AVPE
         .lookup(FRAMED_IP_NETMASK_TYPE)
         .map(|v| v.decode_ipv4())
 }
+pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_IP_NETMASK_TYPE) {
+        vec.push(avp.decode_ipv4()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_ROUTING_TYPE: AVPType = 10;
 pub fn delete_framed_routing(packet: &mut Packet) {
     packet.delete(FRAMED_ROUTING_TYPE);
 }
-pub fn lookup_all_framed_routing(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_ROUTING_TYPE)
-}
 pub fn add_framed_routing(packet: &mut Packet, value: FramedRouting) {
     packet.add(AVP::encode_u32(FRAMED_ROUTING_TYPE, value as u32));
 }
@@ -236,42 +269,54 @@ pub fn lookup_framed_routing(packet: &Packet) -> Option<Result<FramedRouting, AV
         .lookup(FRAMED_ROUTING_TYPE)
         .map(|v| Ok(v.decode_u32()? as FramedRouting))
 }
+pub fn lookup_all_framed_routing(packet: &Packet) -> Result<Vec<FramedRouting>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_ROUTING_TYPE) {
+        vec.push(avp.decode_u32()? as FramedRouting)
+    }
+    Ok(vec)
+}
 
 pub const FILTER_ID_TYPE: AVPType = 11;
 pub fn delete_filter_id(packet: &mut Packet) {
     packet.delete(FILTER_ID_TYPE);
 }
-pub fn lookup_all_filter_id(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FILTER_ID_TYPE)
-}
 pub fn add_filter_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(FILTER_ID_TYPE, value));
 }
 pub fn lookup_filter_id(packet: &Packet) -> Option<Result<String, AVPError>> {
     packet.lookup(FILTER_ID_TYPE).map(|v| v.decode_string())
 }
+pub fn lookup_all_filter_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FILTER_ID_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_MTU_TYPE: AVPType = 12;
 pub fn delete_framed_mtu(packet: &mut Packet) {
     packet.delete(FRAMED_MTU_TYPE);
 }
-pub fn lookup_all_framed_mtu(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_MTU_TYPE)
-}
 pub fn add_framed_mtu(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(FRAMED_MTU_TYPE, value));
 }
 pub fn lookup_framed_mtu(packet: &Packet) -> Option<Result<u32, AVPError>> {
     packet.lookup(FRAMED_MTU_TYPE).map(|v| v.decode_u32())
 }
+pub fn lookup_all_framed_mtu(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_MTU_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_COMPRESSION_TYPE: AVPType = 13;
 pub fn delete_framed_compression(packet: &mut Packet) {
     packet.delete(FRAMED_COMPRESSION_TYPE);
 }
-pub fn lookup_all_framed_compression(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_COMPRESSION_TYPE)
-}
 pub fn add_framed_compression(packet: &mut Packet, value: FramedCompression) {
     packet.add(AVP::encode_u32(FRAMED_COMPRESSION_TYPE, value as u32));
 }
@@ -280,28 +325,36 @@ pub fn lookup_framed_compression(packet: &Packet) -> Option<Result<FramedCompres
         .lookup(FRAMED_COMPRESSION_TYPE)
         .map(|v| Ok(v.decode_u32()? as FramedCompression))
 }
+pub fn lookup_all_framed_compression(packet: &Packet) -> Result<Vec<FramedCompression>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_COMPRESSION_TYPE) {
+        vec.push(avp.decode_u32()? as FramedCompression)
+    }
+    Ok(vec)
+}
 
 pub const LOGIN_IP_HOST_TYPE: AVPType = 14;
 pub fn delete_login_ip_host(packet: &mut Packet) {
     packet.delete(LOGIN_IP_HOST_TYPE);
 }
-pub fn lookup_all_login_ip_host(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(LOGIN_IP_HOST_TYPE)
-}
 pub fn add_login_ip_host(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(LOGIN_IP_HOST_TYPE, value));
 }
 pub fn lookup_login_ip_host(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
     packet.lookup(LOGIN_IP_HOST_TYPE).map(|v| v.decode_ipv4())
 }
+pub fn lookup_all_login_ip_host(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(LOGIN_IP_HOST_TYPE) {
+        vec.push(avp.decode_ipv4()?)
+    }
+    Ok(vec)
+}
 
 pub const LOGIN_SERVICE_TYPE: AVPType = 15;
 pub fn delete_login_service(packet: &mut Packet) {
     packet.delete(LOGIN_SERVICE_TYPE);
 }
-pub fn lookup_all_login_service(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(LOGIN_SERVICE_TYPE)
-}
 pub fn add_login_service(packet: &mut Packet, value: LoginService) {
     packet.add(AVP::encode_u32(LOGIN_SERVICE_TYPE, value as u32));
 }
@@ -310,14 +363,18 @@ pub fn lookup_login_service(packet: &Packet) -> Option<Result<LoginService, AVPE
         .lookup(LOGIN_SERVICE_TYPE)
         .map(|v| Ok(v.decode_u32()? as LoginService))
 }
+pub fn lookup_all_login_service(packet: &Packet) -> Result<Vec<LoginService>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(LOGIN_SERVICE_TYPE) {
+        vec.push(avp.decode_u32()? as LoginService)
+    }
+    Ok(vec)
+}
 
 pub const LOGIN_TCP_PORT_TYPE: AVPType = 16;
 pub fn delete_login_tcp_port(packet: &mut Packet) {
     packet.delete(LOGIN_TCP_PORT_TYPE);
 }
-pub fn lookup_all_login_tcp_port(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(LOGIN_TCP_PORT_TYPE)
-}
 pub fn add_login_tcp_port(packet: &mut Packet, value: LoginTCPPort) {
     packet.add(AVP::encode_u32(LOGIN_TCP_PORT_TYPE, value as u32));
 }
@@ -326,28 +383,36 @@ pub fn lookup_login_tcp_port(packet: &Packet) -> Option<Result<LoginTCPPort, AVP
         .lookup(LOGIN_TCP_PORT_TYPE)
         .map(|v| Ok(v.decode_u32()? as LoginTCPPort))
 }
+pub fn lookup_all_login_tcp_port(packet: &Packet) -> Result<Vec<LoginTCPPort>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(LOGIN_TCP_PORT_TYPE) {
+        vec.push(avp.decode_u32()? as LoginTCPPort)
+    }
+    Ok(vec)
+}
 
 pub const REPLY_MESSAGE_TYPE: AVPType = 18;
 pub fn delete_reply_message(packet: &mut Packet) {
     packet.delete(REPLY_MESSAGE_TYPE);
 }
-pub fn lookup_all_reply_message(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(REPLY_MESSAGE_TYPE)
-}
 pub fn add_reply_message(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(REPLY_MESSAGE_TYPE, value));
 }
 pub fn lookup_reply_message(packet: &Packet) -> Option<Result<String, AVPError>> {
     packet.lookup(REPLY_MESSAGE_TYPE).map(|v| v.decode_string())
 }
+pub fn lookup_all_reply_message(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(REPLY_MESSAGE_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const CALLBACK_NUMBER_TYPE: AVPType = 19;
 pub fn delete_callback_number(packet: &mut Packet) {
     packet.delete(CALLBACK_NUMBER_TYPE);
 }
-pub fn lookup_all_callback_number(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(CALLBACK_NUMBER_TYPE)
-}
 pub fn add_callback_number(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLBACK_NUMBER_TYPE, value));
 }
@@ -356,42 +421,54 @@ pub fn lookup_callback_number(packet: &Packet) -> Option<Result<String, AVPError
         .lookup(CALLBACK_NUMBER_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_callback_number(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(CALLBACK_NUMBER_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const CALLBACK_ID_TYPE: AVPType = 20;
 pub fn delete_callback_id(packet: &mut Packet) {
     packet.delete(CALLBACK_ID_TYPE);
 }
-pub fn lookup_all_callback_id(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(CALLBACK_ID_TYPE)
-}
 pub fn add_callback_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLBACK_ID_TYPE, value));
 }
 pub fn lookup_callback_id(packet: &Packet) -> Option<Result<String, AVPError>> {
     packet.lookup(CALLBACK_ID_TYPE).map(|v| v.decode_string())
 }
+pub fn lookup_all_callback_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(CALLBACK_ID_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_ROUTE_TYPE: AVPType = 22;
 pub fn delete_framed_route(packet: &mut Packet) {
     packet.delete(FRAMED_ROUTE_TYPE);
 }
-pub fn lookup_all_framed_route(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_ROUTE_TYPE)
-}
 pub fn add_framed_route(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(FRAMED_ROUTE_TYPE, value));
 }
 pub fn lookup_framed_route(packet: &Packet) -> Option<Result<String, AVPError>> {
     packet.lookup(FRAMED_ROUTE_TYPE).map(|v| v.decode_string())
 }
+pub fn lookup_all_framed_route(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_ROUTE_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_IPX_NETWORK_TYPE: AVPType = 23;
 pub fn delete_framed_ipx_network(packet: &mut Packet) {
     packet.delete(FRAMED_IPX_NETWORK_TYPE);
 }
-pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_IPX_NETWORK_TYPE)
-}
 pub fn add_framed_ipx_network(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(FRAMED_IPX_NETWORK_TYPE, value));
 }
@@ -400,78 +477,95 @@ pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<Result<Ipv4Addr, AVP
         .lookup(FRAMED_IPX_NETWORK_TYPE)
         .map(|v| v.decode_ipv4())
 }
+pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_IPX_NETWORK_TYPE) {
+        vec.push(avp.decode_ipv4()?)
+    }
+    Ok(vec)
+}
 
 pub const STATE_TYPE: AVPType = 24;
 pub fn delete_state(packet: &mut Packet) {
     packet.delete(STATE_TYPE);
 }
-pub fn lookup_all_state(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(STATE_TYPE)
-}
 pub fn add_state(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(STATE_TYPE, value));
 }
 pub fn lookup_state(packet: &Packet) -> Option<Vec<u8>> {
     packet.lookup(STATE_TYPE).map(|v| v.decode_bytes())
 }
+pub fn lookup_all_state(packet: &Packet) -> Vec<Vec<u8>> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(STATE_TYPE) {
+        vec.push(avp.decode_bytes())
+    }
+    vec
+}
 
 pub const CLASS_TYPE: AVPType = 25;
 pub fn delete_class(packet: &mut Packet) {
     packet.delete(CLASS_TYPE);
 }
-pub fn lookup_all_class(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(CLASS_TYPE)
-}
 pub fn add_class(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(CLASS_TYPE, value));
 }
 pub fn lookup_class(packet: &Packet) -> Option<Vec<u8>> {
     packet.lookup(CLASS_TYPE).map(|v| v.decode_bytes())
 }
+pub fn lookup_all_class(packet: &Packet) -> Vec<Vec<u8>> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(CLASS_TYPE) {
+        vec.push(avp.decode_bytes())
+    }
+    vec
+}
 
 pub const VENDOR_SPECIFIC_TYPE: AVPType = 26;
 pub fn delete_vendor_specific(packet: &mut Packet) {
     packet.delete(VENDOR_SPECIFIC_TYPE);
 }
-pub fn lookup_all_vendor_specific(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(VENDOR_SPECIFIC_TYPE)
-}
 
 pub const SESSION_TIMEOUT_TYPE: AVPType = 27;
 pub fn delete_session_timeout(packet: &mut Packet) {
     packet.delete(SESSION_TIMEOUT_TYPE);
 }
-pub fn lookup_all_session_timeout(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(SESSION_TIMEOUT_TYPE)
-}
 pub fn add_session_timeout(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(SESSION_TIMEOUT_TYPE, value));
 }
 pub fn lookup_session_timeout(packet: &Packet) -> Option<Result<u32, AVPError>> {
     packet.lookup(SESSION_TIMEOUT_TYPE).map(|v| v.decode_u32())
 }
+pub fn lookup_all_session_timeout(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(SESSION_TIMEOUT_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const IDLE_TIMEOUT_TYPE: AVPType = 28;
 pub fn delete_idle_timeout(packet: &mut Packet) {
     packet.delete(IDLE_TIMEOUT_TYPE);
 }
-pub fn lookup_all_idle_timeout(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(IDLE_TIMEOUT_TYPE)
-}
 pub fn add_idle_timeout(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(IDLE_TIMEOUT_TYPE, value));
 }
 pub fn lookup_idle_timeout(packet: &Packet) -> Option<Result<u32, AVPError>> {
     packet.lookup(IDLE_TIMEOUT_TYPE).map(|v| v.decode_u32())
 }
+pub fn lookup_all_idle_timeout(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(IDLE_TIMEOUT_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const TERMINATION_ACTION_TYPE: AVPType = 29;
 pub fn delete_termination_action(packet: &mut Packet) {
     packet.delete(TERMINATION_ACTION_TYPE);
 }
-pub fn lookup_all_termination_action(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(TERMINATION_ACTION_TYPE)
-}
 pub fn add_termination_action(packet: &mut Packet, value: TerminationAction) {
     packet.add(AVP::encode_u32(TERMINATION_ACTION_TYPE, value as u32));
 }
@@ -480,14 +574,18 @@ pub fn lookup_termination_action(packet: &Packet) -> Option<Result<TerminationAc
         .lookup(TERMINATION_ACTION_TYPE)
         .map(|v| Ok(v.decode_u32()? as TerminationAction))
 }
+pub fn lookup_all_termination_action(packet: &Packet) -> Result<Vec<TerminationAction>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(TERMINATION_ACTION_TYPE) {
+        vec.push(avp.decode_u32()? as TerminationAction)
+    }
+    Ok(vec)
+}
 
 pub const CALLED_STATION_ID_TYPE: AVPType = 30;
 pub fn delete_called_station_id(packet: &mut Packet) {
     packet.delete(CALLED_STATION_ID_TYPE);
 }
-pub fn lookup_all_called_station_id(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(CALLED_STATION_ID_TYPE)
-}
 pub fn add_called_station_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLED_STATION_ID_TYPE, value));
 }
@@ -496,14 +594,18 @@ pub fn lookup_called_station_id(packet: &Packet) -> Option<Result<String, AVPErr
         .lookup(CALLED_STATION_ID_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_called_station_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(CALLED_STATION_ID_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const CALLING_STATION_ID_TYPE: AVPType = 31;
 pub fn delete_calling_station_id(packet: &mut Packet) {
     packet.delete(CALLING_STATION_ID_TYPE);
 }
-pub fn lookup_all_calling_station_id(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(CALLING_STATION_ID_TYPE)
-}
 pub fn add_calling_station_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLING_STATION_ID_TYPE, value));
 }
@@ -512,14 +614,18 @@ pub fn lookup_calling_station_id(packet: &Packet) -> Option<Result<String, AVPEr
         .lookup(CALLING_STATION_ID_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_calling_station_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(CALLING_STATION_ID_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const NAS_IDENTIFIER_TYPE: AVPType = 32;
 pub fn delete_nas_identifier(packet: &mut Packet) {
     packet.delete(NAS_IDENTIFIER_TYPE);
 }
-pub fn lookup_all_nas_identifier(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(NAS_IDENTIFIER_TYPE)
-}
 pub fn add_nas_identifier(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(NAS_IDENTIFIER_TYPE, value));
 }
@@ -528,28 +634,36 @@ pub fn lookup_nas_identifier(packet: &Packet) -> Option<Result<String, AVPError>
         .lookup(NAS_IDENTIFIER_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_nas_identifier(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(NAS_IDENTIFIER_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const PROXY_STATE_TYPE: AVPType = 33;
 pub fn delete_proxy_state(packet: &mut Packet) {
     packet.delete(PROXY_STATE_TYPE);
 }
-pub fn lookup_all_proxy_state(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(PROXY_STATE_TYPE)
-}
 pub fn add_proxy_state(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(PROXY_STATE_TYPE, value));
 }
 pub fn lookup_proxy_state(packet: &Packet) -> Option<Vec<u8>> {
     packet.lookup(PROXY_STATE_TYPE).map(|v| v.decode_bytes())
 }
+pub fn lookup_all_proxy_state(packet: &Packet) -> Vec<Vec<u8>> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(PROXY_STATE_TYPE) {
+        vec.push(avp.decode_bytes())
+    }
+    vec
+}
 
 pub const LOGIN_LAT_SERVICE_TYPE: AVPType = 34;
 pub fn delete_login_lat_service(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_SERVICE_TYPE);
 }
-pub fn lookup_all_login_lat_service(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(LOGIN_LAT_SERVICE_TYPE)
-}
 pub fn add_login_lat_service(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(LOGIN_LAT_SERVICE_TYPE, value));
 }
@@ -558,14 +672,18 @@ pub fn lookup_login_lat_service(packet: &Packet) -> Option<Result<String, AVPErr
         .lookup(LOGIN_LAT_SERVICE_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_login_lat_service(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(LOGIN_LAT_SERVICE_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const LOGIN_LAT_NODE_TYPE: AVPType = 35;
 pub fn delete_login_lat_node(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_NODE_TYPE);
 }
-pub fn lookup_all_login_lat_node(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(LOGIN_LAT_NODE_TYPE)
-}
 pub fn add_login_lat_node(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(LOGIN_LAT_NODE_TYPE, value));
 }
@@ -574,14 +692,18 @@ pub fn lookup_login_lat_node(packet: &Packet) -> Option<Result<String, AVPError>
         .lookup(LOGIN_LAT_NODE_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_login_lat_node(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(LOGIN_LAT_NODE_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const LOGIN_LAT_GROUP_TYPE: AVPType = 36;
 pub fn delete_login_lat_group(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_GROUP_TYPE);
 }
-pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(LOGIN_LAT_GROUP_TYPE)
-}
 pub fn add_login_lat_group(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(LOGIN_LAT_GROUP_TYPE, value));
 }
@@ -590,14 +712,18 @@ pub fn lookup_login_lat_group(packet: &Packet) -> Option<Vec<u8>> {
         .lookup(LOGIN_LAT_GROUP_TYPE)
         .map(|v| v.decode_bytes())
 }
+pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<Vec<u8>> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(LOGIN_LAT_GROUP_TYPE) {
+        vec.push(avp.decode_bytes())
+    }
+    vec
+}
 
 pub const FRAMED_APPLE_TALK_LINK_TYPE: AVPType = 37;
 pub fn delete_framed_apple_talk_link(packet: &mut Packet) {
     packet.delete(FRAMED_APPLE_TALK_LINK_TYPE);
 }
-pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_APPLE_TALK_LINK_TYPE)
-}
 pub fn add_framed_apple_talk_link(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(FRAMED_APPLE_TALK_LINK_TYPE, value));
 }
@@ -606,14 +732,18 @@ pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<Result<u32, AVPE
         .lookup(FRAMED_APPLE_TALK_LINK_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_APPLE_TALK_LINK_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_APPLE_TALK_NETWORK_TYPE: AVPType = 38;
 pub fn delete_framed_apple_talk_network(packet: &mut Packet) {
     packet.delete(FRAMED_APPLE_TALK_NETWORK_TYPE);
 }
-pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_APPLE_TALK_NETWORK_TYPE)
-}
 pub fn add_framed_apple_talk_network(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(FRAMED_APPLE_TALK_NETWORK_TYPE, value));
 }
@@ -622,14 +752,18 @@ pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<Result<u32, A
         .lookup(FRAMED_APPLE_TALK_NETWORK_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_APPLE_TALK_NETWORK_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const FRAMED_APPLE_TALK_ZONE_TYPE: AVPType = 39;
 pub fn delete_framed_apple_talk_zone(packet: &mut Packet) {
     packet.delete(FRAMED_APPLE_TALK_ZONE_TYPE);
 }
-pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(FRAMED_APPLE_TALK_ZONE_TYPE)
-}
 pub fn add_framed_apple_talk_zone(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(FRAMED_APPLE_TALK_ZONE_TYPE, value));
 }
@@ -638,28 +772,36 @@ pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<Result<String, A
         .lookup(FRAMED_APPLE_TALK_ZONE_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(FRAMED_APPLE_TALK_ZONE_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const CHAP_CHALLENGE_TYPE: AVPType = 60;
 pub fn delete_chap_challenge(packet: &mut Packet) {
     packet.delete(CHAP_CHALLENGE_TYPE);
 }
-pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(CHAP_CHALLENGE_TYPE)
-}
 pub fn add_chap_challenge(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(CHAP_CHALLENGE_TYPE, value));
 }
 pub fn lookup_chap_challenge(packet: &Packet) -> Option<Vec<u8>> {
     packet.lookup(CHAP_CHALLENGE_TYPE).map(|v| v.decode_bytes())
 }
+pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec<Vec<u8>> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(CHAP_CHALLENGE_TYPE) {
+        vec.push(avp.decode_bytes())
+    }
+    vec
+}
 
 pub const NAS_PORT_TYPE_TYPE: AVPType = 61;
 pub fn delete_nas_port_type(packet: &mut Packet) {
     packet.delete(NAS_PORT_TYPE_TYPE);
 }
-pub fn lookup_all_nas_port_type(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(NAS_PORT_TYPE_TYPE)
-}
 pub fn add_nas_port_type(packet: &mut Packet, value: NasPortType) {
     packet.add(AVP::encode_u32(NAS_PORT_TYPE_TYPE, value as u32));
 }
@@ -668,28 +810,36 @@ pub fn lookup_nas_port_type(packet: &Packet) -> Option<Result<NasPortType, AVPEr
         .lookup(NAS_PORT_TYPE_TYPE)
         .map(|v| Ok(v.decode_u32()? as NasPortType))
 }
+pub fn lookup_all_nas_port_type(packet: &Packet) -> Result<Vec<NasPortType>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(NAS_PORT_TYPE_TYPE) {
+        vec.push(avp.decode_u32()? as NasPortType)
+    }
+    Ok(vec)
+}
 
 pub const PORT_LIMIT_TYPE: AVPType = 62;
 pub fn delete_port_limit(packet: &mut Packet) {
     packet.delete(PORT_LIMIT_TYPE);
 }
-pub fn lookup_all_port_limit(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(PORT_LIMIT_TYPE)
-}
 pub fn add_port_limit(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(PORT_LIMIT_TYPE, value));
 }
 pub fn lookup_port_limit(packet: &Packet) -> Option<Result<u32, AVPError>> {
     packet.lookup(PORT_LIMIT_TYPE).map(|v| v.decode_u32())
 }
+pub fn lookup_all_port_limit(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(PORT_LIMIT_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const LOGIN_LAT_PORT_TYPE: AVPType = 63;
 pub fn delete_login_lat_port(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_PORT_TYPE);
 }
-pub fn lookup_all_login_lat_port(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(LOGIN_LAT_PORT_TYPE)
-}
 pub fn add_login_lat_port(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(LOGIN_LAT_PORT_TYPE, value));
 }
@@ -698,3 +848,10 @@ pub fn lookup_login_lat_port(packet: &Packet) -> Option<Result<String, AVPError>
         .lookup(LOGIN_LAT_PORT_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_login_lat_port(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(LOGIN_LAT_PORT_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
diff --git a/src/rfc2866.rs b/src/rfc2866.rs
index 4394a35..d9557dd 100644
--- a/src/rfc2866.rs
+++ b/src/rfc2866.rs
@@ -42,9 +42,6 @@ pub const ACCT_STATUS_TYPE_TYPE: AVPType = 40;
 pub fn delete_acct_status_type(packet: &mut Packet) {
     packet.delete(ACCT_STATUS_TYPE_TYPE);
 }
-pub fn lookup_all_acct_status_type(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_STATUS_TYPE_TYPE)
-}
 pub fn add_acct_status_type(packet: &mut Packet, value: AcctStatusType) {
     packet.add(AVP::encode_u32(ACCT_STATUS_TYPE_TYPE, value as u32));
 }
@@ -53,28 +50,36 @@ pub fn lookup_acct_status_type(packet: &Packet) -> Option<Result<AcctStatusType,
         .lookup(ACCT_STATUS_TYPE_TYPE)
         .map(|v| Ok(v.decode_u32()? as AcctStatusType))
 }
+pub fn lookup_all_acct_status_type(packet: &Packet) -> Result<Vec<AcctStatusType>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_STATUS_TYPE_TYPE) {
+        vec.push(avp.decode_u32()? as AcctStatusType)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_DELAY_TIME_TYPE: AVPType = 41;
 pub fn delete_acct_delay_time(packet: &mut Packet) {
     packet.delete(ACCT_DELAY_TIME_TYPE);
 }
-pub fn lookup_all_acct_delay_time(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_DELAY_TIME_TYPE)
-}
 pub fn add_acct_delay_time(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_DELAY_TIME_TYPE, value));
 }
 pub fn lookup_acct_delay_time(packet: &Packet) -> Option<Result<u32, AVPError>> {
     packet.lookup(ACCT_DELAY_TIME_TYPE).map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_delay_time(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_DELAY_TIME_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_INPUT_OCTETS_TYPE: AVPType = 42;
 pub fn delete_acct_input_octets(packet: &mut Packet) {
     packet.delete(ACCT_INPUT_OCTETS_TYPE);
 }
-pub fn lookup_all_acct_input_octets(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_INPUT_OCTETS_TYPE)
-}
 pub fn add_acct_input_octets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_INPUT_OCTETS_TYPE, value));
 }
@@ -83,14 +88,18 @@ pub fn lookup_acct_input_octets(packet: &Packet) -> Option<Result<u32, AVPError>
         .lookup(ACCT_INPUT_OCTETS_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_input_octets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_INPUT_OCTETS_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_OUTPUT_OCTETS_TYPE: AVPType = 43;
 pub fn delete_acct_output_octets(packet: &mut Packet) {
     packet.delete(ACCT_OUTPUT_OCTETS_TYPE);
 }
-pub fn lookup_all_acct_output_octets(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_OUTPUT_OCTETS_TYPE)
-}
 pub fn add_acct_output_octets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_OUTPUT_OCTETS_TYPE, value));
 }
@@ -99,14 +108,18 @@ pub fn lookup_acct_output_octets(packet: &Packet) -> Option<Result<u32, AVPError
         .lookup(ACCT_OUTPUT_OCTETS_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_output_octets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_OUTPUT_OCTETS_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_SESSION_ID_TYPE: AVPType = 44;
 pub fn delete_acct_session_id(packet: &mut Packet) {
     packet.delete(ACCT_SESSION_ID_TYPE);
 }
-pub fn lookup_all_acct_session_id(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_SESSION_ID_TYPE)
-}
 pub fn add_acct_session_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(ACCT_SESSION_ID_TYPE, value));
 }
@@ -115,14 +128,18 @@ pub fn lookup_acct_session_id(packet: &Packet) -> Option<Result<String, AVPError
         .lookup(ACCT_SESSION_ID_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_acct_session_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_SESSION_ID_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_AUTHENTIC_TYPE: AVPType = 45;
 pub fn delete_acct_authentic(packet: &mut Packet) {
     packet.delete(ACCT_AUTHENTIC_TYPE);
 }
-pub fn lookup_all_acct_authentic(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_AUTHENTIC_TYPE)
-}
 pub fn add_acct_authentic(packet: &mut Packet, value: AcctAuthentic) {
     packet.add(AVP::encode_u32(ACCT_AUTHENTIC_TYPE, value as u32));
 }
@@ -131,14 +148,18 @@ pub fn lookup_acct_authentic(packet: &Packet) -> Option<Result<AcctAuthentic, AV
         .lookup(ACCT_AUTHENTIC_TYPE)
         .map(|v| Ok(v.decode_u32()? as AcctAuthentic))
 }
+pub fn lookup_all_acct_authentic(packet: &Packet) -> Result<Vec<AcctAuthentic>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_AUTHENTIC_TYPE) {
+        vec.push(avp.decode_u32()? as AcctAuthentic)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_SESSION_TIME_TYPE: AVPType = 46;
 pub fn delete_acct_session_time(packet: &mut Packet) {
     packet.delete(ACCT_SESSION_TIME_TYPE);
 }
-pub fn lookup_all_acct_session_time(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_SESSION_TIME_TYPE)
-}
 pub fn add_acct_session_time(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_SESSION_TIME_TYPE, value));
 }
@@ -147,14 +168,18 @@ pub fn lookup_acct_session_time(packet: &Packet) -> Option<Result<u32, AVPError>
         .lookup(ACCT_SESSION_TIME_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_session_time(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_SESSION_TIME_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_INPUT_PACKETS_TYPE: AVPType = 47;
 pub fn delete_acct_input_packets(packet: &mut Packet) {
     packet.delete(ACCT_INPUT_PACKETS_TYPE);
 }
-pub fn lookup_all_acct_input_packets(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_INPUT_PACKETS_TYPE)
-}
 pub fn add_acct_input_packets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_INPUT_PACKETS_TYPE, value));
 }
@@ -163,14 +188,18 @@ pub fn lookup_acct_input_packets(packet: &Packet) -> Option<Result<u32, AVPError
         .lookup(ACCT_INPUT_PACKETS_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_input_packets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_INPUT_PACKETS_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_OUTPUT_PACKETS_TYPE: AVPType = 48;
 pub fn delete_acct_output_packets(packet: &mut Packet) {
     packet.delete(ACCT_OUTPUT_PACKETS_TYPE);
 }
-pub fn lookup_all_acct_output_packets(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_OUTPUT_PACKETS_TYPE)
-}
 pub fn add_acct_output_packets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_OUTPUT_PACKETS_TYPE, value));
 }
@@ -179,14 +208,18 @@ pub fn lookup_acct_output_packets(packet: &Packet) -> Option<Result<u32, AVPErro
         .lookup(ACCT_OUTPUT_PACKETS_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_output_packets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_OUTPUT_PACKETS_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_TERMINATE_CAUSE_TYPE: AVPType = 49;
 pub fn delete_acct_terminate_cause(packet: &mut Packet) {
     packet.delete(ACCT_TERMINATE_CAUSE_TYPE);
 }
-pub fn lookup_all_acct_terminate_cause(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_TERMINATE_CAUSE_TYPE)
-}
 pub fn add_acct_terminate_cause(packet: &mut Packet, value: AcctTerminateCause) {
     packet.add(AVP::encode_u32(ACCT_TERMINATE_CAUSE_TYPE, value as u32));
 }
@@ -197,14 +230,20 @@ pub fn lookup_acct_terminate_cause(
         .lookup(ACCT_TERMINATE_CAUSE_TYPE)
         .map(|v| Ok(v.decode_u32()? as AcctTerminateCause))
 }
+pub fn lookup_all_acct_terminate_cause(
+    packet: &Packet,
+) -> Result<Vec<AcctTerminateCause>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_TERMINATE_CAUSE_TYPE) {
+        vec.push(avp.decode_u32()? as AcctTerminateCause)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_MULTI_SESSION_ID_TYPE: AVPType = 50;
 pub fn delete_acct_multi_session_id(packet: &mut Packet) {
     packet.delete(ACCT_MULTI_SESSION_ID_TYPE);
 }
-pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_MULTI_SESSION_ID_TYPE)
-}
 pub fn add_acct_multi_session_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(ACCT_MULTI_SESSION_ID_TYPE, value));
 }
@@ -213,17 +252,28 @@ pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<Result<String, AV
         .lookup(ACCT_MULTI_SESSION_ID_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_MULTI_SESSION_ID_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_LINK_COUNT_TYPE: AVPType = 51;
 pub fn delete_acct_link_count(packet: &mut Packet) {
     packet.delete(ACCT_LINK_COUNT_TYPE);
 }
-pub fn lookup_all_acct_link_count(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_LINK_COUNT_TYPE)
-}
 pub fn add_acct_link_count(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_LINK_COUNT_TYPE, value));
 }
 pub fn lookup_acct_link_count(packet: &Packet) -> Option<Result<u32, AVPError>> {
     packet.lookup(ACCT_LINK_COUNT_TYPE).map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_link_count(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_LINK_COUNT_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}
diff --git a/src/rfc2867.rs b/src/rfc2867.rs
index 9c9d218..402be09 100644
--- a/src/rfc2867.rs
+++ b/src/rfc2867.rs
@@ -15,9 +15,6 @@ pub const ACCT_TUNNEL_CONNECTION_TYPE: AVPType = 68;
 pub fn delete_acct_tunnel_connection(packet: &mut Packet) {
     packet.delete(ACCT_TUNNEL_CONNECTION_TYPE);
 }
-pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_TUNNEL_CONNECTION_TYPE)
-}
 pub fn add_acct_tunnel_connection(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(ACCT_TUNNEL_CONNECTION_TYPE, value));
 }
@@ -26,14 +23,18 @@ pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<Result<String, A
         .lookup(ACCT_TUNNEL_CONNECTION_TYPE)
         .map(|v| v.decode_string())
 }
+pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Result<Vec<String>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_TUNNEL_CONNECTION_TYPE) {
+        vec.push(avp.decode_string()?)
+    }
+    Ok(vec)
+}
 
 pub const ACCT_TUNNEL_PACKETS_LOST_TYPE: AVPType = 86;
 pub fn delete_acct_tunnel_packets_lost(packet: &mut Packet) {
     packet.delete(ACCT_TUNNEL_PACKETS_LOST_TYPE);
 }
-pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Vec<&AVP> {
-    packet.lookup_all(ACCT_TUNNEL_PACKETS_LOST_TYPE)
-}
 pub fn add_acct_tunnel_packets_lost(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_TUNNEL_PACKETS_LOST_TYPE, value));
 }
@@ -42,3 +43,10 @@ pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<Result<u32, AV
         .lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE)
         .map(|v| v.decode_u32())
 }
+pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Result<Vec<u32>, AVPError> {
+    let mut vec = Vec::new();
+    for avp in packet.lookup_all(ACCT_TUNNEL_PACKETS_LOST_TYPE) {
+        vec.push(avp.decode_u32()?)
+    }
+    Ok(vec)
+}