static int __bro_table_val_write(BroTableVal *tbl, BroConn *bc) { double d = 0; char opt = 0; D_ENTER; if (! __bro_mutable_val_write((BroMutableVal *) tbl, bc)) D_RETURN_(FALSE); if (! __bro_buf_write_double(bc->tx_buf, d)) D_RETURN_(FALSE); /* XXX For now we neever send any attributes, nor an expire expr */ if (! __bro_buf_write_char(bc->tx_buf, opt)) D_RETURN_(FALSE); if (! __bro_buf_write_char(bc->tx_buf, opt)) D_RETURN_(FALSE); /* How we iterate depends on whether the index type is atomic or not. * If atomic, we use __bro_table_val_write_cb_direct(), otherwise * we use ..._unpack(), which converts the elements of the RecordVal * into a ListVal before sending. */ if (__bro_table_val_has_atomic_key(tbl)) __bro_table_foreach(tbl->table, (BroTableCallback) __bro_table_val_write_cb_direct, bc); else __bro_table_foreach(tbl->table, (BroTableCallback) __bro_table_val_write_cb_unpack, bc); D_RETURN_(TRUE); }
int __bro_io_raw_queue(BroConn *bc, int type, uchar *data, int data_len) { BroMsg *msg; int result = FALSE; D_ENTER; if (!bc) D_RETURN_(FALSE); if (! (msg = __bro_io_msg_new(type, 0))) D_RETURN_(FALSE); if (data_len > 0) { BroBuf *buf; if (! (buf = __bro_buf_new())) { __bro_io_msg_free(msg); D_RETURN_(FALSE); } __bro_buf_append(buf, data, data_len); __bro_io_msg_set_cont(msg, BRO_MSG_CONT_RAW, buf); } result = io_msg_queue(bc, msg); D_RETURN_(result); }
int __bro_io_msg_queue_flush(BroConn *bc) { BroMsg *msg; int result; D_ENTER; if (! bc) D_RETURN_(-1); for ( ; ; ) { if (! io_msg_empty_tx(bc)) break; if (! (msg = bc->msg_queue.tqh_first)) break; if (! io_msg_fill_tx(bc, msg)) break; TAILQ_REMOVE(&bc->msg_queue, msg, msg_queue); __bro_io_msg_free(msg); bc->msg_queue_len--; bc->state->io_msg = BRO_IOMSG_WRITE; } result = bc->msg_queue_len; D_RETURN_(result); }
int __bro_io_event_queue(BroConn *bc, BroEvent *ev) { BroEvent *ev_copy; BroMsg *msg; int result; D_ENTER; if (!bc) D_RETURN_(FALSE); if (! (msg = __bro_io_msg_new(BRO_MSG_SERIAL, 0))) D_RETURN_(FALSE); if (! (ev_copy = __bro_event_copy(ev))) { D(("Could not clone event\n")); __bro_io_msg_free(msg); D_RETURN_(FALSE); } __bro_io_msg_set_cont(msg, BRO_MSG_CONT_EVENT, ev_copy); result = io_msg_queue(bc, msg); D_RETURN_(result); }
static int __bro_list_val_write(BroListVal *lv, BroConn *bc) { BroList *l; D_ENTER; if (! __bro_val_write((BroVal *) lv, bc)) D_RETURN_(FALSE); if (! __bro_buf_write_char(bc->tx_buf, lv->type_tag)) D_RETURN_(FALSE); if (! __bro_buf_write_int(bc->tx_buf, lv->len)) D_RETURN_(FALSE); for (l = lv->list; l; l = __bro_list_next(l)) { BroVal *val = __bro_list_data(l); if (! __bro_sobject_serialize((BroSObject *) val, bc)) D_RETURN_(FALSE); } D_RETURN_(TRUE); }
static int __bro_list_val_cmp(BroListVal *lv1, BroListVal *lv2) { BroList *l1, *l2; D_ENTER; if (! lv1 || ! lv2) D_RETURN_(FALSE); if (lv1->len != lv2->len || lv1->type_tag != lv2->type_tag) D_RETURN_(FALSE); for (l1 = lv1->list, l2 = lv2->list; l1 && l2; l1 = __bro_list_next(l1), l2 = __bro_list_next(l2)) { if (! __bro_sobject_cmp((BroSObject*) __bro_list_data(l1), (BroSObject*) __bro_list_data(l2))) D_RETURN_(FALSE); } if (l1 || l2) { D(("WARNING -- list length inconsistency.\n")); D_RETURN_(FALSE); } D_RETURN_(TRUE); }
int e_file_can_exec(struct stat *st) { static int have_uid = 0; static uid_t uid = -1; static gid_t gid = -1; int ok; D_ENTER; if (!st) D_RETURN_(0); ok = 0; if (!have_uid) uid = getuid(); if (!have_uid) gid = getgid(); have_uid = 1; if (st->st_uid == uid) { if (st->st_mode & S_IXUSR) ok = 1; } else if (st->st_gid == gid) { if (st->st_mode & S_IXGRP) ok = 1; } else { if (st->st_mode & S_IXOTH) ok = 1; } D_RETURN_(ok); }
int __bro_openssl_read(BroConn *bc, uchar *buf, uint buf_size) { int n; D_ENTER; /* It's important here to use <= for comparison, since, as the * invaluable O'Reilly OpenSSL book reports, "for each of the four * reading and writing functions, a 0 or -1 return value may or may * not necessarily indicate that an error has occurred." This may or * may not necessarily be indicative of the incredible PITA that * OpenSSL is. --cpk */ if ( (n = BIO_read(bc->bio, buf, buf_size)) <= 0) { if (BIO_should_retry(bc->bio)) D_RETURN_(0); __bro_openssl_shutdown(bc); D(("Connection closed, BIO_read() returned %i.\n", n)); print_errors(); D_RETURN_(-1); } D_RETURN_(n); }
int __bro_io_packet_queue(BroConn *bc, BroPacket *packet) { BroPacket *clone; BroMsg *msg; int result; D_ENTER; if (!bc) D_RETURN_(FALSE); if (! (msg = __bro_io_msg_new(BRO_MSG_SERIAL, 0))) D_RETURN_(FALSE); if (! (clone = bro_packet_clone(packet))) { __bro_io_msg_free(msg); D_RETURN_(FALSE); } __bro_io_msg_set_cont(msg, BRO_MSG_CONT_PACKET, clone); result = io_msg_queue(bc, msg); D_RETURN_(result); }
int e_file_mkdir(char *dir) { D_ENTER; if (mkdir(dir, default_mode) < 0) D_RETURN_(0); D_RETURN_(1); }
int __bro_list_val_get_length(BroListVal *lv) { D_ENTER; if (! lv) D_RETURN_(0); D_RETURN_(lv->len); }
int __bro_vector_get_length(BroVector *vec) { D_ENTER; if ( ! vec ) D_RETURN_(0); D_RETURN_(vec->length); }
int __bro_sobject_write(BroSObject *obj, BroConn *bc) { D_ENTER; if (! __bro_buf_write_short(bc->tx_buf, obj->type_id)) D_RETURN_(FALSE); D_RETURN_(TRUE); }
int __bro_sobject_cmp(BroSObject *obj1, BroSObject *obj2) { D_ENTER; if (! obj1 || !obj2) D_RETURN_(FALSE); D_RETURN_(obj1->cmp(obj1, obj2)); }
uint32 __bro_sobject_hash(BroSObject *obj) { D_ENTER; if (! obj) D_RETURN_(0); D_RETURN_(obj->hash(obj)); }
int e_object_get_usecount(E_Object *obj) { D_ENTER; if (!obj) D_RETURN_(-1); D_RETURN_(obj->references); }
int __bro_id_cmp(BroID *id1, BroID *id2) { D_ENTER; if (! id1 || ! id2) D_RETURN_(FALSE); D_RETURN_(__bro_ht_str_cmp(id1->name.str_val, id2->name.str_val)); }
time_t e_file_mod_time(char *file) { struct stat st; D_ENTER; if (stat(file, &st) < 0) D_RETURN_(0); D_RETURN_(st.st_mtime); }
int e_file_exists(char *file) { struct stat st; D_ENTER; if (stat(file, &st) < 0) D_RETURN_(0); D_RETURN_(1); }
int e_file_is_dir(char *file) { struct stat st; D_ENTER; if (stat(file, &st) < 0) D_RETURN_(0); if (S_ISDIR(st.st_mode)) D_RETURN_(1); D_RETURN_(0); }
BroVal * __bro_list_val_get_front(BroListVal *lv) { BroVal *result; BroList *l; D_ENTER; if (! lv) D_RETURN_(NULL); D_RETURN_((BroVal*) __bro_list_data(lv->list)); }
static int __bro_record_val_clone(BroRecordVal *dst, BroRecordVal *src) { D_ENTER; if (! __bro_mutable_val_clone((BroMutableVal *) dst, (BroMutableVal *) src)) D_RETURN_(FALSE); if (src->rec && ! (dst->rec = __bro_record_copy(src->rec))) D_RETURN_(FALSE); D_RETURN_(TRUE); }
char * e_file_realpath(char *file) { char buf[PATH_MAX]; char *f; D_ENTER; if (!realpath(file, buf)) D_RETURN_(strdup("")); e_strdup(f, buf); D_RETURN_(f); }
static int __bro_table_val_clone(BroTableVal *dst, BroTableVal *src) { D_ENTER; if (! __bro_mutable_val_clone((BroMutableVal *) dst, (BroMutableVal *) src)) D_RETURN_(FALSE); if (src->table && ! (dst->table = __bro_table_copy(src->table))) D_RETURN_(FALSE); D_RETURN_(TRUE); }
static int __bro_sobject_cmp_impl(BroSObject *obj1, BroSObject *obj2) { D_ENTER; if (! obj1 || ! obj2) D_RETURN_(FALSE); if (obj1->perm_id != obj2->perm_id) D_RETURN_(FALSE); D_RETURN_(TRUE); }
static int __bro_val_cmp(BroVal *val1, BroVal *val2) { int i; D_ENTER; if (! val1 || ! val2) D_RETURN_(FALSE); if (! __bro_sobject_cmp((BroSObject*) val1->val_type, (BroSObject*) val2->val_type)) D_RETURN_(FALSE); switch (val1->val_type->internal_tag) { case BRO_INTTYPE_INT: case BRO_INTTYPE_UNSIGNED: if (val1->val_int64 != val2->val_int64) D_RETURN_(FALSE); break; case BRO_INTTYPE_IPADDR: for (i = 3; i >= 0; --i) if (val1->val_addr.addr[i] != val2->val_addr.addr[i]) D_RETURN_(FALSE); break; case BRO_INTTYPE_DOUBLE: if (val1->val_double != val2->val_double) D_RETURN_(FALSE); break; case BRO_INTTYPE_STRING: if (! __bro_ht_str_cmp(val1->val_str.str_val, val2->val_str.str_val)) D_RETURN_(FALSE); break; case BRO_INTTYPE_SUBNET: for (i = 3; i >= 0; --i) if (val1->val_subnet.sn_net.addr[i] != val2->val_subnet.sn_net.addr[i]) D_RETURN_(FALSE); if (val1->val_subnet.sn_width != val2->val_subnet.sn_width) D_RETURN_(FALSE); break; case BRO_INTTYPE_OTHER: D(("WARNING -- __bro_val_cmp() invoked on derived type.\n")); break; default: D(("Unknown internal type tag: %i\n", val1->val_type->internal_tag)); break; } D_RETURN_(TRUE); }
static uint32 __bro_val_hash(BroVal *val) { uint32 result; int i; D_ENTER; if (! val) D_RETURN_(0); result = __bro_sobject_hash((BroSObject*) val->val_type); switch (val->val_type->internal_tag) { case BRO_INTTYPE_INT: case BRO_INTTYPE_UNSIGNED: result ^= val->val_int64; break; case BRO_INTTYPE_IPADDR: for ( i = 0; i < 4; ++i ) result ^= val->val_addr.addr[i]; break; case BRO_INTTYPE_DOUBLE: result ^= (uint32) val->val_double; break; case BRO_INTTYPE_STRING: result ^= __bro_ht_str_hash(val->val_str.str_val); break; case BRO_INTTYPE_SUBNET: for ( i = 0; i < 4; ++i ) result ^= val->val_subnet.sn_net.addr[i]; result ^= val->val_subnet.sn_width; break; case BRO_INTTYPE_OTHER: D(("WARNING -- __bro_val_hash() invoked on derived type.\n")); break; default: D(("Unknown internal type tag: %i\n", val->val_type->internal_tag)); break; } D_RETURN_(result); }
static int __bro_record_val_cmp(BroRecordVal *rv1, BroRecordVal *rv2) { D_ENTER; if (! rv1 || ! rv2) D_RETURN_(FALSE); if (! __bro_record_cmp(rv1->rec, rv2->rec)) D_RETURN_(FALSE); D_RETURN_(TRUE); }
BroID * __bro_id_new(void) { BroID *id; D_ENTER; if (! (id = calloc(1, sizeof(BroID)))) D_RETURN_(NULL); __bro_id_init(id); D_RETURN_(id); }
BroVal * __bro_val_new(void) { BroVal *val; D_ENTER; if (! (val = calloc(1, sizeof(BroVal)))) D_RETURN_(NULL); __bro_val_init(val); D_RETURN_(val); }