Version 0.1.10 from FTP

git-svn-id: http://svn.digium.com/svn/asterisk/trunk@396 f38db490-d61c-443f-a65b-d21fe96a405b

3 files changed, 1657 insertions, 0 deletions

diff --git a/res/Makefile b/res/Makefile
new file mode 100755
index 000000000..9c4bffb6c
--- /dev/null
+++ b/res/Makefile
@@ -0,0 +1,32 @@
+#
+# Asterisk -- A telephony toolkit for Linux.
+# 
+# Makefile for CDR backends (dynamically loaded)
+#
+# Copyright (C) 1999, Mark Spencer
+#
+# Mark Spencer <markster@linux-support.net>
+#
+# This program is free software, distributed under the terms of
+# the GNU General Public License
+#
+
+MODS=res_adsi.so res_parking.so res_crypto.so
+
+CRYPTO_LIBS=-lssl -lcrypto
+
+CFLAGS+=
+
+all: $(MODS)
+
+install: all
+	for x in $(MODS); do $(INSTALL) -m 755 $$x $(MODULES_DIR) ; done
+
+res_crypto.so: res_crypto.o
+	$(CC) -shared -Xlinker -x -o $@ $< $(CRYPTO_LIBS)
+
+clean:
+	rm -f *.so *.o
+
+%.so : %.o
+	$(CC) -shared -Xlinker -x -o $@ $<
diff --git a/res/res_adsi.c b/res/res_adsi.c
new file mode 100755
index 000000000..c7aad7b48
--- /dev/null
+++ b/res/res_adsi.c
@@ -0,0 +1,992 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * ADSI support 
+ * 
+ * Copyright (C) 2001, Linux Support Services, Inc.
+ *
+ * Mark Spencer <markster@linux-support.net>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ *
+ * Includes code and algorithms from the Zapata library.
+ *
+ */
+
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+#include <asterisk/ulaw.h>
+#include <asterisk/callerid.h>
+#include <asterisk/logger.h>
+#include <asterisk/fskmodem.h>
+#include <asterisk/channel.h>
+#include <asterisk/adsi.h>
+#include <asterisk/module.h>
+#include <asterisk/config.h>
+#include <asterisk/file.h>
+
+#define DEFAULT_ADSI_MAX_RETRIES 3
+
+#define ADSI_MAX_INTRO 20
+#define ADSI_MAX_SPEED_DIAL 6
+
+#define ADSI_FLAG_DATAMODE	(1 << 8)
+
+static int maxretries = DEFAULT_ADSI_MAX_RETRIES;
+
+/* Asterisk ADSI button definitions */
+#define ADSI_SPEED_DIAL		10	/* 10-15 are reserved for speed dial */
+
+static char intro[ADSI_MAX_INTRO][20];
+static int aligns[ADSI_MAX_INTRO];
+
+static char speeddial[ADSI_MAX_SPEED_DIAL][3][20];
+
+static int alignment = 0;
+
+static int adsi_generate(unsigned char *buf, int msgtype, char *msg, int msglen, int msgnum, int last)
+{
+	int sum;
+	int x;	
+	int bytes=0;
+	/* Initial carrier (imaginary) */
+	float cr = 1.0;
+	float ci = 0.0;
+	float scont = 0.0;
+
+	if (msglen > 255)
+		msglen = 255;
+
+	/* If first message, Send 150ms of MARK's */
+	if (msgnum == 1) {
+		for (x=0;x<150;x++)	/* was 150 */
+			PUT_CLID_MARKMS;
+	}
+	/* Put message type */
+	PUT_CLID(msgtype);
+	sum = msgtype;
+
+	/* Put message length (plus one  for the message number) */
+	PUT_CLID(msglen + 1);
+	sum += msglen + 1;
+
+	/* Put message number */
+	PUT_CLID(msgnum);
+	sum += msgnum;
+
+	/* Put actual message */
+	for (x=0;x<msglen;x++) {
+		PUT_CLID(msg[x]);
+		sum += msg[x];
+	}
+
+	/* Put 2's compliment of sum */
+	PUT_CLID(256-(sum & 0xff));
+
+#if 0
+	if (last) {
+		/* Put trailing marks */
+		for (x=0;x<50;x++)
+			PUT_CLID_MARKMS;
+	}
+#endif
+	return bytes;
+
+}
+
+#if 0
+static int adsi_careful_send(struct ast_channel *chan, unsigned char *buf, int len, int *remainder)
+{
+	int res;
+	fd_set fds;
+	while(len) {
+		FD_ZERO(&fds);
+		FD_SET(chan->fds[0], &fds);
+		select(chan->fds[0] + 1, NULL, &fds, NULL, NULL);
+		res = write(chan->fds[0], buf, len);
+		if (res < 1) {
+			ast_log(LOG_WARNING, "Failed to write: %s\n", strerror(errno));
+			return -1;
+		}
+		buf += res;
+		len -= res;
+	}
+	return 0;
+}
+
+#else
+static int adsi_careful_send(struct ast_channel *chan, unsigned char *buf, int len, int *remainder)
+{
+	/* Sends carefully on a full duplex channel by using reading for
+	   timing */
+	struct ast_frame *inf, outf;
+	int amt;
+
+	/* Zero out our outgoing frame */
+	memset(&outf, 0, sizeof(outf));
+
+	if (remainder && *remainder) {
+		amt = len;
+
+		/* Send remainder if provided */
+		if (amt > *remainder)
+			amt = *remainder;
+		else
+			*remainder = *remainder - amt;
+		outf.frametype = AST_FRAME_VOICE;
+		outf.subclass = AST_FORMAT_ULAW;
+		outf.data = buf;
+		outf.datalen = amt;
+		outf.timelen = amt * 8;
+		if (ast_write(chan, &outf)) {
+			ast_log(LOG_WARNING, "Failed to carefully write frame\n");
+			return -1;
+		}
+		/* Update pointers and lengths */
+		buf += amt;
+		len -= amt;
+	}
+
+	while(len) {
+		amt = len;
+		/* If we don't get anything at all back in a second, forget
+		   about it */
+		if (ast_waitfor(chan, 1000) < 1)
+			return -1;
+		inf = ast_read(chan);
+		/* Detect hangup */
+		if (!inf)
+			return -1;
+		if (inf->frametype == AST_FRAME_VOICE) {
+			/* Read a voice frame */
+			if (inf->subclass != AST_FORMAT_ULAW) {
+				ast_log(LOG_WARNING, "Channel not in ulaw?\n");
+				return -1;
+			}
+			/* Send no more than they sent us */
+			if (amt > inf->datalen)
+				amt = inf->datalen;
+			else if (remainder)
+				*remainder = inf->datalen - amt;
+			outf.frametype = AST_FRAME_VOICE;
+			outf.subclass = AST_FORMAT_ULAW;
+			outf.data = buf;
+			outf.datalen = amt;
+			outf.timelen = amt * 8;
+			if (ast_write(chan, &outf)) {
+				ast_log(LOG_WARNING, "Failed to carefully write frame\n");
+				return -1;
+			}
+			/* Update pointers and lengths */
+			buf += amt;
+			len -= amt;
+		}
+		ast_frfree(inf);
+	}
+	return 0;
+}
+#endif
+
+static int __adsi_transmit_messages(struct ast_channel *chan, unsigned char **msg, int *msglen, int *msgtype)
+{
+	/* msglen must be no more than 256 bits, each */
+	unsigned char buf[24000 * 5];
+	int pos = 0, res;
+	int x;
+	int start=0;
+	int retries = 0;
+
+	char ack[3];
+
+	/* Wait up to 500 ms for initial ACK */
+	int waittime;
+	struct ast_frame *f;
+	int rem = 0;
+
+	if (chan->adsicpe == AST_ADSI_UNAVAILABLE) {
+		/* Don't bother if we know they don't support ADSI */
+		errno = ENOSYS;
+		return -1;
+	}
+
+	while(retries < maxretries) {
+		if (!(chan->adsicpe & ADSI_FLAG_DATAMODE)) {
+			/* Generate CAS (no SAS) */
+			ast_gen_cas(buf, 0, 680);
+		
+			/* Send CAS */
+			if (adsi_careful_send(chan, buf, 680, NULL)) {
+				ast_log(LOG_WARNING, "Unable to send CAS\n");
+			}
+			/* Wait For DTMF result */
+			waittime = 500;
+			for(;;) {
+				if (((res = ast_waitfor(chan, waittime)) < 1)) {
+					/* Didn't get back DTMF A in time */
+					ast_log(LOG_DEBUG, "No ADSI CPE detected (%d)\n", res);
+					if (!chan->adsicpe)
+						chan->adsicpe = AST_ADSI_UNAVAILABLE;
+					errno = ENOSYS;
+					return -1;
+				}
+				waittime = res;
+				f = ast_read(chan);
+				if (!f) {
+					ast_log(LOG_DEBUG, "Hangup in ADSI\n");
+					return -1;
+				}
+				if (f->frametype == AST_FRAME_DTMF) {
+					if (f->subclass == 'A') {
+						/* Okay, this is an ADSI CPE.  Note this for future reference, too */
+						if (!chan->adsicpe)
+							chan->adsicpe = AST_ADSI_AVAILABLE;
+						break;
+					} else {
+						if (f->subclass == 'D')  {
+							ast_log(LOG_DEBUG, "Off-hook capable CPE only, not ADSI\n");
+						} else
+							ast_log(LOG_WARNING, "Unknown ADSI response '%c'\n", f->subclass);
+						if (!chan->adsicpe)
+							chan->adsicpe = AST_ADSI_UNAVAILABLE;
+						errno =	ENOSYS;
+						return -1;
+					}
+				}
+				ast_frfree(f);
+			}
+
+			ast_log(LOG_DEBUG, "ADSI Compatible CPE Detected\n");
+		} else
+			ast_log(LOG_DEBUG, "Already in data mode\n");
+
+		x = 0;
+		pos = 0;
+#if 0
+		def= ast_channel_defer_dtmf(chan);
+#endif
+		while((x < 6) && msg[x]) {
+			res = adsi_generate(buf + pos, msgtype[x], msg[x], msglen[x], x+1 - start, (x == 5) || !msg[x+1]);
+			if (res < 0) {
+				ast_log(LOG_WARNING, "Failed to generate ADSI message %d on channel %s\n", x + 1, chan->name);
+				return -1;
+			}
+			ast_log(LOG_DEBUG, "Message %d, of %d input bytes, %d output bytes\n", 
+					x + 1, msglen[x], res);
+			pos += res; 
+			x++;
+		}
+
+
+		rem = 0;
+		if (adsi_careful_send(chan, buf, pos, &rem))
+			return -1;
+
+		ast_log(LOG_DEBUG, "Sent total spill of %d bytes\n", pos);
+
+		memset(ack, 0, sizeof(ack));
+		/* Get real result */
+		res = ast_readstring(chan, ack, 3, 1000, 1000, "");
+		/* Check for hangup */
+		if (res < 0)
+			return -1;
+		if (ack[0] == 'D') {
+			ast_log(LOG_DEBUG, "Acked up to message %d\n", atoi(ack + 1));
+			start += atoi(ack + 1);
+			if (start >= x)
+				break;
+			else {
+				retries++;
+				ast_log(LOG_DEBUG, "Retransmitting (%d), from %d\n", start + 1);
+			}
+		} else {
+			retries++;
+			ast_log(LOG_WARNING, "Unexpected response to ack: %s (retry %d)\n", ack, retries);
+		} 
+	}
+	if (retries >= maxretries) {
+		ast_log(LOG_WARNING, "Maximum ADSI Retries (%d) exceeded\n", maxretries);
+		errno = ETIMEDOUT;
+		return -1;
+	}
+	return 0;
+	
+}
+
+int adsi_begin_download(struct ast_channel *chan, char *service, char *fdn, char *sec, int version)
+{
+	int bytes;
+	unsigned char buf[256];
+	char ack[2];
+        bytes = 0;
+        /* Setup the resident soft key stuff, a piece at a time */
+        /* Upload what scripts we can for voicemail ahead of time */
+        bytes += adsi_download_connect(buf + bytes, service, fdn, sec, version);
+        if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD))
+		return -1;
+	if (ast_readstring(chan, ack, 1, 10000, 10000, ""))
+		return -1;
+	if (ack[0] == 'B')
+		return 0;
+	ast_log(LOG_DEBUG, "Download was denied by CPE\n");
+	return -1;
+}
+
+int adsi_end_download(struct ast_channel *chan)
+{
+	int bytes;
+	unsigned char buf[256];
+        bytes = 0;
+        /* Setup the resident soft key stuff, a piece at a time */
+        /* Upload what scripts we can for voicemail ahead of time */
+        bytes += adsi_download_disconnect(buf + bytes);
+        if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD))
+		return -1;
+	return 0;
+}
+
+int adsi_transmit_message(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype)
+{
+	unsigned char *msgs[5] = { NULL, NULL, NULL, NULL, NULL };
+	int msglens[5];
+	int msgtypes[5];
+	int newdatamode;
+	int res;
+	int x;
+	int writeformat, readformat;
+
+	writeformat = chan->writeformat;
+	readformat = chan->readformat;
+
+	newdatamode = chan->adsicpe & ADSI_FLAG_DATAMODE;
+
+	for (x=0;x<msglen;x+=(msg[x+1]+2)) {
+		if (msg[x] == ADSI_SWITCH_TO_DATA) 
+			newdatamode = ADSI_FLAG_DATAMODE;
+		
+		if (msg[x] == ADSI_SWITCH_TO_VOICE)
+			newdatamode = 0;
+	}
+	msgs[0] = msg;
+
+	msglens[0] = msglen;
+	msgtypes[0] = msgtype;
+
+	if (msglen > 253) {
+		ast_log(LOG_WARNING, "Can't send ADSI message of %d bytes, too large\n", msglen);
+		return -1;
+	}
+
+	ast_stopstream(chan);
+
+	if (ast_set_write_format(chan, AST_FORMAT_ULAW)) {
+		ast_log(LOG_WARNING, "Unable to set write format to ULAW\n");
+		return -1;
+	}
+
+	if (ast_set_read_format(chan, AST_FORMAT_ULAW)) {
+		ast_log(LOG_WARNING, "Unable to set read format to ULAW\n");
+		if (writeformat) {
+			if (ast_set_write_format(chan, writeformat)) 
+				ast_log(LOG_WARNING, "Unable to restore write format to %d\n", writeformat);
+		}
+		return -1;
+	}
+	res = __adsi_transmit_messages(chan, msgs, msglens, msgtypes);
+	if (!res)
+		chan->adsicpe = (chan->adsicpe & ~ADSI_FLAG_DATAMODE) | newdatamode;
+
+	if (writeformat)
+		ast_set_write_format(chan, writeformat);
+	if (readformat)
+		ast_set_read_format(chan, readformat);
+
+	return res;
+}
+
+static inline int ccopy(unsigned char *dst, unsigned char *src, int max)
+{
+	int x=0;
+	/* Carefully copy the requested data */
+	while ((x < max) && src[x] && (src[x] != 0xff)) {
+		dst[x] = src[x];
+		x++;
+	}
+	return x;
+}
+
+int adsi_load_soft_key(unsigned char *buf, int key, unsigned char *llabel, unsigned char *slabel, unsigned char *ret, int data)
+{
+	int bytes=0;
+
+	/* Abort if invalid key specified */
+	if ((key < 2) || (key > 33))
+		return -1;
+	buf[bytes++] = ADSI_LOAD_SOFTKEY;
+	/* Reserve for length */
+	bytes++;
+	/* Which key */
+	buf[bytes++] = key;
+
+	/* Carefully copy long label */
+	bytes += ccopy(buf + bytes, llabel, 18);
+
+	/* Place delimiter */
+	buf[bytes++] = 0xff;
+
+	/* Short label */
+	bytes += ccopy(buf + bytes, slabel, 7);
+
+
+	/* If specified, copy return string */
+	if (ret) {
+		/* Place delimiter */
+		buf[bytes++] = 0xff;
+		if (data)
+			buf[bytes++] = ADSI_SWITCH_TO_DATA2;
+		/* Carefully copy return string */
+		bytes += ccopy(buf + bytes, ret, 20);
+
+	}
+	/* Replace parameter length */
+	buf[1] = bytes - 2;
+	return bytes;
+	
+}
+
+int adsi_connect_session(unsigned char *buf, unsigned char *fdn, int ver)
+{
+	int bytes=0;
+	int x;
+
+	/* Message type */
+	buf[bytes++] = ADSI_CONNECT_SESSION;
+
+	/* Reserve space for length */
+	bytes++;
+
+	if (fdn) {
+		for (x=0;x<4;x++)
+			buf[bytes++] = fdn[x];
+		if (ver > -1)
+			buf[bytes++] = ver & 0xff;
+	}
+
+	buf[1] = bytes - 2;
+	return bytes;
+
+}
+
+int adsi_download_connect(unsigned char *buf, unsigned char *service,  unsigned char *fdn, unsigned char *sec, int ver)
+{
+	int bytes=0;
+	int x;
+
+	/* Message type */
+	buf[bytes++] = ADSI_DOWNLOAD_CONNECT;
+
+	/* Reserve space for length */
+	bytes++;
+
+	/* Primary column */
+	bytes+= ccopy(buf + bytes, service, 18);
+
+	/* Delimiter */
+	buf[bytes++] = 0xff;
+	
+	for (x=0;x<4;x++)
+		buf[bytes++] = fdn[x];
+	for (x=0;x<4;x++)
+		buf[bytes++] = sec[x];
+	if (ver > -1)
+		buf[bytes++] = ver & 0xff;
+
+	buf[1] = bytes - 2;
+	return bytes;
+
+}
+
+int adsi_disconnect_session(unsigned char *buf)
+{
+	int bytes=0;
+
+	/* Message type */
+	buf[bytes++] = ADSI_DISC_SESSION;
+
+	/* Reserve space for length */
+	bytes++;
+
+	buf[1] = bytes - 2;
+	return bytes;
+
+}
+
+int adsi_data_mode(unsigned char *buf)
+{
+	int bytes=0;
+
+	/* Message type */
+	buf[bytes++] = ADSI_SWITCH_TO_DATA;
+
+	/* Reserve space for length */
+	bytes++;
+
+	buf[1] = bytes - 2;
+	return bytes;
+
+}
+
+int adsi_voice_mode(unsigned char *buf, int when)
+{
+	int bytes=0;
+
+	/* Message type */
+	buf[bytes++] = ADSI_SWITCH_TO_VOICE;
+
+	/* Reserve space for length */
+	bytes++;
+
+	buf[bytes++] = when & 0x7f;
+
+	buf[1] = bytes - 2;
+	return bytes;
+
+}
+
+int adsi_available(struct ast_channel *chan)
+{
+	int cpe = chan->adsicpe & 0xff;
+	if ((cpe == AST_ADSI_AVAILABLE) ||
+	    (cpe == AST_ADSI_UNKNOWN))
+		return 1;
+	return 0;
+}
+
+int adsi_download_disconnect(unsigned char *buf)
+{
+	int bytes=0;
+
+	/* Message type */
+	buf[bytes++] = ADSI_DOWNLOAD_DISC;
+
+	/* Reserve space for length */
+	bytes++;
+
+	buf[1] = bytes - 2;
+	return bytes;
+
+}
+
+int adsi_display(unsigned char *buf, int page, int line, int just, int wrap, 
+		 unsigned char *col1, unsigned char *col2)
+{
+	int bytes=0;
+
+	/* Sanity check line number */
+
+	if (page) {
+		if (line > 4) return -1;
+	} else {
+		if (line > 33) return -1;
+	}
+
+	if (line < 1)
+		return -1;
+	/* Parameter type */
+	buf[bytes++] = ADSI_LOAD_VIRTUAL_DISP;
+	
+	/* Reserve space for size */
+	bytes++;
+
+	/* Page and wrap indicator */
+	buf[bytes++] = ((page & 0x1) << 7) | ((wrap & 0x1) << 6) | (line & 0x3f);
+
+	/* Justification */
+	buf[bytes++] = (just & 0x3) << 5;
+
+	/* Omit highlight mode definition */
+	buf[bytes++] = 0xff;
+
+	/* Primary column */
+	bytes+= ccopy(buf + bytes, col1, 20);
+
+	/* Delimiter */
+	buf[bytes++] = 0xff;
+	
+	/* Secondary column */
+	bytes += ccopy(buf + bytes, col2, 20);
+
+	/* Update length */
+	buf[1] = bytes - 2;
+	
+	return bytes;
+
+}
+
+int adsi_input_control(unsigned char *buf, int page, int line, int display, int format, int just)
+{
+	int bytes=0;
+
+ 	if (page) {
+		if (line > 4) return -1;
+	} else {
+		if (line > 33) return -1;
+	}
+
+	if (line < 1)
+		return -1;
+
+	buf[bytes++] = ADSI_INPUT_CONTROL;
+	bytes++;
+	buf[bytes++] = ((page & 1) << 7) | (line & 0x3f);
+	buf[bytes++] = ((display & 1) << 7) | ((just & 0x3) << 4) | (format & 0x7);
+	
+	buf[1] = bytes - 2;
+	return bytes;
+
+}
+
+int adsi_input_format(unsigned char *buf, int num, int dir, int wrap, unsigned char *format1, unsigned char *format2)
+{
+	int bytes = 0;
+
+	if (!strlen(format1))
+		return -1;
+
+	buf[bytes++] = ADSI_INPUT_FORMAT;
+	bytes++;
+	buf[bytes++] = ((dir & 1) << 7) | ((wrap & 1) << 6) | (num & 0x7);
+	bytes += ccopy(buf + bytes, format1, 20);
+	buf[bytes++] = 0xff;
+	if (format2 && strlen(format2)) {
+		bytes += ccopy(buf + bytes, format2, 20);
+	}
+	buf[1] = bytes - 2;
+	return bytes;
+}
+
+int adsi_set_keys(unsigned char *buf, unsigned char *keys)
+{
+	int bytes=0;
+	int x;
+	/* Message type */
+	buf[bytes++] = ADSI_INIT_SOFTKEY_LINE;
+	/* Space for size */
+	bytes++;
+	/* Key definitions */
+	for (x=0;x<6;x++)
+		buf[bytes++] = (keys[x] & 0x3f) ? keys[x] : (keys[x] | 0x1);
+	buf[1] = bytes - 2;
+	return bytes;
+}
+
+int adsi_set_line(unsigned char *buf, int page, int line)
+{
+	int bytes=0;
+
+	/* Sanity check line number */
+
+ 	if (page) {
+		if (line > 4) return -1;
+	} else {
+		if (line > 33) return -1;
+	}
+
+	if (line < 1)
+		return -1;
+	/* Parameter type */
+	buf[bytes++] = ADSI_LINE_CONTROL;
+	
+	/* Reserve space for size */
+	bytes++;
+
+	/* Page and line */
+	buf[bytes++] = ((page & 0x1) << 7) | (line & 0x3f);
+
+	buf[1] = bytes - 2;
+	return bytes;
+
+};
+
+static int total = 0;
+static int speeds = 0;
+
+#if 0
+int adsi_channel_init(struct ast_channel *chan)
+{
+	char dsp[256];
+	char keys[256];
+	int bytes;
+	int x;
+	unsigned char *msgs[3];
+	unsigned char keyd[6];
+	int lens[3];
+	int types[3];
+	memset(dsp, 0, sizeof(dsp));
+	memset(keys, 0, sizeof(keys));
+	memset(msgs, 0, sizeof(msgs));
+
+	/* Start with initial display setup */
+	bytes = 0;
+	bytes += adsi_connect_session(dsp, NULL, -1);
+	for (x=0;x<total;x++) {
+		bytes += adsi_display(dsp + bytes, ADSI_INFO_PAGE, x + 1, aligns[x], 0,
+			strlen(intro[x]) ? intro[x] : " ", "");
+	}
+	bytes += adsi_set_line(dsp + bytes, ADSI_INFO_PAGE, 1);
+ 	msgs[0] = dsp;
+	lens[0] = bytes;
+	types[0] = ADSI_MSG_DISPLAY;
+
+	/* Prepare key setup messages */
+
+	if (speeds) {
+		bytes = 0;
+		memset(keyd, 0, sizeof(keyd));
+		for (x=0;x<speeds;x++) {
+			bytes += adsi_load_soft_key(keys + bytes, ADSI_SPEED_DIAL + x,
+					speeddial[x][1], speeddial[x][2], speeddial[x][0]);
+			keyd[x] = ADSI_SPEED_DIAL + x;
+		}
+		bytes += adsi_set_keys(keys + bytes, keyd);
+		msgs[1] = keys;
+		lens[1] = bytes;
+		types[1] = ADSI_MSG_DISPLAY;
+	}
+	adsi_transmit_messages(chan, msgs, lens, types);
+	return 0;
+}
+#else
+int adsi_channel_init(struct ast_channel *chan)
+{
+	char dsp[256];
+	int bytes;
+	int x;
+	unsigned char keyd[6];
+
+	memset(dsp, 0, sizeof(dsp));
+
+	/* Start with initial display setup */
+	bytes = 0;
+	bytes += adsi_connect_session(dsp, NULL, -1);
+	for (x=0;x<total;x++) {
+		bytes += adsi_display(dsp + bytes, ADSI_INFO_PAGE, x + 1, aligns[x], 0,
+			strlen(intro[x]) ? intro[x] : " ", "");
+	}
+	bytes += adsi_set_line(dsp + bytes, ADSI_INFO_PAGE, 1);
+
+	/* Prepare key setup messages */
+
+	if (speeds) {
+		memset(keyd, 0, sizeof(keyd));
+		for (x=0;x<speeds;x++) {
+			bytes += adsi_load_soft_key(dsp + bytes, ADSI_SPEED_DIAL + x,
+					speeddial[x][1], speeddial[x][2], speeddial[x][0], 0);
+			keyd[x] = ADSI_SPEED_DIAL + x;
+		}
+		bytes += adsi_set_keys(dsp + bytes, keyd);
+	}
+	adsi_transmit_message(chan, dsp, bytes, ADSI_MSG_DISPLAY);
+	return 0;
+}
+#endif
+
+int adsi_channel_restore(struct ast_channel *chan)
+{
+	char dsp[256];
+	int bytes;
+	int x;
+	unsigned char keyd[6];
+
+	memset(dsp, 0, sizeof(dsp));
+
+	/* Start with initial display setup */
+	bytes = 0;
+	bytes += adsi_set_line(dsp + bytes, ADSI_INFO_PAGE, 1);
+
+	/* Prepare key setup messages */
+
+	if (speeds) {
+		memset(keyd, 0, sizeof(keyd));
+		for (x=0;x<speeds;x++) {
+			keyd[x] = ADSI_SPEED_DIAL + x;
+		}
+		bytes += adsi_set_keys(dsp + bytes, keyd);
+	}
+	adsi_transmit_message(chan, dsp, bytes, ADSI_MSG_DISPLAY);
+	return 0;
+
+}
+
+int adsi_load_session(struct ast_channel *chan, unsigned char *app, int ver, int data)
+{
+	char dsp[256];
+	int bytes;
+	int res;
+	char resp[2];
+
+	memset(dsp, 0, sizeof(dsp));
+
+	/* Connect to session */
+	bytes = 0;
+	bytes += adsi_connect_session(dsp + bytes, app,ver);
+
+	if (data)
+		bytes += adsi_data_mode(dsp + bytes);
+
+	/* Prepare key setup messages */
+	if (adsi_transmit_message(chan, dsp, bytes, ADSI_MSG_DISPLAY))
+		return -1;
+	res = ast_readstring(chan, resp, 1, 1200, 1200, "");
+	if (res < 0)
+		return -1;
+	if (res) {
+		ast_log(LOG_DEBUG, "No response from CPE about version.  Assuming not there.\n");
+		return 0;
+	}
+	if (!strcmp(resp, "B")) {
+		ast_log(LOG_DEBUG, "CPE has script '%s' version %d already loaded\n", app, ver);
+		return 1;
+	} else if (!strcmp(resp, "A")) {
+		ast_log(LOG_DEBUG, "CPE hasn't script '%s' version %d already loaded\n", app, ver);
+	} else {
+		ast_log(LOG_WARNING, "Unexpected CPE response to script query: %s\n", resp);
+	}
+	return 0;
+
+}
+
+int adsi_unload_session(struct ast_channel *chan)
+{
+	char dsp[256];
+	int bytes;
+
+	memset(dsp, 0, sizeof(dsp));
+
+	/* Connect to session */
+	bytes = 0;
+	bytes += adsi_disconnect_session(dsp + bytes);
+	bytes += adsi_voice_mode(dsp + bytes, 0);
+
+	/* Prepare key setup messages */
+	if (adsi_transmit_message(chan, dsp, bytes, ADSI_MSG_DISPLAY))
+		return -1;
+	return 0;
+}
+
+static int str2align(char *s)
+{
+	if (!strncasecmp(s, "l", 1))
+		return ADSI_JUST_LEFT;
+	else if (!strncasecmp(s, "r", 1))
+		return ADSI_JUST_RIGHT;
+	else if (!strncasecmp(s, "i", 1))
+		return ADSI_JUST_IND;
+	else
+		return ADSI_JUST_CENT;
+}
+
+static void init_state(void)
+{
+	int x;
+	for (x=0;x<ADSI_MAX_INTRO;x++)
+		aligns[x] = ADSI_JUST_CENT;
+	strcpy(intro[0], "Welcome to the");
+	strcpy(intro[1], "Asterisk");
+	strcpy(intro[2], "Open Source PBX");
+	total = 3;
+	speeds = 0;
+	for (x=3;x<ADSI_MAX_INTRO;x++)
+		strcpy(intro[x], "");
+	memset(speeddial, 0, sizeof(speeddial));
+	alignment = ADSI_JUST_CENT;
+}
+
+static void adsi_load(void)
+{
+	int x;
+	struct ast_config *conf;
+	struct ast_variable *v;
+	char *name, *sname;
+	init_state();
+	conf = ast_load("adsi.conf");
+	if (conf) {
+		x=0;
+		v = ast_variable_browse(conf, "intro");
+		while(v) {
+			if (!strcasecmp(v->name, "alignment"))
+				alignment = str2align(v->value);
+			else if (!strcasecmp(v->name, "greeting")) {
+				if (x < ADSI_MAX_INTRO) {
+					aligns[x] = alignment;
+					strncpy(intro[x], v->value, 20);
+					x++;
+				}
+			} else if (!strcasecmp(v->name, "maxretries")) {
+				if (atoi(v->value) > 0)
+					maxretries = atoi(v->value);
+			}
+			v = v->next;
+		}
+		v = ast_variable_browse(conf, "speeddial");
+		if (x)
+			total = x;
+		x = 0;
+		while(v) {
+			name = strtok(v->value, ",");
+			sname = strtok(NULL, ",");
+			if (!sname) 
+				sname = name;
+			if (x < ADSI_MAX_SPEED_DIAL) {
+				/* Up to 20 digits */
+				strncpy(speeddial[x][0], v->name, 20);
+				strncpy(speeddial[x][1], name, 18);
+				strncpy(speeddial[x][2], sname, 7);
+				x++;
+			}
+			v = v->next;
+				
+		}
+		if (x)
+			speeds = x;
+		ast_destroy(conf);
+	}
+}
+
+int reload(void)
+{
+	adsi_load();
+	return 0;
+}
+
+int load_module(void)
+{
+	adsi_load();
+	return 0;
+}
+
+int unload_module(void)
+{
+	/* Can't unload this once we're loaded */
+	return -1;
+}
+
+char *description(void)
+{
+	return "Call Parking Resource";
+}
+
+int usecount(void)
+{
+	/* We should never be unloaded */
+	return 1;
+}
+
+char *key()
+{
+	return ASTERISK_GPL_KEY;
+}
diff --git a/res/res_crypto.c b/res/res_crypto.c
new file mode 100755
index 000000000..8aa4e9d6e
--- /dev/null
+++ b/res/res_crypto.c
@@ -0,0 +1,633 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * Provide Cryptographic Signature capability
+ * 
+ * Copyright (C) 1999, Mark Spencer
+ *
+ * Mark Spencer <markster@linux-support.net>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#include <asterisk/file.h>
+#include <asterisk/channel.h>
+#include <asterisk/logger.h>
+#include <asterisk/say.h>
+#include <asterisk/module.h>
+#include <asterisk/options.h>
+#include <asterisk/crypto.h>
+#include <asterisk/md5.h>
+#include <asterisk/cli.h>
+#include <asterisk/io.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <dirent.h>
+#include <string.h>
+#include <errno.h>
+#include "../asterisk.h"
+
+/*
+ * Asterisk uses RSA keys with SHA-1 message digests for its
+ * digital signatures.  The choice of RSA is due to its higher
+ * throughput on verification, and the choice of SHA-1 based
+ * on the recently discovered collisions in MD5's compression 
+ * algorithm and recommendations of avoiding MD5 in new schemes
+ * from various industry experts.
+ *
+ * We use OpenSSL to provide our crypto routines, although we never
+ * actually use full-up SSL
+ *
+ */
+
+/*
+ * XXX This module is not very thread-safe.  It is for everyday stuff
+ *     like reading keys and stuff, but there are all kinds of weird
+ *     races with people running reload and key init at the same time
+ *     for example
+ *
+ * XXXX
+ */
+
+static char base64[64];
+static char b2a[256];
+
+static pthread_mutex_t keylock = PTHREAD_MUTEX_INITIALIZER;
+
+#define KEY_NEEDS_PASSCODE (1 << 16)
+
+struct ast_key {
+	/* Name of entity */
+	char name[80];
+	/* File name */
+	char fn[256];
+	/* Key type (AST_KEY_PUB or AST_KEY_PRIV, along with flags from above) */
+	int ktype;
+	/* RSA structure (if successfully loaded) */
+	RSA *rsa;
+	/* Whether we should be deleted */
+	int delme;
+	/* FD for input (or -1 if no input allowed, or -2 if we needed input) */
+	int infd;
+	/* FD for output */
+	int outfd;
+	/* Last MD5 Digest */
+	unsigned char digest[16];
+	struct ast_key *next;
+};
+
+static struct ast_key *keys = NULL;
+
+static int fdprint(int fd, char *s)
+{
+        return write(fd, s, strlen(s) + 1);
+}
+
+static int pw_cb(char *buf, int size, int rwflag, void *userdata)
+{
+	struct ast_key *key = (struct ast_key *)userdata;
+	char prompt[256];
+	int res;
+	int tmp;
+	if (key->infd > -1) {
+		snprintf(prompt, sizeof(prompt), ">>>> passcode for %s key '%s': ",
+			 key->ktype == AST_KEY_PRIVATE ? "PRIVATE" : "PUBLIC", key->name);
+		write(key->outfd, prompt, strlen(prompt));
+		memset(buf, 0, sizeof(buf));
+		tmp = ast_hide_password(key->infd);
+		memset(buf, 0, size);
+		res = read(key->infd, buf, size);
+		ast_restore_tty(key->infd, tmp);
+		if (buf[strlen(buf) -1] == '\n')
+			buf[strlen(buf) - 1] = '\0';
+		return strlen(buf);
+	} else {
+		/* Note that we were at least called */
+		key->infd = -2;
+	}
+	return -1;
+}
+
+struct ast_key *ast_key_get(char *kname, int ktype)
+{
+	struct ast_key *key;
+	ast_pthread_mutex_lock(&keylock);
+	key = keys;
+	while(key) {
+		if (!strcmp(kname, key->name) &&
+		    (ktype == key->ktype))
+			break;
+		key = key->next;
+	}
+	ast_pthread_mutex_unlock(&keylock);
+	return key;
+}
+
+static struct ast_key *try_load_key (char *dir, char *fname, int ifd, int ofd, int *not2)
+{
+	int ktype = 0;
+	char *c = NULL;
+	char ffname[256];
+	char digest[16];
+	FILE *f;
+	struct MD5Context md5;
+	struct ast_key *key;
+	static int notice = 0;
+	int found = 0;
+
+	/* Make sure its name is a public or private key */
+
+	if ((c = strstr(fname, ".pub")) && !strcmp(c, ".pub")) {
+		ktype = AST_KEY_PUBLIC;
+	} else if ((c = strstr(fname, ".key")) && !strcmp(c, ".key")) {
+		ktype = AST_KEY_PRIVATE;
+	} else
+		return NULL;
+
+	/* Get actual filename */
+	snprintf(ffname, sizeof(ffname), "%s/%s", dir, fname);
+
+	ast_pthread_mutex_lock(&keylock);
+	key = keys;
+	while(key) {
+		/* Look for an existing version already */
+		if (!strcasecmp(key->fn, ffname)) 
+			break;
+		key = key->next;
+	}
+	ast_pthread_mutex_unlock(&keylock);
+
+	/* Open file */
+	f = fopen(ffname, "r");
+	if (!f) {
+		ast_log(LOG_WARNING, "Unable to open key file %s: %s\n", ffname, strerror(errno));
+		return NULL;
+	}
+	MD5Init(&md5);
+	while(!feof(f)) {
+		/* Calculate a "whatever" quality md5sum of the key */
+		char buf[256];
+		fgets(buf, sizeof(buf), f);
+		if (!feof(f)) {
+			MD5Update(&md5, buf, strlen(buf));
+		}
+	}
+	MD5Final(digest, &md5);
+	if (key) {
+		/* If the MD5 sum is the same, and it isn't awaiting a passcode 
+		   then this is far enough */
+		if (!memcmp(digest, key->digest, 16) &&
+		    !(key->ktype & KEY_NEEDS_PASSCODE)) {
+			fclose(f);
+			key->delme = 0;
+			return NULL;
+		} else {
+			/* Preserve keytype */
+			ktype = key->ktype;
+			/* Recycle the same structure */
+			found++;
+		}
+	}
+
+	/* Make fname just be the normal name now */
+	*c = '\0';
+	if (!key) {
+		key = (struct ast_key *)malloc(sizeof(struct ast_key));
+		if (!key) {
+			ast_log(LOG_WARNING, "Out of memory\n");
+			fclose(f);
+			return NULL;
+		}
+		memset(key, 0, sizeof(struct ast_key));
+	}
+	/* At this point we have a key structure (old or new).  Time to
+	   fill it with what we know */
+	/* Gotta lock if this one already exists */
+	if (found)
+		ast_pthread_mutex_lock(&keylock);
+	/* First the filename */
+	strncpy(key->fn, ffname, sizeof(key->fn));
+	/* Then the name */
+	strncpy(key->name, fname, sizeof(key->name));
+	key->ktype = ktype;
+	/* Yes, assume we're going to be deleted */
+	key->delme = 1;
+	/* Keep the key type */
+	memcpy(key->digest, digest, 16);
+	/* Can I/O takes the FD we're given */
+	key->infd = ifd;
+	key->outfd = ofd;
+	/* Reset the file back to the beginning */
+	rewind(f);
+	/* Now load the key with the right method */
+	if (ktype == AST_KEY_PUBLIC)
+		key->rsa = PEM_read_RSA_PUBKEY(f, NULL, pw_cb, key);
+	else
+		key->rsa = PEM_read_RSAPrivateKey(f, NULL, pw_cb, key);
+	fclose(f);
+	if (key->rsa) {
+		/* Key loaded okay */
+		key->ktype &= ~KEY_NEEDS_PASSCODE;
+		if (option_verbose > 2)
+			ast_verbose(VERBOSE_PREFIX_3 "Loaded %s key '%s'\n", key->ktype == AST_KEY_PUBLIC ? "PUBLIC" : "PRIVATE", key->name);
+		if (option_debug)
+			ast_log(LOG_DEBUG, "Key '%s' loaded OK\n", key->name);
+		key->delme = 0;
+	} else if (key->infd != -2) {
+		ast_log(LOG_WARNING, "Key load %s '%s' failed\n",key->ktype == AST_KEY_PUBLIC ? "PUBLIC" : "PRIVATE", key->name);
+		if (ofd > -1) {
+			ERR_print_errors_fp(stderr);
+		} else
+			ERR_print_errors_fp(stderr);
+	} else {
+		ast_log(LOG_NOTICE, "Key '%s' needs passcode.\n", key->name);
+		key->ktype |= KEY_NEEDS_PASSCODE;
+		if (!notice) {
+			if (!option_initcrypto) 
+				ast_log(LOG_NOTICE, "Add the '-i' flag to the asterisk command line if you want to automatically initialize passcodes at launch.\n");
+			notice++;
+		}
+		/* Keep it anyway */
+		key->delme = 0;
+		/* Print final notice about "init keys" when done */
+		*not2 = 1;
+	}
+	if (found)
+		ast_pthread_mutex_unlock(&keylock);
+	if (!found) {
+		ast_pthread_mutex_lock(&keylock);
+		key->next = keys;
+		keys = key;
+		ast_pthread_mutex_unlock(&keylock);
+	}
+	return key;
+}
+
+#if 0
+
+static void dump(unsigned char *src, int len)
+{
+	int x; 
+	for (x=0;x<len;x++)
+		printf("%02x", *(src++));
+	printf("\n");
+}
+
+static char *binary(int y, int len)
+{
+	static char res[80];
+	int x;
+	memset(res, 0, sizeof(res));
+	for (x=0;x<len;x++) {
+		if (y & (1 << x))
+			res[(len - x - 1)] = '1';
+		else
+			res[(len - x - 1)] = '0';
+	}
+	return res;
+}
+
+#endif
+
+static int base64decode(unsigned char *dst, char *src, int max)
+{
+	int cnt = 0;
+	unsigned int byte = 0;
+	unsigned int bits = 0;
+	int incnt = 0;
+#if 0
+	unsigned char *odst = dst;
+#endif
+	while(*src && (cnt < max)) {
+		/* Shift in 6 bits of input */
+		byte <<= 6;
+		byte |= (b2a[(int)(*src)]) & 0x3f;
+		bits += 6;
+#if 0
+		printf("Add: %c %s\n", *src, binary(b2a[(int)(*src)] & 0x3f, 6));
+#endif
+		src++;
+		incnt++;
+		/* If we have at least 8 bits left over, take that character 
+		   off the top */
+		if (bits >= 8)  {
+			bits -= 8;
+			*dst = (byte >> bits) & 0xff;
+#if 0
+			printf("Remove: %02x %s\n", *dst, binary(*dst, 8));
+#endif
+			dst++;
+			cnt++;
+		}
+	}
+#if 0
+	dump(odst, cnt);
+#endif
+	/* Dont worry about left over bits, they're extra anyway */
+	return cnt;
+}
+
+static int base64encode(char *dst, unsigned char *src, int srclen, int max)
+{
+	int cnt = 0;
+	unsigned int byte = 0;
+	int bits = 0;
+	int index;
+	int cntin = 0;
+#if 0
+	char *odst = dst;
+	dump(src, srclen);
+#endif
+	/* Reserve one bit for end */
+	max--;
+	while((cntin < srclen) && (cnt < max)) {
+		byte <<= 8;
+#if 0
+		printf("Add: %02x %s\n", *src, binary(*src, 8));
+#endif
+		byte |= *(src++);
+		bits += 8;
+		cntin++;
+		while((bits >= 6) && (cnt < max)) {
+			bits -= 6;
+			/* We want only the top */
+			index = (byte >> bits) & 0x3f;
+			*dst = base64[index];
+#if 0
+			printf("Remove: %c %s\n", *dst, binary(index, 6));
+#endif
+			dst++;
+			cnt++;
+		}
+	}
+	if (bits && (cnt < max)) {
+		/* Add one last character for the remaining bits, 
+		   padding the rest with 0 */
+		byte <<= (6 - bits);
+		index = (byte) & 0x3f;
+		*(dst++) = base64[index];
+		cnt++;
+	}
+	*dst = '\0';
+	return cnt;
+}
+
+int ast_sign(struct ast_key *key, char *msg, char *sig)
+{
+	unsigned char digest[20];
+	unsigned char dsig[128];
+	int siglen = sizeof(dsig);
+	int res;
+
+	if (key->ktype != AST_KEY_PRIVATE) {
+		ast_log(LOG_WARNING, "Cannot sign with a private key\n");
+		return -1;
+	}
+
+	/* Calculate digest of message */
+	SHA1((unsigned char *)msg, strlen(msg), digest);
+
+	/* Verify signature */
+	res = RSA_sign(NID_sha1, digest, sizeof(digest), dsig, &siglen, key->rsa);
+	
+	if (!res) {
+		ast_log(LOG_WARNING, "RSA Signature (key %s) failed\n", key->name);
+		return -1;
+	}
+
+	if (siglen != sizeof(dsig)) {
+		ast_log(LOG_WARNING, "Unexpected signature length %d, expecting %d\n", siglen, sizeof(dsig));
+		return -1;
+	}
+
+	/* Success -- encode (256 bytes max as documented) */
+	base64encode(sig, dsig, siglen, 256);
+	return 0;
+	
+}
+
+int ast_check_signature(struct ast_key *key, char *msg, char *sig)
+{
+	unsigned char digest[20];
+	unsigned char dsig[128];
+	int res;
+
+	if (key->ktype != AST_KEY_PUBLIC) {
+		/* Okay, so of course you really *can* but for our purposes
+		   we're going to say you can't */
+		ast_log(LOG_WARNING, "Cannot check message signature with a private key\n");
+		return -1;
+	}
+
+	/* Decode signature */
+	res = base64decode(dsig, sig, sizeof(dsig));
+	if (res != sizeof(dsig)) {
+		ast_log(LOG_WARNING, "Signature improper length (expect %d, got %d)\n", sizeof(dsig), res);
+		return -1;
+	}
+
+	/* Calculate digest of message */
+	SHA1((unsigned char *)msg, strlen(msg), digest);
+
+	/* Verify signature */
+	res = RSA_verify(NID_sha1, digest, sizeof(digest), dsig, sizeof(dsig), key->rsa);
+	
+	if (!res) {
+		ast_log(LOG_DEBUG, "Key failed verification\n");
+		return -1;
+	}
+	/* Pass */
+	return 0;
+}
+
+static void crypto_load(int ifd, int ofd)
+{
+	struct ast_key *key, *nkey, *last;
+	DIR *dir;
+	struct dirent *ent;
+	int note = 0;
+	/* Mark all keys for deletion */
+	ast_pthread_mutex_lock(&keylock);
+	key = keys;
+	while(key) {
+		key->delme = 1;
+		key = key->next;
+	}
+	ast_pthread_mutex_unlock(&keylock);
+	/* Load new keys */
+	dir = opendir(AST_KEY_DIR);
+	if (dir) {
+		while((ent = readdir(dir))) {
+			try_load_key(AST_KEY_DIR, ent->d_name, ifd, ofd, &note);
+		}
+		closedir(dir);
+	} else
+		ast_log(LOG_WARNING, "Unable to open key directory '%s'\n", AST_KEY_DIR);
+	if (note) {
+		ast_log(LOG_NOTICE, "Please run the command 'init keys' to enter the passcodes for the keys\n");
+	}
+	ast_pthread_mutex_lock(&keylock);
+	key = keys;
+	last = NULL;
+	while(key) {
+		nkey = key->next;
+		if (key->delme) {
+			ast_log(LOG_DEBUG, "Deleting key %s type %d\n", key->name, key->ktype);
+			/* Do the delete */
+			if (last)
+				last->next = nkey;
+			else
+				keys = nkey;
+			if (key->rsa)
+				RSA_free(key->rsa);
+			free(key);
+		} else 
+			last = key;
+		key = nkey;
+	}
+	ast_pthread_mutex_unlock(&keylock);
+}
+
+static void md52sum(char *sum, unsigned char *md5)
+{
+	int x;
+	for (x=0;x<16;x++) 
+		sum += sprintf(sum, "%02x", *(md5++));
+}
+
+static int show_keys(int fd, int argc, char *argv[])
+{
+	struct ast_key *key;
+	char sum[16 * 2 + 1];
+
+	ast_pthread_mutex_lock(&keylock);
+	key = keys;
+	ast_cli(fd, "%-18s %-8s %-16s %-33s\n", "Key Name", "Type", "Status", "Sum");
+	while(key) {
+		md52sum(sum, key->digest);
+		ast_cli(fd, "%-18s %-8s %-16s %-33s\n", key->name, 
+			(key->ktype & 0xf) == AST_KEY_PUBLIC ? "PUBLIC" : "PRIVATE",
+			key->ktype & KEY_NEEDS_PASSCODE ? "[Needs Passcode]" : "[Loaded]", sum);
+				
+		key = key->next;
+	}
+	ast_pthread_mutex_unlock(&keylock);
+	return RESULT_SUCCESS;
+}
+
+static int init_keys(int fd, int argc, char *argv[])
+{
+	struct ast_key *key;
+	int ign;
+	char *kn;
+	char tmp[256];
+
+	key = keys;
+	while(key) {
+		/* Reload keys that need pass codes now */
+		if (key->ktype & KEY_NEEDS_PASSCODE) {
+			kn = key->fn + strlen(AST_KEY_DIR) + 1;
+			strncpy(tmp, kn, sizeof(tmp));
+			try_load_key(AST_KEY_DIR, tmp, fd, fd, &ign);
+		}
+		key = key->next;
+	}
+	return RESULT_SUCCESS;
+}
+
+static char show_key_usage[] =
+"Usage: show keys\n"
+"       Displays information about RSA keys known by Asterisk\n";
+
+static char init_keys_usage[] =
+"Usage: init keys\n"
+"       Initializes private keys (by reading in pass code from the user)\n";
+
+static struct ast_cli_entry cli_show_keys = 
+{ { "show", "keys", NULL }, show_keys, "Displays RSA key information", show_key_usage };
+
+static struct ast_cli_entry cli_init_keys = 
+{ { "init", "keys", NULL }, init_keys, "Initialize RSA key passcodes", init_keys_usage };
+
+static void base64_init(void)
+{
+	int x;
+	memset(b2a, -1, sizeof(b2a));
+	/* Initialize base-64 Conversion table */
+	for (x=0;x<26;x++) {
+		/* A-Z */
+		base64[x] = 'A' + x;
+		b2a['A' + x] = x;
+		/* a-z */
+		base64[x + 26] = 'a' + x;
+		b2a['a' + x] = x + 26;
+		/* 0-9 */
+		if (x < 10) {
+			base64[x + 52] = '0' + x;
+			b2a['0' + x] = x + 52;
+		}
+	}
+	base64[62] = '+';
+	base64[63] = '/';
+	b2a[(int)'+'] = 62;
+	b2a[(int)'/'] = 63;
+#if 0
+	for (x=0;x<64;x++) {
+		if (b2a[(int)base64[x]] != x) {
+			fprintf(stderr, "!!! %d failed\n", x);
+		} else
+			fprintf(stderr, "--- %d passed\n", x);
+	}
+#endif
+}
+
+static int crypto_init(void)
+{
+	base64_init();
+	SSL_library_init();
+	ERR_load_crypto_strings();
+	ast_cli_register(&cli_show_keys);
+	ast_cli_register(&cli_init_keys);
+	return 0;
+}
+
+int reload(void)
+{
+	crypto_load(-1, -1);
+	return 0;
+}
+
+int load_module(void)
+{
+	crypto_init();
+	if (option_initcrypto)
+		crypto_load(STDIN_FILENO, STDOUT_FILENO);
+	else
+		crypto_load(-1, -1);
+	return 0;
+}
+
+int unload_module(void)
+{
+	/* Can't unload this once we're loaded */
+	return -1;
+}
+
+char *description(void)
+{
+	return "Cryptographic Digital Signatures";
+}
+
+int usecount(void)
+{
+	/* We should never be unloaded */
+	return 1;
+}
+
+char *key()
+{
+	return ASTERISK_GPL_KEY;
+}