contrib/libc-vis/vis.c

   1 /*      $NetBSD: vis.c,v 1.45 2012/12/14 21:38:18 christos Exp $        */
   2
   3 /*-
   4  * Copyright (c) 1989, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 /*-
  33  * Copyright (c) 1999, 2005 The NetBSD Foundation, Inc.
  34  * All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  * 1. Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  * 2. Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in the
  43  *    documentation and/or other materials provided with the distribution.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  46  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  47  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  48  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  49  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  50  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  51  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  52  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  53  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  54  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  55  * POSSIBILITY OF SUCH DAMAGE.
  56  */
  57
  58 #include <sys/cdefs.h>
  59 #if defined(LIBC_SCCS) && !defined(lint)
  60 __RCSID("$NetBSD: vis.c,v 1.45 2012/12/14 21:38:18 christos Exp $");
  61 #endif /* LIBC_SCCS and not lint */
  62 __FBSDID("$FreeBSD$");
  63
  64 #include "namespace.h"
  65 #include <sys/types.h>
  66
  67 #include <assert.h>
  68 #include <vis.h>
  69 #include <errno.h>
  70 #include <stdlib.h>
  71
  72 #define _DIAGASSERT(x)  assert(x)
  73
  74 #ifdef __weak_alias
  75 __weak_alias(strvisx,_strvisx)
  76 #endif
  77
  78 #if !HAVE_VIS || !HAVE_SVIS
  79 #include <ctype.h>
  80 #include <limits.h>
  81 #include <stdio.h>
  82 #include <string.h>
  83
  84 static char *do_svis(char *, size_t *, int, int, int, const char *);
  85
  86 #undef BELL
  87 #define BELL '\a'
  88
  89 #define isoctal(c)      (((u_char)(c)) >= '0' && ((u_char)(c)) <= '7')
  90 #define iswhite(c)      (c == ' ' || c == '\t' || c == '\n')
  91 #define issafe(c)       (c == '\b' || c == BELL || c == '\r')
  92 #define xtoa(c)         "0123456789abcdef"[c]
  93 #define XTOA(c)         "0123456789ABCDEF"[c]
  94
  95 #define MAXEXTRAS       9
  96
  97 #define MAKEEXTRALIST(flag, extra, orig_str)                                  \
  98 do {                                                                          \
  99         const char *orig = orig_str;                                          \
 100         const char *o = orig;                                                 \
 101         char *e;                                                              \
 102         while (*o++)                                                          \
 103                 continue;                                                     \
 104         extra = malloc((size_t)((o - orig) + MAXEXTRAS));                     \
 105         if (!extra) break;                                                    \
 106         for (o = orig, e = extra; (*e++ = *o++) != '\0';)                     \
 107                 continue;                                                     \
 108         e--;                                                                  \
 109         if (flag & VIS_GLOB) {                                                \
 110                 *e++ = '*';                                                   \
 111                 *e++ = '?';                                                   \
 112                 *e++ = '[';                                                   \
 113                 *e++ = '#';                                                   \
 114         }                                                                     \
 115         if (flag & VIS_SP) *e++ = ' ';                                        \
 116         if (flag & VIS_TAB) *e++ = '\t';                                      \
 117         if (flag & VIS_NL) *e++ = '\n';                                       \
 118         if ((flag & VIS_NOSLASH) == 0) *e++ = '\\';                           \
 119         *e = '\0';                                                            \
 120 } while (/*CONSTCOND*/0)
 121
 122 /*
 123  * This is do_hvis, for HTTP style (RFC 1808)
 124  */
 125 static char *
 126 do_hvis(char *dst, size_t *dlen, int c, int flag, int nextc, const char *extra)
 127 {
 128
 129         if ((isascii(c) && isalnum(c))
 130             /* safe */
 131             || c == '$' || c == '-' || c == '_' || c == '.' || c == '+'
 132             /* extra */
 133             || c == '!' || c == '*' || c == '\'' || c == '(' || c == ')'
 134             || c == ',') {
 135                 dst = do_svis(dst, dlen, c, flag, nextc, extra);
 136         } else {
 137                 if (dlen) {
 138                         if (*dlen < 3)
 139                                 return NULL;
 140                         *dlen -= 3;
 141                 }
 142                 *dst++ = '%';
 143                 *dst++ = xtoa(((unsigned int)c >> 4) & 0xf);
 144                 *dst++ = xtoa((unsigned int)c & 0xf);
 145         }
 146
 147         return dst;
 148 }
 149
 150 /*
 151  * This is do_mvis, for Quoted-Printable MIME (RFC 2045)
 152  * NB: No handling of long lines or CRLF.
 153  */
 154 static char *
 155 do_mvis(char *dst, size_t *dlen, int c, int flag, int nextc, const char *extra)
 156 {
 157         if ((c != '\n') &&
 158             /* Space at the end of the line */
 159             ((isspace(c) && (nextc == '\r' || nextc == '\n')) ||
 160             /* Out of range */
 161             (!isspace(c) && (c < 33 || (c > 60 && c < 62) || c > 126)) ||
 162             /* Specific char to be escaped */
 163             strchr("#$@[\\]^`{|}~", c) != NULL)) {
 164                 if (dlen) {
 165                         if (*dlen < 3)
 166                                 return NULL;
 167                         *dlen -= 3;
 168                 }
 169                 *dst++ = '=';
 170                 *dst++ = XTOA(((unsigned int)c >> 4) & 0xf);
 171                 *dst++ = XTOA((unsigned int)c & 0xf);
 172         } else {
 173                 dst = do_svis(dst, dlen, c, flag, nextc, extra);
 174         }
 175         return dst;
 176 }
 177
 178 /*
 179  * This is do_vis, the central code of vis.
 180  * dst:       Pointer to the destination buffer
 181  * c:         Character to encode
 182  * flag:      Flag word
 183  * nextc:     The character following 'c'
 184  * extra:     Pointer to the list of extra characters to be
 185  *            backslash-protected.
 186  */
 187 static char *
 188 do_svis(char *dst, size_t *dlen, int c, int flag, int nextc, const char *extra)
 189 {
 190         int isextra;
 191         size_t odlen = dlen ? *dlen : 0;
 192
 193         isextra = strchr(extra, c) != NULL;
 194 #define HAVE(x) \
 195         do { \
 196                 if (dlen) { \
 197                         if (*dlen < (x)) \
 198                                 goto out; \
 199                         *dlen -= (x); \
 200                 } \
 201         } while (/*CONSTCOND*/0)
 202         if (!isextra && isascii(c) && (isgraph(c) || iswhite(c) ||
 203             ((flag & VIS_SAFE) && issafe(c)))) {
 204                 HAVE(1);
 205                 *dst++ = c;
 206                 return dst;
 207         }
 208         if (flag & VIS_CSTYLE) {
 209                 HAVE(2);
 210                 switch (c) {
 211                 case '\n':
 212                         *dst++ = '\\'; *dst++ = 'n';
 213                         return dst;
 214                 case '\r':
 215                         *dst++ = '\\'; *dst++ = 'r';
 216                         return dst;
 217                 case '\b':
 218                         *dst++ = '\\'; *dst++ = 'b';
 219                         return dst;
 220                 case BELL:
 221                         *dst++ = '\\'; *dst++ = 'a';
 222                         return dst;
 223                 case '\v':
 224                         *dst++ = '\\'; *dst++ = 'v';
 225                         return dst;
 226                 case '\t':
 227                         *dst++ = '\\'; *dst++ = 't';
 228                         return dst;
 229                 case '\f':
 230                         *dst++ = '\\'; *dst++ = 'f';
 231                         return dst;
 232                 case ' ':
 233                         *dst++ = '\\'; *dst++ = 's';
 234                         return dst;
 235                 case '\0':
 236                         *dst++ = '\\'; *dst++ = '0';
 237                         if (isoctal(nextc)) {
 238                                 HAVE(2);
 239                                 *dst++ = '0';
 240                                 *dst++ = '0';
 241                         }
 242                         return dst;
 243                 default:
 244                         if (isgraph(c)) {
 245                                 *dst++ = '\\'; *dst++ = c;
 246                                 return dst;
 247                         }
 248                         if (dlen)
 249                                 *dlen = odlen;
 250                 }
 251         }
 252         if (isextra || ((c & 0177) == ' ') || (flag & VIS_OCTAL)) {
 253                 HAVE(4);
 254                 *dst++ = '\\';
 255                 *dst++ = (u_char)(((u_int32_t)(u_char)c >> 6) & 03) + '0';
 256                 *dst++ = (u_char)(((u_int32_t)(u_char)c >> 3) & 07) + '0';
 257                 *dst++ =                             (c       & 07) + '0';
 258         } else {
 259                 if ((flag & VIS_NOSLASH) == 0) {
 260                         HAVE(1);
 261                         *dst++ = '\\';
 262                 }
 263
 264                 if (c & 0200) {
 265                         HAVE(1);
 266                         c &= 0177; *dst++ = 'M';
 267                 }
 268
 269                 if (iscntrl(c)) {
 270                         HAVE(2);
 271                         *dst++ = '^';
 272                         if (c == 0177)
 273                                 *dst++ = '?';
 274                         else
 275                                 *dst++ = c + '@';
 276                 } else {
 277                         HAVE(2);
 278                         *dst++ = '-'; *dst++ = c;
 279                 }
 280         }
 281         return dst;
 282 out:
 283         *dlen = odlen;
 284         return NULL;
 285 }
 286
 287 typedef char *(*visfun_t)(char *, size_t *, int, int, int, const char *);
 288
 289 /*
 290  * Return the appropriate encoding function depending on the flags given.
 291  */
 292 static visfun_t
 293 getvisfun(int flag)
 294 {
 295         if (flag & VIS_HTTPSTYLE)
 296                 return do_hvis;
 297         if (flag & VIS_MIMESTYLE)
 298                 return do_mvis;
 299         return do_svis;
 300 }
 301
 302 /*
 303  * isnvis - visually encode characters, also encoding the characters
 304  *        pointed to by `extra'
 305  */
 306 static char *
 307 isnvis(char *dst, size_t *dlen, int c, int flag, int nextc, const char *extra)
 308 {
 309         char *nextra = NULL;
 310         visfun_t f;
 311
 312         _DIAGASSERT(dst != NULL);
 313         _DIAGASSERT(extra != NULL);
 314         MAKEEXTRALIST(flag, nextra, extra);
 315         if (!nextra) {
 316                 if (dlen && *dlen == 0) {
 317                         errno = ENOSPC;
 318                         return NULL;
 319                 }
 320                 *dst = '\0';            /* can't create nextra, return "" */
 321                 return dst;
 322         }
 323         f = getvisfun(flag);
 324         dst = (*f)(dst, dlen, c, flag, nextc, nextra);
 325         free(nextra);
 326         if (dst == NULL || (dlen && *dlen == 0)) {
 327                 errno = ENOSPC;
 328                 return NULL;
 329         }
 330         *dst = '\0';
 331         return dst;
 332 }
 333
 334 char *
 335 svis(char *dst, int c, int flag, int nextc, const char *extra)
 336 {
 337         return isnvis(dst, NULL, c, flag, nextc, extra);
 338 }
 339
 340 char *
 341 snvis(char *dst, size_t dlen, int c, int flag, int nextc, const char *extra)
 342 {
 343         return isnvis(dst, &dlen, c, flag, nextc, extra);
 344 }
 345
 346
 347 /*
 348  * strsvis, strsvisx - visually encode characters from src into dst
 349  *
 350  *      Extra is a pointer to a \0-terminated list of characters to
 351  *      be encoded, too. These functions are useful e. g. to
 352  *      encode strings in such a way so that they are not interpreted
 353  *      by a shell.
 354  *
 355  *      Dst must be 4 times the size of src to account for possible
 356  *      expansion.  The length of dst, not including the trailing NULL,
 357  *      is returned.
 358  *
 359  *      Strsvisx encodes exactly len bytes from src into dst.
 360  *      This is useful for encoding a block of data.
 361  */
 362 static int
 363 istrsnvis(char *dst, size_t *dlen, const char *csrc, int flag, const char *extra)
 364 {
 365         int c;
 366         char *start;
 367         char *nextra = NULL;
 368         const unsigned char *src = (const unsigned char *)csrc;
 369         visfun_t f;
 370
 371         _DIAGASSERT(dst != NULL);
 372         _DIAGASSERT(src != NULL);
 373         _DIAGASSERT(extra != NULL);
 374         MAKEEXTRALIST(flag, nextra, extra);
 375         if (!nextra) {
 376                 *dst = '\0';            /* can't create nextra, return "" */
 377                 return 0;
 378         }
 379         f = getvisfun(flag);
 380         for (start = dst; (c = *src++) != '\0'; /* empty */) {
 381                 dst = (*f)(dst, dlen, c, flag, *src, nextra);
 382                 if (dst == NULL) {
 383                         errno = ENOSPC;
 384                         return -1;
 385                 }
 386         }
 387         free(nextra);
 388         if (dlen && *dlen == 0) {
 389                 errno = ENOSPC;
 390                 return -1;
 391         }
 392         *dst = '\0';
 393         return (int)(dst - start);
 394 }
 395
 396 int
 397 strsvis(char *dst, const char *csrc, int flag, const char *extra)
 398 {
 399         return istrsnvis(dst, NULL, csrc, flag, extra);
 400 }
 401
 402 int
 403 strsnvis(char *dst, size_t dlen, const char *csrc, int flag, const char *extra)
 404 {
 405         return istrsnvis(dst, &dlen, csrc, flag, extra);
 406 }
 407
 408 static int
 409 istrsnvisx(char *dst, size_t *dlen, const char *csrc, size_t len, int flag,
 410     const char *extra)
 411 {
 412         unsigned char c;
 413         char *start;
 414         char *nextra = NULL;
 415         const unsigned char *src = (const unsigned char *)csrc;
 416         visfun_t f;
 417
 418         _DIAGASSERT(dst != NULL);
 419         _DIAGASSERT(src != NULL);
 420         _DIAGASSERT(extra != NULL);
 421         MAKEEXTRALIST(flag, nextra, extra);
 422         if (! nextra) {
 423                 if (dlen && *dlen == 0) {
 424                         errno = ENOSPC;
 425                         return -1;
 426                 }
 427                 *dst = '\0';            /* can't create nextra, return "" */
 428                 return 0;
 429         }
 430
 431         f = getvisfun(flag);
 432         for (start = dst; len > 0; len--) {
 433                 c = *src++;
 434                 dst = (*f)(dst, dlen, c, flag, len > 1 ? *src : '\0', nextra);
 435                 if (dst == NULL) {
 436                         errno = ENOSPC;
 437                         return -1;
 438                 }
 439         }
 440         free(nextra);
 441         if (dlen && *dlen == 0) {
 442                 errno = ENOSPC;
 443                 return -1;
 444         }
 445         *dst = '\0';
 446         return (int)(dst - start);
 447 }
 448
 449 int
 450 strsvisx(char *dst, const char *csrc, size_t len, int flag, const char *extra)
 451 {
 452         return istrsnvisx(dst, NULL, csrc, len, flag, extra);
 453 }
 454
 455 int
 456 strsnvisx(char *dst, size_t dlen, const char *csrc, size_t len, int flag,
 457     const char *extra)
 458 {
 459         return istrsnvisx(dst, &dlen, csrc, len, flag, extra);
 460 }
 461 #endif
 462
 463 #if !HAVE_VIS
 464 /*
 465  * vis - visually encode characters
 466  */
 467 static char *
 468 invis(char *dst, size_t *dlen, int c, int flag, int nextc)
 469 {
 470         char *extra = NULL;
 471         unsigned char uc = (unsigned char)c;
 472         visfun_t f;
 473
 474         _DIAGASSERT(dst != NULL);
 475
 476         MAKEEXTRALIST(flag, extra, "");
 477         if (! extra) {
 478                 if (dlen && *dlen == 0) {
 479                         errno = ENOSPC;
 480                         return NULL;
 481                 }
 482                 *dst = '\0';            /* can't create extra, return "" */
 483                 return dst;
 484         }
 485         f = getvisfun(flag);
 486         dst = (*f)(dst, dlen, uc, flag, nextc, extra);
 487         free(extra);
 488         if (dst == NULL || (dlen && *dlen == 0)) {
 489                 errno = ENOSPC;
 490                 return NULL;
 491         }
 492         *dst = '\0';
 493         return dst;
 494 }
 495
 496 char *
 497 vis(char *dst, int c, int flag, int nextc)
 498 {
 499         return invis(dst, NULL, c, flag, nextc);
 500 }
 501
 502 char *
 503 nvis(char *dst, size_t dlen, int c, int flag, int nextc)
 504 {
 505         return invis(dst, &dlen, c, flag, nextc);
 506 }
 507
 508
 509 /*
 510  * strvis, strvisx - visually encode characters from src into dst
 511  *
 512  *      Dst must be 4 times the size of src to account for possible
 513  *      expansion.  The length of dst, not including the trailing NULL,
 514  *      is returned.
 515  *
 516  *      Strvisx encodes exactly len bytes from src into dst.
 517  *      This is useful for encoding a block of data.
 518  */
 519 static int
 520 istrnvis(char *dst, size_t *dlen, const char *src, int flag)
 521 {
 522         char *extra = NULL;
 523         int rv;
 524
 525         MAKEEXTRALIST(flag, extra, "");
 526         if (!extra) {
 527                 if (dlen && *dlen == 0) {
 528                         errno = ENOSPC;
 529                         return -1;
 530                 }
 531                 *dst = '\0';            /* can't create extra, return "" */
 532                 return 0;
 533         }
 534         rv = istrsnvis(dst, dlen, src, flag, extra);
 535         free(extra);
 536         return rv;
 537 }
 538
 539 int
 540 strvis(char *dst, const char *src, int flag)
 541 {
 542         return istrnvis(dst, NULL, src, flag);
 543 }
 544
 545 int
 546 strnvis(char *dst, size_t dlen, const char *src, int flag)
 547 {
 548         return istrnvis(dst, &dlen, src, flag);
 549 }
 550
 551 static int
 552 istrnvisx(char *dst, size_t *dlen, const char *src, size_t len, int flag)
 553 {
 554         char *extra = NULL;
 555         int rv;
 556
 557         MAKEEXTRALIST(flag, extra, "");
 558         if (!extra) {
 559                 if (dlen && *dlen == 0) {
 560                         errno = ENOSPC;
 561                         return -1;
 562                 }
 563                 *dst = '\0';            /* can't create extra, return "" */
 564                 return 0;
 565         }
 566         rv = istrsnvisx(dst, dlen, src, len, flag, extra);
 567         free(extra);
 568         return rv;
 569 }
 570
 571 int
 572 strvisx(char *dst, const char *src, size_t len, int flag)
 573 {
 574         return istrnvisx(dst, NULL, src, len, flag);
 575 }
 576
 577 int
 578 strnvisx(char *dst, size_t dlen, const char *src, size_t len, int flag)
 579 {
 580         return istrnvisx(dst, &dlen, src, len, flag);
 581 }
 582
 583 #endif