wtap_module.h

Go to the documentation of this file.

 
#ifndef __WTAP_MODULE_H__
#define __WTAP_MODULE_H__
 
#include "wtap.h"
 
#include "wtap_opttypes.h"
 
#include <wsutil/file_util.h>

WS_DLL_PUBLIC
int wtap_fstat(wtap *wth, ws_statb64 *statb, int *err);

typedef bool (*subtype_read_func)(struct wtap* wtap, wtap_rec* rec,
                                  int* err, char** err_info, int64_t* offset);

typedef bool (*subtype_seek_read_func)(struct wtap* wtap, int64_t seek_off, wtap_rec* rec,
                                       int* err, char** err_info);

struct wtap {
    FILE_T                      fh;                     
    FILE_T                      random_fh;              
    bool                        ispipe;                 
    int                         file_type_subtype;      
    unsigned                    snapshot_length;        
    GArray                      *shb_hdrs;              
    GArray                      *shb_iface_to_global;   
    GArray                      *interface_data;        
    unsigned                    next_interface_data;    
    GArray                      *nrbs;                  
    GArray                      *dsbs;                  
    GArray                      *meta_events;           
    GArray                      *pibs;                  
    GHashTable                  *pibs_by_pid;           
    GArray                      *pib_offsets;           
    char                        *pathname;              
    const char                  *app_env_var_prefix;    
 
    void                        *priv;                  
    void                        *wslua_data;            
 
    subtype_read_func           subtype_read;           
    subtype_seek_read_func      subtype_seek_read;      
    void                        (*subtype_sequential_close)(struct wtap*); 
    void                        (*subtype_close)(struct wtap*);            
    int                         file_encap;    
    int                         file_tsprec;    
    nstime_t                    file_start_ts; 
    nstime_t                    file_end_ts;   
    wtap_new_ipv4_callback_t    add_new_ipv4;    
    wtap_new_ipv6_callback_t    add_new_ipv6;    
    wtap_new_secrets_callback_t add_new_secrets; 
    wtap_pcapng_block_callback_t pcapng_block_cb;     
    void                        *pcapng_block_cb_data; 
    GPtrArray                   *fast_seek;      
};

typedef void *WFILE_T;

typedef bool (*subtype_add_idb_func)(struct wtap_dumper* dumper, wtap_block_t idb,
                                         int* err, char** err_info);

typedef bool (*subtype_write_func)(struct wtap_dumper* dumper, const wtap_rec* rec,
                                   int* err, char** err_info);

typedef bool (*subtype_finish_func)(struct wtap_dumper* dumper, int* err, char** err_info);

struct wtap_dumper {
    WFILE_T                 fh;              
    int                     file_type_subtype; 
    int                     snaplen;         
    int                     file_encap;      
    ws_compression_type     compression_type; 
    bool                    needs_reload;    
    uint64_t                bytes_dumped;    
 
    void                    *priv;           
    void                    *wslua_data;     
 
    subtype_add_idb_func    subtype_add_idb; 
    subtype_write_func      subtype_write;   
    subtype_finish_func     subtype_finish;  
 
    addrinfo_lists_t        *addrinfo_lists; 
    GArray                  *shb_hdrs;       
    const GArray            *shb_iface_to_global; 
    GArray                  *interface_data; 
    GArray                  *dsbs_initial;   
 
    /*
     * Additional blocks that might grow as data is being collected.
     * Subtypes should write these blocks before writing new packet blocks.
     */
    const GArray            *nrbs_growing;          
    const GArray            *dsbs_growing;          
    const GArray            *mevs_growing;          
    const GArray            *pibs_growing;           
    unsigned                nrbs_growing_written;   
    unsigned                dsbs_growing_written;   
    unsigned                mevs_growing_written;   
    unsigned                pibs_growing_written;    
};

WS_DLL_PUBLIC bool wtap_dump_file_write(wtap_dumper *wdh, const void *buf,
                                        size_t bufsize, int *err);

WS_DLL_PUBLIC int64_t wtap_dump_file_seek(wtap_dumper *wdh, int64_t offset,
                                          int whence, int *err);

WS_DLL_PUBLIC int64_t wtap_dump_file_tell(wtap_dumper *wdh, int *err);

WS_DLL_PUBLIC
bool
wtap_read_bytes_or_eof(FILE_T fh, void *buf, unsigned int count, int *err,
    char **err_info);

WS_DLL_PUBLIC
bool
wtap_read_bytes_or_eof_buffer(FILE_T fh, Buffer *buf, unsigned int count,
    int *err, char **err_info);

WS_DLL_PUBLIC
bool
wtap_read_bytes(FILE_T fh, void *buf, unsigned int count, int *err,
    char **err_info);

WS_DLL_PUBLIC
bool
wtap_read_bytes_buffer(FILE_T fh, Buffer *buf, unsigned length, int *err,
                       char **err_info);

bool
wtap_full_file_read(wtap *wth, wtap_rec *rec, int *err, char **err_info,
                    int64_t *data_offset);

bool
wtap_full_file_seek_read(wtap *wth, int64_t seek_off, wtap_rec *rec,
                         int *err, char **err_info);

void
wtap_add_idb(wtap *wth, wtap_block_t idb);

void
wtap_add_pib(wtap *wth, wtap_block_t pib, int64_t offset);

void
wtapng_process_nrb(wtap *wth, wtap_block_t nrb);

void
wtapng_process_dsb(wtap *wth, wtap_block_t dsb);

void
wtap_register_compatibility_file_subtype_name(const char *old_name,
                                              const char *new_name);

void
wtap_register_backwards_compatibility_lua_name(const char *name, int ft);

WS_DLL_PUBLIC
void wtap_add_generated_idb(wtap *wth);

wtap_block_t wtap_rec_generate_idb(const wtap_rec *rec);
 
/* Macros to byte-swap possibly-unaligned 64-bit, 32-bit and 16-bit quantities;
 * they take a pointer to the quantity, and byte-swap it in place.
 */
#define PBSWAP64(p) \
    {            \
        uint8_t tmp;        \
        tmp = (p)[7];      \
        (p)[7] = (p)[0];   \
        (p)[0] = tmp;      \
        tmp = (p)[6];      \
        (p)[6] = (p)[1];   \
        (p)[1] = tmp;      \
        tmp = (p)[5];      \
        (p)[5] = (p)[2];   \
        (p)[2] = tmp;      \
        tmp = (p)[4];      \
        (p)[4] = (p)[3];   \
        (p)[3] = tmp;      \
    }

#define PBSWAP32(p) \
    {            \
        uint8_t tmp;         \
        tmp = (p)[3];       \
        (p)[3] = (p)[0];    \
        (p)[0] = tmp;       \
        tmp = (p)[2];       \
        (p)[2] = (p)[1];    \
        (p)[1] = tmp;       \
    }

#define PBSWAP16(p) \
    {            \
        uint8_t tmp;        \
        tmp = (p)[1];      \
        (p)[1] = (p)[0];   \
        (p)[0] = tmp;      \
    }
 
#endif /* __WTAP_MODULE_H__ */
 
/*
 * 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:
 */