broccoli

Name

broccoli  -- 

Synopsis

extern              int bro_debug_calltrace;
extern              int bro_debug_messages;
void                (*BroEventFunc)                     (BroConn *bc,
                                                         void *user_data,
                                                         ...);
void                (*BroCompactEventFunc)              (BroConn *bc,
                                                         void *user_data,
                                                         BroEvMeta *meta);
BroConn *           bro_conn_new                        (struct in_addr *ip_addr,
                                                         uint16 port,
                                                         int flags);
BroConn *           bro_conn_new_str                    (const char *hostname,
                                                         int flags);
BroConn *           bro_conn_new_socket                 (int socket,
                                                         int flags);
void                bro_conn_set_class                  (BroConn *bc,
                                                         const char *classname);
const char *        bro_conn_get_peer_class             (const BroConn *bc);
int                 bro_conn_connect                    (BroConn *bc);
int                 bro_conn_alive                      (const BroConn *bc);
int                 bro_conn_delete                     (BroConn *bc);
void                bro_conn_adopt_events               (BroConn *src,
                                                         BroConn *dst);
int                 bro_conn_get_fd                     (BroConn *bc);
int                 bro_conn_process_input              (BroConn *bc);
void                bro_conn_data_set                   (BroConn *bc,
                                                         const char *key,
                                                         void *val);
void *              bro_conn_data_get                   (BroConn *bc,
                                                         const char *key);
void *              bro_conn_data_del                   (BroConn *bc,
                                                         const char *key);
BroEvent *          bro_event_new                       (const char *event_name);
void                bro_event_free                      (BroEvent *be);
int                 bro_event_add_val                   (BroEvent *be,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);
int                 bro_event_set_val                   (BroEvent *be,
                                                         int val_num,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);
int                 bro_event_send                      (BroConn *bc,
                                                         BroEvent *be);
int                 bro_event_queue_length              (BroConn *bc);
int                 bro_event_queue_flush               (BroConn *bc);
void                bro_event_registry_add              (BroConn *bc,
                                                         const char *event_name,
                                                         BroEventFunc func,
                                                         void *user_data);
void                bro_event_registry_add_compact      (BroConn *bc,
                                                         const char *event_name,
                                                         BroCompactEventFunc func,
                                                         void *user_data);
void                bro_event_registry_remove           (BroConn *bc,
                                                         const char *event_name);
void                bro_event_registry_request          (BroConn *bc);
BroBuf *            bro_buf_new                         (void);
void                bro_buf_free                        (BroBuf *buf);
int                 bro_buf_append                      (BroBuf *buf,
                                                         void *data,
                                                         int data_len);
void                bro_buf_consume                     (BroBuf *buf);
void                bro_buf_reset                       (BroBuf *buf);
uchar *             bro_buf_get                         (BroBuf *buf);
uchar *             bro_buf_get_end                     (BroBuf *buf);
uint                bro_buf_get_size                    (BroBuf *buf);
uint                bro_buf_get_used_size               (BroBuf *buf);
uchar *             bro_buf_ptr_get                     (BroBuf *buf);
uint32              bro_buf_ptr_tell                    (BroBuf *buf);
int                 bro_buf_ptr_seek                    (BroBuf *buf,
                                                         int offset,
                                                         int whence);
int                 bro_buf_ptr_check                   (BroBuf *buf,
                                                         int size);
int                 bro_buf_ptr_read                    (BroBuf *buf,
                                                         void *data,
                                                         int size);
int                 bro_buf_ptr_write                   (BroBuf *buf,
                                                         void *data,
                                                         int size);
int                 bro_conf_get_int                    (const char *val_name,
                                                         int *val);
int                 bro_conf_get_dbl                    (const char *val_name,
                                                         double *val);
const char *        bro_conf_get_str                    (const char *val_name);
void                bro_conf_set_domain                 (const char *domain);
void                bro_string_init                     (BroString *bs);
int                 bro_string_set                      (BroString *bs,
                                                         const char *s);
int                 bro_string_set_data                 (BroString *bs,
                                                         const uchar *data,
                                                         int data_len);
const uchar *       bro_string_get_data                 (const BroString *bs);
uint32              bro_string_get_length               (const BroString *bs);
BroString *         bro_string_copy                     (BroString *bs);
void                bro_string_cleanup                  (BroString *bs);
void                bro_string_free                     (BroString *bs);
BroRecord *         bro_record_new                      (void);
void                bro_record_free                     (BroRecord *rec);
int                 bro_record_add_val                  (BroRecord *rec,
                                                         const char *name,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);
void*               bro_record_get_nth_val              (BroRecord *rec,
                                                         int num,
                                                         int *type);
const char*         bro_record_get_nth_name             (BroRecord *rec,
                                                         int num);
void*               bro_record_get_named_val            (BroRecord *rec,
                                                         const char *name,
                                                         int *type);
int                 bro_record_set_nth_val              (BroRecord *rec,
                                                         int num,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);
int                 bro_record_set_named_val            (BroRecord *rec,
                                                         const char *name,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);
int                 (*BroTableCallback)                 (void *key,
                                                         void *val,
                                                         void *user_data);
BroTable *          bro_table_new                       (void);
void                bro_table_free                      (BroTable *tbl);
int                 bro_table_insert                    (BroTable *tbl,
                                                         int key_type,
                                                         const void *key,
                                                         int val_type,
                                                         const void *val);
void *              bro_table_find                      (BroTable *tbl,
                                                         const void *key);
int                 bro_table_get_size                  (BroTable *tbl);
void                bro_table_get_types                 (BroTable *tbl,
                                                         int *key_type,
                                                         int *val_type);
void                bro_table_foreach                   (BroTable *tbl,
                                                         BroTableCallback cb,
                                                         void *user_data);
int                 (*BroSetCallback)                   (void *val,
                                                         void *user_data);
BroSet *            bro_set_new                         (void);
void                bro_set_free                        (BroSet *set);
int                 bro_set_insert                      (BroSet *set,
                                                         int type,
                                                         const void *val);
int                 bro_set_find                        (BroSet *set,
                                                         const void *key);
int                 bro_set_get_size                    (BroSet *set);
void                bro_set_get_type                    (BroSet *set,
                                                         int *type);
void                bro_set_foreach                     (BroSet *set,
                                                         BroSetCallback cb,
                                                         void *user_data);
void                bro_conn_set_packet_ctxt            (BroConn *bc,
                                                         int link_type);
void                bro_conn_get_packet_ctxt            (BroConn *bc,
                                                         int *link_type);
BroPacket *         bro_packet_new                      (const struct pcap_pkthdr *hdr,
                                                         const u_char *data,
                                                         const char *tag);
BroPacket *         bro_packet_clone                    (const BroPacket *packet);
void                bro_packet_free                     (BroPacket *packet);
int                 bro_packet_send                     (BroConn *bc,
                                                         BroPacket *packet);
double              bro_util_current_time               (void);
double              bro_util_timeval_to_double          (const struct timeval *tv);

Description

Details

bro_debug_calltrace

extern int bro_debug_calltrace;


bro_debug_messages

extern int bro_debug_messages;


BroEventFunc ()

void                (*BroEventFunc)                     (BroConn *bc,
                                                         void *user_data,
                                                         ...);

bc :

user_data :

... :


BroCompactEventFunc ()

void                (*BroCompactEventFunc)              (BroConn *bc,
                                                         void *user_data,
                                                         BroEvMeta *meta);

bc :

user_data :

meta :


bro_conn_new ()

BroConn *           bro_conn_new                        (struct in_addr *ip_addr,
                                                         uint16 port,
                                                         int flags);

ip_addr :

port :

flags :

Returns :


bro_conn_new_str ()

BroConn *           bro_conn_new_str                    (const char *hostname,
                                                         int flags);

hostname :

flags :

Returns :


bro_conn_new_socket ()

BroConn *           bro_conn_new_socket                 (int socket,
                                                         int flags);

socket :

flags :

Returns :


bro_conn_set_class ()

void                bro_conn_set_class                  (BroConn *bc,
                                                         const char *classname);

bc :

classname :


bro_conn_get_peer_class ()

const char *        bro_conn_get_peer_class             (const BroConn *bc);

bc :

Returns :


bro_conn_connect ()

int                 bro_conn_connect                    (BroConn *bc);

bc :

Returns :


bro_conn_alive ()

int                 bro_conn_alive                      (const BroConn *bc);

bc :

Returns :


bro_conn_delete ()

int                 bro_conn_delete                     (BroConn *bc);

bc :

Returns :


bro_conn_adopt_events ()

void                bro_conn_adopt_events               (BroConn *src,
                                                         BroConn *dst);

src :

dst :


bro_conn_get_fd ()

int                 bro_conn_get_fd                     (BroConn *bc);

bc :

Returns :


bro_conn_process_input ()

int                 bro_conn_process_input              (BroConn *bc);

bc :

Returns :


bro_conn_data_set ()

void                bro_conn_data_set                   (BroConn *bc,
                                                         const char *key,
                                                         void *val);

bc :

key :

val :


bro_conn_data_get ()

void *              bro_conn_data_get                   (BroConn *bc,
                                                         const char *key);

bc :

key :

Returns :


bro_conn_data_del ()

void *              bro_conn_data_del                   (BroConn *bc,
                                                         const char *key);

bc :

key :

Returns :


bro_event_new ()

BroEvent *          bro_event_new                       (const char *event_name);

event_name :

Returns :


bro_event_free ()

void                bro_event_free                      (BroEvent *be);

be :


bro_event_add_val ()

int                 bro_event_add_val                   (BroEvent *be,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);

be :

type :

type_name :

val :

Returns :


bro_event_set_val ()

int                 bro_event_set_val                   (BroEvent *be,
                                                         int val_num,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);

be :

val_num :

type :

type_name :

val :

Returns :


bro_event_send ()

int                 bro_event_send                      (BroConn *bc,
                                                         BroEvent *be);

bc :

be :

Returns :


bro_event_queue_length ()

int                 bro_event_queue_length              (BroConn *bc);

bc :

Returns :


bro_event_queue_flush ()

int                 bro_event_queue_flush               (BroConn *bc);

bc :

Returns :


bro_event_registry_add ()

void                bro_event_registry_add              (BroConn *bc,
                                                         const char *event_name,
                                                         BroEventFunc func,
                                                         void *user_data);

bc :

event_name :

func :

user_data :


bro_event_registry_add_compact ()

void                bro_event_registry_add_compact      (BroConn *bc,
                                                         const char *event_name,
                                                         BroCompactEventFunc func,
                                                         void *user_data);

bc :

event_name :

func :

user_data :


bro_event_registry_remove ()

void                bro_event_registry_remove           (BroConn *bc,
                                                         const char *event_name);

bc :

event_name :


bro_event_registry_request ()

void                bro_event_registry_request          (BroConn *bc);

bc :


bro_buf_new ()

BroBuf *            bro_buf_new                         (void);

Returns :


bro_buf_free ()

void                bro_buf_free                        (BroBuf *buf);

buf :


bro_buf_append ()

int                 bro_buf_append                      (BroBuf *buf,
                                                         void *data,
                                                         int data_len);

buf :

data :

data_len :

Returns :


bro_buf_consume ()

void                bro_buf_consume                     (BroBuf *buf);

buf :


bro_buf_reset ()

void                bro_buf_reset                       (BroBuf *buf);

buf :


bro_buf_get ()

uchar *             bro_buf_get                         (BroBuf *buf);

buf :

Returns :


bro_buf_get_end ()

uchar *             bro_buf_get_end                     (BroBuf *buf);

buf :

Returns :


bro_buf_get_size ()

uint                bro_buf_get_size                    (BroBuf *buf);

buf :

Returns :


bro_buf_get_used_size ()

uint                bro_buf_get_used_size               (BroBuf *buf);

buf :

Returns :


bro_buf_ptr_get ()

uchar *             bro_buf_ptr_get                     (BroBuf *buf);

buf :

Returns :


bro_buf_ptr_tell ()

uint32              bro_buf_ptr_tell                    (BroBuf *buf);

buf :

Returns :


bro_buf_ptr_seek ()

int                 bro_buf_ptr_seek                    (BroBuf *buf,
                                                         int offset,
                                                         int whence);

buf :

offset :

whence :

Returns :


bro_buf_ptr_check ()

int                 bro_buf_ptr_check                   (BroBuf *buf,
                                                         int size);

buf :

size :

Returns :


bro_buf_ptr_read ()

int                 bro_buf_ptr_read                    (BroBuf *buf,
                                                         void *data,
                                                         int size);

buf :

data :

size :

Returns :


bro_buf_ptr_write ()

int                 bro_buf_ptr_write                   (BroBuf *buf,
                                                         void *data,
                                                         int size);

buf :

data :

size :

Returns :


bro_conf_get_int ()

int                 bro_conf_get_int                    (const char *val_name,
                                                         int *val);

val_name :

val :

Returns :


bro_conf_get_dbl ()

int                 bro_conf_get_dbl                    (const char *val_name,
                                                         double *val);

val_name :

val :

Returns :


bro_conf_get_str ()

const char *        bro_conf_get_str                    (const char *val_name);

val_name :

Returns :


bro_conf_set_domain ()

void                bro_conf_set_domain                 (const char *domain);

domain :


bro_string_init ()

void                bro_string_init                     (BroString *bs);

bs :


bro_string_set ()

int                 bro_string_set                      (BroString *bs,
                                                         const char *s);

bs :

s :

Returns :


bro_string_set_data ()

int                 bro_string_set_data                 (BroString *bs,
                                                         const uchar *data,
                                                         int data_len);

bs :

data :

data_len :

Returns :


bro_string_get_data ()

const uchar *       bro_string_get_data                 (const BroString *bs);

bs :

Returns :


bro_string_get_length ()

uint32              bro_string_get_length               (const BroString *bs);

bs :

Returns :


bro_string_copy ()

BroString *         bro_string_copy                     (BroString *bs);

bs :

Returns :


bro_string_cleanup ()

void                bro_string_cleanup                  (BroString *bs);

bs :


bro_string_free ()

void                bro_string_free                     (BroString *bs);

bs :


bro_record_new ()

BroRecord *         bro_record_new                      (void);

Returns :


bro_record_free ()

void                bro_record_free                     (BroRecord *rec);

rec :


bro_record_add_val ()

int                 bro_record_add_val                  (BroRecord *rec,
                                                         const char *name,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);

rec :

name :

type :

type_name :

val :

Returns :


bro_record_get_nth_val ()

void*               bro_record_get_nth_val              (BroRecord *rec,
                                                         int num,
                                                         int *type);

rec :

num :

type :

Returns :


bro_record_get_nth_name ()

const char*         bro_record_get_nth_name             (BroRecord *rec,
                                                         int num);

rec :

num :

Returns :


bro_record_get_named_val ()

void*               bro_record_get_named_val            (BroRecord *rec,
                                                         const char *name,
                                                         int *type);

rec :

name :

type :

Returns :


bro_record_set_nth_val ()

int                 bro_record_set_nth_val              (BroRecord *rec,
                                                         int num,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);

rec :

num :

type :

type_name :

val :

Returns :


bro_record_set_named_val ()

int                 bro_record_set_named_val            (BroRecord *rec,
                                                         const char *name,
                                                         int type,
                                                         const char *type_name,
                                                         const void *val);

rec :

name :

type :

type_name :

val :

Returns :


BroTableCallback ()

int                 (*BroTableCallback)                 (void *key,
                                                         void *val,
                                                         void *user_data);

key :

val :

user_data :

Returns :


bro_table_new ()

BroTable *          bro_table_new                       (void);

Returns :


bro_table_free ()

void                bro_table_free                      (BroTable *tbl);

tbl :


bro_table_insert ()

int                 bro_table_insert                    (BroTable *tbl,
                                                         int key_type,
                                                         const void *key,
                                                         int val_type,
                                                         const void *val);

tbl :

key_type :

key :

val_type :

val :

Returns :


bro_table_find ()

void *              bro_table_find                      (BroTable *tbl,
                                                         const void *key);

tbl :

key :

Returns :


bro_table_get_size ()

int                 bro_table_get_size                  (BroTable *tbl);

tbl :

Returns :


bro_table_get_types ()

void                bro_table_get_types                 (BroTable *tbl,
                                                         int *key_type,
                                                         int *val_type);

tbl :

key_type :

val_type :


bro_table_foreach ()

void                bro_table_foreach                   (BroTable *tbl,
                                                         BroTableCallback cb,
                                                         void *user_data);

tbl :

cb :

user_data :


BroSetCallback ()

int                 (*BroSetCallback)                   (void *val,
                                                         void *user_data);

val :

user_data :

Returns :


bro_set_new ()

BroSet *            bro_set_new                         (void);

Returns :


bro_set_free ()

void                bro_set_free                        (BroSet *set);

set :


bro_set_insert ()

int                 bro_set_insert                      (BroSet *set,
                                                         int type,
                                                         const void *val);

set :

type :

val :

Returns :


bro_set_find ()

int                 bro_set_find                        (BroSet *set,
                                                         const void *key);

set :

key :

Returns :


bro_set_get_size ()

int                 bro_set_get_size                    (BroSet *set);

set :

Returns :


bro_set_get_type ()

void                bro_set_get_type                    (BroSet *set,
                                                         int *type);

set :

type :


bro_set_foreach ()

void                bro_set_foreach                     (BroSet *set,
                                                         BroSetCallback cb,
                                                         void *user_data);

set :

cb :

user_data :


bro_conn_set_packet_ctxt ()

void                bro_conn_set_packet_ctxt            (BroConn *bc,
                                                         int link_type);

bc :

link_type :


bro_conn_get_packet_ctxt ()

void                bro_conn_get_packet_ctxt            (BroConn *bc,
                                                         int *link_type);

bc :

link_type :


bro_packet_new ()

BroPacket *         bro_packet_new                      (const struct pcap_pkthdr *hdr,
                                                         const u_char *data,
                                                         const char *tag);

hdr :

data :

tag :

Returns :


bro_packet_clone ()

BroPacket *         bro_packet_clone                    (const BroPacket *packet);

packet :

Returns :


bro_packet_free ()

void                bro_packet_free                     (BroPacket *packet);

packet :


bro_packet_send ()

int                 bro_packet_send                     (BroConn *bc,
                                                         BroPacket *packet);

bc :

packet :

Returns :


bro_util_current_time ()

double              bro_util_current_time               (void);

Returns :


bro_util_timeval_to_double ()

double              bro_util_timeval_to_double          (const struct timeval *tv);

tv :

Returns :