static jdns_string_t *reg_readString(HKEY hk, const char *subkey)
{
char *buf;
DWORD bufsize;
int ret;
jdns_string_t *str = 0;
bufsize = 1024;
buf = (char *)jdns_alloc((int)bufsize);
if(!buf)
return 0;
ret = RegQueryValueExA(hk, subkey, 0, 0, (LPBYTE)buf, &bufsize);
if(ret == ERROR_MORE_DATA)
{
buf = (char *)jdns_realloc(buf, bufsize);
if(!buf)
{
jdns_free(buf);
return 0;
}
ret = RegQueryValueExA(hk, subkey, 0, 0, (LPBYTE)buf, &bufsize);
}
if(ret == ERROR_SUCCESS)
{
str = jdns_string_new();
jdns_string_set_cstr(str, (char *)buf);
}
jdns_free(buf);
return str;
}
void jdns_packet_resource_add_bytes(jdns_packet_resource_t *a, const unsigned char *data, int size)
{
jdns_packet_write_t *write = jdns_packet_write_new();
write->type = JDNS_PACKET_WRITE_RAW;
write->value = jdns_string_new();
jdns_string_set(write->value, data, size);
jdns_list_insert_value(a->writelog, write, -1);
jdns_packet_write_delete(write);
}
static jdns_dnsparams_t *dnsparams_get_winsys()
{
jdns_dnsparams_t *params;
GetNetworkParamsFunc myGetNetworkParams;
DWORD ret;
HINSTANCE lib;
jdns_address_t *addr;
jdns_string_t *str;
IP_ADDR_STRING *ipstr;
lib = LoadLibraryA("iphlpapi");
if(!lib)
return 0;
params = 0;
myGetNetworkParams = (GetNetworkParamsFunc)GetProcAddress(lib, "GetNetworkParams");
if(myGetNetworkParams)
{
ULONG bufsize = 0;
ret = myGetNetworkParams(0, &bufsize);
if(ret == ERROR_BUFFER_OVERFLOW)
{
FIXED_INFO *info = (FIXED_INFO *)jdns_alloc((int)bufsize);
ret = myGetNetworkParams(info, &bufsize);
if(ret == ERROR_SUCCESS)
{
params = jdns_dnsparams_new();
ipstr = &info->DnsServerList;
while(ipstr)
{
addr = jdns_address_new();
if(jdns_address_set_cstr(addr, (char *)ipstr->IpAddress.String))
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
ipstr = ipstr->Next;
}
str = jdns_string_new();
jdns_string_set_cstr(str, info->DomainName);
if(str->size > 0)
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
jdns_free(info);
}
}
FreeLibrary(lib);
return params;
}
static jdns_string_t *file_nextline(FILE *f)
{
int at, size;
unsigned char *buf;
jdns_string_t *str;
size = 1023;
buf = (unsigned char *)jdns_alloc(size);
at = 0;
while(1)
{
unsigned char c = (unsigned char)fgetc(f); // cast is intentional
if(feof(f)) // checking EOF here
{
if(at > 0)
{
// if we read at least one char, take it as a
// line
break;
}
else
{
jdns_free(buf);
return 0;
}
}
if(c == '\n')
break;
if(c == '\r')
continue;
if(at < 1023)
buf[at++] = c;
}
str = jdns_string_new();
jdns_string_set(str, buf, at);
jdns_free(buf);
return str;
}
static jdns_dnsparams_t *dnsparams_get_unixsys()
{
int n;
jdns_dnsparams_t *params;
#ifdef JDNS_MODERN_RES_API
struct __res_state res;
memset(&res, 0, sizeof(struct __res_state));
n = res_ninit(&res);
#define RESVAR res
#else
n = my_res_init();
#define RESVAR _res
#endif
params = jdns_dnsparams_new();
// error initializing?
if(n == -1)
return params;
#ifdef USE_INDEP_EXT
for(n = 0; n < MAXNS && n < RESVAR.nscount; ++n)
{
struct sockaddr_in *sa = (struct sockaddr_in*)&(_res_ext.nsaddr_list[n]);
jdns_address_t *addr = jdns_address_new();
if (sa->sin_family = AF_INET6) {
struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
jdns_address_set_ipv6(addr, sa6->sin6_addr.s6_addr);
} else {
jdns_address_set_ipv4(addr, ntohl(sa->sin_addr.s_addr));
}
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
#else
// nameservers - ipv6
#ifdef __GLIBC__
for(n = 0; n < MAXNS; ++n)
#else
for(n = 0; n < MAXNS && n < RESVAR._u._ext.nscount; ++n)
#endif
{
jdns_address_t *addr;
struct sockaddr_in6 *sa6;
#ifdef USE_EXTEXT
// seems _ext.ext can be null in some cases...
if(RESVAR._u._ext.ext == NULL)
break;
sa6 = ((struct sockaddr_in6 *)RESVAR._u._ext.ext) + n;
#else
sa6 = RESVAR._u._ext.nsaddrs[n];
#endif
if(sa6 == NULL)
continue;
addr = jdns_address_new();
jdns_address_set_ipv6(addr, sa6->sin6_addr.s6_addr);
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
// nameservers - ipv4
#ifdef __GLIBC__
int ns4count = RESVAR.nscount - RESVAR._u._ext.nscount6;
for(n = 0; n < MAXNS && n < ns4count; ++n)
#else
for(n = 0; n < MAXNS && n < RESVAR.nscount; ++n)
#endif
{
jdns_address_t *addr = jdns_address_new();
jdns_address_set_ipv4(addr, ntohl(RESVAR.nsaddr_list[n].sin_addr.s_addr));
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
#endif
// domain name
if(strlen(RESVAR.defdname) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.defdname);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
// search list
#ifdef MAXDFLSRCH
for(n = 0; n < MAXDFLSRCH && RESVAR.dnsrch[n]; ++n)
{
if(strlen(RESVAR.dnsrch[n]) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.dnsrch[n]);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
// don't add dups
if(!dnsparams_have_domain(params, str))
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
}
#endif
return params;
}
static jdns_string_t *string_simplify(const jdns_string_t *in)
{
int n;
int pos;
int total;
unsigned char *out;
int outlen;
jdns_string_t *outstr;
jdns_stringlist_t *wordlist;
// gather words and total of lengths
pos = 0;
total = 0;
wordlist = jdns_stringlist_new();
while(1)
{
jdns_string_t *word;
unsigned char *str = string_getnextword(in->data, in->size, pos, &pos);
if(!str)
break;
word = jdns_string_new();
jdns_string_set_cstr(word, (char *)str);
jdns_free(str);
jdns_stringlist_append(wordlist, word);
total += word->size;
jdns_string_delete(word);
}
if(total == 0)
{
jdns_stringlist_delete(wordlist);
outstr = jdns_string_new();
jdns_string_set_cstr(outstr, "");
return outstr;
}
// we need to allocate space for total lengths and wordcount-1 spaces
outlen = total + (wordlist->count - 1);
out = (unsigned char *)jdns_alloc(outlen);
// lay out the words
pos = 0;
for(n = 0; n < wordlist->count; ++n)
{
unsigned char *data = wordlist->item[n]->data;
int size = wordlist->item[n]->size;
memcpy(out + pos, data, size);
pos += size;
// if this is not the last word, append a space
if(n + 1 < wordlist->count)
out[pos++] = ' ';
}
jdns_stringlist_delete(wordlist);
outstr = jdns_string_new();
jdns_string_set(outstr, out, outlen);
jdns_free(out);
return outstr;
}
// lookup list is made of jdns_packet_labels
static int writelabel(const jdns_string_t *name, int at, int left, unsigned char **bufp, jdns_list_t *lookup)
{
unsigned char label[MAX_LABEL_LENGTH];
int n, i, len;
unsigned char *l;
unsigned char *ref;
int refsize;
len = name_to_label(name, label);
if(len == -1)
return 0;
ref = *bufp - at;
refsize = at + left;
for(n = 0; label[n]; n += label[n] + 1)
{
for(i = 0; i < lookup->count; ++i)
{
jdns_packet_label_t *pl = (jdns_packet_label_t *)lookup->item[i];
if(matchlabel(label + n, len - n, pl->value->data, pl->value->size, ref, refsize, 8, 8))
{
// set up a pointer right here, overwriting
// the length byte and the first content
// byte of this section within 'label'.
// this is safe, because the length value
// will always be greater than zero,
// ensuring we have two bytes available to
// use.
l = label + n;
short2net((unsigned short int)pl->offset, &l);
label[n] |= 0xc0;
len = n + 2; // cut things short
break;
}
}
if(label[n] & 0xc0) // double loop, so break again
break;
}
if(left < len)
return 0;
// copy into buffer, point there now
memcpy(*bufp, label, len);
l = *bufp;
*bufp += len;
// for each new label, store its location for future compression
for(n = 0; l[n]; n += l[n] + 1)
{
jdns_string_t *str;
jdns_packet_label_t *pl;
if(l[n] & 0xc0)
break;
pl = jdns_packet_label_new();
str = jdns_string_new();
jdns_string_set(str, l + n, len - n);
pl->offset = l + n - ref;
pl->value = str;
jdns_list_insert(lookup, pl, -1);
}
return 1;
}
static int readlabel(const unsigned char *in, int insize, const unsigned char *ref, int refsize, int *_at, jdns_string_t **name)
{
int at;
// string format is one character smaller than dns format. e.g.:
// dns: [7] affinix [3] com [0] = 13 bytes
// string: "affinix.com." = 12 bytes
// only exception is '.' itself, but that won't influence the max.
unsigned char out[MAX_LABEL_LENGTH - 1];
int out_size;
const unsigned char *label, *last;
int hopped_yet;
int hopsleft;
int label_size;
at = *_at;
// stay in range
if(at < 0 || at >= insize)
return 0;
out_size = 0;
label = in + at;
hopped_yet = 0;
last = in + insize;
while(1)
{
// need a byte
if(label + 1 > last)
goto error;
// we make this a while loop instead of an 'if', in case
// there's a pointer to a pointer. as a precaution,
// we will hop no more than 8 times
hopsleft = 8;
while(*label & 0xc0)
{
int offset;
// need the next byte, too
if(label + 2 > last)
goto error;
offset = getoffset(label, refsize, &hopsleft);
if(offset == -1)
goto error;
label = ref + offset;
if(!hopped_yet)
{
at += 2;
hopped_yet = 1;
last = ref + refsize;
}
// need a byte
if(label + 1 > last)
goto error;
}
label_size = *label & 0x3f;
// null label? then we're done
if(label_size == 0)
{
if(!hopped_yet)
++at;
break;
}
// enough source bytes? (length byte + length)
if(label + label_size + 1 > last)
goto error;
// enough dest bytes? (length + dot)
if(out_size + label_size + 1 > MAX_LABEL_LENGTH - 1)
goto error;
memcpy(out + out_size, label + 1, label_size);
out_size += label_size;
out[out_size] = '.';
++out_size;
if(!hopped_yet)
at += label_size + 1;
label += label_size + 1;
}
*_at = at;
*name = jdns_string_new();
jdns_string_set(*name, out, out_size);
return 1;
error:
return 0;
}
static int readlabel(const unsigned char *in, int insize, const unsigned char *ref, int refsize, int *_at, jdns_string_t **name)
{
int at;
unsigned char out[255];
int out_size;
const unsigned char *label, *last;
int hopped_yet;
int hopsleft;
int label_size;
at = *_at;
// stay in range
if(at < 0 || at >= insize)
return 0;
out_size = 0;
label = in + at;
hopped_yet = 0;
last = in + insize;
while(1)
{
// need a byte
if(label + 1 > last)
goto error;
// we make this a while loop instead of an 'if', in case
// there's a pointer to a pointer. as a precaution,
// we will hop no more than 8 times
hopsleft = 8;
while(*label & 0xc0)
{
int offset;
// need the next byte, too
if(label + 2 > last)
goto error;
offset = getoffset(label, refsize, &hopsleft);
if(offset == -1)
goto error;
label = ref + offset;
if(!hopped_yet)
{
at += 2;
hopped_yet = 1;
last = ref + refsize;
}
// need a byte
if(label + 1 > last)
goto error;
}
label_size = *label & 0x3f;
// null label? then we're done
if(label_size == 0)
{
if(!hopped_yet)
++at;
break;
}
// enough source bytes? (length byte + length)
if(label + label_size + 1 > last)
goto error;
// enough dest bytes? (length + dot)
if(out_size + label_size + 1 > 255)
goto error;
memcpy(out + out_size, label + 1, label_size);
out_size += label_size;
out[out_size] = '.';
++out_size;
if(!hopped_yet)
at += label_size + 1;
label += label_size + 1;
}
*_at = at;
*name = jdns_string_new();
jdns_string_set(*name, out, out_size);
return 1;
error:
return 0;
}
static jdns_dnsparams_t *dnsparams_get_unixsys()
{
int n;
jdns_dnsparams_t *params;
#ifdef JDNS_MODERN_RES_API
struct __res_state res;
memset(&res, 0, sizeof(struct __res_state));
n = res_ninit(&res);
#define RESVAR res
#else
n = my_res_init();
#define RESVAR _res
#endif
params = jdns_dnsparams_new();
// error initializing?
if(n == -1)
return params;
// nameservers - ipv6
for(n = 0; n < MAXNS && n < RESVAR._u._ext.nscount; ++n)
{
jdns_address_t *addr;
struct sockaddr_in6 *sa6;
#ifdef USE_EXTEXT
sa6 = ((struct sockaddr_in6 *)RESVAR._u._ext.ext) + n;
#else
sa6 = RESVAR._u._ext.nsaddrs[n];
#endif
if(sa6 == NULL)
continue;
addr = jdns_address_new();
jdns_address_set_ipv6(addr, sa6->sin6_addr.s6_addr);
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
// nameservers - ipv4
for(n = 0; n < MAXNS && n < RESVAR.nscount; ++n)
{
jdns_address_t *addr = jdns_address_new();
jdns_address_set_ipv4(addr, ntohl(RESVAR.nsaddr_list[n].sin_addr.s_addr));
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
// domain name
if(strlen(RESVAR.defdname) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.defdname);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
// search list
#ifdef MAXDFLSRCH
for(n = 0; n < MAXDFLSRCH && RESVAR.dnsrch[n]; ++n)
{
if(strlen(RESVAR.dnsrch[n]) > 0)
{
jdns_string_t *str;
jdns_string_t *p;
str = jdns_string_new();
jdns_string_set_cstr(str, RESVAR.dnsrch[n]);
p = string_tolower(str);
jdns_string_delete(str);
str = p;
// don't add dups
if(!dnsparams_have_domain(params, str))
jdns_dnsparams_append_domain(params, str);
jdns_string_delete(str);
}
}
#endif
return params;
}
