diff options
Diffstat (limited to 'mDNSResponder/mDNSShared/dnsextd.c')
| -rw-r--r-- | mDNSResponder/mDNSShared/dnsextd.c | 3150 |
1 files changed, 3150 insertions, 0 deletions
diff --git a/mDNSResponder/mDNSShared/dnsextd.c b/mDNSResponder/mDNSShared/dnsextd.c new file mode 100644 index 00000000..aa06650a --- /dev/null +++ b/mDNSResponder/mDNSShared/dnsextd.c @@ -0,0 +1,3150 @@ +/* -*- Mode: C; tab-width: 4 -*- + * + * Copyright (c) 2002-2004 Apple Computer, Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if __APPLE__ +// In Mac OS X 10.5 and later trying to use the daemon function gives a “‘daemon’ is deprecated” +// error, which prevents compilation because we build with "-Werror". +// Since this is supposed to be portable cross-platform code, we don't care that daemon is +// deprecated on Mac OS X 10.5, so we use this preprocessor trick to eliminate the error message. +#define daemon yes_we_know_that_daemon_is_deprecated_in_os_x_10_5_thankyou +#endif + +#include <signal.h> +#include <pthread.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <stdio.h> +#include <syslog.h> +#include <string.h> +#include <sys/time.h> +#include <sys/resource.h> +#include <time.h> +#include <errno.h> + +#if __APPLE__ +#undef daemon +extern int daemon(int, int); +#endif + +// Solaris doesn't have daemon(), so we define it here +#ifdef NOT_HAVE_DAEMON +#include "../mDNSPosix/mDNSUNP.h" // For daemon() +#endif // NOT_HAVE_DAEMON + +#include "dnsextd.h" +#include "../mDNSShared/uds_daemon.h" +#include "../mDNSShared/dnssd_ipc.h" +#include "../mDNSCore/uDNS.h" +#include "../mDNSShared/DebugServices.h" + +// Compatibility workaround +#ifndef AF_LOCAL +#define AF_LOCAL AF_UNIX +#endif + +// +// Constants +// +mDNSexport const char ProgramName[] = "dnsextd"; + +#define LOOPBACK "127.0.0.1" +#if !defined(LISTENQ) +# define LISTENQ 128 // tcp connection backlog +#endif +#define RECV_BUFLEN 9000 +#define LEASETABLE_INIT_NBUCKETS 256 // initial hashtable size (doubles as table fills) +#define EXPIRATION_INTERVAL 300 // check for expired records every 5 minutes +#define SRV_TTL 7200 // TTL For _dns-update SRV records +#define CONFIG_FILE "/etc/dnsextd.conf" +#define TCP_SOCKET_FLAGS kTCPSocketFlags_UseTLS + +// LLQ Lease bounds (seconds) +#define LLQ_MIN_LEASE (15 * 60) +#define LLQ_MAX_LEASE (120 * 60) +#define LLQ_LEASE_FUDGE 60 + +// LLQ SOA poll interval (microseconds) +#define LLQ_MONITOR_ERR_INTERVAL (60 * 1000000) +#define LLQ_MONITOR_INTERVAL 250000 +#ifdef SIGINFO +#define INFO_SIGNAL SIGINFO +#else +#define INFO_SIGNAL SIGUSR1 +#endif + +#define SAME_INADDR(x,y) (*((mDNSu32 *)&x) == *((mDNSu32 *)&y)) + +// +// Data Structures +// Structs/fields that must be locked for thread safety are explicitly commented +// + +// args passed to UDP request handler thread as void* + +typedef struct +{ + PktMsg pkt; + struct sockaddr_in cliaddr; + DaemonInfo *d; + int sd; +} UDPContext; + +// args passed to TCP request handler thread as void* +typedef struct +{ + PktMsg pkt; + struct sockaddr_in cliaddr; + TCPSocket *sock; // socket connected to client + DaemonInfo *d; +} TCPContext; + +// args passed to UpdateAnswerList thread as void* +typedef struct +{ + DaemonInfo *d; + AnswerListElem *a; +} UpdateAnswerListArgs; + +// +// Global Variables +// + +// booleans to determine runtime output +// read-only after initialization (no mutex protection) +static mDNSBool foreground = 0; +static mDNSBool verbose = 0; + +// globals set via signal handler (accessed exclusively by main select loop and signal handler) +static mDNSBool terminate = 0; +static mDNSBool dumptable = 0; +static mDNSBool hangup = 0; + +// global for config file location +static char * cfgfile = NULL; + +// +// Logging Routines +// Log messages are delivered to syslog unless -f option specified +// + +// common message logging subroutine +mDNSlocal void PrintLog(const char *buffer) +{ + if (foreground) + { + fprintf(stderr,"%s\n", buffer); + fflush(stderr); + } + else + { + openlog("dnsextd", LOG_CONS, LOG_DAEMON); + syslog(LOG_ERR, "%s", buffer); + closelog(); + } +} + +// Verbose Logging (conditional on -v option) +mDNSlocal void VLog(const char *format, ...) +{ + char buffer[512]; + va_list ptr; + + if (!verbose) return; + va_start(ptr,format); + buffer[mDNS_vsnprintf((char *)buffer, sizeof(buffer), format, ptr)] = 0; + va_end(ptr); + PrintLog(buffer); +} + +// Unconditional Logging +mDNSlocal void Log(const char *format, ...) +{ + char buffer[512]; + va_list ptr; + + va_start(ptr,format); + buffer[mDNS_vsnprintf((char *)buffer, sizeof(buffer), format, ptr)] = 0; + va_end(ptr); + PrintLog(buffer); +} + +// Error Logging +// prints message "dnsextd <function>: <operation> - <error message>" +// must be compiled w/ -D_REENTRANT for thread-safe errno usage +mDNSlocal void LogErr(const char *fn, const char *operation) +{ + char buf[512], errbuf[256]; + strerror_r(errno, errbuf, sizeof(errbuf)); + snprintf(buf, sizeof(buf), "%s: %s - %s", fn, operation, errbuf); + PrintLog(buf); +} + +// +// Networking Utility Routines +// + +// Convert DNS Message Header from Network to Host byte order +mDNSlocal void HdrNToH(PktMsg *pkt) +{ + // Read the integer parts which are in IETF byte-order (MSB first, LSB second) + mDNSu8 *ptr = (mDNSu8 *)&pkt->msg.h.numQuestions; + pkt->msg.h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); + pkt->msg.h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); + pkt->msg.h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]); + pkt->msg.h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]); +} + +// Convert DNS Message Header from Host to Network byte order +mDNSlocal void HdrHToN(PktMsg *pkt) +{ + mDNSu16 numQuestions = pkt->msg.h.numQuestions; + mDNSu16 numAnswers = pkt->msg.h.numAnswers; + mDNSu16 numAuthorities = pkt->msg.h.numAuthorities; + mDNSu16 numAdditionals = pkt->msg.h.numAdditionals; + mDNSu8 *ptr = (mDNSu8 *)&pkt->msg.h.numQuestions; + + // Put all the integer values in IETF byte-order (MSB first, LSB second) + *ptr++ = (mDNSu8)(numQuestions >> 8); + *ptr++ = (mDNSu8)(numQuestions & 0xFF); + *ptr++ = (mDNSu8)(numAnswers >> 8); + *ptr++ = (mDNSu8)(numAnswers & 0xFF); + *ptr++ = (mDNSu8)(numAuthorities >> 8); + *ptr++ = (mDNSu8)(numAuthorities & 0xFF); + *ptr++ = (mDNSu8)(numAdditionals >> 8); + *ptr++ = (mDNSu8)(numAdditionals & 0xFF); +} + + +// Add socket to event loop + +mDNSlocal mStatus AddSourceToEventLoop( DaemonInfo * self, TCPSocket *sock, EventCallback callback, void *context ) +{ + EventSource * newSource; + mStatus err = mStatus_NoError; + + if ( self->eventSources.LinkOffset == 0 ) + { + InitLinkedList( &self->eventSources, offsetof( EventSource, next)); + } + + newSource = ( EventSource*) malloc( sizeof *newSource ); + if ( newSource == NULL ) + { + err = mStatus_NoMemoryErr; + goto exit; + } + + newSource->callback = callback; + newSource->context = context; + newSource->sock = sock; + newSource->fd = mDNSPlatformTCPGetFD( sock ); + + AddToTail( &self->eventSources, newSource ); + +exit: + + return err; +} + + +// Remove socket from event loop + +mDNSlocal mStatus RemoveSourceFromEventLoop( DaemonInfo * self, TCPSocket *sock ) +{ + EventSource * source; + mStatus err; + + for ( source = ( EventSource* ) self->eventSources.Head; source; source = source->next ) + { + if ( source->sock == sock ) + { + RemoveFromList( &self->eventSources, source ); + + free( source ); + err = mStatus_NoError; + goto exit; + } + } + + err = mStatus_NoSuchNameErr; + +exit: + + return err; +} + +// create a socket connected to nameserver +// caller terminates connection via close() +mDNSlocal TCPSocket *ConnectToServer(DaemonInfo *d) +{ + int ntries = 0, retry = 0; + + while (1) + { + mDNSIPPort port = zeroIPPort; + int fd; + + TCPSocket *sock = mDNSPlatformTCPSocket( NULL, 0, &port, mDNSfalse ); + if ( !sock ) { LogErr("ConnectToServer", "socket"); return NULL; } + fd = mDNSPlatformTCPGetFD( sock ); + if (!connect( fd, (struct sockaddr *)&d->ns_addr, sizeof(d->ns_addr))) return sock; + mDNSPlatformTCPCloseConnection( sock ); + if (++ntries < 10) + { + LogErr("ConnectToServer", "connect"); + Log("ConnectToServer - retrying connection"); + if (!retry) retry = 500000 + random() % 500000; + usleep(retry); + retry *= 2; + } + else { Log("ConnectToServer - %d failed attempts. Aborting.", ntries); return NULL; } + } +} + +// send an entire block of data over a connected socket +mDNSlocal int MySend(TCPSocket *sock, const void *msg, int len) +{ + int selectval, n, nsent = 0; + fd_set wset; + struct timeval timeout = { 3, 0 }; // until we remove all calls from main thread, keep timeout short + + while (nsent < len) + { + int fd; + + FD_ZERO(&wset); + + fd = mDNSPlatformTCPGetFD( sock ); + + FD_SET( fd, &wset ); + selectval = select( fd+1, NULL, &wset, NULL, &timeout); + if (selectval < 0) { LogErr("MySend", "select"); return -1; } + if (!selectval || !FD_ISSET(fd, &wset)) { Log("MySend - timeout"); return -1; } + + n = mDNSPlatformWriteTCP( sock, ( char* ) msg + nsent, len - nsent); + + if (n < 0) { LogErr("MySend", "send"); return -1; } + nsent += n; + } + return 0; +} + +// Transmit a DNS message, prefixed by its length, over TCP, blocking if necessary +mDNSlocal int SendPacket(TCPSocket *sock, PktMsg *pkt) +{ + // send the lenth, in network byte order + mDNSu16 len = htons((mDNSu16)pkt->len); + if (MySend(sock, &len, sizeof(len)) < 0) return -1; + + // send the message + VLog("SendPacket Q:%d A:%d A:%d A:%d ", + ntohs(pkt->msg.h.numQuestions), + ntohs(pkt->msg.h.numAnswers), + ntohs(pkt->msg.h.numAuthorities), + ntohs(pkt->msg.h.numAdditionals)); + return MySend(sock, &pkt->msg, pkt->len); +} + +// Receive len bytes, waiting until we have all of them. +// Returns number of bytes read (which should always be the number asked for). +static int my_recv(TCPSocket *sock, void *const buf, const int len, mDNSBool * closed) +{ + // Don't use "MSG_WAITALL"; it returns "Invalid argument" on some Linux versions; + // use an explicit while() loop instead. + // Also, don't try to do '+=' arithmetic on the original "void *" pointer -- + // arithmetic on "void *" pointers is compiler-dependent. + + fd_set rset; + struct timeval timeout = { 3, 0 }; // until we remove all calls from main thread, keep timeout short + int selectval, remaining = len; + char *ptr = (char *)buf; + ssize_t num_read; + + while (remaining) + { + int fd; + + fd = mDNSPlatformTCPGetFD( sock ); + + FD_ZERO(&rset); + FD_SET(fd, &rset); + selectval = select(fd+1, &rset, NULL, NULL, &timeout); + if (selectval < 0) { LogErr("my_recv", "select"); return -1; } + if (!selectval || !FD_ISSET(fd, &rset)) + { + Log("my_recv - timeout"); + return -1; + } + + num_read = mDNSPlatformReadTCP( sock, ptr, remaining, closed ); + + if (((num_read == 0) && *closed) || (num_read < 0) || (num_read > remaining)) return -1; + if (num_read == 0) return 0; + ptr += num_read; + remaining -= num_read; + } + return(len); +} + +// Return a DNS Message read off of a TCP socket, or NULL on failure +// If storage is non-null, result is placed in that buffer. Otherwise, +// returned value is allocated with Malloc, and contains sufficient extra +// storage for a Lease OPT RR + +mDNSlocal PktMsg* +RecvPacket +( + TCPSocket * sock, + PktMsg * storage, + mDNSBool * closed +) +{ + int nread; + int allocsize; + mDNSu16 msglen = 0; + PktMsg * pkt = NULL; + unsigned int srclen; + int fd; + mStatus err = 0; + + fd = mDNSPlatformTCPGetFD( sock ); + + nread = my_recv( sock, &msglen, sizeof( msglen ), closed ); + + require_action_quiet( nread != -1, exit, err = mStatus_UnknownErr ); + require_action_quiet( nread > 0, exit, err = mStatus_NoError ); + + msglen = ntohs( msglen ); + require_action_quiet( nread == sizeof( msglen ), exit, err = mStatus_UnknownErr; Log( "Could not read length field of message") ); + + if ( storage ) + { + require_action_quiet( msglen <= sizeof( storage->msg ), exit, err = mStatus_UnknownErr; Log( "RecvPacket: provided buffer too small." ) ); + pkt = storage; + } + else + { + // buffer extra space to add an OPT RR + + if ( msglen > sizeof(DNSMessage)) + { + allocsize = sizeof(PktMsg) - sizeof(DNSMessage) + msglen; + } + else + { + allocsize = sizeof(PktMsg); + } + + pkt = malloc(allocsize); + require_action_quiet( pkt, exit, err = mStatus_NoMemoryErr; LogErr( "RecvPacket", "malloc" ) ); + mDNSPlatformMemZero( pkt, sizeof( *pkt ) ); + } + + pkt->len = msglen; + srclen = sizeof(pkt->src); + + if ( getpeername( fd, ( struct sockaddr* ) &pkt->src, &srclen ) || ( srclen != sizeof( pkt->src ) ) ) + { + LogErr("RecvPacket", "getpeername"); + mDNSPlatformMemZero(&pkt->src, sizeof(pkt->src)); + } + + nread = my_recv(sock, &pkt->msg, msglen, closed ); + require_action_quiet( nread >= 0, exit, err = mStatus_UnknownErr ; LogErr( "RecvPacket", "recv" ) ); + require_action_quiet( nread == msglen, exit, err = mStatus_UnknownErr ; Log( "Could not read entire message" ) ); + require_action_quiet( pkt->len >= sizeof( DNSMessageHeader ), exit, err = mStatus_UnknownErr ; Log( "RecvPacket: Message too short (%d bytes)", pkt->len ) ); + +exit: + + if ( err && pkt ) + { + if ( pkt != storage ) + { + free(pkt); + } + + pkt = NULL; + } + + return pkt; +} + + +mDNSlocal DNSZone* +FindZone +( + DaemonInfo * self, + domainname * name +) +{ + DNSZone * zone; + + for ( zone = self->zones; zone; zone = zone->next ) + { + if ( SameDomainName( &zone->name, name ) ) + { + break; + } + } + + return zone; +} + + +mDNSlocal mDNSBool +ZoneHandlesName +( + const domainname * zname, + const domainname * dname +) +{ + mDNSu16 i = DomainNameLength( zname ); + mDNSu16 j = DomainNameLength( dname ); + + if ( ( i == ( MAX_DOMAIN_NAME + 1 ) ) || ( j == ( MAX_DOMAIN_NAME + 1 ) ) || ( i > j ) || ( memcmp( zname->c, dname->c + ( j - i ), i ) != 0 ) ) + { + return mDNSfalse; + } + + return mDNStrue; +} + + +mDNSlocal mDNSBool IsQuery( PktMsg * pkt ) +{ + return ( pkt->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask ) == (mDNSu8) ( kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery ); +} + + +mDNSlocal mDNSBool IsUpdate( PktMsg * pkt ) +{ + return ( pkt->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask ) == (mDNSu8) ( kDNSFlag0_OP_Update ); +} + + +mDNSlocal mDNSBool IsNotify(PktMsg *pkt) +{ + return ( pkt->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask ) == ( mDNSu8) ( kDNSFlag0_OP_Notify ); +} + + +mDNSlocal mDNSBool IsLLQRequest(PktMsg *pkt) +{ + const mDNSu8 *ptr = NULL, *end = (mDNSu8 *)&pkt->msg + pkt->len; + LargeCacheRecord lcr; + int i; + mDNSBool result = mDNSfalse; + + HdrNToH(pkt); + if ((mDNSu8)(pkt->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask) != (mDNSu8)(kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery)) goto end; + + if (!pkt->msg.h.numAdditionals) goto end; + ptr = LocateAdditionals(&pkt->msg, end); + if (!ptr) goto end; + + // find last Additional info. + for (i = 0; i < pkt->msg.h.numAdditionals; i++) + { + ptr = GetLargeResourceRecord(NULL, &pkt->msg, ptr, end, 0, kDNSRecordTypePacketAdd, &lcr); + if (!ptr) { Log("Unable to read additional record"); goto end; } + } + + if ( lcr.r.resrec.rrtype == kDNSType_OPT && lcr.r.resrec.rdlength >= DNSOpt_LLQData_Space && lcr.r.resrec.rdata->u.opt[0].opt == kDNSOpt_LLQ ) + { + result = mDNStrue; + } + +end: + HdrHToN(pkt); + return result; +} + +// !!!KRS implement properly +mDNSlocal mDNSBool IsLLQAck(PktMsg *pkt) +{ + if ((pkt->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask ) == (mDNSu8) ( kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery ) && + pkt->msg.h.numQuestions && !pkt->msg.h.numAnswers && !pkt->msg.h.numAuthorities) return mDNStrue; + return mDNSfalse; +} + + +mDNSlocal mDNSBool +IsPublicSRV +( + DaemonInfo * self, + DNSQuestion * q +) +{ + DNameListElem * elem; + mDNSBool ret = mDNSfalse; + int i = ( int ) DomainNameLength( &q->qname ) - 1; + + for ( elem = self->public_names; elem; elem = elem->next ) + { + int j = ( int ) DomainNameLength( &elem->name ) - 1; + + if ( i > j ) + { + for ( ; i >= 0; i--, j-- ) + { + if ( q->qname.c[ i ] != elem->name.c[ j ] ) + { + ret = mDNStrue; + goto exit; + } + } + } + } + +exit: + + return ret; +} + + +mDNSlocal void +SetZone +( + DaemonInfo * self, + PktMsg * pkt +) +{ + domainname zname; + mDNSu8 QR_OP; + const mDNSu8 * ptr = pkt->msg.data; + mDNSBool exception = mDNSfalse; + + // Initialize + + pkt->zone = NULL; + pkt->isZonePublic = mDNStrue; + zname.c[0] = '\0'; + + // Figure out what type of packet this is + + QR_OP = ( mDNSu8 ) ( pkt->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask ); + + if ( IsQuery( pkt ) ) + { + DNSQuestion question; + + // It's a query + + ptr = getQuestion( &pkt->msg, ptr, ( ( mDNSu8* ) &pkt->msg ) + pkt->len, NULL, &question ); + + AppendDomainName( &zname, &question.qname ); + + exception = ( ( question.qtype == kDNSType_SOA ) || ( question.qtype == kDNSType_NS ) || ( ( question.qtype == kDNSType_SRV ) && IsPublicSRV( self, &question ) ) ); + } + else if ( IsUpdate( pkt ) ) + { + DNSQuestion question; + + // It's an update. The format of the zone section is the same as the format for the question section + // according to RFC 2136, so we'll just treat this as a question so we can get at the zone. + + ptr = getQuestion( &pkt->msg, ptr, ( ( mDNSu8* ) &pkt->msg ) + pkt->len, NULL, &question ); + + AppendDomainName( &zname, &question.qname ); + + exception = mDNSfalse; + } + + if ( zname.c[0] != '\0' ) + { + // Find the right zone + + for ( pkt->zone = self->zones; pkt->zone; pkt->zone = pkt->zone->next ) + { + if ( ZoneHandlesName( &pkt->zone->name, &zname ) ) + { + VLog( "found correct zone %##s for query", pkt->zone->name.c ); + + pkt->isZonePublic = ( ( pkt->zone->type == kDNSZonePublic ) || exception ); + + VLog( "zone %##s is %s", pkt->zone->name.c, ( pkt->isZonePublic ) ? "public" : "private" ); + + break; + } + } + } +} + + +mDNSlocal int +UDPServerTransaction(const DaemonInfo *d, const PktMsg *request, PktMsg *reply, mDNSBool *trunc) +{ + fd_set rset; + struct timeval timeout = { 3, 0 }; // until we remove all calls from main thread, keep timeout short + int sd; + int res; + mStatus err = mStatus_NoError; + + // Initialize + + *trunc = mDNSfalse; + + // Create a socket + + sd = socket( AF_INET, SOCK_DGRAM, 0 ); + require_action( sd >= 0, exit, err = mStatus_UnknownErr; LogErr( "UDPServerTransaction", "socket" ) ); + + // Send the packet to the nameserver + + VLog("UDPServerTransaction Q:%d A:%d A:%d A:%d ", + ntohs(request->msg.h.numQuestions), + ntohs(request->msg.h.numAnswers), + ntohs(request->msg.h.numAuthorities), + ntohs(request->msg.h.numAdditionals)); + res = sendto( sd, (char *)&request->msg, request->len, 0, ( struct sockaddr* ) &d->ns_addr, sizeof( d->ns_addr ) ); + require_action( res == (int) request->len, exit, err = mStatus_UnknownErr; LogErr( "UDPServerTransaction", "sendto" ) ); + + // Wait for reply + + FD_ZERO( &rset ); + FD_SET( sd, &rset ); + res = select( sd + 1, &rset, NULL, NULL, &timeout ); + require_action( res >= 0, exit, err = mStatus_UnknownErr; LogErr( "UDPServerTransaction", "select" ) ); + require_action( ( res > 0 ) && FD_ISSET( sd, &rset ), exit, err = mStatus_UnknownErr; Log( "UDPServerTransaction - timeout" ) ); + + // Receive reply + + reply->len = recvfrom( sd, &reply->msg, sizeof(reply->msg), 0, NULL, NULL ); + require_action( ( ( int ) reply->len ) >= 0, exit, err = mStatus_UnknownErr; LogErr( "UDPServerTransaction", "recvfrom" ) ); + require_action( reply->len >= sizeof( DNSMessageHeader ), exit, err = mStatus_UnknownErr; Log( "UDPServerTransaction - Message too short (%d bytes)", reply->len ) ); + + // Check for truncation bit + + if ( reply->msg.h.flags.b[0] & kDNSFlag0_TC ) + { + *trunc = mDNStrue; + } + +exit: + + if ( sd >= 0 ) + { + close( sd ); + } + + return err; +} + +// +// Dynamic Update Utility Routines +// + +// check if a request and server response complete a successful dynamic update +mDNSlocal mDNSBool SuccessfulUpdateTransaction(PktMsg *request, PktMsg *reply) +{ + char buf[32]; + char *vlogmsg = NULL; + + // check messages + if (!request || !reply) { vlogmsg = "NULL message"; goto failure; } + if (request->len < sizeof(DNSMessageHeader) || reply->len < sizeof(DNSMessageHeader)) { vlogmsg = "Malformatted message"; goto failure; } + + // check request operation + if ((request->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask) != (request->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask)) + { vlogmsg = "Request opcode not an update"; goto failure; } + + // check result + if ((reply->msg.h.flags.b[1] & kDNSFlag1_RC_Mask)) { vlogmsg = "Reply contains non-zero rcode"; goto failure; } + if ((reply->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask) != (kDNSFlag0_OP_Update | kDNSFlag0_QR_Response)) + { vlogmsg = "Reply opcode not an update response"; goto failure; } + + VLog("Successful update from %s", inet_ntop(AF_INET, &request->src.sin_addr, buf, 32)); + return mDNStrue; + +failure: + VLog("Request %s: %s", inet_ntop(AF_INET, &request->src.sin_addr, buf, 32), vlogmsg); + return mDNSfalse; +} + +// Allocate an appropriately sized CacheRecord and copy data from original. +// Name pointer in CacheRecord object is set to point to the name specified +// +mDNSlocal CacheRecord *CopyCacheRecord(const CacheRecord *orig, domainname *name) +{ + CacheRecord *cr; + size_t size = sizeof(*cr); + if (orig->resrec.rdlength > InlineCacheRDSize) size += orig->resrec.rdlength - InlineCacheRDSize; + cr = malloc(size); + if (!cr) { LogErr("CopyCacheRecord", "malloc"); return NULL; } + memcpy(cr, orig, size); + cr->resrec.rdata = (RData*)&cr->smallrdatastorage; + cr->resrec.name = name; + + return cr; +} + + +// +// Lease Hashtable Utility Routines +// + +// double hash table size +// caller must lock table prior to invocation +mDNSlocal void RehashTable(DaemonInfo *d) +{ + RRTableElem *ptr, *tmp, **new; + int i, bucket, newnbuckets = d->nbuckets * 2; + + VLog("Rehashing lease table (new size %d buckets)", newnbuckets); + new = malloc(sizeof(RRTableElem *) * newnbuckets); + if (!new) { LogErr("RehashTable", "malloc"); return; } + mDNSPlatformMemZero(new, newnbuckets * sizeof(RRTableElem *)); + + for (i = 0; i < d->nbuckets; i++) + { + ptr = d->table[i]; + while (ptr) + { + bucket = ptr->rr.resrec.namehash % newnbuckets; + tmp = ptr; + ptr = ptr->next; + tmp->next = new[bucket]; + new[bucket] = tmp; + } + } + d->nbuckets = newnbuckets; + free(d->table); + d->table = new; +} + +// print entire contents of hashtable, invoked via SIGINFO +mDNSlocal void PrintLeaseTable(DaemonInfo *d) +{ + int i; + RRTableElem *ptr; + char rrbuf[MaxMsg], addrbuf[16]; + struct timeval now; + int hr, min, sec; + + if (gettimeofday(&now, NULL)) { LogErr("PrintTable", "gettimeofday"); return; } + if (pthread_mutex_lock(&d->tablelock)) { LogErr("PrintTable", "pthread_mutex_lock"); return; } + + Log("Dumping Lease Table Contents (table contains %d resource records)", d->nelems); + for (i = 0; i < d->nbuckets; i++) + { + for (ptr = d->table[i]; ptr; ptr = ptr->next) + { + hr = ((ptr->expire - now.tv_sec) / 60) / 60; + min = ((ptr->expire - now.tv_sec) / 60) % 60; + sec = (ptr->expire - now.tv_sec) % 60; + Log("Update from %s, Expires in %d:%d:%d\n\t%s", inet_ntop(AF_INET, &ptr->cli.sin_addr, addrbuf, 16), hr, min, sec, + GetRRDisplayString_rdb(&ptr->rr.resrec, &ptr->rr.resrec.rdata->u, rrbuf)); + } + } + pthread_mutex_unlock(&d->tablelock); +} + +// +// Startup SRV Registration Routines +// Register _dns-update._udp/_tcp.<zone> SRV records indicating the port on which +// the daemon accepts requests +// + +// delete all RRS of a given name/type +mDNSlocal mDNSu8 *putRRSetDeletion(DNSMessage *msg, mDNSu8 *ptr, mDNSu8 *limit, ResourceRecord *rr) +{ + ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name); + if (!ptr || ptr + 10 >= limit) return NULL; // out of space + ptr[0] = (mDNSu8)(rr->rrtype >> 8); + ptr[1] = (mDNSu8)(rr->rrtype & 0xFF); + ptr[2] = (mDNSu8)((mDNSu16)kDNSQClass_ANY >> 8); + ptr[3] = (mDNSu8)((mDNSu16)kDNSQClass_ANY & 0xFF); + mDNSPlatformMemZero(ptr+4, sizeof(rr->rroriginalttl) + sizeof(rr->rdlength)); // zero ttl/rdata + msg->h.mDNS_numUpdates++; + return ptr + 10; +} + +mDNSlocal mDNSu8 *PutUpdateSRV(DaemonInfo *d, DNSZone * zone, PktMsg *pkt, mDNSu8 *ptr, char *regtype, mDNSIPPort port, mDNSBool registration) +{ + AuthRecord rr; + char hostname[1024], buf[MaxMsg]; + mDNSu8 *end = (mDNSu8 *)&pkt->msg + sizeof(DNSMessage); + + ( void ) d; + + mDNS_SetupResourceRecord(&rr, NULL, 0, kDNSType_SRV, SRV_TTL, kDNSRecordTypeUnique, AuthRecordAny, NULL, NULL); + rr.resrec.rrclass = kDNSClass_IN; + rr.resrec.rdata->u.srv.priority = 0; + rr.resrec.rdata->u.srv.weight = 0; + rr.resrec.rdata->u.srv.port = port; + if (gethostname(hostname, 1024) < 0 || !MakeDomainNameFromDNSNameString(&rr.resrec.rdata->u.srv.target, hostname)) + rr.resrec.rdata->u.srv.target.c[0] = '\0'; + + MakeDomainNameFromDNSNameString(&rr.namestorage, regtype); + AppendDomainName(&rr.namestorage, &zone->name); + VLog("%s %s", registration ? "Registering SRV record" : "Deleting existing RRSet", + GetRRDisplayString_rdb(&rr.resrec, &rr.resrec.rdata->u, buf)); + if (registration) ptr = PutResourceRecord(&pkt->msg, ptr, &pkt->msg.h.mDNS_numUpdates, &rr.resrec); + else ptr = putRRSetDeletion(&pkt->msg, ptr, end, &rr.resrec); + return ptr; +} + + +// perform dynamic update. +// specify deletion by passing false for the register parameter, otherwise register the records. +mDNSlocal int UpdateSRV(DaemonInfo *d, mDNSBool registration) +{ + TCPSocket *sock = NULL; + DNSZone * zone; + int err = mStatus_NoError; + + sock = ConnectToServer( d ); + require_action( sock, exit, err = mStatus_UnknownErr; Log( "UpdateSRV: ConnectToServer failed" ) ); + + for ( zone = d->zones; zone; zone = zone->next ) + { + PktMsg pkt; + mDNSu8 *ptr = pkt.msg.data; + mDNSu8 *end = (mDNSu8 *)&pkt.msg + sizeof(DNSMessage); + PktMsg *reply = NULL; + mDNSBool closed; + mDNSBool ok; + + // Initialize message + InitializeDNSMessage(&pkt.msg.h, zeroID, UpdateReqFlags); + pkt.src.sin_addr.s_addr = zerov4Addr.NotAnInteger; // address field set solely for verbose logging in subroutines + pkt.src.sin_family = AF_INET; + + // format message body + ptr = putZone(&pkt.msg, ptr, end, &zone->name, mDNSOpaque16fromIntVal(kDNSClass_IN)); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + + if ( zone->type == kDNSZonePrivate ) + { + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-update-tls._tcp.", d->private_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-query-tls._tcp.", d->private_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-llq-tls._tcp.", d->private_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + + if ( !registration ) + { + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-update._udp.", d->llq_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-llq._udp.", d->llq_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + } + } + else + { + if ( !registration ) + { + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-update-tls.", d->private_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-query-tls.", d->private_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-llq-tls.", d->private_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + } + + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-update._udp.", d->llq_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + ptr = PutUpdateSRV(d, zone, &pkt, ptr, "_dns-llq._udp.", d->llq_port, registration); + require_action( ptr, exit, err = mStatus_UnknownErr; Log("UpdateSRV: Error constructing lease expiration update" ) ); + } + + HdrHToN(&pkt); + + if ( zone->updateKeys ) + { + DNSDigest_SignMessage( &pkt.msg, &ptr, zone->updateKeys, 0 ); + require_action( ptr, exit, Log("UpdateSRV: Error constructing lease expiration update" ) ); + } + + pkt.len = ptr - (mDNSu8 *)&pkt.msg; + + // send message, receive reply + + err = SendPacket( sock, &pkt ); + require_action( !err, exit, Log( "UpdateSRV: SendPacket failed" ) ); + + reply = RecvPacket( sock, NULL, &closed ); + require_action( reply, exit, err = mStatus_UnknownErr; Log( "UpdateSRV: RecvPacket returned NULL" ) ); + + ok = SuccessfulUpdateTransaction( &pkt, reply ); + + if ( !ok ) + { + Log("SRV record registration failed with rcode %d", reply->msg.h.flags.b[1] & kDNSFlag1_RC_Mask); + } + + free( reply ); + } + +exit: + + if ( sock ) + { + mDNSPlatformTCPCloseConnection( sock ); + } + + return err; +} + +// wrapper routines/macros +#define ClearUpdateSRV(d) UpdateSRV(d, 0) + +// clear any existing records prior to registration +mDNSlocal int SetUpdateSRV(DaemonInfo *d) +{ + int err; + + err = ClearUpdateSRV(d); // clear any existing record + if (!err) err = UpdateSRV(d, 1); + return err; +} + +// +// Argument Parsing and Configuration +// + +mDNSlocal void PrintUsage(void) +{ + fprintf(stderr, "Usage: dnsextd [-f <config file>] [-vhd] ...\n" + "Use \"dnsextd -h\" for help\n"); +} + +mDNSlocal void PrintHelp(void) +{ + fprintf(stderr, "\n\n"); + PrintUsage(); + + fprintf(stderr, + "dnsextd is a daemon that implements DNS extensions supporting Dynamic DNS Update Leases\n" + "and Long Lived Queries, used in Wide-Area DNS Service Discovery, on behalf of name servers\n" + "that do not natively support these extensions. (See dns-sd.org for more info on DNS Service\n" + "Discovery, Update Leases, and Long Lived Queries.)\n\n" + + "dnsextd requires one argument,the zone, which is the domain for which Update Leases\n" + "and Long Lived Queries are to be administered. dnsextd communicates directly with the\n" + "primary master server for this zone.\n\n" + + "The options are as follows:\n\n" + + "-f Specify configuration file. The default is /etc/dnsextd.conf.\n\n" + + "-d Run daemon in foreground.\n\n" + + "-h Print help.\n\n" + + "-v Verbose output.\n\n" + ); +} + + +// Note: ProcessArgs called before process is daemonized, and therefore must open no descriptors +// returns 0 (success) if program is to continue execution +// output control arguments (-f, -v) do not affect this routine +mDNSlocal int ProcessArgs(int argc, char *argv[], DaemonInfo *d) +{ + DNSZone * zone; + int opt; + int err = 0; + + cfgfile = strdup( CONFIG_FILE ); + require_action( cfgfile, arg_error, err = mStatus_NoMemoryErr ); + + // defaults, may be overriden by command option + + // setup our sockaddr + + mDNSPlatformMemZero( &d->addr, sizeof( d->addr ) ); + d->addr.sin_addr.s_addr = zerov4Addr.NotAnInteger; + d->addr.sin_port = UnicastDNSPort.NotAnInteger; + d->addr.sin_family = AF_INET; +#ifndef NOT_HAVE_SA_LEN + d->addr.sin_len = sizeof( d->addr ); +#endif + + // setup nameserver's sockaddr + + mDNSPlatformMemZero(&d->ns_addr, sizeof(d->ns_addr)); + d->ns_addr.sin_family = AF_INET; + inet_pton( AF_INET, LOOPBACK, &d->ns_addr.sin_addr ); + d->ns_addr.sin_port = NSIPCPort.NotAnInteger; +#ifndef NOT_HAVE_SA_LEN + d->ns_addr.sin_len = sizeof( d->ns_addr ); +#endif + + // setup our ports + + d->private_port = PrivateDNSPort; + d->llq_port = DNSEXTPort; + + while ((opt = getopt(argc, argv, "f:hdv")) != -1) + { + switch(opt) + { + case 'f': free( cfgfile ); cfgfile = strdup( optarg ); require_action( cfgfile, arg_error, err = mStatus_NoMemoryErr ); break; + case 'h': PrintHelp(); return -1; + case 'd': foreground = 1; break; // Also used when launched via OS X's launchd mechanism + case 'v': verbose = 1; break; + default: goto arg_error; + } + } + + err = ParseConfig( d, cfgfile ); + require_noerr( err, arg_error ); + + // Make sure we've specified some zones + + require_action( d->zones, arg_error, err = mStatus_UnknownErr ); + + // if we have a shared secret, use it for the entire zone + + for ( zone = d->zones; zone; zone = zone->next ) + { + if ( zone->updateKeys ) + { + AssignDomainName( &zone->updateKeys->domain, &zone->name ); + } + } + + return 0; + +arg_error: + + PrintUsage(); + return -1; +} + + +// +// Initialization Routines +// + +// Allocate memory, initialize locks and bookkeeping variables +mDNSlocal int InitLeaseTable(DaemonInfo *d) +{ + if (pthread_mutex_init(&d->tablelock, NULL)) { LogErr("InitLeaseTable", "pthread_mutex_init"); return -1; } + d->nbuckets = LEASETABLE_INIT_NBUCKETS; + d->nelems = 0; + d->table = malloc(sizeof(RRTableElem *) * LEASETABLE_INIT_NBUCKETS); + if (!d->table) { LogErr("InitLeaseTable", "malloc"); return -1; } + mDNSPlatformMemZero(d->table, sizeof(RRTableElem *) * LEASETABLE_INIT_NBUCKETS); + return 0; +} + + +mDNSlocal int +SetupSockets +( + DaemonInfo * self +) +{ + static const int kOn = 1; + int sockpair[2]; + mDNSBool private = mDNSfalse; + struct sockaddr_in daddr; + DNSZone * zone; + mStatus err = 0; + + // set up sockets on which we all ns requests + + self->tcpsd = socket( AF_INET, SOCK_STREAM, 0 ); + require_action( dnssd_SocketValid(self->tcpsd), exit, err = mStatus_UnknownErr; LogErr( "SetupSockets", "socket" ) ); + +#if defined(SO_REUSEADDR) + err = setsockopt(self->tcpsd, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn)); + require_action( !err, exit, LogErr( "SetupSockets", "SO_REUSEADDR self->tcpsd" ) ); +#endif + + err = bind( self->tcpsd, ( struct sockaddr* ) &self->addr, sizeof( self->addr ) ); + require_action( !err, exit, LogErr( "SetupSockets", "bind self->tcpsd" ) ); + + err = listen( self->tcpsd, LISTENQ ); + require_action( !err, exit, LogErr( "SetupSockets", "listen" ) ); + + self->udpsd = socket( AF_INET, SOCK_DGRAM, 0 ); + require_action( dnssd_SocketValid(self->udpsd), exit, err = mStatus_UnknownErr; LogErr( "SetupSockets", "socket" ) ); + +#if defined(SO_REUSEADDR) + err = setsockopt(self->udpsd, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn)); + require_action( !err, exit, LogErr( "SetupSockets", "SO_REUSEADDR self->udpsd" ) ); +#endif + + err = bind( self->udpsd, ( struct sockaddr* ) &self->addr, sizeof( self->addr ) ); + require_action( !err, exit, LogErr( "SetupSockets", "bind self->udpsd" ) ); + + // set up sockets on which we receive llq requests + + mDNSPlatformMemZero(&self->llq_addr, sizeof(self->llq_addr)); + self->llq_addr.sin_family = AF_INET; + self->llq_addr.sin_addr.s_addr = zerov4Addr.NotAnInteger; + self->llq_addr.sin_port = ( self->llq_port.NotAnInteger ) ? self->llq_port.NotAnInteger : DNSEXTPort.NotAnInteger; + + if (self->llq_addr.sin_port == self->addr.sin_port) + { + self->llq_tcpsd = self->tcpsd; + self->llq_udpsd = self->udpsd; + } + else + { + self->llq_tcpsd = socket( AF_INET, SOCK_STREAM, 0 ); + require_action( dnssd_SocketValid(self->llq_tcpsd), exit, err = mStatus_UnknownErr; LogErr( "SetupSockets", "socket" ) ); + +#if defined(SO_REUSEADDR) + err = setsockopt(self->llq_tcpsd, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn)); + require_action( !err, exit, LogErr( "SetupSockets", "SO_REUSEADDR self->llq_tcpsd" ) ); +#endif + + err = bind( self->llq_tcpsd, ( struct sockaddr* ) &self->llq_addr, sizeof( self->llq_addr ) ); + require_action( !err, exit, LogErr( "SetupSockets", "bind self->llq_tcpsd" ) ); + + err = listen( self->llq_tcpsd, LISTENQ ); + require_action( !err, exit, LogErr( "SetupSockets", "listen" ) ); + + self->llq_udpsd = socket( AF_INET, SOCK_DGRAM, 0 ); + require_action( dnssd_SocketValid(self->llq_udpsd), exit, err = mStatus_UnknownErr; LogErr( "SetupSockets", "socket" ) ); + +#if defined(SO_REUSEADDR) + err = setsockopt(self->llq_udpsd, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn)); + require_action( !err, exit, LogErr( "SetupSockets", "SO_REUSEADDR self->llq_udpsd" ) ); +#endif + + err = bind(self->llq_udpsd, ( struct sockaddr* ) &self->llq_addr, sizeof( self->llq_addr ) ); + require_action( !err, exit, LogErr( "SetupSockets", "bind self->llq_udpsd" ) ); + } + + // set up Unix domain socket pair for LLQ polling thread to signal main thread that a change to the zone occurred + + err = socketpair( AF_LOCAL, SOCK_STREAM, 0, sockpair ); + require_action( !err, exit, LogErr( "SetupSockets", "socketpair" ) ); + + self->LLQEventListenSock = sockpair[0]; + self->LLQEventNotifySock = sockpair[1]; + + // set up socket on which we receive private requests + + self->llq_tcpsd = socket( AF_INET, SOCK_STREAM, 0 ); + require_action( dnssd_SocketValid(self->tlssd), exit, err = mStatus_UnknownErr; LogErr( "SetupSockets", "socket" ) ); + mDNSPlatformMemZero(&daddr, sizeof(daddr)); + daddr.sin_family = AF_INET; + daddr.sin_addr.s_addr = zerov4Addr.NotAnInteger; + daddr.sin_port = ( self->private_port.NotAnInteger ) ? self->private_port.NotAnInteger : PrivateDNSPort.NotAnInteger; + + self->tlssd = socket( AF_INET, SOCK_STREAM, 0 ); + require_action( dnssd_SocketValid(self->tlssd), exit, err = mStatus_UnknownErr; LogErr( "SetupSockets", "socket" ) ); + +#if defined(SO_REUSEADDR) + err = setsockopt(self->tlssd, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn)); + require_action( !err, exit, LogErr( "SetupSockets", "SO_REUSEADDR self->tlssd" ) ); +#endif + + err = bind( self->tlssd, ( struct sockaddr* ) &daddr, sizeof( daddr ) ); + require_action( !err, exit, LogErr( "SetupSockets", "bind self->tlssd" ) ); + + err = listen( self->tlssd, LISTENQ ); + require_action( !err, exit, LogErr( "SetupSockets", "listen" ) ); + + // Do we have any private zones? + + for ( zone = self->zones; zone; zone = zone->next ) + { + if ( zone->type == kDNSZonePrivate ) + { + private = mDNStrue; + break; + } + } + + if ( private ) + { + err = mDNSPlatformTLSSetupCerts(); + require_action( !err, exit, LogErr( "SetupSockets", "mDNSPlatformTLSSetupCerts" ) ); + } + +exit: + + return err; +} + +// +// periodic table updates +// + +// Delete a resource record from the nameserver via a dynamic update +// sd is a socket already connected to the server +mDNSlocal void DeleteOneRecord(DaemonInfo *d, CacheRecord *rr, domainname *zname, TCPSocket *sock) +{ + DNSZone * zone; + PktMsg pkt; + mDNSu8 *ptr = pkt.msg.data; + mDNSu8 *end = (mDNSu8 *)&pkt.msg + sizeof(DNSMessage); + char buf[MaxMsg]; + mDNSBool closed; + PktMsg *reply = NULL; + + VLog("Expiring record %s", GetRRDisplayString_rdb(&rr->resrec, &rr->resrec.rdata->u, buf)); + + InitializeDNSMessage(&pkt.msg.h, zeroID, UpdateReqFlags); + + ptr = putZone(&pkt.msg, ptr, end, zname, mDNSOpaque16fromIntVal(rr->resrec.rrclass)); + if (!ptr) goto end; + ptr = putDeletionRecord(&pkt.msg, ptr, &rr->resrec); + if (!ptr) goto end; + + HdrHToN(&pkt); + + zone = FindZone( d, zname ); + + if ( zone && zone->updateKeys) + { + DNSDigest_SignMessage(&pkt.msg, &ptr, zone->updateKeys, 0 ); + if (!ptr) goto end; + } + + pkt.len = ptr - (mDNSu8 *)&pkt.msg; + pkt.src.sin_addr.s_addr = zerov4Addr.NotAnInteger; // address field set solely for verbose logging in subroutines + pkt.src.sin_family = AF_INET; + if (SendPacket( sock, &pkt)) { Log("DeleteOneRecord: SendPacket failed"); } + reply = RecvPacket( sock, NULL, &closed ); + if (reply) HdrNToH(reply); + require_action( reply, end, Log( "DeleteOneRecord: RecvPacket returned NULL" ) ); + + if (!SuccessfulUpdateTransaction(&pkt, reply)) + Log("Expiration update failed with rcode %d", reply ? reply->msg.h.flags.b[1] & kDNSFlag1_RC_Mask : -1); + +end: + if (!ptr) { Log("DeleteOneRecord: Error constructing lease expiration update"); } + if (reply) free(reply); +} + +// iterate over table, deleting expired records (or all records if DeleteAll is true) +mDNSlocal void DeleteRecords(DaemonInfo *d, mDNSBool DeleteAll) +{ + struct timeval now; + int i; + TCPSocket *sock = ConnectToServer(d); + if (!sock) { Log("DeleteRecords: ConnectToServer failed"); return; } + if (gettimeofday(&now, NULL)) { LogErr("DeleteRecords ", "gettimeofday"); return; } + if (pthread_mutex_lock(&d->tablelock)) { LogErr("DeleteRecords", "pthread_mutex_lock"); return; } + + for (i = 0; i < d->nbuckets; i++) + { + RRTableElem **ptr = &d->table[i]; + while (*ptr) + { + if (DeleteAll || (*ptr)->expire - now.tv_sec < 0) + { + RRTableElem *fptr; + // delete record from server + DeleteOneRecord(d, &(*ptr)->rr, &(*ptr)->zone, sock); + fptr = *ptr; + *ptr = (*ptr)->next; + free(fptr); + d->nelems--; + } + else ptr = &(*ptr)->next; + } + } + pthread_mutex_unlock(&d->tablelock); + mDNSPlatformTCPCloseConnection( sock ); +} + +// +// main update request handling +// + +// Add, delete, or refresh records in table based on contents of a successfully completed dynamic update +mDNSlocal void UpdateLeaseTable(PktMsg *pkt, DaemonInfo *d, mDNSs32 lease) +{ + RRTableElem **rptr, *tmp; + int i, allocsize, bucket; + LargeCacheRecord lcr; + ResourceRecord *rr = &lcr.r.resrec; + const mDNSu8 *ptr, *end; + struct timeval tv; + DNSQuestion zone; + char buf[MaxMsg]; + + if (pthread_mutex_lock(&d->tablelock)) { LogErr("UpdateLeaseTable", "pthread_mutex_lock"); return; } + HdrNToH(pkt); + ptr = pkt->msg.data; + end = (mDNSu8 *)&pkt->msg + pkt->len; + ptr = getQuestion(&pkt->msg, ptr, end, 0, &zone); + if (!ptr) { Log("UpdateLeaseTable: cannot read zone"); goto cleanup; } + ptr = LocateAuthorities(&pkt->msg, end); + if (!ptr) { Log("UpdateLeaseTable: Format error"); goto cleanup; } + + for (i = 0; i < pkt->msg.h.mDNS_numUpdates; i++) + { + mDNSBool DeleteAllRRSets = mDNSfalse, DeleteOneRRSet = mDNSfalse, DeleteOneRR = mDNSfalse; + + ptr = GetLargeResourceRecord(NULL, &pkt->msg, ptr, end, 0, kDNSRecordTypePacketAns, &lcr); + if (!ptr || lcr.r.resrec.RecordType == kDNSRecordTypePacketNegative) { Log("UpdateLeaseTable: GetLargeResourceRecord failed"); goto cleanup; } + bucket = rr->namehash % d->nbuckets; + rptr = &d->table[bucket]; + + // handle deletions + if (rr->rrtype == kDNSQType_ANY && !rr->rroriginalttl && rr->rrclass == kDNSQClass_ANY && !rr->rdlength) + DeleteAllRRSets = mDNStrue; // delete all rrsets for a name + else if (!rr->rroriginalttl && rr->rrclass == kDNSQClass_ANY && !rr->rdlength) + DeleteOneRRSet = mDNStrue; + else if (!rr->rroriginalttl && rr->rrclass == kDNSClass_NONE) + DeleteOneRR = mDNStrue; + + if (DeleteAllRRSets || DeleteOneRRSet || DeleteOneRR) + { + while (*rptr) + { + if (SameDomainName((*rptr)->rr.resrec.name, rr->name) && + (DeleteAllRRSets || + (DeleteOneRRSet && (*rptr)->rr.resrec.rrtype == rr->rrtype) || + (DeleteOneRR && IdenticalResourceRecord(&(*rptr)->rr.resrec, rr)))) + { + tmp = *rptr; + VLog("Received deletion update for %s", GetRRDisplayString_rdb(&tmp->rr.resrec, &tmp->rr.resrec.rdata->u, buf)); + *rptr = (*rptr)->next; + free(tmp); + d->nelems--; + } + else rptr = &(*rptr)->next; + } + } + else if (lease > 0) + { + // see if add or refresh + while (*rptr && !IdenticalResourceRecord(&(*rptr)->rr.resrec, rr)) rptr = &(*rptr)->next; + if (*rptr) + { + // refresh + if (gettimeofday(&tv, NULL)) { LogErr("UpdateLeaseTable", "gettimeofday"); goto cleanup; } + (*rptr)->expire = tv.tv_sec + (unsigned)lease; + VLog("Refreshing lease for %s", GetRRDisplayString_rdb(&lcr.r.resrec, &lcr.r.resrec.rdata->u, buf)); + } + else + { + // New record - add to table + if (d->nelems > d->nbuckets) + { + RehashTable(d); + bucket = rr->namehash % d->nbuckets; + rptr = &d->table[bucket]; + } + if (gettimeofday(&tv, NULL)) { LogErr("UpdateLeaseTable", "gettimeofday"); goto cleanup; } + allocsize = sizeof(RRTableElem); + if (rr->rdlength > InlineCacheRDSize) allocsize += (rr->rdlength - InlineCacheRDSize); + tmp = malloc(allocsize); + if (!tmp) { LogErr("UpdateLeaseTable", "malloc"); goto cleanup; } + memcpy(&tmp->rr, &lcr.r, sizeof(CacheRecord) + rr->rdlength - InlineCacheRDSize); + tmp->rr.resrec.rdata = (RData *)&tmp->rr.smallrdatastorage; + AssignDomainName(&tmp->name, rr->name); + tmp->rr.resrec.name = &tmp->name; + tmp->expire = tv.tv_sec + (unsigned)lease; + tmp->cli.sin_addr = pkt->src.sin_addr; + AssignDomainName(&tmp->zone, &zone.qname); + tmp->next = d->table[bucket]; + d->table[bucket] = tmp; + d->nelems++; + VLog("Adding update for %s to lease table", GetRRDisplayString_rdb(&lcr.r.resrec, &lcr.r.resrec.rdata->u, buf)); + } + } + } + +cleanup: + pthread_mutex_unlock(&d->tablelock); + HdrHToN(pkt); +} + +// Given a successful reply from a server, create a new reply that contains lease information +// Replies are currently not signed !!!KRS change this +mDNSlocal PktMsg *FormatLeaseReply(DaemonInfo *d, PktMsg *orig, mDNSu32 lease) +{ + PktMsg *reply; + mDNSu8 *ptr, *end; + mDNSOpaque16 flags; + + (void)d; //unused + reply = malloc(sizeof(*reply)); + if (!reply) { LogErr("FormatLeaseReply", "malloc"); return NULL; } + flags.b[0] = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update; + flags.b[1] = 0; + + InitializeDNSMessage(&reply->msg.h, orig->msg.h.id, flags); + reply->src.sin_addr.s_addr = zerov4Addr.NotAnInteger; // unused except for log messages + reply->src.sin_family = AF_INET; + ptr = reply->msg.data; + end = (mDNSu8 *)&reply->msg + sizeof(DNSMessage); + ptr = putUpdateLease(&reply->msg, ptr, lease); + if (!ptr) { Log("FormatLeaseReply: putUpdateLease failed"); free(reply); return NULL; } + reply->len = ptr - (mDNSu8 *)&reply->msg; + HdrHToN(reply); + return reply; +} + + +// pkt is thread-local, not requiring locking + +mDNSlocal PktMsg* +HandleRequest +( + DaemonInfo * self, + PktMsg * request +) +{ + PktMsg * reply = NULL; + PktMsg * leaseReply; + PktMsg buf; + char addrbuf[32]; + TCPSocket * sock = NULL; + mStatus err; + mDNSs32 lease = 0; + if ((request->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask) == kDNSFlag0_OP_Update) + { + int i, adds = 0, dels = 0; + const mDNSu8 *ptr, *end = (mDNSu8 *)&request->msg + request->len; + HdrNToH(request); + lease = GetPktLease(&mDNSStorage, &request->msg, end); + ptr = LocateAuthorities(&request->msg, end); + for (i = 0; i < request->msg.h.mDNS_numUpdates; i++) + { + LargeCacheRecord lcr; + ptr = GetLargeResourceRecord(NULL, &request->msg, ptr, end, 0, kDNSRecordTypePacketAns, &lcr); + if (lcr.r.resrec.RecordType != kDNSRecordTypePacketNegative && lcr.r.resrec.rroriginalttl) adds++;else dels++; + } + HdrHToN(request); + if (adds && !lease) + { + static const mDNSOpaque16 UpdateRefused = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_Update, kDNSFlag1_RC_Refused } }; + Log("Rejecting Update Request with %d additions but no lease", adds); + reply = malloc(sizeof(*reply)); + mDNSPlatformMemZero(&reply->src, sizeof(reply->src)); + reply->len = sizeof(DNSMessageHeader); + reply->zone = NULL; + reply->isZonePublic = 0; + InitializeDNSMessage(&reply->msg.h, request->msg.h.id, UpdateRefused); + return(reply); + } + if (lease > 7200) // Don't allow lease greater than two hours; typically 90-minute renewal period + lease = 7200; + } + // Send msg to server, read reply + + if ( request->len <= 512 ) + { + mDNSBool trunc; + + if ( UDPServerTransaction( self, request, &buf, &trunc) < 0 ) + { + Log("HandleRequest - UDPServerTransaction failed. Trying TCP"); + } + else if ( trunc ) + { + VLog("HandleRequest - answer truncated. Using TCP"); + } + else + { + reply = &buf; // success + } + } + + if ( !reply ) + { + mDNSBool closed; + int res; + + sock = ConnectToServer( self ); + require_action_quiet( sock, exit, err = mStatus_UnknownErr ; Log( "Discarding request from %s due to connection errors", inet_ntop( AF_INET, &request->src.sin_addr, addrbuf, 32 ) ) ); + + res = SendPacket( sock, request ); + require_action_quiet( res >= 0, exit, err = mStatus_UnknownErr ; Log( "Couldn't relay message from %s to server. Discarding.", inet_ntop(AF_INET, &request->src.sin_addr, addrbuf, 32 ) ) ); + + reply = RecvPacket( sock, &buf, &closed ); + } + + // IMPORTANT: reply is in network byte order at this point in the code + // We keep it this way because we send it back to the client in the same form + + // Is it an update? + + if ( reply && ( ( reply->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask ) == ( kDNSFlag0_OP_Update | kDNSFlag0_QR_Response ) ) ) + { + char pingmsg[4]; + mDNSBool ok = SuccessfulUpdateTransaction( request, reply ); + require_action( ok, exit, err = mStatus_UnknownErr; VLog( "Message from %s not a successful update.", inet_ntop(AF_INET, &request->src.sin_addr, addrbuf, 32 ) ) ); + + UpdateLeaseTable( request, self, lease ); + + if ( lease > 0 ) + { + leaseReply = FormatLeaseReply( self, reply, lease ); + + if ( !leaseReply ) + { + Log("HandleRequest - unable to format lease reply"); + } + + // %%% Looks like a potential memory leak -- who frees the original reply? + reply = leaseReply; + } + + // tell the main thread there was an update so it can send LLQs + + if ( send( self->LLQEventNotifySock, pingmsg, sizeof( pingmsg ), 0 ) != sizeof( pingmsg ) ) + { + LogErr("HandleRequest", "send"); + } + } + +exit: + + if ( sock ) + { + mDNSPlatformTCPCloseConnection( sock ); + } + + if ( reply == &buf ) + { + reply = malloc( sizeof( *reply ) ); + + if ( reply ) + { + reply->len = buf.len; + memcpy(&reply->msg, &buf.msg, buf.len); + } + else + { + LogErr("HandleRequest", "malloc"); + } + } + + return reply; +} + + +// +// LLQ Support Routines +// + +// Set fields of an LLQ OPT Resource Record +mDNSlocal void FormatLLQOpt(AuthRecord *opt, int opcode, const mDNSOpaque64 *const id, mDNSs32 lease) +{ + mDNSPlatformMemZero(opt, sizeof(*opt)); + mDNS_SetupResourceRecord(opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); + opt->resrec.rrclass = NormalMaxDNSMessageData; + opt->resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record + opt->resrec.rdestimate = sizeof(rdataOPT); + opt->resrec.rdata->u.opt[0].opt = kDNSOpt_LLQ; + opt->resrec.rdata->u.opt[0].u.llq.vers = kLLQ_Vers; + opt->resrec.rdata->u.opt[0].u.llq.llqOp = opcode; + opt->resrec.rdata->u.opt[0].u.llq.err = LLQErr_NoError; + opt->resrec.rdata->u.opt[0].u.llq.id = *id; + opt->resrec.rdata->u.opt[0].u.llq.llqlease = lease; +} + +// Calculate effective remaining lease of an LLQ +mDNSlocal mDNSu32 LLQLease(LLQEntry *e) +{ + struct timeval t; + + gettimeofday(&t, NULL); + if (e->expire < t.tv_sec) return 0; + else return e->expire - t.tv_sec; +} + +mDNSlocal void DeleteLLQ(DaemonInfo *d, LLQEntry *e) +{ + int bucket = DomainNameHashValue(&e->qname) % LLQ_TABLESIZE; + LLQEntry **ptr = &d->LLQTable[bucket]; + AnswerListElem *a = e->AnswerList; + char addr[32]; + + inet_ntop(AF_INET, &e->cli.sin_addr, addr, 32); + VLog("Deleting LLQ table entry for %##s client %s", e->qname.c, addr); + + if (a && !(--a->refcount) && d->AnswerTableCount >= LLQ_TABLESIZE) + { + // currently, generating initial answers blocks the main thread, so we keep the answer list + // even if the ref count drops to zero. To prevent unbounded table growth, we free shared answers + // if the ref count drops to zero AND there are more table elements than buckets + // !!!KRS update this when we make the table dynamically growable + + CacheRecord *cr = a->KnownAnswers, *tmp; + AnswerListElem **tbl = &d->AnswerTable[bucket]; + + while (cr) + { + tmp = cr; + cr = cr->next; + free(tmp); + } + + while (*tbl && *tbl != a) tbl = &(*tbl)->next; + if (*tbl) { *tbl = (*tbl)->next; free(a); d->AnswerTableCount--; } + else Log("Error: DeleteLLQ - AnswerList not found in table"); + } + + // remove LLQ from table, free memory + while(*ptr && *ptr != e) ptr = &(*ptr)->next; + if (!*ptr) { Log("Error: DeleteLLQ - LLQ not in table"); return; } + *ptr = (*ptr)->next; + free(e); +} + +mDNSlocal int SendLLQ(DaemonInfo *d, PktMsg *pkt, struct sockaddr_in dst, TCPSocket *sock) +{ + char addr[32]; + int err = -1; + + HdrHToN(pkt); + + if ( sock ) + { + if ( SendPacket( sock, pkt ) != 0 ) + { + LogErr("DaemonInfo", "MySend"); + Log("Could not send response to client %s", inet_ntop(AF_INET, &dst.sin_addr, addr, 32)); + } + } + else + { + if (sendto(d->llq_udpsd, &pkt->msg, pkt->len, 0, (struct sockaddr *)&dst, sizeof(dst)) != (int)pkt->len) + { + LogErr("DaemonInfo", "sendto"); + Log("Could not send response to client %s", inet_ntop(AF_INET, &dst.sin_addr, addr, 32)); + } + } + + err = 0; + HdrNToH(pkt); + return err; +} + +mDNSlocal CacheRecord *AnswerQuestion(DaemonInfo *d, AnswerListElem *e) +{ + PktMsg q; + int i; + TCPSocket *sock = NULL; + const mDNSu8 *ansptr; + mDNSu8 *end = q.msg.data; + PktMsg buf, *reply = NULL; + LargeCacheRecord lcr; + CacheRecord *AnswerList = NULL; + mDNSu8 rcode; + + VLog("Querying server for %##s type %d", e->name.c, e->type); + + InitializeDNSMessage(&q.msg.h, zeroID, uQueryFlags); + + end = putQuestion(&q.msg, end, end + AbsoluteMaxDNSMessageData, &e->name, e->type, kDNSClass_IN); + if (!end) { Log("Error: AnswerQuestion - putQuestion returned NULL"); goto end; } + q.len = (int)(end - (mDNSu8 *)&q.msg); + + HdrHToN(&q); + + if (!e->UseTCP) + { + mDNSBool trunc; + + if (UDPServerTransaction(d, &q, &buf, &trunc) < 0) + Log("AnswerQuestion %##s - UDPServerTransaction failed. Trying TCP", e->name.c); + else if (trunc) + { VLog("AnswerQuestion %##s - answer truncated. Using TCP", e->name.c); e->UseTCP = mDNStrue; } + else reply = &buf; // success + } + + if (!reply) + { + mDNSBool closed; + + sock = ConnectToServer(d); + if (!sock) { Log("AnswerQuestion: ConnectToServer failed"); goto end; } + if (SendPacket( sock, &q)) { Log("AnswerQuestion: SendPacket failed"); mDNSPlatformTCPCloseConnection( sock ); goto end; } + reply = RecvPacket( sock, NULL, &closed ); + mDNSPlatformTCPCloseConnection( sock ); + require_action( reply, end, Log( "AnswerQuestion: RecvPacket returned NULL" ) ); + } + + HdrNToH(&q); + if (reply) HdrNToH(reply); + + if ((reply->msg.h.flags.b[0] & kDNSFlag0_QROP_Mask) != (kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery)) + { Log("AnswerQuestion: %##s type %d - Invalid response flags from server"); goto end; } + rcode = (mDNSu8)(reply->msg.h.flags.b[1] & kDNSFlag1_RC_Mask); + if (rcode && rcode != kDNSFlag1_RC_NXDomain) { Log("AnswerQuestion: %##s type %d - non-zero rcode %d from server", e->name.c, e->type, rcode); goto end; } + + end = (mDNSu8 *)&reply->msg + reply->len; + ansptr = LocateAnswers(&reply->msg, end); + if (!ansptr) { Log("Error: AnswerQuestion - LocateAnswers returned NULL"); goto end; } + + for (i = 0; i < reply->msg.h.numAnswers; i++) + { + ansptr = GetLargeResourceRecord(NULL, &reply->msg, ansptr, end, 0, kDNSRecordTypePacketAns, &lcr); + if (!ansptr) { Log("AnswerQuestions: GetLargeResourceRecord returned NULL"); goto end; } + if (lcr.r.resrec.RecordType != kDNSRecordTypePacketNegative) + { + if (lcr.r.resrec.rrtype != e->type || lcr.r.resrec.rrclass != kDNSClass_IN || !SameDomainName(lcr.r.resrec.name, &e->name)) + { + Log("AnswerQuestion: response %##s type #d does not answer question %##s type #d. Discarding", + lcr.r.resrec.name->c, lcr.r.resrec.rrtype, e->name.c, e->type); + } + else + { + CacheRecord *cr = CopyCacheRecord(&lcr.r, &e->name); + if (!cr) { Log("Error: AnswerQuestion - CopyCacheRecord returned NULL"); goto end; } + cr->next = AnswerList; + AnswerList = cr; + } + } + } + +end: + if (reply && reply != &buf) free(reply); + return AnswerList; +} + +// Routine forks a thread to set EventList to contain Add/Remove events, and deletes any removes from the KnownAnswer list +mDNSlocal void *UpdateAnswerList(void *args) +{ + CacheRecord *cr, *NewAnswers, **na, **ka; // "new answer", "known answer" + DaemonInfo *d = ((UpdateAnswerListArgs *)args)->d; + AnswerListElem *a = ((UpdateAnswerListArgs *)args)->a; + + free(args); + args = NULL; + + // get up to date answers + NewAnswers = AnswerQuestion(d, a); + + // first pass - mark all answers for deletion + for (ka = &a->KnownAnswers; *ka; ka = &(*ka)->next) + (*ka)->resrec.rroriginalttl = (unsigned)-1; // -1 means delete + + // second pass - mark answers pre-existent + for (ka = &a->KnownAnswers; *ka; ka = &(*ka)->next) + { + for (na = &NewAnswers; *na; na = &(*na)->next) + { + if (IdenticalResourceRecord(&(*ka)->resrec, &(*na)->resrec)) + { (*ka)->resrec.rroriginalttl = 0; break; } // 0 means no change + } + } + + // third pass - add new records to Event list + na = &NewAnswers; + while (*na) + { + for (ka = &a->KnownAnswers; *ka; ka = &(*ka)->next) + if (IdenticalResourceRecord(&(*ka)->resrec, &(*na)->resrec)) break; + if (!*ka) + { + // answer is not in list - splice from NewAnswers list, add to Event list + cr = *na; + *na = (*na)->next; // splice from list + cr->next = a->EventList; // add spliced record to event list + a->EventList = cr; + cr->resrec.rroriginalttl = 1; // 1 means add + } + else na = &(*na)->next; + } + + // move all the removes from the answer list to the event list + ka = &a->KnownAnswers; + while (*ka) + { + if ((*ka)->resrec.rroriginalttl == (unsigned)-1) + { + cr = *ka; + *ka = (*ka)->next; + cr->next = a->EventList; + a->EventList = cr; + } + else ka = &(*ka)->next; + } + + // lastly, free the remaining records (known answers) in NewAnswers list + while (NewAnswers) + { + cr = NewAnswers; + NewAnswers = NewAnswers->next; + free(cr); + } + + return NULL; +} + +mDNSlocal void SendEvents(DaemonInfo *d, LLQEntry *e) +{ + PktMsg response; + CacheRecord *cr; + mDNSu8 *end = (mDNSu8 *)&response.msg.data; + mDNSOpaque16 msgID; + char rrbuf[MaxMsg], addrbuf[32]; + AuthRecord opt; + + // Should this really be random? Do we use the msgID on the receiving end? + msgID.NotAnInteger = random(); + if (verbose) inet_ntop(AF_INET, &e->cli.sin_addr, addrbuf, 32); + InitializeDNSMessage(&response.msg.h, msgID, ResponseFlags); + end = putQuestion(&response.msg, end, end + AbsoluteMaxDNSMessageData, &e->qname, e->qtype, kDNSClass_IN); + if (!end) { Log("Error: SendEvents - putQuestion returned NULL"); return; } + + // put adds/removes in packet + for (cr = e->AnswerList->EventList; cr; cr = cr->next) + { + if (verbose) GetRRDisplayString_rdb(&cr->resrec, &cr->resrec.rdata->u, rrbuf); + VLog("%s (%s): %s", addrbuf, (mDNSs32)cr->resrec.rroriginalttl < 0 ? "Remove" : "Add", rrbuf); + end = PutResourceRecordTTLJumbo(&response.msg, end, &response.msg.h.numAnswers, &cr->resrec, cr->resrec.rroriginalttl); + if (!end) { Log("Error: SendEvents - PutResourceRecordTTLJumbo returned NULL"); return; } + } + + FormatLLQOpt(&opt, kLLQOp_Event, &e->id, LLQLease(e)); + end = PutResourceRecordTTLJumbo(&response.msg, end, &response.msg.h.numAdditionals, &opt.resrec, 0); + if (!end) { Log("Error: SendEvents - PutResourceRecordTTLJumbo"); return; } + + response.len = (int)(end - (mDNSu8 *)&response.msg); + if (SendLLQ(d, &response, e->cli, NULL ) < 0) LogMsg("Error: SendEvents - SendLLQ"); +} + +mDNSlocal void PrintLLQAnswers(DaemonInfo *d) +{ + int i; + char rrbuf[MaxMsg]; + + Log("Printing LLQ Answer Table contents"); + + for (i = 0; i < LLQ_TABLESIZE; i++) + { + AnswerListElem *a = d->AnswerTable[i]; + while(a) + { + int ancount = 0; + const CacheRecord *rr = a->KnownAnswers; + while (rr) { ancount++; rr = rr->next; } + Log("%p : Question %##s; type %d; referenced by %d LLQs; %d answers:", a, a->name.c, a->type, a->refcount, ancount); + for (rr = a->KnownAnswers; rr; rr = rr->next) Log("\t%s", GetRRDisplayString_rdb(&rr->resrec, &rr->resrec.rdata->u, rrbuf)); + a = a->next; + } + } +} + +mDNSlocal void PrintLLQTable(DaemonInfo *d) +{ + LLQEntry *e; + char addr[32]; + int i; + + Log("Printing LLQ table contents"); + + for (i = 0; i < LLQ_TABLESIZE; i++) + { + e = d->LLQTable[i]; + while(e) + { + char *state; + + switch (e->state) + { + case RequestReceived: state = "RequestReceived"; break; + case ChallengeSent: state = "ChallengeSent"; break; + case Established: state = "Established"; break; + default: state = "unknown"; + } + inet_ntop(AF_INET, &e->cli.sin_addr, addr, 32); + + Log("LLQ from %s in state %s; %##s; type %d; orig lease %d; remaining lease %d; AnswerList %p)", + addr, state, e->qname.c, e->qtype, e->lease, LLQLease(e), e->AnswerList); + e = e->next; + } + } +} + +// Send events to clients as a result of a change in the zone +mDNSlocal void GenLLQEvents(DaemonInfo *d) +{ + LLQEntry **e; + int i; + struct timeval t; + UpdateAnswerListArgs *args; + + VLog("Generating LLQ Events"); + + gettimeofday(&t, NULL); + + // get all answers up to date + for (i = 0; i < LLQ_TABLESIZE; i++) + { + AnswerListElem *a = d->AnswerTable[i]; + while(a) + { + args = malloc(sizeof(*args)); + if (!args) { LogErr("GenLLQEvents", "malloc"); return; } + args->d = d; + args->a = a; + if (pthread_create(&a->tid, NULL, UpdateAnswerList, args) < 0) { LogErr("GenLLQEvents", "pthread_create"); return; } + usleep(1); + a = a->next; + } + } + + for (i = 0; i < LLQ_TABLESIZE; i++) + { + AnswerListElem *a = d->AnswerTable[i]; + while(a) + { + if (pthread_join(a->tid, NULL)) LogErr("GenLLQEvents", "pthread_join"); + a = a->next; + } + } + + // for each established LLQ, send events + for (i = 0; i < LLQ_TABLESIZE; i++) + { + e = &d->LLQTable[i]; + while(*e) + { + if ((*e)->expire < t.tv_sec) DeleteLLQ(d, *e); + else + { + if ((*e)->state == Established && (*e)->AnswerList->EventList) SendEvents(d, *e); + e = &(*e)->next; + } + } + } + + // now that all LLQs are updated, we move Add events from the Event list to the Known Answer list, and free Removes + for (i = 0; i < LLQ_TABLESIZE; i++) + { + AnswerListElem *a = d->AnswerTable[i]; + while(a) + { + if (a->EventList) + { + CacheRecord *cr = a->EventList, *tmp; + while (cr) + { + tmp = cr; + cr = cr->next; + if ((signed)tmp->resrec.rroriginalttl < 0) free(tmp); + else + { + tmp->next = a->KnownAnswers; + a->KnownAnswers = tmp; + tmp->resrec.rroriginalttl = 0; + } + } + a->EventList = NULL; + } + a = a->next; + } + } +} + +mDNSlocal void SetAnswerList(DaemonInfo *d, LLQEntry *e) +{ + int bucket = DomainNameHashValue(&e->qname) % LLQ_TABLESIZE; + AnswerListElem *a = d->AnswerTable[bucket]; + while (a && (a->type != e->qtype ||!SameDomainName(&a->name, &e->qname))) a = a->next; + if (!a) + { + a = malloc(sizeof(*a)); + if (!a) { LogErr("SetAnswerList", "malloc"); return; } + AssignDomainName(&a->name, &e->qname); + a->type = e->qtype; + a->refcount = 0; + a->EventList = NULL; + a->UseTCP = mDNSfalse; + a->next = d->AnswerTable[bucket]; + d->AnswerTable[bucket] = a; + d->AnswerTableCount++; + a->KnownAnswers = AnswerQuestion(d, a); + } + + e->AnswerList = a; + a->refcount++; +} + +// Allocate LLQ entry, insert into table +mDNSlocal LLQEntry *NewLLQ(DaemonInfo *d, struct sockaddr_in cli, domainname *qname, mDNSu16 qtype, mDNSu32 lease ) +{ + char addr[32]; + struct timeval t; + int bucket = DomainNameHashValue(qname) % LLQ_TABLESIZE; + LLQEntry *e; + + e = malloc(sizeof(*e)); + if (!e) { LogErr("NewLLQ", "malloc"); return NULL; } + + inet_ntop(AF_INET, &cli.sin_addr, addr, 32); + VLog("Allocating LLQ entry for client %s question %##s type %d", addr, qname->c, qtype); + + // initialize structure + e->cli = cli; + AssignDomainName(&e->qname, qname); + e->qtype = qtype; + e->id = zeroOpaque64; + e->state = RequestReceived; + e->AnswerList = NULL; + + if (lease < LLQ_MIN_LEASE) lease = LLQ_MIN_LEASE; + else if (lease > LLQ_MAX_LEASE) lease = LLQ_MAX_LEASE; + + gettimeofday(&t, NULL); + e->expire = t.tv_sec + (int)lease; + e->lease = lease; + + // add to table + e->next = d->LLQTable[bucket]; + d->LLQTable[bucket] = e; + + return e; +} + +// Handle a refresh request from client +mDNSlocal void LLQRefresh(DaemonInfo *d, LLQEntry *e, LLQOptData *llq, mDNSOpaque16 msgID, TCPSocket *sock ) +{ + AuthRecord opt; + PktMsg ack; + mDNSu8 *end = (mDNSu8 *)&ack.msg.data; + char addr[32]; + + inet_ntop(AF_INET, &e->cli.sin_addr, addr, 32); + VLog("%s LLQ for %##s from %s", llq->llqlease ? "Refreshing" : "Deleting", e->qname.c, addr); + + if (llq->llqlease) + { + struct timeval t; + if (llq->llqlease < LLQ_MIN_LEASE) llq->llqlease = LLQ_MIN_LEASE; + else if (llq->llqlease > LLQ_MAX_LEASE) llq->llqlease = LLQ_MIN_LEASE; + gettimeofday(&t, NULL); + e->expire = t.tv_sec + llq->llqlease; + } + + ack.src.sin_addr.s_addr = 0; // unused + InitializeDNSMessage(&ack.msg.h, msgID, ResponseFlags); + end = putQuestion(&ack.msg, end, end + AbsoluteMaxDNSMessageData, &e->qname, e->qtype, kDNSClass_IN); + if (!end) { Log("Error: putQuestion"); return; } + + FormatLLQOpt(&opt, kLLQOp_Refresh, &e->id, llq->llqlease ? LLQLease(e) : 0); + end = PutResourceRecordTTLJumbo(&ack.msg, end, &ack.msg.h.numAdditionals, &opt.resrec, 0); + if (!end) { Log("Error: PutResourceRecordTTLJumbo"); return; } + + ack.len = (int)(end - (mDNSu8 *)&ack.msg); + if (SendLLQ(d, &ack, e->cli, sock)) Log("Error: LLQRefresh"); + + if (llq->llqlease) e->state = Established; + else DeleteLLQ(d, e); +} + +// Complete handshake with Ack an initial answers +mDNSlocal void LLQCompleteHandshake(DaemonInfo *d, LLQEntry *e, LLQOptData *llq, mDNSOpaque16 msgID, TCPSocket *sock) +{ + char addr[32]; + CacheRecord *ptr; + AuthRecord opt; + PktMsg ack; + mDNSu8 *end = (mDNSu8 *)&ack.msg.data; + char rrbuf[MaxMsg], addrbuf[32]; + + inet_ntop(AF_INET, &e->cli.sin_addr, addr, 32); + + if (!mDNSSameOpaque64(&llq->id, &e->id) || + llq->vers != kLLQ_Vers || + llq->llqOp != kLLQOp_Setup || + llq->err != LLQErr_NoError || + llq->llqlease > e->lease + LLQ_LEASE_FUDGE || + llq->llqlease < e->lease - LLQ_LEASE_FUDGE) + { + Log("Incorrect challenge response from %s", addr); + return; + } + + if (e->state == Established) VLog("Retransmitting LLQ ack + answers for %##s", e->qname.c); + else VLog("Delivering LLQ ack + answers for %##s", e->qname.c); + + // format ack + answers + ack.src.sin_addr.s_addr = 0; // unused + InitializeDNSMessage(&ack.msg.h, msgID, ResponseFlags); + end = putQuestion(&ack.msg, end, end + AbsoluteMaxDNSMessageData, &e->qname, e->qtype, kDNSClass_IN); + if (!end) { Log("Error: putQuestion"); return; } + + if (e->state != Established) { SetAnswerList(d, e); e->state = Established; } + + if (verbose) inet_ntop(AF_INET, &e->cli.sin_addr, addrbuf, 32); + for (ptr = e->AnswerList->KnownAnswers; ptr; ptr = ptr->next) + { + if (verbose) GetRRDisplayString_rdb(&ptr->resrec, &ptr->resrec.rdata->u, rrbuf); + VLog("%s Intitial Answer - %s", addr, rrbuf); + end = PutResourceRecordTTLJumbo(&ack.msg, end, &ack.msg.h.numAnswers, &ptr->resrec, 1); + if (!end) { Log("Error: PutResourceRecordTTLJumbo"); return; } + } + + FormatLLQOpt(&opt, kLLQOp_Setup, &e->id, LLQLease(e)); + end = PutResourceRecordTTLJumbo(&ack.msg, end, &ack.msg.h.numAdditionals, &opt.resrec, 0); + if (!end) { Log("Error: PutResourceRecordTTLJumbo"); return; } + + ack.len = (int)(end - (mDNSu8 *)&ack.msg); + if (SendLLQ(d, &ack, e->cli, sock)) Log("Error: LLQCompleteHandshake"); +} + +mDNSlocal void LLQSetupChallenge(DaemonInfo *d, LLQEntry *e, LLQOptData *llq, mDNSOpaque16 msgID) +{ + struct timeval t; + PktMsg challenge; + mDNSu8 *end = challenge.msg.data; + AuthRecord opt; + + if (e->state == ChallengeSent) VLog("Retransmitting LLQ setup challenge for %##s", e->qname.c); + else VLog("Sending LLQ setup challenge for %##s", e->qname.c); + + if (!mDNSOpaque64IsZero(&llq->id)) { Log("Error: LLQSetupChallenge - nonzero ID"); return; } // server bug + if (llq->llqOp != kLLQOp_Setup) { Log("LLQSetupChallenge - incorrrect operation from client"); return; } // client error + + if (mDNSOpaque64IsZero(&e->id)) // don't regenerate random ID for retransmissions + { + // construct ID <time><random> + gettimeofday(&t, NULL); + e->id.l[0] = t.tv_sec; + e->id.l[1] = random(); + } + + // format response (query + LLQ opt rr) + challenge.src.sin_addr.s_addr = 0; // unused + InitializeDNSMessage(&challenge.msg.h, msgID, ResponseFlags); + end = putQuestion(&challenge.msg, end, end + AbsoluteMaxDNSMessageData, &e->qname, e->qtype, kDNSClass_IN); + if (!end) { Log("Error: putQuestion"); return; } + FormatLLQOpt(&opt, kLLQOp_Setup, &e->id, LLQLease(e)); + end = PutResourceRecordTTLJumbo(&challenge.msg, end, &challenge.msg.h.numAdditionals, &opt.resrec, 0); + if (!end) { Log("Error: PutResourceRecordTTLJumbo"); return; } + challenge.len = (int)(end - (mDNSu8 *)&challenge.msg); + if (SendLLQ(d, &challenge, e->cli, NULL)) { Log("Error: LLQSetupChallenge"); return; } + e->state = ChallengeSent; +} + +// Take action on an LLQ message from client. Entry must be initialized and in table +mDNSlocal void UpdateLLQ(DaemonInfo *d, LLQEntry *e, LLQOptData *llq, mDNSOpaque16 msgID, TCPSocket *sock ) +{ + switch(e->state) + { + case RequestReceived: + if ( sock ) + { + struct timeval t; + gettimeofday(&t, NULL); + e->id.l[0] = t.tv_sec; // construct ID <time><random> + e->id.l[1] = random(); + llq->id = e->id; + LLQCompleteHandshake( d, e, llq, msgID, sock ); + + // Set the state to established because we've just set the LLQ up using TCP + e->state = Established; + } + else + { + LLQSetupChallenge(d, e, llq, msgID); + } + return; + case ChallengeSent: + if (mDNSOpaque64IsZero(&llq->id)) LLQSetupChallenge(d, e, llq, msgID); // challenge sent and lost + else LLQCompleteHandshake(d, e, llq, msgID, sock ); + return; + case Established: + if (mDNSOpaque64IsZero(&llq->id)) + { + // client started over. reset state. + LLQEntry *newe = NewLLQ(d, e->cli, &e->qname, e->qtype, llq->llqlease ); + if (!newe) return; + DeleteLLQ(d, e); + LLQSetupChallenge(d, newe, llq, msgID); + return; + } + else if (llq->llqOp == kLLQOp_Setup) + { LLQCompleteHandshake(d, e, llq, msgID, sock); return; } // Ack lost + else if (llq->llqOp == kLLQOp_Refresh) + { LLQRefresh(d, e, llq, msgID, sock); return; } + else { Log("Unhandled message for established LLQ"); return; } + } +} + +mDNSlocal LLQEntry *LookupLLQ(DaemonInfo *d, struct sockaddr_in cli, domainname *qname, mDNSu16 qtype, const mDNSOpaque64 *const id) +{ + int bucket = bucket = DomainNameHashValue(qname) % LLQ_TABLESIZE; + LLQEntry *ptr = d->LLQTable[bucket]; + + while(ptr) + { + if (((ptr->state == ChallengeSent && mDNSOpaque64IsZero(id) && (cli.sin_port == ptr->cli.sin_port)) || // zero-id due to packet loss OK in state ChallengeSent + mDNSSameOpaque64(id, &ptr->id)) && // id match + (cli.sin_addr.s_addr == ptr->cli.sin_addr.s_addr) && (qtype == ptr->qtype) && SameDomainName(&ptr->qname, qname)) // same source, type, qname + return ptr; + ptr = ptr->next; + } + return NULL; +} + +mDNSlocal int +RecvNotify +( + DaemonInfo * d, + PktMsg * pkt +) +{ + int res; + int err = 0; + + pkt->msg.h.flags.b[0] |= kDNSFlag0_QR_Response; + + res = sendto( d->udpsd, &pkt->msg, pkt->len, 0, ( struct sockaddr* ) &pkt->src, sizeof( pkt->src ) ); + require_action( res == ( int ) pkt->len, exit, err = mStatus_UnknownErr; LogErr( "RecvNotify", "sendto" ) ); + +exit: + + return err; +} + + +mDNSlocal int RecvLLQ( DaemonInfo *d, PktMsg *pkt, TCPSocket *sock ) +{ + DNSQuestion q; + LargeCacheRecord opt; + int i, err = -1; + char addr[32]; + const mDNSu8 *qptr = pkt->msg.data; + const mDNSu8 *end = (mDNSu8 *)&pkt->msg + pkt->len; + const mDNSu8 *aptr; + LLQOptData *llq = NULL; + LLQEntry *e = NULL; + + HdrNToH(pkt); + aptr = LocateAdditionals(&pkt->msg, end); // Can't do this until after HdrNToH(pkt); + inet_ntop(AF_INET, &pkt->src.sin_addr, addr, 32); + + VLog("Received LLQ msg from %s", addr); + // sanity-check packet + if (!pkt->msg.h.numQuestions || !pkt->msg.h.numAdditionals) + { + Log("Malformatted LLQ from %s with %d questions, %d additionals", addr, pkt->msg.h.numQuestions, pkt->msg.h.numAdditionals); + goto end; + } + + // Locate the OPT record. + // According to RFC 2671, "One OPT pseudo-RR can be added to the additional data section of either a request or a response." + // This implies that there may be *at most* one OPT record per DNS message, in the Additional Section, + // but not necessarily the *last* entry in the Additional Section. + for (i = 0; i < pkt->msg.h.numAdditionals; i++) + { + aptr = GetLargeResourceRecord(NULL, &pkt->msg, aptr, end, 0, kDNSRecordTypePacketAdd, &opt); + if (!aptr) { Log("Malformatted LLQ from %s: could not get Additional record %d", addr, i); goto end; } + if (opt.r.resrec.RecordType != kDNSRecordTypePacketNegative && opt.r.resrec.rrtype == kDNSType_OPT) break; + } + + // validate OPT + if (opt.r.resrec.rrtype != kDNSType_OPT) { Log("Malformatted LLQ from %s: last Additional not an OPT RR", addr); goto end; } + if (opt.r.resrec.rdlength < pkt->msg.h.numQuestions * DNSOpt_LLQData_Space) { Log("Malformatted LLQ from %s: OPT RR to small (%d bytes for %d questions)", addr, opt.r.resrec.rdlength, pkt->msg.h.numQuestions); } + + // dispatch each question + for (i = 0; i < pkt->msg.h.numQuestions; i++) + { + qptr = getQuestion(&pkt->msg, qptr, end, 0, &q); + if (!qptr) { Log("Malformatted LLQ from %s: cannot read question %d", addr, i); goto end; } + llq = (LLQOptData *)&opt.r.resrec.rdata->u.opt[0].u.llq + i; // point into OptData at index i + if (llq->vers != kLLQ_Vers) { Log("LLQ from %s contains bad version %d (expected %d)", addr, llq->vers, kLLQ_Vers); goto end; } + + e = LookupLLQ(d, pkt->src, &q.qname, q.qtype, &llq->id); + if (!e) + { + // no entry - if zero ID, create new + e = NewLLQ(d, pkt->src, &q.qname, q.qtype, llq->llqlease ); + if (!e) goto end; + } + UpdateLLQ(d, e, llq, pkt->msg.h.id, sock); + } + err = 0; + +end: + HdrHToN(pkt); + return err; +} + + +mDNSlocal mDNSBool IsAuthorized( DaemonInfo * d, PktMsg * pkt, DomainAuthInfo ** key, mDNSu16 * rcode, mDNSu16 * tcode ) +{ + const mDNSu8 * lastPtr = NULL; + const mDNSu8 * ptr = NULL; + DomainAuthInfo * keys; + mDNSu8 * end = ( mDNSu8* ) &pkt->msg + pkt->len; + LargeCacheRecord lcr; + mDNSBool hasTSIG = mDNSfalse; + mDNSBool strip = mDNSfalse; + mDNSBool ok = mDNSfalse; + int i; + + // Unused parameters + + ( void ) d; + + HdrNToH(pkt); + + *key = NULL; + + if ( pkt->msg.h.numAdditionals ) + { + ptr = LocateAdditionals(&pkt->msg, end); + if (ptr) + { + for (i = 0; i < pkt->msg.h.numAdditionals; i++) + { + lastPtr = ptr; + ptr = GetLargeResourceRecord(NULL, &pkt->msg, ptr, end, 0, kDNSRecordTypePacketAdd, &lcr); + if (!ptr) + { + Log("Unable to read additional record"); + lastPtr = NULL; + break; + } + } + + hasTSIG = ( ptr && lcr.r.resrec.RecordType != kDNSRecordTypePacketNegative && lcr.r.resrec.rrtype == kDNSType_TSIG ); + } + else + { + LogMsg( "IsAuthorized: unable to find Additional section" ); + } + } + + // If we don't know what zone this is, then it's authorized. + + if ( !pkt->zone ) + { + ok = mDNStrue; + strip = mDNSfalse; + goto exit; + } + + if ( IsQuery( pkt ) ) + { + keys = pkt->zone->queryKeys; + strip = mDNStrue; + } + else if ( IsUpdate( pkt ) ) + { + keys = pkt->zone->updateKeys; + strip = mDNSfalse; + } + else + { + ok = mDNStrue; + strip = mDNSfalse; + goto exit; + } + + if ( pkt->isZonePublic ) + { + ok = mDNStrue; + goto exit; + } + + // If there are no keys, then we're authorized + + if ( ( hasTSIG && !keys ) || ( !hasTSIG && keys ) ) + { + Log( "Invalid TSIG spec %##s for zone %##s", lcr.r.resrec.name->c, pkt->zone->name.c ); + *rcode = kDNSFlag1_RC_NotAuth; + *tcode = TSIG_ErrBadKey; + strip = mDNStrue; + ok = mDNSfalse; + goto exit; + } + + // Find the right key + + for ( *key = keys; *key; *key = (*key)->next ) + { + if ( SameDomainName( lcr.r.resrec.name, &(*key)->keyname ) ) + { + break; + } + } + + if ( !(*key) ) + { + Log( "Invalid TSIG name %##s for zone %##s", lcr.r.resrec.name->c, pkt->zone->name.c ); + *rcode = kDNSFlag1_RC_NotAuth; + *tcode = TSIG_ErrBadKey; + strip = mDNStrue; + ok = mDNSfalse; + goto exit; + } + + // Okay, we have the correct key and a TSIG record. DNSDigest_VerifyMessage does the heavy + // lifting of message verification + + pkt->msg.h.numAdditionals--; + + HdrHToN( pkt ); + + ok = DNSDigest_VerifyMessage( &pkt->msg, ( mDNSu8* ) lastPtr, &lcr, (*key), rcode, tcode ); + + HdrNToH( pkt ); + + pkt->msg.h.numAdditionals++; + +exit: + + if ( hasTSIG && strip ) + { + // Strip the TSIG from the message + + pkt->msg.h.numAdditionals--; + pkt->len = lastPtr - ( mDNSu8* ) ( &pkt->msg ); + } + + HdrHToN(pkt); + + return ok; +} + +// request handler wrappers for TCP and UDP requests +// (read message off socket, fork thread that invokes main processing routine and handles cleanup) + +mDNSlocal void* +UDPMessageHandler +( + void * vptr +) +{ + UDPContext * context = ( UDPContext* ) vptr; + PktMsg * reply = NULL; + int res; + mStatus err; + + // !!!KRS strictly speaking, we shouldn't use TCP for a UDP request because the server + // may give us a long answer that would require truncation for UDP delivery to client + + reply = HandleRequest( context->d, &context->pkt ); + require_action( reply, exit, err = mStatus_UnknownErr ); + + res = sendto( context->sd, &reply->msg, reply->len, 0, ( struct sockaddr* ) &context->pkt.src, sizeof( context->pkt.src ) ); + require_action_quiet( res == ( int ) reply->len, exit, LogErr( "UDPMessageHandler", "sendto" ) ); + +exit: + + if ( reply ) + { + free( reply ); + } + + free( context ); + + pthread_exit( NULL ); + + return NULL; +} + + +mDNSlocal int +RecvUDPMessage +( + DaemonInfo * self, + int sd +) +{ + UDPContext * context = NULL; + pthread_t tid; + mDNSu16 rcode; + mDNSu16 tcode; + DomainAuthInfo * key; + unsigned int clisize = sizeof( context->cliaddr ); + int res; + mStatus err = mStatus_NoError; + + context = malloc( sizeof( UDPContext ) ); + require_action( context, exit, err = mStatus_NoMemoryErr ; LogErr( "RecvUDPMessage", "malloc" ) ); + + mDNSPlatformMemZero( context, sizeof( *context ) ); + context->d = self; + context->sd = sd; + + res = recvfrom(sd, &context->pkt.msg, sizeof(context->pkt.msg), 0, (struct sockaddr *)&context->cliaddr, &clisize); + + require_action( res >= 0, exit, err = mStatus_UnknownErr ; LogErr( "RecvUDPMessage", "recvfrom" ) ); + context->pkt.len = res; + require_action( clisize == sizeof( context->cliaddr ), exit, err = mStatus_UnknownErr ; Log( "Client address of unknown size %d", clisize ) ); + context->pkt.src = context->cliaddr; + + // Set the zone in the packet + + SetZone( context->d, &context->pkt ); + + // Notify messages handled by main thread + + if ( IsNotify( &context->pkt ) ) + { + int e = RecvNotify( self, &context->pkt ); + free(context); + return e; + } + else if ( IsAuthorized( context->d, &context->pkt, &key, &rcode, &tcode ) ) + { + if ( IsLLQRequest( &context->pkt ) ) + { + // LLQ messages handled by main thread + int e = RecvLLQ( self, &context->pkt, NULL ); + free(context); + return e; + } + + if ( IsLLQAck(&context->pkt ) ) + { + // !!!KRS need to do acks + retrans + + free(context); + return 0; + } + + err = pthread_create( &tid, NULL, UDPMessageHandler, context ); + require_action( !err, exit, LogErr( "RecvUDPMessage", "pthread_create" ) ); + + pthread_detach(tid); + } + else + { + PktMsg reply; + int e; + + memcpy( &reply, &context->pkt, sizeof( PktMsg ) ); + + reply.msg.h.flags.b[0] = kDNSFlag0_QR_Response | kDNSFlag0_AA | kDNSFlag0_RD; + reply.msg.h.flags.b[1] = kDNSFlag1_RA | kDNSFlag1_RC_NXDomain; + + e = sendto( sd, &reply.msg, reply.len, 0, ( struct sockaddr* ) &context->pkt.src, sizeof( context->pkt.src ) ); + require_action_quiet( e == ( int ) reply.len, exit, LogErr( "RecvUDPMessage", "sendto" ) ); + + err = mStatus_NoAuth; + } + +exit: + + if ( err && context ) + { + free( context ); + } + + return err; +} + + +mDNSlocal void +FreeTCPContext +( + TCPContext * context +) +{ + if ( context ) + { + if ( context->sock ) + { + mDNSPlatformTCPCloseConnection( context->sock ); + } + + free( context ); + } +} + + +mDNSlocal void* +TCPMessageHandler +( + void * vptr +) +{ + TCPContext * context = ( TCPContext* ) vptr; + PktMsg * reply = NULL; + int res; + char buf[32]; + + //!!!KRS if this read blocks indefinitely, we can run out of threads + // read the request + + reply = HandleRequest( context->d, &context->pkt ); + require_action_quiet( reply, exit, LogMsg( "TCPMessageHandler: No reply for client %s", inet_ntop( AF_INET, &context->cliaddr.sin_addr, buf, 32 ) ) ); + + // deliver reply to client + + res = SendPacket( context->sock, reply ); + require_action( res >= 0, exit, LogMsg("TCPMessageHandler: Unable to send reply to client %s", inet_ntop(AF_INET, &context->cliaddr.sin_addr, buf, 32 ) ) ); + +exit: + + FreeTCPContext( context ); + + if ( reply ) + { + free( reply ); + } + + pthread_exit(NULL); +} + + +mDNSlocal void +RecvTCPMessage +( + void * param +) +{ + TCPContext * context = ( TCPContext* ) param; + mDNSu16 rcode; + mDNSu16 tcode; + pthread_t tid; + DomainAuthInfo * key; + PktMsg * pkt; + mDNSBool closed; + mDNSBool freeContext = mDNStrue; + mStatus err = mStatus_NoError; + + // Receive a packet. It's okay if we don't actually read a packet, as long as the closed flag is + // set to false. This is because SSL/TLS layer might gobble up the first packet that we read off the + // wire. We'll let it do that, and wait for the next packet which will be ours. + + pkt = RecvPacket( context->sock, &context->pkt, &closed ); + if (pkt) HdrNToH(pkt); + require_action( pkt || !closed, exit, err = mStatus_UnknownErr; LogMsg( "client disconnected" ) ); + + if ( pkt ) + { + // Always do this, regardless of what kind of packet it is. If we wanted LLQ events to be sent over TCP, + // we would change this line of code. As it is now, we will reply to an LLQ via TCP, but then events + // are sent over UDP + + RemoveSourceFromEventLoop( context->d, context->sock ); + + // Set's the DNS Zone that is associated with this message + + SetZone( context->d, &context->pkt ); + + // IsAuthorized will make sure the message is authorized for the designated zone. + // After verifying the signature, it will strip the TSIG from the message + + if ( IsAuthorized( context->d, &context->pkt, &key, &rcode, &tcode ) ) + { + if ( IsLLQRequest( &context->pkt ) ) + { + // LLQ messages handled by main thread + RecvLLQ( context->d, &context->pkt, context->sock); + } + else + { + err = pthread_create( &tid, NULL, TCPMessageHandler, context ); + + if ( err ) + { + LogErr( "RecvTCPMessage", "pthread_create" ); + err = mStatus_NoError; + goto exit; + } + + // Let the thread free the context + + freeContext = mDNSfalse; + + pthread_detach(tid); + } + } + else + { + PktMsg reply; + + LogMsg( "Client %s Not authorized for zone %##s", inet_ntoa( context->pkt.src.sin_addr ), pkt->zone->name.c ); + + memcpy( &reply, &context->pkt, sizeof( PktMsg ) ); + + reply.msg.h.flags.b[0] = kDNSFlag0_QR_Response | kDNSFlag0_AA | kDNSFlag0_RD; + reply.msg.h.flags.b[1] = kDNSFlag1_RA | kDNSFlag1_RC_Refused; + + SendPacket( context->sock, &reply ); + } + } + else + { + freeContext = mDNSfalse; + } + +exit: + + if ( err ) + { + RemoveSourceFromEventLoop( context->d, context->sock ); + } + + if ( freeContext ) + { + FreeTCPContext( context ); + } +} + + +mDNSlocal int +AcceptTCPConnection +( + DaemonInfo * self, + int sd, + TCPSocketFlags flags +) +{ + TCPContext * context = NULL; + unsigned int clilen = sizeof( context->cliaddr); + int newSock; + mStatus err = mStatus_NoError; + + context = ( TCPContext* ) malloc( sizeof( TCPContext ) ); + require_action( context, exit, err = mStatus_NoMemoryErr; LogErr( "AcceptTCPConnection", "malloc" ) ); + mDNSPlatformMemZero( context, sizeof( sizeof( TCPContext ) ) ); + context->d = self; + newSock = accept( sd, ( struct sockaddr* ) &context->cliaddr, &clilen ); + require_action( newSock != -1, exit, err = mStatus_UnknownErr; LogErr( "AcceptTCPConnection", "accept" ) ); + + context->sock = mDNSPlatformTCPAccept( flags, newSock ); + require_action( context->sock, exit, err = mStatus_UnknownErr; LogErr( "AcceptTCPConnection", "mDNSPlatformTCPAccept" ) ); + + err = AddSourceToEventLoop( self, context->sock, RecvTCPMessage, context ); + require_action( !err, exit, LogErr( "AcceptTCPConnection", "AddSourceToEventLoop" ) ); + +exit: + + if ( err && context ) + { + free( context ); + context = NULL; + } + + return err; +} + + +// main event loop +// listen for incoming requests, periodically check table for expired records, respond to signals +mDNSlocal int Run(DaemonInfo *d) +{ + int staticMaxFD, nfds; + fd_set rset; + struct timeval timenow, timeout, EventTS, tablecheck = { 0, 0 }; + mDNSBool EventsPending = mDNSfalse; + + VLog("Listening for requests..."); + + staticMaxFD = 0; + + if ( d->tcpsd + 1 > staticMaxFD ) staticMaxFD = d->tcpsd + 1; + if ( d->udpsd + 1 > staticMaxFD ) staticMaxFD = d->udpsd + 1; + if ( d->tlssd + 1 > staticMaxFD ) staticMaxFD = d->tlssd + 1; + if ( d->llq_tcpsd + 1 > staticMaxFD ) staticMaxFD = d->llq_tcpsd + 1; + if ( d->llq_udpsd + 1 > staticMaxFD ) staticMaxFD = d->llq_udpsd + 1; + if ( d->LLQEventListenSock + 1 > staticMaxFD ) staticMaxFD = d->LLQEventListenSock + 1; + + while(1) + { + EventSource * source; + int maxFD; + + // set timeout + timeout.tv_sec = timeout.tv_usec = 0; + if (gettimeofday(&timenow, NULL)) { LogErr("Run", "gettimeofday"); return -1; } + + if (EventsPending) + { + if (timenow.tv_sec - EventTS.tv_sec >= 5) // if we've been waiting 5 seconds for a "quiet" period to send + { GenLLQEvents(d); EventsPending = mDNSfalse; } // events, we go ahead and do it now + else timeout.tv_usec = 500000; // else do events after 1/2 second with no new events or LLQs + } + if (!EventsPending) + { + // if no pending events, timeout when we need to check for expired records + if (tablecheck.tv_sec && timenow.tv_sec - tablecheck.tv_sec >= 0) + { DeleteRecords(d, mDNSfalse); tablecheck.tv_sec = 0; } // table check overdue + if (!tablecheck.tv_sec) tablecheck.tv_sec = timenow.tv_sec + EXPIRATION_INTERVAL; + timeout.tv_sec = tablecheck.tv_sec - timenow.tv_sec; + } + + FD_ZERO(&rset); + FD_SET( d->tcpsd, &rset ); + FD_SET( d->udpsd, &rset ); + FD_SET( d->tlssd, &rset ); + FD_SET( d->llq_tcpsd, &rset ); + FD_SET( d->llq_udpsd, &rset ); + FD_SET( d->LLQEventListenSock, &rset ); + + maxFD = staticMaxFD; + + for ( source = ( EventSource* ) d->eventSources.Head; source; source = source->next ) + { + FD_SET( source->fd, &rset ); + + if ( source->fd > maxFD ) + { + maxFD = source->fd; + } + } + + nfds = select( maxFD + 1, &rset, NULL, NULL, &timeout); + if (nfds < 0) + { + if (errno == EINTR) + { + if (terminate) + { + // close sockets to prevent clients from making new requests during shutdown + close( d->tcpsd ); + close( d->udpsd ); + close( d->tlssd ); + close( d->llq_tcpsd ); + close( d->llq_udpsd ); + d->tcpsd = d->udpsd = d->tlssd = d->llq_tcpsd = d->llq_udpsd = -1; + DeleteRecords(d, mDNStrue); + return 0; + } + else if (dumptable) + { + Log( "Received SIGINFO" ); + + PrintLeaseTable(d); + PrintLLQTable(d); + PrintLLQAnswers(d); + dumptable = 0; + } + else if (hangup) + { + int err; + + Log( "Received SIGHUP" ); + + err = ParseConfig( d, cfgfile ); + + if ( err ) + { + LogErr( "Run", "ParseConfig" ); + return -1; + } + + hangup = 0; + } + else + { + Log("Received unhandled signal - continuing"); + } + } + else + { + LogErr("Run", "select"); return -1; + } + } + else if (nfds) + { + if (FD_ISSET(d->udpsd, &rset)) RecvUDPMessage( d, d->udpsd ); + if (FD_ISSET(d->llq_udpsd, &rset)) RecvUDPMessage( d, d->llq_udpsd ); + if (FD_ISSET(d->tcpsd, &rset)) AcceptTCPConnection( d, d->tcpsd, 0 ); + if (FD_ISSET(d->llq_tcpsd, &rset)) AcceptTCPConnection( d, d->llq_tcpsd, 0 ); + if (FD_ISSET(d->tlssd, &rset)) AcceptTCPConnection( d, d->tlssd, TCP_SOCKET_FLAGS ); + if (FD_ISSET(d->LLQEventListenSock, &rset)) + { + // clear signalling data off socket + char buf[256]; + recv(d->LLQEventListenSock, buf, 256, 0); + if (!EventsPending) + { + EventsPending = mDNStrue; + if (gettimeofday(&EventTS, NULL)) { LogErr("Run", "gettimeofday"); return -1; } + } + } + + for ( source = ( EventSource* ) d->eventSources.Head; source; source = source->next ) + { + if ( FD_ISSET( source->fd, &rset ) ) + { + source->callback( source->context ); + break; // in case we removed this guy from the event loop + } + } + } + else + { + // timeout + if (EventsPending) { GenLLQEvents(d); EventsPending = mDNSfalse; } + else { DeleteRecords(d, mDNSfalse); tablecheck.tv_sec = 0; } + } + } + return 0; +} + +// signal handler sets global variables, which are inspected by main event loop +// (select automatically returns due to the handled signal) +mDNSlocal void HndlSignal(int sig) +{ + if (sig == SIGTERM || sig == SIGINT ) { terminate = 1; return; } + if (sig == INFO_SIGNAL) { dumptable = 1; return; } + if (sig == SIGHUP) { hangup = 1; return; } +} + +mDNSlocal mStatus +SetPublicSRV +( + DaemonInfo * d, + const char * name +) +{ + DNameListElem * elem; + mStatus err = mStatus_NoError; + + elem = ( DNameListElem* ) malloc( sizeof( DNameListElem ) ); + require_action( elem, exit, err = mStatus_NoMemoryErr ); + MakeDomainNameFromDNSNameString( &elem->name, name ); + elem->next = d->public_names; + d->public_names = elem; + +exit: + + return err; +} + + +int main(int argc, char *argv[]) +{ + int started_via_launchd = 0; + DaemonInfo *d; + struct rlimit rlim; + + Log("dnsextd starting"); + + d = malloc(sizeof(*d)); + if (!d) { LogErr("main", "malloc"); exit(1); } + mDNSPlatformMemZero(d, sizeof(DaemonInfo)); + + // Setup the public SRV record names + + SetPublicSRV(d, "_dns-update._udp."); + SetPublicSRV(d, "_dns-llq._udp."); + SetPublicSRV(d, "_dns-update-tls._tcp."); + SetPublicSRV(d, "_dns-query-tls._tcp."); + SetPublicSRV(d, "_dns-llq-tls._tcp."); + + // Setup signal handling + + if (signal(SIGHUP, HndlSignal) == SIG_ERR) perror("Can't catch SIGHUP"); + if (signal(SIGTERM, HndlSignal) == SIG_ERR) perror("Can't catch SIGTERM"); + if (signal(INFO_SIGNAL, HndlSignal) == SIG_ERR) perror("Can't catch SIGINFO"); + if (signal(SIGINT, HndlSignal) == SIG_ERR) perror("Can't catch SIGINT"); + if (signal(SIGPIPE, SIG_IGN ) == SIG_ERR) perror("Can't ignore SIGPIPE"); + + // remove open file limit + rlim.rlim_max = RLIM_INFINITY; + rlim.rlim_cur = RLIM_INFINITY; + if (setrlimit(RLIMIT_NOFILE, &rlim) < 0) + { + LogErr("main", "setrlimit"); + Log("Using default file descriptor resource limit"); + } + + if (argc > 1 && !strcasecmp(argv[1], "-launchd")) + { + Log("started_via_launchd"); + started_via_launchd = 1; + argv++; + argc--; + } + if (ProcessArgs(argc, argv, d) < 0) { LogErr("main", "ProcessArgs"); exit(1); } + + if (!foreground && !started_via_launchd) + { + if (daemon(0,0)) + { + LogErr("main", "daemon"); + foreground = 1; + } + } + + if (InitLeaseTable(d) < 0) { LogErr("main", "InitLeaseTable"); exit(1); } + if (SetupSockets(d) < 0) { LogErr("main", "SetupSockets"); exit(1); } + if (SetUpdateSRV(d) < 0) { LogErr("main", "SetUpdateSRV"); exit(1); } + + Run(d); + + Log("dnsextd stopping"); + + if (ClearUpdateSRV(d) < 0) { LogErr("main", "ClearUpdateSRV"); exit(1); } // clear update srv's even if Run or pthread_create returns an error + free(d); + exit(0); +} + + +// These are stubbed out implementations of up-call routines that the various platform support layers +// call. These routines are fully implemented in both mDNS.c and uDNS.c, but dnsextd doesn't +// link this code in. +// +// It's an error for these routines to actually be called, so perhaps we should log any call +// to them. +void mDNSCoreInitComplete( mDNS * const m, mStatus result) { ( void ) m; ( void ) result; } +void mDNS_ConfigChanged(mDNS *const m) { ( void ) m; } +void mDNSCoreMachineSleep(mDNS * const m, mDNSBool wake) { ( void ) m; ( void ) wake; } +void mDNSCoreReceive(mDNS *const m, void *const msg, const mDNSu8 *const end, + const mDNSAddr *const srcaddr, const mDNSIPPort srcport, + const mDNSAddr *const dstaddr, const mDNSIPPort dstport, const mDNSInterfaceID iid) +{ ( void ) m; ( void ) msg; ( void ) end; ( void ) srcaddr; ( void ) srcport; ( void ) dstaddr; ( void ) dstport; ( void ) iid; } +DNSServer *mDNS_AddDNSServer(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, const int serviceID, const mDNSAddr *addr, const mDNSIPPort port, + mDNSu32 scoped, mDNSu32 timeout, mDNSBool cellIntf, mDNSu16 resGroupID, mDNSBool reqA, mDNSBool reqAAAA, mDNSBool reqDO) +{ ( void ) m; ( void ) d; ( void ) interface; ( void ) serviceID; ( void ) addr; ( void ) port; ( void ) scoped; ( void ) timeout; (void) cellIntf; + (void) resGroupID; (void) reqA; (void) reqAAAA; (void) reqDO; return(NULL); } +void mDNS_AddSearchDomain(const domainname *const domain, mDNSInterfaceID InterfaceID) { (void)domain; (void) InterfaceID;} +void mDNS_AddDynDNSHostName(mDNS *m, const domainname *fqdn, mDNSRecordCallback *StatusCallback, const void *StatusContext) +{ ( void ) m; ( void ) fqdn; ( void ) StatusCallback; ( void ) StatusContext; } +mDNSs32 mDNS_Execute (mDNS *const m) { ( void ) m; return 0; } +mDNSs32 mDNS_TimeNow(const mDNS *const m) { ( void ) m; return 0; } +mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr) { ( void ) m; ( void ) rr; return 0; } +void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping) +{ ( void ) m; ( void ) set; ( void ) flapping; } +const char * const mDNS_DomainTypeNames[1] = {}; +mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom, + const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context) +{ ( void ) m; ( void ) question; ( void ) DomainType; ( void ) dom; ( void ) InterfaceID; ( void ) Callback; ( void ) Context; return 0; } +mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr) { ( void ) m; ( void ) rr; return 0; } +mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping) +{ ( void ) m; ( void ) set; ( void ) flapping; return 0; } +void mDNS_RemoveDynDNSHostName(mDNS *m, const domainname *fqdn) { ( void ) m; ( void ) fqdn; } +void mDNS_SetFQDN(mDNS * const m) { ( void ) m; } +void mDNS_SetPrimaryInterfaceInfo(mDNS *m, const mDNSAddr *v4addr, const mDNSAddr *v6addr, const mDNSAddr *router) +{ ( void ) m; ( void ) v4addr; ( void ) v6addr; ( void ) router; } +mStatus uDNS_SetupDNSConfig( mDNS *const m ) { ( void ) m; return 0; } +mStatus mDNS_SetSecretForDomain(mDNS *m, DomainAuthInfo *info, + const domainname *domain, const domainname *keyname, const char *b64keydata, const domainname *hostname, mDNSIPPort *port, mDNSBool autoTunnel) +{ ( void ) m; ( void ) info; ( void ) domain; ( void ) keyname; ( void ) b64keydata; ( void ) hostname; (void) port; ( void ) autoTunnel; return 0; } +mStatus mDNS_StopQuery(mDNS *const m, DNSQuestion *const question) { ( void ) m; ( void ) question; return 0; } +void TriggerEventCompletion(void); +void TriggerEventCompletion() {} +int AnonInfoAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q); +int AnonInfoAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q) { ( void ) rr; ( void ) q; return 1;} +mDNS mDNSStorage; + + +// For convenience when using the "strings" command, this is the last thing in the file +// The "@(#) " pattern is a special prefix the "what" command looks for +const char mDNSResponderVersionString_SCCS[] = "@(#) dnsextd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")"; + +#if _BUILDING_XCODE_PROJECT_ +// If the process crashes, then this string will be magically included in the automatically-generated crash log +const char *__crashreporter_info__ = mDNSResponderVersionString_SCCS + 5; +asm (".desc ___crashreporter_info__, 0x10"); +#endif |