getdns_return_t
_getdns_fp2rr_list(struct mem_funcs *mf,
FILE *in, getdns_list **rr_list, const char *origin, uint32_t default_ttl)
{
struct gldns_file_parse_state pst;
getdns_list *rrs;
getdns_return_t r = GETDNS_RETURN_GOOD;
uint8_t *rr;
size_t len, dname_len;
getdns_dict *rr_dict;
if (!in || !rr_list)
return GETDNS_RETURN_INVALID_PARAMETER;
if (!origin) {
*pst.origin = 0;
pst.origin_len = 1;
} else if (gldns_str2wire_dname_buf(origin,pst.origin,&pst.origin_len))
return GETDNS_RETURN_GENERIC_ERROR;
*pst.prev_rr = 0;
pst.prev_rr_len = 1;
pst.default_ttl = default_ttl;
pst.lineno = 1;
if (!(rrs = _getdns_list_create_with_mf(mf)))
return GETDNS_RETURN_MEMORY_ERROR;
if (!(rr = GETDNS_XMALLOC(*mf, uint8_t, GLDNS_RR_BUF_SIZE)))
r = GETDNS_RETURN_MEMORY_ERROR;
else while (r == GETDNS_RETURN_GOOD && !feof(in)) {
len = GLDNS_RR_BUF_SIZE;
dname_len = 0;
if (gldns_fp2wire_rr_buf(in, rr, &len, &dname_len, &pst))
break;
if (dname_len && dname_len < sizeof(pst.prev_rr)) {
memcpy(pst.prev_rr, rr, dname_len);
pst.prev_rr_len = dname_len;
}
if (len == 0)
continue;
if ((r = _getdns_wire2rr_dict(mf, rr, len, &rr_dict)))
break;
r = _getdns_list_append_dict(rrs, rr_dict);
getdns_dict_destroy(rr_dict);
}
if (rr)
GETDNS_FREE(*mf, rr);
if (r)
getdns_list_destroy(rrs);
else
*rr_list = rrs;
return r;
}
getdns_return_t
getdns_rr_dict2str_scan(
const getdns_dict *rr_dict, char **str, int *str_len)
{
getdns_return_t r;
gldns_buffer gbuf;
uint8_t buf_spc[4096], *buf = buf_spc, *scan_buf;
size_t sz, scan_sz;
int prev_str_len;
char *prev_str;
int sz_needed;
if (!rr_dict || !str || !*str || !str_len)
return GETDNS_RETURN_INVALID_PARAMETER;
gldns_buffer_init_frm_data(&gbuf, buf, sizeof(buf_spc));
r = _getdns_rr_dict2wire(rr_dict, &gbuf);
if (gldns_buffer_position(&gbuf) > sizeof(buf_spc)) {
if (!(buf = GETDNS_XMALLOC(
rr_dict->mf, uint8_t, (sz = gldns_buffer_position(&gbuf))))) {
return GETDNS_RETURN_MEMORY_ERROR;
}
gldns_buffer_init_frm_data(&gbuf, buf, sz);
r = _getdns_rr_dict2wire(rr_dict, &gbuf);
}
if (r) {
if (buf != buf_spc)
GETDNS_FREE(rr_dict->mf, buf);
return r;
}
scan_buf = gldns_buffer_begin(&gbuf);
scan_sz = gldns_buffer_position(&gbuf);
prev_str = *str;
prev_str_len = *str_len;
sz = (size_t)*str_len;
sz_needed = gldns_wire2str_rr_scan(
&scan_buf, &scan_sz, str, &sz, NULL, 0);
if (sz_needed > prev_str_len) {
*str = prev_str + sz_needed;
*str_len = prev_str_len - sz_needed;
r = GETDNS_RETURN_NEED_MORE_SPACE;
} else {
*str_len = sz;
**str = 0;
}
if (buf != buf_spc)
GETDNS_FREE(rr_dict->mf, buf);
return r;
}
getdns_return_t
_getdns_str2rr_dict(struct mem_funcs *mf,
const char *str, getdns_dict **rr_dict, const char *origin, uint32_t default_ttl)
{
uint8_t wire_spc[4096], *wire = wire_spc;
uint8_t origin_spc[256], *origin_wf;
size_t origin_len = sizeof(origin_spc), wire_len = sizeof(wire_spc);
int e;
getdns_return_t r;
if (!str || !rr_dict)
return GETDNS_RETURN_INVALID_PARAMETER;
if (!origin)
origin_wf = NULL;
else if (gldns_str2wire_dname_buf(origin, origin_spc, &origin_len))
return GETDNS_RETURN_GENERIC_ERROR;
else
origin_wf = origin_spc;
e = gldns_str2wire_rr_buf(str, wire, &wire_len,
NULL, default_ttl, origin_wf, origin_len, NULL, 0);
if (GLDNS_WIREPARSE_ERROR(e) == GLDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL) {
if (!(wire = GETDNS_XMALLOC(
*mf, uint8_t, (wire_len = GLDNS_RR_BUF_SIZE))))
return GETDNS_RETURN_MEMORY_ERROR;
e = gldns_str2wire_rr_buf(str, wire, &wire_len,
NULL, default_ttl, origin_wf, origin_len, NULL, 0);
}
if (e) {
if (wire != wire_spc)
GETDNS_FREE(*mf, wire);
return GETDNS_RETURN_GENERIC_ERROR;
}
r = _getdns_wire2rr_dict(mf, wire, wire_len, rr_dict);
if (wire != wire_spc)
GETDNS_FREE(*mf, wire);
return r;
}
struct getdns_list *
getdns_list_create_with_extended_memory_functions(
void *userarg,
void *(*malloc)(void *userarg, size_t),
void *(*realloc)(void *userarg, void *, size_t),
void (*free)(void *userarg, void *))
{
struct getdns_list *list;
mf_union mf;
if (!malloc || !realloc || !free)
return NULL;
mf.ext.malloc = malloc;
list = userarg == MF_PLAIN
? (struct getdns_list *)(*mf.pln.malloc)(
sizeof(struct getdns_list))
: (struct getdns_list *)(*mf.ext.malloc)(userarg,
sizeof(struct getdns_list));
if (!list)
return NULL;
list->mf.mf_arg = userarg;
list->mf.mf.ext.malloc = malloc;
list->mf.mf.ext.realloc = realloc;
list->mf.mf.ext.free = free;
list->numinuse = 0;
if (!(list->items = GETDNS_XMALLOC(
list->mf, getdns_item, GETDNS_LIST_BLOCKSZ))) {
GETDNS_FREE(list->mf, list);
return NULL;
}
list->numalloc = GETDNS_LIST_BLOCKSZ;
return list;
}
getdns_return_t
getdns_reply(getdns_context *context,
const getdns_dict *reply, getdns_transaction_t request_id)
{
/* TODO: Check request_id at context->outbound_requests */
connection *conn = (connection *)(intptr_t)request_id;
struct mem_funcs *mf;
getdns_eventloop *loop;
uint8_t buf[65536];
size_t len;
getdns_return_t r;
if (!conn)
return GETDNS_RETURN_INVALID_PARAMETER;
if (!context || !context->server) {
if (!context)
context = conn->l->set->context;
} else if (_getdns_rbtree_search(&context->server->connections_set, conn)
!= &conn->super)
return GETDNS_RETURN_NO_SUCH_LIST_ITEM;
if (!reply) {
_getdns_cancel_reply(context, conn);
return GETDNS_RETURN_GOOD;
}
if (!(mf = &conn->l->set->context->mf))
return GETDNS_RETURN_GENERIC_ERROR;;
if ((r = getdns_context_get_eventloop(conn->l->set->context, &loop)))
return r;
len = sizeof(buf);
if ((r = getdns_msg_dict2wire_buf(reply, buf, &len)))
return r;
else if (conn->l->transport == GETDNS_TRANSPORT_UDP) {
listener *l = conn->l;
if (conn->l->fd >= 0 && sendto(conn->l->fd, (void *)buf, len, 0,
(struct sockaddr *)&conn->remote_in, conn->addrlen) == -1) {
/* TODO: handle _getdns_socketerror_wants_retry() */
/* IO error, never cleanup a listener because of I/O error */
DEBUG_SERVER("I/O error from sendto(): %s\n",
_getdns_errnostr());
}
/* Unlink this connection */
(void) _getdns_rbtree_delete(
&l->set->connections_set, conn);
DEBUG_SERVER("[connection del] count: %d\n",
(int)l->set->connections_set.count);
if ((*conn->prev_next = conn->next))
conn->next->prev_next = conn->prev_next;
GETDNS_FREE(*mf, conn);
if (l->fd < 0)
free_listen_set_when_done(l->set);
} else if (conn->l->transport == GETDNS_TRANSPORT_TCP) {
tcp_connection *conn = (tcp_connection *)(intptr_t)request_id;
tcp_to_write **to_write_p;
tcp_to_write *to_write;
if (conn->fd == -1) {
if (conn->to_answer > 0)
--conn->to_answer;
tcp_connection_destroy(conn);
return GETDNS_RETURN_GOOD;
}
if (!(to_write = (tcp_to_write *)GETDNS_XMALLOC(
*mf, uint8_t, sizeof(tcp_to_write) + len + 2))) {
tcp_connection_destroy(conn);
return GETDNS_RETURN_MEMORY_ERROR;
}
to_write->write_buf_len = len + 2;
to_write->write_buf[0] = (len >> 8) & 0xFF;
to_write->write_buf[1] = len & 0xFF;
to_write->written = 0;
to_write->next = NULL;
(void) memcpy(to_write->write_buf + 2, buf, len);
/* Append to_write to conn->to_write list */
for ( to_write_p = &conn->to_write
; *to_write_p
; to_write_p = &(*to_write_p)->next)
; /* pass */
*to_write_p = to_write;
if (conn->to_answer > 0)
conn->to_answer--;
/* When event is scheduled, and doesn't have tcp_write_cb:
* reschedule.
*/
if (conn->event.write_cb == NULL) {
if (conn->event.ev)
loop->vmt->clear(loop, &conn->event);
conn->event.write_cb = tcp_write_cb;
(void) loop->vmt->schedule(loop,
conn->fd, DOWNSTREAM_IDLE_TIMEOUT,
&conn->event);
}
}
