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#7902

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,28 +22,41 @@ 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 {
+        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(
-            attribute.attribute_type.to_string().as_str(),
+            &key,
             attribute.attribute_value.to_string().as_str(),
         )?;
 
         if let Some(numeric_value) = attribute.numeric_value {
             js.set_uint(
-                format!("{}_raw", attribute.attribute_type).as_str(),
+                format!("{}_raw", key).as_str(),
                 numeric_value as u64,
             )?;
         } else if let Some(hex_value) = &attribute.hex_value {
             js.set_string(
-                format!("{}_raw", attribute.attribute_type).as_str(),
+                format!("{}_raw", key).as_str(),
                 hex_value,
             )?;
         }
+
+        *idx += 1;
+
     }
 
     return Ok(());