ike: suffix duplicate attributes with an index

The attributes in a proposal are an array so its possible to have
duplicate values, even if not within spec.

To address this in a backwards compatible way, suffix duplicates with
their index. The first seen attribute will not have a suffix, but the
first duplicate attribute type will have suffix 1, etc.

For example:

  "client": {
    "proposals": [
      {
        "sa_life_duration": "Unknown",
        "sa_life_duration_raw": 86400,
        "sa_life_duration_1": "Unknown",
        "sa_life_duration_1_raw": 65535
      }
    }
  }

Ticket: OISF#7923

Author: jasonish

etc/schema.json

@@ -2563,6 +2563,14 @@
                                             "sa_life_type_raw": {
                                                 "type": "integer"
                                             }
+                                        },
+                                        "patternProperties": {
+                                            "^sa_life_duration_[0-9]+$": {
+                                                "type": "string"
+                                            },
+                                            "^sa_life_duration_[0-9]+_raw$": {
+                                                "type": "integer"
+                                            }
                                         }
                                     }
                                 }

rust/src/ike/logger.rs

@@ -22,31 +22,34 @@ use crate::ike::parser::{ExchangeType, IsakmpPayloadType, SaAttribute};
 use crate::jsonbuilder::{JsonBuilder, JsonError};
 use num_traits::FromPrimitive;
 use std;
+use std::collections::HashMap;
 use std::convert::TryFrom;
 
 const LOG_EXTENDED: u32 = 0x01;
 
 fn add_attributes(transform: &Vec<SaAttribute>, js: &mut JsonBuilder) -> Result<(), JsonError> {
+    let mut logged: HashMap<String, usize> = HashMap::new();
+
     for attribute in transform {
-        js.set_string(
-            attribute.attribute_type.to_string().as_str(),
-            attribute.attribute_value.to_string().as_str(),
-        )?;
+        let mut key = attribute.attribute_type.to_string();
+        let idx = logged.entry(key.clone()).or_insert(0);
+
+        if *idx > 0 {
+            key = format!("{}_{}", key, idx);
+        }
+
+        js.set_string(&key, &attribute.attribute_value.to_string())?;
 
         if let Some(numeric_value) = attribute.numeric_value {
-            js.set_uint(
-                format!("{}_raw", attribute.attribute_type).as_str(),
-                numeric_value as u64,
-            )?;
+            js.set_uint(&format!("{}_raw", key), numeric_value as u64)?;
         } else if let Some(hex_value) = &attribute.hex_value {
-            js.set_string(
-                format!("{}_raw", attribute.attribute_type).as_str(),
-                hex_value,
-            )?;
+            js.set_string(&format!("{}_raw", key), hex_value)?;
         }
+
+        *idx += 1;
     }
 
-    return Ok(());
+    Ok(())
 }
 
 fn log_ike(