DNP3: Convert logging to JsonBuilder - v1

rust/src/jsonbuilder.rs

@@ -330,6 +330,23 @@ impl JsonBuilder {
         Ok(self)
     }
 
+    pub fn append_float(&mut self, val: f64) -> Result<&mut Self, JsonError> {
+        match self.current_state() {
+            State::ArrayFirst => {
+                self.set_state(State::ArrayNth);
+            }
+            State::ArrayNth => {
+                self.buf.push(',');
+            }
+            _ => {
+                debug_validate_fail!("invalid state");
+                return Err(JsonError::InvalidState);
+            }
+        }
+        self.buf.push_str(&val.to_string());
+        Ok(self)
+    }
+
     pub fn set_object(&mut self, key: &str, js: &JsonBuilder) -> Result<&mut Self, JsonError> {
         match self.current_state() {
             State::ObjectNth => {
@@ -467,6 +484,26 @@ impl JsonBuilder {
         Ok(self)
     }
 
+    pub fn set_float(&mut self, key: &str, val: f64) -> Result<&mut Self, JsonError> {
+        match self.current_state() {
+            State::ObjectNth => {
+                self.buf.push(',');
+            }
+            State::ObjectFirst => {
+                self.set_state(State::ObjectNth);
+            }
+            _ => {
+                debug_validate_fail!("invalid state");
+                return Err(JsonError::InvalidState);
+            }
+        }
+        self.buf.push('"');
+        self.buf.push_str(key);
+        self.buf.push_str("\":");
+        self.buf.push_str(&val.to_string());
+        Ok(self)
+    }
+
     pub fn set_bool(&mut self, key: &str, val: bool) -> Result<&mut Self, JsonError> {
         match self.current_state() {
             State::ObjectNth => {
@@ -714,6 +751,11 @@ pub unsafe extern "C" fn jb_append_uint(js: &mut JsonBuilder, val: u64) -> bool
     return js.append_uint(val).is_ok();
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn jb_append_float(js: &mut JsonBuilder, val: f64) -> bool {
+    return js.append_float(val).is_ok();
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn jb_set_uint(js: &mut JsonBuilder, key: *const c_char, val: u64) -> bool {
     if let Ok(key) = CStr::from_ptr(key).to_str() {
@@ -722,6 +764,14 @@ pub unsafe extern "C" fn jb_set_uint(js: &mut JsonBuilder, key: *const c_char, v
     return false;
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn jb_set_float(js: &mut JsonBuilder, key: *const c_char, val: f64) -> bool {
+    if let Ok(key) = CStr::from_ptr(key).to_str() {
+        return js.set_float(key, val).is_ok();
+    }
+    return false;
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn jb_set_bool(js: &mut JsonBuilder, key: *const c_char, val: bool) -> bool {
     if let Ok(key) = CStr::from_ptr(key).to_str() {
@@ -1030,6 +1080,24 @@ mod test {
         jb.close().unwrap();
         assert_eq!(jb.buf, r#"{"foo":"bar","bar":"foo"}"#);
     }
+
+    #[test]
+    fn test_set_float() {
+        let mut jb = JsonBuilder::new_object();
+        jb.set_float("one", 1.1).unwrap();
+        jb.set_float("two", 2.2).unwrap();
+        jb.close().unwrap();
+        assert_eq!(jb.buf, r#"{"one":1.1,"two":2.2}"#);
+    }
+
+    #[test]
+    fn test_append_float() {
+        let mut jb = JsonBuilder::new_array();
+        jb.append_float(1.1).unwrap();
+        jb.append_float(2.2).unwrap();
+        jb.close().unwrap();
+        assert_eq!(jb.buf, r#"[1.1,2.2]"#);
+    }
 }
 
 // Escape table as seen in serde-json (MIT/Apache license)

scripts/dnp3-gen/dnp3-gen.py

@@ -155,8 +155,9 @@
 #include "app-layer-dnp3.h"
 #include "app-layer-dnp3-objects.h"
 #include "output-json-dnp3-objects.h"
+#include "output-json.h"
 
-void OutputJsonDNP3SetItem(json_t *js, DNP3Object *object,
+void OutputJsonDNP3SetItem(JsonBuilder *js, DNP3Object *object,
     DNP3Point *point)
 {
 
@@ -166,35 +167,31 @@
             DNP3ObjectG{{object.group}}V{{object.variation}} *data = point->data;
 {% for field in object.fields %}
 {% if is_integer_type(field.type) %}
-            json_object_set_new(js, "{{field.name}}",
-                json_integer(data->{{field.name}}));
+            jb_set_uint(js, "{{field.name}}", data->{{field.name}});
 {% elif field.type in ["flt32", "flt64"] %}
-            json_object_set_new(js, "{{field.name}}",
-                json_real(data->{{field.name}}));
+            jb_set_float(js, "{{field.name}}", data->{{field.name}});
 {% elif field.type == "bytearray" %}
             unsigned long {{field.name}}_b64_len = data->{{field.len_field}} * 2;
             uint8_t {{field.name}}_b64[{{field.name}}_b64_len];
             Base64Encode(data->{{field.name}}, data->{{field.len_field}},
                 {{field.name}}_b64, &{{field.name}}_b64_len);
-            json_object_set_new(js, "data->{{field.name}}",
-                json_string((char *){{field.name}}_b64));
+            jb_set_string(js, "data->{{field.name}}", (char *){{field.name}}_b64);
 {% elif field.type == "vstr4" %}
-            json_object_set_new(js, "data->{{field.name}}", json_string(data->{{field.name}}));
+            jb_set_string(js, "data->{{field.name}}", data->{{field.name}});
 {% elif field.type == "chararray" %}
             if (data->{{field.len_field}} > 0) {
                 /* First create a null terminated string as not all versions
                  * of jansson have json_stringn. */
                 char tmpbuf[data->{{field.len_field}} + 1];
                 memcpy(tmpbuf, data->{{field.name}}, data->{{field.len_field}});
                 tmpbuf[data->{{field.len_field}}] = '\\0';
-                json_object_set_new(js, "{{field.name}}", json_string(tmpbuf));
+                jb_set_string(js, "{{field.name}}", tmpbuf);
             } else {
-                json_object_set_new(js, "{{field.name}}", json_string(""));
+                jb_set_string(js, "{{field.name}}", "");
             }
 {% elif field.type == "bstr8" %}
 {% for field in field.fields %}
-            json_object_set_new(js, "{{field.name}}",
-                json_integer(data->{{field.name}}));
+            jb_set_uint(js, "{{field.name}}", data->{{field.name}});
 {% endfor %}
 {% else %}
 {{ raise("Unhandled datatype: %s" % (field.type)) }}

src/output-json-alert.c

@@ -167,27 +167,30 @@ static void AlertJsonDnp3(const Flow *f, const uint64_t tx_id, JsonBuilder *js)
         DNP3Transaction *tx = AppLayerParserGetTx(IPPROTO_TCP, ALPROTO_DNP3,
             dnp3_state, tx_id);
         if (tx) {
-            json_t *dnp3js = json_object();
-            if (likely(dnp3js != NULL)) {
-                if (tx->has_request && tx->request_done) {
-                    json_t *request = JsonDNP3LogRequest(tx);
-                    if (request != NULL) {
-                        json_object_set_new(dnp3js, "request", request);
-                    }
-                }
-                if (tx->has_response && tx->response_done) {
-                    json_t *response = JsonDNP3LogResponse(tx);
-                    if (response != NULL) {
-                        json_object_set_new(dnp3js, "response", response);
-                    }
-                }
-                jb_set_jsont(js, "dnp3", dnp3js);
-                json_decref(dnp3js);
+            JsonBuilderMark mark = { 0, 0, 0 };
+            jb_get_mark(js, &mark);
+            bool logged = false;
+            jb_open_object(js, "dnp3");
+            if (tx->has_request && tx->request_done) {
+                jb_open_object(js, "request");
+                JsonDNP3LogRequest(js, tx);
+                jb_close(js);
+                logged = true;
+            }
+            if (tx->has_response && tx->response_done) {
+                jb_open_object(js, "response");
+                JsonDNP3LogResponse(js, tx);
+                jb_close(js);
+                logged = true;
+            }
+            if (logged) {
+                /* Close dnp3 object. */
+                jb_close(js);
+            } else {
+                jb_restore_mark(js, &mark);
             }
         }
     }
-
-    return;
 }
 
 static void AlertJsonDns(const Flow *f, const uint64_t tx_id, JsonBuilder *js)