Skip to contentSkip to conversation

eal: support strlcat function

PATCH Superseded Bruce Richardson 6 participants 13 messages Jan 16, 2019 – Apr 16, 2019

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 eal: support strlcat function

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit: 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

---
 .../common/include/rte_string_fns.h           | 15 +++++++
 test/test/test_string_fns.c                   | 45 +++++++++++++++++++
 2 files changed, 60 insertions(+)
lib/librte_eal/common/include/rte_string_fns.h +15 -0
index 9a2a1ff90..e7a1656f0 100644
@@ -59,10 +59,24 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 	return (size_t)snprintf(dst, size, "%s", src);
 }
 
+/**
+ * @internal
+ * DPDK-specific version of strlcat for systems without
+ * libc or libbsd copies of the function
+ */
+static inline size_t
+rte_strlcat(char *dst, const char *src, size_t size)
+{
+	size_t l = strnlen(dst, size);
+	return l + ((l < size) ?
+		rte_strlcpy(&dst[l], src, size - l) : strlen(src));
+}
+
 /* pull in a strlcpy function */
 #ifdef RTE_EXEC_ENV_BSDAPP
 #ifndef __BSD_VISIBLE /* non-standard functions are hidden */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 #endif
 
 #else /* non-BSD platforms */
@@ -71,6 +85,7 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 
 #else /* no BSD header files, create own */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 
 #endif /* RTE_USE_LIBBSD */
 #endif /* BSDAPP */
test/test/test_string_fns.c +45 -0

56 lines not on this page · raw message

Signature · 1 line
2.20.1
#1 lore raw
Quoted 11 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit: 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

---

<...>

test/test/test_string_fns.c test_rte_strsplit(void) · line 183

Quoted 11 lines
  static int
  test_string_fns(void)
  {
  	if (test_rte_strsplit() < 0)
  		return -1;
test/test/test_string_fns.c +2 -0
+	if (test_rte_strlcat() < 0)
+		return -1;
  	return 0;
  }

Unrelated, but do we also need to test strlcpy, strscpy and other functions that were introduced?

Signature · 2 lines
Thanks,
Anatoly
#2 lore raw
Quoted 14 lines · Anatoly
Quoted 10 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit: 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

<...>

Quoted 8 lines
Quoted 4 lines
  static int test_string_fns(void) { if (test_rte_strsplit() < 0)
  return -1; +	if (test_rte_strlcat() < 0) +		return -1;
  return 0; }

Unrelated, but do we also need to test strlcpy, strscpy and other functions that were introduced?

Yes, I think that would be advisable. I imagine the easiest way to test them is to do as I have here in running comparisons with a range of inputs, especially boundary conditions, against a known-good version for platforms that have the functions built-in.
As always, volunteers and patches welcome... :-)

/Bruce

#3 lore raw
Quoted 24 lines · Bruce Richardson
Quoted 14 lines · Anatoly
Quoted 10 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit: 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

<...>

Quoted 8 lines
Quoted 4 lines
   static int test_string_fns(void) { if (test_rte_strsplit() < 0)
   return -1; +	if (test_rte_strlcat() < 0) +		return -1;
   return 0; }

Unrelated, but do we also need to test strlcpy, strscpy and other functions that were introduced?

Quoted 5 lines

Yes, I think that would be advisable. I imagine the easiest way to test them is to do as I have here in running comparisons with a range of inputs, especially boundary conditions, against a known-good version for platforms that have the functions built-in.
As always, volunteers and patches welcome... :-)

/action hides

Quoted 3 lines

/Bruce

Signature · 2 lines
Thanks,
Anatoly
#4 lore raw
In reply to Bruce Richardson
Quoted 24 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit: 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

---
 .../common/include/rte_string_fns.h           | 15 +++++++
 test/test/test_string_fns.c                   | 45 +++++++++++++++++++
 2 files changed, 60 insertions(+)
lib/librte_eal/common/include/rte_string_fns.h +1 -0
index 9a2a1ff90..e7a1656f0 100644
@@ -59,10 +59,24 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 	return (size_t)snprintf(dst, size, "%s", src);
 }
 
+/**

lib/librte_eal/common/include/rte_string_fns.h rte_strlcpy(char *dst, const char *src, size_t size) · line 72

Quoted 10 lines
lib/librte_eal/common/include/rte_string_fns.h +10 -0
+ * @internal
+ * DPDK-specific version of strlcat for systems without
+ * libc or libbsd copies of the function
+ */
+static inline size_t
+rte_strlcat(char *dst, const char *src, size_t size)
+{
+	size_t l = strnlen(dst, size);
+	return l + ((l < size) ?
+		rte_strlcpy(&dst[l], src, size - l) : strlen(src));

I think operation is complex for ternary operation, regular if check can be simpler, other than that looks good to me.

Quoted 80 lines
lib/librte_eal/common/include/rte_string_fns.h +4 -0
+}
+
 /* pull in a strlcpy function */
 #ifdef RTE_EXEC_ENV_BSDAPP
 #ifndef __BSD_VISIBLE /* non-standard functions are hidden */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 #endif
 
 #else /* non-BSD platforms */
@@ -71,6 +85,7 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 
 #else /* no BSD header files, create own */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 
 #endif /* RTE_USE_LIBBSD */
 #endif /* BSDAPP */
test/test/test_string_fns.c +45 -0
index 3f091ab92..3bd8ed5d8 100644
@@ -129,11 +129,56 @@ test_rte_strsplit(void)
 	return 0;
 }
 
+int
+test_rte_strlcat(void)
+{
+	/* only run actual unit tests if we have system-provided strlcat */
+#if defined(__BSD_VISIBLE) || defined(RTE_USE_LIBBSD)
+#define BUF_LEN 32
+	const char dst[BUF_LEN] = "Test string";
+	const char src[] = " appended";
+	char bsd_dst[BUF_LEN];
+	char rte_dst[BUF_LEN];
+	size_t i, bsd_ret, rte_ret;
+
+	LOG("dst = '%s', strlen(dst) = %zu\n", dst, strlen(dst));
+	LOG("src = '%s', strlen(src) = %zu\n", src, strlen(src));
+	LOG("---\n");
+
+	for (i = 0; i < BUF_LEN; i++) {
+		/* initialize destination buffers */
+		memcpy(bsd_dst, dst, BUF_LEN);
+		memcpy(rte_dst, dst, BUF_LEN);
+		/* compare implementations */
+		bsd_ret = strlcat(bsd_dst, src, i);
+		rte_ret = rte_strlcat(rte_dst, src, i);
+		if (bsd_ret != rte_ret) {
+			LOG("Incorrect retval for buf length = %zu\n", i);
+			LOG("BSD: '%zu', rte: '%zu'\n", bsd_ret, rte_ret);
+			return -1;
+		}
+		if (memcmp(bsd_dst, rte_dst, BUF_LEN) != 0) {
+			LOG("Resulting buffers don't match\n");
+			LOG("BSD: '%s', rte: '%s'\n", bsd_dst, rte_dst);
+			return -1;
+		}
+		LOG("buffer size = %zu: dst = '%s', ret = %zu\n",
+			i, rte_dst, rte_ret);
+	}
+	LOG("Checked %zu combinations\n", i);
+#undef BUF_LEN
+#endif /* defined(__BSD_VISIBLE) || defined(RTE_USE_LIBBSD) */
+
+	return 0;
+}
+
 static int
 test_string_fns(void)
 {
 	if (test_rte_strsplit() < 0)
 		return -1;
+	if (test_rte_strlcat() < 0)
+		return -1;
 	return 0;
 }
 
#5 lore raw

PATCH v2 1/1 eal: support strlcat function

In reply to Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit: 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

---
V2: place ternary operator with regular if statement for readability
CC: Ferruh Yigit <[email protected]>

---
 .../common/include/rte_string_fns.h           | 16 +++++++
 test/test/test_string_fns.c                   | 45 +++++++++++++++++++
 2 files changed, 61 insertions(+)
lib/librte_eal/common/include/rte_string_fns.h +16 -0
index 9a2a1ff90..35c6b003c 100644
@@ -59,10 +59,25 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 	return (size_t)snprintf(dst, size, "%s", src);
 }
 
+/**
+ * @internal
+ * DPDK-specific version of strlcat for systems without
+ * libc or libbsd copies of the function
+ */
+static inline size_t
+rte_strlcat(char *dst, const char *src, size_t size)
+{
+	size_t l = strnlen(dst, size);
+	if (l < size)
+		return l + rte_strlcpy(&dst[l], src, size - l);
+	return l + strlen(src);
+}
+
 /* pull in a strlcpy function */
 #ifdef RTE_EXEC_ENV_BSDAPP
 #ifndef __BSD_VISIBLE /* non-standard functions are hidden */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 #endif
 
 #else /* non-BSD platforms */
@@ -71,6 +86,7 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 
 #else /* no BSD header files, create own */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 
 #endif /* RTE_USE_LIBBSD */
 #endif /* BSDAPP */
test/test/test_string_fns.c +45 -0

56 lines not on this page · raw message

Signature · 1 line
2.20.1
Reviewed-by on v2 1/1
#6 lore raw
Quoted 10 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit: 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

#7 lore raw
In reply to Bruce Richardson
Quoted 8 lines

-----Original Message-----
From: dev [mailto:[email protected]] On Behalf Of Bruce Richardson 3f091ab92..3bd8ed5d8 100644

test/test/test_string_fns.c test_rte_strsplit(void) · line 134

Quoted 6 lines
test/test/test_string_fns.c +3 -0
@@ -129,11 +129,56 @@ test_rte_strsplit(void)
 	return 0;
 }
 
+int
+test_rte_strlcat(void)
+{

test_string_fns.c:133:1: error: no previous prototype for 'test_rte_strlcat' [-Werror=missing-prototypes]
test_rte_strlcat(void)
^~~~~~~~~~~~~~~~
cc1: all warnings being treated as errors

function return type should be static int.

Thanks,
Reshma

#8 lore raw

PATCH v3 1/1 eal: support strlcat function

In reply to Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

---
V3: fix compiler error by making the test function static
CC: Reshma Pattan <[email protected]>

V2: place ternary operator with regular if statement for readability
CC: Ferruh Yigit <[email protected]>

---
 .../common/include/rte_string_fns.h           | 16 +++++++
 test/test/test_string_fns.c                   | 45 +++++++++++++++++++
 2 files changed, 61 insertions(+)
lib/librte_eal/common/include/rte_string_fns.h +16 -0
index 9a2a1ff90..35c6b003c 100644
@@ -59,10 +59,25 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 	return (size_t)snprintf(dst, size, "%s", src);
 }
 
+/**
+ * @internal
+ * DPDK-specific version of strlcat for systems without
+ * libc or libbsd copies of the function
+ */
+static inline size_t
+rte_strlcat(char *dst, const char *src, size_t size)
+{
+	size_t l = strnlen(dst, size);
+	if (l < size)
+		return l + rte_strlcpy(&dst[l], src, size - l);
+	return l + strlen(src);
+}
+
 /* pull in a strlcpy function */
 #ifdef RTE_EXEC_ENV_BSDAPP
 #ifndef __BSD_VISIBLE /* non-standard functions are hidden */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 #endif
 
 #else /* non-BSD platforms */
@@ -71,6 +86,7 @@ rte_strlcpy(char *dst, const char *src, size_t size)
 
 #else /* no BSD header files, create own */
 #define strlcpy(dst, src, size) rte_strlcpy(dst, src, size)
+#define strlcat(dst, src, size) rte_strlcat(dst, src, size)
 
 #endif /* RTE_USE_LIBBSD */
 #endif /* BSDAPP */
test/test/test_string_fns.c +45 -0

56 lines not on this page · raw message

Signature · 1 line
2.20.1
#9 lore raw

17/01/2019 18:30, Bruce Richardson:

Quoted 11 lines

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

Applied, thanks

#10 lore raw
In reply to Bruce Richardson
Quoted 11 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

Hi - I'd like to backport this to 18.11 stable branch. Not having it is starting to cause build failures with backports. Let me know if any objection.

thanks,
Kevin.

#11 lore raw
Quoted 10 lines · Kevin Traynor
Quoted 9 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

Quoted 7 lines
Quoted 2 lines

Hi - I'd like to backport this to 18.11 stable branch. Not having it is starting to cause build failures with backports. Let me know if any objection.

Go for it! No objections here, I think it makes sense.

/Bruce

#12 lore raw
Quoted 11 lines · Bruce Richardson
Quoted 10 lines · Kevin Traynor
Quoted 9 lines · Bruce Richardson

Add the strlcat function to DPDK to exist alongside the strlcpy one. While strncat is generally safe for use for concatenation, the API for the strlcat function is perhaps a little nicer to use, and supports truncation detection.

See commit 5364de644a4b ("eal: support strlcpy function") for more details on the function selection logic, since we only should be using the DPDK-provided version when no system-provided version is present.

Quoted 8 lines
Quoted 7 lines
Quoted 2 lines

Hi - I'd like to backport this to 18.11 stable branch. Not having it is starting to cause build failures with backports. Let me know if any objection.

Go for it! No objections here, I think it makes sense.

+1 for the backport.