contrib/file-4/src/funcs.c

   1 /*
   2  * Copyright (c) Christos Zoulas 2003.
   3  * All Rights Reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice immediately at the beginning of the file, without modification,
  10  *    this list of conditions, and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  19  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27 #include "file.h"
  28 #include "magic.h"
  29 #include <stdarg.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #if defined(HAVE_WCHAR_H)
  34 #include <wchar.h>
  35 #endif
  36 #if defined(HAVE_WCTYPE_H)
  37 #include <wctype.h>
  38 #endif
  39
  40 #ifndef lint
  41 FILE_RCSID("@(#)$Id: funcs.c,v 1.23 2006/12/11 21:48:49 christos Exp $")
  42 #endif  /* lint */
  43
  44 #ifndef HAVE_VSNPRINTF
  45 int vsnprintf(char *, size_t, const char *, va_list);
  46 #endif
  47
  48 /*
  49  * Like printf, only we print to a buffer and advance it.
  50  */
  51 protected int
  52 file_printf(struct magic_set *ms, const char *fmt, ...)
  53 {
  54         va_list ap;
  55         size_t len;
  56         char *buf;
  57
  58         va_start(ap, fmt);
  59
  60         if ((len = vsnprintf(ms->o.ptr, ms->o.len, fmt, ap)) >= ms->o.len) {
  61                 va_end(ap);
  62                 if ((buf = realloc(ms->o.buf, len + 1024)) == NULL) {
  63                         file_oomem(ms, len + 1024);
  64                         return -1;
  65                 }
  66                 ms->o.ptr = buf + (ms->o.ptr - ms->o.buf);
  67                 ms->o.buf = buf;
  68                 ms->o.len = ms->o.size - (ms->o.ptr - ms->o.buf);
  69                 ms->o.size = len + 1024;
  70
  71                 va_start(ap, fmt);
  72                 len = vsnprintf(ms->o.ptr, ms->o.len, fmt, ap);
  73         }
  74         ms->o.ptr += len;
  75         ms->o.len -= len;
  76         va_end(ap);
  77         return 0;
  78 }
  79
  80 /*
  81  * error - print best error message possible
  82  */
  83 /*VARARGS*/
  84 protected void
  85 file_error(struct magic_set *ms, int error, const char *f, ...)
  86 {
  87         va_list va;
  88         /* Only the first error is ok */
  89         if (ms->haderr)
  90                 return;
  91         va_start(va, f);
  92         (void)vsnprintf(ms->o.buf, ms->o.size, f, va);
  93         va_end(va);
  94         if (error > 0) {
  95                 size_t len = strlen(ms->o.buf);
  96                 (void)snprintf(ms->o.buf + len, ms->o.size - len, " (%s)",
  97                     strerror(error));
  98         }
  99         ms->haderr++;
 100         ms->error = error;
 101 }
 102
 103
 104 protected void
 105 file_oomem(struct magic_set *ms, size_t len)
 106 {
 107         file_error(ms, errno, "cannot allocate %zu bytes", len);
 108 }
 109
 110 protected void
 111 file_badseek(struct magic_set *ms)
 112 {
 113         file_error(ms, errno, "error seeking");
 114 }
 115
 116 protected void
 117 file_badread(struct magic_set *ms)
 118 {
 119         file_error(ms, errno, "error reading");
 120 }
 121
 122 #ifndef COMPILE_ONLY
 123 protected int
 124 file_buffer(struct magic_set *ms, int fd, const void *buf, size_t nb)
 125 {
 126     int m;
 127     /* try compression stuff */
 128     if ((m = file_zmagic(ms, fd, buf, nb)) == 0) {
 129         /* Check if we have a tar file */
 130         if ((m = file_is_tar(ms, buf, nb)) == 0) {
 131             /* try tests in /etc/magic (or surrogate magic file) */
 132             if ((m = file_softmagic(ms, buf, nb)) == 0) {
 133                 /* try known keywords, check whether it is ASCII */
 134                 if ((m = file_ascmagic(ms, buf, nb)) == 0) {
 135                     /* abandon hope, all ye who remain here */
 136                     if (file_printf(ms, ms->flags & MAGIC_MIME ?
 137                         (nb ? "application/octet-stream" :
 138                             "application/empty") :
 139                         (nb ? "data" :
 140                             "empty")) == -1)
 141                             return -1;
 142                     m = 1;
 143                 }
 144             }
 145         }
 146     }
 147     return m;
 148 }
 149 #endif
 150
 151 protected int
 152 file_reset(struct magic_set *ms)
 153 {
 154         if (ms->mlist == NULL) {
 155                 file_error(ms, 0, "no magic files loaded");
 156                 return -1;
 157         }
 158         ms->o.ptr = ms->o.buf;
 159         ms->haderr = 0;
 160         ms->error = -1;
 161         return 0;
 162 }
 163
 164 #define OCTALIFY(n, o)  \
 165         /*LINTED*/ \
 166         (void)(*(n)++ = '\\', \
 167         *(n)++ = (((uint32_t)*(o) >> 6) & 3) + '0', \
 168         *(n)++ = (((uint32_t)*(o) >> 3) & 7) + '0', \
 169         *(n)++ = (((uint32_t)*(o) >> 0) & 7) + '0', \
 170         (o)++)
 171
 172 protected const char *
 173 file_getbuffer(struct magic_set *ms)
 174 {
 175         char *nbuf, *op, *np;
 176         size_t nsize;
 177
 178         if (ms->haderr)
 179                 return NULL;
 180
 181         if (ms->flags & MAGIC_RAW)
 182                 return ms->o.buf;
 183
 184         nsize = ms->o.len * 4 + 1;
 185         if (ms->o.psize < nsize) {
 186                 if ((nbuf = realloc(ms->o.pbuf, nsize)) == NULL) {
 187                         file_oomem(ms, nsize);
 188                         return NULL;
 189                 }
 190                 ms->o.psize = nsize;
 191                 ms->o.pbuf = nbuf;
 192         }
 193
 194 #if defined(HAVE_WCHAR_H) && defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH)
 195         {
 196                 mbstate_t state;
 197                 wchar_t nextchar;
 198                 int mb_conv = 1;
 199                 size_t bytesconsumed;
 200                 char *eop;
 201                 (void)memset(&state, 0, sizeof(mbstate_t));
 202
 203                 np = ms->o.pbuf;
 204                 op = ms->o.buf;
 205                 eop = op + strlen(ms->o.buf);
 206
 207                 while (op < eop) {
 208                         bytesconsumed = mbrtowc(&nextchar, op,
 209                             (size_t)(eop - op), &state);
 210                         if (bytesconsumed == (size_t)(-1) ||
 211                             bytesconsumed == (size_t)(-2)) {
 212                                 mb_conv = 0;
 213                                 break;
 214                         }
 215
 216                         if (iswprint(nextchar)) {
 217                                 (void)memcpy(np, op, bytesconsumed);
 218                                 op += bytesconsumed;
 219                                 np += bytesconsumed;
 220                         } else {
 221                                 while (bytesconsumed-- > 0)
 222                                         OCTALIFY(np, op);
 223                         }
 224                 }
 225                 *np = '\0';
 226
 227                 /* Parsing succeeded as a multi-byte sequence */
 228                 if (mb_conv != 0)
 229                         return ms->o.pbuf;
 230         }
 231 #endif
 232
 233         for (np = ms->o.pbuf, op = ms->o.buf; *op; op++) {
 234                 if (isprint((unsigned char)*op)) {
 235                         *np++ = *op;
 236                 } else {
 237                         OCTALIFY(np, op);
 238                 }
 239         }
 240         *np = '\0';
 241         return ms->o.pbuf;
 242 }
 243
 244 /*
 245  * Yes these wrappers suffer from buffer overflows, but if your OS does not have
 246  * the real functions, maybe you should consider replacing your OS?
 247  */
 248 #ifndef HAVE_VSNPRINTF
 249 int
 250 vsnprintf(char *buf, size_t len, const char *fmt, va_list ap)
 251 {
 252         return vsprintf(buf, fmt, ap);
 253 }
 254 #endif
 255
 256 #ifndef HAVE_SNPRINTF
 257 /*ARGSUSED*/
 258 int
 259 snprintf(char *buf, size_t len, const char *fmt, ...)
 260 {
 261         int rv;
 262         va_list ap;
 263         va_start(ap, fmt);
 264         rv = vsprintf(buf, fmt, ap);
 265         va_end(ap);
 266         return rv;
 267 }
 268 #endif