bin/ls/util.c

   1 /*
   2  * Copyright (c) 1989, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Michael Fischbein.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 4. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * @(#)util.c   8.3 (Berkeley) 4/2/94
  33  * $FreeBSD: src/bin/ls/util.c,v 1.35 2004/05/03 11:48:55 tjr Exp $
  34  * $DragonFly: src/bin/ls/util.c,v 1.7 2005/09/18 18:35:23 asmodai Exp $
  35  */
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39
  40 #include <ctype.h>
  41 #include <err.h>
  42 #include <fts.h>
  43 #include <limits.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <wchar.h>
  48 #include <wctype.h>
  49
  50 #include "ls.h"
  51 #include "extern.h"
  52
  53 int
  54 prn_normal(const char *s)
  55 {
  56         mbstate_t mbs;
  57         wchar_t wc;
  58         int i, n;
  59         size_t clen;
  60
  61         memset(&mbs, 0, sizeof(mbs));
  62         n = 0;
  63         while ((clen = mbrtowc(&wc, s, MB_LEN_MAX, &mbs)) != 0) {
  64                 if (clen == (size_t)-2) {
  65                         n += printf("%s", s);
  66                         break;
  67                 }
  68                 if (clen == (size_t)-1) {
  69                         memset(&mbs, 0, sizeof(mbs));
  70                         putchar((unsigned char)*s);
  71                         s++;
  72                         n++;
  73                         continue;
  74                 }
  75                 for (i = 0; i < (int)clen; i++)
  76                         putchar((unsigned char)s[i]);
  77                 s += clen;
  78                 if (iswprint(wc))
  79                         n += wcwidth(wc);
  80         }
  81         return (n);
  82 }
  83
  84 int
  85 prn_printable(const char *s)
  86 {
  87         mbstate_t mbs;
  88         wchar_t wc;
  89         int i, n;
  90         size_t clen;
  91
  92         memset(&mbs, 0, sizeof(mbs));
  93         n = 0;
  94         while ((clen = mbrtowc(&wc, s, MB_LEN_MAX, &mbs)) != 0) {
  95                 if (clen == (size_t)-1) {
  96                         putchar('?');
  97                         s++;
  98                         n++;
  99                         memset(&mbs, 0, sizeof(mbs));
 100                         continue;
 101                 }
 102                 if (clen == (size_t)-2) {
 103                         putchar('?');
 104                         n++;
 105                         break;
 106                 }
 107                 if (!iswprint(wc)) {
 108                         putchar('?');
 109                         s += clen;
 110                         n++;
 111                         continue;
 112                 }
 113                 for (i = 0; i < (int)clen; i++)
 114                         putchar((unsigned char)s[i]);
 115                 s += clen;
 116                 n += wcwidth(wc);
 117         }
 118         return (n);
 119 }
 120
 121 /*
 122  * The fts system makes it difficult to replace fts_name with a different-
 123  * sized string, so we just calculate the real length here and do the
 124  * conversion in prn_octal()
 125  *
 126  * XXX when using f_octal_escape (-b) rather than f_octal (-B), the
 127  * length computed by len_octal may be too big. I just can't be buggered
 128  * to fix this as an efficient fix would involve a lookup table. Same goes
 129  * for the rather inelegant code in prn_octal.
 130  *
 131  *                                              DES 1998/04/23
 132  */
 133
 134 size_t
 135 len_octal(const char *s, int len)
 136 {
 137         mbstate_t mbs;
 138         wchar_t wc;
 139         size_t clen, r;
 140
 141         memset(&mbs, 0, sizeof(mbs));
 142         r = 0;
 143         while (len != 0 && (clen = mbrtowc(&wc, s, len, &mbs)) != 0) {
 144                 if (clen == (size_t)-1) {
 145                         r += 4;
 146                         s++;
 147                         len--;
 148                         memset(&mbs, 0, sizeof(mbs));
 149                         continue;
 150                 }
 151                 if (clen == (size_t)-2) {
 152                         r += 4 * len;
 153                         break;
 154                 }
 155                 if (iswprint(wc))
 156                         r++;
 157                 else
 158                         r += 4 * clen;
 159                 s += clen;
 160         }
 161         return (r);
 162 }
 163
 164 int
 165 prn_octal(const char *s)
 166 {
 167         static const char esc[] = "\\\\\"\"\aa\bb\ff\nn\rr\tt\vv";
 168         const char *p;
 169         mbstate_t mbs;
 170         wchar_t wc;
 171         size_t clen;
 172         unsigned char ch;
 173         int goodchar, i, len, prtlen;
 174
 175         memset(&mbs, 0, sizeof(mbs));
 176         len = 0;
 177         while ((clen = mbrtowc(&wc, s, MB_LEN_MAX, &mbs)) != 0) {
 178                 goodchar = clen != (size_t)-1 && clen != (size_t)-2;
 179                 if (goodchar && iswprint(wc) && wc != L'\"' && wc != L'\\') {
 180                          for (i = 0; i < (int)clen; i++)
 181                                  putchar((unsigned char)s[i]);
 182                          len += wcwidth(wc);
 183                 } else if (goodchar && f_octal_escape && wc >= 0 &&
 184                     wc <= (wchar_t)UCHAR_MAX &&
 185                     (p = strchr(esc, (char)wc)) != NULL) {
 186                         putchar('\\');
 187                         putchar(p[1]);
 188                         len += 2;
 189                 } else {
 190                         if (goodchar)
 191                                 prtlen = clen;
 192                         else if (clen == (size_t)-1)
 193                                 prtlen = 1;
 194                         else
 195                                 prtlen = strlen(s);
 196                         for (i = 0; i < prtlen; i++) {
 197                                 ch = (unsigned char)s[i];
 198                                 putchar('\\');
 199                                 putchar('0' + (ch >> 6));
 200                                 putchar('0' + ((ch >> 3) & 7));
 201                                 putchar('0' + (ch & 7));
 202                                 len += 4;
 203                         }
 204                 }
 205                 if (clen == (size_t)-2)
 206                         break;
 207                 if (clen == (size_t)-1) {
 208                         memset(&mbs, 0, sizeof(mbs));
 209                         s++;
 210                 } else
 211                         s += clen;
 212         }
 213         return (len);
 214 }
 215
 216 void
 217 usage(void)
 218 {
 219         fprintf(stderr,
 220 #ifdef COLORLS
 221         "usage: ls [-ABCFGHLPRTWabcdfghiklmnoqrstuwxy1]"
 222 #else
 223         "usage: ls [-ABCFHLPRTWabcdfghiklmnoqrstuwxy1]"
 224 #endif
 225                       " [file ...]\n");
 226         exit(1);
 227 }