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;
}
}
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;
}
/**
* 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;
}
int bvlc_read_fdt_ack_encode(bvlc_read_fdt_ack_t *message, buffer_t *buf)
{
int ret = 1
&& buffer_write_u16(buf, 0);
if(ret) {
for(uint16_t i = 0; ret && i < message->entry_count; i++) {
ret = 1
&& buffer_write_raw(buf, message->entries[i].bip_address, 6)
&& buffer_write_u16(buf, message->entries[i].original_ttl)
&& buffer_write_u16(buf, message->entries[i].ttl);
}
}
return ret;
}
int bvlc_forwarded_npdu_encode(bvlc_forwarded_npdu_t *message, buffer_t *buf)
{
return 1
&& buffer_write_u16(buf, 0)
&& buffer_write_raw(buf, message->original_bip_address, 6)
&& buffer_write_raw(buf, message->npdu, message->npdu_length);
}
static void
encode_dname(query_type *q, domain_type *domain)
{
while (domain->parent && query_get_dname_offset(q, domain) == 0) {
query_put_dname_offset(q, domain, buffer_position(q->packet));
DEBUG(DEBUG_NAME_COMPRESSION, 2,
(LOG_INFO, "dname: %s, number: %lu, offset: %u\n",
dname_to_string(domain_dname(domain), NULL),
(unsigned long) domain->number,
query_get_dname_offset(q, domain)));
buffer_write(q->packet, dname_name(domain_dname(domain)),
label_length(dname_name(domain_dname(domain))) + 1U);
domain = domain->parent;
}
if (domain->parent) {
DEBUG(DEBUG_NAME_COMPRESSION, 2,
(LOG_INFO, "dname: %s, number: %lu, pointer: %u\n",
dname_to_string(domain_dname(domain), NULL),
(unsigned long) domain->number,
query_get_dname_offset(q, domain)));
assert(query_get_dname_offset(q, domain) <= MAX_COMPRESSION_OFFSET);
buffer_write_u16(q->packet,
0xc000 | query_get_dname_offset(q, domain));
} else {
buffer_write_u8(q->packet, 0);
}
}
void
xfrd_setup_packet(buffer_type* packet,
uint16_t type, uint16_t klass, const dname_type* dname)
{
/* Set up the header */
buffer_clear(packet);
ID_SET(packet, qid_generate());
FLAGS_SET(packet, 0);
OPCODE_SET(packet, OPCODE_QUERY);
QDCOUNT_SET(packet, 1);
ANCOUNT_SET(packet, 0);
NSCOUNT_SET(packet, 0);
ARCOUNT_SET(packet, 0);
buffer_skip(packet, QHEADERSZ);
/* The question record. */
buffer_write(packet, dname_name(dname), dname->name_size);
buffer_write_u16(packet, type);
buffer_write_u16(packet, klass);
}
int bvlc_write_bdt_encode(bvlc_write_bdt_t *message, buffer_t *buf)
{
int ret = 1
&& buffer_write_u16(buf, 0);
if(ret) {
for(uint16_t i = 0; ret && i < message->entry_count; i++) {
ret = 1
&& buffer_write_raw(buf, message->entries[i].bip_address, 6)
&& buffer_write_raw(buf, message->entries[i].broadcast_mask, 4);
}
}
return ret;
}
int bvlc_original_broadcast_encode(bvlc_original_broadcast_t *message, buffer_t *buf)
{
return 1
&& buffer_write_u16(buf, 0)
&& buffer_write_raw(buf, message->npdu, message->npdu_length);
}
int bvlc_delete_fdt_entry_encode(bvlc_delete_fdt_entry_t *message, buffer_t *buf)
{
return 1
&& buffer_write_u16(buf, 0)
&& buffer_write_raw(buf, message->bip_address, 6);
}
int bvlc_read_fdt_encode(bvlc_read_fdt_t *message, buffer_t *buf)
{
return 1
&& buffer_write_u16(buf, 0);
}
int bvlc_register_fd_encode(bvlc_register_fd_t *message, buffer_t *buf)
{
return 1
&& buffer_write_u16(buf, 0)
&& buffer_write_u16(buf, message->ttl);
}
int bvlc_result_encode(bvlc_result_t *message, buffer_t *buf)
{
return 1
&& buffer_write_u16(buf, 0)
&& buffer_write_u16(buf, message->result_code);
}
static void
marshal_u16(struct buffer* b, uint16_t v)
{
buffer_reserve(b, 2);
buffer_write_u16(b, v);
}
