[BACK]Return to magic.h CVS log [TXT][DIR] Up to [local] / src / usr.bin / file

Annotation of src/usr.bin/file/magic.h, Revision 1.11

1.11    ! nicm        1: /* $OpenBSD: magic.h,v 1.10 2015/10/05 19:50:38 nicm Exp $ */
1.5       nicm        2:
1.1       tedu        3: /*
1.5       nicm        4:  * Copyright (c) 2015 Nicholas Marriott <nicm@openbsd.org>
                      5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
                      7:  * purpose with or without fee is hereby granted, provided that the above
                      8:  * copyright notice and this permission notice appear in all copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     11:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     12:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     13:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     14:  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
                     15:  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
                     16:  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.1       tedu       17:  */
                     18:
1.5       nicm       19: #ifndef MAGIC_H
                     20: #define MAGIC_H
                     21:
                     22: #include <sys/tree.h>
                     23: #include <sys/queue.h>
                     24: #include <sys/stat.h>
                     25:
                     26: #include <err.h>
                     27: #include <regex.h>
                     28: #include <stdio.h>
1.7       nicm       29: #include <stdarg.h>
1.5       nicm       30: #include <stdlib.h>
                     31: #include <string.h>
                     32:
                     33: #define MAGIC_STRING_SIZE 31
1.6       nicm       34: #define MAGIC_STRENGTH_MULTIPLIER 10
1.5       nicm       35:
                     36: enum magic_type {
                     37:        MAGIC_TYPE_NONE = 0,
                     38:        MAGIC_TYPE_BYTE,
                     39:        MAGIC_TYPE_SHORT,
                     40:        MAGIC_TYPE_LONG,
                     41:        MAGIC_TYPE_QUAD,
                     42:        MAGIC_TYPE_UBYTE,
                     43:        MAGIC_TYPE_USHORT,
                     44:        MAGIC_TYPE_ULONG,
                     45:        MAGIC_TYPE_UQUAD,
                     46:        MAGIC_TYPE_FLOAT,
                     47:        MAGIC_TYPE_DOUBLE,
                     48:        MAGIC_TYPE_STRING,
                     49:        MAGIC_TYPE_PSTRING,
                     50:        MAGIC_TYPE_DATE,
                     51:        MAGIC_TYPE_QDATE,
                     52:        MAGIC_TYPE_LDATE,
                     53:        MAGIC_TYPE_QLDATE,
                     54:        MAGIC_TYPE_UDATE,
                     55:        MAGIC_TYPE_UQDATE,
                     56:        MAGIC_TYPE_ULDATE,
                     57:        MAGIC_TYPE_UQLDATE,
                     58:        MAGIC_TYPE_BESHORT,
                     59:        MAGIC_TYPE_BELONG,
                     60:        MAGIC_TYPE_BEQUAD,
                     61:        MAGIC_TYPE_UBESHORT,
                     62:        MAGIC_TYPE_UBELONG,
                     63:        MAGIC_TYPE_UBEQUAD,
                     64:        MAGIC_TYPE_BEFLOAT,
                     65:        MAGIC_TYPE_BEDOUBLE,
                     66:        MAGIC_TYPE_BEDATE,
                     67:        MAGIC_TYPE_BEQDATE,
                     68:        MAGIC_TYPE_BELDATE,
                     69:        MAGIC_TYPE_BEQLDATE,
                     70:        MAGIC_TYPE_UBEDATE,
                     71:        MAGIC_TYPE_UBEQDATE,
                     72:        MAGIC_TYPE_UBELDATE,
                     73:        MAGIC_TYPE_UBEQLDATE,
                     74:        MAGIC_TYPE_BESTRING16,
                     75:        MAGIC_TYPE_LESHORT,
                     76:        MAGIC_TYPE_LELONG,
                     77:        MAGIC_TYPE_LEQUAD,
                     78:        MAGIC_TYPE_ULESHORT,
                     79:        MAGIC_TYPE_ULELONG,
                     80:        MAGIC_TYPE_ULEQUAD,
                     81:        MAGIC_TYPE_LEFLOAT,
                     82:        MAGIC_TYPE_LEDOUBLE,
                     83:        MAGIC_TYPE_LEDATE,
                     84:        MAGIC_TYPE_LEQDATE,
                     85:        MAGIC_TYPE_LELDATE,
                     86:        MAGIC_TYPE_LEQLDATE,
                     87:        MAGIC_TYPE_ULEDATE,
                     88:        MAGIC_TYPE_ULEQDATE,
                     89:        MAGIC_TYPE_ULELDATE,
                     90:        MAGIC_TYPE_ULEQLDATE,
                     91:        MAGIC_TYPE_LESTRING16,
                     92:        MAGIC_TYPE_MELONG,
                     93:        MAGIC_TYPE_MEDATE,
                     94:        MAGIC_TYPE_MELDATE,
                     95:        MAGIC_TYPE_REGEX,
                     96:        MAGIC_TYPE_SEARCH,
                     97:        MAGIC_TYPE_DEFAULT,
                     98: };
                     99:
                    100: TAILQ_HEAD(magic_lines, magic_line);
                    101: RB_HEAD(magic_tree, magic_line);
                    102:
                    103: struct magic_line {
                    104:        struct magic            *root;
                    105:        u_int                    line;
                    106:        u_int                    strength;
                    107:        struct magic_line       *parent;
1.11    ! nicm      108:
        !           109:        char                     strength_operator;
        !           110:        u_int                    strength_value;
1.5       nicm      111:
                    112:        int                      text;
                    113:
                    114:        int64_t                  offset;
                    115:        int                      offset_relative;
                    116:
                    117:        char                     indirect_type;
                    118:        int                      indirect_relative;
                    119:        int64_t                  indirect_offset;
                    120:        char                     indirect_operator;
                    121:        int64_t                  indirect_operand;
                    122:
                    123:        enum magic_type          type;
                    124:        const char              *type_string;
                    125:        char                     type_operator;
                    126:        int64_t                  type_operand;
                    127:
                    128:        char                     test_operator;
                    129:        int                      test_not;
                    130:        const char              *test_string;
                    131:        size_t                   test_string_size;
                    132:        uint64_t                 test_unsigned;
                    133:        int64_t                  test_signed;
1.8       nicm      134:        double                   test_double;
1.5       nicm      135:
                    136:        int                      stringify;
                    137:        const char              *result;
                    138:        const char              *mimetype;
                    139:
                    140:        struct magic_lines       children;
                    141:        TAILQ_ENTRY(magic_line)  entry;
                    142:        RB_ENTRY(magic_line)     node;
                    143: };
1.1       tedu      144:
1.5       nicm      145: struct magic {
                    146:        const char              *path;
                    147:        int                      warnings;
                    148:
                    149:        struct magic_tree        tree;
                    150:
                    151:        int                      compiled;
                    152:        regex_t                  format_short;
                    153:        regex_t                  format_long;
                    154:        regex_t                  format_quad;
                    155:        regex_t                  format_float;
                    156:        regex_t                  format_string;
                    157: };
1.1       tedu      158:
1.5       nicm      159: struct magic_state {
                    160:        char                     out[4096];
                    161:        const char              *mimetype;
                    162:        int                      text;
                    163:
                    164:        const char              *base;
                    165:        size_t                   size;
1.10      nicm      166:        size_t                   offset;
1.1       tedu      167: };
                    168:
1.5       nicm      169: #define MAGIC_TEST_TEXT 0x1
                    170: #define MAGIC_TEST_MIME 0x2
                    171:
                    172: int             magic_compare(struct magic_line *, struct magic_line *);
                    173: RB_PROTOTYPE(magic_tree, magic_line, node, magic_compare);
                    174:
                    175: char           *magic_strtoull(const char *, uint64_t *);
                    176: char           *magic_strtoll(const char *, int64_t *);
1.7       nicm      177: void            magic_vwarnm(struct magic *, u_int, const char *, va_list);
                    178: void            magic_warnm(struct magic *, u_int, const char *, ...)
                    179:                     __attribute__ ((format (printf, 3, 4)));
1.5       nicm      180: void            magic_warn(struct magic_line *, const char *, ...)
                    181:                     __attribute__ ((format (printf, 2, 3)));
                    182:
                    183: void            magic_dump(struct magic *);
                    184: struct magic   *magic_load(FILE *, const char *, int);
                    185: const char     *magic_test(struct magic *, const void *, size_t, int);
                    186:
                    187: #endif /* MAGIC_H */