[asterisk-commits] jdixon: branch jdixon/chan_usbradio-1.4 r140411 - /team/jdixon/chan_usbradio-...

SVN commits to the Asterisk project asterisk-commits at lists.digium.com
Thu Aug 28 20:45:02 CDT 2008


Author: jdixon
Date: Thu Aug 28 20:45:01 2008
New Revision: 140411

URL: http://svn.digium.com/view/asterisk?view=rev&rev=140411
Log:
Added chan_echolink to main SVN

Added:
    team/jdixon/chan_usbradio-1.4/channels/chan_echolink.c   (with props)

Added: team/jdixon/chan_usbradio-1.4/channels/chan_echolink.c
URL: http://svn.digium.com/view/asterisk/team/jdixon/chan_usbradio-1.4/channels/chan_echolink.c?view=auto&rev=140411
==============================================================================
--- team/jdixon/chan_usbradio-1.4/channels/chan_echolink.c (added)
+++ team/jdixon/chan_usbradio-1.4/channels/chan_echolink.c Thu Aug 28 20:45:01 2008
@@ -1,0 +1,2404 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2006, Digium, Inc.
+ *
+ * Copyright (C) 2008, Scott Lawson/KI4LKF
+ * ScottLawson/KI4LKF <ham44865 at yahoo.com>
+ * Jim Dixon, WB6NIL <jim at lambdatel.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 Echolink channel driver for Asterisk
+ * 
+ * \author Scott Lawson/KI4LKF <ham44865 at yahoo.com>
+ * \author Jim Dixon, WB6NIL <jim at lambdatel.com>
+ *
+ * \ingroup channel_drivers
+ */
+
+/*** MODULEINFO
+	<depend>zlib</depend>
+ ***/
+
+/* Version 0.14, 08/27/2008
+Echolink channel driver for Asterisk/app_rpt.
+A lot more has to be added,
+Here is what comes to mind first:
+
+---> does not send its station info.
+---> does not process chat text.
+---> recognizes a few remote text commands.
+---> no busy, deaf or mute.
+---> no capacity limits.
+---> no banned or privare station list.
+---> no admin list, only local 127.0.0.1 access.
+---> no welcome text message.
+---> no login or connect timeouts.
+---> no max TX time limit.
+---> no activity reporting.
+---> no event notififications.
+---> no stats.
+---> no callsign prefix restrictions.
+---> no announcements on connects/disconnects.
+---> no loop detection.
+---> allows "doubles"
+
+Otherwise it works as an Echolink conference and it
+will accept multiple station connects.
+It also detects disconnect requests and 
+removes dead stations on heartbeat timeouts.
+Default ports are 5198,5199.
+
+Remote text commands thru netcat:
+o.conip <IPaddress>    (request a connect)
+o.dconip <IPaddress>   (request a disconnect)
+o.rec                  (turn on/off recording)
+
+It is invoked as echolink/identifier (like el0 for example)
+Example: 
+Under a node stanza in rpt.conf, 
+rxchannel=echolink/el0
+
+The el0 or whatever you put there must match the stanza in the
+echolink.conf file.
+
+If the linux box is protected by a NAT router,
+leave the IP address as 0.0.0.0,
+do not use 127.0.0.1
+
+*/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <ctype.h>
+#include <search.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <zlib.h>
+
+#include "asterisk/lock.h"
+#include "asterisk/channel.h"
+#include "asterisk/config.h"
+#include "asterisk/logger.h"
+#include "asterisk/module.h"
+#include "asterisk/pbx.h"
+#include "asterisk/options.h"
+#include "asterisk/utils.h"
+#include "asterisk/app.h"
+#include "asterisk/dsp.h"
+#include "asterisk/translate.h"
+#include "asterisk/astdb.h"
+
+#define	MAX_RXKEY_TIME 4
+
+/* 50 * 10 * 20ms iax2 = 10,000ms = 10 seconds heartbeat */
+#define	KEEPALIVE_TIME 50 * 10
+#define	BLOCKING_FACTOR 4
+#define	GSM_FRAME_SIZE 33
+#define QUEUE_OVERLOAD_THRESHOLD_AST 25
+#define QUEUE_OVERLOAD_THRESHOLD_EL 20
+
+#define EL_IP_SIZE 15
+#define EL_CALL_SIZE 15
+#define EL_NAME_SIZE 31
+#define EL_PWD_SIZE 15
+#define EL_EMAIL_SIZE 31
+#define EL_QTH_SIZE 31
+#define EL_MAX_SERVERS 3
+#define EL_SERVERNAME_SIZE 63
+#define	EL_MAX_INSTANCES 100
+
+/* 
+   If you want to compile/link this code
+   on "BIG-ENDIAN" platforms, then
+   use this: #define RTP_BIG_ENDIAN
+   Have only tested this code on "little-endian"
+   platforms running Linux.
+*/
+
+static const char tdesc[] = "Echolink channel driver by KI4LKF";
+static int prefformat = AST_FORMAT_GSM;
+static char type[] = "echolink";
+static char db_active = 'a';
+static char db_loading = 0;
+static char snapshot_id[50] = {'0',0};
+static int el_net_get_index = 0;
+static int el_net_get_nread = 0;
+
+
+/* Echolink audio packet heafer */
+struct gsmVoice_t {
+#ifdef RTP_BIG_ENDIAN
+  uint8_t version:2;
+  uint8_t pad:1;
+  uint8_t ext:1;
+  uint8_t csrc:4;
+  uint8_t marker:1;
+  uint8_t payt:7;
+#else
+  uint8_t csrc:4;
+  uint8_t ext:1;
+  uint8_t pad:1;
+  uint8_t version:2;
+  uint8_t payt:7;
+  uint8_t marker:1;
+#endif
+  uint16_t seqnum;
+  uint32_t time;
+  uint32_t ssrc;
+  unsigned char data[BLOCKING_FACTOR * GSM_FRAME_SIZE];
+};
+
+struct el_instance;
+struct el_pvt;
+
+/* Echolink node details */
+/* Also each node in binary tree in memory */
+struct el_node {
+   char ip[EL_IP_SIZE + 1]; 
+   char call[EL_CALL_SIZE + 1];
+   char name[EL_NAME_SIZE + 1];
+   unsigned int nodenum; /* not used yet */
+   short countdown;
+   uint16_t seqnum;
+   struct el_instance *instp;
+   struct el_pvt *p;
+   struct ast_channel *chan;
+};
+
+struct el_instance
+{
+	ast_mutex_t lock;
+	char name[EL_NAME_SIZE + 1];
+	char mycall[EL_CALL_SIZE + 1];
+	char myname[EL_NAME_SIZE + 1];
+	char mypwd[EL_PWD_SIZE + 1];
+	char myemail[EL_EMAIL_SIZE + 1];
+	char myqth[EL_QTH_SIZE + 1];
+	char elservers[EL_MAX_SERVERS][EL_SERVERNAME_SIZE + 1];
+	char ipaddr[EL_IP_SIZE + 1];
+	char port[EL_IP_SIZE + 1];
+	char astnode[EL_NAME_SIZE + 1];
+	char context[EL_NAME_SIZE + 1];
+	int maxstns;
+	/* missed 10 heartbeats, you're out */
+	short rtcptimeout;
+	unsigned int mynode;
+	char fdr_file[FILENAME_MAX];
+	int audio_sock;
+	int ctrl_sock;
+	uint16_t audio_port;
+	uint16_t ctrl_port;
+	int fdr;
+	unsigned long seqno;
+	int confmode;
+	struct el_pvt *confp;
+	struct gsmVoice_t audio_all_but_one;
+	struct gsmVoice_t audio_all;
+	struct el_node el_node_test;
+
+} ;
+
+struct el_rxqast {
+	struct el_rxqast *qe_forw;
+	struct el_rxqast *qe_back;
+	char buf[GSM_FRAME_SIZE];
+};
+
+struct el_rxqel {
+        struct el_rxqel *qe_forw;
+        struct el_rxqel *qe_back;
+        char buf[BLOCKING_FACTOR * GSM_FRAME_SIZE];
+        char fromip[EL_IP_SIZE + 1];
+};
+
+struct el_pvt {
+	struct ast_channel *owner;
+	struct el_instance *instp;
+	char app[16];		
+	char stream[80];
+	char ip[EL_IP_SIZE + 1]; 
+	char txkey;
+	int rxkey;
+	int keepalive;
+	struct ast_frame fr;	
+	int txindex;
+	struct el_rxqast rxqast;
+        struct el_rxqel rxqel;
+	char firstsent;
+	char firstheard;
+	struct ast_dsp *dsp;
+	struct ast_module_user *u;
+	struct ast_trans_pvt *xpath;
+	unsigned int nodenum;
+};
+
+struct rtcp_sdes_request_item {
+    unsigned char r_item;
+    char *r_text;
+};
+
+struct rtcp_sdes_request {
+   int nitems;
+   unsigned char ssrc[4];
+   struct rtcp_sdes_request_item item[10];
+};
+
+struct rtcp_common_t {
+#ifdef RTP_BIG_ENDIAN
+  uint8_t version:2;
+  uint8_t p:1;
+  uint8_t count:5;
+#else
+  uint8_t count:5;
+  uint8_t p:1;
+  uint8_t version:2;
+#endif
+  uint8_t pt:8;
+  uint16_t length;
+};
+
+struct rtcp_sdes_item_t {
+  uint8_t type;
+  uint8_t length;
+  char data[1];
+};
+
+struct rtcp_t {
+  struct rtcp_common_t common;
+  union {
+    struct {
+      uint32_t src[1];
+    } bye;
+
+    struct rtcp_sdes_t {
+      uint32_t src;
+      struct rtcp_sdes_item_t item[1];
+    } sdes;
+  } r;
+};
+
+int debug = 0;
+struct el_instance *instances[EL_MAX_INSTANCES];
+int ninstances = 0;
+
+/* binary search tree in memory, root node */
+static void *el_node_list = NULL;
+
+/* Echolink registration thread */
+static  pthread_t el_register_thread;
+static  pthread_t el_reader_thread;
+static  pthread_t el_directory_thread;
+static int run_forever = 1;
+
+static char *config = "echolink.conf";
+
+#ifdef OLD_ASTERISK
+#define ast_free free
+#define ast_malloc malloc
+#endif
+
+static struct ast_channel *el_request(const char *type, int format, void *data, int *cause);
+static int el_call(struct ast_channel *ast, char *dest, int timeout);
+static int el_hangup(struct ast_channel *ast);
+static struct ast_frame *el_xread(struct ast_channel *ast);
+static int el_xwrite(struct ast_channel *ast, struct ast_frame *frame);
+static int el_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen);
+static int el_digit_begin(struct ast_channel *c, char digit);
+static int el_digit_end(struct ast_channel *c, char digit, unsigned int duratiion);
+static int el_text(struct ast_channel *c, const char *text);
+
+static int rtcp_make_sdes(unsigned char *pkt, int pktLen, char *call, char *name);
+static int rtcp_make_bye(unsigned char *p, char *reason);
+static void parse_sdes(unsigned char *packet, struct rtcp_sdes_request *r);
+static void copy_sdes_item(char *source, char *dest, int destlen);
+static int is_rtcp_bye(unsigned char *p, int len);
+static int is_rtcp_sdes(unsigned char *p, int len);
+ /* remove binary tree functions if Asterisk has similar functionality */
+static int compare_ip(const void *pa, const void *pb);
+static void send_audio_all_but_one(const void *nodep, const VISIT which, const int depth);
+static void send_audio_all(const void *nodep, const VISIT which, const int depth);
+static void send_heartbeat(const void *nodep, const VISIT which, const int depth);
+static void print_users(const void *nodep, const VISIT which, const int depth);
+static void free_node(void *nodep);
+static void process_cmd(char *buf,char *fromip,struct el_instance *instp);
+static int find_delete(struct el_node *key);
+static int sendcmd(char *server,struct el_instance *instp);
+static int do_new_call(struct el_instance *instp, struct el_pvt *p, char *call, char *name);
+
+/* remove writen if Asterisk has similar functionality */
+static int writen(int fd, char *ptr, int nbytes);
+
+static const struct ast_channel_tech el_tech = {
+	.type = type,
+	.description = tdesc,
+	.capabilities = AST_FORMAT_GSM,
+	.requester = el_request,
+	.call = el_call,
+	.hangup = el_hangup,
+	.read = el_xread,
+	.write = el_xwrite,
+	.indicate = el_indicate,
+	.send_text = el_text,
+	.send_digit_begin = el_digit_begin,
+	.send_digit_end = el_digit_end,
+};
+
+static int rtcp_make_sdes(unsigned char *pkt, int pktLen, char *call, char *name)
+{
+    unsigned char zp[1500];
+    unsigned char *p = zp;
+    struct rtcp_t *rp;
+    unsigned char *ap;
+    char line[EL_CALL_SIZE + EL_NAME_SIZE + 1];
+    int l, hl, pl;
+
+    hl = 0;
+    *p++ = 3 << 6;
+    *p++ = 201;
+    *p++ = 0;
+    *p++ = 1;
+    *((long *) p) = htonl(0);
+    p += 4;
+    hl = 8;
+
+    rp = (struct rtcp_t *) p;
+    *((short *) p) = htons((3 << 14) | 202 | (1 << 8));
+    rp->r.sdes.src = htonl(0);
+    ap = (unsigned char *) rp->r.sdes.item;
+
+    strncpy(line,"CALLSIGN",EL_CALL_SIZE + EL_NAME_SIZE);
+    *ap++ = 1;
+    *ap++ = l = strlen(line);
+    memcpy(ap,line,l);
+    ap += l;
+
+    snprintf(line,EL_CALL_SIZE + EL_NAME_SIZE,"%s %s",call,name);
+    *ap++ = 2;
+    *ap++ = l = strlen(line);
+    memcpy(ap,line,l); 
+    ap += l;
+
+    /* enable DTMF keypad */
+    *ap++ = 8;
+    *ap++ = 3;
+    *ap++ = 1;
+    *ap++ = 'D';
+    *ap++ = '1';
+
+    *ap++ = 0;
+    *ap++ = 0;
+    l = ap - p;
+
+    rp->common.length = htons(((l + 3) / 4) - 1);
+    l = hl + ((ntohs(rp->common.length) + 1) * 4);
+
+    pl = (l & 4) ? l : l + 4;
+
+    if (pl > l) {
+       int pad = pl - l;
+       memset(zp + l, '\0', pad);  
+       zp[pl - 1] = pad;
+       p[0] |= 0x20;
+       rp->common.length = htons(ntohs(rp->common.length) + ((pad) / 4));
+       l = pl;
+    }
+
+    if (l > pktLen)
+       return 0;
+    memcpy(pkt,zp,l);
+    return l;
+}
+
+static int rtcp_make_bye(unsigned char *p, char *reason)
+{
+    struct rtcp_t *rp;
+    unsigned char *ap, *zp;
+    int l, hl, pl;
+
+    zp = p;
+    hl = 0;
+
+    *p++ = 3 << 6;
+    *p++ = 201;
+    *p++ = 0;
+    *p++ = 1;
+    *((long *) p) = htonl(0);
+    p += 4;
+    hl = 8;
+
+    rp = (struct rtcp_t *)p;
+    *((short *) p) = htons((3 << 14) | 203 | (1 << 8));
+    rp->r.bye.src[0] = htonl(0);
+    ap = (unsigned char *) rp->r.sdes.item;
+    l = 0; 
+    if (reason != NULL) {
+        l = strlen(reason);
+        if (l > 0) {
+            *ap++ = l;
+             memcpy(ap,reason,l);
+            ap += l;
+        }
+    }
+    while ((ap - p) & 3)
+        *ap++ = 0;
+    l = ap - p;
+    rp->common.length = htons((l / 4) - 1);
+    l = hl + ((ntohs(rp->common.length) + 1) * 4);
+
+    pl = (l & 4) ? l : l + 4;
+    if (pl > l) {
+       int pad = pl - l;
+       memset(zp + l, '\0', pad);
+       zp[pl - 1] = pad;
+       p[0] |= 0x20;
+       rp->common.length = htons(ntohs(rp->common.length) + ((pad) / 4));
+       l = pl;    
+    }
+    return l;
+}
+
+static void parse_sdes(unsigned char *packet, struct rtcp_sdes_request *r)
+{
+    int i;
+    unsigned char *p = packet;
+
+    for (i = 0; i < r->nitems; i++)
+        r->item[i].r_text = NULL;
+
+    while ((p[0] >> 6 & 3) == 3 || (p[0] >> 6 & 3) == 1) {
+        if ((p[1] == 202) && ((p[0] & 0x1F) > 0)) {
+            unsigned char *cp = p + 8,
+                          *lp = cp + (ntohs(*((short *) (p + 2))) + 1) * 4;
+            memcpy(r->ssrc, p + 4, 4); 
+            while (cp < lp) {
+                unsigned char itype = *cp;
+                if (itype == 0)
+                    break;
+
+                for (i = 0; i < r->nitems; i++) {
+                    if (r->item[i].r_item == itype &&
+                        r->item[i].r_text == NULL) {
+                        r->item[i].r_text = (char *) cp;
+                        break;
+                    }
+                }
+                cp += cp[1] + 2;
+            }
+            break;
+        }
+        p += (ntohs(*((short *) (p + 2))) + 1) * 4;
+    }
+    return;
+}
+
+static void copy_sdes_item(char *source, char *dest, int destlen)
+{
+    int len = source[1] & 0xFF;
+    if (len > destlen)
+       len = destlen;
+    memcpy(dest,source + 2, len);
+    dest[len] = 0;
+    return;
+}
+
+static int is_rtcp_bye(unsigned char *p, int len)
+{
+    unsigned char *end;
+    int sawbye = 0;
+
+
+    if ((((p[0] >> 6) & 3) != 3 && ((p[0] >> 6) & 3) != 1) ||
+        ((p[0] & 0x20) != 0) ||
+        ((p[1] != 200) && (p[1] != 201)))
+      return 0;
+
+    end = p + len;
+
+    do {
+        if (p[1] == 203)
+            sawbye = 1;
+
+        p += (ntohs(*((short *) (p + 2))) + 1) * 4;
+    } while (p < end && (((p[0] >> 6) & 3) == 3));
+
+    return sawbye;
+}
+
+static int is_rtcp_sdes(unsigned char *p, int len)
+{
+    unsigned char *end;
+    int sawsdes = 0;
+
+    if ((((p[0] >> 6) & 3) != 3 && ((p[0] >> 6) & 3) != 1) ||
+        ((p[0] & 0x20) != 0) ||
+        ((p[1] != 200) && (p[1] != 201)))
+      return 0;
+
+    end = p + len;
+    do {
+       if (p[1] == 202)
+          sawsdes = 1;
+
+        p += (ntohs(*((short *) (p + 2))) + 1) * 4;
+    } while (p < end && (((p[0] >> 6) & 3) == 3));
+
+    return sawsdes;
+}
+
+static int el_call(struct ast_channel *ast, char *dest, int timeout)
+{
+	struct el_pvt *p = ast->tech_pvt;
+	struct el_instance *instp = p->instp;
+	char buf[100];
+
+
+	if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
+		ast_log(LOG_WARNING, "el_call called on %s, neither down nor reserved\n", ast->name);
+		return -1;
+	}
+	/* When we call, it just works, really, there's no destination...  Just
+	   ring the phone and wait for someone to answer */
+//	if (option_debug)
+		ast_log(LOG_NOTICE, "Calling %s on %s\n", dest, ast->name);
+	if (*dest)  /* if number specified */
+	{
+		char *str,*cp;
+
+		str = strdup(dest);
+		cp = strchr(str,'/');
+		if (cp) *cp++ = 0; else cp = str;
+		snprintf(buf,sizeof(buf) - 1,"o.conip %s",cp);
+		free(str);
+		ast_mutex_lock(&instp->lock);
+		strcpy(instp->el_node_test.ip,cp);
+		do_new_call(instp,p,"OUTBOUND","OUTBOUND");
+		process_cmd(buf,"127.0.0.1",instp);
+		ast_mutex_unlock(&instp->lock);
+	}
+	ast_setstate(ast,AST_STATE_RINGING);
+	return 0;
+}
+
+static void el_destroy(struct el_pvt *p)
+{
+	if (p->dsp) ast_dsp_free(p->dsp);
+	if (p->xpath) ast_translator_free_path(p->xpath);
+	ast_module_user_remove(p->u);
+	ast_free(p);
+}
+
+static struct el_pvt *el_alloc(void *data)
+{
+	struct el_pvt *p;
+	int n;
+	/* int flags = 0; */
+	char stream[256];
+        
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(idstr);
+	);
+
+	if (ast_strlen_zero(data)) return NULL;
+
+	AST_STANDARD_APP_ARGS(args,data);
+
+	for(n = 0; n < ninstances; n++)
+	{
+		if (!strcmp(instances[n]->name,args.idstr)) break;
+	}
+	if (n >= ninstances)
+	{
+		ast_log(LOG_NOTICE,"Cannot find echolink channel %s\n",args.idstr);
+		return NULL;
+	}
+
+	p = ast_malloc(sizeof(struct el_pvt));
+	if (p) {
+		memset(p, 0, sizeof(struct el_pvt));
+		
+		sprintf(stream,"%s-%lu",args.idstr,instances[n]->seqno++);
+		strcpy(p->stream,stream);
+		p->rxqast.qe_forw = &p->rxqast;
+		p->rxqast.qe_back = &p->rxqast;
+
+                p->rxqel.qe_forw = &p->rxqel;
+                p->rxqel.qe_back = &p->rxqel;
+                
+		p->keepalive = KEEPALIVE_TIME;
+		p->instp = instances[n];
+		p->instp->confp = p;  /* save for conference mode */
+		if (!p->instp->confmode)
+		{
+			p->dsp = ast_dsp_new();
+			if (!p->dsp)
+			{
+				ast_log(LOG_ERROR,"Cannot get DSP!!\n");
+				return NULL;
+			}
+#ifdef  NEW_ASTERISK
+	                ast_dsp_set_features(p->dsp,DSP_FEATURE_DIGIT_DETECT);
+	                ast_dsp_set_digitmode(p->dsp,DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_RELAXDTMF);
+#else
+	                ast_dsp_set_features(p->dsp,DSP_FEATURE_DTMF_DETECT);
+	                ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_RELAXDTMF);
+#endif
+			p->xpath = ast_translator_build_path(AST_FORMAT_SLINEAR,AST_FORMAT_GSM);
+			if (!p->xpath)
+			{
+				ast_log(LOG_ERROR,"Cannot get translator!!\n");
+				return NULL;
+			}
+		}
+	}
+	return p;
+}
+
+static int el_hangup(struct ast_channel *ast)
+{
+	struct el_pvt *p = ast->tech_pvt;
+	struct el_instance *instp = p->instp;
+	int i,n;
+        unsigned char bye[50];
+	struct sockaddr_in sin;
+
+	if (!instp->confmode)
+	{
+		if (debug) ast_log(LOG_DEBUG,"Sent bye to IP address %s\n",p->ip);
+		ast_mutex_lock(&instp->lock);
+		strcpy(instp->el_node_test.ip,p->ip);
+		find_delete(&instp->el_node_test);
+		ast_mutex_unlock(&instp->lock);
+		n = rtcp_make_bye(bye,"disconnected");
+		sin.sin_family = AF_INET;
+		sin.sin_addr.s_addr = inet_addr(p->ip);
+		sin.sin_port = htons(instp->ctrl_port);
+		for (i = 0; i < 20; i++)
+		{
+			sendto(instp->ctrl_sock, bye, n,
+				0,(struct sockaddr *)&sin,sizeof(sin));
+		}
+	}		
+	if (option_debug)
+		ast_log(LOG_DEBUG, "el_hangup(%s)\n", ast->name);
+	if (!ast->tech_pvt) {
+		ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
+		return 0;
+	}
+	el_destroy(p);
+	ast->tech_pvt = NULL;
+	ast_setstate(ast, AST_STATE_DOWN);
+	return 0;
+}
+
+static int el_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
+{
+	struct el_pvt *p = ast->tech_pvt;
+
+	switch (cond) {
+		case AST_CONTROL_RADIO_KEY:
+			p->txkey = 1;
+			break;
+		case AST_CONTROL_RADIO_UNKEY:
+			p->txkey = 0;
+			break;
+		case AST_CONTROL_HANGUP:
+			return -1;
+		default:
+			return 0;
+	}
+
+	return 0;
+}
+
+static int el_digit_begin(struct ast_channel *ast, char digit)
+{
+	return -1;
+}
+
+static int el_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
+{
+	return -1;
+}
+
+static int el_text(struct ast_channel *ast, const char *text)
+{
+	struct el_pvt *p = ast->tech_pvt;
+	char *cmd = NULL,*arg1 = NULL,*arg2 = NULL;
+	char *arg3 = NULL,delim = ' ',*saveptr;
+	char buf[200],*ptr,str[200],*arg4 = NULL;
+
+	strncpy(buf,text,sizeof(buf) - 1);
+	ptr = strchr(buf, (int)'\r'); 
+	if (ptr) *ptr = '\0';
+	ptr = strchr(buf, (int)'\n');    
+	if (ptr) *ptr = '\0';
+	cmd = strtok_r(buf, &delim, &saveptr);
+	if (!cmd)
+	{
+		return 0;
+	}
+
+	arg1 = strtok_r(NULL, &delim, &saveptr);
+	arg2 = strtok_r(NULL, &delim, &saveptr);
+	arg3 = strtok_r(NULL, &delim, &saveptr);
+	arg4 = strtok_r(NULL, &delim, &saveptr);
+
+	if (!strcasecmp(cmd,"D"))
+	{
+		sprintf(str,"3%06u",p->nodenum);
+		/* if not for this one, we cant go any farther */
+		if (strcmp(arg1,str)) return 0;
+		ast_senddigit(ast,*arg4);
+		return 0;
+	}
+	return 0;
+}
+
+static int compare_ip(const void *pa, const void *pb)
+{
+   return strncmp(((struct el_node *)pa)->ip,((struct el_node *)pb)->ip,EL_IP_SIZE); 
+}
+
+/* Echolink ---> Echolink */
+void send_audio_all_but_one(const void *nodep, const VISIT which, const int depth) 
+{
+   struct sockaddr_in sin;
+   struct el_instance *instp = (*(struct el_node **)nodep)->instp;
+
+   if ((which == leaf) || (which == postorder)) {
+      if (strncmp((*(struct el_node **)nodep)->ip, instp->el_node_test.ip,EL_IP_SIZE) != 0) {
+         sin.sin_family = AF_INET;
+         sin.sin_port = htons(instp->audio_port);
+         sin.sin_addr.s_addr = inet_addr((*(struct el_node **)nodep)->ip);
+
+         instp->audio_all_but_one.version = 3;
+         instp->audio_all_but_one.pad = 0;
+         instp->audio_all_but_one.ext = 0;
+         instp->audio_all_but_one.csrc = 0;
+         instp->audio_all_but_one.marker = 0;
+         instp->audio_all_but_one.payt = 3;
+         instp->audio_all_but_one.seqnum = htons((*(struct el_node **)nodep)->seqnum++); 
+         instp->audio_all_but_one.time = htonl(0);
+         instp->audio_all_but_one.ssrc = instp->mynode;
+
+         /*
+         ast_log(LOG_NOTICE, "sending to %s(%s)\n", 
+                  (*(struct el_node **)nodep)->call, (*(struct el_node **)nodep)->ip);
+         */
+        
+         sendto(instp->audio_sock, (char *)&instp->audio_all_but_one, sizeof(instp->audio_all_but_one),
+                0,(struct sockaddr *)&sin,sizeof(sin));
+      }
+   }
+}
+
+static void send_audio_only_one(const void *nodep, const VISIT which, const int depth) 
+{
+   struct sockaddr_in sin;
+   struct el_instance *instp = (*(struct el_node **)nodep)->instp;
+
+   if ((which == leaf) || (which == postorder)) {
+      if (strncmp((*(struct el_node **)nodep)->ip, instp->el_node_test.ip,EL_IP_SIZE) == 0) {
+         sin.sin_family = AF_INET;
+         sin.sin_port = htons(instp->audio_port);
+         sin.sin_addr.s_addr = inet_addr((*(struct el_node **)nodep)->ip);
+
+      instp->audio_all.version = 3;
+      instp->audio_all.pad = 0;
+      instp->audio_all.ext = 0;
+      instp->audio_all.csrc = 0;
+      instp->audio_all.marker = 0;
+      instp->audio_all.payt = 3;
+      instp->audio_all.seqnum = htons((*(struct el_node **)nodep)->seqnum++);
+      instp->audio_all.time = htonl(0);
+      instp->audio_all.ssrc = instp->mynode;
+
+      /*
+      ast_log(LOG_NOTICE, "sending to %s(%s)\n", 
+                  (*(struct el_node **)nodep)->call, (*(struct el_node **)nodep)->ip);
+      */
+      sendto(instp->audio_sock, (char *)&instp->audio_all, sizeof(instp->audio_all), 
+             0,(struct sockaddr *)&sin,sizeof(sin));
+      }
+   }
+}
+
+/* Asterisk ---> Echolink */
+void send_audio_all(const void *nodep, const VISIT which, const int depth)
+{
+   struct sockaddr_in sin;
+   struct el_instance *instp = (*(struct el_node **)nodep)->instp;
+
+   if ((which == leaf) || (which == postorder)) {
+      sin.sin_family = AF_INET;
+      sin.sin_port = htons(instp->audio_port);
+      sin.sin_addr.s_addr = inet_addr((*(struct el_node **)nodep)->ip);
+
+      instp->audio_all.version = 3;
+      instp->audio_all.pad = 0;
+      instp->audio_all.ext = 0;
+      instp->audio_all.csrc = 0;
+      instp->audio_all.marker = 0;
+      instp->audio_all.payt = 3;
+      instp->audio_all.seqnum = htons((*(struct el_node **)nodep)->seqnum++);
+      instp->audio_all.time = htonl(0);
+      instp->audio_all.ssrc = instp->mynode;
+
+      /*
+      ast_log(LOG_NOTICE, "sending to %s(%s)\n", 
+                  (*(struct el_node **)nodep)->call, (*(struct el_node **)nodep)->ip);
+      */
+      sendto(instp->audio_sock, (char *)&instp->audio_all, sizeof(instp->audio_all), 
+             0,(struct sockaddr *)&sin,sizeof(sin));
+   }
+}
+
+static void print_users(const void *nodep, const VISIT which, const int depth)
+{
+   if ((which == leaf) || (which == postorder)) {
+      ast_log(LOG_NOTICE,"call=%s,ip=%s,name=%s\n",
+             (*(struct el_node **)nodep)->call,
+             (*(struct el_node **)nodep)->ip,
+             (*(struct el_node **)nodep)->name);
+   }
+}
+
+static void send_heartbeat(const void *nodep, const VISIT which, const int depth)
+{
+   struct sockaddr_in sin;
+   unsigned char  sdes_packet[256];
+   int sdes_length;
+   struct el_instance *instp = (*(struct el_node **)nodep)->instp;
+
+   if ((which == leaf) || (which == postorder)) {
+
+      if ((*(struct el_node **)nodep)->countdown >= 0)
+         (*(struct el_node **)nodep)->countdown --;
+  
+      if ((*(struct el_node **)nodep)->countdown < 0) {
+         strncpy(instp->el_node_test.ip,(*(struct el_node **)nodep)->ip,EL_IP_SIZE);
+         strncpy(instp->el_node_test.call,(*(struct el_node **)nodep)->call,EL_CALL_SIZE);
+         ast_log(LOG_NOTICE,"countdown for %s(%s) negative\n",instp->el_node_test.call,instp->el_node_test.ip);
+      }
+      memset(sdes_packet,0,sizeof(sdes_packet));
+      sdes_length = rtcp_make_sdes(sdes_packet,sizeof(sdes_packet),
+	instp->mycall,instp->myname);
+
+      sin.sin_family = AF_INET;
+      sin.sin_port = htons(instp->ctrl_port);
+      sin.sin_addr.s_addr = inet_addr((*(struct el_node **)nodep)->ip);
+      sendto(instp->ctrl_sock, sdes_packet, sdes_length, 
+             0,(struct sockaddr *)&sin,sizeof(sin));
+   }
+}
+
+static void free_node(void *nodep)
+{
+}
+
+static int find_delete(struct el_node *key)
+{
+   int found = 0;
+   struct el_node **found_key = NULL;
+
+   found_key = (struct el_node **)tfind(key, &el_node_list, compare_ip);
+   if (found_key) {
+       if (debug) ast_log(LOG_DEBUG,"...removing %s(%s)\n", (*found_key)->call, (*found_key)->ip); 
+       found = 1;
+       if (!(*found_key)->instp->confmode) 
+		ast_softhangup((*found_key)->chan,AST_SOFTHANGUP_DEV);
+       tdelete(key, &el_node_list, compare_ip);
+   }
+   return found;
+}
+
+static void process_cmd(char *buf, char *fromip,struct el_instance *instp)
+{
+   char *cmd = NULL;
+   char *arg1 = NULL;
+   char *arg2 = NULL;
+   char *arg3 = NULL;
+
+   char delim = ' ';
+   char *saveptr;
+   char *ptr;
+   struct sockaddr_in sin;
+   unsigned char  pack[256];
+   int pack_length;
+   unsigned short i;
+   struct el_node key;
+
+   if (strncmp(fromip,"127.0.0.1",EL_IP_SIZE) != 0)
+      return;
+   ptr = strchr(buf, (int)'\r'); 
+   if (ptr)
+      *ptr = '\0';
+   ptr = strchr(buf, (int)'\n');    
+   if (ptr)
+      *ptr = '\0';
+
+   /* all commands with no arguments go first */
+
+   if (strcmp(buf,"o.users") == 0) {
+      twalk(el_node_list, print_users);
+      return;
+   }
+
+   if (strcmp(buf, "o.rec") == 0) {
+      if (instp->fdr >= 0) {
+         close(instp->fdr);
+         instp->fdr = -1;
+         ast_log(LOG_NOTICE, "rec stopped\n");
+      }
+      else {
+         instp->fdr = open(instp->fdr_file, O_CREAT | O_WRONLY | O_APPEND | O_TRUNC, 
+                    S_IRUSR | S_IWUSR);
+         if (instp->fdr >= 0)
+            ast_log(LOG_NOTICE, "rec into %s started\n", instp->fdr_file);
+      }
+      return;
+   }
+
+   cmd = strtok_r(buf, &delim, &saveptr);
+   if (!cmd)
+   {
+      return;
+   }
+
+   /* This version:  up to 3 parameters */
+   arg1 = strtok_r(NULL, &delim, &saveptr);
+   arg2 = strtok_r(NULL, &delim, &saveptr);
+   arg3 = strtok_r(NULL, &delim, &saveptr);
+
+   if ((strcmp(cmd, "o.conip") == 0) ||
+       (strcmp(cmd, "o.dconip") == 0)) {
+      if (!arg1)
+      {
+         return;
+      }
+
+      if (strcmp(cmd, "o.conip") == 0)
+         pack_length = rtcp_make_sdes(pack,sizeof(pack),instp->mycall,instp->myname);
+      else
+         pack_length = rtcp_make_bye(pack,"bye");
+      sin.sin_family = AF_INET;
+      sin.sin_port = htons(instp->ctrl_port);
+      sin.sin_addr.s_addr = inet_addr(arg1);
+
+      if (strcmp(cmd, "o.dconip") == 0) {
+           strncpy(key.ip,arg1,EL_IP_SIZE);
+           if (find_delete(&key)) {
+              for (i = 0; i < 20; i++)
+                 sendto(instp->ctrl_sock, pack, pack_length,
+                        0,(struct sockaddr *)&sin,sizeof(sin));
+              ast_log(LOG_NOTICE,"disconnect request sent to %s\n",key.ip);
+           }
+           else
+              ast_log(LOG_NOTICE, "Did not find ip=%s to request disconnect\n",key.ip);
+      }
+      else {
+         for (i = 0; i < 20; i++)
+	 {
+            sendto(instp->ctrl_sock, pack, pack_length,
+                   0,(struct sockaddr *)&sin,sizeof(sin));
+	 }
+         ast_log(LOG_NOTICE,"connect request sent to %s\n", arg1);
+      }
+      return;
+   }
+   return;
+}
+
+static struct ast_frame  *el_xread(struct ast_channel *ast)
+{
+	struct el_pvt *p = ast->tech_pvt;
+  
+        p->fr.frametype = 0;
+        p->fr.subclass = 0;
+        p->fr.datalen = 0;
+        p->fr.samples = 0;
+        p->fr.data =  NULL;
+        p->fr.src = type;
+        p->fr.offset = 0;
+        p->fr.mallocd=0;
+        p->fr.delivery.tv_sec = 0;
+        p->fr.delivery.tv_usec = 0;
+        return &p->fr;
+}
+
+static int el_xwrite(struct ast_channel *ast, struct ast_frame *frame)
+{
+        int bye_length;
+        unsigned char bye[50];
+        unsigned short i;
+        struct sockaddr_in sin;
+	struct el_pvt *p = ast->tech_pvt;
+	struct el_instance *instp = p->instp;
+	struct ast_frame fr,*f1, *f2;
+	struct el_rxqast *qpast;
+	int n,m,x;
+        struct el_rxqel *qpel;
+	char buf[GSM_FRAME_SIZE + AST_FRIENDLY_OFFSET];
+
+	if (frame->frametype != AST_FRAME_VOICE) return 0;
+
+	if (!p->firstsent)
+	{
+		struct sockaddr_in sin;
+		unsigned char  sdes_packet[256];
+		int sdes_length;
+
+		p->firstsent = 1;
+		memset(sdes_packet,0,sizeof(sdes_packet));
+		sdes_length = rtcp_make_sdes(sdes_packet,sizeof(sdes_packet),
+			instp->mycall,instp->myname);
+
+		sin.sin_family = AF_INET;
+		sin.sin_port = htons(instp->ctrl_port);
+		sin.sin_addr.s_addr = inet_addr(p->ip);
+		sendto(instp->ctrl_sock, sdes_packet, sdes_length, 
+			0,(struct sockaddr *)&sin,sizeof(sin));
+	}
+
+        /* Echolink to Asterisk */
+	if (p->rxqast.qe_forw != &p->rxqast) {
+		for(n = 0,qpast = p->rxqast.qe_forw; qpast != &p->rxqast; qpast = qpast->qe_forw) {
+			n++;
+		}
+		if (n > QUEUE_OVERLOAD_THRESHOLD_AST) {
+			while(p->rxqast.qe_forw != &p->rxqast) {
+				qpast = p->rxqast.qe_forw;
+				remque((struct qelem *)qpast);
+				ast_free(qpast);
+			}
+			if (p->rxkey) p->rxkey = 1;
+		} else {		
+			if (!p->rxkey) {
+				fr.datalen = 0;
+				fr.samples = 0;
+				fr.frametype = AST_FRAME_CONTROL;
+				fr.subclass = AST_CONTROL_RADIO_KEY;
+				fr.data =  0;
+				fr.src = type;
+				fr.offset = 0;
+				fr.mallocd=0;
+				fr.delivery.tv_sec = 0;
+				fr.delivery.tv_usec = 0;
+				ast_queue_frame(ast,&fr);
+			} 
+			p->rxkey = MAX_RXKEY_TIME;
+			qpast = p->rxqast.qe_forw;
+			remque((struct qelem *)qpast);
+			memcpy(buf + AST_FRIENDLY_OFFSET,qpast->buf,GSM_FRAME_SIZE);
+			ast_free(qpast);
+
+			fr.datalen = GSM_FRAME_SIZE;
+			fr.samples = 160;
+			fr.frametype = AST_FRAME_VOICE;
+			fr.subclass = AST_FORMAT_GSM;
+			fr.data =  buf + AST_FRIENDLY_OFFSET;
+			fr.src = type;
+			fr.offset = AST_FRIENDLY_OFFSET;
+			fr.mallocd=0;
+			fr.delivery.tv_sec = 0;
+			fr.delivery.tv_usec = 0;
+
+			x = 0;
+			if (p->dsp && (!instp->confmode))
+			{
+				f2 = ast_translate(p->xpath,&fr,0);
+				f1 = ast_dsp_process(NULL,p->dsp,f2);
+				ast_frfree(f2);
+				if ((f1->frametype == AST_FRAME_DTMF_END) ||
+					(f1->frametype == AST_FRAME_DTMF_BEGIN))
+				{
+					if ((f1->subclass != 'm') && (f1->subclass != 'u'))
+					{
+						if (f1->frametype == AST_FRAME_DTMF_END)
+							ast_log(LOG_NOTICE,"Echolink %s Got DTMF char %c from IP %s\n",p->stream,f1->subclass,p->ip);
+						ast_queue_frame(ast,f1);
+						x = 1;
+					}
+				}
+				ast_frfree(f1);
+			} 
+			if (!x) ast_queue_frame(ast,&fr);
+		}
+	}
+	if (p->rxkey == 1) {
+		fr.datalen = 0;
+		fr.samples = 0;
+		fr.frametype = AST_FRAME_CONTROL;
+		fr.subclass = AST_CONTROL_RADIO_UNKEY;
+		fr.data =  0;
+		fr.src = type;
+		fr.offset = 0;
+		fr.mallocd=0;
+		fr.delivery.tv_sec = 0;
+		fr.delivery.tv_usec = 0;
+		ast_queue_frame(ast,&fr);
+	} 
+	if (p->rxkey) p->rxkey--;
+
+        if (instp->confmode && (p->rxqel.qe_forw != &p->rxqel))
+        {
+           for(m = 0,qpel = p->rxqel.qe_forw; qpel != &p->rxqel; qpel = qpel->qe_forw) 
+              m++;
+
+           if (m > QUEUE_OVERLOAD_THRESHOLD_EL)
+           {
+              while(p->rxqel.qe_forw != &p->rxqel) 
+              {
+                 qpel = p->rxqel.qe_forw;
+                 remque((struct qelem *)qpel);
+                 ast_free(qpel);
+              }
+           } 
+           else 
+           {
+              qpel = p->rxqel.qe_forw;
+              remque((struct qelem *)qpel);
+
+              memcpy(instp->audio_all_but_one.data,qpel->buf,BLOCKING_FACTOR * GSM_FRAME_SIZE);
+              strncpy(instp->el_node_test.ip, qpel->fromip, EL_IP_SIZE);
+
+              ast_free(qpel);
+	      ast_mutex_lock(&instp->lock);
+              twalk(el_node_list, send_audio_all_but_one);
+	      ast_mutex_unlock(&instp->lock);
+
+              if (instp->fdr >= 0)
+                 write(instp->fdr, instp->audio_all_but_one.data, BLOCKING_FACTOR * GSM_FRAME_SIZE);
+           }
+        }
+        else
+        {
+           /* Asterisk to Echolink */
+           if (!(frame->subclass & (AST_FORMAT_GSM))) {
+                ast_log(LOG_WARNING, "Cannot handle frames in %d format\n", frame->subclass);
+		ast_mutex_unlock(&instp->lock);
+                return 0;
+           }
+           if (p->txkey || p->txindex)  {
+                memcpy(instp->audio_all.data + (GSM_FRAME_SIZE * p->txindex++), frame->data,GSM_FRAME_SIZE);
+           }      
+           if (p->txindex >= BLOCKING_FACTOR) {
+		ast_mutex_lock(&instp->lock);
+                if (instp->confmode)
+		{
+			twalk(el_node_list, send_audio_all);
+		}
+		else
+		{
+			strcpy(instp->el_node_test.ip,p->ip);
+			twalk(el_node_list, send_audio_only_one);
+		}
+		ast_mutex_unlock(&instp->lock);
+                p->txindex = 0;
+           }
+        }
+
+	if (p->keepalive--) return 0;
+	p->keepalive = KEEPALIVE_TIME;
+
+        /* Echolink: send heartbeats and drop dead stations */
+	ast_mutex_lock(&instp->lock);
+        instp->el_node_test.ip[0] = '\0';
+        twalk(el_node_list, send_heartbeat); 
+        if (instp->el_node_test.ip[0] != '\0') {
+           if (find_delete(&instp->el_node_test)) {
+              bye_length = rtcp_make_bye(bye,"rtcp timeout");
+              sin.sin_family = AF_INET;
+              sin.sin_addr.s_addr = inet_addr(instp->el_node_test.ip);
+              sin.sin_port = htons(instp->ctrl_port);
+	      ast_mutex_lock(&instp->lock);
+              for (i = 0; i < 20; i++)
+                 sendto(instp->ctrl_sock, bye, bye_length,
+                        0,(struct sockaddr *)&sin,sizeof(sin));
+	      ast_mutex_unlock(&instp->lock);
+              ast_log(LOG_NOTICE,"call=%s RTCP timeout, removing\n",instp->el_node_test.call);
+           }
+           instp->el_node_test.ip[0] = '\0';
+        } 
+	ast_mutex_unlock(&instp->lock);
+	return 0;
+}
+
+static struct ast_channel *el_new(struct el_pvt *i, int state, unsigned int nodenum)
+{
+	struct ast_channel *tmp;
+	struct el_instance *instp = i->instp;
+
+	tmp = ast_channel_alloc(1, state, 0, 0, "", instp->astnode, instp->context, 0, "echolink/%s", i->stream);
+	if (tmp) {
+		tmp->tech = &el_tech;
+		tmp->nativeformats = prefformat;
+		tmp->rawreadformat = prefformat;
+		tmp->rawwriteformat = prefformat;
+		tmp->writeformat = prefformat;
+		tmp->readformat = prefformat;
+		if (state == AST_STATE_RING)
+			tmp->rings = 1;
+		tmp->tech_pvt = i;
+		ast_copy_string(tmp->context, instp->context, sizeof(tmp->context));
+		ast_copy_string(tmp->exten, instp->astnode,  sizeof(tmp->exten));
+		ast_string_field_set(tmp, language, "");
+		if (nodenum > 0)
+		{
+			char tmpstr[30];
+
+			sprintf(tmpstr,"3%06u",nodenum);
+			ast_set_callerid(tmp,tmpstr,NULL,NULL);
+		}
+		i->owner = tmp;
+		i->u = ast_module_user_add(tmp);
+		i->nodenum = nodenum;
+		if (state != AST_STATE_DOWN) {
+			if (ast_pbx_start(tmp)) {
+				ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
+				ast_hangup(tmp);
+			}
+		}
+	} else
+		ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
+	return tmp;
+}
+
+
+static struct ast_channel *el_request(const char *type, int format, void *data, int *cause)
+{
+	int oldformat,nodenum;
+	struct el_pvt *p;
+	struct ast_channel *tmp = NULL;
+	char *str,*cp;
+	
+	oldformat = format;
+	format &= (AST_FORMAT_GSM);
+	if (!format) {
+		ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", oldformat);
+		return NULL;
+	}
+	str = strdup((char *)data);
+	cp = strchr(str,'/');
+	if (cp) *cp++ = 0;
+	nodenum = 0;
+	if (*cp && *++cp) nodenum = atoi(cp);
+	p = el_alloc(str);
+	free(str);
+	if (p) {
+		tmp = el_new(p, AST_STATE_DOWN,nodenum);
+		if (!tmp)
+			el_destroy(p);
+	}
+	return tmp;
+}
+
+static int unload_module(void)
+{
+int	n;
+
+        run_forever = 0;
+        tdestroy(el_node_list, free_node);
+	for(n = 0; n < ninstances; n++)
+	{
+		if (instances[n]->audio_sock != -1)
+		{
+			close(instances[n]->audio_sock);
+			instances[n]->audio_sock = -1;
+		}
+		if (instances[n]->ctrl_sock != -1)
+		{
+			close(instances[n]->ctrl_sock);
+			instances[n]->ctrl_sock = -1;
+		}
+	}	
+	/* First, take us out of the channel loop */
+	ast_channel_unregister(&el_tech);
+	for(n = 0; n < ninstances; n++) ast_free(instances[n]);
+	return 0;
+}
+
+/* 
+   If asterisk has a function that writes at least n bytes to a TCP socket,
+   remove writen function and use the one provided by Asterisk
+*/
+static int writen(int fd, char *ptr, int nbytes)
+{
+   int nleft, nwritten;
+   char *local_ptr;
+
+   nleft = nbytes;
+   local_ptr = ptr;
+
+   while (nleft > 0)
+   {
+      nwritten = write(fd, local_ptr, nleft);
+      if (nwritten < 0)
+         return nwritten;
+      nleft -= nwritten;
+      local_ptr += nwritten;
+   }
+   return (nbytes - nleft);
+}
+
+/* Feel free to make this code smaller, I know it works, so I use it */
+static int sendcmd(char *server, struct el_instance *instp)
+{
+  struct hostent *ahp;
+  struct ast_hostent ah;
+  struct in_addr ia;
+
+  char ip[EL_IP_SIZE + 1];
+  struct sockaddr_in el;
+  int el_len;
+  int sd;
+  int  rc;
+  time_t now;
+  struct tm *p_tm;
+  char *id = NULL;
+  const size_t LOGINSIZE = 1023;
+  char buf[LOGINSIZE + 1];
+  size_t len;
+
+  ahp = ast_gethostbyname(server,&ah);
+  if (ahp) {
+     memcpy(&ia,ahp->h_addr,sizeof(in_addr_t));
+#ifdef  OLD_ASTERISK
+     ast_inet_ntoa(ip,EL_IP_SIZE,ia);
+#else
+     strncpy(ip,ast_inet_ntoa(ia),EL_IP_SIZE);
+#endif
+  } else {
+     ast_log(LOG_NOTICE, "Failed to resolve Echolink server %s\n", server);
+     return -1;
+  }
+
+  memset(&el,0,sizeof(struct sockaddr_in));
+  el.sin_family = AF_INET;
+  el.sin_port = htons(5200);
+  el.sin_addr.s_addr =  inet_addr(ip);
+  el_len = sizeof(el);
+

[... 1014 lines stripped ...]



More information about the asterisk-commits mailing list