summaryrefslogtreecommitdiffstats
path: root/wiretap/ruby_marshal.c
blob: 026f7b65966f379be1bf4def5655c22128af1e5c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/* ruby_marshal.c
 *
 * Routines for reading a binary file containing a ruby marshal object
 *
 * Copyright 2018, Dario Lombardo <lomato@gmail.com>
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "config.h"

#include <string.h>

#include "wtap-int.h"
#include "file_wrappers.h"

#include "ruby_marshal.h"

static int ruby_marshal_file_type_subtype = -1;

void register_ruby_marshal(void);

static gboolean is_ruby_marshal(const guint8* filebuf)
{
    if (filebuf[0] != RUBY_MARSHAL_MAJOR)
        return FALSE;
    if (filebuf[1] != RUBY_MARSHAL_MINOR)
        return FALSE;
    switch (filebuf[2]) {
        case '0':
        case 'T':
        case 'F':
        case 'i':
        case ':':
        case '"':
        case 'I':
        case '[':
        case '{':
        case 'f':
        case 'c':
        case 'm':
        case 'S':
        case '/':
        case 'o':
        case 'C':
        case 'e':
        case ';':
        case '@':
            return TRUE;
            break;
        default:
            return FALSE;
    }
}

wtap_open_return_val ruby_marshal_open(wtap *wth, int *err, gchar **err_info)
{
    /* The size of this buffer should match the expectations of is_ruby_marshal */
    guint8 filebuf[3];
    int bytes_read;

    bytes_read = file_read(filebuf, sizeof(filebuf), wth->fh);
    if (bytes_read < 0) {
        /* Read error. */
        *err = file_error(wth->fh, err_info);
        return WTAP_OPEN_ERROR;
    }

    if (bytes_read != sizeof(filebuf) || !is_ruby_marshal(filebuf)) {
        return WTAP_OPEN_NOT_MINE;
    }

    if (file_seek(wth->fh, 0, SEEK_SET, err) == -1) {
        return WTAP_OPEN_ERROR;
    }

    wth->file_type_subtype = ruby_marshal_file_type_subtype;
    wth->file_encap = WTAP_ENCAP_RUBY_MARSHAL;
    wth->file_tsprec = WTAP_TSPREC_SEC;
    wth->subtype_read = wtap_full_file_read;
    wth->subtype_seek_read = wtap_full_file_seek_read;
    wth->snapshot_length = 0;

    return WTAP_OPEN_MINE;
}

static const struct supported_block_type ruby_marshal_blocks_supported[] = {
    /*
     * We support packet blocks, with no comments or other options.
     */
    { WTAP_BLOCK_PACKET, MULTIPLE_BLOCKS_SUPPORTED, NO_OPTIONS_SUPPORTED }
};

static const struct file_type_subtype_info ruby_marshal_info = {
    "Ruby marshal files", "ruby_marshal", NULL, NULL,
    FALSE, BLOCKS_SUPPORTED(ruby_marshal_blocks_supported),
    NULL, NULL, NULL
};

void register_ruby_marshal(void)
{
    ruby_marshal_file_type_subtype = wtap_register_file_type_subtype(&ruby_marshal_info);

    /*
     * Register name for backwards compatibility with the
     * wtap_filetypes table in Lua.
     */
    wtap_register_backwards_compatibility_lua_name("RUBY_MARSHAL",
                                                   ruby_marshal_file_type_subtype);
}

/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 4
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * vi: set shiftwidth=4 tabstop=8 expandtab:
 * :indentSize=4:tabSize=8:noTabs=true:
 */