pbx_dundi.c File Reference

Distributed Universal Number Discovery (DUNDi) More...

#include "asterisk.h"
#include "asterisk/network.h"
#include <sys/ioctl.h>
#include <zlib.h>
#include <signal.h>
#include <pthread.h>
#include <net/if.h>
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/frame.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/netsock2.h"
#include "asterisk/crypto.h"
#include "asterisk/astdb.h"
#include "asterisk/acl.h"
#include "asterisk/app.h"
#include "dundi-parser.h"

Include dependency graph for pbx_dundi.c:

Go to the source code of this file.

Data Structures
struct	alltrans
struct	dundi_hint_metadata
struct	dundi_mapping
struct	dundi_packet
struct	dundi_peer
struct	dundi_precache_queue
struct	dundi_query_state
struct	dundi_request
struct	dundi_result_datastore
struct	dundi_transaction
struct	mappings
struct	dundi_transaction::packetlist
struct	pcq
struct	peers
struct	permission
struct	dundi_peer::permissionlist
struct	requests

Macros
#define	DUNDI_FLAG_INTERNAL_NOPARTIAL   (1 << 17)
#define	DUNDI_MODEL_INBOUND   (1 << 0)
#define	DUNDI_MODEL_OUTBOUND   (1 << 1)
#define	DUNDI_MODEL_SYMMETRIC   (DUNDI_MODEL_INBOUND | DUNDI_MODEL_OUTBOUND)
#define	DUNDI_SECRET_TIME   DUNDI_DEFAULT_CACHE_TIME
#define	DUNDI_TIMING_HISTORY   10
#define	FORMAT   "%-20.20s %-41s %s %-6d %-10.10s %-8.8s %-15.15s\n"
#define	FORMAT   "%-41s:%5d %-5.5d %-5.5d %-3.3d %-3.3d %-3.3d\n"
#define	FORMAT   "%-15s %-15s %-15s %-3.3d %-3.3d\n"
#define	FORMAT   "%-12.12s %-7s %-12.12s %-10.10s %-5.5s %-25.25s\n"
#define	FORMAT   "%-12.12s %-12.12s %02d:%02d:%02d\n"
#define	FORMAT   "%-12.12s %-16.16s %6d sec %-18s %-7d %s/%s (%s)\n"
#define	FORMAT   "%-12.12s %-16.16s %6d sec %-18s\n"
#define	FORMAT2   "%-20.20s %-41s %-6.6s %-10.10s %-8.8s %-15.15s\n"
#define	FORMAT2   "%-47s %-5.5s %-5.5s %-3.3s %-3.3s %-3.3s\n"
#define	FORMAT2   "%-15s %-15s %-15s %-3.3s %-3.3s\n"
#define	FORMAT2   "%-12.12s %-7.7s %-12.12s %-10.10s %-5.5s %-25.25s\n"
#define	FORMAT2   "%-12.12s %-12.12s %-10.10s\n"
#define	FORMAT2   "%-12.12s %-16.16s %-10.10s %-18s %-7s %s\n"
#define	FORMAT2   "%-12.12s %-16.16s %-10.10s %-18s\n"
#define	MAX_OPTS   128
#define	MAX_PACKET_SIZE   8192
#define	MAX_RESULTS   64
#define	MAX_WEIGHT   59999

Enumerations
enum	{   FLAG_ISREG = (1 << 0), FLAG_DEAD = (1 << 1), FLAG_FINAL = (1 << 2), FLAG_ISQUAL = (1 << 3),   FLAG_ENCRYPT = (1 << 4), FLAG_SENDFULLKEY = (1 << 5), FLAG_STOREHIST = (1 << 6) }
enum	{ OPT_BYPASS_CACHE = (1 << 0) }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static void	abort_request (struct dundi_request *dr)
static int	ack_trans (struct dundi_transaction *trans, int iseqno)
static void	append_permission (struct permissionlist *permlist, const char *s, int allow)
static int	append_transaction (struct dundi_request *dr, struct dundi_peer *p, int ttl, dundi_eid *avoid[])
static void	apply_peer (struct dundi_transaction *trans, struct dundi_peer *p)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static unsigned long	avoid_crc32 (dundi_eid *avoid[])
static void	build_iv (unsigned char *iv)
static void	build_mapping (const char *name, const char *value)
static void	build_peer (dundi_eid *eid, struct ast_variable *v, int *globalpcmode)
static void	build_secret (char *secret, int seclen)
static void	build_transactions (struct dundi_request *dr, int ttl, int order, int *foundcache, int *skipped, int blockempty, int nocache, int modeselect, dundi_eid *skip, dundi_eid *avoid[], int directs[])
static int	cache_lookup (struct dundi_request *req, dundi_eid *peer_eid, uint32_t crc, int *lowexpiration)
static int	cache_lookup_internal (time_t now, struct dundi_request *req, char *key, char *eid_str_full, int *lowexpiration)
static int	cache_save (dundi_eid *eidpeer, struct dundi_request *req, int start, int unaffected, int expiration, int push)
static int	cache_save_hint (dundi_eid *eidpeer, struct dundi_request *req, struct dundi_hint *hint, int expiration)
static void	cancel_request (struct dundi_request *dr)
static int	check_key (struct dundi_peer *peer, unsigned char *newkey, unsigned char *newsig, uint32_t keycrc32)
static void	check_password (void)
static int	check_request (struct dundi_request *dr)
static char *	complete_peer_helper (const char *line, const char *word, int pos, int state, int rpos)
static struct dundi_transaction *	create_transaction (struct dundi_peer *p)
static int	decrypt_memcpy (unsigned char *dst, unsigned char *src, int len, unsigned char *iv, ast_aes_decrypt_key *dcx)
static void	deep_copy_peer (struct dundi_peer *peer_dst, const struct dundi_peer *peer_src)
static void	destroy_map (struct dundi_mapping *map)
static void	destroy_packet (struct dundi_packet *pack, int needfree)
static void	destroy_packets (struct packetlist *p)
static void	destroy_peer (struct dundi_peer *peer)
static void	destroy_permissions (struct permissionlist *permlist)
static void	destroy_trans (struct dundi_transaction *trans, int fromtimeout)
static int	discover_transactions (struct dundi_request *dr)
static int	do_autokill (const void *data)
static int	do_qualify (const void *data)
static int	do_register (const void *data)
static int	do_register_expire (const void *data)
static void	drds_destroy (struct dundi_result_datastore *drds)
static void	drds_destroy_cb (void *data)
static int	dundi_ack (struct dundi_transaction *trans, int final)
static int	dundi_answer_entity (struct dundi_transaction *trans, struct dundi_ies *ies, char *ccontext)
static int	dundi_answer_query (struct dundi_transaction *trans, struct dundi_ies *ies, char *ccontext)
static int	dundi_canmatch (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
static void	dundi_debug_output (const char *data)
static struct dundi_hdr *	dundi_decrypt (struct dundi_transaction *trans, unsigned char *dst, int *dstlen, struct dundi_hdr *ohdr, struct dundi_encblock *src, int srclen)
static int	dundi_discover (struct dundi_transaction *trans)
static char *	dundi_do_lookup (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_do_precache (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_do_query (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	dundi_encrypt (struct dundi_transaction *trans, struct dundi_packet *pack)
static void	dundi_error_output (const char *data)
static int	dundi_exec (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
static int	dundi_exists (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
static char *	dundi_flush (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	dundi_helper (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *data, int flag)
static void	dundi_ie_append_eid_appropriately (struct dundi_ie_data *ied, char *context, dundi_eid *eid, dundi_eid *us)
int	dundi_lookup (struct dundi_result *result, int maxret, struct ast_channel *chan, const char *dcontext, const char *number, int cbypass)
	Lookup the given number in the given dundi context. Lookup number in a given dundi context (if unspecified use e164), the given callerid (if specified) and return up to maxret results in the array specified. More...
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_lookup_local (struct dundi_result *dr, struct dundi_mapping *map, char *called_number, dundi_eid *us_eid, int anscnt, struct dundi_hint_metadata *hmd)
static void *	dundi_lookup_thread (void *data)
static int	dundi_matchmore (struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
int	dundi_precache (const char *context, const char *number)
	Pre-cache to push upstream peers. More...
static void	dundi_precache_full (void)
static int	dundi_precache_internal (const char *context, const char *number, int ttl, dundi_eid *avoids[])
static void *	dundi_precache_thread (void *data)
static int	dundi_prop_precache (struct dundi_transaction *trans, struct dundi_ies *ies, char *ccontext)
static int	dundi_query (struct dundi_transaction *trans)
int	dundi_query_eid (struct dundi_entity_info *dei, const char *dcontext, dundi_eid eid)
	Retrieve information on a specific EID. More...
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 int	dundi_query_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static void *	dundi_query_thread (void *data)
static void	dundi_reject (struct dundi_hdr *h, struct ast_sockaddr *sin)
static int	dundi_result_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	dundi_rexmit (const void *data)
static int	dundi_send (struct dundi_transaction *trans, int cmdresp, int flags, int final, struct dundi_ie_data *ied)
static char *	dundi_set_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_cache (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_entityid (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_hints (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_mappings (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_peer (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_peers (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_precache (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_requests (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dundi_show_trans (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static uint16_t	dundi_sockaddr_port (const struct ast_sockaddr *addr)
static char *	dundi_sockaddr_stringify_host (const struct ast_sockaddr *addr)
static char *	dundi_store_history (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	dundi_xmit (struct dundi_packet *pack)
static int	dundifunc_read (struct ast_channel *chan, const char *cmd, char *num, char *buf, size_t len)
static int	encrypt_memcpy (unsigned char *dst, unsigned char *src, int len, unsigned char *iv, ast_aes_encrypt_key *ecx)
static struct dundi_peer *	find_peer (dundi_eid *eid)
static struct dundi_transaction *	find_transaction (struct dundi_hdr *hdr, struct ast_sockaddr *sin)
static int	get_ipaddress (char *ip, size_t size, const char *str, int family)
static int	get_mapping_weight (struct dundi_mapping *map, struct varshead *headp)
static int	get_trans_id (void)
static int	handle_command_response (struct dundi_transaction *trans, struct dundi_hdr *hdr, int datalen, int encrypted)
static int	handle_frame (struct dundi_hdr *h, struct ast_sockaddr *sin, int datalen)
static int	has_permission (struct permissionlist *permlist, char *cont)
static int	load_module (void)
static void	load_password (void)
static void	mark_mappings (void)
static void	mark_peers (void)
static char *	model2str (int model)
static void *	network_thread (void *ignore)
static int	optimize_transactions (struct dundi_request *dr, int order)
static void	populate_addr (struct dundi_peer *peer, dundi_eid *eid)
static int	precache_trans (struct dundi_transaction *trans, struct dundi_mapping *maps, int mapcount, int *minexp, int *foundanswers)
static int	precache_transactions (struct dundi_request *dr, struct dundi_mapping *maps, int mapcount, int *expiration, int *foundanswers)
static void *	process_clearcache (void *ignore)
static void *	process_precache (void *ign)
static void	prune_mappings (void)
static void	prune_peers (void)
static void	qualify_peer (struct dundi_peer *peer, int schedonly)
static int	query_transactions (struct dundi_request *dr)
static int	register_request (struct dundi_request *dr, struct dundi_request **pending)
static int	reload (void)
static void	reschedule_precache (const char *number, const char *context, int expiration)
static int	rescomp (const void *a, const void *b)
static int	reset_transaction (struct dundi_transaction *trans)
static void	save_secret (const char *newkey, const char *oldkey)
static int	set_config (char *config_file, struct ast_sockaddr *sin, int reload, struct ast_sockaddr *sin2)
static void	set_host_ipaddr (struct ast_sockaddr *sin)
static int	socket_read (int *id, int fd, short events, void *sock)
static void	sort_results (struct dundi_result *results, int count)
static int	start_network_thread (void)
static int	str2tech (char *str)
static char *	tech2str (int tech)
static int	unload_module (void)
static void	unregister_request (struct dundi_request *dr)
static int	update_key (struct dundi_peer *peer)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Distributed Universal Number Discovery (DUNDi)" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload, .optional_modules = "res_crypto", }
static struct alltrans	alltrans = { .first = NULL, .last = NULL, }
static struct dundi_peer *	any_peer
	Wildcard peer. More...
static const struct ast_module_info *	ast_module_info = &__mod_info
static int	authdebug = 0
static pthread_t	clearcachethreadid = AST_PTHREADT_NULL
static struct ast_cli_entry	cli_dundi []
static char	country [80]
static char	cursecret [80]
static int	default_expiration = 60
static char	dept [80]
static int	dundi_cache_time = DUNDI_DEFAULT_CACHE_TIME
static struct ast_custom_function	dundi_function
static int	dundi_key_ttl = DUNDI_DEFAULT_KEY_EXPIRE
static struct ast_custom_function	dundi_query_function
static const struct ast_app_option	dundi_query_opts [128] = { [ 'b' ] = { .flag = OPT_BYPASS_CACHE }, }
static const struct ast_datastore_info	dundi_result_datastore_info
static struct ast_custom_function	dundi_result_function
static unsigned int	dundi_result_id
static int	dundi_shutdown = 0
static struct ast_switch	dundi_switch
static int	dundi_ttl = DUNDI_DEFAULT_TTL
static int	dundidebug = 0
static char	email [80]
static dundi_eid	empty_eid = { { 0, 0, 0, 0, 0, 0 } }
static int	global_autokilltimeout = 0
static dundi_eid	global_eid
static int	global_storehistory = 0
static struct io_context *	io
static char	ipaddr [80]
static char	locality [80]
static struct mappings	mappings = { .first = NULL, .last = NULL, }
static int	netsocket = -1
static int	netsocket2 = -1
static pthread_t	netthreadid = AST_PTHREADT_NULL
static char	org [80]
static struct pcq	pcq = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static struct peers	peers = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static char	phone [80]
static pthread_t	precachethreadid = AST_PTHREADT_NULL
static struct requests	requests = { .first = NULL, .last = NULL, }
static time_t	rotatetime
static struct ast_sched_context *	sched
static char	secretpath [80]
static char	stateprov [80]
static unsigned int	tos = 0

Detailed Description

Distributed Universal Number Discovery (DUNDi)

Definition in file pbx_dundi.c.

Macro Definition Documentation

DUNDI_FLAG_INTERNAL_NOPARTIAL

#define DUNDI_FLAG_INTERNAL_NOPARTIAL   (1 << 17)

Definition at line 176 of file pbx_dundi.c.

Referenced by build_mapping(), and dundi_lookup_local().

DUNDI_MODEL_INBOUND

#define DUNDI_MODEL_INBOUND   (1 << 0)

Definition at line 159 of file pbx_dundi.c.

Referenced by build_peer(), dundi_show_peer(), handle_command_response(), and model2str().

DUNDI_MODEL_OUTBOUND

#define DUNDI_MODEL_OUTBOUND   (1 << 1)

Definition at line 160 of file pbx_dundi.c.

Referenced by build_peer(), build_transactions(), dundi_show_peer(), model2str(), and set_config().

DUNDI_MODEL_SYMMETRIC

#define DUNDI_MODEL_SYMMETRIC   (DUNDI_MODEL_INBOUND | DUNDI_MODEL_OUTBOUND)

Definition at line 161 of file pbx_dundi.c.

Referenced by build_peer(), and model2str().

DUNDI_SECRET_TIME

#define DUNDI_SECRET_TIME   DUNDI_DEFAULT_CACHE_TIME

Definition at line 181 of file pbx_dundi.c.

Referenced by load_password(), and save_secret().

DUNDI_TIMING_HISTORY

#define DUNDI_TIMING_HISTORY   10

Keep times of last 10 lookups

Definition at line 164 of file pbx_dundi.c.

Referenced by destroy_trans(), dundi_flush(), and dundi_show_peer().

FORMAT [1/7]

#define FORMAT   "%-20.20s %-41s %s %-6d %-10.10s %-8.8s %-15.15s\n"

Referenced by dundi_show_cache(), dundi_show_hints(), dundi_show_mappings(), dundi_show_peers(), dundi_show_precache(), dundi_show_requests(), and dundi_show_trans().

FORMAT [2/7]

#define FORMAT   "%-41s:%5d %-5.5d %-5.5d %-3.3d %-3.3d %-3.3d\n"

FORMAT [3/7]

#define FORMAT   "%-15s %-15s %-15s %-3.3d %-3.3d\n"

FORMAT [4/7]

#define FORMAT   "%-12.12s %-7s %-12.12s %-10.10s %-5.5s %-25.25s\n"

FORMAT [5/7]

#define FORMAT   "%-12.12s %-12.12s %02d:%02d:%02d\n"

FORMAT [6/7]

#define FORMAT   "%-12.12s %-16.16s %6d sec %-18s %-7d %s/%s (%s)\n"

FORMAT [7/7]

#define FORMAT   "%-12.12s %-16.16s %6d sec %-18s\n"

FORMAT2 [1/7]

#define FORMAT2   "%-20.20s %-41s %-6.6s %-10.10s %-8.8s %-15.15s\n"

Referenced by dundi_show_cache(), dundi_show_hints(), dundi_show_mappings(), dundi_show_peers(), dundi_show_precache(), dundi_show_requests(), and dundi_show_trans().

FORMAT2 [2/7]

#define FORMAT2   "%-47s %-5.5s %-5.5s %-3.3s %-3.3s %-3.3s\n"

FORMAT2 [3/7]

#define FORMAT2   "%-15s %-15s %-15s %-3.3s %-3.3s\n"

FORMAT2 [4/7]

#define FORMAT2   "%-12.12s %-7.7s %-12.12s %-10.10s %-5.5s %-25.25s\n"

FORMAT2 [5/7]

#define FORMAT2   "%-12.12s %-12.12s %-10.10s\n"

FORMAT2 [6/7]

#define FORMAT2   "%-12.12s %-16.16s %-10.10s %-18s %-7s %s\n"

FORMAT2 [7/7]

#define FORMAT2   "%-12.12s %-16.16s %-10.10s %-18s\n"

MAX_OPTS

#define MAX_OPTS   128

Definition at line 4455 of file pbx_dundi.c.

Referenced by build_mapping().

MAX_PACKET_SIZE

#define MAX_PACKET_SIZE   8192

Definition at line 155 of file pbx_dundi.c.

Referenced by handle_command_response(), and socket_read().

MAX_RESULTS

#define MAX_RESULTS   64

Definition at line 153 of file pbx_dundi.c.

Referenced by dundi_precache_internal(), and dundi_prop_precache().

MAX_WEIGHT

#define MAX_WEIGHT   59999

Definition at line 157 of file pbx_dundi.c.

Referenced by build_mapping(), and get_mapping_weight().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
FLAG_ISREG	Transaction is register request
FLAG_DEAD	Transaction is dead
FLAG_FINAL	Transaction has final message sent
FLAG_ISQUAL	Transaction is a qualification
FLAG_ENCRYPT	Transaction is encrypted wiht ECX/DCX
FLAG_SENDFULLKEY	Send full key on transaction
FLAG_STOREHIST	Record historic performance

Definition at line 166 of file pbx_dundi.c.

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

anonymous enum

anonymous enum

Enumerator
OPT_BYPASS_CACHE

Definition at line 4129 of file pbx_dundi.c.

 {
 OPT_BYPASS_CACHE = (1 << 0),
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 5278 of file pbx_dundi.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 5278 of file pbx_dundi.c.

abort_request()

static void abort_request ( struct dundi_request *  dr )

static

Definition at line 3688 of file pbx_dundi.c.

References AST_LIST_FIRST, AST_LIST_LOCK, AST_LIST_UNLOCK, destroy_trans(), and dundi_request::trans.

Referenced by dundi_lookup_internal().

{
 struct dundi_transaction *trans;

 AST_LIST_LOCK(&peers);
 while ((trans = AST_LIST_FIRST(&dr->trans))) {
 /* This will remove the transaction from the list */
 destroy_trans(trans, 0);
 }
 AST_LIST_UNLOCK(&peers);
}

ack_trans()

static int ack_trans ( struct dundi_transaction *  trans, int  iseqno  )

static

Definition at line 2021 of file pbx_dundi.c.

References AST_LIST_EMPTY, AST_LIST_INSERT_HEAD, AST_LIST_TRAVERSE, ast_log, AST_SCHED_DEL, dundi_transaction::autokillid, destroy_packet(), destroy_packets(), dundi_packet::h, dundi_transaction::lasttrans, permission::list, LOG_WARNING, dundi_hdr::oseqno, and dundi_transaction::packets.

Referenced by handle_frame().

{
 struct dundi_packet *pack;

 /* Ack transmitted packet corresponding to iseqno */
 AST_LIST_TRAVERSE(&trans->packets, pack, list) {
 if ((pack->h->oseqno + 1) % 255 == iseqno) {
 destroy_packet(pack, 0);
 if (!AST_LIST_EMPTY(&trans->lasttrans)) {
 ast_log(LOG_WARNING, "Whoa, there was still a last trans?\n");
 destroy_packets(&trans->lasttrans);
 }
 AST_LIST_INSERT_HEAD(&trans->lasttrans, pack, list);
 AST_SCHED_DEL(sched, trans->autokillid);
 return 1;
 }
 }

 return 0;
}

append_permission()

static void append_permission ( struct permissionlist *  permlist, const char *  s, int  allow  )

static

Definition at line 4442 of file pbx_dundi.c.

References permission::allow, ast_calloc, AST_LIST_INSERT_TAIL, permission::list, and permission::name.

Referenced by build_peer().

{
 struct permission *perm;

 if (!(perm = ast_calloc(1, sizeof(*perm) + strlen(s) + 1)))
 return;

 strcpy(perm->name, s);
 perm->allow = allow;

 AST_LIST_INSERT_TAIL(permlist, perm, list);
}

append_transaction()

static int append_transaction ( struct dundi_request *  dr, struct dundi_peer *  p, int  ttl, dundi_eid *  avoid[]  )

static

Definition at line 3642 of file pbx_dundi.c.

References dundi_peer::addr, ast_debug, ast_eid_to_str(), AST_LIST_INSERT_HEAD, ast_sockaddr_isnull(), ast_strlen_zero, create_transaction(), dundi_request::dcontext, dr, DUNDI_MAX_STACK, dundi_peer::eid, dundi_transaction::eidcount, dundi_transaction::eids, dundi_peer::lastms, dundi_peer::maxms, dundi_request::number, dundi_transaction::parent, dundi_transaction::parentlist, dundi_request::query_eid, dundi_request::trans, and dundi_transaction::ttl.

Referenced by build_transactions().

{
 struct dundi_transaction *trans;
 int x;
 char eid_str[20];
 char eid_str2[20];

 /* Ignore if not registered */
 if (ast_sockaddr_isnull(&p->addr)) {
 return 0;
 }
 if (p->maxms && ((p->lastms < 0) || (p->lastms >= p->maxms)))
 return 0;

 if (ast_strlen_zero(dr->number))
 ast_debug(1, "Will query peer '%s' for '%s' (context '%s')\n", ast_eid_to_str(eid_str, sizeof(eid_str), &p->eid), ast_eid_to_str(eid_str2, sizeof(eid_str2), &dr->query_eid), dr->dcontext);
 else
 ast_debug(1, "Will query peer '%s' for '%s@%s'\n", ast_eid_to_str(eid_str, sizeof(eid_str), &p->eid), dr->number, dr->dcontext);

 trans = create_transaction(p);
 if (!trans)
 return -1;
 trans->parent = dr;
 trans->ttl = ttl;
 for (x = 0; avoid[x] && (x < DUNDI_MAX_STACK); x++)
 trans->eids[x] = *avoid[x];
 trans->eidcount = x;
 AST_LIST_INSERT_HEAD(&dr->trans, trans, parentlist);

 return 0;
}

apply_peer()

static void apply_peer ( struct dundi_transaction *  trans, struct dundi_peer *  p  )

static

Definition at line 1295 of file pbx_dundi.c.

References dundi_transaction::addr, dundi_peer::addr, ast_set_flag, ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_strlen_zero, dundi_transaction::autokilltimeout, DUNDI_DEFAULT_RETRANS_TIMER, dundi_peer::eid, FLAG_ENCRYPT, global_autokilltimeout, dundi_peer::inkey, dundi_peer::lastms, dundi_peer::maxms, dundi_transaction::retranstimer, dundi_transaction::them_eid, dundi_transaction::us_eid, and dundi_peer::us_eid.

Referenced by create_transaction(), and handle_command_response().

{
 if (ast_sockaddr_isnull(&trans->addr)) {
 ast_sockaddr_copy(&trans->addr, &p->addr);
 }
 trans->us_eid = p->us_eid;
 trans->them_eid = p->eid;
 /* Enable encryption if appropriate */
 if (!ast_strlen_zero(p->inkey))
 ast_set_flag(trans, FLAG_ENCRYPT);
 if (p->maxms) {
 trans->autokilltimeout = p->maxms;
 trans->retranstimer = DUNDI_DEFAULT_RETRANS_TIMER;
 if (p->lastms > 1) {
 trans->retranstimer = p->lastms * 2;
 /* Keep it from being silly */
 if (trans->retranstimer < 150)
 trans->retranstimer = 150;
 }
 if (trans->retranstimer > DUNDI_DEFAULT_RETRANS_TIMER)
 trans->retranstimer = DUNDI_DEFAULT_RETRANS_TIMER;
 } else
 trans->autokilltimeout = global_autokilltimeout;
}

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 5278 of file pbx_dundi.c.

avoid_crc32()

static unsigned long avoid_crc32 ( dundi_eid *  avoid[] )

static

Definition at line 3809 of file pbx_dundi.c.

References dundi_request::crc32.

Referenced by dundi_lookup_internal().

{
 /* Idea is that we're calculating a checksum which is independent of
 the order that the EID's are listed in */
 uint32_t acrc32 = 0;
 int x;
 for (x=0;avoid[x];x++) {
 /* Order doesn't matter */
 if (avoid[x+1]) {
 acrc32 ^= crc32(0L, (unsigned char *)avoid[x], sizeof(dundi_eid));
 }
 }
 return acrc32;
}

build_iv()

static void build_iv ( unsigned char *  iv )

static

Definition at line 533 of file pbx_dundi.c.

References ast_random().

Referenced by build_secret(), dundi_encrypt(), and update_key().

{
 /* 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();
}

build_mapping()

static void build_mapping ( const char *  name, const char *  value  )

static

Definition at line 4457 of file pbx_dundi.c.

References dundi_mapping::_weight, ast_calloc, ast_copy_string(), AST_LIST_INSERT_HEAD, AST_LIST_TRAVERSE, ast_log, ast_strdup, ast_strdupa, ast_strlen_zero, dundi_mapping::dcontext, dundi_mapping::dead, dundi_mapping::dest, DUNDI_FLAG_COMMERCIAL, DUNDI_FLAG_INTERNAL_NOPARTIAL, DUNDI_FLAG_MOBILE, DUNDI_FLAG_NOCOMUNSOLICIT, DUNDI_FLAG_NOUNSOLICITED, DUNDI_FLAG_RESIDENTIAL, dundi_mapping::lcontext, permission::list, LOG_WARNING, map, MAX_OPTS, MAX_WEIGHT, dundi_mapping::options, str2tech(), dundi_mapping::tech, and dundi_mapping::weightstr.

Referenced by set_config().

{
 char *t, *fields[MAX_OPTS];
 struct dundi_mapping *map;
 int x;
 int y;

 t = ast_strdupa(value);

 AST_LIST_TRAVERSE(&mappings, map, list) {
 /* Find a double match */
 if (!strcasecmp(map->dcontext, name) &&
 (!strncasecmp(map->lcontext, value, strlen(map->lcontext)) &&
 (!value[strlen(map->lcontext)] ||
 (value[strlen(map->lcontext)] == ','))))
 break;
 }
 if (!map) {
 if (!(map = ast_calloc(1, sizeof(*map))))
 return;
 AST_LIST_INSERT_HEAD(&mappings, map, list);
 map->dead = 1;
 }
 map->options = 0;
 memset(fields, 0, sizeof(fields));
 x = 0;
 while (t && x < MAX_OPTS) {
 fields[x++] = t;
 t = strchr(t, ',');
 if (t) {
 *t = '\0';
 t++;
 }
 } /* Russell was here, arrrr! */
 if ((x == 1) && ast_strlen_zero(fields[0])) {
 /* Placeholder mapping */
 ast_copy_string(map->dcontext, name, sizeof(map->dcontext));
 map->dead = 0;
 } else if (x >= 4) {
 ast_copy_string(map->dcontext, name, sizeof(map->dcontext));
 ast_copy_string(map->lcontext, fields[0], sizeof(map->lcontext));
 if ((sscanf(fields[1], "%30d", &map->_weight) == 1) && (map->_weight >= 0) && (map->_weight <= MAX_WEIGHT)) {
 ast_copy_string(map->dest, fields[3], sizeof(map->dest));
 if ((map->tech = str2tech(fields[2])))
 map->dead = 0;
 } else if (!strncmp(fields[1], "${", 2) && fields[1][strlen(fields[1]) - 1] == '}') {
 map->weightstr = ast_strdup(fields[1]);
 ast_copy_string(map->dest, fields[3], sizeof(map->dest));
 if ((map->tech = str2tech(fields[2])))
 map->dead = 0;
 } else {
 ast_log(LOG_WARNING, "Invalid weight '%s' specified, deleting entry '%s/%s'\n", fields[1], map->dcontext, map->lcontext);
 }
 for (y = 4;y < x; y++) {
 if (!strcasecmp(fields[y], "nounsolicited"))
 map->options |= DUNDI_FLAG_NOUNSOLICITED;
 else if (!strcasecmp(fields[y], "nocomunsolicit"))
 map->options |= DUNDI_FLAG_NOCOMUNSOLICIT;
 else if (!strcasecmp(fields[y], "residential"))
 map->options |= DUNDI_FLAG_RESIDENTIAL;
 else if (!strcasecmp(fields[y], "commercial"))
 map->options |= DUNDI_FLAG_COMMERCIAL;
 else if (!strcasecmp(fields[y], "mobile"))
 map->options |= DUNDI_FLAG_MOBILE;
 else if (!strcasecmp(fields[y], "nopartial"))
 map->options |= DUNDI_FLAG_INTERNAL_NOPARTIAL;
 else
 ast_log(LOG_WARNING, "Don't know anything about option '%s'\n", fields[y]);
 }
 } else
 ast_log(LOG_WARNING, "Expected at least %d arguments in map, but got only %d\n", 4, x);
}

build_peer()

static void build_peer ( dundi_eid *  eid, struct ast_variable *  v, int *  globalpcmode  )

static

Definition at line 4628 of file pbx_dundi.c.

References dundi_peer::addr, append_permission(), ast_calloc, ast_copy_string(), ast_eid_cmp(), ast_eid_to_str(), ast_free, AST_LIST_EMPTY, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_sched_add(), AST_SCHED_DEL, ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_resolve(), ast_sockaddr_set_port, ast_str_to_eid(), ast_true(), dundi_peer::dead, DEFAULT_MAXMS, destroy_permissions(), do_register(), DUNDI_MODEL_INBOUND, DUNDI_MODEL_OUTBOUND, DUNDI_MODEL_SYMMETRIC, DUNDI_PORT, dundi_peer::dynamic, dundi_peer::eid, global_eid, dundi_peer::include, dundi_peer::inkey, ast_variable::lineno, permission::list, LOG_WARNING, dundi_peer::maxms, dundi_peer::model, ast_variable::name, ast_variable::next, dundi_peer::order, dundi_peer::outkey, PARSE_PORT_FORBID, dundi_peer::pcmodel, dundi_peer::permit, populate_addr(), qualify_peer(), dundi_peer::qualifyid, dundi_peer::registerexpire, dundi_peer::registerid, dundi_peer::us_eid, and ast_variable::value.

Referenced by set_config().

{
 struct dundi_peer *peer;
 dundi_eid testeid;
 int needregister=0;
 char eid_str[20];
 int port = 0;

 AST_LIST_LOCK(&peers);
 AST_LIST_TRAVERSE(&peers, peer, list) {
 if (!ast_eid_cmp(&peer->eid, eid)) {
 break;
 }
 }
 if (!peer) {
 /* Add us into the list */
 if (!(peer = ast_calloc(1, sizeof(*peer)))) {
 AST_LIST_UNLOCK(&peers);
 return;
 }
 peer->registerid = -1;
 peer->registerexpire = -1;
 peer->qualifyid = -1;
 populate_addr(peer, eid);
 AST_LIST_INSERT_HEAD(&peers, peer, list);
 }
 peer->dead = 0;
 peer->eid = *eid;
 peer->us_eid = global_eid;
 destroy_permissions(&peer->permit);
 destroy_permissions(&peer->include);
 AST_SCHED_DEL(sched, peer->registerid);
 for (; v; v = v->next) {
 if (!strcasecmp(v->name, "inkey")) {
 ast_copy_string(peer->inkey, v->value, sizeof(peer->inkey));
 } else if (!strcasecmp(v->name, "outkey")) {
 ast_copy_string(peer->outkey, v->value, sizeof(peer->outkey));
 } else if (!strcasecmp(v->name, "port")) {
 port = atoi(v->value);
 } else if (!strcasecmp(v->name, "host")) {
 if (!strcasecmp(v->value, "dynamic")) {
 peer->dynamic = 1;
 } else {
 struct ast_sockaddr *addrs;

 if (ast_sockaddr_resolve(&addrs, v->value, PARSE_PORT_FORBID, AF_UNSPEC) > 0) {
 ast_sockaddr_copy(&peer->addr, &addrs[0]);
 peer->dynamic = 0;
 ast_free(addrs);
 } else {
 ast_log(LOG_WARNING, "Unable to find host '%s' at line %d\n", v->value, v->lineno);
 peer->dead = 1;
 }
 }
 } else if (!strcasecmp(v->name, "ustothem")) {
 if (!ast_str_to_eid(&testeid, v->value))
 peer->us_eid = testeid;
 else
 ast_log(LOG_WARNING, "'%s' is not a valid DUNDi Entity Identifier at line %d\n", v->value, v->lineno);
 } else if (!strcasecmp(v->name, "include")) {
 append_permission(&peer->include, v->value, 1);
 } else if (!strcasecmp(v->name, "permit")) {
 append_permission(&peer->permit, v->value, 1);
 } else if (!strcasecmp(v->name, "noinclude")) {
 append_permission(&peer->include, v->value, 0);
 } else if (!strcasecmp(v->name, "deny")) {
 append_permission(&peer->permit, v->value, 0);
 } else if (!strcasecmp(v->name, "register")) {
 needregister = ast_true(v->value);
 } else if (!strcasecmp(v->name, "order")) {
 if (!strcasecmp(v->value, "primary"))
 peer->order = 0;
 else if (!strcasecmp(v->value, "secondary"))
 peer->order = 1;
 else if (!strcasecmp(v->value, "tertiary"))
 peer->order = 2;
 else if (!strcasecmp(v->value, "quartiary"))
 peer->order = 3;
 else {
 ast_log(LOG_WARNING, "'%s' is not a valid order, should be primary, secondary, tertiary or quartiary at line %d\n", v->value, v->lineno);
 }
 } else if (!strcasecmp(v->name, "qualify")) {
 if (!strcasecmp(v->value, "no")) {
 peer->maxms = 0;
 } else if (!strcasecmp(v->value, "yes")) {
 peer->maxms = DEFAULT_MAXMS;
 } else if (sscanf(v->value, "%30d", &peer->maxms) != 1) {
 ast_log(LOG_WARNING, "Qualification of peer '%s' should be 'yes', 'no', or a number of milliseconds at line %d of dundi.conf\n",
 ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid), v->lineno);
 peer->maxms = 0;
 }
 } else if (!strcasecmp(v->name, "model")) {
 if (!strcasecmp(v->value, "inbound"))
 peer->model = DUNDI_MODEL_INBOUND;
 else if (!strcasecmp(v->value, "outbound"))
 peer->model = DUNDI_MODEL_OUTBOUND;
 else if (!strcasecmp(v->value, "symmetric"))
 peer->model = DUNDI_MODEL_SYMMETRIC;
 else if (!strcasecmp(v->value, "none"))
 peer->model = 0;
 else {
 ast_log(LOG_WARNING, "Unknown model '%s', should be 'none', 'outbound', 'inbound', or 'symmetric' at line %d\n",
 v->value, v->lineno);
 }
 } else if (!strcasecmp(v->name, "precache")) {
 if (!strcasecmp(v->value, "inbound"))
 peer->pcmodel = DUNDI_MODEL_INBOUND;
 else if (!strcasecmp(v->value, "outbound"))
 peer->pcmodel = DUNDI_MODEL_OUTBOUND;
 else if (!strcasecmp(v->value, "symmetric"))
 peer->pcmodel = DUNDI_MODEL_SYMMETRIC;
 else if (!strcasecmp(v->value, "none"))
 peer->pcmodel = 0;
 else {
 ast_log(LOG_WARNING, "Unknown pcmodel '%s', should be 'none', 'outbound', 'inbound', or 'symmetric' at line %d\n",
 v->value, v->lineno);
 }
 }
 }

 if (!ast_sockaddr_isnull(&peer->addr)) {
 ast_sockaddr_set_port(&peer->addr, (0 < port) ? port : DUNDI_PORT);
 }

 (*globalpcmode) |= peer->pcmodel;
 if (!peer->model && !peer->pcmodel) {
 ast_log(LOG_WARNING, "Peer '%s' lacks a model or pcmodel, discarding!\n",
 ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 peer->dead = 1;
 } else if ((peer->model & DUNDI_MODEL_INBOUND) && (peer->pcmodel & DUNDI_MODEL_OUTBOUND)) {
 ast_log(LOG_WARNING, "Peer '%s' may not be both inbound/symmetric model and outbound/symmetric precache model, discarding!\n",
 ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 peer->dead = 1;
 } else if ((peer->model & DUNDI_MODEL_OUTBOUND) && (peer->pcmodel & DUNDI_MODEL_INBOUND)) {
 ast_log(LOG_WARNING, "Peer '%s' may not be both outbound/symmetric model and inbound/symmetric precache model, discarding!\n",
 ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 peer->dead = 1;
 } else if (!AST_LIST_EMPTY(&peer->include) && !(peer->model & DUNDI_MODEL_OUTBOUND) && !(peer->pcmodel & DUNDI_MODEL_INBOUND)) {
 ast_log(LOG_WARNING, "Peer '%s' is supposed to be included in outbound searches but isn't an outbound peer or inbound precache!\n",
 ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 } else if (!AST_LIST_EMPTY(&peer->permit) && !(peer->model & DUNDI_MODEL_INBOUND) && !(peer->pcmodel & DUNDI_MODEL_OUTBOUND)) {
 ast_log(LOG_WARNING, "Peer '%s' is supposed to have permission for some inbound searches but isn't an inbound peer or outbound precache!\n",
 ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 } else {
 if (ast_eid_cmp(&peer->eid, &empty_eid)) {
 /* Schedule any items for explicitly configured peers. */
 if (needregister) {
 peer->registerid = ast_sched_add(sched, 2000, do_register, peer);
 }
 qualify_peer(peer, 1);
 }
 }
 AST_LIST_UNLOCK(&peers);
}

build_secret()

static void build_secret ( char *  secret, int  seclen  )

static

Definition at line 2110 of file pbx_dundi.c.

References ast_base64encode(), build_iv(), and tmp().

Referenced by check_password(), and load_password().

{
 unsigned char tmp[16];
 char *s;
 build_iv(tmp);
 secret[0] = '\0';
 ast_base64encode(secret, tmp, sizeof(tmp), seclen);
 /* Eliminate potential bad characters */
 while((s = strchr(secret, ';'))) *s = '+';
 while((s = strchr(secret, '/'))) *s = '+';
 while((s = strchr(secret, ':'))) *s = '+';
 while((s = strchr(secret, '@'))) *s = '+';
}

build_transactions()

static void build_transactions ( struct dundi_request *  dr, int  ttl, int  order, int *  foundcache, int *  skipped, int  blockempty, int  nocache, int  modeselect, dundi_eid *  skip, dundi_eid *  avoid[], int  directs[]  )

static

Definition at line 3700 of file pbx_dundi.c.

References append_transaction(), ast_clear_flag_nonstd, ast_debug, ast_eid_cmp(), ast_eid_to_str(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, cache_lookup(), dundi_request::crc32, dundi_request::dcontext, dundi_eid_zero(), DUNDI_HINT_UNAFFECTED, DUNDI_MODEL_OUTBOUND, dundi_peer::eid, dundi_request::expiration, has_permission(), dundi_request::hmd, dundi_peer::include, permission::list, dundi_peer::model, dundi_peer::order, pass, dundi_peer::pcmodel, dundi_peer::permit, and dundi_peer::us_eid.

Referenced by dundi_lookup_internal(), dundi_precache_internal(), and dundi_query_eid_internal().

{
 struct dundi_peer *p;
 int x;
 int res;
 int pass;
 int allowconnect;
 char eid_str[20];
 AST_LIST_LOCK(&peers);
 AST_LIST_TRAVERSE(&peers, p, list) {
 if (modeselect == 1) {
 /* Send the precache to push upstreams only! */
 pass = has_permission(&p->permit, dr->dcontext) && (p->pcmodel & DUNDI_MODEL_OUTBOUND);
 allowconnect = 1;
 } else {
 /* Normal lookup / EID query */
 pass = has_permission(&p->include, dr->dcontext);
 allowconnect = p->model & DUNDI_MODEL_OUTBOUND;
 }
 if (skip) {
 if (!ast_eid_cmp(skip, &p->eid))
 pass = 0;
 }
 if (pass) {
 if (p->order <= order) {
 /* Check order first, then check cache, regardless of
 omissions, this gets us more likely to not have an
 affected answer. */
 if((nocache || !(res = cache_lookup(dr, &p->eid, dr->crc32, &dr->expiration)))) {
 res = 0;
 /* Make sure we haven't already seen it and that it won't
 affect our answer */
 for (x=0;avoid[x];x++) {
 if (!ast_eid_cmp(avoid[x], &p->eid) || !ast_eid_cmp(avoid[x], &p->us_eid)) {
 /* If not a direct connection, it affects our answer */
 if (directs && !directs[x])
 ast_clear_flag_nonstd(dr->hmd, DUNDI_HINT_UNAFFECTED);
 break;
 }
 }
 /* Make sure we can ask */
 if (allowconnect) {
 if (!avoid[x] && (!blockempty || !dundi_eid_zero(&p->us_eid))) {
 /* Check for a matching or 0 cache entry */
 append_transaction(dr, p, ttl, avoid);
 } else {
 ast_debug(1, "Avoiding '%s' in transaction\n", ast_eid_to_str(eid_str, sizeof(eid_str), avoid[x]));
 }
 }
 }
 *foundcache |= res;
 } else if (!*skipped || (p->order < *skipped))
 *skipped = p->order;
 }
 }
 AST_LIST_UNLOCK(&peers);
}

cache_lookup()

static int cache_lookup ( struct dundi_request *  req, dundi_eid *  peer_eid, uint32_t  crc, int *  lowexpiration  )

static

Definition at line 1242 of file pbx_dundi.c.

References ast_copy_string(), ast_eid_to_str(), cache_lookup_internal(), dundi_request::dcontext, dundi_eid_to_str_short(), dundi_hint_metadata::exten, dundi_request::hmd, dundi_request::number, qualify_peer(), dundi_request::respcount, dundi_request::root_eid, and tmp().

Referenced by build_transactions().

{
 char eid_str[20];
 char eidroot_str[20];
 time_t now;
 int res=0;
 int res2=0;
 char eid_str_full[20];
 char tmp[256]="";
 /* Enough space for largest value that can be stored in key. */
 char key[sizeof(eid_str) + sizeof(tmp) + sizeof(req->dcontext) + sizeof(eidroot_str) + sizeof("hint////r")];
 int x;

 time(&now);
 dundi_eid_to_str_short(eid_str, sizeof(eid_str), peer_eid);
 dundi_eid_to_str_short(eidroot_str, sizeof(eidroot_str), &req->root_eid);
 ast_eid_to_str(eid_str_full, sizeof(eid_str_full), peer_eid);
 snprintf(key, sizeof(key), "%s/%s/%s/e%08x", eid_str, req->number, req->dcontext, crc);
 res |= cache_lookup_internal(now, req, key, eid_str_full, lowexpiration);
 snprintf(key, sizeof(key), "%s/%s/%s/e%08x", eid_str, req->number, req->dcontext, (unsigned)0);
 res |= cache_lookup_internal(now, req, key, eid_str_full, lowexpiration);
 snprintf(key, sizeof(key), "%s/%s/%s/r%s", eid_str, req->number, req->dcontext, eidroot_str);
 res |= cache_lookup_internal(now, req, key, eid_str_full, lowexpiration);
 x = 0;
 if (!req->respcount) {
 while(!res2) {
 /* Look and see if we have a hint that would preclude us from looking at this
 peer for this number. */
 if (!(tmp[x] = req->number[x]))
 break;
 x++;
 /* Check for hints */
 snprintf(key, sizeof(key), "hint/%s/%s/%s/e%08x", eid_str, tmp, req->dcontext, crc);
 res2 |= cache_lookup_internal(now, req, key, eid_str_full, lowexpiration);
 snprintf(key, sizeof(key), "hint/%s/%s/%s/e%08x", eid_str, tmp, req->dcontext, (unsigned)0);
 res2 |= cache_lookup_internal(now, req, key, eid_str_full, lowexpiration);
 snprintf(key, sizeof(key), "hint/%s/%s/%s/r%s", eid_str, tmp, req->dcontext, eidroot_str);
 res2 |= cache_lookup_internal(now, req, key, eid_str_full, lowexpiration);
 if (res2) {
 if (strlen(tmp) > strlen(req->hmd->exten)) {
 /* Update meta data if appropriate */
 ast_copy_string(req->hmd->exten, tmp, sizeof(req->hmd->exten));
 }
 }
 }
 res |= res2;
 }

 return res;
}

cache_lookup_internal()

static int cache_lookup_internal ( time_t  now, struct dundi_request *  req, char *  key, char *  eid_str_full, int *  lowexpiration  )

static

Definition at line 1170 of file pbx_dundi.c.

References ast_clear_flag_nonstd, ast_copy_flags, ast_copy_string(), ast_db_del(), ast_db_get(), ast_debug, ast_eid_to_str(), AST_FLAGS_ALL, ast_get_time_t(), dundi_result::dest, dundi_request::dr, dundi_flags2str(), DUNDI_HINT_DONT_ASK, dundi_str_short_to_eid(), dundi_result::eid, dundi_result::eid_str, dundi_result::expiration, ast_flags::flags, dundi_request::hmd, dundi_request::respcount, dundi_result::tech, dundi_mapping::tech, tech2str(), dundi_result::techint, timeout, weight, and dundi_result::weight.

Referenced by cache_lookup().

{
 char data[1024];
 char *ptr, *term, *src;
 int tech;
 struct ast_flags flags;
 int weight;
 int length;
 int z;
 char fs[256];

 /* Build request string */
 if (!ast_db_get("dundi/cache", key, data, sizeof(data))) {
 time_t timeout;
 ptr = data;
 if (!ast_get_time_t(ptr, &timeout, 0, &length)) {
 int expiration = timeout - now;
 if (expiration > 0) {
 ast_debug(1, "Found cache expiring in %d seconds!\n", expiration);
 ptr += length + 1;
 while((sscanf(ptr, "%30d/%30d/%30d/%n", (int *)&(flags.flags), &weight, &tech, &length) == 3)) {
 ptr += length;
 term = strchr(ptr, '|');
 if (term) {
 *term = '\0';
 src = strrchr(ptr, '/');
 if (src) {
 *src = '\0';
 src++;
 } else
 src = "";
 ast_debug(1, "Found cached answer '%s/%s' originally from '%s' with flags '%s' on behalf of '%s'\n",
 tech2str(tech), ptr, src, dundi_flags2str(fs, sizeof(fs), flags.flags), eid_str_full);
 /* Make sure it's not already there */
 for (z=0;z<req->respcount;z++) {
 if ((req->dr[z].techint == tech) &&
 !strcmp(req->dr[z].dest, ptr))
 break;
 }
 if (z == req->respcount) {
 /* Copy into parent responses */
 ast_copy_flags(&(req->dr[req->respcount]), &flags, AST_FLAGS_ALL);
 req->dr[req->respcount].weight = weight;
 req->dr[req->respcount].techint = tech;
 req->dr[req->respcount].expiration = expiration;
 dundi_str_short_to_eid(&req->dr[req->respcount].eid, src);
 ast_eid_to_str(req->dr[req->respcount].eid_str,
 sizeof(req->dr[req->respcount].eid_str), &req->dr[req->respcount].eid);
 ast_copy_string(req->dr[req->respcount].dest, ptr,
 sizeof(req->dr[req->respcount].dest));
 ast_copy_string(req->dr[req->respcount].tech, tech2str(tech),
 sizeof(req->dr[req->respcount].tech));
 req->respcount++;
 ast_clear_flag_nonstd(req->hmd, DUNDI_HINT_DONT_ASK);
 } else if (req->dr[z].weight > weight)
 req->dr[z].weight = weight;
 ptr = term + 1;
 }
 }
 /* We found *something* cached */
 if (expiration < *lowexpiration)
 *lowexpiration = expiration;
 return 1;
 } else
 ast_db_del("dundi/cache", key);
 } else
 ast_db_del("dundi/cache", key);
 }

 return 0;
}

cache_save()

static int cache_save ( dundi_eid *  eidpeer, struct dundi_request *  req, int  start, int  unaffected, int  expiration, int  push  )

static

Definition at line 899 of file pbx_dundi.c.

References ast_db_put(), dundi_request::crc32, dundi_request::dcontext, dundi_result::dest, dundi_request::dr, dundi_cache_time, dundi_eid_to_str_short(), dundi_result::eid, dundi_result::flags, dundi_request::number, dundi_request::respcount, dundi_request::root_eid, dundi_result::techint, timeout, and dundi_result::weight.

Referenced by dundi_prop_precache(), and handle_command_response().

{
 int x;
 char key1[256];
 char key2[256];
 char data[1024];
 char eidpeer_str[20];
 char eidroot_str[20];
 time_t timeout;

 if (expiration < 1)
 expiration = dundi_cache_time;

 /* Keep pushes a little longer, cut pulls a little short */
 if (push)
 expiration += 10;
 else
 expiration -= 10;
 if (expiration < 1)
 expiration = 1;
 dundi_eid_to_str_short(eidpeer_str, sizeof(eidpeer_str), eidpeer);
 dundi_eid_to_str_short(eidroot_str, sizeof(eidroot_str), &req->root_eid);
 snprintf(key1, sizeof(key1), "%s/%s/%s/e%08x", eidpeer_str, req->number, req->dcontext, unaffected ? 0 : req->crc32);
 snprintf(key2, sizeof(key2), "%s/%s/%s/r%s", eidpeer_str, req->number, req->dcontext, eidroot_str);
 /* Build request string */
 time(&timeout);
 timeout += expiration;
 snprintf(data, sizeof(data), "%ld|", (long)(timeout));
 for (x=start;x<req->respcount;x++) {
 /* Skip anything with an illegal pipe in it */
 if (strchr(req->dr[x].dest, '|'))
 continue;
 snprintf(data + strlen(data), sizeof(data) - strlen(data), "%u/%d/%d/%s/%s|",
 req->dr[x].flags, req->dr[x].weight, req->dr[x].techint, req->dr[x].dest,
 dundi_eid_to_str_short(eidpeer_str, sizeof(eidpeer_str), &req->dr[x].eid));
 }
 ast_db_put("dundi/cache", key1, data);
 ast_db_put("dundi/cache", key2, data);
 return 0;
}

cache_save_hint()

static int cache_save_hint ( dundi_eid *  eidpeer, struct dundi_request *  req, struct dundi_hint *  hint, int  expiration  )

static

Definition at line 864 of file pbx_dundi.c.

References ast_db_put(), ast_debug, ast_test_flag_nonstd, dundi_request::crc32, dundi_hint::data, dundi_request::dcontext, dundi_cache_time, dundi_eid_to_str_short(), DUNDI_HINT_DONT_ASK, DUNDI_HINT_UNAFFECTED, dundi_request::root_eid, and timeout.

Referenced by dundi_prop_precache(), and handle_command_response().

{
 int unaffected;
 char key1[256];
 char key2[256];
 char eidpeer_str[20];
 char eidroot_str[20];
 char data[80];
 time_t timeout;

 if (expiration < 0)
 expiration = dundi_cache_time;

 /* Only cache hint if "don't ask" is there... */
 if (!ast_test_flag_nonstd(hint, htons(DUNDI_HINT_DONT_ASK)))
 return 0;

 unaffected = ast_test_flag_nonstd(hint, htons(DUNDI_HINT_UNAFFECTED));

 dundi_eid_to_str_short(eidpeer_str, sizeof(eidpeer_str), eidpeer);
 dundi_eid_to_str_short(eidroot_str, sizeof(eidroot_str), &req->root_eid);
 snprintf(key1, sizeof(key1), "hint/%s/%s/%s/e%08x", eidpeer_str, hint->data, req->dcontext, unaffected ? 0 : req->crc32);
 snprintf(key2, sizeof(key2), "hint/%s/%s/%s/r%s", eidpeer_str, hint->data, req->dcontext, eidroot_str);

 time(&timeout);
 timeout += expiration;
 snprintf(data, sizeof(data), "%ld|", (long)(timeout));

 ast_db_put("dundi/cache", key1, data);
 ast_debug(1, "Caching hint at '%s'\n", key1);
 ast_db_put("dundi/cache", key2, data);
 ast_debug(1, "Caching hint at '%s'\n", key2);
 return 0;
}

cancel_request()

static void cancel_request ( struct dundi_request *  dr )

static

Definition at line 3674 of file pbx_dundi.c.

References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, DUNDI_COMMAND_CANCEL, dundi_send(), NULL, dundi_transaction::parent, dundi_transaction::parentlist, and dundi_request::trans.

Referenced by dundi_lookup_internal(), and dundi_precache_internal().

{
 struct dundi_transaction *trans;

 AST_LIST_LOCK(&peers);
 while ((trans = AST_LIST_REMOVE_HEAD(&dr->trans, parentlist))) {
 /* Orphan transaction from request */
 trans->parent = NULL;
 /* Send final cancel */
 dundi_send(trans, DUNDI_COMMAND_CANCEL, 0, 1, NULL);
 }
 AST_LIST_UNLOCK(&peers);
}

check_key()

static int check_key ( struct dundi_peer *  peer, unsigned char *  newkey, unsigned char *  newsig, uint32_t  keycrc32  )

static

Definition at line 1492 of file pbx_dundi.c.

References ast_aes_set_decrypt_key(), ast_aes_set_encrypt_key(), ast_check_signature_bin(), ast_debug, ast_decrypt_bin(), ast_eid_to_str(), ast_key_get(), AST_KEY_PRIVATE, AST_KEY_PUBLIC, ast_log, dundi_peer::eid, dundi_peer::inkey, LOG_NOTICE, dundi_peer::outkey, dundi_peer::rxenckey, dundi_peer::them_dcx, dundi_peer::them_ecx, and dundi_peer::them_keycrc32.

Referenced by handle_command_response().

{
 unsigned char dst[128];
 int res;
 struct ast_key *key, *skey;
 char eid_str[20];
 ast_debug(1, "Expected '%08x' got '%08x'\n", peer->them_keycrc32, keycrc32);
 if (peer->them_keycrc32 && (peer->them_keycrc32 == keycrc32)) {
 /* A match */
 return 1;
 } else if (!newkey || !newsig)
 return 0;
 if (!memcmp(peer->rxenckey, newkey, 128) &&
 !memcmp(peer->rxenckey + 128, newsig, 128)) {
 /* By definition, a match */
 return 1;
 }
 /* Decrypt key */
 key = ast_key_get(peer->outkey, AST_KEY_PRIVATE);
 if (!key) {
 ast_log(LOG_NOTICE, "Unable to find key '%s' to decode shared key from '%s'\n",
 peer->outkey, ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 return -1;
 }

 skey = ast_key_get(peer->inkey, AST_KEY_PUBLIC);
 if (!skey) {
 ast_log(LOG_NOTICE, "Unable to find key '%s' to verify shared key from '%s'\n",
 peer->inkey, ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 return -1;
 }

 /* First check signature */
 res = ast_check_signature_bin(skey, (char *)newkey, 128, newsig);
 if (res)
 return 0;

 res = ast_decrypt_bin(dst, newkey, sizeof(dst), key);
 if (res != 16) {
 if (res >= 0)
 ast_log(LOG_NOTICE, "Weird, key decoded to the wrong size (%d)\n", res);
 return 0;
 }
 /* Decrypted, passes signature */
 ast_debug(1, "Wow, new key combo passed signature and decrypt!\n");
 memcpy(peer->rxenckey, newkey, 128);
 memcpy(peer->rxenckey + 128, newsig, 128);
 peer->them_keycrc32 = crc32(0L, peer->rxenckey, 128);
 ast_aes_set_decrypt_key(dst, &peer->them_dcx);
 ast_aes_set_encrypt_key(dst, &peer->them_ecx);
 return 1;
}

check_password()

static void check_password ( void  )

static

Definition at line 2177 of file pbx_dundi.c.

References ast_copy_string(), build_secret(), and save_secret().

Referenced by network_thread().

{
 char oldsecret[80];
 time_t now;

 time(&now);
#if 0
 printf("%ld/%ld\n", now, rotatetime);
#endif
 if ((now - rotatetime) >= 0) {
 /* Time to rotate keys */
 ast_copy_string(oldsecret, cursecret, sizeof(oldsecret));
 build_secret(cursecret, sizeof(cursecret));
 save_secret(cursecret, oldsecret);
 }
}

check_request()

static int check_request ( struct dundi_request *  dr )

static

Definition at line 3795 of file pbx_dundi.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, and permission::list.

Referenced by dundi_lookup_internal().

{
 struct dundi_request *cur;

 AST_LIST_LOCK(&peers);
 AST_LIST_TRAVERSE(&requests, cur, list) {
 if (cur == dr)
 break;
 }
 AST_LIST_UNLOCK(&peers);

 return cur ? 1 : 0;
}

complete_peer_helper()

static char* complete_peer_helper ( const char *  line, const char *  word, int  pos, int  state, int  rpos  )

static

Definition at line 2417 of file pbx_dundi.c.

References ast_eid_to_str(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strdup, dundi_peer::eid, len(), permission::list, and NULL.

Referenced by dundi_show_peer().

{
 int which=0, len;
 char *ret = NULL;
 struct dundi_peer *p;
 char eid_str[20];

 if (pos != rpos)
 return NULL;
 AST_LIST_LOCK(&peers);
 len = strlen(word);
 AST_LIST_TRAVERSE(&peers, p, list) {
 const char *s = ast_eid_to_str(eid_str, sizeof(eid_str), &p->eid);
 if (!strncasecmp(word, s, len) && ++which > state) {
 ret = ast_strdup(s);
 break;
 }
 }
 AST_LIST_UNLOCK(&peers);
 return ret;
}

create_transaction()

static struct dundi_transaction * create_transaction ( struct dundi_peer *  p )

static

Definition at line 3137 of file pbx_dundi.c.

References dundi_peer::addr, dundi_transaction::all, apply_peer(), ast_calloc, AST_LIST_INSERT_HEAD, ast_set_flag, ast_sockaddr_isnull(), ast_tvnow(), dundi_transaction::autokillid, DUNDI_DEFAULT_RETRANS_TIMER, FLAG_SENDFULLKEY, FLAG_STOREHIST, get_trans_id(), NULL, dundi_transaction::retranstimer, dundi_peer::sentfullkey, dundi_transaction::start, and dundi_transaction::strans.

Referenced by append_transaction(), do_register(), find_transaction(), qualify_peer(), and str2tech().

{
 struct dundi_transaction *trans;
 int tid;

 /* Don't allow creation of transactions to non-registered peers */
 if (p && ast_sockaddr_isnull(&p->addr)) {
 return NULL;
 }
 tid = get_trans_id();
 if (tid < 1)
 return NULL;
 if (!(trans = ast_calloc(1, sizeof(*trans))))
 return NULL;

 if (global_storehistory) {
 trans->start = ast_tvnow();
 ast_set_flag(trans, FLAG_STOREHIST);
 }
 trans->retranstimer = DUNDI_DEFAULT_RETRANS_TIMER;
 trans->autokillid = -1;
 if (p) {
 apply_peer(trans, p);
 if (!p->sentfullkey)
 ast_set_flag(trans, FLAG_SENDFULLKEY);
 }
 trans->strans = tid;
 AST_LIST_INSERT_HEAD(&alltrans, trans, all);

 return trans;
}

decrypt_memcpy()

static int decrypt_memcpy ( unsigned char *  dst, unsigned char *  src, int  len, unsigned char *  iv, ast_aes_decrypt_key *  dcx  )

static

Definition at line 1389 of file pbx_dundi.c.

References ast_aes_decrypt().

Referenced by dundi_decrypt().

{
 unsigned char lastblock[16];
 int x;
 memcpy(lastblock, iv, sizeof(lastblock));
 while(len > 0) {
 ast_aes_decrypt(src, dst, dcx);
 for (x=0;x<16;x++)
 dst[x] ^= lastblock[x];
 memcpy(lastblock, src, sizeof(lastblock));
 dst += 16;
 src += 16;
 len -= 16;
 }
 return 0;
}

deep_copy_peer()

static void deep_copy_peer ( struct dundi_peer *  peer_dst, const struct dundi_peer *  peer_src  )

static

Definition at line 1545 of file pbx_dundi.c.

References permission::allow, ast_calloc, AST_LIST_INSERT_HEAD, AST_LIST_NEXT, AST_LIST_TRAVERSE, dundi_peer::include, permission::list, dundi_peer::lookups, permission::name, NULL, dundi_peer::permit, dundi_peer::qualifyid, dundi_peer::qualtrans, dundi_peer::registerexpire, dundi_peer::registerid, and dundi_peer::regtrans.

Referenced by handle_command_response().

{
 struct permission *cur, *perm;

 *peer_dst = *peer_src;
 AST_LIST_NEXT(peer_dst, list) = NULL;

 /* Scheduled items cannot go with the copy */
 peer_dst->registerid = -1;
 peer_dst->qualifyid = -1;
 peer_dst->registerexpire = -1;

 /* Transactions and lookup history cannot go with the copy either */
 peer_dst->regtrans = NULL;
 peer_dst->qualtrans = NULL;
 memset(&peer_dst->lookups, 0, sizeof(peer_dst->lookups));

 memset(&peer_dst->permit, 0, sizeof(peer_dst->permit));
 memset(&peer_dst->include, 0, sizeof(peer_dst->permit));

 AST_LIST_TRAVERSE(&peer_src->permit, cur, list) {
 if (!(perm = ast_calloc(1, sizeof(*perm) + strlen(cur->name) + 1)))
 continue;

 perm->allow = cur->allow;
 strcpy(perm->name, cur->name);

 AST_LIST_INSERT_HEAD(&peer_dst->permit, perm, list);
 }

 AST_LIST_TRAVERSE(&peer_src->include, cur, list) {
 if (!(perm = ast_calloc(1, sizeof(*perm) + strlen(cur->name) + 1)))
 continue;

 perm->allow = cur->allow;
 strcpy(perm->name, cur->name);

 AST_LIST_INSERT_HEAD(&peer_dst->include, perm, list);
 }
}

destroy_map()

static void destroy_map ( struct dundi_mapping *  map )

static

Definition at line 4406 of file pbx_dundi.c.

References ast_free, and dundi_mapping::weightstr.

Referenced by prune_mappings().

{
 ast_free(map->weightstr);
 ast_free(map);
}

destroy_packet()

static void destroy_packet ( struct dundi_packet *  pack, int  needfree  )

static

Definition at line 3194 of file pbx_dundi.c.

References ast_free, AST_LIST_REMOVE, AST_SCHED_DEL, permission::list, dundi_transaction::packets, dundi_packet::parent, and dundi_packet::retransid.

Referenced by ack_trans(), and handle_command_response().

{
 if (pack->parent)
 AST_LIST_REMOVE(&pack->parent->packets, pack, list);
 AST_SCHED_DEL(sched, pack->retransid);
 if (needfree)
 ast_free(pack);
}

destroy_packets()

static void destroy_packets ( struct packetlist *  p )

static

Definition at line 2010 of file pbx_dundi.c.

References ast_free, AST_LIST_REMOVE_HEAD, AST_SCHED_DEL, permission::list, and dundi_packet::retransid.

Referenced by ack_trans(), destroy_trans(), and handle_frame().

{
 struct dundi_packet *pack;

 while ((pack = AST_LIST_REMOVE_HEAD(p, list))) {
 AST_SCHED_DEL(sched, pack->retransid);
 ast_free(pack);
 }
}

destroy_peer()

static void destroy_peer ( struct dundi_peer *  peer )

static

Definition at line 4382 of file pbx_dundi.c.

References ARRAY_LEN, ast_free, AST_SCHED_DEL, destroy_permissions(), destroy_trans(), dundi_peer::include, dundi_peer::lookups, dundi_peer::permit, dundi_peer::qualifyid, dundi_peer::qualtrans, dundi_peer::registerexpire, dundi_peer::registerid, and dundi_peer::regtrans.

Referenced by prune_peers().

{
 int idx;

 AST_SCHED_DEL(sched, peer->registerexpire);
 AST_SCHED_DEL(sched, peer->registerid);
 if (peer->regtrans) {
 destroy_trans(peer->regtrans, 0);
 }
 AST_SCHED_DEL(sched, peer->qualifyid);
 if (peer->qualtrans) {
 destroy_trans(peer->qualtrans, 0);
 }
 destroy_permissions(&peer->permit);
 destroy_permissions(&peer->include);

 /* Release lookup history */
 for (idx = 0; idx < ARRAY_LEN(peer->lookups); ++idx) {
 ast_free(peer->lookups[idx]);
 }

 ast_free(peer);
}

destroy_permissions()

static void destroy_permissions ( struct permissionlist *  permlist )

static

Definition at line 4374 of file pbx_dundi.c.

References ast_free, AST_LIST_REMOVE_HEAD, and permission::list.

Referenced by build_peer(), and destroy_peer().

{
 struct permission *perm;

 while ((perm = AST_LIST_REMOVE_HEAD(permlist, list)))
 ast_free(perm);
}

destroy_trans()

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

static

Definition at line 3203 of file pbx_dundi.c.

References ast_eid_cmp(), ast_eid_to_str(), ast_free, AST_LIST_EMPTY, AST_LIST_REMOVE, AST_LIST_TRAVERSE, ast_log, ast_malloc, AST_SCHED_DEL, ast_set_flag, ast_strlen_zero, ast_test_flag, ast_tvdiff_ms(), ast_tvnow(), dundi_transaction::autokillid, dundi_peer::avgms, dundi_request::dcontext, destroy_packets(), DUNDI_TIMING_HISTORY, dundi_peer::eid, errno, FLAG_DEAD, FLAG_ISQUAL, FLAG_ISREG, FLAG_STOREHIST, dundi_peer::lastms, dundi_transaction::lasttrans, permission::list, LOG_NOTICE, LOG_WARNING, dundi_peer::lookups, dundi_peer::lookuptimes, dundi_peer::maxms, NULL, dundi_request::number, dundi_transaction::packets, dundi_transaction::parent, dundi_request::pfds, dundi_peer::qualtrans, dundi_peer::qualtx, dundi_peer::regtrans, dundi_transaction::start, dundi_transaction::them_eid, dundi_transaction::thread, and dundi_request::trans.

Referenced by abort_request(), destroy_peer(), do_autokill(), do_register(), dundi_lookup_local(), dundi_lookup_thread(), dundi_precache_thread(), dundi_query_thread(), dundi_rexmit(), handle_frame(), precache_trans(), precache_transactions(), and qualify_peer().

{
 struct dundi_peer *peer;
 int ms;
 int x;
 int cnt;
 char eid_str[20];
 if (ast_test_flag(trans, FLAG_ISREG | FLAG_ISQUAL | FLAG_STOREHIST)) {
 AST_LIST_TRAVERSE(&peers, peer, list) {
 if (peer->regtrans == trans)
 peer->regtrans = NULL;
 if (peer->qualtrans == trans) {
 if (fromtimeout) {
 if (peer->lastms > -1)
 ast_log(LOG_NOTICE, "Peer '%s' has become UNREACHABLE!\n", ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 peer->lastms = -1;
 } else {
 ms = ast_tvdiff_ms(ast_tvnow(), peer->qualtx);
 if (ms < 1)
 ms = 1;
 if (ms < peer->maxms) {
 if ((peer->lastms >= peer->maxms) || (peer->lastms < 0))
 ast_log(LOG_NOTICE, "Peer '%s' has become REACHABLE!\n", ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 } else if (peer->lastms < peer->maxms) {
 ast_log(LOG_NOTICE, "Peer '%s' has become TOO LAGGED (%d ms)\n", ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid), ms);
 }
 peer->lastms = ms;
 }
 peer->qualtrans = NULL;
 }
 if (ast_test_flag(trans, FLAG_STOREHIST)) {
 if (trans->parent && !ast_strlen_zero(trans->parent->number)) {
 if (!ast_eid_cmp(&trans->them_eid, &peer->eid)) {
 peer->avgms = 0;
 cnt = 0;
 ast_free(peer->lookups[DUNDI_TIMING_HISTORY - 1]);
 for (x=DUNDI_TIMING_HISTORY-1;x>0;x--) {
 peer->lookuptimes[x] = peer->lookuptimes[x-1];
 peer->lookups[x] = peer->lookups[x-1];
 if (peer->lookups[x]) {
 peer->avgms += peer->lookuptimes[x];
 cnt++;
 }
 }
 peer->lookuptimes[0] = ast_tvdiff_ms(ast_tvnow(), trans->start);
 peer->lookups[0] = ast_malloc(strlen(trans->parent->number) + strlen(trans->parent->dcontext) + 2);
 if (peer->lookups[0]) {
 sprintf(peer->lookups[0], "%s@%s", trans->parent->number, trans->parent->dcontext);
 peer->avgms += peer->lookuptimes[0];
 cnt++;
 }
 if (cnt)
 peer->avgms /= cnt;
 }
 }
 }
 }
 }
 if (trans->parent) {
 /* Unlink from parent if appropriate */
 AST_LIST_REMOVE(&trans->parent->trans, trans, parentlist);
 if (AST_LIST_EMPTY(&trans->parent->trans)) {
 /* Wake up sleeper */
 if (trans->parent->pfds[1] > -1) {
 if (write(trans->parent->pfds[1], "killa!", 6) < 0) {
 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
 }
 }
 }
 }
 /* Unlink from all trans */
 AST_LIST_REMOVE(&alltrans, trans, all);
 destroy_packets(&trans->packets);
 destroy_packets(&trans->lasttrans);
 AST_SCHED_DEL(sched, trans->autokillid);
 if (trans->thread) {
 /* If used by a thread, mark as dead and be done */
 ast_set_flag(trans, FLAG_DEAD);
 } else
 ast_free(trans);
}

discover_transactions()

static int discover_transactions ( struct dundi_request *  dr )

static

Definition at line 3525 of file pbx_dundi.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, dundi_discover(), dundi_transaction::parentlist, and dundi_request::trans.

Referenced by dundi_lookup_internal().

{
 struct dundi_transaction *trans;
 AST_LIST_LOCK(&peers);
 AST_LIST_TRAVERSE(&dr->trans, trans, parentlist) {
 dundi_discover(trans);
 }
 AST_LIST_UNLOCK(&peers);
 return 0;
}

do_autokill()

static int do_autokill ( const void *  data )

static

Definition at line 3380 of file pbx_dundi.c.

References ast_eid_to_str(), ast_log, dundi_transaction::autokillid, destroy_trans(), LOG_NOTICE, and dundi_transaction::them_eid.

Referenced by dundi_discover(), dundi_query(), and precache_trans().

{
 struct dundi_transaction *trans = (struct dundi_transaction *)data;
 char eid_str[20];
 ast_log(LOG_NOTICE, "Transaction to '%s' took too long to ACK, destroying\n",
 ast_eid_to_str(eid_str, sizeof(eid_str), &trans->them_eid));
 trans->autokillid = -1;
 destroy_trans(trans, 0); /* We could actually set it to 1 instead of 0, but we won't ;-) */
 return 0;
}

do_qualify()

static int do_qualify ( const void *  data )

static

Definition at line 4557 of file pbx_dundi.c.

References qualify_peer(), and dundi_peer::qualifyid.

Referenced by qualify_peer().

{
 struct dundi_peer *peer = (struct dundi_peer *)data;
 peer->qualifyid = -1;
 qualify_peer(peer, 0);
 return 0;
}

do_register()

static int do_register ( const void *  data )

static

Definition at line 4531 of file pbx_dundi.c.

References ast_debug, ast_eid_to_str(), ast_log, ast_sched_add(), ast_set_flag, create_transaction(), destroy_trans(), DUNDI_COMMAND_REGREQ, DUNDI_DEFAULT_VERSION, dundi_ie_append_eid(), dundi_ie_append_short(), DUNDI_IE_EID, DUNDI_IE_EXPIRATION, DUNDI_IE_VERSION, dundi_send(), dundi_peer::eid, FLAG_ISREG, LOG_NOTICE, dundi_peer::registerid, dundi_peer::regtrans, dundi_transaction::us_eid, and dundi_peer::us_eid.

Referenced by build_peer().

{
 struct dundi_ie_data ied;
 struct dundi_peer *peer = (struct dundi_peer *)data;
 char eid_str[20];
 char eid_str2[20];
 ast_debug(1, "Register us as '%s' to '%s'\n", ast_eid_to_str(eid_str, sizeof(eid_str), &peer->us_eid), ast_eid_to_str(eid_str2, sizeof(eid_str2), &peer->eid));
 peer->registerid = ast_sched_add(sched, default_expiration * 1000, do_register, data);
 /* Destroy old transaction if there is one */
 if (peer->regtrans)
 destroy_trans(peer->regtrans, 0);
 peer->regtrans = create_transaction(peer);
 if (peer->regtrans) {
 ast_set_flag(peer->regtrans, FLAG_ISREG);
 memset(&ied, 0, sizeof(ied));
 dundi_ie_append_short(&ied, DUNDI_IE_VERSION, DUNDI_DEFAULT_VERSION);
 dundi_ie_append_eid(&ied, DUNDI_IE_EID, &peer->regtrans->us_eid);
 dundi_ie_append_short(&ied, DUNDI_IE_EXPIRATION, default_expiration);
 dundi_send(peer->regtrans, DUNDI_COMMAND_REGREQ, 0, 0, &ied);

 } else
 ast_log(LOG_NOTICE, "Unable to create new transaction for registering to '%s'!\n", ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));

 return 0;
}

do_register_expire()

static int do_register_expire ( const void *  data )

static

Note

Called with the peers list already locked

Definition at line 1321 of file pbx_dundi.c.

References dundi_peer::addr, ast_db_del(), ast_debug, ast_eid_to_str(), ast_sockaddr_setnull(), dundi_eid_to_str_short(), dundi_peer::eid, dundi_peer::lastms, and dundi_peer::registerexpire.

Referenced by handle_command_response(), and populate_addr().

{
 struct dundi_peer *peer = (struct dundi_peer *)data;
 char eid_str[20];

 ast_debug(1, "Register expired for '%s'\n", ast_eid_to_str(eid_str, sizeof(eid_str), &peer->eid));
 ast_db_del("dundi/dpeers", dundi_eid_to_str_short(eid_str, sizeof(eid_str), &peer->eid));
 peer->registerexpire = -1;
 peer->lastms = 0;
 ast_sockaddr_setnull(&peer->addr);
 return 0;
}

drds_destroy()

static void drds_destroy ( struct dundi_result_datastore *  drds )

static

Definition at line 4199 of file pbx_dundi.c.

References ast_free.

Referenced by drds_destroy_cb(), and dundi_query_read().

{
 ast_free(drds);
}

drds_destroy_cb()

static void drds_destroy_cb ( void *  data )

static

Definition at line 4204 of file pbx_dundi.c.

References drds_destroy().

{
 struct dundi_result_datastore *drds = data;
 drds_destroy(drds);
}

dundi_ack()

static int dundi_ack ( struct dundi_transaction *  trans, int  final  )

static

Definition at line 451 of file pbx_dundi.c.

References DUNDI_COMMAND_ACK, dundi_send(), and NULL.

Referenced by handle_command_response(), and handle_frame().

{
 return dundi_send(trans, DUNDI_COMMAND_ACK, 0, final, NULL);
}

dundi_answer_entity()

static int dundi_answer_entity ( struct dundi_transaction *  trans, struct dundi_ies *  ies, char *  ccontext  )

static

Definition at line 809 of file pbx_dundi.c.

References ast_calloc, ast_copy_string(), ast_debug, ast_eid_cmp(), ast_eid_to_str(), ast_free, ast_log, ast_pthread_create_detached, dundi_ies::called_context, dundi_query_state::called_context, DUNDI_CAUSE_GENERAL, DUNDI_COMMAND_EIDRESPONSE, dundi_ie_append_cause(), DUNDI_IE_CAUSE, dundi_query_thread(), dundi_send(), dundi_ies::eidcount, dundi_ies::eids, dundi_query_state::eids, dundi_query_state::fluffy, LOG_WARNING, NULL, dundi_ies::reqeid, dundi_query_state::reqeid, dundi_transaction::thread, dundi_query_state::trans, dundi_ies::ttl, and dundi_query_state::ttl.

Referenced by handle_command_response().

{
 struct dundi_query_state *st;
 int totallen;
 int x;
 int skipfirst=0;
 char eid_str[20];
 char *s;
 pthread_t lookupthread;

 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 (!ast_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_debug(1, "Answering EID query for '%s@%s'!\n", ast_eid_to_str(eid_str, sizeof(eid_str), ies->reqeid), ies->called_context);

 trans->thread = 1;
 if (ast_pthread_create_detached(&lookupthread, NULL, dundi_query_thread, st)) {
 struct dundi_ie_data ied = { 0, };
 trans->thread = 0;
 ast_log(LOG_WARNING, "Unable to create thread!\n");
 ast_free(st);
 dundi_ie_append_cause(&ied, DUNDI_IE_CAUSE, DUNDI_CAUSE_GENERAL, "Out of threads");
 dundi_send(trans, DUNDI_COMMAND_EIDRESPONSE, 0, 1, &ied);
 return -1;
 }
 } else {
 struct dundi_ie_data ied = { 0, };
 dundi_ie_append_cause(&ied, DUNDI_IE_CAUSE, DUNDI_CAUSE_GENERAL, "Out of memory");
 dundi_send(trans, DUNDI_COMMAND_EIDRESPONSE, 0, 1, &ied);
 return -1;
 }
 return 0;
}

dundi_answer_query()

static int dundi_answer_query ( struct dundi_transaction *  trans, struct dundi_ies *  ies, char *  ccontext  )

static

Definition at line 1087 of file pbx_dundi.c.

References ast_calloc, ast_copy_string(), ast_debug, ast_eid_cmp(), ast_free, AST_LIST_TRAVERSE, ast_log, ast_pthread_create_detached, dundi_ies::called_context, dundi_query_state::called_context, dundi_ies::called_number, dundi_query_state::called_number, dundi_ies::cbypass, dundi_mapping::dcontext, dundi_query_state::directs, DUNDI_CAUSE_GENERAL, DUNDI_COMMAND_DPRESPONSE, dundi_ie_append_cause(), DUNDI_IE_CAUSE, dundi_lookup_thread(), dundi_send(), dundi_ies::eid_direct, dundi_ies::eidcount, dundi_ies::eids, dundi_query_state::eids, dundi_query_state::fluffy, permission::list, dundi_mapping::list, LOG_WARNING, dundi_query_state::maps, dundi_mapping::next, dundi_query_state::nocache, NULL, dundi_query_state::nummaps, dundi_transaction::thread, dundi_query_state::trans, dundi_ies::ttl, and dundi_query_state::ttl.

Referenced by handle_command_response().

{
 struct dundi_query_state *st;
 int totallen;
 int x;
 struct dundi_ie_data ied;
 char *s;
 struct dundi_mapping *cur;
 int mapcount = 0;
 int skipfirst = 0;

 pthread_t lookupthread;
 totallen = sizeof(struct dundi_query_state);
 /* Count matching map entries */
 AST_LIST_TRAVERSE(&mappings, cur, list) {
 if (!strcasecmp(cur->dcontext, ccontext))
 mapcount++;
 }
 /* If no maps, return -1 immediately */
 if (!mapcount)
 return -1;

 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 (!ast_eid_cmp(ies->eids[0], ies->eids[ies->eidcount - 1]))
 skipfirst = 1;
 }

 totallen += mapcount * sizeof(struct dundi_mapping);
 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));
 ast_copy_string(st->called_number, ies->called_number, sizeof(st->called_number));
 st->trans = trans;
 st->ttl = ies->ttl - 1;
 st->nocache = ies->cbypass;
 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];
 st->directs[x-skipfirst] = ies->eid_direct[x];
 s += sizeof(dundi_eid);
 }
 /* Append mappings */
 x = 0;
 st->maps = (struct dundi_mapping *)s;
 AST_LIST_TRAVERSE(&mappings, cur, list) {
 if (!strcasecmp(cur->dcontext, ccontext)) {
 if (x < mapcount) {
 st->maps[x] = *cur;
 st->maps[x].list.next = NULL;
 x++;
 }
 }
 }
 st->nummaps = mapcount;
 ast_debug(1, "Answering query for '%s@%s'!\n", ies->called_number, ies->called_context);
 trans->thread = 1;
 if (ast_pthread_create_detached(&lookupthread, NULL, dundi_lookup_thread, st)) {
 trans->thread = 0;
 ast_log(LOG_WARNING, "Unable to create thread!\n");
 ast_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_DPRESPONSE, 0, 1, &ied);
 return -1;
 }
 } else {
 ast_log(LOG_WARNING, "Out of memory!\n");
 memset(&ied, 0, sizeof(ied));
 dundi_ie_append_cause(&ied, DUNDI_IE_CAUSE, DUNDI_CAUSE_GENERAL, "Out of memory");
 dundi_send(trans, DUNDI_COMMAND_DPRESPONSE, 0, 1, &ied);
 return -1;
 }
 return 0;
}

dundi_canmatch()

static int dundi_canmatch ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  callerid, const char *  data  )

static

Definition at line 4827 of file pbx_dundi.c.

References DUNDI_FLAG_CANMATCH, and dundi_helper().

{
 return dundi_helper(chan, context, exten, priority, data, DUNDI_FLAG_CANMATCH);
}

dundi_debug_output()

static void dundi_debug_output ( const char *  data )

static

Definition at line 356 of file pbx_dundi.c.

References ast_verbose().

Referenced by load_module().

{
 if (dundidebug)
 ast_verbose("%s", data);
}

dundi_decrypt()

static struct dundi_hdr* dundi_decrypt ( struct dundi_transaction *  trans, unsigned char *  dst, int *  dstlen, struct dundi_hdr *  ohdr, struct dundi_encblock *  src, int  srclen  )

static

Definition at line 1406 of file pbx_dundi.c.

References ast_alloca, ast_debug, dundi_transaction::dcx, decrypt_memcpy(), dundi_encblock::encdata, dundi_encblock::iv, and NULL.

Referenced by handle_command_response().

{
 int space = *dstlen;
 unsigned long bytes;
 struct dundi_hdr *h;
 unsigned char *decrypt_space;
 decrypt_space = ast_alloca(srclen);
 decrypt_memcpy(decrypt_space, src->encdata, srclen, src->iv, &trans->dcx);
 /* Setup header */
 h = (struct dundi_hdr *)dst;
 *h = *ohdr;
 bytes = space - 6;
 if (uncompress(dst + 6, &bytes, decrypt_space, srclen) != Z_OK) {
 ast_debug(1, "Ouch, uncompress failed :(\n");
 return NULL;
 }
 /* Update length */
 *dstlen = bytes + 6;
 /* Return new header */
 return h;
}

dundi_discover()

static int dundi_discover ( struct dundi_transaction *  trans )

static

Definition at line 3413 of file pbx_dundi.c.

References ast_log, ast_sched_add(), dundi_transaction::autokillid, dundi_transaction::autokilltimeout, dundi_request::cbypass, dundi_request::dcontext, do_autokill(), DUNDI_COMMAND_DPDISCOVER, DUNDI_DEFAULT_VERSION, dundi_eid_zero(), dundi_ie_append(), dundi_ie_append_eid(), dundi_ie_append_eid_appropriately(), dundi_ie_append_short(), dundi_ie_append_str(), DUNDI_IE_CACHEBYPASS, DUNDI_IE_CALLED_CONTEXT, DUNDI_IE_CALLED_NUMBER, DUNDI_IE_EID_DIRECT, DUNDI_IE_TTL, DUNDI_IE_VERSION, dundi_send(), dundi_transaction::eidcount, dundi_transaction::eids, LOG_WARNING, dundi_request::number, dundi_transaction::parent, dundi_transaction::ttl, and dundi_transaction::us_eid.

Referenced by discover_transactions().

{
 struct dundi_ie_data ied;
 int x;
 if (!trans->parent) {
 ast_log(LOG_WARNING, "Tried to discover a transaction with no parent?!?\n");
 return -1;
 }
 memset(&ied, 0, sizeof(ied));
 dundi_ie_append_short(&ied, DUNDI_IE_VERSION, DUNDI_DEFAULT_VERSION);
 if (!dundi_eid_zero(&trans->us_eid))
 dundi_ie_append_eid(&ied, DUNDI_IE_EID_DIRECT, &trans->us_eid);
 for (x=0;x<trans->eidcount;x++)
 dundi_ie_append_eid_appropriately(&ied, trans->parent->dcontext, &trans->eids[x], &trans->us_eid);
 dundi_ie_append_str(&ied, DUNDI_IE_CALLED_NUMBER, trans->parent->number);
 dundi_ie_append_str(&ied, DUNDI_IE_CALLED_CONTEXT, trans->parent->dcontext);
 dundi_ie_append_short(&ied, DUNDI_IE_TTL, trans->ttl);
 if (trans->parent->cbypass)
 dundi_ie_append(&ied, DUNDI_IE_CACHEBYPASS);
 if (trans->autokilltimeout)
 trans->autokillid = ast_sched_add(sched, trans->autokilltimeout, do_autokill, trans);
 return dundi_send(trans, DUNDI_COMMAND_DPDISCOVER, 0, 0, &ied);
}

dundi_do_lookup()

static char* dundi_do_lookup ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2456 of file pbx_dundi.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_copy_string(), ast_tvdiff_ms(), ast_tvnow(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, context, dundi_result::dest, dundi_flags2str(), dundi_lookup(), dundi_result::eid_str, dundi_result::expiration, ast_cli_args::fd, NULL, sort_results(), dundi_result::tech, tmp(), ast_cli_entry::usage, and dundi_result::weight.

{
 int res;
 char tmp[256];
 char fs[80] = "";
 char *context;
 int x;
 int bypass = 0;
 struct dundi_result dr[MAX_RESULTS];
 struct timeval start;
 switch (cmd) {
 case CLI_INIT:
 e->command = "dundi lookup";
 e->usage =
 "Usage: dundi lookup <number>[@context] [bypass]\n"
 " Lookup the given number within the given DUNDi context\n"
 "(or e164 if none is specified). Bypasses cache if 'bypass'\n"
 "keyword is specified.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if ((a->argc < 3) || (a->argc > 4)) {
 return CLI_SHOWUSAGE;
 }
 if (a->argc > 3) {
 if (!strcasecmp(a->argv[3], "bypass")) {
 bypass=1;
 } else {
 return CLI_SHOWUSAGE;
 }
 }
 ast_copy_string(tmp, a->argv[2], sizeof(tmp));
 context = strchr(tmp, '@');
 if (context) {
 *context = '\0';
 context++;
 }
 start = ast_tvnow();
 res = dundi_lookup(dr, MAX_RESULTS, NULL, context, tmp, bypass);

 if (res < 0)
 ast_cli(a->fd, "DUNDi lookup returned error.\n");
 else if (!res)
 ast_cli(a->fd, "DUNDi lookup returned no results.\n");
 else
 sort_results(dr, res);
 for (x=0;x<res;x++) {
 ast_cli(a->fd, "%3d. %5d %s/%s (%s)\n", x + 1, dr[x].weight, dr[x].tech, dr[x].dest, dundi_flags2str(fs, sizeof(fs), dr[x].flags));
 ast_cli(a->fd, " from %s, expires in %d s\n", dr[x].eid_str, dr[x].expiration);
 }
 ast_cli(a->fd, "DUNDi lookup completed in %" PRIi64 " ms\n", ast_tvdiff_ms(ast_tvnow(), start));
 return CLI_SUCCESS;
}

dundi_do_precache()

static char* dundi_do_precache ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2512 of file pbx_dundi.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_copy_string(), ast_tvdiff_ms(), ast_tvnow(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, context, dundi_precache(), ast_cli_args::fd, NULL, tmp(), and ast_cli_entry::usage.

{
 int res;
 char tmp[256];
 char *context;
 struct timeval start;
 switch (cmd) {
 case CLI_INIT:
 e->command = "dundi precache";
 e->usage =
 "Usage: dundi precache <number>[@context]\n"
 " Lookup the given number within the given DUNDi context\n"
 "(or e164 if none is specified) and precaches the results to any\n"
 "upstream DUNDi push servers.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }
 if ((a->argc < 3) || (a->argc > 3)) {
 return CLI_SHOWUSAGE;
 }
 ast_copy_string(tmp, a->argv[2], sizeof(tmp));
 context = strchr(tmp, '@');
 if (context) {
 *context = '\0';
 context++;
 }
 start = ast_tvnow();
 res = dundi_precache(context, tmp);

 if (res < 0)
 ast_cli(a->fd, "DUNDi precache returned error.\n");
 else if (!res)
 ast_cli(a->fd, "DUNDi precache returned no error.\n");
 ast_cli(a->fd, "DUNDi lookup completed in %" PRIi64 " ms\n", ast_tvdiff_ms(ast_tvnow(), start));
 return CLI_SUCCESS;
}

dundi_do_query()

static char* dundi_do_query ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2550 of file pbx_dundi.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_copy_string(), ast_str_to_eid(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, context, dundi_entity_info::country, dundi_query_eid(), dundi_entity_info::email, ast_cli_args::fd, dundi_entity_info::ipaddr, dundi_entity_info::locality, NULL, dundi_entity_info::org, dundi_entity_info::orgunit, dundi_entity_info::phone, dundi_entity_info::stateprov, tmp(), and ast_cli_entry::usage.

{
 int res;
 char tmp[256];
 char *context;
 dundi_eid eid;
 struct dundi_entity_info dei;
 switch (cmd) {
 case CLI_INIT:
 e->command = "dundi query";
 e->usage =
 "Usage: dundi query <entity>[@context]\n"
 " Attempts to retrieve contact information for a specific\n"
 "DUNDi entity identifier (EID) within a given DUNDi context (or\n"
 "e164 if none is specified).\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }
 if ((a->argc < 3) || (a->argc > 3)) {
 return CLI_SHOWUSAGE;
 }
 if (ast_str_to_eid(&eid, a->argv[2])) {
 ast_cli(a->fd, "'%s' is not a valid EID!\n", a->argv[2]);
 return CLI_SHOWUSAGE;
 }
 ast_copy_string(tmp, a->argv[2], sizeof(tmp));
 context = strchr(tmp, '@');
 if (context) {
 *context = '\0';
 context++;
 }
 res = dundi_query_eid(&dei, context, eid);
 if (res < 0)
 ast_cli(a->fd, "DUNDi Query EID returned error.\n");
 else if (!res)
 ast_cli(a->fd, "DUNDi Query EID returned no results.\n");
 else {
 ast_cli(a->fd, "DUNDi Query EID succeeded:\n");
 ast_cli(a->fd, "Department: %s\n", dei.orgunit);
 ast_cli(a->fd, "Organization: %s\n", dei.org);
 ast_cli(a->fd, "City/Locality: %s\n", dei.locality);
 ast_cli(a->fd, "State/Province: %s\n", dei.stateprov);
 ast_cli(a->fd, "Country: %s\n", dei.country);
 ast_cli(a->fd, "E-mail: %s\n", dei.email);
 ast_cli(a->fd, "Phone: %s\n", dei.phone);
 ast_cli(a->fd, "IP Address: %s\n", dei.ipaddr);
 }
 return CLI_SUCCESS;
}

dundi_encrypt()

static int dundi_encrypt ( struct dundi_transaction *  trans, struct dundi_packet *  pack  )

static

Definition at line 1428 of file pbx_dundi.c.

References ast_alloca, ast_debug, ast_log, ast_set_flag, ast_test_flag, dundi_ie_data::buf, build_iv(), dundi_hdr::cmdflags, dundi_hdr::cmdresp, dundi_packet::data, dundi_packet::datalen, dundi_transaction::dcx, DUNDI_COMMAND_ENCRYPT, dundi_ie_append_eid(), dundi_ie_append_encdata(), dundi_ie_append_int(), dundi_ie_append_raw(), DUNDI_IE_EID, DUNDI_IE_ENCDATA, DUNDI_IE_KEYCRC32, DUNDI_IE_SHAREDKEY, DUNDI_IE_SIGNATURE, dundi_transaction::ecx, encrypt_memcpy(), find_peer(), FLAG_SENDFULLKEY, dundi_packet::h, dundi_hdr::ies, dundi_hdr::iseqno, len(), LOG_NOTICE, NULL, dundi_hdr::oseqno, dundi_ie_data::pos, dundi_peer::sentfullkey, dundi_transaction::them_eid, dundi_peer::txenckey, update_key(), dundi_peer::us_dcx, dundi_peer::us_ecx, dundi_transaction::us_eid, and dundi_peer::us_keycrc32.

Referenced by dundi_send().

{
 unsigned char *compress_space;
 int len;
 int res;
 unsigned long bytes;
 struct dundi_ie_data ied;
 struct dundi_peer *peer;
 unsigned char iv[16];
 len = pack->datalen + pack->datalen / 100 + 42;
 compress_space = ast_alloca(len);
 memset(compress_space, 0, len);
 /* We care about everthing save the first 6 bytes of header */
 bytes = len;
 res = compress(compress_space, &bytes, pack->data + 6, pack->datalen - 6);
 if (res != Z_OK) {
 ast_debug(1, "Ouch, compression failed!\n");
 return -1;
 }
 memset(&ied, 0, sizeof(ied));
 /* Say who we are */
 if (!pack->h->iseqno && !pack->h->oseqno) {
 /* Need the key in the first copy */
 if (!(peer = find_peer(&trans->them_eid)))
 return -1;
 if (update_key(peer))
 return -1;
 if (!peer->sentfullkey)
 ast_set_flag(trans, FLAG_SENDFULLKEY);
 /* Append key data */
 dundi_ie_append_eid(&ied, DUNDI_IE_EID, &trans->us_eid);
 if (ast_test_flag(trans, FLAG_SENDFULLKEY)) {
 dundi_ie_append_raw(&ied, DUNDI_IE_SHAREDKEY, peer->txenckey, 128);
 dundi_ie_append_raw(&ied, DUNDI_IE_SIGNATURE, peer->txenckey + 128, 128);
 } else {
 dundi_ie_append_int(&ied, DUNDI_IE_KEYCRC32, peer->us_keycrc32);
 }
 /* Setup contexts */
 trans->ecx = peer->us_ecx;
 trans->dcx = peer->us_dcx;

 /* We've sent the full key */
 peer->sentfullkey = 1;
 }
 /* Build initialization vector */
 build_iv(iv);
 /* Add the field, rounded up to 16 bytes */
 dundi_ie_append_encdata(&ied, DUNDI_IE_ENCDATA, iv, NULL, ((bytes + 15) / 16) * 16);
 /* Copy the data */
 if ((ied.pos + bytes) >= sizeof(ied.buf)) {
 ast_log(LOG_NOTICE, "Final packet too large!\n");
 return -1;
 }
 encrypt_memcpy(ied.buf + ied.pos, compress_space, bytes, iv, &trans->ecx);
 ied.pos += ((bytes + 15) / 16) * 16;
 /* Reconstruct header */
 pack->datalen = sizeof(struct dundi_hdr);
 pack->h->cmdresp = DUNDI_COMMAND_ENCRYPT;
 pack->h->cmdflags = 0;
 memcpy(pack->h->ies, ied.buf, ied.pos);
 pack->datalen += ied.pos;
 return 0;
}

dundi_error_output()

static void dundi_error_output ( const char *  data )

static

Definition at line 362 of file pbx_dundi.c.

References ast_log, and LOG_WARNING.

Referenced by load_module().

{
 ast_log(LOG_WARNING, "%s", data);
}

dundi_exec()

static int dundi_exec ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  callerid, const char *  data  )

static

Definition at line 4832 of file pbx_dundi.c.

References ast_channel_exten(), ast_channel_macroexten(), ast_log, ast_strlen_zero, ast_test_flag, context, DUNDI_FLAG_EXISTS, dundi_lookup(), LOG_NOTICE, LOG_WARNING, pbx_builtin_getvar_helper(), pbx_exec(), pbx_findapp(), S_OR, and sort_results().

{
 struct dundi_result results[MAX_RESULTS];
 int res;
 int x=0;
 char req[1024];
 const char *dundiargs;
 struct ast_app *dial;

 if (!strncasecmp(context, "macro-", 6)) {
 if (!chan) {
 ast_log(LOG_NOTICE, "Can't use macro mode without a channel!\n");
 return -1;
 }
 /* If done as a macro, use macro extension */
 if (!strcasecmp(exten, "s")) {
 exten = pbx_builtin_getvar_helper(chan, "ARG1");
 if (ast_strlen_zero(exten))
 exten = ast_channel_macroexten(chan);
 if (ast_strlen_zero(exten))
 exten = ast_channel_exten(chan);
 if (ast_strlen_zero(exten)) {
 ast_log(LOG_WARNING, "Called in Macro mode with no ARG1 or MACRO_EXTEN?\n");
 return -1;
 }
 }
 if (ast_strlen_zero(data))
 data = "e164";
 } else {
 if (ast_strlen_zero(data))
 data = context;
 }
 res = dundi_lookup(results, MAX_RESULTS, chan, data, exten, 0);
 if (res > 0) {
 sort_results(results, res);
 for (x=0;x<res;x++) {
 if (ast_test_flag(results + x, DUNDI_FLAG_EXISTS)) {
 if (!--priority)
 break;
 }
 }
 }
 if (x < res) {
 /* Got a hit! */
 dundiargs = pbx_builtin_getvar_helper(chan, "DUNDIDIALARGS");
 snprintf(req, sizeof(req), "%s/%s,,%s", results[x].tech, results[x].dest,
 S_OR(dundiargs, ""));
 dial = pbx_findapp("Dial");
 if (dial)
 res = pbx_exec(chan, dial, req);
 } else
 res = -1;
 return res;
}

dundi_exists()

static int dundi_exists ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  callerid, const char *  data  )

static

Definition at line 4822 of file pbx_dundi.c.

References DUNDI_FLAG_EXISTS, and dundi_helper().

{
 return dundi_helper(chan, context, exten, priority, data, DUNDI_FLAG_EXISTS);
}

dundi_flush()

static char* dundi_flush ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2357 of file pbx_dundi.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_db_deltree(), ast_free, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, dundi_peer::avgms, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, DUNDI_TIMING_HISTORY, ast_cli_args::fd, permission::list, dundi_peer::lookups, dundi_peer::lookuptimes, NULL, and ast_cli_entry::usage.

{
 int stats = 0;
 switch (cmd) {
 case CLI_INIT:
 e->command = "dundi flush [stats]";
 e->usage =
 "Usage: dundi flush [stats]\n"
 " Flushes DUNDi answer cache, used primarily for debug. If\n"
 "'stats' is present, clears timer statistics instead of normal\n"
 "operation.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }
 if ((a->argc < 2) || (a->argc > 3)) {
 return CLI_SHOWUSAGE;
 }
 if (a->argc > 2) {
 if (!strcasecmp(a->argv[2], "stats")) {
 stats = 1;
 } else {
 return CLI_SHOWUSAGE;
 }
 }
 if (stats) {
 /* Flush statistics */
 struct dundi_peer *p;
 int x;
 AST_LIST_LOCK(&peers);
 AST_LIST_TRAVERSE(&peers, p, list) {
 for (x = 0;x < DUNDI_TIMING_HISTORY; x++) {
 ast_free(p->lookups[x]);
 p->lookups[x] = NULL;
 p->lookuptimes[x] = 0;
 }
 p->avgms = 0;
 }
 AST_LIST_UNLOCK(&peers);
 } else {
 ast_db_deltree("dundi/cache", NULL);
 ast_cli(a->fd, "DUNDi Cache Flushed\n");
 }
 return CLI_SUCCESS;
}

dundi_helper()

static int dundi_helper ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority, const char *  data, int  flag  )

static

Definition at line 4783 of file pbx_dundi.c.

References ast_channel_exten(), ast_channel_macroexten(), ast_log, ast_strlen_zero, ast_test_flag, context, dundi_lookup(), LOG_NOTICE, LOG_WARNING, and pbx_builtin_getvar_helper().

Referenced by dundi_canmatch(), dundi_exists(), and dundi_matchmore().

{
 struct dundi_result results[MAX_RESULTS];
 int res;
 int x;
 int found = 0;
 if (!strncasecmp(context, "macro-", 6)) {
 if (!chan) {
 ast_log(LOG_NOTICE, "Can't use macro mode without a channel!\n");
 return -1;
 }
 /* If done as a macro, use macro extension */
 if (!strcasecmp(exten, "s")) {
 exten = pbx_builtin_getvar_helper(chan, "ARG1");
 if (ast_strlen_zero(exten))
 exten = ast_channel_macroexten(chan);
 if (ast_strlen_zero(exten))
 exten = ast_channel_exten(chan);
 if (ast_strlen_zero(exten)) {
 ast_log(LOG_WARNING, "Called in Macro mode with no ARG1 or MACRO_EXTEN?\n");
 return -1;
 }
 }
 if (ast_strlen_zero(data))
 data = "e164";
 } else {
 if (ast_strlen_zero(data))
 data = context;
 }
 res = dundi_lookup(results, MAX_RESULTS, chan, data, exten, 0);
 for (x=0;x<res;x++) {
 if (ast_test_flag(results + x, flag))
 found++;
 }
 if (found >= priority)
 return 1;
 return 0;
}

dundi_ie_append_eid_appropriately()

static void dundi_ie_append_eid_appropriately ( struct dundi_ie_data *  ied, char *  context, dundi_eid *  eid, dundi_eid *  us  )

static

Definition at line 3391 of file pbx_dundi.c.

References ast_eid_cmp(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, dundi_ie_append_eid(), DUNDI_IE_EID, DUNDI_IE_EID_DIRECT, dundi_peer::eid, has_permission(), dundi_peer::include, and permission::list.

Referenced by dundi_discover().

{
 struct dundi_peer *p;
 if (!ast_eid_cmp(eid, us)) {
 dundi_ie_append_eid(ied, DUNDI_IE_EID_DIRECT, eid);
 return;
 }
 AST_LIST_LOCK(&peers);
 AST_LIST_TRAVERSE(&peers, p, list) {
 if (!ast_eid_cmp(&p->eid, eid)) {
 if (has_permission(&p->include, context))
 dundi_ie_append_eid(ied, DUNDI_IE_EID_DIRECT, eid);
 else
 dundi_ie_append_eid(ied, DUNDI_IE_EID, eid);
 break;
 }
 }
 if (!p)
 dundi_ie_append_eid(ied, DUNDI_IE_EID, eid);
 AST_LIST_UNLOCK(&peers);
}

dundi_lookup()

int dundi_lookup	(	struct dundi_result *	result,
		int	maxret,
		struct ast_channel *	chan,
		const char *	dcontext,
		const char *	number,
		int	nocache
	)

Lookup the given number in the given dundi context. Lookup number in a given dundi context (if unspecified use e164), the given callerid (if specified) and return up to maxret results in the array specified.

Return values

the	number of results found.
-1	on a hangup of the channel.

Definition at line 3926 of file pbx_dundi.c.

References dundi_cache_time, DUNDI_HINT_DONT_ASK, DUNDI_HINT_UNAFFECTED, dundi_lookup_internal(), dundi_hint_metadata::flags, and NULL.

Referenced by dundi_do_lookup(), dundi_exec(), dundi_helper(), dundi_query_read(), and dundifunc_read().

{
 struct dundi_hint_metadata hmd;
 dundi_eid *avoid[1] = { NULL, };
 int direct[1] = { 0, };
 int expiration = dundi_cache_time;
 memset(&hmd, 0, sizeof(hmd));
 hmd.flags = DUNDI_HINT_DONT_ASK | DUNDI_HINT_UNAFFECTED;
 return dundi_lookup_internal(result, maxret, chan, dcontext, number, dundi_ttl, 0, &hmd, &expiration, cbypass, 0, NULL, avoid, direct);
}

dundi_lookup_internal()

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

Definition at line 3824 of file pbx_dundi.c.

References abort_request(), ast_channel_name(), ast_check_hangup(), ast_copy_string(), ast_debug, ast_eid_cmp(), ast_eid_to_str(), AST_LIST_EMPTY, ast_log, ast_set_flag_nonstd, ast_tvdiff_ms(), ast_tvnow(), ast_waitfor_n_fd(), avoid_crc32(), build_transactions(), cancel_request(), dundi_request::cbypass, check_request(), dundi_request::crc32, dundi_request::dcontext, discover_transactions(), dundi_request::dr, DUNDI_FLUFF_TIME, DUNDI_HINT_TTL_EXPIRED, DUNDI_TTL_TIME, errno, dundi_request::expiration, dundi_request::hmd, LOG_WARNING, dundi_request::maxcount, NULL, dundi_request::number, optimize_transactions(), order, dundi_request::pfds, register_request(), dundi_request::respcount, result, dundi_request::root_eid, dundi_request::trans, and unregister_request().

Referenced by dundi_lookup(), dundi_lookup_thread(), precache_trans(), and str2tech().

{
 int res;
 struct dundi_request dr, *pending;
 dundi_eid *rooteid=NULL;
 int x;
 int ttlms;
 int ms;
 int foundcache;
 int skipped=0;
 int order=0;
 char eid_str[20];
 struct timeval start;

 /* Don't do anthing for a hungup channel */
 if (chan && ast_check_hangup(chan))
 return 0;

 ttlms = DUNDI_FLUFF_TIME + ttl * DUNDI_TTL_TIME;

 for (x=0;avoid[x];x++)
 rooteid = avoid[x];
 /* Now perform real check */
 memset(&dr, 0, sizeof(dr));
 if (pipe(dr.pfds)) {
 ast_log(LOG_WARNING, "pipe failed: %s\n" , strerror(errno));
 return -1;
 }
 dr.dr = result;
 dr.hmd = hmd;
 dr.maxcount = maxret;
 dr.expiration = *expiration;
 dr.cbypass = cbypass;
 dr.crc32 = avoid_crc32(avoid);
 ast_copy_string(dr.dcontext, dcontext ? dcontext : "e164", sizeof(dr.dcontext));
 ast_copy_string(dr.number, number, sizeof(dr.number));
 if (rooteid)
 dr.root_eid = *rooteid;
 res = register_request(&dr, &pending);
 if (res) {
 /* Already a request */
 if (rooteid && !ast_eid_cmp(&dr.root_eid, &pending->root_eid)) {
 /* This is on behalf of someone else. Go ahead and close this out since
 they'll get their answer anyway. */
 ast_debug(1, "Oooh, duplicate request for '%s@%s' for '%s'\n",
 dr.number,dr.dcontext,ast_eid_to_str(eid_str, sizeof(eid_str), &dr.root_eid));
 close(dr.pfds[0]);
 close(dr.pfds[1]);
 return -2;
 } else {
 /* Wait for the cache to populate */
 ast_debug(1, "Waiting for similar request for '%s@%s' for '%s'\n",
 dr.number,dr.dcontext,ast_eid_to_str(eid_str, sizeof(eid_str), &pending->root_eid));
 start = ast_tvnow();
 while(check_request(pending) && (ast_tvdiff_ms(ast_tvnow(), start) < ttlms) && (!chan || !ast_check_hangup(chan))) {
 /* XXX Would be nice to have a way to poll/select here XXX */
 /* XXX this is a busy wait loop!!! */
 usleep(1);
 }
 /* Continue on as normal, our cache should kick in */
 }
 }
 /* Create transactions */
 do {
 order = skipped;
 skipped = 0;
 foundcache = 0;
 build_transactions(&dr, ttl, order, &foundcache, &skipped, blockempty, cbypass, modeselect, skip, avoid, direct);
 } while (skipped && !foundcache && AST_LIST_EMPTY(&dr.trans));
 /* If no TTL, abort and return 0 now after setting TTL expired hint. Couldn't
 do this earlier because we didn't know if we were going to have transactions
 or not. */
 if (!ttl) {
 ast_set_flag_nonstd(hmd, DUNDI_HINT_TTL_EXPIRED);
 abort_request(&dr);
 unregister_request(&dr);
 close(dr.pfds[0]);
 close(dr.pfds[1]);
 return 0;
 }

 /* Optimize transactions */
 optimize_transactions(&dr, order);
 /* Actually perform transactions */
 discover_transactions(&dr);
 /* Wait for transaction to come back */
 start = ast_tvnow();
 while (!AST_LIST_EMPTY(&dr.trans) && (ast_tvdiff_ms(ast_tvnow(), start) < ttlms) && (!chan || !ast_check_hangup(chan))) {
 ms = 100;
 ast_waitfor_n_fd(dr.pfds, 1, &ms, NULL);
 }
 if (chan && ast_check_hangup(chan))
 ast_debug(1, "Hrm, '%s' hungup before their query for %s@%s finished\n", ast_channel_name(chan), dr.number, dr.dcontext);
 cancel_request(&dr);
 unregister_request(&dr);
 res = dr.respcount;
 *expiration = dr.expiration;
 close(dr.pfds[0]);
 close(dr.pfds[1]);
 return res;
}

dundi_lookup_local()

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  )

static

Definition at line 578 of file pbx_dundi.c.

References ast_canmatch_extension(), ast_clear_flag, ast_clear_flag_nonstd, ast_copy_flags, ast_copy_string(), ast_eid_to_str(), ast_exists_extension(), AST_FLAGS_ALL, ast_ignore_pattern(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_HEAD, AST_LIST_REMOVE_HEAD, ast_matchmore_extension(), AST_MAX_EXTENSION, ast_set_flag, ast_strlen_zero, ast_test_flag, ast_var_assign, ast_var_delete(), dundi_result::dest, dundi_mapping::dest, destroy_trans(), dundi_cache_time, DUNDI_FLAG_CANMATCH, DUNDI_FLAG_EXISTS, DUNDI_FLAG_IGNOREPAT, DUNDI_FLAG_INTERNAL_NOPARTIAL, DUNDI_FLAG_MATCHMORE, DUNDI_HINT_DONT_ASK, dundi_result::eid, ast_var_t::entries, dundi_result::expiration, dundi_hint_metadata::exten, get_mapping_weight(), dundi_mapping::lcontext, NULL, dundi_mapping::options, pbx_substitute_variables_varshead(), dundi_result::tech, dundi_mapping::tech, tech2str(), dundi_result::techint, tmp(), and dundi_result::weight.

Referenced by dundi_lookup_thread(), and precache_trans().

{
 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].expiration = dundi_cache_time;
 ast_copy_string(dr[anscnt].tech, tech2str(map->tech), sizeof(dr[anscnt].tech));
 dr[anscnt].eid = *us_eid;
 ast_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);
 if ((newvariable = ast_var_assign("NUMBER", called_number))) {
 AST_LIST_INSERT_HEAD(&headp, newvariable, entries);
 }
 if ((newvariable = ast_var_assign("EID", dr[anscnt].eid_str))) {
 AST_LIST_INSERT_HEAD(&headp, newvariable, entries);
 }
 if ((newvariable = ast_var_assign("SECRET", cursecret))) {
 AST_LIST_INSERT_HEAD(&headp, newvariable, entries);
 }
 if ((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));
 dr[anscnt].weight = get_mapping_weight(map, &headp);
 while ((newvariable = AST_LIST_REMOVE_HEAD(&headp, entries)))
 ast_var_delete(newvariable);
 } else {
 dr[anscnt].dest[0] = '\0';
 dr[anscnt].weight = get_mapping_weight(map, NULL);
 }
 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;
}

dundi_lookup_thread()

static void* dundi_lookup_thread ( void *  data )

static

Definition at line 657 of file pbx_dundi.c.

References ast_debug, ast_eid_to_str(), ast_free, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_test_flag, ast_test_flag_nonstd, dundi_query_state::called_context, dundi_query_state::called_number, destroy_trans(), dundi_query_state::directs, dundi_cache_time, DUNDI_CAUSE_DUPLICATE, DUNDI_COMMAND_DPRESPONSE, DUNDI_HINT_DONT_ASK, DUNDI_HINT_UNAFFECTED, DUNDI_IE_ANSWER, dundi_ie_append_answer(), dundi_ie_append_cause(), dundi_ie_append_hint(), dundi_ie_append_short(), DUNDI_IE_CAUSE, DUNDI_IE_EXPIRATION, DUNDI_IE_HINT, dundi_lookup_internal(), dundi_lookup_local(), dundi_send(), dundi_query_state::eids, dundi_result::expiration, dundi_hint_metadata::exten, FLAG_DEAD, dundi_hint_metadata::flags, dundi_query_state::maps, max,