You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by as...@apache.org on 2022/06/14 17:15:04 UTC
[qpid-proton] branch main updated (bc364b993 -> a0443f64b)
This is an automated email from the ASF dual-hosted git repository.
astitcher pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/qpid-proton.git
from bc364b993 Revert "NO-JIRA Workaround Travis CI package installation issues (#311)" (#372)
new 6de74a08c PROTON-2562: Fix pn_value_dump to output to a fixed size string buffer
new a0443f64b PROTON-2562: Use a fixed size buffer for more log messages
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
c/src/core/fixed_string.h | 94 +++++++++++++++++++++++++++
c/src/core/logger.c | 36 +++++++----
c/src/core/value_dump.c | 162 ++++++++++++++++++++++++----------------------
c/src/core/value_dump.h | 6 +-
4 files changed, 207 insertions(+), 91 deletions(-)
create mode 100644 c/src/core/fixed_string.h
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org
[qpid-proton] 01/02: PROTON-2562: Fix pn_value_dump to output to a fixed size string buffer
Posted by as...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
astitcher pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/qpid-proton.git
commit 6de74a08c9b1d4dc7cf375fddb2256f8b5b41b48
Author: Andrew Stitcher <as...@apache.org>
AuthorDate: Wed Dec 15 21:40:48 2021 -0500
PROTON-2562: Fix pn_value_dump to output to a fixed size string buffer
Introduce a new fixed size string type that does not grow and works in a
fixed buffer.
This is then used by the logger to avoid dynamically
growing the logger output.
---
c/src/core/fixed_string.h | 94 +++++++++++++++++++++++++++
c/src/core/logger.c | 24 ++++---
c/src/core/value_dump.c | 162 ++++++++++++++++++++++++----------------------
c/src/core/value_dump.h | 6 +-
4 files changed, 197 insertions(+), 89 deletions(-)
diff --git a/c/src/core/fixed_string.h b/c/src/core/fixed_string.h
new file mode 100644
index 000000000..fc36ee866
--- /dev/null
+++ b/c/src/core/fixed_string.h
@@ -0,0 +1,94 @@
+#ifndef PROTON_FIXED_STRING_H
+#define PROTON_FIXED_STRING_H 1
+
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+#include "util.h"
+
+#include <stdarg.h>
+
+typedef struct pn_fixed_string_t {
+ char *bytes;
+ uint32_t size;
+ uint32_t position;
+} pn_fixed_string_t;
+
+typedef struct pn_string_const_t {
+ const char *bytes;
+ uint32_t size;
+} pn_string_const_t;
+
+static inline pn_fixed_string_t pn_fixed_string(char *bytes, uint32_t size) {
+ return (pn_fixed_string_t) {.bytes=bytes, .size=size, .position=0};
+}
+
+static inline pn_string_const_t pn_string_const(const char* bytes, uint32_t size) {
+ return (pn_string_const_t) {.bytes=bytes, .size=size};
+}
+
+#define STR_CONST(x) pn_string_const(#x, sizeof(#x)-1)
+
+static inline void pn_fixed_string_append(pn_fixed_string_t *str, const pn_string_const_t chars) {
+ uint32_t copy_size = pn_min(chars.size, str->size-str->position);
+ if (copy_size==0) return;
+
+ memcpy(&str->bytes[str->position], chars.bytes, copy_size);
+ str->position += copy_size;
+}
+
+static inline void pn_fixed_string_vaddf(pn_fixed_string_t *str, const char *format, va_list ap){
+ uint32_t bytes_left = str->size-str->position;
+ if (bytes_left==0) return;
+
+ char *out = &str->bytes[str->position];
+ int out_size = vsnprintf(out, bytes_left, format, ap);
+ if ( out_size<0 ) return;
+ str->position += pn_min((uint32_t)out_size, bytes_left);
+}
+
+static inline void pn_fixed_string_addf(pn_fixed_string_t *str, const char *format, ...) {
+ va_list ap;
+ va_start(ap, format);
+ pn_fixed_string_vaddf(str, format, ap);
+ va_end(ap);
+}
+
+static inline void pn_fixed_string_quote(pn_fixed_string_t *str, const char *data, size_t size) {
+ size_t bytes_left = str->size-str->position;
+ if (bytes_left==0) return;
+
+ char *out = &str->bytes[str->position];
+ ssize_t out_size = pn_quote_data(out, bytes_left, data, size);
+ // The only error (ie value less than 0) that can come from pn_quote_data is PN_OVERFLOW
+ if ( out_size>0 ) {
+ str->position += out_size;
+ } else {
+ str->position = str->size;
+ }
+}
+
+static inline void pn_fixed_string_terminate(pn_fixed_string_t *str) {
+ if (str->position==str->size) str->position--;
+ str->bytes[str->position] = 0;
+}
+
+#endif // PROTON_FIXED_STRING_H
diff --git a/c/src/core/logger.c b/c/src/core/logger.c
index e81dc172c..0ea4fba59 100644
--- a/c/src/core/logger.c
+++ b/c/src/core/logger.c
@@ -22,6 +22,7 @@
#include <proton/logger.h>
#include <proton/error.h>
+#include "fixed_string.h"
#include "memory.h"
#include "util.h"
#include "value_dump.h"
@@ -216,22 +217,25 @@ void pni_logger_log_msg_inspect(pn_logger_t *logger, pn_log_subsystem_t subsyste
void pni_logger_log_msg_frame(pn_logger_t *logger, pn_log_subsystem_t subsystem, pn_log_level_t severity, pn_bytes_t frame, const char *fmt, ...) {
va_list ap;
+ char buf[1024];
+ pn_fixed_string_t output = pn_fixed_string(buf, sizeof(buf));
va_start(ap, fmt);
- pn_string_vformat(logger->scratch, fmt, ap);
+ pn_fixed_string_vaddf(&output, fmt, ap);
va_end(ap);
- size_t psize = pn_value_dump(frame, logger->scratch);
+ size_t psize = pni_value_dump(frame, &output);
pn_bytes_t payload = {.size=frame.size-psize, .start=frame.start+psize};
if (payload.size>0) {
- char buf[512];
- ssize_t n = pn_quote_data(buf, sizeof(buf), payload.start, payload.size);
- if (n >= 0) {
- pn_string_addf(logger->scratch, " (%zu) %s", payload.size, buf);
- } else if (n == PN_OVERFLOW) {
- pn_string_addf(logger->scratch, " (%zu) %s ... (truncated)", payload.size, buf);
- }
+ pn_fixed_string_addf(&output, " (%zu) ", payload.size);
+ pn_fixed_string_quote(&output, payload.start, payload.size);
}
- pni_logger_log(logger, subsystem, severity, pn_string_get(logger->scratch));
+ if (output.position==output.size) {
+ // Message overflow
+ const char truncated[] = " ... (truncated)";
+ output.position -= sizeof(truncated);
+ pn_fixed_string_append(&output, pn_string_const(truncated, sizeof(truncated)));
+ }
+ pni_logger_log(logger, subsystem, severity, buf);
}
void pni_logger_log(pn_logger_t *logger, pn_log_subsystem_t subsystem, pn_log_level_t severity, const char *message)
diff --git a/c/src/core/value_dump.c b/c/src/core/value_dump.c
index ac4e0c0d7..3dbcea9ea 100644
--- a/c/src/core/value_dump.c
+++ b/c/src/core/value_dump.c
@@ -23,11 +23,11 @@
#include "encodings.h"
#include "consumers.h"
+#include "fixed_string.h"
#include "framing.h"
#include "protocol.h"
#include "util.h"
-#include "proton/object.h"
#include "proton/types.h"
#include <ctype.h>
@@ -105,33 +105,33 @@ static inline bool type_islist_notspecial(uint8_t type) {
return type==PNE_LIST8 || type==PNE_LIST32;
}
-void pn_value_dump_special(uint8_t type, pn_string_t *output) {
+void pn_value_dump_special(uint8_t type, pn_fixed_string_t *output) {
switch (type) {
case PNE_NULL:
- pn_string_addf(output, "null");
+ pn_fixed_string_addf(output, "null");
break;
case PNE_TRUE:
- pn_string_addf(output, "true");
+ pn_fixed_string_addf(output, "true");
break;
case PNE_FALSE:
- pn_string_addf(output, "false");
+ pn_fixed_string_addf(output, "false");
break;
case PNE_UINT0:
- pn_string_addf(output, "0x0");
+ pn_fixed_string_addf(output, "0x0");
break;
case PNE_ULONG0:
- pn_string_addf(output, "0x0");
+ pn_fixed_string_addf(output, "0x0");
break;
case PNE_LIST0:
- pn_string_addf(output, "[]");
+ pn_fixed_string_addf(output, "[]");
break;
default:
- pn_string_addf(output, "!!<unknown>");
+ pn_fixed_string_addf(output, "!!<unknown>");
break;
}
}
-void pn_value_dump_descriptor_ulong(uint8_t type, pn_bytes_t value, pn_string_t* output, uint64_t* dcode) {
+void pn_value_dump_descriptor_ulong(uint8_t type, pn_bytes_t value, pn_fixed_string_t* output, uint64_t* dcode) {
uint64_t ulong;
switch (type) {
case PNE_ULONG0:
@@ -145,7 +145,7 @@ void pn_value_dump_descriptor_ulong(uint8_t type, pn_bytes_t value, pn_string_t*
break;
default:
// If we get a different descriptor type - huh
- pn_string_addf(output, "!!<not-a-ulong>");
+ pn_fixed_string_addf(output, "!!<not-a-ulong>");
return;
}
*dcode = ulong;
@@ -154,18 +154,18 @@ void pn_value_dump_descriptor_ulong(uint8_t type, pn_bytes_t value, pn_string_t*
if (ulong>=FIELD_MIN && ulong<=FIELD_MAX) {
uint8_t name_index = FIELDS[ulong-FIELD_MIN].name_index;
if (name_index!=0) {
- pn_string_addf(output, "%s(%" PRIu64 ") ",
+ pn_fixed_string_addf(output, "%s(%" PRIu64 ") ",
(const char *)FIELD_STRINGPOOL.STRING0+FIELD_NAME[name_index],
ulong);
return;
}
}
- pn_string_addf(output, "%" PRIu64 " ", ulong);
+ pn_fixed_string_addf(output, "%" PRIu64 " ", ulong);
return;
}
-void pn_value_dump_scalar(uint8_t type, pn_bytes_t value, pn_string_t *output){
+void pn_value_dump_scalar(uint8_t type, pn_bytes_t value, pn_fixed_string_t *output){
if (type_isfixedsize(type)) {
if (type_isspecial(type)) {
pn_value_dump_special(type, output);
@@ -192,64 +192,64 @@ void pn_value_dump_scalar(uint8_t type, pn_bytes_t value, pn_string_t *output){
break;
case 0:
// We'll get here if there aren't enough bytes left for the value
- pn_string_addf(output, "!!");
+ pn_fixed_string_addf(output, "!!");
return;
default:
// It has to be length 1,2,4 or 8!
- pn_string_addf(output, "!!<WeirdLengthHappened(%zu)>", value.size);
+ pn_fixed_string_addf(output, "!!<WeirdLengthHappened(%zu)>", value.size);
return;
}
if (type_isunsigned_ifsimpleint(type)) {
// mask high sign extended bits if unsigned
uint = uint & mask;
- pn_string_addf(output, "0x%" PRIx64, uint);
+ pn_fixed_string_addf(output, "0x%" PRIx64, uint);
} else {
int64_t i = (int64_t)uint;
- pn_string_addf(output, "%" PRIi64, i);
+ pn_fixed_string_addf(output, "%" PRIi64, i);
}
} else {
// Check if we didn't have enough bytes for the value
if (value.size==0) {
- pn_string_addf(output, "!!");
+ pn_fixed_string_addf(output, "!!");
return;
}
switch (type) {
case PNE_BOOLEAN:
- pn_string_addf(output, *value.start ? "true" : "false");
+ pn_fixed_string_addf(output, *value.start ? "true" : "false");
break;
case PNE_FLOAT: {
union {uint32_t i; float f;} conv;
conv.i = pni_read32(value.start);
- pn_string_addf(output, "%g", conv.f);
+ pn_fixed_string_addf(output, "%g", conv.f);
break;
}
case PNE_DOUBLE: {
union {uint64_t i; double f;} conv;
conv.i = pni_read64(value.start);
- pn_string_addf(output, "%g", conv.f);
+ pn_fixed_string_addf(output, "%g", conv.f);
break;
}
case PNE_UTF32:
break;
case PNE_MS64: {
int64_t timestamp = pni_read64(value.start);
- pn_string_addf(output, "%" PRIi64, timestamp);
+ pn_fixed_string_addf(output, "%" PRIi64, timestamp);
break;
}
case PNE_DECIMAL32:
- pn_string_addf(output, "D32(%04" PRIx32 ")", pni_read32(value.start));
+ pn_fixed_string_addf(output, "D32(%04" PRIx32 ")", pni_read32(value.start));
break;
case PNE_DECIMAL64:
- pn_string_addf(output, "D64(%08" PRIx64 ")", pni_read64(value.start));
+ pn_fixed_string_addf(output, "D64(%08" PRIx64 ")", pni_read64(value.start));
break;
case PNE_DECIMAL128:
- pn_string_addf(
+ pn_fixed_string_addf(
output,
"D128(%08" PRIx64 "%08" PRIx64 ")",
pni_read64(value.start), pni_read64(&value.start[8]));
break;
case PNE_UUID:
- pn_string_addf(
+ pn_fixed_string_addf(
output,
"UUID(%02hhx%02hhx%02hhx%02hhx-"
"%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-"
@@ -261,11 +261,11 @@ void pn_value_dump_scalar(uint8_t type, pn_bytes_t value, pn_string_t *output){
value.start[10], value.start[11], value.start[12], value.start[13], value.start[14], value.start[15]);
break;
default:
- pn_string_addf(output, "!!<UnknownType<0x%02hhx>(", type);
+ pn_fixed_string_addf(output, "!!<UnknownType<0x%02hhx>(", type);
for (size_t i=0; i<value.size; i++) {
- pn_string_addf(output, "%.2x", value.start[i]);
+ pn_fixed_string_addf(output, "%.2x", value.start[i]);
}
- pn_string_addf(output, ")>");
+ pn_fixed_string_addf(output, ")>");
}
}
} else {
@@ -307,9 +307,9 @@ void pn_value_dump_scalar(uint8_t type, pn_bytes_t value, pn_string_t *output){
prefix = "<?<";
suffix = ">?>";
}
- pn_string_addf(output, "%s", prefix);
- pn_quote(output, value.start, value.size);
- pn_string_addf(output, "%s", suffix);
+ pn_fixed_string_addf(output, "%s", prefix);
+ pn_fixed_string_quote(output, value.start, value.size);
+ pn_fixed_string_addf(output, "%s", suffix);
}
}
@@ -325,72 +325,72 @@ static inline uint32_t consume_count(uint8_t type, pn_bytes_t *value) {
return count;
}
-void pn_value_dump_nondescribed_value(uint8_t type, pn_bytes_t value, pn_string_t *output);
+void pn_value_dump_nondescribed_value(uint8_t type, pn_bytes_t value, pn_fixed_string_t *output);
-void pn_value_dump_list(uint32_t count, pn_bytes_t value, pn_string_t *output) {
+void pn_value_dump_list(uint32_t count, pn_bytes_t value, pn_fixed_string_t *output) {
uint32_t elements = 0;
- pn_string_addf(output, "[");
+ pn_fixed_string_addf(output, "[");
while (value.size) {
elements++;
- size_t size = pn_value_dump(value, output);
+ size_t size = pni_value_dump(value, output);
value = pn_bytes_advance(value, size);
if (value.size) {
- pn_string_addf(output, ", ");
+ pn_fixed_string_addf(output, ", ");
}
}
- pn_string_addf(output, "]");
+ pn_fixed_string_addf(output, "]");
if (elements!=count) {
- pn_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
+ pn_fixed_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
}
}
-void pn_value_dump_described_list(uint32_t count, pn_bytes_t value, uint64_t dcode, pn_string_t *output) {
+void pn_value_dump_described_list(uint32_t count, pn_bytes_t value, uint64_t dcode, pn_fixed_string_t *output) {
uint32_t elements = 0;
bool output_element = false;
- pn_string_addf(output, "[");
+ pn_fixed_string_addf(output, "[");
while (value.size) {
uint8_t type = value.start[0];
if (type==PNE_NULL) {
value = pn_bytes_advance(value, 1);
} else {
if (output_element) {
- pn_string_addf(output, ", ");
+ pn_fixed_string_addf(output, ", ");
}
const pn_fields_t *fields = &FIELDS[dcode-FIELD_MIN];
if (elements < fields->field_count) {
- pn_string_addf(output, "%s=",
+ pn_fixed_string_addf(output, "%s=",
(const char*)FIELD_STRINGPOOL.STRING0+FIELD_FIELDS[fields->first_field_index+elements]);
}
- size_t size = pn_value_dump(value, output);
+ size_t size = pni_value_dump(value, output);
value = pn_bytes_advance(value, size);
output_element = true;
}
elements++;
}
- pn_string_addf(output, "]");
+ pn_fixed_string_addf(output, "]");
if (elements!=count) {
- pn_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
+ pn_fixed_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
}
}
-void pn_value_dump_map(uint32_t count, pn_bytes_t value, pn_string_t *output) {
+void pn_value_dump_map(uint32_t count, pn_bytes_t value, pn_fixed_string_t *output) {
uint32_t elements = 0;
- pn_string_addf(output, "{");
+ pn_fixed_string_addf(output, "{");
while (value.size) {
elements++;
- size_t size = pn_value_dump(value, output);
+ size_t size = pni_value_dump(value, output);
value = pn_bytes_advance(value, size);
if (value.size) {
if (elements & 1) {
- pn_string_addf(output, "=");
+ pn_fixed_string_addf(output, "=");
} else {
- pn_string_addf(output, ", ");
+ pn_fixed_string_addf(output, ", ");
}
}
}
- pn_string_addf(output, "}");
+ pn_fixed_string_addf(output, "}");
if (elements!=count) {
- pn_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
+ pn_fixed_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
}
}
@@ -438,7 +438,7 @@ static inline const char* pni_type_name(uint8_t type) {
return NULL;
}
-void pn_value_dump_array(uint32_t count, pn_bytes_t value, pn_string_t *output) {
+void pn_value_dump_array(uint32_t count, pn_bytes_t value, pn_fixed_string_t *output) {
// Read base type only (ignoring descriptor) and first value
uint8_t type = 0;
pn_bytes_t evalue;
@@ -450,49 +450,49 @@ void pn_value_dump_array(uint32_t count, pn_bytes_t value, pn_string_t *output)
}
if (type==0){
// Type isn't allowed to be 0 at present because we dump described values as the base type anyway
- pn_string_addf(output, "@<!!>[]");
+ pn_fixed_string_addf(output, "@<!!>[]");
return;
}
const char* type_name = pni_type_name(type);
if (type_name) {
- pn_string_addf(output, "@<%s>[", type_name);
+ pn_fixed_string_addf(output, "@<%s>[", type_name);
} else {
- pn_string_addf(output, "@<%02hhx>[", type);
+ pn_fixed_string_addf(output, "@<%02hhx>[", type);
}
if (count==0) {
- pn_string_addf(output, "]");
+ pn_fixed_string_addf(output, "]");
return;
}
pn_value_dump_nondescribed_value(type, evalue, output);
if (type_isspecial(type)) {
if (count>1) {
- pn_string_addf(output, ", ...(%d more)]", count-1);
+ pn_fixed_string_addf(output, ", ...(%d more)]", count-1);
} else {
- pn_string_addf(output, "]");
+ pn_fixed_string_addf(output, "]");
}
return;
}
uint32_t elements = 1;
while (value.size) {
- pn_string_addf(output, ", ");
+ pn_fixed_string_addf(output, ", ");
elements++;
size_t size = pni_frame_read_value_not_described(value, type, &evalue);
pn_value_dump_nondescribed_value(type, evalue, output);
if (size <= value.size) {
value = pn_bytes_advance(value, size);
} else {
- pn_string_addf(output, "<error: %zd > %zd>", size, value.size);
+ pn_fixed_string_addf(output, "<error: %zd > %zd>", size, value.size);
value.size = 0;
}
}
- pn_string_addf(output, "]");
+ pn_fixed_string_addf(output, "]");
if (elements!=count) {
- pn_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
+ pn_fixed_string_addf(output, "<%" PRIu32 "!=%" PRIu32 ">", elements, count);
}
}
-void pn_value_dump_nondescribed_value(uint8_t type, pn_bytes_t value, pn_string_t *output){
+void pn_value_dump_nondescribed_value(uint8_t type, pn_bytes_t value, pn_fixed_string_t *output){
if (!type_iscompund(type)) {
// The one exception to 'scalar' is LIST0 which is encoded as a special type
pn_value_dump_scalar(type, value, output);
@@ -503,15 +503,15 @@ void pn_value_dump_nondescribed_value(uint8_t type, pn_bytes_t value, pn_string_
switch (type) {
case PNE_LIST8:
case PNE_LIST32:
- pn_string_addf(output, "[!!]");
+ pn_fixed_string_addf(output, "[!!]");
break;
case PNE_MAP8:
case PNE_MAP32:
- pn_string_addf(output, "{!!}");
+ pn_fixed_string_addf(output, "{!!}");
break;
case PNE_ARRAY8:
case PNE_ARRAY32:
- pn_string_addf(output, "@<>[!!]");
+ pn_fixed_string_addf(output, "@<>[!!]");
break;
}
return;
@@ -536,19 +536,19 @@ void pn_value_dump_nondescribed_value(uint8_t type, pn_bytes_t value, pn_string_
}
}
-size_t pn_value_dump_described(pn_bytes_t bytes, uint64_t dcode, pn_string_t *output) {
+size_t pn_value_dump_described(pn_bytes_t bytes, uint64_t dcode, pn_fixed_string_t *output) {
uint8_t type;
pn_bytes_t value;
size_t size = pni_frame_get_type_value(bytes, &type, &value);
if (size==0) {
- pn_string_addf(output, "!!");
+ pn_fixed_string_addf(output, "!!");
return 0;
}
// The only described type handled differently is list
if (type_islist_notspecial(type) && dcode) {
if (value.size==0) {
- pn_string_addf(output, "[!!]");
+ pn_fixed_string_addf(output, "[!!]");
return size;
}
uint32_t count = consume_count(type, &value);
@@ -559,12 +559,12 @@ size_t pn_value_dump_described(pn_bytes_t bytes, uint64_t dcode, pn_string_t *ou
return size;
}
-size_t pn_value_dump_nondescribed(pn_bytes_t bytes, pn_string_t *output) {
+size_t pn_value_dump_nondescribed(pn_bytes_t bytes, pn_fixed_string_t *output) {
uint8_t type;
pn_bytes_t value;
size_t size = pni_frame_get_type_value(bytes, &type, &value);
if (size==0) {
- pn_string_addf(output, "!!");
+ pn_fixed_string_addf(output, "!!");
return 0;
}
@@ -572,7 +572,7 @@ size_t pn_value_dump_nondescribed(pn_bytes_t bytes, pn_string_t *output) {
return size;
}
-size_t pn_value_dump(pn_bytes_t frame, pn_string_t *output)
+size_t pni_value_dump(pn_bytes_t frame, pn_fixed_string_t *output)
{
if (frame.size==0) {
return 0;
@@ -580,7 +580,7 @@ size_t pn_value_dump(pn_bytes_t frame, pn_string_t *output)
uint8_t type = frame.start[0];
// Check for described type first
if (type==PNE_DESCRIPTOR) {
- pn_string_addf(output, "@");
+ pn_fixed_string_addf(output, "@");
frame = pn_bytes_advance(frame, 1);
size_t fsize = 1;
uint8_t type;
@@ -589,7 +589,7 @@ size_t pn_value_dump(pn_bytes_t frame, pn_string_t *output)
frame = pn_bytes_advance(frame, size);
fsize += size;
if (value.size==0) {
- pn_string_addf(output, "!!");
+ pn_fixed_string_addf(output, "!!");
return fsize;
}
if (type_isulong(type)) {
@@ -605,3 +605,11 @@ size_t pn_value_dump(pn_bytes_t frame, pn_string_t *output)
return pn_value_dump_nondescribed(frame, output);
}
}
+
+size_t pn_value_dump(pn_bytes_t frame, char *bytes, uint32_t size)
+{
+ pn_fixed_string_t output = pn_fixed_string(bytes, size);
+ size_t fsize = pni_value_dump(frame, &output);
+ pn_fixed_string_terminate(&output);
+ return fsize;
+}
diff --git a/c/src/core/value_dump.h b/c/src/core/value_dump.h
index b2987aaa5..0f6418f5a 100644
--- a/c/src/core/value_dump.h
+++ b/c/src/core/value_dump.h
@@ -23,8 +23,10 @@
*/
#include "proton/types.h"
-#include "proton/object.h"
-PN_EXTERN size_t pn_value_dump(pn_bytes_t frame, pn_string_t *output);
+struct pn_fixed_string_t;
+size_t pni_value_dump(pn_bytes_t frame, struct pn_fixed_string_t *output);
+
+PN_EXTERN size_t pn_value_dump(pn_bytes_t frame, char *output, uint32_t size);
#endif // PROTON_VALUE_DUMP_H
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org
[qpid-proton] 02/02: PROTON-2562: Use a fixed size buffer for more log messages
Posted by as...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
astitcher pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/qpid-proton.git
commit a0443f64b2394947100c4f364f72af9a9f41ee31
Author: Andrew Stitcher <as...@apache.org>
AuthorDate: Wed Dec 15 22:28:50 2021 -0500
PROTON-2562: Use a fixed size buffer for more log messages
The log messages that still use a pn_string_t either use that type
because of internal APIs.
---
c/src/core/logger.c | 12 ++++++++++--
1 file changed, 10 insertions(+), 2 deletions(-)
diff --git a/c/src/core/logger.c b/c/src/core/logger.c
index 0ea4fba59..2ee9e1dd1 100644
--- a/c/src/core/logger.c
+++ b/c/src/core/logger.c
@@ -247,8 +247,16 @@ void pni_logger_log(pn_logger_t *logger, pn_log_subsystem_t subsystem, pn_log_le
void pni_logger_vlogf(pn_logger_t *logger, pn_log_subsystem_t subsystem, pn_log_level_t severity, const char *fmt, va_list ap)
{
assert(logger);
- pn_string_vformat(logger->scratch, fmt, ap);
- pni_logger_log(logger, subsystem, severity, pn_string_get(logger->scratch));
+ char buf[1024];
+ pn_fixed_string_t output = pn_fixed_string(buf, sizeof(buf));
+ pn_fixed_string_vaddf(&output, fmt, ap);
+ if (output.position==output.size) {
+ // Message overflow
+ const char truncated[] = " ... (truncated)";
+ output.position -= sizeof(truncated);
+ pn_fixed_string_append(&output, pn_string_const(truncated, sizeof(truncated)));
+ }
+ pni_logger_log(logger, subsystem, severity, buf);
}
void pn_logger_logf(pn_logger_t *logger, pn_log_subsystem_t subsystem, pn_log_level_t severity, const char *fmt, ...)
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org