Sat Nov 1 06:28:35 2008

Asterisk developer's documentation

---

pbx_dundi.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief Distributed Universal Number Discovery (DUNDi)
 */

/*** MODULEINFO
   <depend>zlib</depend>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 134595 $")

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(SOLARIS) || defined(__Darwin__)
#include <sys/types.h>
#include <netinet/in_systm.h>
#endif
#include <netinet/ip.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <net/if.h>
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__Darwin__)
#include <net/if_dl.h>
#include <ifaddrs.h>
#endif
#include <zlib.h>
#include <sys/signal.h>
#include <pthread.h>

#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/options.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/frame.h"
#include "asterisk/file.h"
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#include "asterisk/md5.h"
#include "asterisk/dundi.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/utils.h"
#include "asterisk/crypto.h"
#include "asterisk/astdb.h"
#include "asterisk/acl.h"
#include "asterisk/aes.h"

#include "dundi-parser.h"

#define MAX_RESULTS  64

#define MAX_PACKET_SIZE 8192

#define DUNDI_MODEL_INBOUND      (1 << 0)
#define DUNDI_MODEL_OUTBOUND  (1 << 1)
#define DUNDI_MODEL_SYMMETRIC (DUNDI_MODEL_INBOUND | DUNDI_MODEL_OUTBOUND)

/*! Keep times of last 10 lookups */
#define DUNDI_TIMING_HISTORY  10

#define FLAG_ISREG       (1 << 0)   /*!< Transaction is register request */
#define FLAG_DEAD        (1 << 1)   /*!< Transaction is dead */
#define FLAG_FINAL       (1 << 2)   /*!< Transaction has final message sent */
#define FLAG_ISQUAL      (1 << 3)   /*!< Transaction is a qualification */
#define FLAG_ENCRYPT     (1 << 4)   /*!< Transaction is encrypted wiht ECX/DCX */
#define FLAG_SENDFULLKEY (1 << 5)   /*!< Send full key on transaction */
#define FLAG_STOREHIST   (1 << 6)   /*!< Record historic performance */

#define DUNDI_FLAG_INTERNAL_NOPARTIAL (1 << 17)

#if 0
#define DUNDI_SECRET_TIME 15  /* Testing only */
#else
#define DUNDI_SECRET_TIME DUNDI_DEFAULT_CACHE_TIME
#endif

#define KEY_OUT         0
#define KEY_IN       1

static struct io_context *io;
static struct sched_context *sched;
static int netsocket = -1;
static pthread_t netthreadid = AST_PTHREADT_NULL;
static pthread_t precachethreadid = AST_PTHREADT_NULL;
static int tos = 0;
static int dundidebug = 0;
static int authdebug = 0;
static int dundi_ttl = DUNDI_DEFAULT_TTL;
static int dundi_key_ttl = DUNDI_DEFAULT_KEY_EXPIRE;
static int dundi_cache_time = DUNDI_DEFAULT_CACHE_TIME;
static int global_autokilltimeout = 0;
static dundi_eid global_eid;
static int default_expiration = 60;
static int global_storehistory = 0;
static char dept[80];
static char org[80];
static char locality[80];
static char stateprov[80];
static char country[80];
static char email[80];
static char phone[80];
static char secretpath[80];
static char cursecret[80];
static char ipaddr[80];
static time_t rotatetime;
static dundi_eid empty_eid = { { 0, 0, 0, 0, 0, 0 } };
static int dundi_shutdown = 0;

struct permission {
   AST_LIST_ENTRY(permission) list;
   int allow;
   char name[0];
};

struct dundi_packet {
   AST_LIST_ENTRY(dundi_packet) list;
   struct dundi_hdr *h;
   int datalen;
   struct dundi_transaction *parent;
   int retransid;
   int retrans;
   unsigned char data[0];
};

struct dundi_hint_metadata {
   unsigned short flags;
   char exten[AST_MAX_EXTENSION];
};

struct dundi_precache_queue {
   AST_LIST_ENTRY(dundi_precache_queue) list;
   char *context;
   time_t expiration;
   char number[0];
};

struct dundi_request;

struct dundi_transaction {
   struct sockaddr_in addr;                       /*!< Other end of transaction */
   struct timeval start;                          /*!< When this transaction was created */
   dundi_eid eids[DUNDI_MAX_STACK + 1];
   int eidcount;                                  /*!< Number of eids in eids */
   dundi_eid us_eid;                              /*!< Our EID, to them */
   dundi_eid them_eid;                            /*!< Their EID, to us */
   aes_encrypt_ctx   ecx;                           /*!< AES 128 Encryption context */
   aes_decrypt_ctx   dcx;                           /*!< AES 128 Decryption context */
   unsigned int flags;                            /*!< Has final packet been sent */
   int ttl;                                       /*!< Remaining TTL for queries on this one */
   int thread;                                    /*!< We have a calling thread */
   int retranstimer;                              /*!< How long to wait before retransmissions */
   int autokillid;                                /*!< ID to kill connection if answer doesn't come back fast enough */
   int autokilltimeout;                           /*!< Recommended timeout for autokill */
   unsigned short strans;                         /*!< Our transaction identifier */
   unsigned short dtrans;                         /*!< Their transaction identifer */
   unsigned char iseqno;                          /*!< Next expected received seqno */
   unsigned char oiseqno;                         /*!< Last received incoming seqno */
   unsigned char oseqno;                          /*!< Next transmitted seqno */
   unsigned char aseqno;                          /*!< Last acknowledge seqno */
   AST_LIST_HEAD_NOLOCK(packetlist, dundi_packet) packets;  /*!< Packets to be retransmitted */
   struct packetlist lasttrans;                   /*!< Last transmitted / ACK'd packet */
   struct dundi_request *parent;                  /*!< Parent request (if there is one) */
   AST_LIST_ENTRY(dundi_transaction) parentlist;  /*!< Next with respect to the parent */
   AST_LIST_ENTRY(dundi_transaction) all;         /*!< Next with respect to all DUNDi transactions */
};

struct dundi_request {
   char dcontext[AST_MAX_EXTENSION];
   char number[AST_MAX_EXTENSION];
   dundi_eid query_eid;
   dundi_eid root_eid;
   struct dundi_result *dr;
   struct dundi_entity_info *dei;
   struct dundi_hint_metadata *hmd;
   int maxcount;
   int respcount;
   int expiration;
   int cbypass;
   int pfds[2];
   unsigned long crc32;                              /*!< CRC-32 of all but root EID's in avoid list */
   AST_LIST_HEAD_NOLOCK(, dundi_transaction) trans;  /*!< Transactions */
   AST_LIST_ENTRY(dundi_request) list;
};

struct dundi_mapping {
   char dcontext[AST_MAX_EXTENSION];
   char lcontext[AST_MAX_EXTENSION];
   int weight;
   int options;
   int tech;
   int dead;
   char dest[AST_MAX_EXTENSION];
   AST_LIST_ENTRY(dundi_mapping) list;
};

struct dundi_peer {
   dundi_eid eid;
   struct sockaddr_in addr;               /*!< Address of DUNDi peer */
   AST_LIST_HEAD_NOLOCK(permissionlist, permission) permit;
   struct permissionlist include;
   dundi_eid us_eid;
   char inkey[80];
   char outkey[80];
   int dead;
   int registerid;
   int qualifyid;
   int sentfullkey;
   int order;
   unsigned char txenckey[256];           /*!< Transmitted encrypted key + sig */
   unsigned char rxenckey[256];           /*!< Cache received encrypted key + sig */
   unsigned long us_keycrc32;             /*!< CRC-32 of our key */
   aes_encrypt_ctx   us_ecx;                /*!< Cached AES 128 Encryption context */
   aes_decrypt_ctx   us_dcx;                 /*!< Cached AES 128 Decryption context */
   unsigned long them_keycrc32;           /*!< CRC-32 of our key */
   aes_encrypt_ctx   them_ecx;              /*!< Cached AES 128 Encryption context */
   aes_decrypt_ctx   them_dcx;              /*!< Cached AES 128 Decryption context */
   time_t keyexpire;                      /*!< When to expire/recreate key */
   int registerexpire;
   int lookuptimes[DUNDI_TIMING_HISTORY];
   char *lookups[DUNDI_TIMING_HISTORY];
   int avgms;
   struct dundi_transaction *regtrans;    /*!< Registration transaction */
   struct dundi_transaction *qualtrans;   /*!< Qualify transaction */
   int model;                             /*!< Pull model */
   int pcmodel;                           /*!< Push/precache model */
   /*! Dynamic peers register with us */
   unsigned int dynamic:1;
   int lastms;                            /*!< Last measured latency */
   int maxms;                             /*!< Max permissible latency */
   struct timeval qualtx;                 /*!< Time of transmit */
   AST_LIST_ENTRY(dundi_peer) list;
};

static AST_LIST_HEAD_STATIC(peers, dundi_peer);
static AST_LIST_HEAD_STATIC(pcq, dundi_precache_queue);
static AST_LIST_HEAD_NOLOCK_STATIC(mappings, dundi_mapping);
static AST_LIST_HEAD_NOLOCK_STATIC(requests, dundi_request);
static AST_LIST_HEAD_NOLOCK_STATIC(alltrans, dundi_transaction);

/*!
 * \brief Wildcard peer
 *
 * This peer is created if the [*] entry is specified in dundi.conf
 */
static struct dundi_peer *any_peer;

static int dundi_xmit(struct dundi_packet *pack);

static void dundi_debug_output(const char *data)
{
   if (dundidebug)
      ast_verbose("%s", data);
}

static void dundi_error_output(const char *data)
{
   ast_log(LOG_WARNING, "%s", data);
}

static int has_permission(struct permissionlist *permlist, char *cont)
{
   struct permission *perm;
   int res = 0;

   AST_LIST_TRAVERSE(permlist, perm, list) {
      if (!strcasecmp(perm->name, "all") || !strcasecmp(perm->name, cont))
         res = perm->allow;
   }

   return res;
}

static char *tech2str(int tech)
{
   switch(tech) {
   case DUNDI_PROTO_NONE:
      return "None";
   case DUNDI_PROTO_IAX:
      return "IAX2";
   case DUNDI_PROTO_SIP:
      return "SIP";
   case DUNDI_PROTO_H323:
      return "H323";
   default:
      return "Unknown";
   }
}

static int str2tech(char *str)
{
   if (!strcasecmp(str, "IAX") || !strcasecmp(str, "IAX2")) 
      return DUNDI_PROTO_IAX;
   else if (!strcasecmp(str, "SIP"))
      return DUNDI_PROTO_SIP;
   else if (!strcasecmp(str, "H323"))
      return DUNDI_PROTO_H323;
   else
      return -1;
}

static int dundi_lookup_internal(struct dundi_result *result, int maxret, struct ast_channel *chan, const char *dcontext, const char *number, int ttl, int blockempty, struct dundi_hint_metadata *md, int *expiration, int cybpass, int modeselect, dundi_eid *skip, dundi_eid *avoid[], int direct[]);
static int dundi_precache_internal(const char *context, const char *number, int ttl, dundi_eid *avoids[]);
static struct dundi_transaction *create_transaction(struct dundi_peer *p);
static struct dundi_transaction *find_transaction(struct dundi_hdr *hdr, struct sockaddr_in *sin)
{
   struct dundi_transaction *trans;

   /* Look for an exact match first */
   AST_LIST_TRAVERSE(&alltrans, trans, all) {
      if (!inaddrcmp(&trans->addr, sin) && 
           ((trans->strans == (ntohs(hdr->dtrans) & 32767)) /* Matches our destination */ ||
           ((trans->dtrans == (ntohs(hdr->strans) & 32767)) && (!hdr->dtrans))) /* We match their destination */) {
           if (hdr->strans)
              trans->dtrans = ntohs(hdr->strans) & 32767;
           break;
      }
   }
   if (!trans) {
      switch(hdr->cmdresp & 0x7f) {
      case DUNDI_COMMAND_DPDISCOVER:
      case DUNDI_COMMAND_EIDQUERY:
      case DUNDI_COMMAND_PRECACHERQ:
      case DUNDI_COMMAND_REGREQ:
      case DUNDI_COMMAND_NULL:
      case DUNDI_COMMAND_ENCRYPT:
         if (hdr->strans) {   
            /* Create new transaction */
            trans = create_transaction(NULL);
            if (trans) {
               memcpy(&trans->addr, sin, sizeof(trans->addr));
               trans->dtrans = ntohs(hdr->strans) & 32767;
            } else
               ast_log(LOG_WARNING, "Out of memory!\n");
         }
         break;
      default:
         break;
      }
   }
   return trans;
}

static int dundi_send(struct dundi_transaction *trans, int cmdresp, int flags, int final, struct dundi_ie_data *ied);

static int dundi_ack(struct dundi_transaction *trans, int final)
{
   return dundi_send(trans, DUNDI_COMMAND_ACK, 0, final, NULL);
}
static void dundi_reject(struct dundi_hdr *h, struct sockaddr_in *sin)
{
   struct {
      struct dundi_packet pack;
      struct dundi_hdr hdr;
   } tmp;
   struct dundi_transaction trans;
   /* Never respond to an INVALID with another INVALID */
   if (h->cmdresp == DUNDI_COMMAND_INVALID)
      return;
   memset(&tmp, 0, sizeof(tmp));
   memset(&trans, 0, sizeof(trans));
   memcpy(&trans.addr, sin, sizeof(trans.addr));
   tmp.hdr.strans = h->dtrans;
   tmp.hdr.dtrans = h->strans;
   tmp.hdr.iseqno = h->oseqno;
   tmp.hdr.oseqno = h->iseqno;
   tmp.hdr.cmdresp = DUNDI_COMMAND_INVALID;
   tmp.hdr.cmdflags = 0;
   tmp.pack.h = (struct dundi_hdr *)tmp.pack.data;
   tmp.pack.datalen = sizeof(struct dundi_hdr);
   tmp.pack.parent = &trans;
   dundi_xmit(&tmp.pack);
}

static void reset_global_eid(void)
{
#if defined(SIOCGIFHWADDR)
   int x,s;
   char eid_str[20];
   struct ifreq ifr;

   s = socket(AF_INET, SOCK_STREAM, 0);
   if (s > 0) {
      x = 0;
      for(x=0;x<10;x++) {
         memset(&ifr, 0, sizeof(ifr));
         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "eth%d", x);
         if (!ioctl(s, SIOCGIFHWADDR, &ifr)) {
            memcpy(&global_eid, ((unsigned char *)&ifr.ifr_hwaddr) + 2, sizeof(global_eid));
            ast_log(LOG_DEBUG, "Seeding global EID '%s' from '%s' using 'siocgifhwaddr'\n", dundi_eid_to_str(eid_str, sizeof(eid_str), &global_eid), ifr.ifr_name);
            close(s);
            return;
         }
        }
      close(s);
   }
#else
#if defined(ifa_broadaddr) && !defined(SOLARIS)
   char eid_str[20];
   struct ifaddrs *ifap;
   
   if (getifaddrs(&ifap) == 0) {
      struct ifaddrs *p;
      for (p = ifap; p; p = p->ifa_next) {
         if ((p->ifa_addr->sa_family == AF_LINK) && !(p->ifa_flags & IFF_LOOPBACK) && (p->ifa_flags & IFF_RUNNING)) {
            struct sockaddr_dl* sdp = (struct sockaddr_dl*) p->ifa_addr;
            memcpy(&(global_eid.eid), sdp->sdl_data + sdp->sdl_nlen, 6);
            ast_log(LOG_DEBUG, "Seeding global EID '%s' from '%s' using 'getifaddrs'\n", dundi_eid_to_str(eid_str, sizeof(eid_str), &global_eid), p->ifa_name);
            freeifaddrs(ifap);
            return;
         }
      }
      freeifaddrs(ifap);
   }
#endif
#endif
   ast_log(LOG_NOTICE, "No ethernet interface found for seeding global EID. You will have to set it manually.\n");
}

static int get_trans_id(void)
{
   struct dundi_transaction *t;
   int stid = (ast_random() % 32766) + 1;
   int tid = stid;

   do {
      AST_LIST_TRAVERSE(&alltrans, t, all) {
         if (t->strans == tid) 
            break;
      }
      if (!t)
         return tid;
      tid = (tid % 32766) + 1;
   } while (tid != stid);

   return 0;
}

static int reset_transaction(struct dundi_transaction *trans)
{
   int tid;
   tid = get_trans_id();
   if (tid < 1)
      return -1;
   trans->strans = tid;
   trans->dtrans = 0;
   trans->iseqno = 0;
   trans->oiseqno = 0;
   trans->oseqno = 0;
   trans->aseqno = 0;
   ast_clear_flag(trans, FLAG_FINAL);  
   return 0;
}

static struct dundi_peer *find_peer(dundi_eid *eid)
{
   struct dundi_peer *cur = NULL;

   if (!eid)
      eid = &empty_eid;
   
   AST_LIST_TRAVERSE(&peers, cur, list) {
      if (!dundi_eid_cmp(&cur->eid,eid))
         break;
   }

   if (!cur && any_peer)
      cur = any_peer;

   return cur;
}

static void build_iv(unsigned char *iv)
{
   /* XXX Would be nice to be more random XXX */
   unsigned int *fluffy;
   int x;
   fluffy = (unsigned int *)(iv);
   for (x=0;x<4;x++)
      fluffy[x] = ast_random();
}

struct dundi_query_state {
   dundi_eid *eids[DUNDI_MAX_STACK + 1]; 
   int directs[DUNDI_MAX_STACK + 1]; 
   dundi_eid reqeid;
   char called_context[AST_MAX_EXTENSION];
   char called_number[AST_MAX_EXTENSION];
   struct dundi_mapping *maps;
   int nummaps;
   int nocache;
   struct dundi_transaction *trans;
   void *chal;
   int challen;
   int ttl;
   char fluffy[0];
};

static int dundi_lookup_local(struct dundi_result *dr, struct dundi_mapping *map, char *called_number, dundi_eid *us_eid, int anscnt, struct dundi_hint_metadata *hmd)
{
   struct ast_flags flags = {0};
   int x;
   if (!ast_strlen_zero(map->lcontext)) {
      if (ast_exists_extension(NULL, map->lcontext, called_number, 1, NULL))
         ast_set_flag(&flags, DUNDI_FLAG_EXISTS);
      if (ast_canmatch_extension(NULL, map->lcontext, called_number, 1, NULL))
         ast_set_flag(&flags, DUNDI_FLAG_CANMATCH);
      if (ast_matchmore_extension(NULL, map->lcontext, called_number, 1, NULL))
         ast_set_flag(&flags, DUNDI_FLAG_MATCHMORE);
      if (ast_ignore_pattern(map->lcontext, called_number))
         ast_set_flag(&flags, DUNDI_FLAG_IGNOREPAT);

      /* Clearly we can't say 'don't ask' anymore if we found anything... */
      if (ast_test_flag(&flags, AST_FLAGS_ALL)) 
         ast_clear_flag_nonstd(hmd, DUNDI_HINT_DONT_ASK);

      if (map->options & DUNDI_FLAG_INTERNAL_NOPARTIAL) {
         /* Skip partial answers */
         ast_clear_flag(&flags, DUNDI_FLAG_MATCHMORE|DUNDI_FLAG_CANMATCH);
      }
      if (ast_test_flag(&flags, AST_FLAGS_ALL)) {
         struct varshead headp;
         struct ast_var_t *newvariable;
         ast_set_flag(&flags, map->options & 0xffff);
         ast_copy_flags(dr + anscnt, &flags, AST_FLAGS_ALL);
         dr[anscnt].techint = map->tech;
         dr[anscnt].weight = map->weight;
         dr[anscnt].expiration = dundi_cache_time;
         ast_copy_string(dr[anscnt].tech, tech2str(map->tech), sizeof(dr[anscnt].tech));
         dr[anscnt].eid = *us_eid;
         dundi_eid_to_str(dr[anscnt].eid_str, sizeof(dr[anscnt].eid_str), &dr[anscnt].eid);
         if (ast_test_flag(&flags, DUNDI_FLAG_EXISTS)) {
            AST_LIST_HEAD_INIT_NOLOCK(&headp);
            newvariable = ast_var_assign("NUMBER", called_number);
            AST_LIST_INSERT_HEAD(&headp, newvariable, entries);
            newvariable = ast_var_assign("EID", dr[anscnt].eid_str);
            AST_LIST_INSERT_HEAD(&headp, newvariable, entries);
            newvariable = ast_var_assign("SECRET", cursecret);
            AST_LIST_INSERT_HEAD(&headp, newvariable, entries);
            newvariable = ast_var_assign("IPADDR", ipaddr);
            AST_LIST_INSERT_HEAD(&headp, newvariable, entries);
            pbx_substitute_variables_varshead(&headp, map->dest, dr[anscnt].dest, sizeof(dr[anscnt].dest));
            while ((newvariable = AST_LIST_REMOVE_HEAD(&headp, entries)))
               ast_var_delete(newvariable);
         } else
            dr[anscnt].dest[0] = '\0';
         anscnt++;
      } else {
         /* No answers...  Find the fewest number of digits from the
            number for which we have no answer. */
         char tmp[AST_MAX_EXTENSION + 1] = "";
         for (x = 0; x < (sizeof(tmp) - 1); x++) {
            tmp[x] = called_number[x];
            if (!tmp[x])
               break;
            if (!ast_canmatch_extension(NULL, map->lcontext, tmp, 1, NULL)) {
               /* Oops found something we can't match.  If this is longer
                  than the running hint, we have to consider it */
               if (strlen(tmp) > strlen(hmd->exten)) {
                  ast_copy_string(hmd->exten, tmp, sizeof(hmd->exten));
               }
               break;
            }
         }
      }
   }
   return anscnt;
}

static void destroy_trans(struct dundi_transaction *trans, int fromtimeout);

static void *dundi_lookup_thread(void *data)
{
   struct dundi_query_state *st = data;
   struct dundi_result dr[MAX_RESULTS];
   struct dundi_ie_data ied;
   struct dundi_hint_metadata hmd;
   char eid_str[20];
   int res, x;
   int ouranswers=0;
   int max = 999999;
   int expiration = dundi_cache_time;

   ast_log(LOG_DEBUG, "Whee, looking up '%s@%s' for '%s'\n", st->called_number, st->called_context, 
      st->eids[0] ? dundi_eid_to_str(eid_str, sizeof(eid_str), st->eids[0]) :  "ourselves");
   memset(&ied, 0, sizeof(ied));
   memset(&dr, 0, sizeof(dr));
   memset(&hmd, 0, sizeof(hmd));
   /* Assume 'don't ask for anything' and 'unaffected', no TTL expired */
   hmd.flags = DUNDI_HINT_DONT_ASK | DUNDI_HINT_UNAFFECTED;
   for (x=0;x<st->nummaps;x++)
      ouranswers = dundi_lookup_local(dr, st->maps + x, st->called_number, &st->trans->us_eid, ouranswers, &hmd);
   if (ouranswers < 0)
      ouranswers = 0;
   for (x=0;x<ouranswers;x++) {
      if (dr[x].weight < max)
         max = dr[x].weight;
   }
      
   if (max) {
      /* If we do not have a canonical result, keep looking */
      res = dundi_lookup_internal(dr + ouranswers, MAX_RESULTS - ouranswers, NULL, st->called_context, st->called_number, st->ttl, 1, &hmd, &expiration, st->nocache, 0, NULL, st->eids, st->directs);
      if (res > 0) {
         /* Append answer in result */
         ouranswers += res;
      } else {
         if ((res < -1) && (!ouranswers))
            dundi_ie_append_cause(&ied, DUNDI_IE_CAUSE, DUNDI_CAUSE_DUPLICATE, "Duplicate Request Pending");
      }
   }
   AST_LIST_LOCK(&peers);
   /* Truncate if "don't ask" isn't present */
   if (!ast_test_flag_nonstd(&hmd, DUNDI_HINT_DONT_ASK))
      hmd.exten[0] = '\0';
   if (ast_test_flag(st->trans, FLAG_DEAD)) {
      ast_log(LOG_DEBUG, "Our transaction went away!\n");
      st->trans->thread = 0;
      destroy_trans(st->trans, 0);
   } else {
      for (x=0;x<ouranswers;x++) {
         /* Add answers */
         if (dr[x].expiration && (expiration > dr[x].expiration))
            expiration = dr[x].expiration;
         dundi_ie_append_answer(&ied, DUNDI_IE_ANSWER, &dr[x].eid, dr[x].techint, dr[x].flags, dr[x].weight, dr[x].dest);
      }
      dundi_ie_append_hint(&ied, DUNDI_IE_HINT, hmd.flags, hmd.exten);
      dundi_ie_append_short(&ied, DUNDI_IE_EXPIRATION, expiration);
      dundi_send(st->trans, DUNDI_COMMAND_DPRESPONSE, 0, 1, &ied);
      st->trans->thread = 0;
   }
   AST_LIST_UNLOCK(&peers);
   free(st);
   return NULL;   
}

static void *dundi_precache_thread(void *data)
{
   struct dundi_query_state *st = data;
   struct dundi_ie_data ied;
   struct dundi_hint_metadata hmd;
   char eid_str[20];

   ast_log(LOG_DEBUG, "Whee, precaching '%s@%s' for '%s'\n", st->called_number, st->called_context, 
      st->eids[0] ? dundi_eid_to_str(eid_str, sizeof(eid_str), st->eids[0]) :  "ourselves");
   memset(&ied, 0, sizeof(ied));

   /* Now produce precache */
   dundi_precache_internal(st->called_context, st->called_number, st->ttl, st->eids);

   AST_LIST_LOCK(&peers);
   /* Truncate if "don't ask" isn't present */
   if (!ast_test_flag_nonstd(&hmd, DUNDI_HINT_DONT_ASK))
      hmd.exten[0] = '\0';
   if (ast_test_flag(st->trans, FLAG_DEAD)) {
      ast_log(LOG_DEBUG, "Our transaction went away!\n");
      st->trans->thread = 0;
      destroy_trans(st->trans, 0);
   } else {
      dundi_send(st->trans, DUNDI_COMMAND_PRECACHERP, 0, 1, &ied);
      st->trans->thread = 0;
   }
   AST_LIST_UNLOCK(&peers);
   free(st);
   return NULL;   
}

static int dundi_query_eid_internal(struct dundi_entity_info *dei, const char *dcontext, dundi_eid *eid, struct dundi_hint_metadata *hmd, int ttl, int blockempty, dundi_eid *avoid[]);

static void *dundi_query_thread(void *data)
{
   struct dundi_query_state *st = data;
   struct dundi_entity_info dei;
   struct dundi_ie_data ied;
   struct dundi_hint_metadata hmd;
   char eid_str[20];
   int res;
   ast_log(LOG_DEBUG, "Whee, looking up '%s@%s' for '%s'\n", st->called_number, st->called_context, 
      st->eids[0] ? dundi_eid_to_str(eid_str, sizeof(eid_str), st->eids[0]) :  "ourselves");
   memset(&ied, 0, sizeof(ied));
   memset(&dei, 0, sizeof(dei));
   memset(&hmd, 0, sizeof(hmd));
   if (!dundi_eid_cmp(&st->trans->us_eid, &st->reqeid)) {
      /* Ooh, it's us! */
      ast_log(LOG_DEBUG, "Neat, someone look for us!\n");
      ast_copy_string(dei.orgunit, dept, sizeof(dei.orgunit));
      ast_copy_string(dei.org, org, sizeof(dei.org));
      ast_copy_string(dei.locality, locality, sizeof(dei.locality));
      ast_copy_string(dei.stateprov, stateprov, sizeof(dei.stateprov));
      ast_copy_string(dei.country, country, sizeof(dei.country));
      ast_copy_string(dei.email, email, sizeof(dei.email));
      ast_copy_string(dei.phone, phone, sizeof(dei.phone));
      res = 1;
   } else {
      /* If we do not have a canonical result, keep looking */
      res = dundi_query_eid_internal(&dei, st->called_context, &st->reqeid, &hmd, st->ttl, 1, st->eids);
   }
   AST_LIST_LOCK(&peers);
   if (ast_test_flag(st->trans, FLAG_DEAD)) {
      ast_log(LOG_DEBUG, "Our transaction went away!\n");
      st->trans->thread = 0;
      destroy_trans(st->trans, 0);
   } else {
      if (res) {
         dundi_ie_append_str(&ied, DUNDI_IE_DEPARTMENT, dei.orgunit);
         dundi_ie_append_str(&ied, DUNDI_IE_ORGANIZATION, dei.org);
         dundi_ie_append_str(&ied, DUNDI_IE_LOCALITY, dei.locality);
         dundi_ie_append_str(&ied, DUNDI_IE_STATE_PROV, dei.stateprov);
         dundi_ie_append_str(&ied, DUNDI_IE_COUNTRY, dei.country);
         dundi_ie_append_str(&ied, DUNDI_IE_EMAIL, dei.email);
         dundi_ie_append_str(&ied, DUNDI_IE_PHONE, dei.phone);
         if (!ast_strlen_zero(dei.ipaddr))
            dundi_ie_append_str(&ied, DUNDI_IE_IPADDR, dei.ipaddr);
      }
      dundi_ie_append_hint(&ied, DUNDI_IE_HINT, hmd.flags, hmd.exten);
      dundi_send(st->trans, DUNDI_COMMAND_EIDRESPONSE, 0, 1, &ied);
      st->trans->thread = 0;
   }
   AST_LIST_UNLOCK(&peers);
   free(st);
   return NULL;   
}

static int dundi_answer_entity(struct dundi_transaction *trans, struct dundi_ies *ies, char *ccontext)
{
   struct dundi_query_state *st;
   int totallen;
   int x;
   int skipfirst=0;
   struct dundi_ie_data ied;
   char eid_str[20];
   char *s;
   pthread_t lookupthread;
   pthread_attr_t attr;
   if (ies->eidcount > 1) {
      /* Since it is a requirement that the first EID is the authenticating host
         and the last EID is the root, it is permissible that the first and last EID
         could be the same.  In that case, we should go ahead copy only the "root" section
         since we will not need it for authentication. */
      if (!dundi_eid_cmp(ies->eids[0], ies->eids[ies->eidcount - 1]))
         skipfirst = 1;
   }
   totallen = sizeof(struct dundi_query_state);
   totallen += (ies->eidcount - skipfirst) * sizeof(dundi_eid);
   st = ast_calloc(1, totallen);
   if (st) {
      ast_copy_string(st->called_context, ies->called_context, sizeof(st->called_context));
      memcpy(&st->reqeid, ies->reqeid, sizeof(st->reqeid));
      st->trans = trans;
      st->ttl = ies->ttl - 1;
      if (st->ttl < 0)
         st->ttl = 0;
      s = st->fluffy;
      for (x=skipfirst;ies->eids[x];x++) {
         st->eids[x-skipfirst] = (dundi_eid *)s;
         *st->eids[x-skipfirst] = *ies->eids[x];
         s += sizeof(dundi_eid);
      }
      ast_log(LOG_DEBUG, "Answering EID query for '%s@%s'!\n", dundi_eid_to_str(eid_str, sizeof(eid_str), ies->reqeid), ies->called_context);
      pthread_attr_init(&attr);
      pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
      trans->thread = 1;
      if (ast_pthread_create(&lookupthread, &attr, dundi_query_thread, st)) {
         trans->thread = 0;
         ast_log(LOG_WARNING, "Unable to create thread!\n");
         free(st);
         memset(&ied, 0, sizeof(ied));
         dundi_ie_append_cause(&ied, DUNDI_IE_CAUSE, DUNDI_CAUSE_GENERAL, "Out of threads");
         dundi_send(trans, DUNDI_COMMAND_EIDRESPONSE, 0, 1, &ied);
         pthread_attr_destroy(&attr);