path: root/mDNSResponder/mDNSShared/dnsextd.h

/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2006 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.
 */


#ifndef _dnsextd_h
#define _dnsextd_h


#include <mDNSEmbeddedAPI.h>
#include <DNSCommon.h>
#include <GenLinkedList.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>


#define LLQ_TABLESIZE   1024    // !!!KRS make this dynamically growable


typedef enum DNSZoneSpecType
{
    kDNSZonePublic,
    kDNSZonePrivate
} DNSZoneSpecType;


typedef struct DNSZone
{
    domainname name;
    DNSZoneSpecType type;
    DomainAuthInfo      *   updateKeys; // linked list of keys for signing deletion updates
    DomainAuthInfo      *   queryKeys;  // linked list of keys for queries
    struct DNSZone      *   next;
} DNSZone;


typedef struct
{
    struct sockaddr_in src;
    size_t len;
    DNSZone * zone;
    mDNSBool isZonePublic;
    DNSMessage msg;
    // Note: extra storage for oversized (TCP) messages goes here
} PktMsg;

// lease table entry
typedef struct RRTableElem
{
    struct RRTableElem *next;
    struct sockaddr_in cli;   // client's source address
    long expire;              // expiration time, in seconds since epoch
    domainname zone;          // from zone field of update message
    domainname name;          // name of the record
    CacheRecord rr;           // last field in struct allows for allocation of oversized RRs
} RRTableElem;

typedef enum
{
    RequestReceived = 0,
    ChallengeSent   = 1,
    Established     = 2
} LLQState;

typedef struct AnswerListElem
{
    struct AnswerListElem *next;
    domainname name;
    mDNSu16 type;
    CacheRecord *KnownAnswers;  // All valid answers delivered to client
    CacheRecord *EventList;     // New answers (adds/removes) to be sent to client
    int refcount;
    mDNSBool UseTCP;            // Use TCP if UDP would cause truncation
    pthread_t tid;              // Allow parallel list updates
} AnswerListElem;

// llq table entry
typedef struct LLQEntry
{
    struct LLQEntry *next;
    struct sockaddr_in cli;   // clien'ts source address
    domainname qname;
    mDNSu16 qtype;
    mDNSOpaque64 id;
    LLQState state;
    mDNSu32 lease;            // original lease, in seconds
    mDNSs32 expire;           // expiration, absolute, in seconds since epoch
    AnswerListElem *AnswerList;
} LLQEntry;


typedef void (*EventCallback)( void * context );

typedef struct EventSource
{
    EventCallback callback;
    void                *   context;
    TCPSocket *         sock;
    int fd;
    mDNSBool markedForDeletion;
    struct  EventSource *   next;
} EventSource;


// daemon-wide information
typedef struct
{
    // server variables - read only after initialization (no locking)
    struct sockaddr_in addr;            // the address we will bind to
    struct sockaddr_in llq_addr;        // the address we will receive llq requests on.
    struct sockaddr_in ns_addr;         // the real ns server address
    int tcpsd;                          // listening TCP socket for dns requests
    int udpsd;                          // listening UDP socket for dns requests
    int tlssd;                          // listening TCP socket for private browsing
    int llq_tcpsd;                      // listening TCP socket for llq service
    int llq_udpsd;                      // listening UDP socket for llq service
    DNameListElem   *   public_names;   // list of public SRV names
    DNSZone         *   zones;

    // daemon variables - read only after initialization (no locking)
    mDNSIPPort private_port;           // listening port for private messages
    mDNSIPPort llq_port;           // listening port for llq

    // lease table variables (locked via mutex after initialization)
    RRTableElem **table;       // hashtable for records with leases
    pthread_mutex_t tablelock; // mutex for lease table
    mDNSs32 nbuckets;          // buckets allocated
    mDNSs32 nelems;            // elements in table

    // LLQ table variables
    LLQEntry *LLQTable[LLQ_TABLESIZE];  // !!!KRS change this and RRTable to use a common data structure
    AnswerListElem *AnswerTable[LLQ_TABLESIZE];
    int AnswerTableCount;
    int LLQEventNotifySock;          // Unix domain socket pair - update handling thread writes to EventNotifySock, which wakes
    int LLQEventListenSock;          // the main thread listening on EventListenSock, indicating that the zone has changed

    GenLinkedList eventSources;     // linked list of EventSource's
} DaemonInfo;


int
ParseConfig
(
    DaemonInfo  *   d,
    const char  *   file
);


#endif