contrib/file/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 #if defined(HAVE_LIMITS_H)
  40 #include <limits.h>
  41 #endif
  42 #ifndef SIZE_T_MAX
  43 #ifdef __LP64__
  44 #define SIZE_T_MAX (size_t)0xffffffffffffffffU
  45 #else
  46 #define SIZE_T_MAX (size_t)0xffffffffU
  47 #endif
  48 #endif
  49
  50 #ifndef lint
  51 FILE_RCSID("@(#)$File: funcs.c,v 1.35 2007/12/27 16:35:59 christos Exp $")
  52 #endif  /* lint */
  53
  54 #ifndef HAVE_VSNPRINTF
  55 int vsnprintf(char *, size_t, const char *, va_list);
  56 #endif
  57
  58 /*
  59  * Like printf, only we print to a buffer and advance it.
  60  */
  61 protected int
  62 file_printf(struct magic_set *ms, const char *fmt, ...)
  63 {
  64         va_list ap;
  65         size_t size;
  66         ssize_t len;
  67         char *buf;
  68
  69         va_start(ap, fmt);
  70
  71         len = vsnprintf(ms->o.ptr, ms->o.left, fmt, ap);
  72         if (len == -1)
  73                 goto out;
  74         if (len >= (ssize_t)ms->o.left) {
  75                 long diff;      /* XXX: really ptrdiff_t */
  76
  77                 va_end(ap);
  78                 size = (ms->o.size - ms->o.left) + len + 1024;
  79                 if ((buf = realloc(ms->o.buf, size)) == NULL) {
  80                         file_oomem(ms, size);
  81                         return -1;
  82                 }
  83                 diff = ms->o.ptr - ms->o.buf;
  84                 ms->o.ptr = buf + diff;
  85                 ms->o.buf = buf;
  86                 ms->o.left = size - diff;
  87                 ms->o.size = size;
  88
  89                 va_start(ap, fmt);
  90                 len = vsnprintf(ms->o.ptr, ms->o.left, fmt, ap);
  91                 if (len == -1)
  92                         goto out;
  93         }
  94         va_end(ap);
  95         ms->o.ptr += len;
  96         ms->o.left -= len;
  97         return 0;
  98 out:
  99         file_error(ms, errno, "vsnprintf failed");
 100         return -1;
 101 }
 102
 103 /*
 104  * error - print best error message possible
 105  */
 106 /*VARARGS*/
 107 private void
 108 file_error_core(struct magic_set *ms, int error, const char *f, va_list va,
 109     uint32_t lineno)
 110 {
 111         size_t len;
 112         /* Only the first error is ok */
 113         if (ms->haderr)
 114                 return;
 115         len = 0;
 116         if (lineno != 0) {
 117                 (void)snprintf(ms->o.buf, ms->o.size, "line %u: ", lineno);
 118                 len = strlen(ms->o.buf);
 119         }
 120         (void)vsnprintf(ms->o.buf + len, ms->o.size - len, f, va);
 121         if (error > 0) {
 122                 len = strlen(ms->o.buf);
 123                 (void)snprintf(ms->o.buf + len, ms->o.size - len, " (%s)",
 124                     strerror(error));
 125         }
 126         ms->haderr++;
 127         ms->error = error;
 128 }
 129
 130 /*VARARGS*/
 131 protected void
 132 file_error(struct magic_set *ms, int error, const char *f, ...)
 133 {
 134         va_list va;
 135         va_start(va, f);
 136         file_error_core(ms, error, f, va, 0);
 137         va_end(va);
 138 }
 139
 140 /*
 141  * Print an error with magic line number.
 142  */
 143 /*VARARGS*/
 144 protected void
 145 file_magerror(struct magic_set *ms, const char *f, ...)
 146 {
 147         va_list va;
 148         va_start(va, f);
 149         file_error_core(ms, 0, f, va, ms->line);
 150         va_end(va);
 151 }
 152
 153 protected void
 154 file_oomem(struct magic_set *ms, size_t len)
 155 {
 156         file_error(ms, errno, "cannot allocate %zu bytes", len);
 157 }
 158
 159 protected void
 160 file_badseek(struct magic_set *ms)
 161 {
 162         file_error(ms, errno, "error seeking");
 163 }
 164
 165 protected void
 166 file_badread(struct magic_set *ms)
 167 {
 168         file_error(ms, errno, "error reading");
 169 }
 170
 171 #ifndef COMPILE_ONLY
 172 protected int
 173 file_buffer(struct magic_set *ms, int fd, const char *inname, const void *buf,
 174     size_t nb)
 175 {
 176         int m;
 177         int mime = ms->flags & MAGIC_MIME;
 178
 179         if (nb == 0) {
 180                 if ((!mime || (mime & MAGIC_MIME_TYPE)) &&
 181                     file_printf(ms, mime ? "application/x-empty" :
 182                     "empty") == -1)
 183                         return -1;
 184                 return 1;
 185         } else if (nb == 1) {
 186                 if ((!mime || (mime & MAGIC_MIME_TYPE)) &&
 187                     file_printf(ms, mime ?  "application/octet-stream" :
 188                     "very short file (no magic)") == -1)
 189                         return -1;
 190                 return 1;
 191         }
 192
 193 #ifdef __EMX__
 194         if ((ms->flags & MAGIC_NO_CHECK_APPTYPE) == 0 && inname) {
 195                 switch (file_os2_apptype(ms, inname, buf, nb)) {
 196                 case -1:
 197                         return -1;
 198                 case 0:
 199                         break;
 200                 default:
 201                         return 1;
 202                 }
 203         }
 204 #endif
 205
 206         /* try compression stuff */
 207         if ((ms->flags & MAGIC_NO_CHECK_COMPRESS) != 0 ||
 208             (m = file_zmagic(ms, fd, inname, buf, nb)) == 0) {
 209             /* Check if we have a tar file */
 210             if ((ms->flags & MAGIC_NO_CHECK_TAR) != 0 ||
 211                 (m = file_is_tar(ms, buf, nb)) == 0) {
 212                 /* try tests in /etc/magic (or surrogate magic file) */
 213                 if ((ms->flags & MAGIC_NO_CHECK_SOFT) != 0 ||
 214                     (m = file_softmagic(ms, buf, nb)) == 0) {
 215                     /* try known keywords, check whether it is ASCII */
 216                     if ((ms->flags & MAGIC_NO_CHECK_ASCII) != 0 ||
 217                         (m = file_ascmagic(ms, buf, nb)) == 0) {
 218                         /* abandon hope, all ye who remain here */
 219                         if ((!mime || (mime & MAGIC_MIME_TYPE)) &&
 220                             file_printf(ms, mime ?  "application/octet-stream" :
 221                                 "data") == -1)
 222                                 return -1;
 223                         m = 1;
 224                     }
 225                 }
 226             }
 227         }
 228 #ifdef BUILTIN_ELF
 229         if ((ms->flags & MAGIC_NO_CHECK_ELF) == 0 && m == 1 &&
 230             nb > 5 && fd != -1) {
 231                 /*
 232                  * We matched something in the file, so this *might*
 233                  * be an ELF file, and the file is at least 5 bytes
 234                  * long, so if it's an ELF file it has at least one
 235                  * byte past the ELF magic number - try extracting
 236                  * information from the ELF headers that cannot easily
 237                  * be extracted with rules in the magic file.
 238                  */
 239                 (void)file_tryelf(ms, fd, buf, nb);
 240         }
 241 #endif
 242         return m;
 243 }
 244 #endif
 245
 246 protected int
 247 file_reset(struct magic_set *ms)
 248 {
 249         if (ms->mlist == NULL) {
 250                 file_error(ms, 0, "no magic files loaded");
 251                 return -1;
 252         }
 253         ms->o.ptr = ms->o.buf;
 254         ms->o.left = ms->o.size;
 255         ms->haderr = 0;
 256         ms->error = -1;
 257         return 0;
 258 }
 259
 260 #define OCTALIFY(n, o)  \
 261         /*LINTED*/ \
 262         (void)(*(n)++ = '\\', \
 263         *(n)++ = (((uint32_t)*(o) >> 6) & 3) + '0', \
 264         *(n)++ = (((uint32_t)*(o) >> 3) & 7) + '0', \
 265         *(n)++ = (((uint32_t)*(o) >> 0) & 7) + '0', \
 266         (o)++)
 267
 268 protected const char *
 269 file_getbuffer(struct magic_set *ms)
 270 {
 271         char *pbuf, *op, *np;
 272         size_t psize, len;
 273
 274         if (ms->haderr)
 275                 return NULL;
 276
 277         if (ms->flags & MAGIC_RAW)
 278                 return ms->o.buf;
 279
 280         len = ms->o.size - ms->o.left;
 281         /* * 4 is for octal representation, + 1 is for NUL */
 282         if (len > (SIZE_T_MAX - 1) / 4) {
 283                 file_oomem(ms, len);
 284                 return NULL;
 285         }
 286         psize = len * 4 + 1;
 287         if (ms->o.psize < psize) {
 288                 if ((pbuf = realloc(ms->o.pbuf, psize)) == NULL) {
 289                         file_oomem(ms, psize);
 290                         return NULL;
 291                 }
 292                 ms->o.psize = psize;
 293                 ms->o.pbuf = pbuf;
 294         }
 295
 296 #if defined(HAVE_WCHAR_H) && defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH)
 297         {
 298                 mbstate_t state;
 299                 wchar_t nextchar;
 300                 int mb_conv = 1;
 301                 size_t bytesconsumed;
 302                 char *eop;
 303                 (void)memset(&state, 0, sizeof(mbstate_t));
 304
 305                 np = ms->o.pbuf;
 306                 op = ms->o.buf;
 307                 eop = op + strlen(ms->o.buf);
 308
 309                 while (op < eop) {
 310                         bytesconsumed = mbrtowc(&nextchar, op,
 311                             (size_t)(eop - op), &state);
 312                         if (bytesconsumed == (size_t)(-1) ||
 313                             bytesconsumed == (size_t)(-2)) {
 314                                 mb_conv = 0;
 315                                 break;
 316                         }
 317
 318                         if (iswprint(nextchar)) {
 319                                 (void)memcpy(np, op, bytesconsumed);
 320                                 op += bytesconsumed;
 321                                 np += bytesconsumed;
 322                         } else {
 323                                 while (bytesconsumed-- > 0)
 324                                         OCTALIFY(np, op);
 325                         }
 326                 }
 327                 *np = '\0';
 328
 329                 /* Parsing succeeded as a multi-byte sequence */
 330                 if (mb_conv != 0)
 331                         return ms->o.pbuf;
 332         }
 333 #endif
 334
 335         for (np = ms->o.pbuf, op = ms->o.buf; *op; op++) {
 336                 if (isprint((unsigned char)*op)) {
 337                         *np++ = *op;
 338                 } else {
 339                         OCTALIFY(np, op);
 340                 }
 341         }
 342         *np = '\0';
 343         return ms->o.pbuf;
 344 }
 345
 346 protected int
 347 file_check_mem(struct magic_set *ms, unsigned int level)
 348 {
 349         size_t len;
 350
 351         if (level >= ms->c.len) {
 352                 len = (ms->c.len += 20) * sizeof(*ms->c.li);
 353                 ms->c.li = (ms->c.li == NULL) ? malloc(len) :
 354                     realloc(ms->c.li, len);
 355                 if (ms->c.li == NULL) {
 356                         file_oomem(ms, len);
 357                         return -1;
 358                 }
 359         }
 360         ms->c.li[level].got_match = 0;
 361 #ifdef ENABLE_CONDITIONALS
 362         ms->c.li[level].last_match = 0;
 363         ms->c.li[level].last_cond = COND_NONE;
 364 #endif /* ENABLE_CONDITIONALS */
 365         return 0;
 366 }
 367 /*
 368  * Yes these wrappers suffer from buffer overflows, but if your OS does not
 369  * have the real functions, maybe you should consider replacing your OS?
 370  */
 371 #ifndef HAVE_VSNPRINTF
 372 int
 373 vsnprintf(char *buf, size_t len, const char *fmt, va_list ap)
 374 {
 375         return vsprintf(buf, fmt, ap);
 376 }
 377 #endif
 378
 379 #ifndef HAVE_SNPRINTF
 380 /*ARGSUSED*/
 381 int
 382 snprintf(char *buf, size_t len, const char *fmt, ...)
 383 {
 384         int rv;
 385         va_list ap;
 386         va_start(ap, fmt);
 387         rv = vsprintf(buf, fmt, ap);
 388         va_end(ap);
 389         return rv;
 390 }
 391 #endif