Move the ancillary iax2 source files into a separate sub-directory.

This patch just moves the IAX2 source and header files into a separate iax2
sub-directory in the channels directory, similar to how the sip source files are
structured.

The only thing that was added was an #ifndef to protect provision.h from multiple
inclusion.


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@380433 65c4cc65-6c06-0410-ace0-fbb531ad65f3

channels/iax2/include/iax2.h

@@ -0,0 +1,301 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Implementation of Inter-Asterisk eXchange
+ * 
+ * Copyright (C) 2003, Digium
+ *
+ * Mark Spencer <markster@linux-support.net>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+/*! \file
+ * \brief
+ *
+ * Implementation of Inter-Asterisk eXchange, version 2
+ * \ref iax2-parser.c
+ * \ref iax2-parser.h
+ * \ref chan_iax2.c
+ */
+ 
+#ifndef _IAX2_H
+#define _IAX2_H
+
+/* Max version of IAX protocol we support */
+#define IAX_PROTO_VERSION 2
+
+/* NOTE: It is recommended that IAX_MAX_CALLS be a power of 2, but it is not
+ * required.  The maximum number of calls supported by the protocol is 32768.
+ *
+ * For LOW_MEMORY, we use 2049 for compatibility with earlier code because
+ * callno 2048 leaked out when the intended callno range was 2 - 2047. */
+#if defined(LOW_MEMORY)
+#define IAX_MAX_CALLS 2049
+#else
+#define IAX_MAX_CALLS 32768
+#endif
+
+#define IAX_FLAG_FULL		0x8000
+
+#define IAX_FLAG_RETRANS	0x8000
+
+#define IAX_FLAG_SC_LOG		0x80
+
+#define IAX_MAX_SHIFT		0x3F
+
+#define IAX_WINDOW			64
+
+/*! Subclass for AST_FRAME_IAX */
+enum iax_frame_subclass {
+	IAX_COMMAND_NEW =       1,
+	IAX_COMMAND_PING =      2,
+	IAX_COMMAND_PONG =      3,
+	IAX_COMMAND_ACK =       4,
+	IAX_COMMAND_HANGUP =    5,
+	IAX_COMMAND_REJECT =    6,
+	IAX_COMMAND_ACCEPT =    7,
+	IAX_COMMAND_AUTHREQ =   8,
+	IAX_COMMAND_AUTHREP =   9,
+	IAX_COMMAND_INVAL =     10,
+	IAX_COMMAND_LAGRQ =     11,
+	IAX_COMMAND_LAGRP =     12,
+	/*! Registration request */
+	IAX_COMMAND_REGREQ =    13,
+	/*! Registration authentication required */
+	IAX_COMMAND_REGAUTH =   14,
+	/*! Registration accepted */
+	IAX_COMMAND_REGACK =    15,
+	/*! Registration rejected */
+	IAX_COMMAND_REGREJ =    16,
+	/*! Force release of registration */
+	IAX_COMMAND_REGREL =    17,
+	/*! If we receive voice before valid first voice frame, send this */
+	IAX_COMMAND_VNAK =      18,
+	/*! Request status of a dialplan entry */
+	IAX_COMMAND_DPREQ =     19,
+	/*! Request status of a dialplan entry */
+	IAX_COMMAND_DPREP =     20,
+	/*! Request a dial on channel brought up TBD */
+	IAX_COMMAND_DIAL =      21,
+	/*! Transfer Request */
+	IAX_COMMAND_TXREQ =     22,
+	/*! Transfer Connect */
+	IAX_COMMAND_TXCNT =     23,
+	/*! Transfer Accepted */
+	IAX_COMMAND_TXACC =     24,
+	/*! Transfer ready */
+	IAX_COMMAND_TXREADY =   25,
+	/*! Transfer release */
+	IAX_COMMAND_TXREL =     26,
+	/*! Transfer reject */
+	IAX_COMMAND_TXREJ =     27,
+	/*! Stop audio/video transmission */
+	IAX_COMMAND_QUELCH =    28,
+	/*! Resume audio/video transmission */
+	IAX_COMMAND_UNQUELCH =  29,
+	/*! Like ping, but does not require an open connection */
+	IAX_COMMAND_POKE =      30,
+	/*! Paging description */
+	IAX_COMMAND_PAGE =      31,
+	/*! Stand-alone message waiting indicator */
+	IAX_COMMAND_MWI =       32,
+	/*! Unsupported message received */
+	IAX_COMMAND_UNSUPPORT = 33,
+	/*! Request remote transfer */
+	IAX_COMMAND_TRANSFER =  34,
+	/*! Provision device */
+	IAX_COMMAND_PROVISION = 35,
+	/*! Download firmware */
+	IAX_COMMAND_FWDOWNL =   36,
+	/*! Firmware Data */
+	IAX_COMMAND_FWDATA =    37,
+	/*! Transfer media only */
+	IAX_COMMAND_TXMEDIA =   38,
+	/*! Command to rotate key */
+	IAX_COMMAND_RTKEY =     39,
+	/*! Call number token */
+	IAX_COMMAND_CALLTOKEN = 40,
+};
+
+/*! By default require re-registration once per minute */
+#define IAX_DEFAULT_REG_EXPIRE  60
+
+/*! How long to wait before closing bridged call */
+#define IAX_LINGER_TIMEOUT		10
+
+#define IAX_DEFAULT_PORTNO		4569
+
+/*! IAX Information elements */
+#define IAX_IE_CALLED_NUMBER		1		/*!< Number/extension being called - string */
+#define IAX_IE_CALLING_NUMBER		2		/*!< Calling number - string */
+#define IAX_IE_CALLING_ANI			3		/*!< Calling number ANI for billing  - string */
+#define IAX_IE_CALLING_NAME			4		/*!< Name of caller - string */
+#define IAX_IE_CALLED_CONTEXT		5		/*!< Context for number - string */
+#define IAX_IE_USERNAME				6		/*!< Username (peer or user) for authentication - string */
+#define IAX_IE_PASSWORD				7		/*!< Password for authentication - string */
+#define IAX_IE_CAPABILITY			8		/*!< Actual codec capability - unsigned int */
+#define IAX_IE_FORMAT				9		/*!< Desired codec format - unsigned int */
+#define IAX_IE_LANGUAGE				10		/*!< Desired language - string */
+#define IAX_IE_VERSION				11		/*!< Protocol version - short */
+#define IAX_IE_ADSICPE				12		/*!< CPE ADSI capability - short */
+#define IAX_IE_DNID					13		/*!< Originally dialed DNID - string */
+#define IAX_IE_AUTHMETHODS			14		/*!< Authentication method(s) - short */
+#define IAX_IE_CHALLENGE			15		/*!< Challenge data for MD5/RSA - string */
+#define IAX_IE_MD5_RESULT			16		/*!< MD5 challenge result - string */
+#define IAX_IE_RSA_RESULT			17		/*!< RSA challenge result - string */
+#define IAX_IE_APPARENT_ADDR		18		/*!< Apparent address of peer - struct sockaddr_in */
+#define IAX_IE_REFRESH				19		/*!< When to refresh registration - short */
+#define IAX_IE_DPSTATUS				20		/*!< Dialplan status - short */
+#define IAX_IE_CALLNO				21		/*!< Call number of peer - short */
+#define IAX_IE_CAUSE				22		/*!< Cause - string */
+#define IAX_IE_IAX_UNKNOWN			23		/*!< Unknown IAX command - byte */
+#define IAX_IE_MSGCOUNT				24		/*!< How many messages waiting - short */
+#define IAX_IE_AUTOANSWER			25		/*!< Request auto-answering -- none */
+#define IAX_IE_MUSICONHOLD			26		/*!< Request musiconhold with QUELCH -- none or string */
+#define IAX_IE_TRANSFERID			27		/*!< Transfer Request Identifier -- int */
+#define IAX_IE_RDNIS				28		/*!< Referring DNIS -- string */
+#define IAX_IE_PROVISIONING			29		/*!< Provisioning info */
+#define IAX_IE_AESPROVISIONING		30		/*!< AES Provisioning info */
+#define IAX_IE_DATETIME				31		/*!< Date/Time */
+#define IAX_IE_DEVICETYPE			32		/*!< Device Type -- string */
+#define IAX_IE_SERVICEIDENT			33		/*!< Service Identifier -- string */
+#define IAX_IE_FIRMWAREVER			34		/*!< Firmware revision -- u16 */
+#define IAX_IE_FWBLOCKDESC			35		/*!< Firmware block description -- u32 */
+#define IAX_IE_FWBLOCKDATA			36		/*!< Firmware block of data -- raw */
+#define IAX_IE_PROVVER				37		/*!< Provisioning Version (u32) */
+#define IAX_IE_CALLINGPRES			38		/*!< Calling presentation (u8) */
+#define IAX_IE_CALLINGTON			39		/*!< Calling type of number (u8) */
+#define IAX_IE_CALLINGTNS			40		/*!< Calling transit network select (u16) */
+#define IAX_IE_SAMPLINGRATE			41		/*!< Supported sampling rates (u16) */
+#define IAX_IE_CAUSECODE			42		/*!< Hangup cause (u8) */
+#define IAX_IE_ENCRYPTION			43		/*!< Encryption format (u16) */
+#define IAX_IE_ENCKEY				44		/*!< Encryption key (raw) */
+#define IAX_IE_CODEC_PREFS          45      /*!< Codec Negotiation */
+
+#define IAX_IE_RR_JITTER			46		/*!< Received jitter (as in RFC1889) u32 */
+#define IAX_IE_RR_LOSS				47		/*!< Received loss (high byte loss pct, low 24 bits loss count, as in rfc1889 */
+#define IAX_IE_RR_PKTS				48		/*!< Received frames (total frames received) u32 */
+#define IAX_IE_RR_DELAY				49		/*!< Max playout delay for received frames (in ms) u16 */
+#define IAX_IE_RR_DROPPED			50		/*!< Dropped frames (presumably by jitterbuf) u32 */
+#define IAX_IE_RR_OOO				51		/*!< Frames received Out of Order u32 */
+#define IAX_IE_VARIABLE				52		/*!< Remote variables */
+#define IAX_IE_OSPTOKEN				53		/*!< OSP token */
+#define IAX_IE_CALLTOKEN			54		/*!< Call number security token */
+
+#define IAX_IE_CAPABILITY2          55      /*!< Actual codec capability - u8 version + integer array */
+#define IAX_IE_FORMAT2              56      /*!< Desired codec format - u8 version + integer array */
+
+#define IAX_MAX_OSPBLOCK_SIZE		254		/*!< Max OSP token block size, 255 bytes - 1 byte OSP token block index */
+#define IAX_MAX_OSPBLOCK_NUM		4
+#define IAX_MAX_OSPTOKEN_SIZE		(IAX_MAX_OSPBLOCK_SIZE * IAX_MAX_OSPBLOCK_NUM)
+#define IAX_MAX_OSPBUFF_SIZE		(IAX_MAX_OSPTOKEN_SIZE + 16)
+
+#define IAX_AUTH_PLAINTEXT			(1 << 0)
+#define IAX_AUTH_MD5				(1 << 1)
+#define IAX_AUTH_RSA				(1 << 2)
+
+#define IAX_ENCRYPT_AES128			(1 << 0)
+#define IAX_ENCRYPT_KEYROTATE			(1 << 15)       /*!< Keyrotation support */
+
+#define IAX_META_TRUNK				1		/*!< Trunk meta-message */
+#define IAX_META_VIDEO				2		/*!< Video frame */
+
+#define IAX_META_TRUNK_SUPERMINI		0	/*!< This trunk frame contains classic supermini frames */
+#define IAX_META_TRUNK_MINI			1	/*!< This trunk frame contains trunked mini frames */
+
+#define IAX_RATE_8KHZ				(1 << 0) /*!< 8khz sampling (default if absent) */
+#define IAX_RATE_11KHZ				(1 << 1) /*!< 11.025khz sampling */
+#define IAX_RATE_16KHZ				(1 << 2) /*!< 16khz sampling */
+#define IAX_RATE_22KHZ				(1 << 3) /*!< 22.05khz sampling */
+#define IAX_RATE_44KHZ				(1 << 4) /*!< 44.1khz sampling */
+#define IAX_RATE_48KHZ				(1 << 5) /*!< 48khz sampling */
+
+#define IAX_DPSTATUS_EXISTS			(1 << 0)
+#define IAX_DPSTATUS_CANEXIST		(1 << 1)
+#define IAX_DPSTATUS_NONEXISTENT	(1 << 2)
+#define IAX_DPSTATUS_IGNOREPAT		(1 << 14)
+#define IAX_DPSTATUS_MATCHMORE		(1 << 15)
+
+/*! iax2 format bit field for handling codecs the old way */
+typedef int64_t iax2_format;
+
+/*!\brief iax2 wrapper function for ast_getformatname */
+const char *iax2_getformatname(iax2_format format);
+
+/*! Full frames are always delivered reliably */
+struct ast_iax2_full_hdr {
+	unsigned short scallno;	/*!< Source call number -- high bit must be 1 */
+	unsigned short dcallno;	/*!< Destination call number -- high bit is 1 if retransmission */
+	unsigned int ts;		/*!< 32-bit timestamp in milliseconds (from 1st transmission) */
+	unsigned char oseqno;	/*!< Packet number (outgoing) */
+	unsigned char iseqno;	/*!< Packet number (next incoming expected) */
+	unsigned char type;		/*!< Frame type */
+	unsigned char csub;		/*!< Compressed subclass */
+	unsigned char iedata[0];
+} __attribute__ ((__packed__));
+
+/*! Full frames are always delivered reliably */
+struct ast_iax2_full_enc_hdr {
+	unsigned short scallno;	/*!< Source call number -- high bit must be 1 */
+	unsigned short dcallno;	/*!< Destination call number -- high bit is 1 if retransmission */
+	unsigned char encdata[0];
+} __attribute__ ((__packed__));
+
+/*! Mini header is used only for voice frames -- delivered unreliably */
+struct ast_iax2_mini_hdr {
+	unsigned short callno;	/*!< Source call number -- high bit must be 0, rest must be non-zero */
+	unsigned short ts;		/*!< 16-bit Timestamp (high 16 bits from last ast_iax2_full_hdr) */
+							/* Frametype implicitly VOICE_FRAME */
+							/* subclass implicit from last ast_iax2_full_hdr */
+	unsigned char data[0];
+} __attribute__ ((__packed__));
+
+/*! Mini header is used only for voice frames -- delivered unreliably */
+struct ast_iax2_mini_enc_hdr {
+	unsigned short callno;	/*!< Source call number -- high bit must be 0, rest must be non-zero */
+	unsigned char encdata[0];
+} __attribute__ ((__packed__));
+
+struct ast_iax2_meta_hdr {
+	unsigned short zeros;			/*!< Zeros field -- must be zero */
+	unsigned char metacmd;			/*!< Meta command */
+	unsigned char cmddata;			/*!< Command Data */
+	unsigned char data[0];
+} __attribute__ ((__packed__));
+
+struct ast_iax2_video_hdr {
+	unsigned short zeros;			/*!< Zeros field -- must be zero */
+	unsigned short callno;			/*!< Video call number */
+	unsigned short ts;				/*!< Timestamp and mark if present */
+	unsigned char data[0];
+} __attribute__ ((__packed__));
+
+struct ast_iax2_meta_trunk_hdr {
+	unsigned int ts;				/*!< 32-bit timestamp for all messages */
+	unsigned char data[0];
+} __attribute__ ((__packed__));
+
+struct ast_iax2_meta_trunk_entry {
+	unsigned short callno;			/*!< Call number */
+	unsigned short len;				/*!< Length of data for this callno */
+} __attribute__ ((__packed__));
+
+/*! When trunktimestamps are used, we use this format instead */
+struct ast_iax2_meta_trunk_mini {
+	unsigned short len;
+	struct ast_iax2_mini_hdr mini;		/*!< this is an actual miniframe */
+} __attribute__ ((__packed__));
+
+#define IAX_FIRMWARE_MAGIC 0x69617879
+
+struct ast_iax2_firmware_header {
+	unsigned int magic;		/*!< Magic number */
+	unsigned short version;		/*!< Software version */
+	unsigned char devname[16];	/*!< Device */
+	unsigned int datalen;		/*!< Data length of file beyond header */
+	unsigned char chksum[16];	/*!< Checksum of all data */
+	unsigned char data[0];
+} __attribute__ ((__packed__));
+#endif

channels/iax2/include/parser.h

@@ -0,0 +1,177 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Implementation of Inter-Asterisk eXchange
+ * 
+ * Copyright (C) 2003, Digium
+ *
+ * Mark Spencer <markster@digium.com>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+/*!\file
+ * \brief Implementation of the IAX2 protocol
+ */
+ 
+#ifndef _IAX2_PARSER_H
+#define _IAX2_PARSER_H
+
+#include "asterisk/linkedlists.h"
+#include "asterisk/crypto.h"
+#include "iax2.h"
+
+struct iax_ies {
+	char *called_number;
+	char *calling_number;
+	char *calling_ani;
+	char *calling_name;
+	int calling_ton;
+	int calling_tns;
+	int calling_pres;
+	char *called_context;
+	char *username;
+	char *password;
+	iax2_format capability;
+	iax2_format format;
+	char *codec_prefs;
+	char *language;
+	int version;
+	unsigned short adsicpe;
+	char *dnid;
+	char *rdnis;
+	unsigned int authmethods;
+	unsigned int encmethods;
+	char *challenge;
+	char *md5_result;
+	char *rsa_result;
+	struct sockaddr_in *apparent_addr;
+	unsigned short refresh;
+	unsigned short dpstatus;
+	unsigned short callno;
+	char *cause;
+	unsigned char causecode;
+	unsigned char iax_unknown;
+	int msgcount;
+	int autoanswer;
+	int musiconhold;
+	unsigned int transferid;
+	unsigned int datetime;
+	char *devicetype;
+	char *serviceident;
+	int firmwarever;
+	unsigned int fwdesc;
+	unsigned char *fwdata;
+	unsigned char fwdatalen;
+	unsigned char *enckey;
+	unsigned char enckeylen;
+	unsigned int provver;
+	unsigned short samprate;
+	int provverpres;
+	unsigned int rr_jitter;
+	unsigned int rr_loss;
+	unsigned int rr_pkts;
+	unsigned short rr_delay;
+	unsigned int rr_dropped;
+	unsigned int rr_ooo;
+	struct ast_variable *vars;
+	char *osptokenblock[IAX_MAX_OSPBLOCK_NUM];
+	unsigned int ospblocklength[IAX_MAX_OSPBLOCK_NUM];
+	unsigned char calltoken;
+	unsigned char *calltokendata;
+};
+
+#define DIRECTION_INGRESS 1
+#define DIRECTION_OUTGRESS 2
+
+struct iax_frame {
+#ifdef LIBIAX
+	struct iax_session *session;
+	struct iax_event *event;
+#else
+	int sockfd;
+#endif
+
+	/*! /Our/ call number */
+	unsigned short callno;
+	/*! /Their/ call number */
+	unsigned short dcallno;
+	/*! Start of raw frame (outgoing only) */
+	void *data;
+	/*! Length of frame (outgoing only) */
+	int datalen;
+	/*! How many retries so far? */
+	int retries;
+	/*! Outgoing relative timestamp (ms) */
+	unsigned int ts;
+	/*! How long to wait before retrying */
+	int retrytime;
+	/*! Are we received out of order?  */
+	unsigned int outoforder:1;
+	/*! Have we been sent at all yet? */
+	unsigned int sentyet:1;
+	/*! Non-zero if should be sent to transfer peer */
+	unsigned int transfer:1;
+	/*! Non-zero if this is the final message */
+	unsigned int final:1;
+	/*! Ingress or outgres */
+	unsigned int direction:2;
+	/*! Can this frame be cached? */
+	unsigned int cacheable:1;
+	/*! Outgoing Packet sequence number */
+	int oseqno;
+	/*! Next expected incoming packet sequence number */
+	int iseqno;
+	/*! Retransmission ID */
+	int retrans;
+	/*! is this packet encrypted or not. if set this varible holds encryption methods*/
+	int encmethods;
+	/*! store encrypt key */
+	ast_aes_encrypt_key ecx;
+	/*! store decrypt key which corresponds to ecx */
+	ast_aes_decrypt_key mydcx;
+	/*! random data for encryption pad */
+	unsigned char semirand[32];
+	/*! Easy linking */
+	AST_LIST_ENTRY(iax_frame) list;
+	/*! Actual, isolated frame header */
+	struct ast_frame af;
+	/*! Amount of space _allocated_ for data */
+	size_t afdatalen;
+	unsigned char unused[AST_FRIENDLY_OFFSET];
+	unsigned char afdata[0];	/* Data for frame */
+};
+
+struct iax_ie_data {
+	unsigned char buf[1024];
+	int pos;
+};
+
+/* Choose a different function for output */
+void iax_set_output(void (*output)(const char *data));
+/* Choose a different function for errors */
+void iax_set_error(void (*output)(const char *data));
+void iax_showframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct sockaddr_in *sin, int datalen);
+void iax_frame_subclass2str(enum iax_frame_subclass subclass, char *str, size_t len);
+
+const char *iax_ie2str(int ie);
+
+int iax_ie_append_raw(struct iax_ie_data *ied, unsigned char ie, const void *data, int datalen);
+int iax_ie_append_addr(struct iax_ie_data *ied, unsigned char ie, const struct sockaddr_in *sin);
+int iax_ie_append_versioned_uint64(struct iax_ie_data *ied, unsigned char ie, unsigned char version, uint64_t value);
+int iax_ie_append_int(struct iax_ie_data *ied, unsigned char ie, unsigned int value);
+int iax_ie_append_short(struct iax_ie_data *ied, unsigned char ie, unsigned short value);
+int iax_ie_append_str(struct iax_ie_data *ied, unsigned char ie, const char *str);
+int iax_ie_append_byte(struct iax_ie_data *ied, unsigned char ie, unsigned char dat);
+int iax_ie_append(struct iax_ie_data *ied, unsigned char ie);
+int iax_parse_ies(struct iax_ies *ies, unsigned char *data, int datalen);
+
+int iax_get_frames(void);
+int iax_get_iframes(void);
+int iax_get_oframes(void);
+
+void iax_frame_wrap(struct iax_frame *fr, struct ast_frame *f);
+struct iax_frame *iax_frame_new(int direction, int datalen, unsigned int cacheable);
+void iax_frame_free(struct iax_frame *fr);
+#endif

channels/iax2/include/provision.h

@@ -0,0 +1,58 @@
+/*
+ * IAX Provisioning Protocol
+ *
+ * Sub-information elements
+ *
+ * Copyright (C) 2003, Digium
+ *
+ * Mark Spencer <markster@digium.com>
+ *
+ */
+
+/*! \file
+ *  \brief IAX2 Provisioning protocol
+ */
+
+#ifndef __IAX2_PROVISION_H
+#define __IAX2_PROVISION_H
+
+#include "parser.h"
+
+#define PROV_IE_USEDHCP 	1	/* Presense only */
+#define PROV_IE_IPADDR		2	/* 32-bit */
+#define PROV_IE_SUBNET		3	/* 32-bit */
+#define PROV_IE_GATEWAY		4	/* 32-bit */
+#define PROV_IE_PORTNO		5	/* 16-bit */
+#define PROV_IE_USER		6	/* < 20 bytes */
+#define PROV_IE_PASS		7	/* < 20 bytes */
+#define PROV_IE_SERVERUSER	8	/* < 20 bytes */
+#define PROV_IE_SERVERPASS	9	/* < 20 bytes */
+#define PROV_IE_LANG		10	/* < 10 bytes */
+#define PROV_IE_TOS			11	/* 8-bits */
+#define PROV_IE_FLAGS		12	/* 32-bits */
+#define PROV_IE_FORMAT		13	/* 32-bits */
+#define PROV_IE_AESKEY		14	/* 128-bits */
+#define PROV_IE_SERVERIP	15	/* 32-bits */
+#define PROV_IE_SERVERPORT	16	/* 16-bits */
+#define PROV_IE_NEWAESKEY	17	/* 128-bits */
+#define PROV_IE_PROVVER		18	/* 32-bits */
+#define PROV_IE_ALTSERVER	19	/* 32-bits */
+
+#define PROV_FLAG_REGISTER		(1 << 0)
+#define PROV_FLAG_SECURE		(1 << 1)
+#define PROV_FLAG_HEARTBEAT		(1 << 2)
+#define PROV_FLAG_DEBUG			(1 << 3)
+
+#define PROV_FLAG_DIS_CALLERID	(1 << 4)	/* Caller-ID Disabled */
+#define PROV_FLAG_DIS_CALLWAIT	(1 << 5)	/* Caller-ID / Call Waiting Disable */
+#define PROV_FLAG_DIS_CIDCW		(1 << 6)	/* CID/CW Disabled */
+#define PROV_FLAG_DIS_THREEWAY	(1 << 7)	/* Three-way calling, transfer disabled */
+
+char *iax_provflags2str(char *buf, int buflen, unsigned int flags);
+int iax_provision_reload(int reload);
+int iax_provision_unload(void);
+int iax_provision_build(struct iax_ie_data *provdata, unsigned int *signature, const char *template, int force);
+int iax_provision_version(unsigned int *signature, const char *template, int force);
+char *iax_prov_complete_template(const char *line, const char *word, int pos, int state);
+
+#endif

channels/iax2/provision.c

@@ -0,0 +1,566 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2006, Digium, Inc.
+ *
+ * Mark Spencer <markster@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ * 
+ * \brief IAX Provisioning Protocol 
+ *
+ * \author Mark Spencer <markster@digium.com>
+ */
+
+/*** MODULEINFO
+	<support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <sys/socket.h>
+
+#include "asterisk/config.h"
+#include "asterisk/cli.h"
+#include "asterisk/lock.h"
+#include "asterisk/frame.h"
+#include "asterisk/md5.h"
+#include "asterisk/astdb.h"
+#include "asterisk/utils.h"
+#include "asterisk/acl.h"
+
+#include "include/iax2.h"
+#include "include/provision.h"
+#include "include/parser.h"
+
+static int provinit = 0;
+
+struct iax_template {
+	int dead;
+	char name[80];
+	char src[80];
+	char user[20];
+	char pass[20];
+	char lang[10];
+	unsigned short port;
+	unsigned int server;
+	unsigned short serverport;
+	unsigned int altserver;
+	unsigned int flags;
+	iax2_format format;
+	unsigned int tos;
+	AST_LIST_ENTRY(iax_template) list;
+};
+
+static AST_LIST_HEAD_NOLOCK_STATIC(templates, iax_template);
+
+AST_MUTEX_DEFINE_STATIC(provlock);
+
+static struct iax_flag {
+	char *name;
+	int value;
+} iax_flags[] = {
+	{ "register", PROV_FLAG_REGISTER },
+	{ "secure", PROV_FLAG_SECURE },
+	{ "heartbeat", PROV_FLAG_HEARTBEAT },
+	{ "debug", PROV_FLAG_DEBUG },
+	{ "disablecid", PROV_FLAG_DIS_CALLERID },
+	{ "disablecw", PROV_FLAG_DIS_CALLWAIT },
+	{ "disablecidcw", PROV_FLAG_DIS_CIDCW },
+	{ "disable3way", PROV_FLAG_DIS_THREEWAY },
+};
+
+char *iax_provflags2str(char *buf, int buflen, unsigned int flags)
+{
+	int x;
+
+	if (!buf || buflen < 1)
+		return NULL;
+	
+	buf[0] = '\0';
+
+	for (x = 0; x < ARRAY_LEN(iax_flags); x++) {
+		if (flags & iax_flags[x].value){
+			strncat(buf, iax_flags[x].name, buflen - strlen(buf) - 1);
+			strncat(buf, ",", buflen - strlen(buf) - 1);
+		}
+	}
+
+	if (!ast_strlen_zero(buf)) 
+		buf[strlen(buf) - 1] = '\0';
+	else
+		strncpy(buf, "none", buflen - 1);
+
+	return buf;
+}
+
+static unsigned int iax_str2flags(const char *buf)
+{
+	int x;
+	int len;
+	unsigned int flags = 0;
+	char *e;
+	while(buf && *buf) {
+		e = strchr(buf, ',');
+		if (e)
+			len = e - buf;
+		else
+			len = 0;
+		for (x = 0; x < ARRAY_LEN(iax_flags); x++) {
+			if ((len && !strncasecmp(iax_flags[x].name, buf, len)) ||
+			    (!len && !strcasecmp(iax_flags[x].name, buf))) {
+				flags |= iax_flags[x].value;
+				break;
+			}
+		}
+		if (e) {
+			buf = e + 1;
+			while(*buf && (*buf < 33))
+				buf++;
+		} else
+			break;
+	}
+	return flags;
+}
+
+static void iax_template_copy(struct iax_template *dst, struct iax_template *src)
+{
+	if (!dst || !src) {
+		return;
+	}
+
+	dst->dead = src->dead;
+	ast_copy_string(dst->name, src->name, sizeof(dst->name));
+	ast_copy_string(dst->src, src->src, sizeof(dst->src));
+	ast_copy_string(dst->user, src->user, sizeof(dst->user));
+	ast_copy_string(dst->pass, src->pass, sizeof(dst->pass));
+	ast_copy_string(dst->lang, src->lang, sizeof(dst->lang));
+	dst->port = src->port;
+	dst->server = src->server;
+	dst->altserver = src->altserver;
+	dst->flags = src->flags;
+	dst->format = src->format;
+	dst->tos = src->tos;
+}
+
+static struct iax_template *iax_template_find(const char *s, int allowdead)
+{
+	struct iax_template *cur;
+
+	AST_LIST_TRAVERSE(&templates, cur, list) {
+		if (!strcasecmp(s, cur->name)) {
+			if (!allowdead && cur->dead) {
+				cur = NULL;
+			}
+			break;
+		}
+	}
+
+	return cur;
+}
+
+char *iax_prov_complete_template(const char *line, const char *word, int pos, int state)
+{
+	struct iax_template *c;
+	int which=0;
+	char *ret = NULL;
+	int wordlen = strlen(word);
+
+	if (pos == 3) {
+		ast_mutex_lock(&provlock);
+		AST_LIST_TRAVERSE(&templates, c, list) {
+			if (!strncasecmp(word, c->name, wordlen) && ++which > state) {
+				ret = ast_strdup(c->name);
+				break;
+			}
+		}
+		ast_mutex_unlock(&provlock);
+	}
+	return ret;
+}
+
+static unsigned int prov_ver_calc(struct iax_ie_data *provdata)
+{
+	struct MD5Context md5;
+	unsigned int tmp[4];
+	MD5Init(&md5);
+	MD5Update(&md5, provdata->buf, provdata->pos);
+	MD5Final((unsigned char *)tmp, &md5);
+	return tmp[0] ^ tmp[1] ^ tmp[2] ^ tmp[3];
+}
+
+int iax_provision_build(struct iax_ie_data *provdata, unsigned int *signature, const char *template, int force)
+{
+	struct iax_template *cur;
+	unsigned int sig;
+	char tmp[40];
+	memset(provdata, 0, sizeof(*provdata));
+	ast_mutex_lock(&provlock);
+	cur = iax_template_find(template, 1);
+	/* If no match, try searching for '*' */
+	if (!cur)
+		cur = iax_template_find("*", 1);
+	if (cur) {
+		/* found it -- add information elements as appropriate */
+		if (force || strlen(cur->user))
+			iax_ie_append_str(provdata, PROV_IE_USER, cur->user);
+		if (force || strlen(cur->pass))
+			iax_ie_append_str(provdata, PROV_IE_PASS, cur->pass);
+		if (force || strlen(cur->lang))
+			iax_ie_append_str(provdata, PROV_IE_LANG, cur->lang);
+		if (force || cur->port)
+			iax_ie_append_short(provdata, PROV_IE_PORTNO, cur->port);
+		if (force || cur->server)
+			iax_ie_append_int(provdata, PROV_IE_SERVERIP, cur->server);
+		if (force || cur->serverport)
+			iax_ie_append_short(provdata, PROV_IE_SERVERPORT, cur->serverport);
+		if (force || cur->altserver)
+			iax_ie_append_int(provdata, PROV_IE_ALTSERVER, cur->altserver);
+		if (force || cur->flags)
+			iax_ie_append_int(provdata, PROV_IE_FLAGS, cur->flags);
+		if (force || cur->format)
+			iax_ie_append_int(provdata, PROV_IE_FORMAT, cur->format);
+		if (force || cur->tos)
+			iax_ie_append_byte(provdata, PROV_IE_TOS, cur->tos);
+		
+		/* Calculate checksum of message so far */
+		sig = prov_ver_calc(provdata);
+		if (signature)
+			*signature = sig;
+		/* Store signature */
+		iax_ie_append_int(provdata, PROV_IE_PROVVER, sig);
+		/* Cache signature for later verification so we need not recalculate all this */
+		snprintf(tmp, sizeof(tmp), "v0x%08x", sig);
+		ast_db_put("iax/provisioning/cache", template, tmp);
+	} else
+		ast_db_put("iax/provisioning/cache", template, "u");
+	ast_mutex_unlock(&provlock);
+	return cur ? 0 : -1;
+}
+
+int iax_provision_version(unsigned int *version, const char *template, int force)
+{
+	char tmp[80] = "";
+	struct iax_ie_data ied;
+	int ret=0;
+	memset(&ied, 0, sizeof(ied));
+
+	ast_mutex_lock(&provlock);
+	if (ast_db_get("iax/provisioning/cache", template, tmp, sizeof(tmp))) {
+		ast_log(LOG_ERROR, "ast_db_get failed to retrieve iax/provisioning/cache/%s\n", template);
+	}
+	if (sscanf(tmp, "v%30x", version) != 1) {
+		if (strcmp(tmp, "u")) {
+			ret = iax_provision_build(&ied, version, template, force);
+			if (ret)
+				ast_debug(1, "Unable to create provisioning packet for '%s'\n", template);
+		} else
+			ret = -1;
+	} else
+		ast_debug(1, "Retrieved cached version '%s' = '%08x'\n", tmp, *version);
+	ast_mutex_unlock(&provlock);
+	return ret;
+}
+
+static int iax_template_parse(struct iax_template *cur, struct ast_config *cfg, const char *s, const char *def)
+{
+	struct ast_variable *v;
+	int foundportno = 0;
+	int foundserverportno = 0;
+	int x;
+	struct in_addr ia;
+	struct hostent *hp;
+	struct ast_hostent h;
+	struct iax_template *src, tmp;
+	const char *t;
+	if (def) {
+		t = ast_variable_retrieve(cfg, s ,"template");
+		src = NULL;
+		if (t && strlen(t)) {
+			src = iax_template_find(t, 0);
+			if (!src)
+				ast_log(LOG_WARNING, "Unable to find base template '%s' for creating '%s'.  Trying '%s'\n", t, s, def);
+			else
+				def = t;
+		} 
+		if (!src) {
+			src = iax_template_find(def, 0);
+			if (!src)
+				ast_log(LOG_WARNING, "Unable to locate default base template '%s' for creating '%s', omitting.\n", def, s);
+		}
+		if (!src)
+			return -1;
+		ast_mutex_lock(&provlock);
+		/* Backup old data */
+		iax_template_copy(&tmp, cur);
+		/* Restore from src */
+		iax_template_copy(cur, src);
+		/* Restore important headers */
+		memcpy(cur->name, tmp.name, sizeof(cur->name));
+		cur->dead = tmp.dead;
+		ast_mutex_unlock(&provlock);
+	}
+	if (def)
+		ast_copy_string(cur->src, def, sizeof(cur->src));
+	else
+		cur->src[0] = '\0';
+	v = ast_variable_browse(cfg, s);
+	while(v) {
+		if (!strcasecmp(v->name, "port") || !strcasecmp(v->name, "serverport")) {
+			if ((sscanf(v->value, "%5d", &x) == 1) && (x > 0) && (x < 65535)) {
+				if (!strcasecmp(v->name, "port")) {
+					cur->port = x;
+					foundportno = 1;
+				} else {
+					cur->serverport = x;
+					foundserverportno = 1;
+				}
+			} else
+				ast_log(LOG_WARNING, "Ignoring invalid %s '%s' for '%s' at line %d\n", v->name, v->value, s, v->lineno);
+		} else if (!strcasecmp(v->name, "server") || !strcasecmp(v->name, "altserver")) {
+			hp = ast_gethostbyname(v->value, &h);
+			if (hp) {
+				memcpy(&ia, hp->h_addr, sizeof(ia));
+				if (!strcasecmp(v->name, "server"))
+					cur->server = ntohl(ia.s_addr);
+				else
+					cur->altserver = ntohl(ia.s_addr);
+			} else 
+				ast_log(LOG_WARNING, "Ignoring invalid %s '%s' for '%s' at line %d\n", v->name, v->value, s, v->lineno);
+		} else if (!strcasecmp(v->name, "codec")) {
+			struct ast_format tmpfmt;
+			if ((ast_getformatbyname(v->value, &tmpfmt)) > 0) {
+				cur->format = ast_format_to_old_bitfield(&tmpfmt);
+			} else
+				ast_log(LOG_WARNING, "Ignoring invalid codec '%s' for '%s' at line %d\n", v->value, s, v->lineno);
+		} else if (!strcasecmp(v->name, "tos")) {
+			if (ast_str2tos(v->value, &cur->tos))
+				ast_log(LOG_WARNING, "Invalid tos value at line %d, refer to QoS documentation\n", v->lineno);
+		} else if (!strcasecmp(v->name, "user")) {
+			ast_copy_string(cur->user, v->value, sizeof(cur->user));
+			if (strcmp(cur->user, v->value))
+				ast_log(LOG_WARNING, "Truncating username from '%s' to '%s' for '%s' at line %d\n", v->value, cur->user, s, v->lineno);
+		} else if (!strcasecmp(v->name, "pass")) {
+			ast_copy_string(cur->pass, v->value, sizeof(cur->pass));
+			if (strcmp(cur->pass, v->value))
+				ast_log(LOG_WARNING, "Truncating password from '%s' to '%s' for '%s' at line %d\n", v->value, cur->pass, s, v->lineno);
+		} else if (!strcasecmp(v->name, "language")) {
+			ast_copy_string(cur->lang, v->value, sizeof(cur->lang));
+			if (strcmp(cur->lang, v->value))
+				ast_log(LOG_WARNING, "Truncating language from '%s' to '%s' for '%s' at line %d\n", v->value, cur->lang, s, v->lineno);
+		} else if (!strcasecmp(v->name, "flags")) {
+			cur->flags = iax_str2flags(v->value);
+		} else if (!strncasecmp(v->name, "flags", 5) && strchr(v->name, '+')) {
+			cur->flags |= iax_str2flags(v->value);
+		} else if (!strncasecmp(v->name, "flags", 5) && strchr(v->name, '-')) {
+			cur->flags &= ~iax_str2flags(v->value);
+		} else if (strcasecmp(v->name, "template")) {
+			ast_log(LOG_WARNING, "Unknown keyword '%s' in definition of '%s' at line %d\n", v->name, s, v->lineno);
+		}
+		v = v->next;
+	}
+	if (!foundportno)
+		cur->port = IAX_DEFAULT_PORTNO;
+	if (!foundserverportno)
+		cur->serverport = IAX_DEFAULT_PORTNO;
+	return 0;
+}
+
+static int iax_process_template(struct ast_config *cfg, char *s, char *def)
+{
+	/* Find an already existing one if there */
+	struct iax_template *cur;
+	int mallocd = 0;
+
+	cur = iax_template_find(s, 1 /* allow dead */);
+	if (!cur) {
+		mallocd = 1;
+		cur = ast_calloc(1, sizeof(*cur));
+		if (!cur) {
+			ast_log(LOG_WARNING, "Out of memory!\n");
+			return -1;
+		}
+		/* Initialize entry */
+		ast_copy_string(cur->name, s, sizeof(cur->name));
+		cur->dead = 1;
+	}
+	if (!iax_template_parse(cur, cfg, s, def))
+		cur->dead = 0;
+
+	/* Link if we're mallocd */
+	if (mallocd) {
+		ast_mutex_lock(&provlock);
+		AST_LIST_INSERT_HEAD(&templates, cur, list);
+		ast_mutex_unlock(&provlock);
+	}
+	return 0;
+}
+
+static const char *ifthere(const char *s)
+{
+	if (strlen(s))
+		return s;
+	else
+		return "<unspecified>";
+}
+
+static const char *iax_server(unsigned int addr)
+{
+	struct in_addr ia;
+	
+	if (!addr)
+		return "<unspecified>";
+	
+	ia.s_addr = htonl(addr);
+
+	return ast_inet_ntoa(ia);
+}
+
+
+static char *iax_show_provisioning(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	struct iax_template *cur;
+	char server[INET_ADDRSTRLEN];
+	char alternate[INET_ADDRSTRLEN];
+	char flags[80];	/* Has to be big enough for 'flags' too */
+	int found = 0;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "iax2 show provisioning";
+		e->usage =
+			"Usage: iax2 show provisioning [template]\n"
+			"       Lists all known IAX provisioning templates or a\n"
+			"       specific one if specified.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return iax_prov_complete_template(a->line, a->word, a->pos, a->n);
+	}
+
+	if ((a->argc != 3) && (a->argc != 4))
+		return CLI_SHOWUSAGE;
+
+	ast_mutex_lock(&provlock);
+	AST_LIST_TRAVERSE(&templates, cur, list) {
+		if ((a->argc == 3) || (!strcasecmp(a->argv[3], cur->name)))  {
+			if (found) 
+				ast_cli(a->fd, "\n");
+			ast_copy_string(server, iax_server(cur->server), sizeof(server));
+			ast_copy_string(alternate, iax_server(cur->altserver), sizeof(alternate));
+			ast_cli(a->fd, "== %s ==\n", cur->name);
+			ast_cli(a->fd, "Base Templ:   %s\n", strlen(cur->src) ? cur->src : "<none>");
+			ast_cli(a->fd, "Username:     %s\n", ifthere(cur->user));
+			ast_cli(a->fd, "Secret:       %s\n", ifthere(cur->pass));
+			ast_cli(a->fd, "Language:     %s\n", ifthere(cur->lang));
+			ast_cli(a->fd, "Bind Port:    %d\n", cur->port);
+			ast_cli(a->fd, "Server:       %s\n", server);
+			ast_cli(a->fd, "Server Port:  %d\n", cur->serverport);
+			ast_cli(a->fd, "Alternate:    %s\n", alternate);
+			ast_cli(a->fd, "Flags:        %s\n", iax_provflags2str(flags, sizeof(flags), cur->flags));
+			ast_cli(a->fd, "Format:       %s\n", iax2_getformatname(cur->format));
+			ast_cli(a->fd, "TOS:          0x%x\n", cur->tos);
+			found++;
+		}
+	}
+	ast_mutex_unlock(&provlock);
+	if (!found) {
+		if (a->argc == 3)
+			ast_cli(a->fd, "No provisioning templates found\n");
+		else
+			ast_cli(a->fd, "No provisioning template matching '%s' found\n", a->argv[3]);
+	}
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cli_iax2_provision[] = {
+	AST_CLI_DEFINE(iax_show_provisioning, "Display iax provisioning"),
+};
+
+static int iax_provision_init(void)
+{
+	ast_cli_register_multiple(cli_iax2_provision, sizeof(cli_iax2_provision) / sizeof(struct ast_cli_entry));
+	provinit = 1;
+	return 0;
+}
+
+static void iax_provision_free_templates(int dead)
+{
+	struct iax_template *cur;
+
+	/* Drop dead or not (depending on dead) entries while locked */
+	ast_mutex_lock(&provlock);
+	AST_LIST_TRAVERSE_SAFE_BEGIN(&templates, cur, list) {
+		if ((dead && cur->dead) || !dead) {
+			AST_LIST_REMOVE_CURRENT(list);
+			ast_free(cur);
+		}
+	}
+	AST_LIST_TRAVERSE_SAFE_END;
+	ast_mutex_unlock(&provlock);
+}
+
+int iax_provision_unload(void)
+{
+	provinit = 0;
+	ast_cli_unregister_multiple(cli_iax2_provision, sizeof(cli_iax2_provision) / sizeof(struct ast_cli_entry));
+	iax_provision_free_templates(0 /* Remove all templates. */);
+
+	return 0;
+}
+
+int iax_provision_reload(int reload)
+{
+	struct ast_config *cfg;
+	struct iax_template *cur;
+	char *cat;
+	int found = 0;
+	struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
+	if (!provinit)
+		iax_provision_init();
+	
+	cfg = ast_config_load2("iaxprov.conf", "chan_iax2", config_flags);
+	if (cfg != NULL && cfg != CONFIG_STATUS_FILEUNCHANGED && cfg != CONFIG_STATUS_FILEINVALID) {
+		/* Mark all as dead.  No need for locking */
+		AST_LIST_TRAVERSE(&templates, cur, list) {
+			cur->dead = 1;
+		}
+
+		/* Load as appropriate */
+		cat = ast_category_browse(cfg, NULL);
+		while(cat) {
+			if (strcasecmp(cat, "general")) {
+				iax_process_template(cfg, cat, found ? "default" : NULL);
+				found++;
+				ast_verb(3, "Loaded provisioning template '%s'\n", cat);
+			}
+			cat = ast_category_browse(cfg, cat);
+		}
+		ast_config_destroy(cfg);
+	} else if (cfg == CONFIG_STATUS_FILEUNCHANGED)
+		return 0;
+	else
+		ast_log(LOG_NOTICE, "No IAX provisioning configuration found, IAX provisioning disabled.\n");
+
+	iax_provision_free_templates(1 /* remove only marked as dead */);
+
+	/* Purge cached signature DB entries */
+	ast_db_deltree("iax/provisioning/cache", NULL);
+	return 0;
+}