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);
}
