ldns_buffer_new(size_t capacity)
{
ldns_buffer *buffer
- = MALLOC(ldns_buffer);
+ = LDNS_MALLOC(ldns_buffer);
if (!buffer) {
return NULL;
}
- buffer->_data = (uint8_t *) XMALLOC(uint8_t, capacity);
+ buffer->_data = (uint8_t *) LDNS_XMALLOC(uint8_t, capacity);
if (!buffer->_data) {
- FREE(buffer);
+ LDNS_FREE(buffer);
return NULL;
}
ldns_buffer_invariant(buffer);
assert(buffer->_position <= capacity);
- data = (uint8_t *) XREALLOC(buffer->_data, uint8_t, capacity);
+ data = (uint8_t *) LDNS_XREALLOC(buffer->_data, uint8_t, capacity);
if (!data) {
buffer->_status = LDNS_STATUS_MEM_ERR;
return false;
/*
if (!buffer->_fixed) {
*/
- FREE(buffer->_data);
+ LDNS_FREE(buffer->_data);
/*
}
*/
- FREE(buffer);
+ LDNS_FREE(buffer);
}
void *
/* we overwrite the nullbyte of rd1 */
new_size = ldns_rdf_size(rd1) + ldns_rdf_size(rd2) - 1;
- buf = XMALLOC(uint8_t, new_size);
+ buf = LDNS_XMALLOC(uint8_t, new_size);
if (!buf) {
return NULL;
}
new = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, new_size, buf);
- FREE(buf);
+ LDNS_FREE(buf);
return new;
}
}
*result_len = pos;
- wire2 = XMALLOC(uint8_t, *result_len);
+ wire2 = LDNS_XMALLOC(uint8_t, *result_len);
memcpy(wire2, wire, *result_len);
write_uint16(wire2 + ARCOUNT_OFF, ar_count);
algorithm_name = ldns_rdf2str(algorithm_rdf);
/* prepare the key */
- key_bytes = XMALLOC(unsigned char, b64_pton_calculate_size(strlen(key_data)));
+ key_bytes = LDNS_XMALLOC(unsigned char, b64_pton_calculate_size(strlen(key_data)));
key_size = b64_pton(key_data, key_bytes, strlen(key_data) * 2);
if (key_size < 0) {
/* LDNS_STATUS_INVALID_B64 */
}
/* hmac it */
/* 2 spare bytes for the length */
- mac_bytes = XMALLOC(unsigned char, md_len);
+ mac_bytes = LDNS_XMALLOC(unsigned char, md_len);
memset(mac_bytes, 0, md_len);
digester = ldns_get_digest_function(algorithm_name);
return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO;
}
- FREE(algorithm_name);
- FREE(mac_bytes);
- FREE(key_bytes);
+ LDNS_FREE(algorithm_name);
+ LDNS_FREE(mac_bytes);
+ LDNS_FREE(key_bytes);
ldns_buffer_free(data_buffer);
*tsig_mac = result;
/* eww don't have create tsigtime rdf yet :( */
/* bleh :p */
if (gettimeofday(&tv_time_signed, NULL) == 0) {
- time_signed = XMALLOC(uint8_t, 6);
+ time_signed = LDNS_XMALLOC(uint8_t, 6);
write_uint64_as_uint48(time_signed, tv_time_signed.tv_sec);
} else {
status = LDNS_STATUS_INTERNAL_ERR;
goto clean;
}
- FREE(pkt_wire);
+ LDNS_FREE(pkt_wire);
/* Create the TSIG RR */
tsig_rr = ldns_rr_new();
ldns_rr_set_ttl(ds, ldns_rr_ttl(key));
ldns_rr_set_class(ds, ldns_rr_get_class(key));
- digest = XMALLOC(uint8_t, SHA_DIGEST_LENGTH);
+ digest = LDNS_XMALLOC(uint8_t, SHA_DIGEST_LENGTH);
if (!digest) {
return NULL;
}
digest);
ldns_rr_push_rdf(ds, tmp);
- FREE(digest);
+ LDNS_FREE(digest);
return ds;
}
linebuf = ldns_buffer_new(MAXLINE_LEN);
/* duh duh duh !!!!! */
- line = XMALLOC(char, MAXLINE_LEN + 1);
- word = XMALLOC(char, MAXLINE_LEN + 1);
- addr = XMALLOC(char, MAXLINE_LEN + 1);
- rr_str = XMALLOC(char, MAXLINE_LEN + 1);
+ line = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
+ word = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
+ addr = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
+ rr_str = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
ip6 = false;
list = ldns_rr_list_new();
rr = NULL;
ldns_rr_list_push_rr(list, rr);
}
}
- FREE(line);
- FREE(word);
- FREE(addr);
- FREE(rr_str);
+ LDNS_FREE(line);
+ LDNS_FREE(word);
+ LDNS_FREE(addr);
+ LDNS_FREE(rr_str);
return list;
}
ldns_rdf2buffer_str_b64(ldns_buffer *output, ldns_rdf *rdf)
{
size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf));
- char *b64 = XMALLOC(char, size);
+ char *b64 = LDNS_XMALLOC(char, size);
if (b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
ldns_buffer_printf(output, "%s", b64);
}
- FREE(b64);
+ LDNS_FREE(b64);
return ldns_buffer_status(output);
}
{
/* Subtract the size (2) of the number that specifies the length */
size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
- char *b64 = XMALLOC(char, size);
+ char *b64 = LDNS_XMALLOC(char, size);
ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf)-2);
b64_ntop(ldns_rdf_data(rdf)+2, ldns_rdf_size(rdf)-2, b64, size)) {
ldns_buffer_printf(output, "%s", b64);
}
- FREE(b64);
+ LDNS_FREE(b64);
return ldns_buffer_status(output);
}
/* no gateway */
break;
case 1:
- gateway_data = XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
+ gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
gateway = ldns_rdf_new(LDNS_RDF_TYPE_A,
LDNS_IP4ADDRLEN , gateway_data);
break;
case 2:
- gateway_data = XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
+ gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
gateway = ldns_rdf_new(LDNS_RDF_TYPE_AAAA,
LDNS_IP6ADDRLEN, gateway_data);
}
public_key_size = ldns_rdf_size(rdf) - offset;
- public_key_data = XMALLOC(uint8_t, public_key_size);
+ public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
memcpy(public_key_data, &data[offset], public_key_size);
public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
if (ldns_pkt_answerfrom(pkt)) {
tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
- FREE(tmp);
+ LDNS_FREE(tmp);
}
if (ldns_pkt_when(pkt)) {
/* \n included in when buffer, see ctime(3) */
}
tmp_str = ldns_buffer_export(buffer);
- str = XMALLOC(char, strlen(tmp_str) + 1);
+ str = LDNS_XMALLOC(char, strlen(tmp_str) + 1);
memcpy(str, tmp_str, strlen(tmp_str) + 1);
return str;
} else {
fprintf(output, "Unable to convert rdf to string\n");
}
- FREE(str);
+ LDNS_FREE(str);
}
void
} else {
fprintf(output, "Unable to convert rr to string\n");
}
- FREE(str);
+ LDNS_FREE(str);
}
void
} else {
fprintf(output, "Unable to convert packet to string\n");
}
- FREE(str);
+ LDNS_FREE(str);
}
void
} else {
fprintf(output, "Unable to convert rr_list to string\n");
}
- FREE(str);
+ LDNS_FREE(str);
}
void
}
if (result) {
- *dest = XMALLOC(uint8_t, ldns_buffer_position(buffer));
+ *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
memcpy(*dest, result, ldns_buffer_position(buffer));
}
}
if (result) {
- *dest = XMALLOC(uint8_t, ldns_buffer_position(buffer));
+ *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
memcpy(*dest, result, ldns_buffer_position(buffer));
}
}
if (result) {
- *dest = XMALLOC(uint8_t, ldns_buffer_position(buffer));
+ *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
memcpy(*dest, result, ldns_buffer_position(buffer));
}
ldns_key_list *
ldns_key_list_new()
{
- ldns_key_list *key_list = MALLOC(ldns_key_list);
+ ldns_key_list *key_list = LDNS_MALLOC(ldns_key_list);
if (!key_list) {
return NULL;
} else {
{
ldns_key *newkey;
- newkey = MALLOC(ldns_key);
+ newkey = LDNS_MALLOC(ldns_key);
if (!newkey) {
return NULL;
} else {
key_count = ldns_key_list_key_count(key_list);
/* grow the array */
- keys = XREALLOC(
+ keys = LDNS_XREALLOC(
key_list->_keys, ldns_key *, key_count + 1);
if (!keys) {
return false;
pop = ldns_key_list_key(key_list, key_count);
/* shrink the array */
- key_list->_keys = XREALLOC(
+ key_list->_keys = LDNS_XREALLOC(
key_list->_keys, ldns_key *, key_count - 1);
ldns_key_list_set_key_count(key_list, key_count - 1);
return NULL;
}
- bin = XMALLOC(unsigned char, MAX_KEYLEN);
+ bin = LDNS_XMALLOC(unsigned char, MAX_KEYLEN);
if (!bin) {
return NULL;
}
}
/* fourth the key bin material */
keybin = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, size+1, bin);
- FREE(bin);
+ LDNS_FREE(bin);
ldns_rr_push_rdf(pubkey, keybin);
return pubkey;
}
/**
* Memory management macro's
*/
-#define MALLOC(type) XMALLOC(type, 1)
+#define LDNS_MALLOC(type) LDNS_XMALLOC(type, 1)
-#define XMALLOC(type, count) ((type *) malloc((count) * sizeof(type)))
+#define LDNS_XMALLOC(type, count) ((type *) malloc((count) * sizeof(type)))
-#define REALLOC(ptr, type) XREALLOC((ptr), type, 1)
+#define LDNS_REALLOC(ptr, type) LDNS_XREALLOC((ptr), type, 1)
-#define XREALLOC(ptr, type, count) \
+#define LDNS_XREALLOC(ptr, type, count) \
((type *) realloc((ptr), (count) * sizeof(type)))
-#define FREE(ptr) \
+#define LDNS_FREE(ptr) \
do { free((ptr)); (ptr) = NULL; } while (0)
#define DEP printf("DEPRECATED FUNCTION!\n");
" Last change: 2004-12-15
" util.h
-syn keyword ldnsMacro MALLOC
-syn keyword ldnsMacro XMALLOC
-syn keyword ldnsMacro REALLOC
-syn keyword ldnsMacro XREALLOC
-syn keyword ldnsMacro FREE
+syn keyword ldnsMacro LDNS_MALLOC
+syn keyword ldnsMacro LDNS_XMALLOC
+syn keyword ldnsMacro LDNS_REALLOC
+syn keyword ldnsMacro LDNS_XREALLOC
+syn keyword ldnsMacro LDNS_FREE
syn keyword ldnsMacro DEP
" ldns/rdata.h
if (ldns_wire2pkt(&reply, reply_bytes, reply_size) !=
LDNS_STATUS_OK) {
- FREE(reply_bytes);
+ LDNS_FREE(reply_bytes);
return LDNS_STATUS_ERR;
}
- FREE(ns);
+ LDNS_FREE(ns);
gettimeofday(&tv_e, NULL);
if (reply) {
}
}
- FREE(reply_bytes);
+ LDNS_FREE(reply_bytes);
ldns_buffer_free(qb);
*result = reply;
return LDNS_STATUS_OK;
}
/* wait for an response*/
- answer = XMALLOC(uint8_t, MAX_PACKETLEN);
+ answer = LDNS_XMALLOC(uint8_t, MAX_PACKETLEN);
if (!answer) {
dprintf("%s", "respons alloc error\n");
return LDNS_STATUS_ERR;
if (errno == EAGAIN) {
dprintf("%s", "socket timeout\n");
}
- FREE(answer);
+ LDNS_FREE(answer);
return LDNS_STATUS_ERR;
}
/* resize accordingly */
- answer = (uint8_t*)XREALLOC(answer, uint8_t *, (size_t) bytes);
+ answer = (uint8_t*)LDNS_XREALLOC(answer, uint8_t *, (size_t) bytes);
*answer_size = (size_t) bytes;
*result = answer;
ssize_t bytes;
/* add length of packet */
- sendbuf = XMALLOC(uint8_t, ldns_buffer_position(qbin) + 2);
+ sendbuf = LDNS_XMALLOC(uint8_t, ldns_buffer_position(qbin) + 2);
write_uint16(sendbuf, ldns_buffer_position(qbin));
memcpy(sendbuf+2, ldns_buffer_export(qbin), ldns_buffer_position(qbin));
bytes = sendto(sockfd, sendbuf,
ldns_buffer_position(qbin)+2, 0, (struct sockaddr *)to, tolen);
- FREE(sendbuf);
+ LDNS_FREE(sendbuf);
if (bytes == -1) {
dprintf("%s", "error with sending\n");
uint16_t wire_size;
ssize_t bytes = 0;
- wire = XMALLOC(uint8_t, 2);
+ wire = LDNS_XMALLOC(uint8_t, 2);
while (bytes < 2) {
bytes = recv(sockfd, wire, 2, 0);
if (bytes == -1) {
wire_size = read_uint16(wire);
- FREE(wire);
- wire = XMALLOC(uint8_t, wire_size);
+ LDNS_FREE(wire);
+ wire = LDNS_XMALLOC(uint8_t, wire_size);
bytes = 0;
while (bytes < (ssize_t) wire_size) {
dprintf("%s", "socket timeout\n");
}
perror("error receiving tcp packet");
- FREE(wire);
+ LDNS_FREE(wire);
return NULL;
}
}
ldns_pkt_new()
{
ldns_pkt *packet;
- packet = MALLOC(ldns_pkt);
+ packet = LDNS_MALLOC(ldns_pkt);
if (!packet) {
return NULL;
}
- packet->_header = MALLOC(ldns_hdr);
+ packet->_header = LDNS_MALLOC(ldns_hdr);
if (!packet->_header) {
- FREE(packet);
+ LDNS_FREE(packet);
return NULL;
}
ldns_pkt_free(ldns_pkt *packet)
{
if (packet) {
- FREE(packet->_header);
+ LDNS_FREE(packet->_header);
ldns_rr_list_free(packet->_question);
ldns_rr_list_free(packet->_answer);
ldns_rr_list_free(packet->_authority);
ldns_rr_list_free(packet->_additional);
ldns_rr_free(packet->_tsig_rr);
- FREE(packet);
+ LDNS_FREE(packet);
}
}
char *fkeyword;
ssize_t i;
- fkeyword = XMALLOC(char, MAXKEYWORD_LEN);
+ fkeyword = LDNS_XMALLOC(char, MAXKEYWORD_LEN);
i = 0;
i = ldns_fget_token(f, fkeyword, k_del, 0);
char *fkeyword;
ssize_t i;
- fkeyword = XMALLOC(char, MAXKEYWORD_LEN);
+ fkeyword = LDNS_XMALLOC(char, MAXKEYWORD_LEN);
i = 0;
i = ldns_bget_token(b, fkeyword, k_del, 0);
b = (struct in_addr*)rd->_data;
- data = MALLOC(struct sockaddr_storage);
+ data = LDNS_MALLOC(struct sockaddr_storage);
switch(ldns_rdf_get_type(rd)) {
case LDNS_RDF_TYPE_A:
memcpy(&data_in6->sin6_addr, ldns_rdf_data(rd), ldns_rdf_size(rd));
return data;
default:
- FREE(data);
+ LDNS_FREE(data);
return NULL;
}
}
ldns_rdf *
ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value)
{
- uint16_t *rdf_data = XMALLOC(uint16_t, 1);
+ uint16_t *rdf_data = LDNS_XMALLOC(uint16_t, 1);
write_uint16(rdf_data, value);
return ldns_rdf_new(type, 2, rdf_data);
}
ldns_rdf *
ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value)
{
- uint32_t *rdf_data = XMALLOC(uint32_t, 1);
+ uint32_t *rdf_data = LDNS_XMALLOC(uint32_t, 1);
write_uint32(rdf_data, value);
return ldns_rdf_new(type, 4, rdf_data);
}
ldns_rdf *
ldns_native2rdf_int16_data(uint16_t size, uint8_t *data)
{
- uint8_t *rdf_data = XMALLOC(uint8_t, (size_t) size + 2);
+ uint8_t *rdf_data = LDNS_XMALLOC(uint8_t, (size_t) size + 2);
write_uint16(rdf_data, size);
memcpy(rdf_data + 2, data, size);
return ldns_rdf_new(LDNS_RDF_TYPE_INT16_DATA, size + 2, rdf_data);
ldns_rdf_new(ldns_rdf_type t, uint16_t s, void *d)
{
ldns_rdf *rd;
- rd = MALLOC(ldns_rdf);
+ rd = LDNS_MALLOC(ldns_rdf);
if (!rd) {
return NULL;
}
ldns_rdf_new_frm_data(ldns_rdf_type type, uint16_t size, const void *data)
{
ldns_rdf *rdf;
- rdf = MALLOC(ldns_rdf);
+ rdf = LDNS_MALLOC(ldns_rdf);
if (!rdf) {
return NULL;
}
- rdf->_data = XMALLOC(uint8_t, size);
+ rdf->_data = LDNS_XMALLOC(uint8_t, size);
if (!rdf->_data) {
return NULL;
}
ldns_rdf_free_data(ldns_rdf *rd)
{
if (rd) {
- FREE(rd->_data);
- FREE(rd);
+ LDNS_FREE(rd->_data);
+ LDNS_FREE(rd);
}
}
ldns_rdf_free(ldns_rdf *rd)
{
if (rd) {
- FREE(rd);
+ LDNS_FREE(rd);
}
}
ldns_rdf *r;
ssize_t t;
- line = XMALLOC(char, MAXLINE_LEN + 1);
+ line = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
if (!line) {
return NULL;
}
/* read an entire line in from the file */
if ((t = ldns_fget_token(fp, line, LDNS_PARSE_SKIP_SPACE, 0)) == -1) {
- FREE(line);
+ LDNS_FREE(line);
return NULL;
}
r = ldns_rdf_new_frm_str(type, (const char*) line);
- FREE(line);
+ LDNS_FREE(line);
return r;
}
}
/* not needed anymore */
ldns_rdf_free(rev);
- FREE(char_dname);
+ LDNS_FREE(char_dname);
break;
case LDNS_RDF_TYPE_AAAA:
/* some foo magic to reverse the nibbles ... */
(octet * 2 + nnibble)] = (uint8_t)int_to_hexdigit((int)nibble);
}
- char_dname = XMALLOC(char, (LDNS_IP6ADDRLEN * 4));
+ char_dname = LDNS_XMALLOC(char, (LDNS_IP6ADDRLEN * 4));
if (!char_dname) {
return NULL;
}
if (!ret_dname) {
return NULL;
}
- FREE(char_dname);
+ LDNS_FREE(char_dname);
break;
default:
break;
pop = nameservers[ns_count - 1];
- nameservers = XREALLOC(nameservers, ldns_rdf *,
+ nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *,
(ns_count - 1));
ldns_resolver_set_nameservers(r, nameservers);
nameservers = ldns_resolver_nameservers(r);
/* make room for the next one */
- nameservers = XREALLOC(nameservers, ldns_rdf *, (ns_count + 1));
+ nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *, (ns_count + 1));
/* set the new value in the resolver */
ldns_resolver_set_nameservers(r, nameservers);
{
ldns_resolver *r;
- r = MALLOC(ldns_resolver);
+ r = LDNS_MALLOC(ldns_resolver);
if (!r) {
return NULL;
}
/* recognized keywords */
keyword[0] = "domain";
keyword[1] = "nameserver";
- word = XMALLOC(char, MAXLINE_LEN + 1);
+ word = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
expect = RESOLV_KEYWORD;
r = ldns_resolver_new();
gtr = ldns_fget_token(fp, word, LDNS_PARSE_NORMAL, 0);
}
- FREE(word);
+ LDNS_FREE(word);
return r;
}
ldns_rdf_free_data(res->_searchlist[i]);
}
}
- FREE(res->_searchlist);
+ LDNS_FREE(res->_searchlist);
if (res->_nameservers) {
for (i = 0; i < res->_nameserver_count; i++) {
ldns_rdf_free_data(res->_nameservers[i]);
}
}
- FREE(res->_nameservers);
- FREE(res);
+ LDNS_FREE(res->_nameservers);
+ LDNS_FREE(res);
}
}
ldns_rr_new(void)
{
ldns_rr *rr;
- rr = MALLOC(ldns_rr);
+ rr = LDNS_MALLOC(ldns_rr);
if (!rr) {
return NULL;
}
const ldns_rr_descriptor *desc;
uint16_t i;
- rr = MALLOC(ldns_rr);
+ rr = LDNS_MALLOC(ldns_rr);
if (!rr) {
return NULL;
}
desc = ldns_rr_descript(t);
- rr->_rdata_fields = XMALLOC(ldns_rdf *,
+ rr->_rdata_fields = LDNS_XMALLOC(ldns_rdf *,
ldns_rr_descriptor_minimum(desc));
for (i = 0; i < ldns_rr_descriptor_minimum(desc); i++) {
rr->_rdata_fields[i] = NULL;
for (i = 0; i < ldns_rr_rd_count(rr); i++) {
ldns_rdf_free_data(ldns_rr_rdf(rr, i));
}
- FREE(rr->_rdata_fields);
- FREE(rr);
+ LDNS_FREE(rr->_rdata_fields);
+ LDNS_FREE(rr);
}
}
new = ldns_rr_new();
- owner = XMALLOC(char, MAX_DOMAINLEN + 1);
- ttl = XMALLOC(char, 21);
- clas = XMALLOC(char, 11);
- type = XMALLOC(char, 10);
- rdata = XMALLOC(char, MAX_PACKETLEN + 1);
- rr_buf = MALLOC(ldns_buffer);
- rd_buf = MALLOC(ldns_buffer);
- rd = XMALLOC(char, MAX_RDFLEN);
+ owner = LDNS_XMALLOC(char, MAX_DOMAINLEN + 1);
+ ttl = LDNS_XMALLOC(char, 21);
+ clas = LDNS_XMALLOC(char, 11);
+ type = LDNS_XMALLOC(char, 10);
+ rdata = LDNS_XMALLOC(char, MAX_PACKETLEN + 1);
+ rr_buf = LDNS_MALLOC(ldns_buffer);
+ rd_buf = LDNS_MALLOC(ldns_buffer);
+ rd = LDNS_XMALLOC(char, MAX_RDFLEN);
if (!owner || !ttl || !clas || !type || !rdata ||
!rr_buf || !rd_buf || !rd) {
return NULL;
/* split the rr in its parts -1 signals trouble */
if (ldns_bget_token(rr_buf, owner, "\t\n ", MAX_DOMAINLEN) == -1) {
- FREE(owner); FREE(ttl); FREE(clas); FREE(rdata);FREE(rd);
- FREE(rd_buf);
+ LDNS_FREE(owner);
+ LDNS_FREE(ttl);
+ LDNS_FREE(clas);
+ LDNS_FREE(rdata);
+ LDNS_FREE(rd);
+ LDNS_FREE(rd_buf);
ldns_buffer_free(rr_buf);
return NULL;
}
if (ldns_bget_token(rr_buf, ttl, "\t\n ", 21) == -1) {
- FREE(owner); FREE(ttl); FREE(clas); FREE(rdata);FREE(rd);
- FREE(rd_buf);
+ LDNS_FREE(owner);
+ LDNS_FREE(ttl);
+ LDNS_FREE(clas);
+ LDNS_FREE(rdata);
+ LDNS_FREE(rd);
+ LDNS_FREE(rd_buf);
ldns_buffer_free(rr_buf);
return NULL;
}
clas_val = ldns_get_rr_class_by_name(ttl);
} else {
if (ldns_bget_token(rr_buf, clas, "\t\n ", 11) == -1) {
- FREE(owner); FREE(ttl); FREE(clas); FREE(rdata);FREE(rd);
- FREE(rd_buf);
+ LDNS_FREE(owner);
+ LDNS_FREE(ttl);
+ LDNS_FREE(clas);
+ LDNS_FREE(rdata);
+ LDNS_FREE(rd);
+ LDNS_FREE(rd_buf);
ldns_buffer_free(rr_buf);
return NULL;
}
/* the rest should still be waiting for us */
if (ldns_bget_token(rr_buf, type, "\t\n ", 10) == -1) {
- FREE(owner); FREE(ttl); FREE(clas); FREE(rdata);FREE(rd);
- FREE(rd_buf);
+ LDNS_FREE(owner);
+ LDNS_FREE(ttl);
+ LDNS_FREE(clas);
+ LDNS_FREE(rdata);
+ LDNS_FREE(rd);
+ LDNS_FREE(rd_buf);
ldns_buffer_free(rr_buf);
return NULL;
}
if (ldns_bget_token(rr_buf, rdata, "\0", MAX_PACKETLEN) == -1) {
- FREE(owner); FREE(ttl); FREE(clas); FREE(type);FREE(rd);
- FREE(rd_buf);
+ LDNS_FREE(owner);
+ LDNS_FREE(ttl);
+ LDNS_FREE(clas);
+ LDNS_FREE(type);
+ LDNS_FREE(rd);
+ LDNS_FREE(rd_buf);
ldns_buffer_free(rr_buf);
return NULL;
}
rd_buf, rdata, strlen(rdata));
ldns_rr_set_owner(new, ldns_dname_new_frm_str(owner));
- FREE(owner);
+ LDNS_FREE(owner);
ldns_rr_set_ttl(new, ttl_val);
- FREE(ttl);
+ LDNS_FREE(ttl);
ldns_rr_set_class(new, clas_val);
- FREE(clas);
+ LDNS_FREE(clas);
rr_type = ldns_get_rr_type_by_name(type);
- FREE(type);
+ LDNS_FREE(type);
desc = ldns_rr_descript((uint16_t)rr_type);
ldns_rr_set_type(new, rr_type);
}
}
- FREE(rdata);
+ LDNS_FREE(rdata);
return new;
}
{
char *line;
- line = XMALLOC(char, MAXLINE_LEN + 1);
+ line = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
if (!line) {
return NULL;
}
rd_count = ldns_rr_rd_count(rr);
/* grow the array */
- rdata_fields = XREALLOC(
+ rdata_fields = LDNS_XREALLOC(
rr->_rdata_fields, ldns_rdf *, rd_count + 1);
if (!rdata_fields) {
return false;
pop = rr->_rdata_fields[rd_count];
/* shrink the array */
- rr->_rdata_fields = XREALLOC(
+ rr->_rdata_fields = LDNS_XREALLOC(
rr->_rdata_fields, ldns_rdf *, rd_count - 1);
ldns_rr_set_rd_count(rr, rd_count - 1);
ldns_rr_list *
ldns_rr_list_new()
{
- ldns_rr_list *rr_list = MALLOC(ldns_rr_list);
+ ldns_rr_list *rr_list = LDNS_MALLOC(ldns_rr_list);
rr_list->_rr_count = 0;
rr_list->_rrs = NULL;
return rr_list;
for (i=0; i < ldns_rr_list_rr_count(rr_list); i++) {
ldns_rr_free(ldns_rr_list_rr(rr_list, i));
}
- FREE(rr_list->_rrs);
- FREE(rr_list);
+ LDNS_FREE(rr_list->_rrs);
+ LDNS_FREE(rr_list);
}
}
rr_count = ldns_rr_list_rr_count(rr_list);
/* grow the array */
- rrs = XREALLOC(
+ rrs = LDNS_XREALLOC(
rr_list->_rrs, ldns_rr *, rr_count + 1);
if (!rrs) {
pop = ldns_rr_list_rr(rr_list, rr_count);
/* shrink the array */
- rr_list->_rrs = XREALLOC(
+ rr_list->_rrs = LDNS_XREALLOC(
rr_list->_rrs, ldns_rr *, rr_count - 1);
ldns_rr_list_set_rr_count(rr_list, rr_count - 1);
}
pop = ldns_rr_set_rdf(rr, rdf, pos);
if (pop) {
- FREE(pop);
+ LDNS_FREE(pop);
return true;
} else {
return true;
}
pop = ldns_rr_set_rdf(r, f, 0);
if (pop) {
- FREE(pop);
+ LDNS_FREE(pop);
return true;
} else {
return false;
rr = ldns_rr_new();
- rdf_data = (uint8_t *) XMALLOC(char, MAX_DOMAINLEN);
+ rdf_data = (uint8_t *) LDNS_XMALLOC(char, MAX_DOMAINLEN);
rdf_data[0] = 3;
memcpy(rdf_data+1, "www", 3);
rdf_data[4] = 4;
rr_str = ldns_rr2str(rr);
printf("%s\n", rr_str);
ldns_rr_free(rr);
- FREE(rr_str);
+ LDNS_FREE(rr_str);
}
{
char *end = NULL;
uint16_t *r;
- r = MALLOC(uint16_t);
+ r = LDNS_MALLOC(uint16_t);
*r = htons((uint16_t)strtol((char *)shortstr, &end, 0));
if(*end != 0) {
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_INVALID_INT;
} else {
*rd = ldns_rdf_new_frm_data(
LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_OK;
}
}
char *end;
/* Try to scan the time... */
- r = (uint16_t*)MALLOC(uint32_t);
+ r = (uint16_t*)LDNS_MALLOC(uint32_t);
if((char*)strptime(time, "%Y%m%d%H%M%S", &tm) == NULL) {
/* handle it as 32 bits */
l = htonl((uint32_t)strtol((char*)time, &end, 0));
if(*end != 0) {
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_ERR;
} else {
memcpy(r, &l, sizeof(uint32_t));
*rd = ldns_rdf_new_frm_data(
LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_OK;
}
} else {
memcpy(r, &l, sizeof(uint32_t));
*rd = ldns_rdf_new_frm_data(
LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r);
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_OK;
}
}
uint16_t *r = NULL;
uint32_t l;
- r = (uint16_t*)MALLOC(uint32_t);
+ r = (uint16_t*)LDNS_MALLOC(uint32_t);
l = htonl((uint32_t)strtol((char*)longstr, &end, 0));
if(*end != 0) {
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_ERR;
} else {
memcpy(r, &l, sizeof(uint32_t));
*rd = ldns_rdf_new_frm_data(
LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_OK;
}
}
char *end;
uint8_t *r = NULL;
- r = MALLOC(uint8_t);
+ r = LDNS_MALLOC(uint8_t);
*r = (uint8_t)strtol((char*)bytestr, &end, 0);
if(*end != 0) {
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_ERR;
} else {
*rd = ldns_rdf_new_frm_data(
LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
- FREE(r);
+ LDNS_FREE(r);
return LDNS_STATUS_OK;
}
}
uint8_t *buffer;
int16_t i;
- buffer = XMALLOC(uint8_t, b64_ntop_calculate_size(strlen(str)));
+ buffer = LDNS_XMALLOC(uint8_t, b64_ntop_calculate_size(strlen(str)));
i = (uint16_t) b64_pton((const char*)str, buffer,
b64_ntop_calculate_size(strlen(str)));
*rd = ldns_rdf_new_frm_data(
LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
}
- FREE(buffer);
+ LDNS_FREE(buffer);
return LDNS_STATUS_OK;
}
} else if (len > MAX_RDFLEN * 2) {
return LDNS_STATUS_LABEL_OVERFLOW;
} else {
- t = XMALLOC(uint8_t, (len / 2));
+ t = LDNS_XMALLOC(uint8_t, (len / 2));
/* Now process octet by octet... */
while (*str) {
tmp_dname[dname_pos] = 0;
dname_pos++;
- dname_ar = XMALLOC(uint8_t, dname_pos);
+ dname_ar = LDNS_XMALLOC(uint8_t, dname_pos);
if (!dname_ar) {
return LDNS_STATUS_MEM_ERR;
}
*dname = ldns_rdf_new(LDNS_RDF_TYPE_DNAME,
(uint16_t) dname_pos, dname_ar);
if (!*dname) {
- FREE(dname_ar);
+ LDNS_FREE(dname_ar);
return LDNS_STATUS_MEM_ERR;
}
}
/* fixed length rdata */
if (cur_rdf_length > 0) {
- data = XMALLOC(uint8_t, rd_length);
+ data = LDNS_XMALLOC(uint8_t, rd_length);
if (!data) {
return LDNS_STATUS_MEM_ERR;
}
return LDNS_STATUS_OK;
status_error:
- FREE(rr);
+ LDNS_FREE(rr);
return status;
}
return status;
status_error:
- FREE(packet);
+ LDNS_FREE(packet);
return status;
}
projects / thirdparty / ldns.git / commitdiff
