/*
 * babd.c - Babylon Config Daemon source
 * Copyright (C) 1997-2000 SpellCaster Telecommunications Inc.
 * Copyright (C) 2003,2007 Benjamin C. R. LaHaise
 * $Id: babd.cc,v 1.15 2004/10/20 05:09:54 bcrl Exp $
 * Released under the GNU Public License. See LICENSE file for details.
 */

#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <syslog.h>
#include <errno.h>
#include <net/if.h>
#include <net/route.h>
#include <net/if_arp.h>
#include <sys/stat.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/un.h>
#include <getopt.h>
#include <sys/param.h>

#include "compat.h"

#include "config.h"
#include "babd.h"

#include "d_aps_if.h"
#include "aps_if.h"

#include "link.h"
#include "iface.h"

#include "ctrlfd.h"
#include "radius.h"
#include "selectops.h"

#include "dfs_parser.h"

SelectEventHandler *selectObjs[2][BAB_OPEN_MAX];

unsigned long interim_update_interval = 6 * 3600 * 100UL;

extern void radius_GetConfig(void (*cbf)(void *, OptionSet_t *), void *obj, OptionSet_t *options);
extern void write_link_state(int, CLink *, int verbose);
extern void write_link_options(int, CLink *);

extern "C" {
#include "md5.h"
};

#define MAX_IFS			500
#define FLAGS_GOOD		(IFF_UP | IFF_BROADCAST)
#define FLAGS_MASK		(IFF_UP | IFF_BROADCAST | IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)

#define CONTROL_PATH	"/tmp/.bab_control"	/* FIXME: relocate in /dev/? */
static char control_path[PATH_MAX] = CONTROL_PATH;

const char *sysname = "";

static int finished = 0;

int b_control_fd, b_sock_fd, b_sock6_fd;
int am_radius_client = 0;
int am_radius_acct_client = 0;
int do_userland_only = 0;	// Used to disable creating network interfaces

void get_config(void);
void do_chap_auth(CfgMessage_t *active, CfgMessage_t *auth_buf);

void print_usage();
void print_debuglevels();

int broken_acfc=0;	/* Don't turn off ACFC after LCP if we were told to if 1 */

int dyn_ip_enabled = -1;	/* set if we've enabled dynamic ips;
				 * -1=default -- don't warn if config file 
				 * doesn't exist. */

/* Options we support (see the man page) */
static char shrt_options[] = "a:fd:rpinhsu:c:C:y:"
#ifdef USE_L2TP
	"2:"
#endif
	"SU"
	;
static struct option long_options[] = {
	{ "radius-acct", required_argument, NULL, 'a' },
	{ "no-fork", no_argument, NULL, 'f' },
	{ "debug", required_argument, NULL, 'd' },
	{ "want-mlcp", no_argument, NULL, 'M' },
	{ "enable-routing", no_argument, NULL, 'R' },
	{ "enable-proxyarp", no_argument, NULL, 'P' },
	{ "enable-pfc", no_argument, NULL, 'F' },
	{ "disable-routing", no_argument, NULL, 'r' },
	{ "disable-proxyarp", no_argument, NULL, 'p' },
	{ "enable-dynamicip", no_argument, NULL, 'i' },
	{ "disable-dynamicip", no_argument, NULL, 'I' },
	{ "scan-chan", no_argument, NULL, 's' },
	{ "broken-acfc", no_argument, NULL, 'B' },
#ifdef USE_L2TP
	{ "enable-l2tp", required_argument, NULL, '2' },
#endif
	{ "system-name", required_argument, NULL, 'n' },
	{ "help", no_argument, NULL, 'h' },
	{ "help-debug", no_argument, NULL, 'D' },
	{ "config-file", required_argument, NULL, 'c' },
	{ "control-socket", required_argument, NULL, 'C' },
	{ "dynamic-file", required_argument, NULL, 'y' },
	{ "radius", required_argument, NULL, 'u' },
	{ "restore-state", no_argument, NULL, 'S' },
	{ "userland-only", no_argument, NULL, 'U' },
	{ 0, 0, 0, 0 }
	};
static char *cmdname;
const char DEFAULT_CFG_FILE[]=	"/etc/babylon/babylon.conf";
const char DEFAULT_DYN_FILE[]=	"/etc/babylon/dynamic_ip.conf";
static char configFile[MAXPATHLEN];
char dynamicFile[MAXPATHLEN];

int do_bdial(ctrlfd_t *cfd, const char *site, const char *phone,
	     Call *call, int lcp_timeout, int lcp_interval,
	     const char *dev_class)
{
	OptionSet_t *options = new OptionSet_t;

	if (lcp_timeout || lcp_interval) {
		policy_t *policy = new policy_t;

		if (lcp_timeout)
			policy->Set(P_ECHO, lcp_timeout);
		if (lcp_interval)
			policy->Set(P_ECHO_INTERVAL, lcp_interval);
		if (options->pol)
			delete options->pol;
		options->pol = policy;
	}

	call->ident = ++callIdent;
	call->set_cfd(cfd);

	Log(LF_DEBUG|LF_CALL, "do_bdial: call=%p #%d site: %s num: %s...", call, call->ident, site, phone);
	strncpy(options->site, site, SITE_NAME_LEN-1);
	strncpy(options->phone, phone, PHONE_LEN-1);
	if (dev_class)
		strncpy(options->dev_class, dev_class, CLASS_NAME_LEN);
	else
		options->dev_class[0] = 0;
	options->SetCall(call);
	babd_GetConfig(DialGotConfig, NULL, options);
	delete options;
	return 0;
}

void cmd_bdial (ctrlfd_t *cfd, char *args)
{
	char *site, *num, *p;
	const char *dev_class = "";
	int wait_for_hangup = 0;
	int lcp_timeout = 0;
	int lcp_interval = 0;

	if (!args[0] || !strcmp(args, "--help"))
		goto usage;

	if (!strncmp("--class=", args, 8)) {
		args += 8;
		dev_class = args;
		while (*args && !isspace(*args))
			args++;
		if (*args)
			*args++ = 0;
		while (*args && isspace(*args))
			args++;
	}

	if (!strncmp("--wait-for-hangup ", args, 18)) {
		args += 18;
		wait_for_hangup = 1;
	}

	if (!strncmp("--lcp-timeout=", args, 14)) {
		args += 14;
		lcp_timeout = atoi(args);
		while (*args && !isspace(*args))
			args++;
		if (*args && isspace(*args))
			args++;
	}

	if (!strncmp("--lcp-interval=", args, 15)) {
		args += 15;
		lcp_interval = atoi(args);
		while (*args && !isspace(*args))
			args++;
		if (*args && isspace(*args))
			args++;
	}

	for (p=args; *p && isspace(*p); p++)
		;
	site = p;
	for (; *p && !isspace(*p); p++)
		;
	if (*p)
		*p++ = 0;
	for (; *p && isspace(*p); p++)
		;
	num = p;
	for (; *p && !isspace(*p); p++)
		;
	*p = 0;
	do_bdial(cfd, site, num, new Call(wait_for_hangup), lcp_timeout, lcp_interval, dev_class);
	return;

usage:
	cfd->printf("usage:\n");
	cfd->printf("	bdial [--class=<class>] [--wait-for-hangup] [--lcp-timeout=<time>]\n");
	cfd->printf("	      [--lcp-interval=<time>] <site> <numer>\n");
	cfd->done(-2);
	return;
}

static char *getword(char **p)
{
	char *s = *p, *word;
	for (; *s && isspace(*s); s++)
		;
	if (!*s)
		return NULL;
	word = s;
	for (; *s && !isspace(*s); s++)
		;
	if (*s)
		*s++ = 0;
	*p = s;
	return word;
}

static int load_channels(int quiet)
{
	FILE *ifp = fopen("/proc/bab_chan", "r");
	char buf[256], *s;
	int i = 0;

	fgets(buf, 256, ifp);

	while ((s=fgets(buf, 256, ifp))) {
		char devname[256];
		char *devidx = getword(&s);
		char *babname = getword(&s);
		char *devclass = getword(&s);

		strcpy(devname, "/dev/bab");
		strcat(devname, devidx);
		/* Add all channels that are not isdn_d class */
		/* This should pick up any new classes as added */
		if (strcmp("isdn_d",devclass)!=0) {
			addchan(devname, babname, devclass, 0);
			i++;
			if (!quiet) {
				Log(LF_ERROR|LF_CALL, "addchan(%s, %s) failed", devname, babname);
			}
		}
	}
	fclose(ifp);
	return i;
}

void do_bchan(int fd, ctrlfd_t *cfd, char *arg)
{
	extern void delchan(channel_t *);
	char tmp[256];
	char *str = getword(&arg);
	int add = 0, hangup = 0, failed = 0, i = 0;
	int no_auth = 0;
	int hard_hangup = 0;

	if (!str)
		goto help;

	if (!strcmp(str, "add"))
		add = 1;
	else if (!strcmp(str, "hangup"))
		hangup = 1;
	else if (strcmp(str, "del")) {
help:
		strcpy(tmp, "[-1] -1: Usage: bchan [add|del|hangup] <chan>\n");
		write(fd, tmp, strlen(tmp));
		delete(cfd);
		return;
	}

	while ((str=getword(&arg))) {
		if (!strcmp("--pre-auth", str)) {
		} else if (!strcmp("--hard", str)) {
			hard_hangup = 1;
		} else if (add) {
			if (addchan(str, str, NULL, no_auth) || !++i) {
				snprintf(tmp, sizeof(tmp), "[-1] 0: %s: channel already registered\n", str);
				write(fd, tmp, strlen(tmp));
				failed = 1;
			}
		} else {
			channel_t *ch = findchan(str);
			if (!ch) {
				snprintf(tmp, sizeof(tmp), "[-1] 0: %s: channel not found\n", str);
				write(fd, tmp, strlen(tmp));
				failed = 1;
				continue;
			}
			if (hangup) {
				if (hard_hangup)
					ch->link->Hangup();
				else
					ch->link->m_lcpProto.Close("local hangup");
			} else
				delchan(ch);
			i++;
		}
	}
	sprintf(tmp, "[-1] %d: %d channel%s %sed\n", failed ? -2 : -1, i,
		(1 == i) ? "" : "s",
		add ? "add" : hangup ? "disconnect" : "delet"
		);
	write(fd, tmp, strlen(tmp));
	delete(cfd);
}


static void link_user_options(int fd, char *name)
{
	CLink *link;

	for (link = linkListHead ; link != NULL ; link = link->m_next) {
		if (name && (!(link->m_wereAcked || link->m_peerAcked) || strcmp(link->ifOptions.user, name)))
			continue;
		write_link_options(fd, link);
	}
}

void link_dev_options(int fd, char *name)
{
	CInterface *i = FindIfaceName(name);
	CLink *link;

	for (link=(i ? i->links : NULL); link; link=link->m_nextBundled)
		write_link_options(fd, link);
}

static void link_query_user(int fd, char *name, int verbose)
{
	CLink *link;

	for (link = linkListHead ; link != NULL ; link = link->m_next) {
		if (name && (!(link->m_wereAcked || link->m_peerAcked) || strcmp(link->ifOptions.user, name)))
			continue;
		write_link_state(fd, link, verbose);
	}
}

static void do_bping(ctrlfd_t *cfd, const char *str)
{
	unsigned size = LCP_ECHO_LEN + 1;
	CLink *link;

	if (*str != ' ') {
usage:
		cfd->printf("usage: bping [-s <size>] <channel>\n");
		cfd->done(-2);
		return;
	}
	str++;
	if (str[0] == '-' && str[1] == 's') {
		int i;
		str += 2;
		if (!*str)
			goto usage;
		if (isspace(*str))
			str++;
		if (!*str)
			goto usage;
		if (1 != sscanf(str, "%u%n", &size, &i))
			goto usage;
		str += i;
		if (*str != ' ')
			goto usage;
		str++;
		if (!*str)
			goto usage;
	}

	for (link = linkListHead ; link != NULL ; link = link->m_next) {
		if (strcmp(str, link->get_name()))
			continue;

		cfd->printf("pinging channel %s with size %u\n", str, size);

		new lcp_ping(cfd, link, size);
		return;
	}

	cfd->printf("channel '%s' not found\n", str);
	cfd->done(-2);
}

static void bpolicy_usage(ctrlfd_t *cfd)
{
	cfd->printf("usage: bpolicy iface <name> <args>\n");
	cfd->printf("usage: bpolicy iface <name> min_frags <num/opt>\n");
	cfd->printf("usage: bpolicy iface <name> max_frags <num/opt>\n");
	cfd->printf("usage: bpolicy global echo <want/opt>\n");
	cfd->printf("usage: bpolicy global echo_len <size>\n");
	cfd->printf("usage: bpolicy global mru <mru/opt>\n");
	cfd->printf("usage: bpolicy global mrru <mrru/opt>\n");
	cfd->printf("usage: bpolicy global rp_filter <value>\n");
	cfd->printf("usage: bpolicy global want_ipv6 <want>\n");
	cfd->done(-2);
}

static void do_bpolicy_iface(ctrlfd_t *cfd, char *str)
{
	char *iface_name = str;
	char *end = strchr(str, ' ');
	if (!end) {
usage:
		cfd->printf("unknown parameter: '%s'\n", str);
		bpolicy_usage(cfd);
		return;
	}

	str = end + 1;
	*end = 0;

	CInterface *iface = FindIfaceName(iface_name);
	if (!iface) {
		cfd->printf("interface not found: '%s'\n", iface_name);
		cfd->done(-1);
		return;
	}

	char *param = str;
	end = strchr(str, ' ');

	if (!end) {
		if (!strcmp(param, "min_frags")) {
			cfd->printf("min_frags: %d\n", iface->get_min_frags());
			cfd->done(0);
			return;
		} else if (!strcmp(param, "max_frags")) {
			cfd->printf("max_frags: %d\n", iface->get_max_frags());
			cfd->done(0);
			return;
		}
		goto usage;
	}

	str = end + 1;
	*end = 0;

	if (!strncmp(param, "min_frags", 9)) {
		long num = atol(str);
		iface->set_min_frags(cfd, num);
		return;
	} else if (!strncmp(param, "max_frags", 9)) {
		long num = atol(str);
		iface->set_max_frags(cfd, num);
		return;
	}
	goto usage;
}

static void bpolicy_print(ctrlfd_t *cfd, policy_t *pol, const char *scope,
			  const char *ident, enum PolicyOpts opt)
{
	if (pol->Valid(opt))
		cfd->printf("bpolicy %s %s %d\n", scope, ident, pol->Get(opt));
	else
		cfd->printf("bpolicy %s %s none\n", scope, ident);
}

void bpolicy_show_running_config(ctrlfd_t *cfd, int verbose)
{
	bpolicy_print(cfd, &g_policy, "global", "echo", P_ECHO);
	bpolicy_print(cfd, &g_policy, "global", "echo_interval",
		      P_ECHO_INTERVAL);
	bpolicy_print(cfd, &g_policy, "global", "echo_len", P_ECHO_LEN);
	bpolicy_print(cfd, &g_policy, "global", "mru", P_MRU);
	bpolicy_print(cfd, &g_policy, "global", "mrru", P_MRRU);
	bpolicy_print(cfd, &g_policy, "global", "rp_filter", P_REVERSE_PATH);
	bpolicy_print(cfd, &g_policy, "global", "want_ipv6", P_WANT_IPV6);
	bpolicy_print(cfd, &g_policy, "global", "ipv6_defroute", P_IPV6_DEFROUTE);
	bpolicy_print(cfd, &g_policy, "global", "want_rej_mrru", P_WANT_REJ_MRRU);
}

static void do_bpolicy_global(ctrlfd_t *cfd, char *str)
{
	if (!strcmp("mru", str)) {
		bpolicy_print(cfd, &g_policy, "global", "mru", P_MRU);
		cfd->done(0);
		return;
	} else if (!strcmp("echo", str)) {
		bpolicy_print(cfd, &g_policy, "global", "echo", P_ECHO);
		cfd->done(0);
		return;
	} else if (!strcmp("echo none", str)) {
		g_policy.Clear(P_ECHO);
		cfd->printf("global echo = none\n");
		cfd->done(0);
		return;
	} else if (!strncmp("echo ", str, 5)) {
		int echo = atoi(str + 5);
		if (echo < 0 || echo > 1000) {
			cfd->printf("bad echo %d\n", echo);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_ECHO, echo);
		cfd->printf("global echo %d\n", echo);
		cfd->done(0);
		return;
	} else if (!strcmp("echo_interval", str)) {
		bpolicy_print(cfd, &g_policy, "global", "echo_interval",
			      P_ECHO_INTERVAL);
		cfd->done(0);
		return;
	} else if (!strcmp("echo_interval none", str)) {
		g_policy.Clear(P_ECHO_INTERVAL);
		cfd->printf("global echo_interval none\n");
		cfd->done(0);
		return;
	} else if (!strncmp("echo_interval ", str, 14)) {
		int echo_interval = atoi(str + 14);
		if (echo_interval < 0) {
			cfd->printf("bad echo_interval %d\n", echo_interval);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_ECHO_INTERVAL, echo_interval);
		cfd->printf("global echo_interval %d\n", echo_interval);
		cfd->done(0);
		return;
	} else if (!strcmp("echo_len", str)) {
		bpolicy_print(cfd, &g_policy, "global", "echo_len", P_ECHO_LEN);
		cfd->done(0);
		return;
	} else if (!strcmp("echo_len none", str)) {
		g_policy.Clear(P_ECHO_LEN);
		cfd->printf("global echo_len none\n");
		cfd->done(0);
		return;
	} else if (!strncmp("echo_len ", str, 9)) {
		int echo_len = atoi(str + 9);
		if (echo_len < 0) {
			cfd->printf("bad echo_len %d\n", echo_len);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_ECHO_LEN, echo_len);
		cfd->printf("global echo_len %d\n", echo_len);
		cfd->done(0);
		return;
	} else if (!strcmp("ipv6_defroute", str)) {
		bpolicy_print(cfd, &g_policy, "global", "ipv6_defroute", P_IPV6_DEFROUTE);
		cfd->done(0);
		return;
	} else if (!strcmp("ipv6_defroute none", str)) {
		g_policy.Clear(P_IPV6_DEFROUTE);
		cfd->printf("global ipv6_defroute = none\n");
		cfd->done(0);
		return;
	} else if (!strncmp("ipv6_defroute ", str, 14)) {
		int ipv6_defroute = atoi(str + 14);
		if (ipv6_defroute < 0 || ipv6_defroute > 1) {
			cfd->printf("bad ipv6_defroute %d\n", ipv6_defroute);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_IPV6_DEFROUTE, ipv6_defroute);
		cfd->printf("global ipv6_defroute = %d\n", ipv6_defroute);
		cfd->done(0);
		return;
	} else if (!strcmp("want_ipv6", str)) {
		bpolicy_print(cfd, &g_policy, "global", "want_ipv6", P_WANT_IPV6);
		cfd->done(0);
		return;
	} else if (!strcmp("want_ipv6 none", str)) {
		g_policy.Clear(P_WANT_IPV6);
		cfd->printf("global want_ipv6 = none\n");
		cfd->done(0);
		return;
	} else if (!strcmp("want_rej_mrru", str)) {
		g_policy.Set(P_WANT_REJ_MRRU, 1);
		bpolicy_print(cfd, &g_policy, "global", "want_rej_mrru", P_WANT_REJ_MRRU);
		cfd->done(0);
		return;
	} else if (!strcmp("mrru", str)) {
		bpolicy_print(cfd, &g_policy, "global", "mrru", P_MRRU);
		cfd->done(0);
		return;
	} else if (!strcmp("mrru none", str)) {
		g_policy.Clear(P_MRRU);
		cfd->printf("global mrru = none\n");
		cfd->done(0);
		return;
	} else if (!strncmp("mrru ", str, 5)) {
		int mrru = atoi(str + 5);
		if (mrru < 576 || mrru > 65535) {
			cfd->printf("bad mrru %d\n", mrru);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_MRRU, mrru);
		cfd->printf("global mrru = %d\n", mrru);
		cfd->done(0);
		return;
	} else if (!strncmp("want_ipv6 ", str, 10)) {
		int want_ipv6 = atoi(str + 10);
		if (want_ipv6 < 0 || want_ipv6 > 1) {
			cfd->printf("bad want_ipv6 %d\n", want_ipv6);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_WANT_IPV6, want_ipv6);
		cfd->printf("global want_ipv6 = %d\n", want_ipv6);
		cfd->done(0);
		return;
	} else if (!strcmp("mru none", str)) {
		g_policy.Clear(P_MRU);
		cfd->printf("global mru = none\n");
		cfd->done(0);
		return;
	} else if (!strncmp("mru ", str, 4)) {
		int mru = atoi(str + 4);
		if (mru < 576 || mru > 65535) {
			cfd->printf("bad mru %d\n", mru);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_MRU, mru);
		cfd->printf("global mru = %d\n", mru);
		cfd->done(0);
		return;
	} else if (!strcmp("rp_filter none", str)) {
		g_policy.Clear(P_REVERSE_PATH);
	} else if (!strncmp("rp_filter ", str, 10)) {
		int rp_filter = atoi(str + 10);
		if (rp_filter < 0 || rp_filter > 2) {
			cfd->printf("bad rp_filter %d\n", rp_filter);
			cfd->done(-1);
			return;
		}

		g_policy.Set(P_REVERSE_PATH, rp_filter);
		cfd->printf("global rp_filter = %d\n", rp_filter);
		cfd->done(0);
		return;
	}

	bpolicy_usage(cfd);
}

void do_bpolicy(ctrlfd_t *cfd, char *str)
{
	if (*str != ' ')
		goto usage;

	str++;
	if (!strncmp("iface ", str, 6)) {
		str += 6;
		do_bpolicy_iface(cfd, str);
		return;
	}

	if (!strncmp("global ", str, 7)) {
		do_bpolicy_global(cfd, str + 7);
		return;
	}

usage:
	bpolicy_usage(cfd);
}

void link_query_dev(int fd, char *name, int verbose)
{
	CInterface *i = FindIfaceName(name);
	CLink *link;

	for (link=(i ? i->links : NULL); link; link=link->m_nextBundled)
		write_link_state(fd, link, verbose);
}

static void do_bquery(int fd, ctrlfd_t *cfd, char *arg)
{
	char *str, tmp[1024];
	char opt[MAX_USER_LEN];
	int got_user = 0, help = 0, got_opt = 0, got_dev = 0, verbose = 0;
	pid_t child;

	while (NULL != (str=getword(&arg))) {
		if (!strncmp(str, "--user=", 7)) {
			strncpy(opt, str+7, MAX_USER_LEN);
			got_user = 1;
		} else if (!strncmp(str, "--dev=", 6)) {
			strncpy(opt, str+6, MAX_USER_LEN);
			got_dev = 1;
		} else if (!strncmp(str, "--options", 9)) {
			got_opt = 1;
		} else if (!strcmp(str, "-v")) {
			verbose = 1;
		} else
			help = 1;
	}
	if (help) {
		strcpy(tmp, "[-1] -1: Usage: bquery [--user=<user id> | --dev=<interface name>] [--options]\n");
		write(fd, tmp, strlen(tmp));
		delete(cfd);
		return;
	}

	cfd->clear_events();

	child = fork();
	if (child) {
		if (child < 0) {
			cfd->perror("fork()");
			cfd->done(-2);
		}
		delete cfd;
		return;
	}

	if (!got_opt) {
		int l = sprintf(tmp,
			"[-1] 0: %-15s %-15s %*s%*s%-13s %*s%-13s %16s %4s %*s%s\n",
			"local_ip", "remote_ip",
			verbose ? -14 : 0, verbose ? "state" : "",
			verbose ? -9 : 0, verbose ? "class" : "",
			"dev",
			verbose ? -25 : 0, verbose ? "phone" :"",
			"name", "connected", "idle",
			verbose ? -9 : 0, verbose ? "qos" : "",
			"user"
			);
		write(fd, tmp, l);
	} else {
		int l = sprintf(tmp,
			"[-1] 0: %-10s %-4s %-10s %-6s %-6s %-6s %-6s %-6s %-6s %-9s %-9s %-9s\n",
			"channel", "    ", "magic", "mrru", "pfc", "acfc", "auth", 
			"answer", "ssn", "echo req", "echo int", "echo len"
		);
		write(fd, tmp, l);
	}

	if (got_opt) {
		if (got_user) 
			link_user_options(fd, opt); 
		else if (got_dev)
			link_dev_options(fd, opt); 
		else
			link_user_options(fd, NULL);
	} else if (got_dev) {
			link_query_dev(fd, opt, verbose);
	} else if (got_user) {
			link_query_user(fd, opt, verbose);
	} else {
		sprintf(tmp, "[-1] -1:\n");
		if (!got_user)
			link_query_user(fd, NULL, verbose);
	}
	sprintf(tmp, "[-1] -1:\n");
	write(fd, tmp, strlen(tmp));
	delete(cfd);
	_exit(0);
}

//void b_ctrlfd_read(int fd, void *data)
void ctrlfd_t::SelectEvent(int fd, SelectEventType event)
{
	if (event & SEL_READ) {
	char buf[1024];
	int len, i;

	if (c_fd != fd)
		Log(LF_ALERT|LF_IPC, "cfd->fd (%d) != fd (%d)", c_fd, fd);

	len = read(c_fd, buf, sizeof(buf));
	Log(LF_DEBUG|LF_IPC, "b_ctrlfd_read: %d got %d", c_fd, len);

	if (len <= 0) {
		Log(LF_DEBUG|LF_IPC, "b_ctrlfd_read: closing %d %p", c_fd, this);
		delete(this);
		return;
	}

	/* FIXME: this won't always work. */
	for (i=0; i<len; i++) {
		if (buf[i] == '\n' || buf[i] == '\r' || !buf[i]) {
			int pos = c_pos;
			c_pos = 0;
			c_err = 0;
			c_buf[pos] = 0;
			c_buf[pos+1] = 0;
			Log(LF_DEBUG|LF_IPC, "b_ctrlfd_read: got %d: '%s'", pos, c_buf);

			if (!strcmp(c_buf, "bchan rescan")) {
				char tmp[64];
				int i = load_channels(1);
				sprintf(tmp, "[-1] -1: added %d channel%s\n", i, (1 == i) ? "" : "s");
				write(c_fd, tmp, strlen(tmp));
			} else if (pos >= 7 && !strncmp(c_buf, "bhangup", 7))
				do_bchan(c_fd, this, c_buf+1);
			else if (pos >= 5 && !strncmp(c_buf, "bchan", 5))
				do_bchan(c_fd, this, c_buf+6);
			else if (pos >= 5 && !strncmp(c_buf, "bping", 5))
				do_bping(this, c_buf+5);
			else if (pos >= 5 && !strncmp(c_buf, "bvirt", 5))
				do_bvirt(this, c_buf+5);
			else if (pos >= 6 && !strncmp(c_buf, "bpppoe", 6))
				do_bpppoe(this, c_buf+7);
			else if (pos >= 6 && !strncmp(c_buf, "bquery", 6))
				do_bquery(c_fd, this, c_buf+7);
			else if (pos >= 7 && !strncmp(c_buf, "bradius", 7))
				do_bradius(this, c_buf+7);
			else if (pos >= 7 && !strncmp(c_buf, "bpolicy", 7))
				do_bpolicy(this, c_buf+7);
			else if (pos >= 8 && !strncmp(c_buf, "bcluster", 8))
				do_bcluster(this, c_buf+8);
			else if (!strcmp(c_buf, "bdial"))
				cmd_bdial(this, c_buf + 5);
			else if (pos > 6 && !strncmp(c_buf, "bdial ", 6)) {
				cmd_bdial(this, c_buf + 6);
#ifdef USE_L2TP
			} else if (pos >= 7 && !strncmp(c_buf, "l2tpctl", 7)) {
				do_l2tpctl(this, c_buf+7);
#endif
			} else {
				char tmp[256];
				snprintf(tmp, 256, "[-1] -1: unknown command %s\n", c_buf);
				write(c_fd, tmp, strlen(tmp));
			}
		} else if (c_pos+1 < sizeof(c_buf))
			c_buf[c_pos++] = buf[i];
		else
			c_err = 1;
	}
	}
}

//ctrlfd_listener *cfd_listen = new ctrlfd_listener(b_control_fd);
class ctrlfd_listener : public SelectEventHandler {
public:
	ctrlfd_listener(int fd) {
		SelectSetEvents(fd, SEL_READ);
	}

	void SelectEvent(int fd, SelectEventType event);
};

void ctrlfd_listener::SelectEvent(int fd, SelectEventType event)
{
	ctrlfd_t *cfd;
	int newfd;

	newfd = accept(fd, NULL, 0);
	if (newfd < 0) {
		syslog(LOG_ERR, "b_control_wakeup: error accepting connection: %s\n", strerror(errno));
		return;
	}

	cfd = new ctrlfd_t(newfd);
	//setup_select(newfd, cfd, b_ctrlfd_read, NULL);
	cfd->SelectSetEvents(newfd, SEL_READ);
	Log(LF_DEBUG|LF_IPC, "accepted connection on control socket(%d): %d %p", fd, newfd, cfd);
}

static void sigchld_handler(int sig)
{
	int status;
	while (waitpid(-1, &status, WNOHANG) > 0)
		;
	signal(SIGCHLD, sigchld_handler);
}

static void do_cmd(const char *cmd, char *dev, char *port, char *user, char *qos_profile_name)
{
	struct stat s;
	pid_t pid;

	if (0 != stat(cmd, &s))
		return;
	if (!(S_IXUSR & s.st_mode))
		return;

	pid = fork();
	if (0 == pid) {
		execl(cmd, cmd, dev, port, user, qos_profile_name, (char *)NULL);
		syslog(LOG_ERR, "execl(%s):%m", cmd);
		_exit(100);
	} else if (-1 == pid)
		syslog(LOG_ERR, "fork():%m");
}

void exit_handler(int foo)
{
	if (foo);
	unlink(control_path);
	_exit(0);
}

int main(int argc, char **argv)
{
	struct sockaddr_un addr;
	int do_fork = 1;	/* Daemon forks to background */
	int do_route = 1;	/* Daemon adds routes */
	int do_proxy = 1;	/* Daemon adds proxy */
	int do_load_chans = 0;
	int do_restore_state = 0;
	dfs_object_t *dfs = NULL;
	const char *l2tp_file = "/etc/babylon/l2tp.conf", *l2tp_default_file = l2tp_file;
	pid_t pid;
	int dbg_flags = LOG_INFO;
	int opt;
	int opt_indx;

	selectops_epoll_init();
	init_netlink();

	/* Set the command name for the print_usage routine */
	cmdname = rindex(argv[0], '/');
	if (cmdname) {
		cmdname++;
	} else {
		cmdname = argv[0];
	}
	debug=0;
	/* Set the default filenames */
	strcpy(configFile,DEFAULT_CFG_FILE);
	strcpy(dynamicFile,DEFAULT_DYN_FILE);
	
	while((opt = getopt_long(argc, argv, shrt_options, long_options, &opt_indx)) != EOF) {
		switch(opt) {
#ifdef USE_L2TP
			case '2':	/* turn on l2tp */
				if (!optarg && optind < argc && argv[optind][0] != '-')
					optarg = argv[optind++];
				l2tp_file = optarg;
				break;
#endif
			case 'f':	/* Don't fork */
				do_fork = 0;
				break;

			case 'M':	/* --want-mlcp */
				want_mlcp = 1;
				break;

			case 'r':	/* Don't do routing */
				do_route = 0;
				break;

			case 'p':	/* Don't do proxy arp */
				do_proxy = 0;
				break;

			case 'R':	/* Do do routing */
				do_route = 1;
				break;

			case 'P':	/* Do do proxy arp */
				do_proxy = 1;
				break;

			case 'F':	/* enable pfc */
				deny_pfc = 0;
				break;

			case 'a':
			case 'u':
				if (!optarg && optind < argc && argv[optind][0] != '-')
					optarg = argv[optind++];
				setup_radius(new ctrlfd_t(2, 1), optarg,
					     (opt == 'a'));
				break;

			case 'd':	/* Enable debugging messages to stderr */
			{
				if (!optarg && optind < argc && argv[optind][0] != '-')
					optarg = argv[optind++];
				debug = strtol(optarg,NULL,0);
				if  ((debug == LONG_MAX || debug == LONG_MIN) && (errno == ERANGE)) {
						fprintf(stderr, "Invalid debug parameter '%s' -- must be a number.\n", optarg);
						print_usage();
					}
				break;
			}

			case 'D':
				print_debuglevels();
				/* Should never get here */
				break;
			case 'i':	/* Do dynamic IP allocation for incoming calls */
				dyn_ip_enabled = 1;
				break;

			case 'I':	/* Don't do dynamic IP allocation for incoming calls */
				dyn_ip_enabled = 0;
				break;

			case 'n':	/* Specify system name */
				if (!optarg && optind < argc && argv[optind][0] != '-')
					optarg = argv[optind++];
				if (optarg) {
					sysname = optarg;
				} else {
					fprintf(stderr, "Missing system name for -n parameter.\n");
					print_usage();
				}

				break;

			case 's':	/* Do channel scan on load */
				do_load_chans = 1;
				break;

			case 'B':	/* Enable broken acfc support */
				broken_acfc=1;
				break;
			case 'c':

				if (!optarg && optind < argc && argv[optind][0] != '-')
					optarg = argv[optind++];
				if (optarg) {
					strncpy(configFile,optarg,MAXPATHLEN);
				} else {
					fprintf(stderr,"Missing config file name.\n");
					print_usage();
				}
				/* Make sure the file does exist */
				if (access(configFile,R_OK)!=0) {
					fprintf(stderr,"Cannot find/read config file: %s.\n",configFile);
					print_usage();
				}
				break;
			case 'C':

				if (!optarg && optind < argc && argv[optind][0] != '-')
					optarg = argv[optind++];
				if (optarg)
					strncpy(control_path, optarg, MAXPATHLEN);
				else {
					fprintf(stderr, "Missing control file name.\n");
					print_usage();
				}
				break;
			case 'y':

				if (!optarg && optind < argc && argv[optind][0] != '-')
					optarg = argv[optind++];
				if (optarg) {
					strncpy(dynamicFile,optarg,MAXPATHLEN);
				} else {
					fprintf(stderr,"Missing dynamic IP file name.\n");
					print_usage();
				}			
				/* Make sure the file does exist */
				if (access(dynamicFile,R_OK)!=0) {
					fprintf(stderr,"Cannot find/read dynamic IP file: %s.\n",dynamicFile);
					print_usage();
				}
				break;
			case 'S':
				do_restore_state = 1;
				break;
			case 'U':
				do_userland_only = 1;
				break;
			default:
				print_usage();
				return -1;
		}
	}

	if (optind != argc) {
		print_usage();
		return -1;
	}

	if (!do_userland_only && getuid()!=0) {
		fprintf(stderr,"\n%s much be run as root.\n\n",cmdname);
		exit(1);
	}
	openlog("babylond", LOG_NDELAY | LOG_PID , LOG_AUTHPRIV);
	setlogmask(LOG_UPTO(dbg_flags));
	
	/* Set up the dynamic ip pool -- if there is one */
	if (dyn_ip_enabled && 0 != parse_dynamic()) {
		syslog(LOG_ERR, " Error parsing file: /etc/babylon/dynamic_ip.conf");
		return -1;
	}

	b_sock_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == b_sock_fd) {
		syslog(LOG_ERR, "socket(AF_INET, SOCK_STREAM, 0): %s\n", strerror(errno));
		exit(1);
	}

	/* Lack of ipv6 isn't fatal. */
	b_sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
	if (b_sock6_fd < 0) {
		int err = errno;
		syslog(LOG_ERR, "error creating ipv6 socket: %s\n",
		       strerror(err));
		fprintf(stderr, "ipv6 support disabled: %s\n", strerror(err));
	}

	if ((b_control_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
		syslog(LOG_ERR, "error creating control socket: %s\n", strerror(errno));
		return 1;
	}

	addr.sun_family = AF_UNIX;
	strcpy(addr.sun_path, control_path);
	if (unlink(control_path) && (errno != ENOENT)) {
		const char *err = strerror(errno);
		fprintf(stderr, "unlink(%s): %s\n", control_path, err);
		return 1;
	}
	umask(0077);
	if (bind(b_control_fd, (struct sockaddr *)&addr, sizeof(addr.sun_family)+strlen(addr.sun_path)) < 0) {
		syslog(LOG_ERR, "error binding control socket to %s: %s\n", control_path, strerror(errno));
		return 1;
	}

	if (listen(b_control_fd, 64) < 0) {
		syslog(LOG_ERR, "listen(control socket): %s\n", strerror(errno));
		return 1;
	}

	//setup_select(b_control_fd, NULL, b_control_accept, NULL);
	ctrlfd_listener *cfd_listen = new ctrlfd_listener(b_control_fd);

	int sync_fds[2];

	/*
	 * Fork and run in the background
	 */
	if (do_fork) {
		if (cloexec_pipe(sync_fds)) {
			perror("cloexec_pipe");
			exit(2);
		}

		pid = fork();
		if (pid > 0) {
			int ret, len;
			close(sync_fds[1]);
			len = read(sync_fds[0], &ret, sizeof(ret));
			if (sizeof(ret) == len)
				return ret;
			if (len == 0) {
				int status;
				if (pid == waitpid(pid, &status, 0)) {
					if (WIFEXITED(status))
						return WEXITSTATUS(status);
					fprintf(stderr, "exiting for unknown failure\n");
					return 1;
				}
				perror("waitpid");
				return 1;
			}
			if (ret < 0) {
				perror("pipe read");
				return 1;
			}
			fprintf(stderr, "exiting for unknown failure\n");
			return 1;	/* Parent exits */
		}

		if (pid < 0) {
			syslog(LOG_ERR, "Error switching to background: fork: %s\n", strerror(errno));
			return -1;
		}

		close(sync_fds[0]);
#if 0
		close(0);
		close(1);
		close(2);

		open("/dev/null", O_RDWR);
		dup(0);
		dup(0);
#endif
	}

	aps_init();
	if (do_load_chans)
		load_channels(0);

#ifdef USE_L2TP
	FILE *l2tp_cfg = fopen(l2tp_file, "r");
	if (l2tp_cfg) {
		int ret = l2tp_setup(l2tp_cfg);
		fclose(l2tp_cfg);

		if (ret)
			return ret;
	} else if (l2tp_file != l2tp_default_file) {
		const char *err = strerror(errno);
		fprintf(stderr, "babylon: unable to open '%s' : %s\n", l2tp_file, err);
		return 1;
	}
#endif

	if (do_restore_state) {
		dfs = dfs_parse_state(stdin);
		if (!dfs) {
			fprintf(stderr, "restore_state: parse failed\n");
			return 1;
		}
	}

	/* last thing before the main loop... */
	signal(SIGCHLD, sigchld_handler);
	signal(SIGPIPE, SIG_IGN);
	signal(SIGINT, exit_handler);
	signal(SIGQUIT, exit_handler);
	signal(SIGTERM, exit_handler);

	if (dfs) {
		if (dfs_build_state(dfs)) {
			fprintf(stderr, "dfs_build_state: FAILED\n");
			exit(2);
		}
	}

	if (do_fork) {
		int ret = 0;
		write(sync_fds[1], &ret, sizeof(ret));
		close(sync_fds[1]);
	}

	while (!finished) {
		bab_poll();
	}

	delete cfd_listen;

	aps_cleanup();
	unlink(control_path);

	return 0;

}

void SendAccounting(AcctMessage_t *acct_buf)
{
	if (acct_buf->type == ACCT_START) {
		syslog(LOG_INFO, "Service started for %s on port %s (%s) phone %s",
			acct_buf->user, acct_buf->port, acct_buf->dev_class,
			acct_buf->phone);
		syslog(LOG_INFO, "Local IP: %s  Remote IP: %s",
			iptostr(acct_buf->loc_ip_address),
			iptostr(acct_buf->rem_ip_address));
		do_cmd("/etc/babylon/bab-up", acct_buf->ifname, acct_buf->port, acct_buf->user, acct_buf->qos_profile_name);
	} else if (acct_buf->type == ACCT_INTERIM_UPDATE) {
		syslog(LOG_INFO, "Service interim update for %s on port %s (%s) phone %s",
			acct_buf->user, acct_buf->port, acct_buf->dev_class,
			acct_buf->phone);

		syslog(LOG_INFO, "Rx Stats: Packets: %Lu, Octets: %Lu",
			acct_buf->in_packets, acct_buf->in_octets);
		syslog(LOG_INFO, "Tx Stats: Packets: %Lu, Octets: %Lu",
			acct_buf->out_packets, acct_buf->out_octets);
		syslog(LOG_INFO, "Local IP: %s  Remote IP: %s",
			iptostr(acct_buf->loc_ip_address),
			iptostr(acct_buf->rem_ip_address));
	} else {
		syslog(LOG_INFO, "Service ended for %s on port %s (%s) phone %s",
			acct_buf->user, acct_buf->port, acct_buf->dev_class,
			acct_buf->phone);
		syslog(LOG_INFO, "Termination cause: %s", acct_buf->reason);

		syslog(LOG_INFO, "Rx Stats: Packets: %Lu, Octets: %Lu",
			acct_buf->in_packets, acct_buf->in_octets);
		syslog(LOG_INFO, "Tx Stats: Packets: %Lu, Octets: %Lu",
			acct_buf->out_packets, acct_buf->out_octets);
		syslog(LOG_INFO, "Local IP: %s  Remote IP: %s",
			iptostr(acct_buf->loc_ip_address),
			iptostr(acct_buf->rem_ip_address));
		do_cmd("/etc/babylon/bab-down", acct_buf->ifname, acct_buf->port, acct_buf->user, NULL);
	}

	if (am_radius_acct_client)
		radius_acct(acct_buf);

	delete(acct_buf);
}

/*
 * Get the hardware address of a device on the same subnet
 * as remote ip.
 */
static int get_ether_addr(u32 rem_ip, struct sockaddr *hwaddr, char *name)
{
	int sockfd = -1;
	struct ifreq *ifr = NULL, *ifend = NULL;
	u32 ina = 0, mask = 0;
	struct ifreq ifreq;
	struct ifconf ifc;
	struct ifreq ifs[MAX_IFS];	// FIXME!!!

	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) {
		syslog(LOG_ERR, "Unable to open socket");
		return 0;
	}

	memset(&ifreq, 0, sizeof(struct ifreq));
	memset(&ifc, 0, sizeof(struct ifconf));

	/* 
	 * Request all the devices configured on system
	 */
	ifc.ifc_len = sizeof(ifs); 
	ifc.ifc_ifcu.ifcu_req = ifs; 
	if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) {
		syslog(LOG_ERR, "ioctl(SIOCGIFCONF) :%m");
		return 0;
	}

	syslog(LOG_DEBUG, "Scanning %ld interfaces for ip 0x%x",
			(long)(ifc.ifc_len / sizeof(struct ifreq)), rem_ip);

	/*
	 * Scan through looking for an interface with same subnet
	 * as rem_ip
	 */

	ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
	for(ifr = ifc.ifc_ifcu.ifcu_req; ifr < ifend; ifr++) {
		if(ifr->ifr_ifru.ifru_addr.sa_family == AF_INET) {
			ina = ((struct sockaddr_in *)&ifr->ifr_ifru.ifru_addr)->sin_addr.s_addr;
			strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
			syslog(LOG_DEBUG, "Proxy arp examining interface %s",
				ifreq.ifr_name);


			if(ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0) {
				continue;
			}
	
			if(((ifreq.ifr_ifru.ifru_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0) {
				continue;
			}
		
			/*
			 * Get the netmask and check that its the right subnet
			 */
			mask = ((struct sockaddr_in *) &ifreq.ifr_ifru.ifru_addr)->sin_addr.s_addr;
			syslog(LOG_DEBUG, "Proxy arp interface address %lx mask %lx",
				(unsigned long)ina, (unsigned long)ntohl(mask));

			if(((rem_ip ^ ina) & mask) != 0) {
				continue;
			}
			break;
		}
	}

	if(ifr >= ifend) {
		return 0;
	}

	memcpy(name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
	syslog(LOG_DEBUG, "Found interface %s for proxy arp", name);


	/*
	 * Now get the hardware address
	 */
	memset(&ifreq.ifr_ifru.ifru_hwaddr, 0, sizeof(struct sockaddr));
	if(ioctl(sockfd, SIOCGIFHWADDR, &ifreq) < 0) {
		syslog(LOG_ERR, "SIOCGIFHWADDR(%s) :%m", ifreq.ifr_name);
		return 0;
	}
#if 0
#ifdef FREEBSD
#elif defined(LINUX)
#else
# error "Don't know how to get etherner hardware address."
#endif
#endif

	*hwaddr = ifreq.ifr_ifru.ifru_hwaddr;
	syslog(LOG_DEBUG, "Successfully got hardware address");
	return 1;
}

/*
 * Add a proxy arp
 */
void AddProxy(ProxyMsg_t *proxy_buf)
{
	struct arpreq arp;
	int sock_fd = -1;


	sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sock_fd < 0) {
		syslog(LOG_ERR, "Error opening socket for route add %m(%d)", errno);
		return;
	}

	syslog(LOG_DEBUG, "Opened socket %#x", sock_fd);
	
	memset(&arp, 0, sizeof(struct arpreq));
	
	syslog(LOG_DEBUG, "get_ether_addr with dst_addr %x", proxy_buf->dst_addr);

	if (!get_ether_addr(proxy_buf->dst_addr, &arp.arp_ha, arp.arp_dev)) {
		syslog(LOG_ERR, "Cannot determine ethernet address for proxy arp");
		return; 
	}
	
	arp.arp_pa.sa_family = AF_INET;
	((struct sockaddr_in *)&arp.arp_pa)->sin_addr.s_addr = proxy_buf->dst_addr;
	arp.arp_flags = ATF_PERM | ATF_PUBL;


	if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arp) < 0)
		syslog(LOG_ERR, "Error adding proxy %m(%d)", errno);
	else
		syslog(LOG_INFO, "Proxy added"); 

	close(sock_fd);
}

	

/*
 * Add a route
 */
void AddRoute(RouteMsg_t *rt_buf)
{
	struct rtentry rt;
	memset(&rt, 0, sizeof(struct rtentry));

	if (rt_buf->flags == ROUTE_HOST) {
		syslog(LOG_DEBUG, "Adding host route");	
		rt.rt_dst.sa_family = AF_INET;
		((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = rt_buf->dst_addr;
		rt.rt_genmask.sa_family = AF_INET;
		((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = rt_buf->mask;
		rt.rt_dev = rt_buf->dev;
		rt.rt_metric = rt_buf->metric;
		rt.rt_flags = RTF_UP | RTF_HOST;	
	}
	else if(rt_buf->flags == ROUTE_NET) {
		syslog(LOG_DEBUG, "Adding net route");	
		rt.rt_dst.sa_family = AF_INET;
		((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = rt_buf->dst_addr;
		rt.rt_genmask.sa_family = AF_INET;
		((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = rt_buf->mask;
		rt.rt_dev = rt_buf->dev;
		rt.rt_metric = rt_buf->metric;
		rt.rt_flags = RTF_UP;
	}
	else if (rt_buf->flags == ROUTE_GATEWAY) {
		syslog(LOG_DEBUG, "Adding default route (gateway: 0x%lx)", 
				(unsigned long)rt_buf->gw_addr);
		rt.rt_dev = rt_buf->dev;
		rt.rt_flags = RTF_UP | RTF_GATEWAY;
		rt.rt_dst.sa_family = AF_INET;
		rt.rt_gateway.sa_family = AF_INET;
		((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = rt_buf->gw_addr;
	}

	if(ioctl(b_sock_fd, SIOCADDRT, &rt) < 0) {
		syslog(LOG_ERR, "Error adding route %m(%d)", errno);
	}
	else {
		syslog(LOG_INFO, "Route added to %s through %s", 
			iptostr(ntohl(rt_buf->dst_addr)), rt_buf->dev);
	}
}

static policy_t *parse_new_user_config(const char *fname, void (*cbf)(void *, OptionSet_t *), void *obj, OptionSet_t *options)
{
	policy_t *pol = NULL;
	FILE *ifp;
	char buf[1024], *str;

	ifp = fopen(fname, "r");
	if (!ifp) {
		fprintf(stderr, "fopen('%s') failed: %s\n", fname, strerror(errno));
		return NULL;
	}

	while (fgets(buf, sizeof buf, ifp)) {
		int len = strlen(buf);
		str = buf;

		if (len && (buf[len-1] == '\n'))
			buf[--len] = 0;

		while (*str && isspace(*str))
			str++;

		if (*str == '#' || !*str)
			continue;

		if (!pol)
			pol = new policy_t;

		if (!strncmp(str, "mru ", 4))
			pol->Set(P_MRU, atoi(str+4));
		else if (!strncmp(str, "mrru ", 5))
			pol->Set(P_MRRU, atoi(str+5));
		else if (!strcmp(str, "rp_filter none"))
			pol->Clear(P_REVERSE_PATH);
		else if (!strncmp(str, "rp_filter ", 10))
			pol->Set(P_REVERSE_PATH, atoi(str+10));
		else if (!strncmp(str, "want_mlcp", 9))
			pol->Set(P_WANT_MLCP, 1);
		else if (!strncmp(str, "want_rej_mrru", 13))
			pol->Set(P_WANT_REJ_MRRU, 1);
		else if (!strncmp(str, "want_rain", 9))
			pol->Set(P_WANT_RAIN, 1);
		else if (!strncmp(str, "want_ipv6", 9))
			pol->Set(P_WANT_IPV6, 1);
		else if (!strcmp(str, "ipv6_defroute"))
			pol->Set(P_IPV6_DEFROUTE, 1);
		else if (!strncmp(str, "echo ", 5))
			pol->Set(P_ECHO, atoi(str+5));
		else if (!strncmp(str, "echo_interval ", 14))
			pol->Set(P_ECHO_INTERVAL, atoi(str+14));
		else if (!strncmp(str, "echo_len ", 9))
			pol->Set(P_ECHO_LEN, atoi(str+9));
		else if (!strncmp(str, "ssn ", 4)) {
			pol->Set(P_SSN, atoi(str+4));
			pol->Set(P_MLCP_SSN, atoi(str+4));
		} else if (!strncmp(str, "min_frags ", 10))
			options->min_frags = atoi(str+10);
		else if (!strncmp(str, "max_frags ", 10))
			options->max_frags = atoi(str+10);
		else
			fprintf(stderr, "%s: unrecognized directive '%s'\n",
				fname, str);
	}

	fclose(ifp);
	if (!pol)
		return NULL;

	fprintf(stderr, "%s: ssn %d\n", fname, pol->Get(P_SSN));
	fprintf(stderr, "%s: mru %d\n", fname, pol->Get(P_MRU));
	fprintf(stderr, "%s: mrru %d\n", fname, pol->Get(P_MRRU));
	fprintf(stderr, "%s: rp_filter %d\n", fname, pol->Get(P_REVERSE_PATH));
	fprintf(stderr, "%s: want_mlcp %d\n", fname, pol->Get(P_WANT_MLCP));
	fprintf(stderr, "%s: want_rej_mrru %d\n", fname, pol->Get(P_WANT_REJ_MRRU));
	fprintf(stderr, "%s: echo %d\n", fname, pol->Get(P_ECHO));
	fprintf(stderr, "%s: echo_interval %d\n", fname, pol->Get(P_ECHO_INTERVAL));
	fprintf(stderr, "%s: echo_len %d\n", fname, pol->Get(P_ECHO_LEN));

	return pol;
}

/*
 * Read a configuration from the config file and validate
 * the users credentials
 */
void babd_GetConfig(void (*cbf)(void *, OptionSet_t *), void *obj, OptionSet_t *options)
{
	struct user_map *map = user_map_lookup(options->user);

	/* we still have to use babylon.conf for dialout */
	if (!options->site[0] && map &&
	    !strncmp(map->new_user, "babylon.conf:", 13)) {
		strcpy(options->user, map->new_user + 13);
		fprintf(stderr, "mapped user %s => babylon.conf:%s\n",
			map->old_user, options->user);
	} else if (!options->site[0] && am_radius_client) {
		if (map) {
			fprintf(stderr, "mapped user %s => %s (radius)\n",
				options->user, map->new_user);
			strcpy(options->user, map->new_user);
		}
		RadiusReq *req = new RadiusReq();
		req->Go_cfg(cbf, obj, options);
		return;
	}

	CfgMessage_t *auth_buf, fooble;
	FILE *cfg_file;
	CfgMessage_t dflt;
	CfgMessage_t current;
	CfgMessage_t *active = &current;
	char entry[256];
	char nstr_buf[1024];
	char *nstr = nstr_buf;
	int i, t_count = 0, l_count = 0;
	policy_t *new_pol = NULL;

	fooble.reserved1 = cbf;
	fooble.reserved2 = obj;
	auth_buf = &fooble;

	if (options->phone[0]) {
		strcpy(dflt.options.phone, options->phone);
		strcpy(current.options.phone, options->phone);
	}

	if (options->dev_class[0]) {
		strcpy(dflt.options.dev_class, options->dev_class);
		strcpy(current.options.dev_class, options->dev_class);
	}

	if (options->site[0] || options->user[0]) {
		if (options->site[0]) {
			strcpy(nstr_buf, "/etc/babylon/site-conf.d/");
			strcat(nstr_buf, options->site);
		} else {
			strcpy(nstr_buf, "/etc/babylon/users-conf.d/");
			strcat(nstr_buf, options->user);
		}
		if (!access(nstr_buf, R_OK))
			new_pol = parse_new_user_config(nstr_buf, cbf, obj, options);
		else if (debug)
			fprintf(stderr, "site(%s) fname(%s)\n", options->site, nstr_buf);

		if (new_pol) {
			dflt.options.min_frags = options->min_frags;
			dflt.options.max_frags = options->max_frags;
		}
	}

	fooble.options.Set(*options);

	cfg_file = fopen(configFile, "r");
	if(cfg_file == NULL) {
		syslog(LOG_ERR, "Error opening config file %s", configFile);
		goto out_failed;
	}

	while (!feof(cfg_file)) {
		int len;
		current.Set(&dflt);
		active = &current;

		l_count++;
		fgets(entry, 256, cfg_file);
		entry[255] = 0;
		len = strlen(entry);
		if (len && entry[len-1] == '\n')
			entry[--len] = '\0';

		syslog(LOG_DEBUG, "%d: %s", l_count, entry);

		/*
		 * Filter out comments and blanks
		 */
		if((entry[0] == '#') || (len == 0))
			continue;

		nstr = nstr_buf;
		strcpy(nstr, entry);
		/* 32 is enough to convert all ':'s in the string to nuls. */
		memset(nstr+len, '\0', 32);

		/*
		 * convert the tokens to nulls
		 */
		t_count = 0;
		for (i = 0 ; nstr[i] != '\0'; i++) {
			if (nstr[i] == ':') {
				t_count++;
				nstr[i] = '\0';
			}
		}

		/*
		 * Make sure we have enough fields
		 */
		if (t_count < 1 || t_count > 15) {
			syslog(LOG_WARNING, 
				"Parse error reading config line %d, ignored", 
				l_count);
			continue;
		}

		/*
		 * Get the user name
		 */
		strcpy(active->options.user, nstr);
		nstr += strlen(nstr) + 1;
		if (active->options.user[0] == '\0') {
			/*
			 * default entry
			 */
			active = &dflt;
		}
		syslog(LOG_DEBUG, "User: %s", active->options.user);

		/* Get Password */
		strcpy(active->options.passwd, nstr);
		nstr += strlen(nstr) + 1;
		syslog(LOG_DEBUG, "Password: %s", active->options.passwd);

		/* Get Site */
		if (active == &dflt && *nstr)
			active = &current;
		strcpy(active->options.site, nstr);
		nstr += strlen(nstr) + 1;
		syslog(LOG_DEBUG, "Site: %s", active->options.site);

		/* Get Local IP */
		if (nstr[0] == '\0')
			active->options.loc_ip = dflt.options.loc_ip;
		else {
			if(0 == strncasecmp(nstr, "dynamic", strlen("dynamic"))) {
				nstr += strlen("dynamic");
				while((*nstr == '\t') || (*nstr == ' '))
					nstr++;
				if (active->options.loc_ip_pool)
					free(active->options.loc_ip_pool);
				active->options.loc_ip_pool = strdup(nstr);
				active->options.loc_ip = 0xffffffffU;
			} else
				active->options.loc_ip = strtoip(nstr);
		}

		nstr += strlen(nstr) + 1;
		
		/* Get Remote IP */
		if (nstr[0] == '\0')
			active->options.rem_ip = dflt.options.rem_ip;
		else {
			if(0 == strncasecmp(nstr, "dynamic", strlen("dynamic"))) {
				nstr += strlen("dynamic");
				while((*nstr == '\t') || (*nstr == ' '))
					nstr++;
				if (active->options.rem_ip_pool)
					free(active->options.rem_ip_pool);
				active->options.rem_ip_pool = strdup(nstr);
				active->options.rem_ip = 0xffffffffU;
			}
			else {
				/* Use static ip address */
				active->options.rem_ip = strtoip(nstr);
			}
		}
		nstr += strlen(nstr) + 1;

		/* Get Netmask */
		if (nstr[0] == '\0')
			active->options.netmask = dflt.options.netmask;
		else
			active->options.netmask = strtoip(nstr);

		nstr += strlen(nstr) + 1;

		/* Get Primary DNS */
		if (nstr[0] == '\0')
			active->options.dns_primary = dflt.options.dns_primary;
		else
			active->options.dns_primary = strtoip(nstr);

		nstr += strlen(nstr) + 1;

		/* Get Secondary DNS */
		if (nstr[0] == '\0')
			active->options.dns_second = dflt.options.dns_second;
		else
			active->options.dns_second = strtoip(nstr);

		nstr += strlen(nstr) + 1;

		/* Get default/net route flag */
		if(nstr[0] == '\0') {
			active->options.defroute = dflt.options.defroute;
			active->options.netroute = dflt.options.netroute;
		} else {
			if(nstr[0] == 'b' || nstr[0] == 'B') {
				// both routes
				active->options.defroute = 1;
				active->options.netroute = 1;
			}
			else if(nstr[0] == 'n' || nstr[0] == 'N') {
				// Add network route
				active->options.netroute = 1;
			}
			else if(nstr[0] == 'd' || nstr[0] == 'D') {
				// Add default route
				active->options.defroute = 1;
			}
		}
		nstr += strlen(nstr) + 1;

		/* Get proxy ARP flag */
		if (nstr[0] == '\0')
			active->options.proxy = dflt.options.proxy;
		else
			active->options.proxy = strtol(nstr, NULL, 10);

		nstr += strlen(nstr) + 1;

		/* Get the device class */
		if (nstr[0] == '\0')
			strcpy(active->options.dev_class, dflt.options.dev_class);
		else
			strcpy(active->options.dev_class, nstr);

		nstr += strlen(nstr) + 1;

		/* Get the device name */
		if (nstr[0] == '\0')
			strcpy(active->options.port, dflt.options.port);
		else
			strcpy(active->options.port, nstr);
		nstr += strlen(nstr) + 1;

		/* Get static paramters */
		if (nstr[0] != '\0') {
			int *ints[] = {
				&active->options.min_links,	&active->options.max_links,
				&active->options.addtime,	&active->options.droptime,
				&active->options.rx_drop_bpls,	&active->options.rx_raise_bpls,
				&active->options.tx_drop_bpls,	&active->options.tx_raise_bpls
			};
			char *sep = strchr(nstr, ',');
			int i;

			active->options.min_links = active->options.max_links = atoi(nstr);
			active->options.addtime = 30;
			active->options.droptime = 0;

			for (i=1; sep && i<=7; i++) {
				if (',' != sep[1])
					*ints[i] = atoi(sep+1);
				sep = strchr(sep+1, ',');
			}
		}
		nstr += strlen(nstr) + 1;

		/* Get class-specific additional call info */
		if (nstr[0] != '\0') {
			active->options.call_info = atoi(nstr);
		}
		nstr += strlen(nstr) + 1;

		/* Get the phone number for dial out only */
		if(nstr[0] != '\0') {
			strcpy(active->options.phone, nstr);
			syslog(LOG_DEBUG, "Phone: %s", active->options.phone);
		}

		/*
		 * If we filled defaults, we're done
		 */
		if (active == &dflt)
			continue;

		if (new_pol) {
			if (!active->options.pol)
				active->options.pol = new policy_t;
			if (!auth_buf->options.pol)
				auth_buf->options.pol = new policy_t;

			active->options.pol->Merge(*new_pol);
			auth_buf->options.pol->Merge(*new_pol);
		}

		/*
		 * If the site is set, get options
		 */
		if (auth_buf->options.site[0] != '\0') {
			syslog(LOG_DEBUG, "Checking site %s == %s",
				auth_buf->options.site, active->options.site);
			if(strcmp(auth_buf->options.site, active->options.site)) {
					continue;
			}
			else if(auth_buf->options.proto_id == 0xc223) {
				syslog(LOG_INFO, "Doing chap auth for site %s\n", auth_buf->options.site);
				strcpy(auth_buf->options.user, active->options.user);
				do_chap_auth(active, auth_buf);
				goto out;
			}

			syslog(LOG_INFO, "Dial-out request for site %s, phone %s", auth_buf->options.site,active->options.phone);
			active->reserved1 = auth_buf->reserved1;
			active->reserved2 = auth_buf->reserved2;
			if (auth_buf->options.phone[0])
				strcpy(active->options.phone, auth_buf->options.phone);
			active->options.SetCall(auth_buf->options.call);
			active->options.ClonePolFrom(auth_buf->options.pol);
			active->options.is_valid = 1;
			active->reserved1(active->reserved2, &active->options);
			goto out;
		}

		if (auth_buf->options.user[0] == '\0') {
			/*
			 * Not sure what to do, reject
			 */
			syslog(LOG_ERR, "Configure request failed, insufficient information: Username blank?");
			auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
			goto out;
		}

		/*
		 * The user name is set, authenticate
		 */
		syslog(LOG_DEBUG, "Checking %s == %s", auth_buf->options.user, active->options.user);
		if (strcmp(auth_buf->options.user, active->options.user))
			continue;

		/* Check the password */
		if(((active->options.passwd[0] != '*') && 
			(strlen(active->options.passwd) != 1))) {
			if(auth_buf->options.proto_id == 0xc023) {
				/*
				 * Authenticate from the configuration as clear text
				 */
				if(strcmp(active->options.passwd, auth_buf->options.passwd)) {
					syslog(LOG_NOTICE, "PAP Login failure for %s on port %s remote passwd %s phone %s, "
						"invalid password", auth_buf->options.user, 
						auth_buf->options.port, auth_buf->options.passwd,
						auth_buf->options.phone);
					auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
					goto out;
				}
				else {
					/* 
					 * Password authentication succeeded 
					 * check the class and port
					 */
					if(active->options.port[0] != '\0') {
						if(strcasecmp(active->options.port, auth_buf->options.port)) {
							/* Port check failed */
							syslog(LOG_NOTICE, "PAP Login failure for %s on port %s, "
								"unauthorized port", auth_buf->options.user, 
								auth_buf->options.port);
							auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
							goto out;
						}
					}
					else if(active->options.dev_class[0] != '\0') {
						if(strcasecmp(active->options.dev_class, 
							auth_buf->options.dev_class)) {
							/* Class check failed */
							syslog(LOG_NOTICE, "PAP Login failure for %s on port %s, "
								"unauthorized device class", auth_buf->options.user, 
								auth_buf->options.port);
							auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
							goto out;
						}
					}

					/*
					 * Log user in
					 */
					syslog(LOG_INFO, "PAP Login successful for %s on port %s phone %s",
						auth_buf->options.user, auth_buf->options.port,
						auth_buf->options.phone);
					active->reserved1 = auth_buf->reserved1;
					active->reserved2 = auth_buf->reserved2;
					strcpy(active->options.site, auth_buf->options.site);
					active->options.SetCall(auth_buf->options.call);
					active->options.ClonePolFrom(auth_buf->options.pol);
					active->options.is_valid = 1;
					active->reserved1(active->reserved2, &active->options);
					goto out;
				}
			}

			/*
			 * CHAP
			 */
			else if(auth_buf->options.proto_id == 0xc223) {
				do_chap_auth(active, auth_buf);
				goto out;
			}
			/*
			 * Unknown authentication protocol
			 */
			else {
				syslog(LOG_NOTICE, "Login failure for %s on port %s, "
					"unsupported protocol (%#x)", auth_buf->options.user, 
					auth_buf->options.port, auth_buf->options.proto_id);
				auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
				goto out;
			}
		}

		/*
		 * Get the password from PAM
		 */
		else {
			syslog(LOG_NOTICE, "Login failure for %s on port %s, "
				"PAM unsupported", auth_buf->options.user, 
				auth_buf->options.port);
			auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
			goto out;
		}
	}

	/*
	 * Didn't find a match, reject
	 */
	syslog(LOG_NOTICE, "Configure request failed, no user[%s]/site[%s] found", auth_buf->options.user, auth_buf->options.site);
out_failed:
	auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);

out:
	if (cfg_file)
		fclose(cfg_file);
	if (new_pol)
		delete new_pol;
}

#define NR_IPBUF	8
#define SIZE_IPBUF	16
char ipbuf[NR_IPBUF][SIZE_IPBUF];
unsigned ipbuf_ctr;
char *iptostr(unsigned int ip)
{
	char *buf = ipbuf[ipbuf_ctr++];
	if (ipbuf_ctr >= NR_IPBUF)
		ipbuf_ctr = 0;
	memset(buf, '\0', SIZE_IPBUF);
	sprintf(buf, "%d.%d.%d.%d", 
		((ip & 0xff000000) >> 24),
		((ip & 0x00ff0000) >> 16),
		((ip & 0x0000ff00) >> 8),
		(ip & 0x000000ff));
	return buf;
}

#if 1
unsigned long strtoip(const char *str)
{
	unsigned long a, b, c, d;
	if (4 != sscanf(str, "%lu.%lu.%lu.%lu", &a, &b, &c, &d)) {
		fprintf(stderr, "invalid ip address '%s'.\n", str);
		return -1L;
	}
	return (a << 24 | b << 16 | c << 8 | d);
}
#else

unsigned int strtoip(const char *str)
{
	int b_count = 3;
	char *d;
	unsigned int a = 0;
	char *nstr;

	nstr = strdup(str);

	for(d = strtok(nstr, "."); d != NULL && b_count >= 0; d = strtok(NULL, "."))
		a |= (strtoul(d, NULL, 10) << (b_count-- * 8));

	free(nstr);
	return a;
}
#endif

int bstrtoip_sin(const char *str, struct sockaddr_in *sin)
{
	char *port_s = strchr((char *)str, ':');

	memset(sin, 0, sizeof(*sin));
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = htonl(strtoip(str));
	if (port_s && *++port_s)
		sin->sin_port = htons(atoi(port_s));
	return 0;
}

void print_usage()
{
	fprintf(stderr, "Usage:  %s [options]\n", cmdname);
	fprintf(stderr, "   -h, --help               display this info\n");
	fprintf(stderr, "       --help-debug         display the available debugging levels\n");
	fprintf(stderr, "   -f, --no-fork            don't fork a daemon, run in foreground\n");
	fprintf(stderr, "   -c, --config-file <s>    use <s> file instead of %s\n",DEFAULT_CFG_FILE);
	fprintf(stderr, "   -C, --control-socket <s> use <s> socket instead of %s\n", CONTROL_PATH);
	fprintf(stderr, "   -d, --debug <n>          set debug level to <n> (in dec, hex, or oct)\n");
	fprintf(stderr, "   -n, --system-name <s>    set system name to <s>\n");
	fprintf(stderr, "   -p, --disable-proxyarp   don't setup proxy arp for links\n");
	fprintf(stderr, "   -r, --disable-routing    disable routing\n");
	fprintf(stderr, "   -s, --scan-chan          scan for available channels automatically\n");
	fprintf(stderr, "   -a<ip>, --radius-acct=<ip> use <ip> as radius accounting server\n");
	fprintf(stderr, "   -u<ip>, --radius=<ip>    use <ip> as radius server\n");
	fprintf(stderr, "       --disable-dynamicip  don't use allocate IP nums dynamically for incoming\n");
	fprintf(stderr, "                              calls (default)\n");
	fprintf(stderr, "       --enable-routing     enable routing (default)\n");
	fprintf(stderr, "       --enable-proxyarp    do setup proxy arp for links (default)\n");
	fprintf(stderr, "       --enable-pfc         enable protocol field compression (default deny)\n");
	fprintf(stderr, "   -i, --enable-dynamicip   don't use allocate IP nums dynamically for incoming\n");
	fprintf(stderr, "                              calls (default)\n");
	fprintf(stderr, "       --broken-acfc        don't setup ACFC after LCP (enables operation with\n");
	fprintf(stderr, "                              some broken routers)\n");
	fprintf(stderr, "   -y, --dynamic-file <s>   use <s> instead of %s\n",DEFAULT_DYN_FILE);
	fprintf(stderr, "   -k, --disable-down-check disable checking of interface up/down state\n");
#ifdef USE_L2TP
	fprintf(stderr, "   -2, --enable-l2tp <file>   Load <file> as l2tp config (/etc/babylon/l2tp.conf).\n");
#endif
	fprintf(stderr, "       --want-mlcp\n");
	fprintf(stderr, "   -S  --restore-state      restore state from stdin\n");
	fprintf(stderr, "   See %s(8) for details.\n", cmdname);
	fprintf(stderr, "   See dynamic_ip.conf(5) for details on dynamic IP\n");
	exit(2);
}

void print_debuglevels() {
	fprintf(stderr,"Babylond debugging levels. OR items together to get appropriate information.\n"),
	fprintf(stderr,"Level		Description\n"),
	fprintf(stderr,"0x0000	Log Nothing\n");
	fprintf(stderr,"0x0001	Log all Protocol transactions\n");
	fprintf(stderr,"0x0002	Log all received packets\n");
	fprintf(stderr,"0x0004	Log all transmitted packets\n");
	fprintf(stderr,"0x0008	Log all state transitions\n");
	fprintf(stderr,"0x0010	Log all phase transitions\n");
	fprintf(stderr,"0x0020	Log and track allocs and frees\n");
	fprintf(stderr,"0x0040	Log function call flow\n");
	fprintf(stderr,"0x0080	Log function call statistics\n");
	fprintf(stderr,"0x0100	Log driver-daemon communcations\n");
	fprintf(stderr,"0x0200	Log list management functions\n");
	fprintf(stderr,"0x0400	Log call control activities\n");
	fprintf(stderr,"0x0800	Log configuration functions\n");
	fprintf(stderr,"\nNOTES:\n1) To log everything, use 0x0FFF\n");
	fprintf(stderr,"2) When making problem reports to Spellcaster Support, please use 0x0007\n");
	fprintf(stderr,"    and caption this information.\n");
	exit(3);
}

void do_chap_auth(CfgMessage_t *active, CfgMessage_t *auth_buf)
{
	MD5_CTX md5;
	unsigned char in[512];
	unsigned char *pin = in;

	if(auth_buf->options.challenge) {
		/*
		 * compute a CHAP response
		 */
		MD5Init(&md5);
		pin = in;
		memcpy(pin, &auth_buf->options.auth_info, 1);	// Ident
		syslog(LOG_DEBUG, "CHAP Ident = %#x", auth_buf->options.auth_info);
		memcpy(pin + 1, active->options.passwd, strlen(active->options.passwd));
		syslog(LOG_DEBUG, "CHAP Password = %s", active->options.passwd);
		pin += (1 + strlen(active->options.passwd));
		memcpy(pin, auth_buf->options.chap_rvalue, auth_buf->options.chap_rvalue_len);
		pin += auth_buf->options.chap_rvalue_len;
		/* syslog(LOG_DEBUG, "CHAP Value = %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", */
		MD5Update(&md5, in, (uint) (pin - &in[0]));
		MD5Final(&md5);

		memcpy(active->options.chap_rvalue, md5.digest, 16);
		active->options.chap_rvalue_len = 16;
		active->reserved1 = auth_buf->reserved1;
		active->reserved2 = auth_buf->reserved2;
		active->options.auth_info = auth_buf->options.auth_info;
		strncpy(active->options.site, auth_buf->options.site, SITE_NAME_LEN);
		strcpy(active->options.dev_class, auth_buf->options.dev_class);
		strcpy(active->options.port, auth_buf->options.port);
		active->options.SetCall(auth_buf->options.call);
		active->options.ClonePolFrom(auth_buf->options.pol);
		active->options.is_valid = 1;
		active->options.challenge = 1;
		active->options.proto_id = auth_buf->options.proto_id;
		active->reserved1(active->reserved2, &active->options);

		return;
	}
	else {
		/*
		 * Compute the expected digest
		 */
		MD5Init(&md5);
		pin = in;
		*pin = auth_buf->options.auth_info;	// Ident
		memcpy(pin + 1, active->options.passwd, 
			strlen(active->options.passwd));
		pin += (1 + strlen(active->options.passwd));
		memcpy(pin, auth_buf->options.chap_lvalue, auth_buf->options.chap_lvalue_len);
		pin += auth_buf->options.chap_lvalue_len;
		MD5Update(&md5, in, (uint)(pin - in));
		MD5Final(&md5);

		/*
		 * Compare with what we got
		 */
		if(auth_buf->options.chap_rvalue_len != 16 || memcmp(auth_buf->options.chap_rvalue, md5.digest, 16)) {
			syslog(LOG_NOTICE, "CHAP Challenge failed for %s on port %s phone %s, "
				"invalid response", auth_buf->options.user, 
				auth_buf->options.port, auth_buf->options.phone);
			auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
			return;
		}

		/* 
		 * Password authentication succeeded 
		 * check the class and port
		 */
		if(active->options.port[0] != '\0') {
			if(strcasecmp(active->options.port, auth_buf->options.port)) {
				/* Port check failed */
				syslog(LOG_NOTICE, "CHAP Challenge failed for %s on port %s, "
					"unauthorized port", auth_buf->options.user, 
					auth_buf->options.port);
				auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
				return;
			}
		}
		else if(active->options.dev_class[0] != '\0') {
			if(strcasecmp(active->options.dev_class, 
				auth_buf->options.dev_class)) {
				/* Class check failed */
				syslog(LOG_NOTICE, "CHAP Challenge failed for %s on port %s, "
					"unauthorized device class", auth_buf->options.user, 
					auth_buf->options.port);
				auth_buf->reserved1(auth_buf->reserved2, &auth_buf->options);
				return;
			}
		}

		/*
		 * Log user in
		 */
		syslog(LOG_INFO, "CHAP Challenge successful for %s on port %s phone %s",
			auth_buf->options.user, auth_buf->options.port,
			auth_buf->options.phone);
		active->reserved1 = auth_buf->reserved1;
		active->reserved2 = auth_buf->reserved2;
		active->options.auth_info = auth_buf->options.auth_info;
		strcpy(active->options.site, auth_buf->options.site);
		active->options.SetCall(auth_buf->options.call);
		active->options.ClonePolFrom(auth_buf->options.pol);
		active->options.is_valid = 1;
		active->reserved1(active->reserved2, &active->options);
		return;
	}
}