int bacdb_ulog_log(bacdb_ulog_t *ulog, bacdb_op_t *op)
{
int ret = 1;
uint8_t temp_buf[16];
buffer_t buf;
buffer_init(&buf, temp_buf, 16);
if(!buffer_write_u32(&buf, (uint32_t)op->type)
|| !buffer_write_u64(&buf, (uint64_t)op->timestamp)
|| !buffer_write_u32(&buf, (uint32_t)op->size)) {
ret = 0;
goto done;
}
if(fwrite(temp_buf, 16, 1, ulog->ulog_file) != 1
|| fwrite(op->buf, op->size, 1, ulog->ulog_file) != 1) {
ret = 0;
goto done;
}
buffer_destroy(&buf);
done:
if(!ret) {
}
return ret;
}
void sc_action_process(struct sc_action *sa) {
sc_action_debug_print(sa);
int haskey = 1;
BUFFER *buffer = buffer_new();
buffer_write_u8(buffer,(uint8_t)sa->m_shellcode->nspace);
switch (sa->m_shellcode->nspace) {
case sc_bindfiletransfer:
case sc_bindshell:
buffer_write_u8(buffer, sc_port);
buffer_write_u16(buffer,htons((uint16_t)sa->m_action.m_bind.m_localport));
if ( haskey ) {
buffer_write_u8(buffer,sc_key);
buffer_write_u32(buffer,htonl((uint32_t)sa->m_action.m_bind.m_key));
}
break;
case sc_connectbackfiletransfer:
case sc_connectbackshell:
buffer_write_u8(buffer,sc_host);
buffer_write_u32(buffer,htonl((uint16_t)sa->m_action.m_connectback.m_remotehost));
buffer_write_u8(buffer,sc_port);
buffer_write_u16(buffer,htons((uint16_t)sa->m_action.m_connectback.m_remoteport));
if ( haskey )
{
buffer_write_u8(buffer,sc_key);
buffer_write_u32(buffer,htonl((uint32_t)sa->m_action.m_connectback.m_key));
}
connectback(sa, haskey);
break;
case sc_execute:
buffer_write_u8(buffer,sc_command);
buffer_write_u8(buffer,strlen(sa->m_action.m_execute.m_command));
buffer_write_string(buffer,sa->m_action.m_execute.m_command);
break;
case sc_url:
buffer_write_u8(buffer,sc_uri);
buffer_write_u8(buffer,strlen(sa->m_action.m_url.m_link));
buffer_write_string(buffer,sa->m_action.m_url.m_link);
break;
default:
break;
}
// int size = buffer_write_size_get(buffer);
// send here
buffer_free(buffer);
return;
}
int
packet_encode_rr(query_type *q, domain_type *owner, rr_type *rr)
{
size_t truncation_mark;
uint16_t rdlength = 0;
size_t rdlength_pos;
uint16_t j;
assert(q);
assert(owner);
assert(rr);
/*
* If the record does not in fit in the packet the packet size
* will be restored to the mark.
*/
truncation_mark = buffer_position(q->packet);
encode_dname(q, owner);
buffer_write_u16(q->packet, rr->type);
buffer_write_u16(q->packet, rr->klass);
buffer_write_u32(q->packet, rr->ttl);
/* Reserve space for rdlength. */
rdlength_pos = buffer_position(q->packet);
buffer_skip(q->packet, sizeof(rdlength));
for (j = 0; j < rr->rdata_count; ++j) {
switch (rdata_atom_wireformat_type(rr->type, j)) {
case RDATA_WF_COMPRESSED_DNAME:
encode_dname(q, rdata_atom_domain(rr->rdatas[j]));
break;
case RDATA_WF_UNCOMPRESSED_DNAME:
{
const dname_type *dname = domain_dname(
rdata_atom_domain(rr->rdatas[j]));
buffer_write(q->packet,
dname_name(dname), dname->name_size);
break;
}
default:
buffer_write(q->packet,
rdata_atom_data(rr->rdatas[j]),
rdata_atom_size(rr->rdatas[j]));
break;
}
}
if (!query_overflow(q)) {
rdlength = (buffer_position(q->packet) - rdlength_pos
- sizeof(rdlength));
buffer_write_u16_at(q->packet, rdlength_pos, rdlength);
return 1;
} else {
buffer_set_position(q->packet, truncation_mark);
query_clear_dname_offsets(q, truncation_mark);
assert(!query_overflow(q));
return 0;
}
}
/**
* Add RR to query.
*
*/
int
query_add_rr(query_type* q, ldns_rr* rr)
{
size_t i = 0;
size_t tc_mark = 0;
size_t rdlength_pos = 0;
uint16_t rdlength = 0;
ods_log_assert(q);
ods_log_assert(q->buffer);
ods_log_assert(rr);
/* set truncation mark, in case rr does not fit */
tc_mark = buffer_position(q->buffer);
/* owner type class ttl */
if (!buffer_available(q->buffer, ldns_rdf_size(ldns_rr_owner(rr)))) {
goto query_add_rr_tc;
}
buffer_write_rdf(q->buffer, ldns_rr_owner(rr));
if (!buffer_available(q->buffer, sizeof(uint16_t) + sizeof(uint16_t) +
sizeof(uint32_t) + sizeof(rdlength))) {
goto query_add_rr_tc;
}
buffer_write_u16(q->buffer, (uint16_t) ldns_rr_get_type(rr));
buffer_write_u16(q->buffer, (uint16_t) ldns_rr_get_class(rr));
buffer_write_u32(q->buffer, (uint32_t) ldns_rr_ttl(rr));
/* skip rdlength */
rdlength_pos = buffer_position(q->buffer);
buffer_skip(q->buffer, sizeof(rdlength));
/* write rdata */
for (i=0; i < ldns_rr_rd_count(rr); i++) {
if (!buffer_available(q->buffer, ldns_rdf_size(ldns_rr_rdf(rr, i)))) {
goto query_add_rr_tc;
}
buffer_write_rdf(q->buffer, ldns_rr_rdf(rr, i));
}
if (!query_overflow(q)) {
/* write rdlength */
rdlength = buffer_position(q->buffer) - rdlength_pos - sizeof(rdlength);
buffer_write_u16_at(q->buffer, rdlength_pos, rdlength);
/* position updated by buffer_write() */
return 1;
}
query_add_rr_tc:
buffer_set_position(q->buffer, tc_mark);
ods_log_assert(!query_overflow(q));
return 0;
}
