- djm@cvs.openbsd.org 2003/11/17 09:45:39

[openssh.git] / openbsd-compat / vis.c

diff --git a/openbsd-compat/vis.c b/openbsd-compat/vis.c
index 7eb2d6cd9cef47e65eed0914a5a17492d09b7ddd..e6a2ce98d0a014aca51113544e5caf2bacffd685 100644 (file)
--- a/openbsd-compat/vis.c
+++ b/openbsd-compat/vis.c
@@ -10,11 +10,7 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
@@ -30,14 +26,17 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
+#include "includes.h"
+#if !defined(HAVE_STRNVIS)
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char rcsid[] = "$OpenBSD: vis.c,v 1.6 2000/11/21 00:47:28 millert Exp $";
+static char rcsid[] = "$OpenBSD: vis.c,v 1.12 2003/06/02 20:18:35 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
-#include "includes.h"
+#include <ctype.h>
+#include <string.h>
 
-#ifndef HAVE_VIS
+#include "vis.h"
 
 #define        isoctal(c)      (((u_char)(c)) >= '0' && ((u_char)(c)) <= '7')
 #define isvisible(c)   (((u_int)(c) <= UCHAR_MAX && isascii((u_char)(c)) && \
@@ -45,13 +44,18 @@ static char rcsid[] = "$OpenBSD: vis.c,v 1.6 2000/11/21 00:47:28 millert Exp $";
                                ((flag & VIS_SP) == 0 && (c) == ' ') ||      \
                                ((flag & VIS_TAB) == 0 && (c) == '\t') ||    \
                                ((flag & VIS_NL) == 0 && (c) == '\n') ||     \
-                               ((flag & VIS_SAFE) &&                        \
-                               ((c) == '\b' || (c) == '\007' || (c) == '\r')))
+                               ((flag & VIS_SAFE) && ((c) == '\b' ||        \
+                               (c) == '\007' || (c) == '\r' ||              \
+                               isgraph((u_char)(c)))))
 
 /*
  * vis - visually encode characters
  */
-char *vis(char *dst, int c, int flag, int nextc)
+char *
+vis(dst, c, flag, nextc)
+       register char *dst;
+       int c, nextc;
+       register int flag;
 {
        if (isvisible(c)) {
                *dst++ = c;
@@ -75,11 +79,7 @@ char *vis(char *dst, int c, int flag, int nextc)
                        *dst++ = '\\';
                        *dst++ = 'b';
                        goto done;
-#ifdef __STDC__
                case '\a':
-#else
-               case '\007':
-#endif
                        *dst++ = '\\';
                        *dst++ = 'a';
                        goto done;
@@ -136,4 +136,102 @@ done:
        *dst = '\0';
        return (dst);
 }
-#endif /* HAVE_VIS */
+
+/*
+ * strvis, strnvis, strvisx - visually encode characters from src into dst
+ *     
+ *     Dst must be 4 times the size of src to account for possible
+ *     expansion.  The length of dst, not including the trailing NULL,
+ *     is returned. 
+ *
+ *     Strnvis will write no more than siz-1 bytes (and will NULL terminate).
+ *     The number of bytes needed to fully encode the string is returned.
+ *
+ *     Strvisx encodes exactly len bytes from src into dst.
+ *     This is useful for encoding a block of data.
+ */
+int
+strvis(dst, src, flag)
+       register char *dst;
+       register const char *src;
+       int flag;
+{
+       register char c;
+       char *start;
+
+       for (start = dst; (c = *src);)
+               dst = vis(dst, c, flag, *++src);
+       *dst = '\0';
+       return (dst - start);
+}
+
+int
+strnvis(dst, src, siz, flag)
+       char *dst;
+       const char *src;
+       size_t siz;
+       int flag;
+{
+       char c;
+       char *start, *end;
+       char tbuf[5];
+       int  i;
+
+       i = 0;
+       for (start = dst, end = start + siz - 1; (c = *src) && dst < end; ) {
+               if (isvisible(c)) {
+                       i = 1;
+                       *dst++ = c;
+                       if (c == '\\' && (flag & VIS_NOSLASH) == 0) {
+                               /* need space for the extra '\\' */
+                               if (dst < end)
+                                       *dst++ = '\\';
+                               else {
+                                       dst--;
+                                       i = 2;
+                                       break;
+                               }
+                       }
+                       src++;
+               } else {
+                       i = vis(tbuf, c, flag, *++src) - tbuf;
+                       if (dst + i <= end) {
+                               memcpy(dst, tbuf, i);
+                               dst += i;
+                       } else {
+                               src--;
+                               break;
+                       }
+               }
+       }
+       if (siz > 0)
+               *dst = '\0';
+       if (dst + i > end) {
+               /* adjust return value for truncation */
+               while ((c = *src))
+                       dst += vis(tbuf, c, flag, *++src) - tbuf;
+       }
+       return (dst - start);
+}
+
+int
+strvisx(dst, src, len, flag)
+       register char *dst;
+       register const char *src;
+       register size_t len;
+       int flag;
+{
+       register char c;
+       char *start;
+
+       for (start = dst; len > 1; len--) {
+               c = *src;
+               dst = vis(dst, c, flag, *++src);
+       }
+       if (len)
+               dst = vis(dst, *src, flag, '\0');
+       *dst = '\0';
+       return (dst - start);
+}
+
+#endif