int
main(int count, char **options) {
int res;
if (strcmp(options[1], "-d") != 0) {
res = daemon(0, 0);
printf("return value: %s\n", res);
}
res_init();
_res.retrans = 4;
_res.retry = 2;
int running = 1;
if (parse_config()) {
printf("error reading configuration!\n");
return 1;
}
if (open_status_socket())
printf("error opening status socket; no status will be provided\n");
stat(config_file, &config_last_mod);
printf("last config modified time: %s\n", ctime(&config_last_mod.st_mtime));
while (running) {
struct config_interfaces *cur = config;
printf("checking if conf file has changed\n");
if (config_changed()) {
printf("modifying:\n");
clear_config(config);
cur = 0;
if (parse_config())
printf("error reading configuration!\n");
else
cur = config;
}
while (cur) {
if (check_interface(cur)) {
printf("media type: %s\n", mediatype(cur->if_name));
if (strcmp(mediatype(cur->if_name), "Ethernet") == 0) {
if (setup_ethernetinterface(cur))
break;
} else if (strcmp(mediatype(cur->if_name), "IEEE802.11") == 0) {
if (setup_wlaninterface(cur))
break;
}
}
cur = cur->next;
}
printf("Sleeping... waiting %d seconds\n", poll_wait);
sleep(poll_wait);
printf("restarto\n");
}
return 0;
}
int
nres_search(struct nres *block)
{
register char *cp, *domain;
int n;
if ((_res.options & RES_INIT) == 0 && res_init() == -1)
return (-1);
block->retries = 0; /* start clock */
if (block->search_index < 0)
return (-1);
/* only try exact match for reverse cases */
if (block->reverse) {
(void) nres_querydomain(block->name, (char *)NULL,
block->search_name);
block->search_index = -1;
return (0);
}
for (cp = block->name, n = 0; *cp; cp++)
if (*cp == '.')
n++;
/* n indicates the presence of trailing dots */
if (block->search_index == 0) {
if (n == 0 && (cp = nres_hostalias(block->name))) {
(void) strncpy(block->search_name, cp, 2 * MAXDNAME);
block->search_index = -1; /* if hostalias try 1 name */
return (0);
}
}
if ((n == 0 || *--cp != '.') && (_res.options & RES_DEFNAMES)) {
domain = _res.dnsrch[block->search_index];
if (domain) {
(void) nres_querydomain(block->name, domain,
block->search_name);
block->search_index++;
return (0);
}
}
if (n) {
(void) nres_querydomain(block->name, (char *)NULL,
block->search_name);
block->search_index = -1;
return (0);
}
block->search_index = -1;
return (-1);
}
void
Settings::ReadConfiguration()
{
BNetworkInterface interface(fName);
BNetworkInterfaceAddress address;
// TODO: We only get the first address
if (interface.GetAddressAt(0, address) != B_OK)
return;
fIP = address.Address().ToString();
fNetmask = address.Mask().ToString();
if (GetDefaultGateway(fGateway) != B_OK)
return;
uint32 flags = interface.Flags();
fAuto = (flags & (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
fDisabled = (flags & IFF_UP) == 0;
// Read wireless network from interfaces
fWirelessNetwork.SetTo(NULL);
BNetworkDevice networkDevice(fName);
if (networkDevice.IsWireless()) {
uint32 networkIndex = 0;
wireless_network wirelessNetwork;
// TODO: We only get the first associated network for now
if (networkDevice.GetNextAssociatedNetwork(networkIndex,
wirelessNetwork) == B_OK) {
fWirelessNetwork.SetTo(wirelessNetwork.name);
}
}
// read resolv.conf for the dns.
fNameServers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameServers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
fDomain = state->dnsrch[0];
}
}
errno_t
monitor_common_res_init(TALLOC_CTX *mem_ctx,
struct sbus_request *sbus_req,
void *no_data)
{
int ret;
ret = res_init();
if (ret != 0) {
return EIO;
}
return EOK;
}
static void resolver_init(void)
{
#ifdef G_OS_UNIX
static time_t resolv_conf_mtime = 0;
struct stat s;
if (g_stat("/etc/resolv.conf", &s) == 0 &&
s.st_mtime != resolv_conf_mtime) {
debug_print("Reloading /etc/resolv.conf\n");
resolv_conf_mtime = s.st_mtime;
res_init();
}
#endif
}
int
utGetDomainInfo(char **szDefDomain, char **szDefServer)
{
if (res_init() != 0)
return 1;
*szDefDomain = calloc(257, sizeof(char));
memcpy(*szDefDomain, _res.defdname, 256);
if (strnlen(*szDefDomain, 256) == 0)
*szDefDomain[0] = '-';
*szDefServer = calloc(IFNAMSIZ, sizeof(char));
memcpy(*szDefServer, inet_ntoa(_res.nsaddr_list[0].sin_addr), IFNAMSIZ-1);
res_close();
return 0;
}
static int my_res_init()
{
#ifdef JDNS_OS_MAC
res_init_func mac_res_init;
// look up res_init in the system library (qt does this, not sure why)
mac_res_init = (res_init_func)dlsym(RTLD_NEXT, "res_init");
if(!mac_res_init)
return -1;
return mac_res_init();
#else
return res_init();
#endif
}
std::vector<std::string> CNetworkLinux::GetNameServers(void)
{
std::vector<std::string> result;
#if defined(TARGET_DARWIN)
FILE* pipe = popen("scutil --dns | grep \"nameserver\" | tail -n2", "r");
usleep(100000);
if (pipe)
{
std::vector<std::string> tmpStr;
char buffer[256] = {'\0'};
if (fread(buffer, sizeof(char), sizeof(buffer), pipe) > 0 && !ferror(pipe))
{
tmpStr = StringUtils::Split(buffer, "\n");
for (unsigned int i = 0; i < tmpStr.size(); i ++)
{
// result looks like this - > ' nameserver[0] : 192.168.1.1'
// 2 blank spaces + 13 in 'nameserver[0]' + blank + ':' + blank == 18 :)
if (tmpStr[i].length() >= 18)
result.push_back(tmpStr[i].substr(18));
}
}
pclose(pipe);
}
if (result.empty())
CLog::Log(LOGWARNING, "Unable to determine nameserver");
#elif defined(TARGET_ANDROID)
char nameserver[PROP_VALUE_MAX];
if (__system_property_get("net.dns1",nameserver))
result.push_back(nameserver);
if (__system_property_get("net.dns2",nameserver))
result.push_back(nameserver);
if (__system_property_get("net.dns3",nameserver))
result.push_back(nameserver);
if (!result.size())
CLog::Log(LOGWARNING, "Unable to determine nameserver");
#else
res_init();
for (int i = 0; i < _res.nscount; i ++)
{
std::string ns = inet_ntoa(((struct sockaddr_in *)&_res.nsaddr_list[i])->sin_addr);
result.push_back(ns);
}
#endif
return result;
}
static int make_resolv (char *ifname, dhcp_t *dhcp, int wait)
{
FILE *f;
struct stat buf;
char resolvconf[PATH_MAX];
address_t *address;
if (!stat ("/sbin/resolvconf", &buf))
{
logger (LOG_DEBUG, "sending DNS information to resolvconf");
snprintf (resolvconf, PATH_MAX, "/sbin/resolvconf -a %s", ifname);
f = popen (resolvconf, "w");
if (!f)
logger (LOG_ERR, "popen: %m");
}
else
{
if (! (f = fopen(RESOLVFILE, "w")))
logger (LOG_ERR, "fopen `%s': %m", RESOLVFILE);
}
if (f)
{
fprintf (f, "# Generated by dhcpcd for interface %s\n", ifname);
if (dhcp->dnssearch)
fprintf (f, "search %s\n", dhcp->dnssearch);
else if (dhcp->dnsdomain) {
fprintf (f, "search %s\n", dhcp->dnsdomain);
}
for (address = dhcp->dnsservers; address; address = address->next)
fprintf (f, "nameserver %s\n", inet_ntoa (address->address));
if (resolvconf)
{
pclose (f);
logger (LOG_DEBUG, "resolvconf completed");
}
else
fclose (f);
}
else
return -1;
/* Refresh the local resolver */
res_init ();
return 0;
}
struct hostent *
gethostbyname(const char *name)
{
struct hostent *hp = NULL;
if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
h_errno = NETDB_INTERNAL;
return (NULL);
}
if (_res.options & RES_USE_INET6) { /* XXX */
hp = gethostbyname2(name, AF_INET6); /* XXX */
if (hp) /* XXX */
return (hp); /* XXX */
} /* XXX */
return (gethostbyname2(name, AF_INET));
}
U_CFUNC void
res_load(ResourceData *pResData,
const char *path, const char *name, UErrorCode *errorCode) {
UVersionInfo formatVersion;
uprv_memset(pResData, 0, sizeof(ResourceData));
/* load the ResourceBundle file */
pResData->data=udata_openChoice(path, "res", name, isAcceptable, formatVersion, errorCode);
if(U_FAILURE(*errorCode)) {
return;
}
/* get its memory and initialize *pResData */
res_init(pResData, formatVersion, udata_getMemory(pResData->data), -1, errorCode);
}
U_CAPI void U_EXPORT2
res_read(ResourceData *pResData,
const UDataInfo *pInfo, const void *inBytes, int32_t length,
UErrorCode *errorCode) {
UVersionInfo formatVersion;
uprv_memset(pResData, 0, sizeof(ResourceData));
if(U_FAILURE(*errorCode)) {
return;
}
if(!isAcceptable(formatVersion, NULL, NULL, pInfo)) {
*errorCode=U_INVALID_FORMAT_ERROR;
return;
}
res_init(pResData, formatVersion, inBytes, length, errorCode);
}
int main( int argc, char ** argv ) {
char domain[ MYMAX ];
int len = 0;
unsigned int res;
int a, i, j, k, l, n, t;
res_init();
len = res_query( argv[1], C_IN, T_MX, buff, MYMAX );
printf( "MX records for gmail.com len =%d\n", len );
a = ReadHeader();
if ( getAnswerRecordCount() > 0 ) {
printf("\n;; Answer section:\n");
for ( i = 0; i < getAnswerRecordCount(); i++ ) {
a = ReadRecord( a );
}
}
if ( getAuthRecordCount() > 0 ) {
printf("\n;; Authority section:\n");
for ( i = 0; i < getAuthRecordCount(); i++ ) {
a = ReadRecord( a );
}
}
if ( getAdditionalRecordCount() > 0 ) {
printf("\n;; Additional section:\n");
for ( i = 0; i < getAdditionalRecordCount(); i++ ) {
a = ReadRecord( a );
}
}
/*
for( a=0; a < len; a++ ) {
printf( "[ %d ] = %d, %c\n", a, buff[ a ], buff[ a ] );
}
for( ; a < len; a++ ) {
printf( "buff[ %d ] = %d, %c\n", a, buff[ a ], buff[ a ] );
}
*/
}
static int make_resolv (const char *ifname, const dhcp_t *dhcp)
{
FILE *f;
struct stat buf;
char resolvconf[PATH_MAX] = {0};
address_t *address;
if (stat (RESOLVCONF, &buf) == 0)
{
logger (LOG_DEBUG, "sending DNS information to resolvconf");
snprintf (resolvconf, PATH_MAX, RESOLVCONF" -a %s", ifname);
f = popen (resolvconf, "w");
if (! f)
logger (LOG_ERR, "popen: %s", strerror (errno));
}
else
{
logger (LOG_DEBUG, "writing "RESOLVFILE);
if (! (f = fopen(RESOLVFILE, "w")))
logger (LOG_ERR, "fopen `%s': %s", RESOLVFILE, strerror (errno));
}
if (f)
{
fprintf (f, "# Generated by dhcpcd for interface %s\n", ifname);
if (dhcp->dnssearch)
fprintf (f, "search %s\n", dhcp->dnssearch);
else if (dhcp->dnsdomain) {
fprintf (f, "search %s\n", dhcp->dnsdomain);
}
for (address = dhcp->dnsservers; address; address = address->next)
fprintf (f, "nameserver %s\n", inet_ntoa (address->address));
if (*resolvconf)
pclose (f);
else
fclose (f);
}
else
return -1;
/* Refresh the local resolver */
res_init ();
return 0;
}
void
Settings::ReadConfiguration()
{
BNetworkInterface interface(fName);
BNetworkAddress hardwareAddress;
if (interface.GetHardwareAddress(hardwareAddress) != B_OK)
return;
fHardwareAddress = hardwareAddress.ToString();
BNetworkInterfaceAddress address;
// TODO: We only get the first address
if (interface.GetAddressAt(0, address) != B_OK)
return;
fIP = address.Address().ToString();
fNetmask = address.Mask().ToString();
int family = AF_INET;
if (address.Address().Family() != AF_UNSPEC)
family = address.Address().Family();
BNetworkAddress gatewayAddress;
if (interface.GetDefaultRoute(family, gatewayAddress) != B_OK)
return;
fGateway = gatewayAddress.ToString();
uint32 flags = interface.Flags();
fAuto = (flags & (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
fDisabled = (flags & IFF_UP) == 0;
// read resolv.conf for the dns.
fNameServers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameServers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
fDomain = state->dnsrch[0];
}
}
std::vector<IpAddr>
ip_utils::getLocalNameservers()
{
std::vector<IpAddr> res;
#if defined __ANDROID__ || defined _WIN32 || TARGET_OS_IPHONE
#ifdef _MSC_VER
#pragma message (__FILE__ "(" STR2(__LINE__) ") : -NOTE- " "Not implemented")
#else
#warning "Not implemented"
#endif
#else
if (not (_res.options & RES_INIT))
res_init();
res.insert(res.end(), _res.nsaddr_list, _res.nsaddr_list + _res.nscount);
#endif
return res;
}
void Resolver::setNameserver(char *nameserver) throw (std::invalid_argument)
{
if (nameserver == NULL) {
throw std::invalid_argument("Cannot use empty nameserver");
}
int ret;
struct addrinfo *result;
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_protocol = 0;
ret = getaddrinfo(nameserver, "domain", &hints, &result);
if (ret != 0) {
std::string err = std::string("Unable to resolve address '") + nameserver + "': " + gai_strerror(ret);
throw std::invalid_argument(err);
}
res_init();
if (result->ai_addr->sa_family == AF_INET) {
#ifdef DEBUG
std::cerr << "Setting up IPv4 DNS server with address " << nameserver << std::endl;
#endif
struct sockaddr_in *sock4 = (struct sockaddr_in *) result->ai_addr;
memcpy((void *)&_res.nsaddr_list[0], sock4, result->ai_addrlen);
_res.nscount = 1;
} else if (result->ai_addr->sa_family == AF_INET6) {
std::cerr << "IPv6 addresses are not supported for DNS server." << std::endl;
/*
struct sockaddr_in6 *sock6 = (struct sockaddr_in6 *) result->ai_addr;
memcpy((void *)&_res.nsaddr_list[0], sock6, result->ai_addrlen);
_res.nscount = 1;
*/
} else {
std::string err = std::string("Unable to resolve address for ") + nameserver + ": " + "Unknown address family";
throw std::invalid_argument(err);
}
freeaddrinfo(result);
this->nameserver = nameserver;
}
/* ________________________________________________________________________ */
int nslookup_main(int argc, char **argv)
{
struct hostent *host;
if (argc < 2 || *argv[1]=='-') {
show_usage();
}
res_init();
server_print();
if (is_ip_address(argv[1])) {
host = gethostbyaddr_wrapper(argv[1]);
} else {
host = gethostbyname(argv[1]);
}
hostent_fprint(host, 0);
return EXIT_SUCCESS;
}
struct nb_dns_info *
nb_dns_init(char *errstr)
{
register struct nb_dns_info *nd;
nd = (struct nb_dns_info *)malloc(sizeof(*nd));
if (nd == NULL) {
snprintf(errstr, NB_DNS_ERRSIZE, "nb_dns_init: malloc(): %s",
my_strerror(errno));
return (NULL);
}
memset(nd, 0, sizeof(*nd));
nd->s = -1;
/* XXX should be able to init static hostent struct some other way */
(void)gethostbyname("localhost.");
if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
snprintf(errstr, NB_DNS_ERRSIZE, "res_init() failed");
free(nd);
return (NULL);
}
nd->s = socket(PF_INET, SOCK_DGRAM, 0);
if (nd->s < 0) {
snprintf(errstr, NB_DNS_ERRSIZE, "socket(): %s",
my_strerror(errno));
free(nd);
return (NULL);
}
/* XXX should use resolver config */
nd->server = _res.nsaddr_list[0];
if (connect(nd->s, (struct sockaddr *)&nd->server,
sizeof(struct sockaddr)) < 0) {
snprintf(errstr, NB_DNS_ERRSIZE, "connect(%s): %s",
inet_ntoa(nd->server.sin_addr), my_strerror(errno));
close(nd->s);
free(nd);
return (NULL);
}
return (nd);
}
/* Drop root privileges and chroot if necessary */
static void
droproot(const char *username, const char *chroot_dir)
{
struct passwd *pw = NULL;
if (chroot_dir && !username) {
fprintf(stderr, "tcpdump: Chroot without dropping root is insecure\n");
exit(1);
}
pw = getpwnam(username);
if (pw) {
if (initgroups(pw->pw_name, pw->pw_gid) != 0) {
fprintf(stderr, "tcpdump: Couldn't initgroups to "
"'%.32s' gid=%lu: %s\n", pw->pw_name,
(unsigned long)pw->pw_gid,
pcap_strerror(errno));
exit(1);
}
if (chroot_dir) {
setprotoent(1);
res_init();
if (chroot(chroot_dir) != 0 || chdir ("/") != 0) {
fprintf(stderr, "tcpdump: Couldn't chroot/chdir to '%.64s': %s\n",
chroot_dir, pcap_strerror(errno));
exit(1);
}
}
if (setgid(pw->pw_gid) != 0 || setuid(pw->pw_uid) != 0) {
fprintf(stderr, "tcpdump: Couldn't change to "
"'%.32s' uid=%lu gid=%lu: %s\n",
username,
(unsigned long)pw->pw_uid,
(unsigned long)pw->pw_gid,
pcap_strerror(errno));
exit(1);
}
}
else {
fprintf(stderr, "tcpdump: Couldn't find user '%.32s'\n",
username);
exit(1);
}
}
struct hostent *
gethostbyname2(const char *name, int af)
{
int r;
res_init();
r = _gethostbyname(name, af, &_hostent, _entbuf, sizeof(_entbuf),
&h_errno);
if (r) {
h_errno = NETDB_INTERNAL;
errno = r;
}
if (h_errno)
return (NULL);
return (&_hostent);
}
/*
Turn a string into a struct addrinfo.
Return NULL on failure.
*/
struct addrinfo *str2addrinfo(const char *address, const char *service, int socktype) {
struct addrinfo *ai, hint = {0};
int err;
hint.ai_family = addressfamily;
hint.ai_socktype = socktype;
#if HAVE_DECL_RES_INIT
res_init();
#endif
err = getaddrinfo(address, service, &hint, &ai);
if(err) {
logger(DEBUG_ALWAYS, LOG_WARNING, "Error looking up %s port %s: %s", address, service, err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err));
return NULL;
}
return ai;
}
void query_as(char *arg, char *namelisten_addr, char *buf, int buflen) {
u_char nsbuf[4096];
ns_msg msg;
ns_rr rr;
int len;
// Set namelisten_addr
res_init();
struct in_addr listen_addr_in_addr;
if (inet_pton(AF_INET, namelisten_addr, &listen_addr_in_addr) > 0) {
_res.nscount = 1;
_res.nsaddr_list[0].sin_addr = listen_addr_in_addr;
}
len = res_query(arg, ns_c_any, ns_t_txt, nsbuf, sizeof(nsbuf));
ns_initparse(nsbuf, len, &msg);
ns_parserr(&msg, ns_s_an, 0, &rr);
ns_sprintrr(&msg, &rr, NULL, NULL, buf, buflen);
}
std::string CPosixConnection::GetNameServer() const
{
std::string nameserver("127.0.0.1");
#if defined(TARGET_ANDROID)
char ns[PROP_VALUE_MAX];
if (__system_property_get("net.dns1", ns))
nameserver = ns;
#else
res_init();
for (int i = 0; i < _res.nscount; i ++)
{
nameserver = inet_ntoa(((struct sockaddr_in *)&_res.nsaddr_list[0])->sin_addr);
break;
}
#endif
return nameserver;
}
static int
INET_resolve(char *name, struct sockaddr_in *sin)
{
struct hostent *hp;
struct netent *np;
/* Grmpf. -FvK */
sin->sin_family = AF_INET;
sin->sin_port = 0;
/* Default is special, meaning 0.0.0.0. */
if (!strcmp(name, "default")) {
sin->sin_addr.s_addr = INADDR_ANY;
return(1);
}
/* gethostbyname doesnt resolve this (Pavel Krauz) */
if (!(strcmp(name, "255.255.255.255"))) {
sin->sin_addr.s_addr = htonl(INADDR_BROADCAST);
return (1);
}
/* Try the NETWORKS database to see if this is a known network. */
if ((np = getnetbyname(name)) != (struct netent *)NULL) {
sin->sin_addr.s_addr = htonl(np->n_net);
strcpy(name, np->n_name);
return(1);
}
#ifdef DEBUG
res_init();
_res.options |= RES_DEBUG;
#endif
if ((hp = gethostbyname(name)) == (struct hostent *)NULL) {
errno = h_errno;
return(-1);
}
memcpy((char *) &sin->sin_addr, (char *) hp->h_addr_list[0], hp->h_length);
strcpy(name, hp->h_name);
return(0);
}
/* init. the resolver
* params: retr_time - time before retransmitting (must be >0)
* retr_no - retransmissions number
* servers_no - how many dns servers will be used
* (from the one listed in /etc/resolv.conf)
* search - if 0 the search list in /etc/resolv.conf will
* be ignored (HINT: even if you don't have a
* search list in resolv.conf, it's still better
* to set search to 0, because an empty seachlist
* means in fact search "" => it takes more time)
* If any of the parameters <0, the default (system specific) value
* will be used. See also resolv.conf(5).
* returns: 0 on success, -1 on error
*/
static int _resolv_init(void)
{
res_init();
#ifdef HAVE_RESOLV_RES
if (cfg_get(core, core_cfg, dns_retr_time)>0)
_res.retrans=cfg_get(core, core_cfg, dns_retr_time);
if (cfg_get(core, core_cfg, dns_retr_no)>0)
_res.retry=cfg_get(core, core_cfg, dns_retr_no);
if ((cfg_get(core, core_cfg, dns_servers_no)>=0)
&& (cfg_get(core, core_cfg, dns_servers_no)<_res.nscount))
_res.nscount=cfg_get(core, core_cfg, dns_servers_no);
if (cfg_get(core, core_cfg, dns_search_list)==0)
_res.options&=~(RES_DEFNAMES|RES_DNSRCH);
#else
#warning "no resolv timeout support"
LOG(L_WARN, "WARNING: _resolv_init: no resolv options support - resolv"
" options will be ignored\n");
#endif
return 0;
}
char* getMailserver(const char* domain) {
int len;
char answer[NS_PACKETSZ];
char *mailserver = malloc(NS_PACKETSZ);
ns_msg msg;
ns_rr rr;
if(res_init() == -1) {
return NULL;
}
len = res_query(domain,C_ANY,T_MX,answer,NS_PACKETSZ);
if(len == -1) {
return NULL;
}
/* return first MX record */
ns_initparse(answer,len,&msg);
ns_parserr(&msg,ns_s_an,0,&rr);
dn_expand(ns_msg_base(msg),ns_msg_base(msg)+ns_msg_size(msg),ns_rr_rdata(rr)+NS_INT16SZ,mailserver,NS_PACKETSZ);
return mailserver;
}
extern "C" void init_dns(const char* root_domain) {
srand(time(NULL));
res_init();
std::string tmp("sock.");
tmp += root_domain;
SOCK_SUFFIX = new char [tmp.length()+1];
strcpy(SOCK_SUFFIX, tmp.c_str());
tmp = "snd.";
tmp += root_domain;
SEND_SUFFIX = new char [tmp.length()+1];
strcpy(SEND_SUFFIX, tmp.c_str());
tmp = "recv.";
tmp += root_domain;
RECV_SUFFIX = new char [tmp.length()+1];
strcpy(RECV_SUFFIX, tmp.c_str());
tmp = "cls.";
tmp += root_domain;
CLS_SUFFIX = new char [tmp.length()+1];
strcpy(CLS_SUFFIX, tmp.c_str());
}
void refresh_resolvers(void)
{
#ifdef G_OS_UNIX
static time_t resolv_conf_changed = (time_t)NULL;
struct stat s;
/* This makes the glibc re-read resolv.conf, if it changed
* since our startup. Maybe that should be #ifdef'ed, I don't
* know if it'd work on BSDs.
* Why doesn't the glibc do it by itself?
*/
if (stat("/etc/resolv.conf", &s) == 0) {
if (s.st_mtime > resolv_conf_changed) {
resolv_conf_changed = s.st_mtime;
res_init();
}
} /* else
we'll have bigger problems. */
#endif /*G_OS_UNIX*/
}
void get_dns(list_head_t *head) {
const int32_t ret_v = res_init();
dns_t *node = NULL;
uint32_t i = 0;
if (ret_v != 0)
return;
for (i = 0; i < _res.nscount; i++) {
char *ret = inet_ntoa(_res.nsaddr_list[i].sin_addr);
if (ret != NULL && !is_local_host(ret)) {
node = malloc(sizeof(dns_t));
memset(node, 0, sizeof(dns_t));
strncpy(node->addr, ret, LEN_64);
list_add_tail(&(node->list), head);
node = NULL;
}
}
}
