ipsec-332.tar.gz

[apple/ipsec.git] / ipsec-tools / racoon / remoteconf.c

/*	$NetBSD: remoteconf.c,v 1.9.4.1 2007/08/01 11:52:22 vanhu Exp $	*/

/* Id: remoteconf.c,v 1.38 2006/05/06 15:52:44 manubsd Exp */

/*
 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/queue.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>

#ifndef HAVE_NETINET6_IPSEC
#include <netinet/ipsec.h>
#else
#include <netinet6/ipsec.h>
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

#include "var.h"
#include "misc.h"
#include "vmbuf.h"
#include "plog.h"
#include "sockmisc.h"
#include "genlist.h"
#include "debug.h"

#include "isakmp_var.h"
#ifdef ENABLE_HYBRID
#include "isakmp_xauth.h"
#endif
#include "isakmp.h"
#include "ipsec_doi.h"
#include "oakley.h"
#include "remoteconf.h"
#include "localconf.h"
#include "grabmyaddr.h"
#include "policy.h"
#include "proposal.h"
#include "vendorid.h"
#include "gcmalloc.h"
#include "strnames.h"
#include "algorithm.h"
#include "nattraversal.h"
#include "isakmp_frag.h"
#include "genlist.h"
#include "vpn_control_var.h"

static TAILQ_HEAD(_rmtree, remoteconf) rmtree;


/*%%%*/
/*
 * search remote configuration.
 * don't use port number to search if its value is either IPSEC_PORT_ANY.
 * If matching anonymous entry, then new entry is copied from anonymous entry.
 * If no anonymous entry found, then return NULL.
 * OUT:	NULL:	NG
 *	Other:	remote configuration entry.
 */
struct remoteconf *
getrmconf_strict(remote, allow_anon)
	struct sockaddr_storage *remote;
	int allow_anon;
{
	struct remoteconf *p;
	struct remoteconf *p_withport_besteffort = NULL;
	struct remoteconf *p_with_prefix = NULL;
	struct remoteconf *p_with_prefix_besteffort = NULL;
    int                last_prefix = 0;
	struct remoteconf *anon = NULL;
    
	int withport;
	char buf[NI_MAXHOST + NI_MAXSERV + 10];
	char addr[NI_MAXHOST], port[NI_MAXSERV];

	withport = 0;

	/* 
	 * We never have ports set in our remote configurations, but when
	 * NAT-T is enabled, the kernel can have policies with ports and
	 * send us an acquire message for a destination that has a port set.
	 * If we do this port check here, we have to fallback to a best-effort result (without the port).
	 *
	 * In an ideal world, we would be able to have remote conf with
	 * port, and the port could be a wildcard. That test could be used.
	 */
	switch (remote->ss_family) {
	case AF_INET:
		if (((struct sockaddr_in *)remote)->sin_port != IPSEC_PORT_ANY)
			withport = 1;
		break;
#ifdef INET6
	case AF_INET6:
		if (((struct sockaddr_in6 *)remote)->sin6_port != IPSEC_PORT_ANY)
			withport = 1;
		break;
#endif
	case AF_UNSPEC:
		break;

	default:
		plog(ASL_LEVEL_ERR, 
			"invalid ip address family: %d\n", remote->ss_family);
		return NULL;
	}

	if (remote->ss_family == AF_UNSPEC)
		snprintf (buf, sizeof(buf), "%s", "anonymous");
	else {
		GETNAMEINFO((struct sockaddr *)remote, addr, port);
		snprintf(buf, sizeof(buf), "%s%s%s%s", addr,
			withport ? "[" : "",
			withport ? port : "",
			withport ? "]" : "");
	}

	TAILQ_FOREACH(p, &rmtree, chain) {
		if (remote->ss_family == AF_UNSPEC
		     && remote->ss_family == p->remote->ss_family) {
            plog(ASL_LEVEL_DEBUG, "configuration found for %s.\n", buf);
			return p;
        }
        if (p->remote_prefix == 0) {
            if ((!withport && cmpsaddrwop(remote, p->remote) == 0)
                || (withport && cmpsaddrstrict(remote, p->remote) == 0)) {
                    plog(ASL_LEVEL_DEBUG, "configuration found for %s.\n", buf);
                    return p;
                } else if (withport && cmpsaddrwop(remote, p->remote) == 0) {
                    // for withport: save the pointer for the best-effort search
                    p_withport_besteffort = p;
                }
        } else {
            if ((!withport && cmpsaddrwop_withprefix(remote, p->remote, p->remote_prefix) == 0)
                || (withport && cmpsaddrstrict_withprefix(remote, p->remote, p->remote_prefix) == 0)) {
                if (p->remote_prefix >= last_prefix) {
                    p_with_prefix = p;
                    last_prefix = p->remote_prefix;
                }
            } else if (withport && cmpsaddrwop_withprefix(remote, p->remote, p->remote_prefix) == 0) {
                if (p->remote_prefix >= last_prefix) {
                    p_with_prefix_besteffort = p;
                    last_prefix = p->remote_prefix;
                }
            }
        }

		/* save the pointer to the anonymous configuration */
		if (p->remote->ss_family == AF_UNSPEC)
			anon = p;
	}

	if (p_withport_besteffort) {
		plog(ASL_LEVEL_DEBUG, "configuration found for %s.\n", buf);
		return p_withport_besteffort;
	}
    if (p_with_prefix) {
        plog(ASL_LEVEL_DEBUG, "configuration found for %s.\n", buf);
        return p_with_prefix;
    }
    if (p_with_prefix_besteffort) {
        plog(ASL_LEVEL_DEBUG, "configuration found for %s.\n", buf);
        return p_with_prefix_besteffort;
    }
	if (allow_anon && anon != NULL) {
		plog(ASL_LEVEL_DEBUG, 
			"anonymous configuration selected for %s.\n", buf);
		return anon;
	}

	plog(ASL_LEVEL_DEBUG, 
		"no remote configuration found.\n");

	return NULL;
}

int
no_remote_configs(ignore_anonymous)
	int ignore_anonymous;
{
	
	struct remoteconf *p;
#if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
	static const char default_idv[] = "macuser@localhost";
	static const int default_idv_len = sizeof(default_idv) - 1;
#endif // !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)

	TAILQ_FOREACH(p, &rmtree, chain) {
		if (ignore_anonymous) {
			if (p->remote->ss_family == AF_UNSPEC)	/* anonymous */
				continue;
		}
#if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
		// ignore the default btmm ipv6 config thats always present in racoon.conf
		if (p->remote->ss_family == AF_INET6 &&
			p->idvtype == IDTYPE_USERFQDN &&
			p->idv != NULL &&
			p->idv->l == default_idv_len &&
			strncmp(p->idv->v, default_idv, p->idv->l) == 0) {
			continue;
		}
#endif // !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
		return 0;
	}
	return 1;
}

struct remoteconf *
getrmconf(remote)
	struct sockaddr_storage *remote;
{
	struct remoteconf *rmconf = getrmconf_strict(remote, 1);
	if (rmconf != NULL) {
		return rmconf;
	}
	if (remote->ss_family == AF_INET6) {
		struct sockaddr_in v4dst;
		v4dst.sin_family = AF_INET;
		v4dst.sin_len = sizeof(struct sockaddr_in);
		v4dst.sin_port = 0;

		nw_nat64_prefix_t nat64_prefix;
		if (vpncontrol_set_nat64_prefix(&nat64_prefix)) {
			nw_nat64_extract_v4(&nat64_prefix, &((struct sockaddr_in6 *)remote)->sin6_addr, &v4dst.sin_addr);

			rmconf = getrmconf(ALIGNED_CAST(struct sockaddr_storage *)&v4dst);
			if (rmconf != NULL) {
				return rmconf;
			}
		}
	}

	return NULL;
}

struct remoteconf *
create_rmconf()
{
	struct remoteconf *new;

	new = racoon_calloc(1, sizeof(*new));
	if (new == NULL)
		return NULL;

    new->refcount = 1;
    new->in_list = 0;
	new->proposal = NULL;

	/* set default */
	new->doitype = IPSEC_DOI;
	new->sittype = IPSECDOI_SIT_IDENTITY_ONLY;
    new->ike_version = ISAKMP_VERSION_NUMBER_IKEV1;
	new->idvtype = IDTYPE_UNDEFINED;
	new->idvl_p = genlist_init();
	new->nonce_size = DEFAULT_NONCE_SIZE;
	new->passive = FALSE;
	new->ike_frag = ISAKMP_FRAG_ON;
	new->esp_frag = IP_MAXPACKET;
	new->ini_contact = TRUE;
	new->mode_cfg = FALSE;
	new->pcheck_level = PROP_CHECK_STRICT;
	new->verify_identifier = FALSE;
	new->verify_cert = TRUE;
	new->getcert_method = ISAKMP_GETCERT_PAYLOAD;
	new->cacerttype = ISAKMP_CERT_X509SIGN;
	new->certtype = ISAKMP_CERT_NONE;
	new->send_cert = TRUE;
	new->send_cr = TRUE;
	new->support_proxy = FALSE;
	new->gen_policy = FALSE;
	new->retry_counter = lcconf->retry_counter;
	new->retry_interval = lcconf->retry_interval;
	new->nat_traversal = NATT_ON;
	new->natt_multiple_user = FALSE;
	new->natt_keepalive = TRUE;
	new->idv = NULL;
	new->key = NULL;

	new->dpd = TRUE; /* Enable DPD support by default */
	new->dpd_interval = 0; /* Disable DPD checks by default */
	new->dpd_retry = 5;
	new->dpd_maxfails = 5;
    new->dpd_algo = DPD_ALGO_INBOUND_DETECT;
    new->idle_timeout = 0;

	new->weak_phase1_check = 0;

#ifdef ENABLE_HYBRID
	new->xauth = NULL;
#endif
	new->initiate_ph1rekey = TRUE;
	return new;
}

struct remoteconf *
copyrmconf(struct sockaddr_storage *remote)
{
	struct remoteconf *new, *old;

	old = getrmconf_strict (remote, 0);
	if (old == NULL) {
		plog (ASL_LEVEL_ERR, 
		      "Remote configuration for '%s' not found!\n",
		      saddr2str((struct sockaddr *)remote));
		return NULL;
	}

	new = duprmconf (old);

	return new;
}

void *
dupidvl(void *entry, void *arg)
{
	struct idspec *id;
	struct idspec *old = (struct idspec *) entry;
	id = newidspec();
	if (!id) return (void *) -1;

	if (set_identifier(&id->id, old->idtype, old->id) != 0) {
		racoon_free(id);
		return (void *) -1;
	}

	id->idtype = old->idtype;

	genlist_append(arg, id);
	return NULL;
}

struct remoteconf *
duprmconf (struct remoteconf *rmconf)
{
    struct remoteconf *new;

    new = racoon_calloc(1, sizeof(*new));
    if (new == NULL)
        return NULL;
    memcpy (new, rmconf, sizeof (*new));
    // FIXME: We should duplicate remote, proposal, etc.
    // This is now handled in the cfparse.y
    // new->proposal = ...;

    // zero-out pointers
    new->remote = NULL;
    new->forced_local = NULL;
    new->keychainCertRef = NULL;	/* peristant keychain ref for cert */
    new->shared_secret = NULL;	/* shared secret */
    new->open_dir_auth_group = NULL;	/* group to be used to authorize user */
    new->proposal = NULL;
    new->in_list = 0;
    new->refcount = 1;
    new->idv = NULL;
    new->key = NULL;
#ifdef ENABLE_HYBRID
    new->xauth = NULL;
#endif
    
	/* duplicate dynamic structures */
	if (new->etypes)
		new->etypes=dupetypes(new->etypes);
	new->idvl_p = genlist_init();
	genlist_foreach(rmconf->idvl_p, dupidvl, new->idvl_p);

	return new;
}

static void
idspec_free(void *data)
{
	vfree (((struct idspec *)data)->id);
	free (data);
}

static void
proposalspec_free(struct proposalspec *head)
{

	struct proposalspec* next_propsp = head;
		
	while (next_propsp) {
		struct proposalspec* curr_propsp;
		struct secprotospec* next_protosp;
		
		curr_propsp = next_propsp;
		next_propsp = next_propsp->next;
		next_protosp = curr_propsp->spspec;
		while (next_protosp) {
			struct secprotospec* curr_protosp;
			
			curr_protosp = next_protosp;
			next_protosp = next_protosp->next;
			
			if (curr_protosp->gssid)
				free(curr_protosp->gssid);
			if (curr_protosp->remote)
				free(curr_protosp->remote);
			racoon_free(curr_protosp);
		}
		racoon_free(curr_propsp);
	}
}

void
delrmconf(struct remoteconf *rmconf)
{
	if (rmconf->remote)
		racoon_free(rmconf->remote);
	if (rmconf->forced_local)
		racoon_free(rmconf->forced_local);
#ifdef ENABLE_HYBRID
	if (rmconf->xauth)
		xauth_rmconf_delete(&rmconf->xauth);
#endif
	if (rmconf->etypes) {
		deletypes(rmconf->etypes);
		rmconf->etypes=NULL;
	}
	if (rmconf->idv)
		vfree(rmconf->idv);
	if (rmconf->idvl_p)
		genlist_free(rmconf->idvl_p, idspec_free);
	if (rmconf->dhgrp)
		oakley_dhgrp_free(rmconf->dhgrp);
	if (rmconf->proposal)
		delisakmpsa(rmconf->proposal);
	if (rmconf->prhead)
		proposalspec_free(rmconf->prhead);
	if (rmconf->shared_secret)
		vfree(rmconf->shared_secret);
	if (rmconf->keychainCertRef)
		vfree(rmconf->keychainCertRef);
	if (rmconf->open_dir_auth_group)
		vfree(rmconf->open_dir_auth_group);

	racoon_free(rmconf);
}

void
delisakmpsa(struct isakmpsa *sa)
{
	if (sa->dhgrp)
		oakley_dhgrp_free(sa->dhgrp);
	if (sa->next)
		delisakmpsa(sa->next);
	racoon_free(sa);
}

struct etypes *
dupetypes(struct etypes *orig)
{
	struct etypes *new;

	if (!orig) 
		return NULL;

	new = racoon_malloc(sizeof(struct etypes));
	if (new == NULL) 
		return NULL;

	new->type = orig->type;
	new->next = NULL;

	if (orig->next)
		new->next=dupetypes(orig->next);

	return new;
}

void
deletypes(struct etypes *e)
{
	if (e->next)
		deletypes(e->next);
	racoon_free(e);
}

/*
 * insert into head of list.
 */
void
insrmconf(struct remoteconf *new)
{
	TAILQ_INSERT_HEAD(&rmtree, new, chain);
    new->in_list = 1;
}

void
remrmconf(struct remoteconf *rmconf)
{
	if (rmconf->in_list)
        TAILQ_REMOVE(&rmtree, rmconf, chain);
    rmconf->in_list = 0;
}

void
retain_rmconf(struct remoteconf *rmconf)
{
    (rmconf->refcount)++;
}

void
release_rmconf(struct remoteconf *rmconf)
{
    if (--(rmconf->refcount) <= 0) {
        remrmconf(rmconf);
        delrmconf(rmconf);
    }
}

void
flushrmconf()
{
	struct remoteconf *p, *next;

	for (p = TAILQ_FIRST(&rmtree); p; p = next) {
		next = TAILQ_NEXT(p, chain);
		remrmconf(p);
        if (--(p->refcount) <= 0)
            delrmconf(p);
	}
}

void
initrmconf()
{
	TAILQ_INIT(&rmtree);
}

/* check exchange type to be acceptable */
struct etypes *
check_etypeok(struct remoteconf *rmconf, u_int8_t etype)
{
	struct etypes *e;

	for (e = rmconf->etypes; e != NULL; e = e->next) {
		if (e->type == etype)
			break;
	}

	return e;
}

/*%%%*/
struct isakmpsa *
newisakmpsa()
{
	struct isakmpsa *new;

	new = racoon_calloc(1, sizeof(*new));
	if (new == NULL)
		return NULL;

	/*
	 * Just for sanity, make sure this is initialized.  This is
	 * filled in for real when the ISAKMP proposal is configured.
	 */
	new->vendorid = VENDORID_UNKNOWN;

	new->next = NULL;
	new->rmconf = NULL;

	return new;
}

/*
 * insert into tail of list.
 */
void
insisakmpsa(struct isakmpsa *new, struct remoteconf *rmconf)
{
	struct isakmpsa *p;

	new->rmconf = rmconf;

	if (rmconf->proposal == NULL) {
		rmconf->proposal = new;
		return;
	}

	for (p = rmconf->proposal; p->next != NULL; p = p->next)
		;
	p->next = new;

	return;
}

struct remoteconf *
foreachrmconf(rmconf_func_t rmconf_func, void *data)
{
	struct remoteconf *p, *ret = NULL;

	TAILQ_FOREACH_REVERSE(p, &rmtree, _rmtree, chain) {
		ret = (*rmconf_func)(p, data);
		if (ret)
			break;
	}

	return ret;
}

static void *
dump_peers_identifiers (void *entry, void *arg)
{
	struct idspec *id = (struct idspec*) entry;
	char buf[1024], *pbuf;
	pbuf = buf;
	pbuf += snprintf (pbuf, sizeof(buf) - (pbuf - buf), "\tpeers_identifier %s",
			 s_idtype (id->idtype));
	if (id->id)
		pbuf += snprintf (pbuf, sizeof(buf) - (pbuf - buf), " \"%s\"", id->id->v);
	plog(ASL_LEVEL_NOTICE, "%s;\n", buf);
	return NULL;
}

static struct remoteconf *
dump_rmconf_single (struct remoteconf *p, void *data)
{
	struct etypes *etype = p->etypes;
	struct isakmpsa *prop = p->proposal;
	char buf[1024], *pbuf;

	pbuf = buf;
    if (p->remote_prefix)
        pbuf += snprintf(pbuf, sizeof(buf) - (pbuf - buf), "remote %s", 
                         saddr2str_with_prefix((struct sockaddr *)p->remote, p->remote_prefix));
    else
        pbuf += snprintf(pbuf, sizeof(buf) - (pbuf - buf), "remote %s", saddr2str((struct sockaddr *)p->remote));
	if (p->inherited_from)
		pbuf += snprintf(pbuf, sizeof(buf) - (pbuf - buf), " inherit %s",
				saddr2str((struct sockaddr *)p->inherited_from->remote));
	plog(ASL_LEVEL_NOTICE, "%s {\n", buf);
	pbuf = buf;
	pbuf += snprintf(pbuf, sizeof(buf) - (pbuf - buf), "\texchange_type ");
	while (etype) {
		pbuf += snprintf (pbuf, sizeof(buf) - (pbuf - buf), "%s%s", s_etype(etype->type),
				 etype->next != NULL ? ", " : ";\n");
		etype = etype->next;
	}
	plog(ASL_LEVEL_NOTICE, "%s", buf);
	plog(ASL_LEVEL_NOTICE, "\tdoi %s;\n", s_doi(p->doitype));
	pbuf = buf;
	pbuf += snprintf(pbuf, sizeof(buf) - (pbuf - buf), "\tmy_identifier %s", s_idtype (p->idvtype));
	if (p->idvtype == IDTYPE_ASN1DN) {
		plog(ASL_LEVEL_NOTICE, "%s;\n", buf);
		switch (p->getcert_method) {
		  case 0:
		  	break;
		  case ISAKMP_GETCERT_PAYLOAD:
			plog(ASL_LEVEL_NOTICE, "\t/* peers certificate from payload */\n");
			break;
		  default:
			plog(ASL_LEVEL_NOTICE, "\tpeers_certfile *UNKNOWN* (%d)\n", p->getcert_method);
		}
	}
	else {
		if (p->idv)
			pbuf += snprintf (pbuf, sizeof(buf) - (pbuf - buf), " \"%s\"", p->idv->v);
		plog(ASL_LEVEL_NOTICE, "%s;\n", buf);
		genlist_foreach(p->idvl_p, &dump_peers_identifiers, NULL);
	}

	plog(ASL_LEVEL_NOTICE, "\tsend_cert %s;\n",
		s_switch (p->send_cert));
	plog(ASL_LEVEL_NOTICE, "\tsend_cr %s;\n",
		s_switch (p->send_cr));
	plog(ASL_LEVEL_NOTICE, "\tverify_cert %s;\n",
		s_switch (p->verify_cert));
	plog(ASL_LEVEL_NOTICE, "\tverify_identifier %s;\n",
		s_switch (p->verify_identifier));
	plog(ASL_LEVEL_NOTICE, "\tnat_traversal %s;\n",
		p->nat_traversal == NATT_FORCE ?
			"force" : s_switch (p->nat_traversal));
	plog(ASL_LEVEL_NOTICE, "\tnatt_multiple_user %s;\n",
		s_switch (p->natt_multiple_user));
	plog(ASL_LEVEL_NOTICE, "\tnonce_size %d;\n",
		p->nonce_size);
	plog(ASL_LEVEL_NOTICE, "\tpassive %s;\n",
		s_switch (p->passive));
	plog(ASL_LEVEL_NOTICE, "\tike_frag %s;\n",
		p->ike_frag == ISAKMP_FRAG_FORCE ?
			"force" : s_switch (p->ike_frag));
	plog(ASL_LEVEL_NOTICE, "\tesp_frag %d;\n", p->esp_frag);
	plog(ASL_LEVEL_NOTICE, "\tinitial_contact %s;\n",
		s_switch (p->ini_contact));
	plog(ASL_LEVEL_NOTICE, "\tgenerate_policy %s;\n",
		s_switch (p->gen_policy));
	plog(ASL_LEVEL_NOTICE, "\tsupport_proxy %s;\n",
		s_switch (p->support_proxy));

	while (prop) {
		plog(ASL_LEVEL_NOTICE, "\n");
		plog(ASL_LEVEL_NOTICE, 
			"\t/* prop_no=%d, trns_no=%d, rmconf=%s */\n",
			prop->prop_no, prop->trns_no,
			saddr2str((struct sockaddr *)prop->rmconf->remote));
		plog(ASL_LEVEL_NOTICE, "\tproposal {\n");
		plog(ASL_LEVEL_NOTICE, "\t\tlifetime time %lu sec;\n",
			(long)prop->lifetime);
		plog(ASL_LEVEL_NOTICE, "\t\tlifetime bytes %zd;\n",
			prop->lifebyte);
		plog(ASL_LEVEL_NOTICE, "\t\tdh_group %s;\n",
			alg_oakley_dhdef_name(prop->dh_group));
		plog(ASL_LEVEL_NOTICE, "\t\tencryption_algorithm %s;\n", 
			alg_oakley_encdef_name(prop->enctype));
		plog(ASL_LEVEL_NOTICE, "\t\thash_algorithm %s;\n",
			alg_oakley_hashdef_name(prop->hashtype));
		plog(ASL_LEVEL_NOTICE, "\t\tprf_algorithm %s;\n",
			 alg_oakley_hashdef_name(prop->prf));
		plog(ASL_LEVEL_NOTICE, "\t\tauthentication_method %s;\n",
			alg_oakley_authdef_name(prop->authmethod));
		plog(ASL_LEVEL_NOTICE, "\t}\n");
		prop = prop->next;
	}
	plog(ASL_LEVEL_NOTICE, "}\n");
	plog(ASL_LEVEL_NOTICE, "\n");

	return NULL;
}

void
dumprmconf()
{
	foreachrmconf (dump_rmconf_single, NULL);
}

struct idspec *
newidspec()
{
	struct idspec *new;

	new = racoon_calloc(1, sizeof(*new));
	if (new == NULL)
		return NULL;
	new->idtype = IDTYPE_ADDRESS;

	return new;
}


struct isakmpsa *
dupisakmpsa(struct isakmpsa *sa)
{
	struct isakmpsa *res = NULL;

	if (sa == NULL)
		return NULL;

	res = newisakmpsa();
	if(res == NULL)
		return NULL;

	*res = *sa;
	res->next=NULL;

	if (sa->dhgrp != NULL)
		oakley_setdhgroup(sa->dh_group, &(res->dhgrp));

	return res;

}