static jdns_dnshostlist_t *read_hosts_file(const char *path)
{
jdns_dnshostlist_t *out;
FILE *f;
jdns_string_t *line, *simp;
jdns_stringlist_t *parts;
jdns_address_t *addr;
int n;
out = jdns_dnshostlist_new();
f = jdns_fopen(path, "r");
if(!f)
return out;
while(1)
{
line = file_nextline(f);
if(!line)
break;
// truncate at comment
n = string_indexOf(line, '#', 0);
if(n != -1)
{
line->size = n;
line->data[n] = 0;
}
simp = string_simplify(line);
jdns_string_delete(line);
parts = string_split(simp, ' ');
jdns_string_delete(simp);
if(parts->count < 2)
{
jdns_stringlist_delete(parts);
continue;
}
addr = jdns_address_new();
if(!jdns_address_set_cstr(addr, (const char *)parts->item[0]->data))
{
jdns_address_delete(addr);
jdns_stringlist_delete(parts);
continue;
}
for(n = 1; n < parts->count; ++n)
{
jdns_dnshost_t *h = jdns_dnshost_new();
h->name = jdns_string_copy(parts->item[n]);
h->address = jdns_address_copy(addr);
jdns_dnshostlist_append(out, h);
jdns_dnshost_delete(h);
}
jdns_address_delete(addr);
jdns_stringlist_delete(parts);
}
fclose(f);
return out;
}
static jdns_dnsparams_t *dnsparams_get_unixfiles()
{
FILE *f;
int n;
jdns_dnsparams_t *params;
jdns_string_t *line, *simp;
jdns_stringlist_t *parts;
params = jdns_dnsparams_new();
f = jdns_fopen("/etc/resolv.conf", "r");
if(!f)
return params;
while(1)
{
line = file_nextline(f);
if(!line)
break;
// truncate at comment
n = string_indexOf(line, '#', 0);
if(n != -1)
{
line->size = n;
line->data[n] = 0;
}
simp = string_simplify(line);
jdns_string_delete(line);
parts = string_split(simp, ' ');
jdns_string_delete(simp);
if(parts->count < 2)
{
jdns_stringlist_delete(parts);
continue;
}
simp = string_tolower(parts->item[0]);
if(strcmp((char *)simp->data, "nameserver") == 0)
{
jdns_address_t *addr = jdns_address_new();
jdns_address_set_cstr(addr, (const char *)parts->item[1]->data);
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
else if(strcmp((char *)simp->data, "search") == 0)
{
for(n = 1; n < parts->count; ++n)
{
jdns_dnsparams_append_domain(params, parts->item[n]);
}
}
else if(strcmp((char *)simp->data, "domain") == 0)
{
jdns_dnsparams_append_domain(params, parts->item[1]);
}
jdns_string_delete(simp);
jdns_stringlist_delete(parts);
}
fclose(f);
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;
}
static jdns_dnsparams_t *dnsparams_get_winreg()
{
int n;
jdns_dnsparams_t *params;
HKEY key;
int ret;
char sep;
jdns_string_t *str_domain, *str_nameserver, *str_searchlist;
jdns_stringlist_t *list_nameserver, *list_searchlist;
sep = ' ';
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
"System\\CurrentControlSet\\Services\\Tcpip\\Parameters",
0, KEY_READ, &key);
if(ret != ERROR_SUCCESS)
{
sep = ',';
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
"System\\CurrentControlSet\\Services\\VxD\\MSTCP",
0, KEY_READ, &key);
if(ret != ERROR_SUCCESS)
return 0;
}
str_domain = reg_readString(key, "DhcpDomain");
if(!str_domain)
str_domain = reg_readString(key, "Domain");
str_nameserver = reg_readString(key, "DhcpNameServer");
if(!str_nameserver)
str_nameserver = reg_readString(key, "NameServer");
str_searchlist = reg_readString(key, "SearchList");
RegCloseKey(key);
list_nameserver = 0;
if(str_nameserver)
{
list_nameserver = string_split(str_nameserver, sep);
jdns_string_delete(str_nameserver);
}
list_searchlist = 0;
if(str_searchlist)
{
// lowercase the string
jdns_string_t *p = string_tolower(str_searchlist);
jdns_string_delete(str_searchlist);
str_searchlist = p;
list_searchlist = string_split(str_searchlist, sep);
jdns_string_delete(str_searchlist);
}
params = jdns_dnsparams_new();
if(list_nameserver)
{
// qt seems to do a strange thing here by running each name
// server address through the q3dns setLabel function, and
// then pulls the result as a list of addresses. i have
// no idea why they do this, or how one IP address would
// turn into anything else, let alone several addresses.
// so, uh, we're not going to do that.
for(n = 0; n < list_nameserver->count; ++n)
{
jdns_address_t *addr = jdns_address_new();
if(jdns_address_set_cstr(addr, (char *)list_nameserver->item[n]->data))
jdns_dnsparams_append_nameserver(params, addr, JDNS_UNICAST_PORT);
jdns_address_delete(addr);
}
jdns_stringlist_delete(list_nameserver);
}
if(str_domain)
{
if(str_domain->size > 0)
jdns_dnsparams_append_domain(params, str_domain);
jdns_string_delete(str_domain);
}
if(list_searchlist)
{
for(n = 0; n < list_searchlist->count; ++n)
{
if(list_searchlist->item[n]->size > 0)
jdns_dnsparams_append_domain(params, list_searchlist->item[n]);
}
jdns_stringlist_delete(list_searchlist);
}
return params;
}
