#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <fcntl.h>
#include <pwd.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "mDNSEmbeddedAPI.h"
#include "mDNSDebug.h"
#include "mDNSPosix.h"
#include "uds_daemon.h"
#include "PlatformCommon.h"
#define uDNS_SERVERS_FILE "/etc/resolv.conf"
#define CONFIG_FILE "/etc/mdnsd.conf"
static domainname DynDNSZone; static domainname DynDNSHostname;
#define RR_CACHE_SIZE 500
static CacheEntity gRRCache[RR_CACHE_SIZE];
extern const char mDNSResponderVersionString[];
static int ParseDNSServers(mDNS *m, const char *filePath)
{
char line[256];
char nameserver[16];
char keyword[10];
int numOfServers = 0;
FILE *fp = fopen(filePath, "r");
if (fp == NULL) return -1;
while (fgets(line,sizeof(line),fp))
{
struct in_addr ina;
line[255]='\0'; if (sscanf(line,"%10s %15s", keyword, nameserver) != 2) continue; if (strncmp(keyword,"nameserver",10)) continue;
if (inet_aton(nameserver, (struct in_addr *)&ina) != 0)
{
mDNSAddr DNSAddr;
DNSAddr.type = mDNSAddrType_IPv4;
DNSAddr.ip.v4.NotAnInteger = ina.s_addr;
mDNS_AddDNSServer(m, &DNSAddr, NULL);
numOfServers++;
}
}
return (numOfServers > 0) ? 0 : -1;
}
static void Reconfigure(mDNS *m)
{
mDNSAddr DynDNSIP;
mDNS_SetPrimaryInterfaceInfo(m, NULL, NULL);
mDNS_DeleteDNSServers(m);
if (ParseDNSServers(m, uDNS_SERVERS_FILE) < 0)
LogMsg("Unable to parse DNS server list. Unicast DNS-SD unavailable");
ReadDDNSSettingsFromConfFile(m, CONFIG_FILE, &DynDNSHostname, &DynDNSZone, NULL);
FindDefaultRouteIP(&DynDNSIP);
if (DynDNSHostname.c[0]) mDNS_AddDynDNSHostName(m, &DynDNSHostname, NULL, NULL);
if (DynDNSIP.type) mDNS_SetPrimaryInterfaceInfo(m, &DynDNSIP, NULL);
}
static void ParseCmdLinArgs(int argc, char **argv)
{
if (argc > 1)
{
if (0 == strcmp(argv[1], "-debug")) mDNS_DebugMode = mDNStrue;
else printf("Usage: mDNSResponder [-debug]\n");
}
if (!mDNS_DebugMode)
{
int result = daemon(0, 0);
if (result != 0) { LogMsg("Could not run as daemon - exiting"); exit(result); }
#if __APPLE__
LogMsg("The POSIX mDNSResponder should only be used on OS X for testing - exiting");
exit(-1);
#endif
}
}
static void DumpStateLog(mDNS *const m)
{
LogMsgIdent(mDNSResponderVersionString, "---- BEGIN STATE LOG ----");
udsserver_info(m);
LogMsgIdent(mDNSResponderVersionString, "---- END STATE LOG ----");
}
static mStatus MainLoop(mDNS *m) {
sigset_t signals;
mDNSBool gotData = mDNSfalse;
mDNSPosixListenForSignalInEventLoop(SIGINT);
mDNSPosixListenForSignalInEventLoop(SIGTERM);
mDNSPosixListenForSignalInEventLoop(SIGUSR1);
mDNSPosixListenForSignalInEventLoop(SIGPIPE);
mDNSPosixListenForSignalInEventLoop(SIGHUP) ;
for (; ;)
{
struct timeval timeout;
mDNSs32 ticks;
if (!gotData)
{
mDNSs32 nextTimerEvent = mDNS_Execute(m);
nextTimerEvent = udsserver_idle(nextTimerEvent);
ticks = nextTimerEvent - mDNS_TimeNow(m);
if (ticks < 1) ticks = 1;
}
else ticks = 0;
timeout.tv_sec = ticks / mDNSPlatformOneSecond;
timeout.tv_usec = (ticks % mDNSPlatformOneSecond) * 1000000 / mDNSPlatformOneSecond;
(void) mDNSPosixRunEventLoopOnce(m, &timeout, &signals, &gotData);
if (sigismember(&signals, SIGHUP )) Reconfigure(m);
if (sigismember(&signals, SIGUSR1)) DumpStateLog(m);
if (sigismember(&signals, SIGPIPE)) LogMsg("Received SIGPIPE - ignoring");
if (sigismember(&signals, SIGINT) || sigismember(&signals, SIGTERM)) break;
}
return EINTR;
}
int main(int argc, char **argv)
{
#define mDNSRecord mDNSStorage
mDNS_PlatformSupport platformStorage;
mStatus err;
bzero(&mDNSRecord, sizeof mDNSRecord);
bzero(&platformStorage, sizeof platformStorage);
ParseCmdLinArgs(argc, argv);
err = mDNS_Init(&mDNSRecord, &platformStorage, gRRCache, RR_CACHE_SIZE, mDNS_Init_AdvertiseLocalAddresses,
mDNS_Init_NoInitCallback, mDNS_Init_NoInitCallbackContext);
if (mStatus_NoError == err)
err = udsserver_init();
Reconfigure(&mDNSRecord);
if (mStatus_NoError == err)
{
const struct passwd *pw = getpwnam("nobody");
if (pw != NULL)
setuid(pw->pw_uid);
else
LogMsg("WARNING: mdnsd continuing as root because user \"nobody\" does not exist");
}
if (mStatus_NoError == err)
err = MainLoop(&mDNSRecord);
mDNS_Close(&mDNSRecord);
if (udsserver_exit() < 0)
LogMsg("ExitCallback: udsserver_exit failed");
#if MDNS_DEBUGMSGS > 0
printf("mDNSResponder exiting normally with %ld\n", err);
#endif
return err;
}
#if MDNS_MALLOC_DEBUGGING >= 2
#define LogMalloc LogMsg
#else
#define LogMalloc(ARGS...) ((void)0)
#endif
mStatus udsSupportAddFDToEventLoop(int fd, udsEventCallback callback, void *context)
{
return mDNSPosixAddFDToEventLoop(fd, callback, context);
}
mStatus udsSupportRemoveFDFromEventLoop(int fd) {
return mDNSPosixRemoveFDFromEventLoop(fd);
close(fd);
}
mDNSexport void RecordUpdatedNiceLabel(mDNS *const m, mDNSs32 delay)
{
(void)m;
(void)delay;
}
#if MACOSX_MDNS_MALLOC_DEBUGGING >= 1
void *mallocL(char *msg, unsigned int size)
{
unsigned long *mem = malloc(size+8);
if (!mem)
{
LogMsg("malloc( %s : %d ) failed", msg, size);
return(NULL);
}
else
{
LogMalloc("malloc( %s : %lu ) = %p", msg, size, &mem[2]);
mem[0] = 0xDEAD1234;
mem[1] = size;
memset(&mem[2], 0xFF, size);
return(&mem[2]);
}
}
void freeL(char *msg, void *x)
{
if (!x)
LogMsg("free( %s @ NULL )!", msg);
else
{
unsigned long *mem = ((unsigned long *)x) - 2;
if (mem[0] != 0xDEAD1234)
{ LogMsg("free( %s @ %p ) !!!! NOT ALLOCATED !!!!", msg, &mem[2]); return; }
if (mem[1] > 8000)
{ LogMsg("free( %s : %ld @ %p) too big!", msg, mem[1], &mem[2]); return; }
LogMalloc("free( %s : %ld @ %p)", msg, mem[1], &mem[2]);
memset(mem, 0xDD, mem[1]+8);
free(mem);
}
}
#endif // MACOSX_MDNS_MALLOC_DEBUGGING >= 1
#if mDNSResponderVersion > 1
mDNSexport const char mDNSResponderVersionString[] = "mDNSResponder-" STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ") ";
#else
mDNSexport const char mDNSResponderVersionString[] = "mDNSResponder (Engineering Build) (" __DATE__ " " __TIME__ ") ";
#endif