Merge ~dougmurray/epics-base:fix-1943245 into epics-base:7.0

[Doug Murray]

Fixes lp: #1943245

[Andrew Johnson (anj)]

See comments inline below...

review: Needs Fixing

ccba97b... by Doug Murray on 2022-05-11

Fix up previous commit with added comment
Remove older routine, replaced by new version; added
comment from updated routine description.

Unmerged commits

ccba97b... by Doug Murray on 2022-05-11

Fix up previous commit with added comment
Remove older routine, replaced by new version; added
comment from updated routine description.

7abe056... by Doug Murray on 2022-05-11

#1943245 epicsStrnEscapedFromRaw may print inclomplete escape sequences
Fixed a problem where a partial escape sequence could be added to
a string. Rather than checking for the limit when adding each
character, the check is made for the entire sequence.

diff --git a/modules/libcom/src/misc/epicsString.c b/modules/libcom/src/misc/epicsString.c
index ca61d9b..1854874 100644
--- a/modules/libcom/src/misc/epicsString.c
+++ b/modules/libcom/src/misc/epicsString.c
@@ -117,46 +117,98 @@ done:
     return ndst;
 }
 
-int epicsStrnEscapedFromRaw(char *dst, size_t dstlen, const char *src,
-    size_t srclen)
+/*
+ * expand the given character.
+ * Place the expansion in *dest, which
+ * must be at least 5 characters long
+ *
+ * Returns: number of characters produced.
+ */
+static int translateEscapedChar( char c, char *dest)
 {
-    int rem = dstlen;
-    int ndst = 0;
+    static const char hex[] = "0123456789abcdef";
+    char *ptr = dest;
+    int ret = 0;
 
-    if (dst == src)
-        return -1;
+    if( ptr == NULL)
+        return 0;
 
-    while (srclen--) {
-        static const char hex[] = "0123456789abcdef";
-        int c = *src++;
-        #define OUT(chr) ndst++; if (--rem > 0) *dst++ = chr
-
-        switch (c) {
-        case '\a': OUT('\\'); OUT('a');  break;
-        case '\b': OUT('\\'); OUT('b');  break;
-        case '\f': OUT('\\'); OUT('f');  break;
-        case '\n': OUT('\\'); OUT('n');  break;
-        case '\r': OUT('\\'); OUT('r');  break;
-        case '\t': OUT('\\'); OUT('t');  break;
-        case '\v': OUT('\\'); OUT('v');  break;
-        case '\\': OUT('\\'); OUT('\\'); break;
-        case '\'': OUT('\\'); OUT('\''); break;
-        case '\"': OUT('\\'); OUT('\"'); break;
-        case '\0': OUT('\\'); OUT('0');  break;
+    *ptr++ = '\\';
+    switch( c) {
         default:
-            if (isprint(c & 0xff)) {
-                OUT(c);
-                break;
+            if( isprint( c & 0xff)) {
+                *--ptr = c;
+                ptr++;
+                ret = 1;
+            } else {
+                *ptr++ = 'x';
+                *ptr++ = hex[(c >> 4) & 0x0f];
+                *ptr++ = hex[ c       & 0x0f];
+                ret = 4;
             }
-            OUT('\\'); OUT('x');
-            OUT(hex[(c >> 4) & 0x0f]);
-            OUT(hex[ c       & 0x0f]);
+            break;
+
+        case '\a': *ptr++ = 'a';  ret = 2; break;
+        case '\b': *ptr++ = 'b';  ret = 2; break;
+        case '\f': *ptr++ = 'f';  ret = 2; break;
+        case '\n': *ptr++ = 'n';  ret = 2; break;
+        case '\r': *ptr++ = 'r';  ret = 2; break;
+        case '\t': *ptr++ = 't';  ret = 2; break;
+        case '\v': *ptr++ = 'v';  ret = 2; break;
+        case '\\': *ptr++ = '\\'; ret = 2; break;
+        case '\'': *ptr++ = '\''; ret = 2; break;
+        case '\"': *ptr++ = '"';  ret = 2; break;
+        case '\0': *ptr++ = '0';  ret = 2; break;
+    }
+
+    *ptr = 0;
+    return ret;
+}
+
+/**
+ * Copy string, converting non-printable characters into their escape sequence
+ * source string.
+ *
+ * epicsStrnEscapedFromRaw does the opposite of epicsStrnRawFromEscaped: It tries
+ * to copy strlen characters from the string src into a buffer dst of size dstlen,
+ * converting non-printable characters into C-style escape sequences. A zero byte
+ * will not terminate the input string. The output string will be zero-terminated
+ * as long as dstlen is non-zero. No more than dstlen characters will actually be
+ * written into the output buffer, although all the characters in the input string
+ * will be read. The return value is the number of characters that would have been
+ * stored in the output buffer if it were large enough, or a negative value if dst
+ * == src. In-place translations are not allowed since the escaped results will
+ * usually be larger than the input string.
+ * 
+ * The following escaped character constants will be used in the output:
+ * \a  \b  \f  \n  \r  \t  \v  \\  \'  \"
+ *
+ * All other non-printable characters appear as hexadeimal escapes in form \xNN
+ * where NN are two hex digits (0-9, a-f).  Non-printable characters are
+ * determined by the C runtime library’s isprint() function.
+ */
+int epicsStrnEscapedFromRaw(char *dst, size_t dstlen, const char *src, size_t srclen)
+{
+    char expanded[6];
+    int remain = dstlen;
+    int cnt = 0;
+
+    if( src == dst)
+            return -1;
+
+    for( int i = 0; i < srclen; i++) {
+        int num = translateEscapedChar( src[i], expanded);
+        if( num < remain) {
+            strcpy( dst, expanded);
+            remain -= num;
+            dst += num;
         }
-        #undef OUT
+        cnt += num;
     }
-    if (dstlen)
-        *dst = '\0';
-    return ndst;
+
+    if( dstlen != 0)
+            *dst = 0;
+    return cnt;
 }
 
 size_t epicsStrnEscapedFromRawSize(const char *src, size_t srclen)
diff --git a/modules/libcom/test/epicsStringTest.c b/modules/libcom/test/epicsStringTest.c
index 7abffa3..185d0b5 100644
--- a/modules/libcom/test/epicsStringTest.c
+++ b/modules/libcom/test/epicsStringTest.c
@@ -155,7 +155,7 @@ MAIN(epicsStringTest)
     char *s;
     int status;
 
-    testPlan(427);
+    testPlan(431);
 
     testChars();
 
@@ -244,10 +244,17 @@ MAIN(epicsStringTest)
 
     memset(result, 'x', sizeof(result));
     status = epicsStrnEscapedFromRaw(result, 4, ABCD, 5);
-    testOk(status == 6,      "esc(\"ABCD\", 5) -> %d (exp. 8)", status);
+    testOk(status == 6,      "esc(\"ABCD\", 5) -> %d (exp. 6)", status);
     testOk(result[3] == 0,   "  0-terminated");
     testOk(result[4] == 'x', "  No overrun");
 
+    memset(result, 'x', sizeof(result));
+    status = epicsStrnEscapedFromRaw(result, 5, "ABC\"DEF", 6);
+    testOk(status == 7,      "esc(\"ABC\\\"DEF\", 5) -> %d (exp. 7)", status);
+    testOk(result[3] != '\\',   "  no partial escape sequence");
+    testOk(result[4] == 0,   "  0-terminated");
+    testOk(result[5] == 'x', "  No overrun");
+
     testDiag("Testing raw = epicsStrnRawFromEscaped(out, 4, ...)");
 
     memset(result, 'x', sizeof(result));