 @@ -1,2185 +1,2184 @@
-/*	$NetBSD: ipsec_doi.c,v 1.48 2012/11/29 15:31:25 vanhu Exp $	*/
+/*	$NetBSD: ipsec_doi.c,v 1.49 2013/06/18 05:39:50 tteras Exp $	*/
 /* Id: ipsec_doi.c,v 1.55 2006/08/17 09:20:41 vanhu 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 <netinet/in.h>
 #include PATH_IPSEC_H
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <netdb.h>
 #if TIME_WITH_SYS_TIME
 # include <sys/time.h>
 # include <time.h>
 #else
 # if HAVE_SYS_TIME_H
 #  include <sys/time.h>
 # else
 #  include <time.h>
 # endif
 #endif
 #include "var.h"
 #include "vmbuf.h"
 #include "misc.h"
 #include "plog.h"
 #include "debug.h"
 #include "cfparse_proto.h"
 #include "isakmp_var.h"
 #include "isakmp.h"
 #include "ipsec_doi.h"
 #include "oakley.h"
 #include "remoteconf.h"
 #include "localconf.h"
 #include "sockmisc.h"
 #include "handler.h"
 #include "policy.h"
 #include "algorithm.h"
 #include "sainfo.h"
 #include "proposal.h"
 #include "crypto_openssl.h"
 #include "strnames.h"
 #include "gcmalloc.h"
 #ifdef ENABLE_NATT
 #include "nattraversal.h"
 #endif
 #ifdef HAVE_GSSAPI
 #include <iconv.h>
 #include "gssapi.h"
 #ifdef HAVE_ICONV_2ND_CONST
 #define __iconv_const const
 #else
 #define __iconv_const
 #endif
 #endif
 static vchar_t *get_ph1approval __P((struct ph1handle *, u_int32_t, u_int32_t,
 				     struct prop_pair **));
 static int get_ph1approvalx __P((struct remoteconf *, void *));
 static int t2isakmpsa __P((struct isakmp_pl_t *, struct isakmpsa *, u_int32_t));
 static int cmp_aproppair_i __P((struct prop_pair *, struct prop_pair *));
 static struct prop_pair *get_ph2approval __P((struct ph2handle *,
 	struct prop_pair **));
 static struct prop_pair *get_ph2approvalx __P((struct ph2handle *,
 	struct prop_pair *));
 static void free_proppair0 __P((struct prop_pair *));
 static struct prop_pair ** get_proppair_and_doi_sit __P((vchar_t *, int,
 							 u_int32_t *, u_int32_t *));
 static int get_transform
 	__P((struct isakmp_pl_p *, struct prop_pair **, int *));
 static u_int32_t ipsecdoi_set_ld __P((vchar_t *));
 static int check_doi __P((u_int32_t));
 static int check_situation __P((u_int32_t));
 static int check_prot_main __P((int));
 static int check_prot_quick __P((int));
 static int (*check_protocol[]) __P((int)) = {
 	check_prot_main,	/* IPSECDOI_TYPE_PH1 */
 	check_prot_quick,	/* IPSECDOI_TYPE_PH2 */
 };
 static int check_spi_size __P((int, int));
 static int check_trns_isakmp __P((int));
 static int check_trns_ah __P((int));
 static int check_trns_esp __P((int));
 static int check_trns_ipcomp __P((int));
 static int (*check_transform[]) __P((int)) = {
 ,
 	check_trns_isakmp,	/* IPSECDOI_PROTO_ISAKMP */
 	check_trns_ah,		/* IPSECDOI_PROTO_IPSEC_AH */
 	check_trns_esp,		/* IPSECDOI_PROTO_IPSEC_ESP */
 	check_trns_ipcomp,	/* IPSECDOI_PROTO_IPCOMP */
 };
 static int check_attr_isakmp __P((struct isakmp_pl_t *));
 static int check_attr_ah __P((struct isakmp_pl_t *));
 static int check_attr_esp __P((struct isakmp_pl_t *));
 static int check_attr_ipsec __P((int, struct isakmp_pl_t *));
 static int check_attr_ipcomp __P((struct isakmp_pl_t *));
 static int (*check_attributes[]) __P((struct isakmp_pl_t *)) = {
 ,
 	check_attr_isakmp,	/* IPSECDOI_PROTO_ISAKMP */
 	check_attr_ah,		/* IPSECDOI_PROTO_IPSEC_AH */
 	check_attr_esp,		/* IPSECDOI_PROTO_IPSEC_ESP */
 	check_attr_ipcomp,	/* IPSECDOI_PROTO_IPCOMP */
 };
 static int setph1prop __P((struct isakmpsa *, caddr_t));
 static int setph1trns __P((struct isakmpsa *, caddr_t));
 static int setph1attr __P((struct isakmpsa *, caddr_t));
 static vchar_t *setph2proposal0 __P((const struct ph2handle *,
 	const struct saprop *, const struct saproto *));
 struct ph1approvalx_ctx {
 	struct prop_pair *p;
 	struct isakmpsa *sa;
 };
 /*%%%*/
 /*
  * check phase 1 SA payload.
  * make new SA payload to be replyed not including general header.
  * the pointer to one of isakmpsa in proposal is set into iph1->approval.
  * OUT:
  *	positive: the pointer to new buffer of SA payload.
  *		  network byte order.
  *	NULL	: error occurd.
  */
 int
 ipsecdoi_checkph1proposal(sa, iph1)
 	vchar_t *sa;
 	struct ph1handle *iph1;
+{
 	vchar_t *newsa;		/* new SA payload approved. */
 	struct prop_pair **pair;
 	u_int32_t doitype, sittype;
 	/* get proposal pair */
 	pair = get_proppair_and_doi_sit(sa, IPSECDOI_TYPE_PH1,
 					&doitype, &sittype);
 	if (pair == NULL)
 		return -1;
 	/* check and get one SA for use */
 	newsa = get_ph1approval(iph1, doitype, sittype, pair);
 	free_proppair(pair);
 	if (newsa == NULL)
 		return -1;
 	iph1->sa_ret = newsa;
 	return 0;
+}
 static void
 print_ph1proposal(pair, s)
 	struct prop_pair *pair;
 	struct isakmpsa *s;
+{
 	struct isakmp_pl_p *prop = pair->prop;
 	struct isakmp_pl_t *trns = pair->trns;
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "prop#=%d, prot-id=%s, spi-size=%d, #trns=%d\n",
 	     prop->p_no, s_ipsecdoi_proto(prop->proto_id),
 	     prop->spi_size, prop->num_t);
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "trns#=%d, trns-id=%s\n",
 	     trns->t_no, s_ipsecdoi_trns(prop->proto_id, trns->t_id));
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "  lifetime = %ld\n", (long) s->lifetime);
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "  lifebyte = %zu\n", s->lifebyte);
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "  enctype = %s\n",
 	     s_oakley_attr_v(OAKLEY_ATTR_ENC_ALG, s->enctype));
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "  encklen = %d\n", s->encklen);
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "  hashtype = %s\n",
 	     s_oakley_attr_v(OAKLEY_ATTR_HASH_ALG, s->hashtype));
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "  authmethod = %s\n",
 	     s_oakley_attr_v(OAKLEY_ATTR_AUTH_METHOD, s->authmethod));
 	plog(LLV_DEBUG, LOCATION, NULL,
 	     "  dh_group = %s\n",
 	     s_oakley_attr_v(OAKLEY_ATTR_GRP_DESC, s->dh_group));
+}
 /*
  * acceptable check for remote configuration.
  * return a new SA payload to be reply to peer.
  */
 static vchar_t *
 get_ph1approval(iph1, doitype, sittype, pair)
 	struct ph1handle *iph1;
 	u_int32_t doitype, sittype;
 	struct prop_pair **pair;
+{
 	vchar_t *newsa;
 	struct ph1approvalx_ctx ctx;
 	struct prop_pair *s, *p;
 	struct rmconfselector rmsel;
 	struct isakmpsa *sa;
 	int i;
 	memset(&rmsel, 0, sizeof(rmsel));
 	rmsel.remote = iph1->remote;
 	if (iph1->approval) {
 		delisakmpsa(iph1->approval);
 		iph1->approval = NULL;
+	}
 	for (i = 0; i < MAXPROPPAIRLEN; i++) {
 		if (pair[i] == NULL)
 			continue;
 		for (s = pair[i]; s; s = s->next) {
 			/* compare proposal and select one */
 			for (p = s; p; p = p->tnext) {
 				struct isakmp_pl_p *prop = p->prop;
 				sa = newisakmpsa();
 				ctx.p = p;
 				ctx.sa = sa;
 				if (t2isakmpsa(p->trns, sa,
 					       iph1->vendorid_mask) < 0)
 					continue;
 				print_ph1proposal(p, sa);
 				if (iph1->rmconf != NULL) {
 					if (get_ph1approvalx(iph1->rmconf, &ctx))
 						goto found;
 				} else {
 					if (enumrmconf(&rmsel, get_ph1approvalx, &ctx))
 						goto found;
+				}
 				delisakmpsa(sa);
+			}
+		}
+	}
 	plog(LLV_ERROR, LOCATION, NULL, "no suitable proposal found.\n");
 	return NULL;
 found:
 	sa = ctx.sa;
 	plog(LLV_DEBUG, LOCATION, NULL, "an acceptable proposal found.\n");
 	/* check DH group settings */
 	if (sa->dhgrp) {
 		if (sa->dhgrp->prime && sa->dhgrp->gen1) {
 			/* it's ok */
 			goto saok;
+		}
 		plog(LLV_WARNING, LOCATION, NULL,
 			"invalid DH parameter found, use default.\n");
 		oakley_dhgrp_free(sa->dhgrp);
 		sa->dhgrp=NULL;
+	}
 	if (oakley_setdhgroup(sa->dh_group, &sa->dhgrp) == -1) {
 		sa->dhgrp = NULL;
 		delisakmpsa(sa);
 		return NULL;
+	}
 saok:
 #ifdef HAVE_GSSAPI
 	if (sa->gssid != NULL)
 		plog(LLV_DEBUG, LOCATION, NULL, "gss id in new sa '%.*s'\n",
 		    (int)sa->gssid->l, sa->gssid->v);
 	if (iph1->side == INITIATOR) {
 		if (iph1->rmconf->proposal->gssid != NULL)
 			iph1->gi_i = vdup(iph1->rmconf->proposal->gssid);
 		if (sa->gssid != NULL)
 			iph1->gi_r = vdup(sa->gssid);
 	} else {
 		if (sa->gssid != NULL) {
 			iph1->gi_r = vdup(sa->gssid);
 			iph1->gi_i = gssapi_get_id(iph1);
+		}
+	}
 	if (iph1->gi_i != NULL)
 		plog(LLV_DEBUG, LOCATION, NULL, "GIi is %.*s\n",
 		    (int)iph1->gi_i->l, iph1->gi_i->v);
 	if (iph1->gi_r != NULL)
 		plog(LLV_DEBUG, LOCATION, NULL, "GIr is %.*s\n",
 		    (int)iph1->gi_r->l, iph1->gi_r->v);
 #endif
 	plog(LLV_DEBUG, LOCATION, NULL, "agreed on %s auth.\n",
 	     s_oakley_attr_method(sa->authmethod));
 	newsa = get_sabyproppair(doitype, sittype, p);
 	if (newsa == NULL)
 		delisakmpsa(sa);
 	else
 		iph1->approval = sa;
 	return newsa;
+}
 /*
  * compare peer's single proposal and all of my proposal.
  * and select one if suiatable.
  */
 static int
 get_ph1approvalx(rmconf, ctx)
 	struct remoteconf *rmconf;
 	void *ctx;
+{
 	struct ph1approvalx_ctx *pctx = (struct ph1approvalx_ctx *) ctx;
 	struct isakmpsa *sa;
 	/* do the hard work */
 	sa = checkisakmpsa(rmconf->pcheck_level, pctx->sa, rmconf->proposal);
 	if (sa == NULL)
 		return 0;
 	/* duplicate and modify the found SA to match proposal */
 	sa = dupisakmpsa(sa);
 	switch (rmconf->pcheck_level) {
 	case PROP_CHECK_OBEY:
 		sa->lifetime = pctx->sa->lifetime;
 		sa->lifebyte = pctx->sa->lifebyte;
 		sa->encklen = pctx->sa->encklen;
 		break;
 	case PROP_CHECK_CLAIM:
 	case PROP_CHECK_STRICT:
 		if (pctx->sa->lifetime < sa->lifetime)
 			sa->lifetime = pctx->sa->lifetime;
 		if (pctx->sa->lifebyte < sa->lifebyte)
 			sa->lifebyte = pctx->sa->lifebyte;
 		if (pctx->sa->encklen > sa->encklen)
 			sa->encklen = pctx->sa->encklen;
 		break;
 	default:
 		break;
+	}
 	/* replace the proposal with our approval sa */
 	delisakmpsa(pctx->sa);
 	pctx->sa = sa;
 	return 1;
+}
 /*
  * get ISAKMP data attributes
  */
 static int
 t2isakmpsa(trns, sa, vendorid_mask)
 	struct isakmp_pl_t *trns;
 	struct isakmpsa *sa;
 	u_int32_t vendorid_mask;
+{
 	struct isakmp_data *d, *prev;
 	int flag, type;
 	int error = -1;
 	int life_t;
 	int keylen = 0;
 	vchar_t *val = NULL;
 	int len, tlen;
 	u_char *p;
 	tlen = ntohs(trns->h.len) - sizeof(*trns);
 	prev = (struct isakmp_data *)NULL;
 	d = (struct isakmp_data *)(trns + 1);
 	/* default */
 	life_t = OAKLEY_ATTR_SA_LD_TYPE_DEFAULT;
 	sa->lifetime = OAKLEY_ATTR_SA_LD_SEC_DEFAULT;
 	sa->lifebyte = 0;
 	sa->dhgrp = racoon_calloc(1, sizeof(struct dhgroup));
 	if (!sa->dhgrp)
 		goto err;
 	while (tlen > 0) {
 		type = ntohs(d->type) & ~ISAKMP_GEN_MASK;
 		flag = ntohs(d->type) & ISAKMP_GEN_MASK;
 		plog(LLV_DEBUG, LOCATION, NULL,
 			"type=%s, flag=0x%04x, lorv=%s\n",
 			s_oakley_attr(type), flag,
 			s_oakley_attr_v(type, ntohs(d->lorv)));
 		/* get variable-sized item */
 		switch (type) {
 		case OAKLEY_ATTR_GRP_PI:
 		case OAKLEY_ATTR_GRP_GEN_ONE:
 		case OAKLEY_ATTR_GRP_GEN_TWO:
 		case OAKLEY_ATTR_GRP_CURVE_A:
 		case OAKLEY_ATTR_GRP_CURVE_B:
 		case OAKLEY_ATTR_SA_LD:
 		case OAKLEY_ATTR_GRP_ORDER:
 			if (flag) {	/*TV*/
 				len = 2;
 				p = (u_char *)&d->lorv;
 			} else {	/*TLV*/
 				len = ntohs(d->lorv);
 				p = (u_char *)(d + 1);
+			}
 			val = vmalloc(len);
 			if (!val)
 				return -1;
 			memcpy(val->v, p, len);
 			break;
 		default:
 			break;
+		}
 		switch (type) {
 		case OAKLEY_ATTR_ENC_ALG:
 			sa->enctype = (u_int16_t)ntohs(d->lorv);
 			break;
 		case OAKLEY_ATTR_HASH_ALG:
 			sa->hashtype = (u_int16_t)ntohs(d->lorv);
 			break;
 		case OAKLEY_ATTR_AUTH_METHOD:
 			sa->authmethod = ntohs(d->lorv);
 #ifdef HAVE_GSSAPI
 			if (sa->authmethod == OAKLEY_ATTR_AUTH_METHOD_GSSAPI_KRB_REAL &&
 			    (vendorid_mask & VENDORID_GSSAPI_MASK))
 				sa->authmethod = OAKLEY_ATTR_AUTH_METHOD_GSSAPI_KRB;
 #endif
 			break;
 		case OAKLEY_ATTR_GRP_DESC:
 			sa->dh_group = (u_int16_t)ntohs(d->lorv);
 			break;
 		case OAKLEY_ATTR_GRP_TYPE:
+		{
 			int type = (int)ntohs(d->lorv);
 			if (type == OAKLEY_ATTR_GRP_TYPE_MODP)
 				sa->dhgrp->type = type;
 			else
 				return -1;
 			break;
+		}
 		case OAKLEY_ATTR_GRP_PI:
 			sa->dhgrp->prime = val;
 			break;
 		case OAKLEY_ATTR_GRP_GEN_ONE:
 			vfree(val);
 			if (!flag)
 				sa->dhgrp->gen1 = ntohs(d->lorv);
 			else {
 				int len = ntohs(d->lorv);
 				sa->dhgrp->gen1 = 0;
 				if (len > 4)
 					return -1;
 				memcpy(&sa->dhgrp->gen1, d + 1, len);
 				sa->dhgrp->gen1 = ntohl(sa->dhgrp->gen1);
+			}
 			break;
 		case OAKLEY_ATTR_GRP_GEN_TWO:
 			vfree(val);
 			if (!flag)
 				sa->dhgrp->gen2 = ntohs(d->lorv);
 			else {
 				int len = ntohs(d->lorv);
 				sa->dhgrp->gen2 = 0;
 				if (len > 4)
 					return -1;
 				memcpy(&sa->dhgrp->gen2, d + 1, len);
 				sa->dhgrp->gen2 = ntohl(sa->dhgrp->gen2);
+			}
 			break;
 		case OAKLEY_ATTR_GRP_CURVE_A:
 			sa->dhgrp->curve_a = val;
 			break;
 		case OAKLEY_ATTR_GRP_CURVE_B:
 			sa->dhgrp->curve_b = val;
 			break;
 		case OAKLEY_ATTR_SA_LD_TYPE:
+		{
 			int type = (int)ntohs(d->lorv);
 			switch (type) {
 			case OAKLEY_ATTR_SA_LD_TYPE_SEC:
 			case OAKLEY_ATTR_SA_LD_TYPE_KB:
 				life_t = type;
 				break;
 			default:
 				life_t = OAKLEY_ATTR_SA_LD_TYPE_DEFAULT;
 				break;
+			}
 			break;
+		}
 		case OAKLEY_ATTR_SA_LD:
 			if (!prev
 			 || (ntohs(prev->type) & ~ISAKMP_GEN_MASK) !=
 					OAKLEY_ATTR_SA_LD_TYPE) {
 				plog(LLV_ERROR, LOCATION, NULL,
 				    "life duration must follow ltype\n");
 				break;
+			}
 			switch (life_t) {
 			case IPSECDOI_ATTR_SA_LD_TYPE_SEC:
 				sa->lifetime = ipsecdoi_set_ld(val);
 				vfree(val);
 				if (sa->lifetime == 0) {
 					plog(LLV_ERROR, LOCATION, NULL,
 						"invalid life duration.\n");
 					goto err;
+				}
 				break;
 			case IPSECDOI_ATTR_SA_LD_TYPE_KB:
 				sa->lifebyte = ipsecdoi_set_ld(val);
 				vfree(val);
 				if (sa->lifebyte == 0) {
 					plog(LLV_ERROR, LOCATION, NULL,
 						"invalid life duration.\n");
 					goto err;
+				}
 				break;
 			default:
 				vfree(val);
 				plog(LLV_ERROR, LOCATION, NULL,
 					"invalid life type: %d\n", life_t);
 				goto err;
+			}
 			break;
 		case OAKLEY_ATTR_KEY_LEN:
+		{
 			int len = ntohs(d->lorv);
 			if (len % 8 != 0) {
 				plog(LLV_ERROR, LOCATION, NULL,
 					"keylen %d: not multiple of 8\n",
 					len);
 				goto err;
+			}
 			sa->encklen = (u_int16_t)len;
 			keylen++;
 			break;
+		}
 		case OAKLEY_ATTR_PRF:
 		case OAKLEY_ATTR_FIELD_SIZE:
 			/* unsupported */
 			break;
 		case OAKLEY_ATTR_GRP_ORDER:
 			sa->dhgrp->order = val;
 			break;
 #ifdef HAVE_GSSAPI
 		case OAKLEY_ATTR_GSS_ID:
+		{
 			int error = -1;
 			iconv_t cd = (iconv_t) -1;
 			size_t srcleft, dstleft, rv;
 			__iconv_const char *src;
 			char *dst;
 			int len = ntohs(d->lorv);
 			/*
 			 * Older verions of racoon just placed the
 			 * ISO-Latin-1 string on the wire directly.
 			 * Check to see if we are configured to be
 			 * compatible with this behavior.
 			 */
 			if (lcconf->gss_id_enc == LC_GSSENC_LATIN1) {
 				if ((sa->gssid = vmalloc(len)) == NULL) {
 					plog(LLV_ERROR, LOCATION, NULL,
 					    "failed to allocate memory\n");
 					goto out;
+				}
 				memcpy(sa->gssid->v, d + 1, len);
 				plog(LLV_DEBUG, LOCATION, NULL,
 				    "received old-style gss "
 				    "id '%.*s' (len %zu)\n",
 				    (int)sa->gssid->l, sa->gssid->v,
 				    sa->gssid->l);
 				error = 0;
 				goto out;
+			}
 			/*
 			 * For Windows 2000 compatibility, we expect
 			 * the GSS ID attribute on the wire to be
 			 * encoded in UTF-16LE.  Internally, we work
 			 * in ISO-Latin-1.  Therefore, we should need
 			 * 1/2 the specified length, which should always
 			 * be a multiple of 2 octets.
 			 */
 			cd = iconv_open("latin1", "utf-16le");
 			if (cd == (iconv_t) -1) {
 				plog(LLV_ERROR, LOCATION, NULL,
 				    "unable to initialize utf-16le -> latin1 "
 				    "conversion descriptor: %s\n",
 				    strerror(errno));
 				goto out;
+			}
 			if ((sa->gssid = vmalloc(len / 2)) == NULL) {
 				plog(LLV_ERROR, LOCATION, NULL,
 				    "failed to allocate memory\n");
 				goto out;
+			}
 			src = (__iconv_const char *)(d + 1);
 			srcleft = len;
 			dst = sa->gssid->v;
 			dstleft = len / 2;
 			rv = iconv(cd, (__iconv_const char **)&src, &srcleft,
 				   &dst, &dstleft);
 			if (rv != 0) {
 				if (rv == -1) {
 					plog(LLV_ERROR, LOCATION, NULL,
 					    "unable to convert GSS ID from "
 					    "utf-16le -> latin1: %s\n",
 					    strerror(errno));
 				} else {
 					plog(LLV_ERROR, LOCATION, NULL,
 					    "%zd character%s in GSS ID cannot "
 					    "be represented in latin1\n",
 					    rv, rv == 1 ? "" : "s");
+				}
 				goto out;
+			}
 			/* XXX dstleft should always be 0; assert it? */
 			sa->gssid->l = (len / 2) - dstleft;
 			plog(LLV_DEBUG, LOCATION, NULL,
 			    "received gss id '%.*s' (len %zu)\n",
 			    (int)sa->gssid->l, sa->gssid->v, sa->gssid->l);
 			error = 0;
 out:
 			if (cd != (iconv_t)-1)
 				(void)iconv_close(cd);
 			if ((error != 0) && (sa->gssid != NULL)) {
 				vfree(sa->gssid);
 				sa->gssid = NULL;
+			}
 			break;
+		}
 #endif /* HAVE_GSSAPI */
 		default:
 			break;
+		}
 		prev = d;
 		if (flag) {
 			tlen -= sizeof(*d);
 			d = (struct isakmp_data *)((char *)d + sizeof(*d));
 		} else {
 			tlen -= (sizeof(*d) + ntohs(d->lorv));
 			d = (struct isakmp_data *)((char *)d + sizeof(*d) + ntohs(d->lorv));
+		}
+	}
 	/* key length must not be specified on some algorithms */
 	if (keylen) {
 		if (sa->enctype == OAKLEY_ATTR_ENC_ALG_DES
 #ifdef HAVE_OPENSSL_IDEA_H
 		 || sa->enctype == OAKLEY_ATTR_ENC_ALG_IDEA
 #endif
 		 || sa->enctype == OAKLEY_ATTR_ENC_ALG_3DES) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"keylen must not be specified "
 				"for encryption algorithm %d\n",
 				sa->enctype);
 			return -1;
+		}
+	}
 	return 0;
 err:
 	return error;
+}
 /*%%%*/
 /*
  * check phase 2 SA payload and select single proposal.
  * make new SA payload to be replyed not including general header.
  * This function is called by responder only.
  * OUT:
  *	0: succeed.
  *	-1: error occured.
  */
 int
 ipsecdoi_selectph2proposal(iph2)
 	struct ph2handle *iph2;
+{
 	struct prop_pair **pair;
 	struct prop_pair *ret;
 	u_int32_t doitype, sittype;
 	/* get proposal pair */
 	pair = get_proppair_and_doi_sit(iph2->sa, IPSECDOI_TYPE_PH2,
 					&doitype, &sittype);
 	if (pair == NULL)
 		return -1;
 	/* check and select a proposal. */
 	ret = get_ph2approval(iph2, pair);
 	free_proppair(pair);
 	if (ret == NULL)
 		return -1;
 	/* make a SA to be replayed. */
 	/* SPI must be updated later. */
 	iph2->sa_ret = get_sabyproppair(doitype, sittype, ret);
 	free_proppair0(ret);
 	if (iph2->sa_ret == NULL)
 		return -1;
 	return 0;
+}
 /*
  * check phase 2 SA payload returned from responder.
  * This function is called by initiator only.
  * OUT:
  *	0: valid.
  *	-1: invalid.
  */
 int
 ipsecdoi_checkph2proposal(iph2)
 	struct ph2handle *iph2;
+{
 	struct prop_pair **rpair = NULL, **spair = NULL;
 	struct prop_pair *p;
 	int i, n, num;
 	int error = -1;
 	vchar_t *sa_ret = NULL;
 	u_int32_t doitype, sittype;
 	/* get proposal pair of SA sent. */
 	spair = get_proppair_and_doi_sit(iph2->sa, IPSECDOI_TYPE_PH2,
 					 &doitype, &sittype);
 	if (spair == NULL) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"failed to get prop pair.\n");
 		goto end;
+	}
 	/* XXX should check the number of transform */
 	/* get proposal pair of SA replayed */
 	rpair = get_proppair(iph2->sa_ret, IPSECDOI_TYPE_PH2);
 	if (rpair == NULL) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"failed to get prop pair.\n");
 		goto end;
+	}
 	/* check proposal is only one ? */
 	n = 0;
 	num = 0;
 	for (i = 0; i < MAXPROPPAIRLEN; i++) {
 		if (rpair[i]) {
 			n = i;
 			num++;
+		}
+	}
 	if (num == 0) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"no proposal received.\n");
 		goto end;
+	}
 	if (num != 1) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"some proposals received.\n");
 		goto end;
+	}
 	if (spair[n] == NULL) {
 		plog(LLV_WARNING, LOCATION, NULL,
 			"invalid proposal number:%d received.\n", i);
+	}
 	if (rpair[n]->tnext != NULL) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"multi transforms replyed.\n");
 		goto end;
+	}
 	if (cmp_aproppair_i(rpair[n], spair[n])) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"proposal mismathed.\n");
 		goto end;
+	}
 	/*
 	 * check and select a proposal.
 	 * ensure that there is no modification of the proposal by
 	 * cmp_aproppair_i()
 	 */
 	p = get_ph2approval(iph2, rpair);
 	if (p == NULL)
 		goto end;
 	/* make a SA to be replayed. */
 	sa_ret = iph2->sa_ret;
 	iph2->sa_ret = get_sabyproppair(doitype, sittype, p);
 	free_proppair0(p);
 	if (iph2->sa_ret == NULL)
 		goto end;
 	error = 0;
 end:
 	if (rpair)
 		free_proppair(rpair);
 	if (spair)
 		free_proppair(spair);
 	if (sa_ret)
 		vfree(sa_ret);
 	return error;
+}
 /*
  * compare two prop_pair which is assumed to have same proposal number.
  * the case of bundle or single SA, NOT multi transforms.
  * a: a proposal that is multi protocols and single transform, usually replyed.
  * b: a proposal that is multi protocols and multi transform, usually sent.
  * NOTE: this function is for initiator.
  * OUT
  *	0: equal
  *	1: not equal
  * XXX cannot understand the comment!
  */
 static int
 cmp_aproppair_i(a, b)
 	struct prop_pair *a, *b;
+{
 	struct prop_pair *p, *q, *r;
 	int len;
 	for (p = a, q = b; p && q; p = p->next, q = q->next) {
 		for (r = q; r; r = r->tnext) {
 			/* compare trns */
 			if (p->trns->t_no == r->trns->t_no)
 				break;
+		}
 		if (!r) {
 			/* no suitable transform found */
 			plog(LLV_ERROR, LOCATION, NULL,
 				"no suitable transform found.\n");
 			return -1;
+		}
 		/* compare prop */
 		if (p->prop->p_no != r->prop->p_no) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"proposal #%d mismatched, "
 				"expected #%d.\n",
 				r->prop->p_no, p->prop->p_no);
 			/*FALLTHROUGH*/
+		}
 		if (p->prop->proto_id != r->prop->proto_id) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"proto_id mismathed: my:%d peer:%d\n",
 				r->prop->proto_id, p->prop->proto_id);
 			return -1;
+		}
 		if (p->prop->spi_size != r->prop->spi_size) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"invalid spi size: %d.\n",
 				p->prop->spi_size);
 			return -1;
+		}
 		/* check #of transforms */
 		if (p->prop->num_t != 1) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"#of transform is %d, "
 				"but expected 1.\n", p->prop->num_t);
 			/*FALLTHROUGH*/
+		}
 		if (p->trns->t_id != r->trns->t_id) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"transform number has been modified.\n");
 			/*FALLTHROUGH*/
+		}
 		if (p->trns->reserved != r->trns->reserved) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"reserved field should be zero.\n");
 			/*FALLTHROUGH*/
+		}
 		/* compare attribute */
 		len = ntohs(r->trns->h.len) - sizeof(*p->trns);
 		if (memcmp(p->trns + 1, r->trns + 1, len) != 0) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"attribute has been modified.\n");
 			/*FALLTHROUGH*/
+		}
+	}
 	if ((p && !q) || (!p && q)) {
 		/* # of protocols mismatched */
 		plog(LLV_ERROR, LOCATION, NULL,
 			"#of protocols mismatched.\n");
 		return -1;
+	}
 	return 0;
+}
 /*
  * acceptable check for policy configuration.
  * return a new SA payload to be reply to peer.
  */
 static struct prop_pair *
 get_ph2approval(iph2, pair)
 	struct ph2handle *iph2;
 	struct prop_pair **pair;
+{
 	struct prop_pair *ret;
 	int i;
 	iph2->approval = NULL;
 	plog(LLV_DEBUG, LOCATION, NULL,
 		"begin compare proposals.\n");
 	for (i = 0; i < MAXPROPPAIRLEN; i++) {
 		if (pair[i] == NULL)
 			continue;
 		plog(LLV_DEBUG, LOCATION, NULL,
 			"pair[%d]: %p\n", i, pair[i]);
 		print_proppair(LLV_DEBUG, pair[i]);;
 		/* compare proposal and select one */
 		ret = get_ph2approvalx(iph2, pair[i]);
 		if (ret != NULL) {
 			/* found */
 			return ret;
+		}
+	}
 	plog(LLV_ERROR, LOCATION, NULL, "no suitable policy found.\n");
 	return NULL;
+}
 /*
  * compare my proposal and peers just one proposal.
  * set a approval.
  */
 static struct prop_pair *
 get_ph2approvalx(iph2, pp)
 	struct ph2handle *iph2;
 	struct prop_pair *pp;
+{
 	struct prop_pair *ret = NULL;
 	struct saprop *pr0, *pr = NULL;
 	struct saprop *q1, *q2;
 	pr0 = aproppair2saprop(pp);
 	if (pr0 == NULL)
 		return NULL;
 	for (q1 = pr0; q1; q1 = q1->next) {
 		for (q2 = iph2->proposal; q2; q2 = q2->next) {
 			plog(LLV_DEBUG, LOCATION, NULL,
 				"peer's single bundle:\n");
 			printsaprop0(LLV_DEBUG, q1);
 			plog(LLV_DEBUG, LOCATION, NULL,
 				"my single bundle:\n");
 			printsaprop0(LLV_DEBUG, q2);
 			pr = cmpsaprop_alloc(iph2->ph1, q1, q2, iph2->side);
 			if (pr != NULL)
 				goto found;
 			plog(LLV_ERROR, LOCATION, NULL,
 				"not matched\n");
+		}
+	}
 	/* no proposal matching */
 err:
 	flushsaprop(pr0);
 	return NULL;
 found:
 	flushsaprop(pr0);
 	plog(LLV_DEBUG, LOCATION, NULL, "matched\n");
 	iph2->approval = pr;
+    {
 	struct saproto *sp;
 	struct prop_pair *p, *x;
 	struct prop_pair *n = NULL;
 	ret = NULL;
 	for (p = pp; p; p = p->next) {
 		/*
 		 * find a proposal with matching proto_id.
 		 * we have analyzed validity already, in cmpsaprop_alloc().
 		 */
 		for (sp = pr->head; sp; sp = sp->next) {
 			if (sp->proto_id == p->prop->proto_id)
 				break;
+		}
 		if (!sp)
 			goto err;
 		if (sp->head->next)
 			goto err;	/* XXX */
 		for (x = p; x; x = x->tnext)
 			if (sp->head->trns_no == x->trns->t_no)
 				break;
 		if (!x)
 			goto err;	/* XXX */
 		n = racoon_calloc(1, sizeof(struct prop_pair));
 		if (n == NULL) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"failed to get buffer.\n");
 			goto err;
+		}
 		n->prop = x->prop;
 		n->trns = x->trns;
 		/* need to preserve the order */
 		for (x = ret; x && x->next; x = x->next)
+			;
 		if (x && x->prop == n->prop) {
 			for (/*nothing*/; x && x->tnext; x = x->tnext)
+				;
 			x->tnext = n;
 		} else {
 			if (x)
 				x->next = n;
 			else {
 				ret = n;
+			}
+		}
 		/* #of transforms should be updated ? */
+	}
+    }
 	return ret;
+}
 void
 free_proppair(pair)
 	struct prop_pair **pair;
+{
 	int i;
 	for (i = 0; i < MAXPROPPAIRLEN; i++) {
 		free_proppair0(pair[i]);
 		pair[i] = NULL;
+	}
 	racoon_free(pair);
+}
 static void
 free_proppair0(pair)
 	struct prop_pair *pair;
+{
 	struct prop_pair *p, *q, *r, *s;
 	p = pair;
 	while (p) {
 		q = p->next;
 		r = p;
 		while (r) {
 			s = r->tnext;
 			racoon_free(r);
 			r = s;
+		}
 		p = q;
+	}
+}
 /*
  * get proposal pairs from SA payload.
  * tiny check for proposal payload.
  */
 static struct prop_pair **
 get_proppair_and_doi_sit(sa, mode, doitype, sittype)
 	vchar_t *sa;
 	int mode;
 	u_int32_t *doitype, *sittype;
+{
 	struct prop_pair **pair = NULL;
 	int num_p = 0;			/* number of proposal for use */
 	int tlen;
 	caddr_t bp;
 	int i;
 	struct ipsecdoi_sa_b *sab = (struct ipsecdoi_sa_b *)sa->v;
 	plog(LLV_DEBUG, LOCATION, NULL, "total SA len=%zu\n", sa->l);
 	plogdump(LLV_DEBUG, sa->v, sa->l);
 	/* check SA payload size */
 	if (sa->l < sizeof(*sab)) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"Invalid SA length = %zu.\n", sa->l);
 		goto bad;
+	}
 	/* check DOI */
 	if (check_doi(ntohl(sab->doi)) < 0)
 		goto bad;
 	if (doitype != NULL)
 		*doitype = ntohl(sab->doi);
 	/* check SITUATION */
 	if (check_situation(ntohl(sab->sit)) < 0)
 		goto bad;
 	if (sittype != NULL)
 		*sittype = ntohl(sab->sit);
 	pair = racoon_calloc(1, MAXPROPPAIRLEN * sizeof(*pair));
 	if (pair == NULL) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"failed to get buffer.\n");
 		goto bad;
+	}
 	memset(pair, 0, sizeof(pair));
 	bp = (caddr_t)(sab + 1);
 	tlen = sa->l - sizeof(*sab);
+    {
 	struct isakmp_pl_p *prop;
 	int proplen;
 	vchar_t *pbuf = NULL;
 	struct isakmp_parse_t *pa;
 	pbuf = isakmp_parsewoh(ISAKMP_NPTYPE_P, (struct isakmp_gen *)bp, tlen);
 	if (pbuf == NULL)
 		goto bad;
 	for (pa = (struct isakmp_parse_t *)pbuf->v;
 	     pa->type != ISAKMP_NPTYPE_NONE;
 	     pa++) {
 		/* check the value of next payload */
 		if (pa->type != ISAKMP_NPTYPE_P) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"Invalid payload type=%u\n", pa->type);
 			vfree(pbuf);
 			goto bad;
+		}
 		prop = (struct isakmp_pl_p *)pa->ptr;
 		proplen = pa->len;
 		plog(LLV_DEBUG, LOCATION, NULL,
 			"proposal #%u len=%d\n", prop->p_no, proplen);
 		if (proplen == 0) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"invalid proposal with length %d\n", proplen);
 			vfree(pbuf);
 			goto bad;
+		}
 		/* check Protocol ID */
 		if (!check_protocol[mode]) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"unsupported mode %d\n", mode);
 			continue;
+		}
 		if (check_protocol[mode](prop->proto_id) < 0)
 			continue;
 		/* check SPI length when IKE. */
 		if (check_spi_size(prop->proto_id, prop->spi_size) < 0)
 			continue;
 		/* get transform */
 		if (get_transform(prop, pair, &num_p) < 0) {
 			vfree(pbuf);
 			goto bad;
+		}
+	}
 	vfree(pbuf);
 	pbuf = NULL;
+    }
+    {
 	int notrans, nprop;
 	struct prop_pair *p, *q;
 	/* check for proposals with no transforms */
 	for (i = 0; i < MAXPROPPAIRLEN; i++) {
 		if (!pair[i])
 			continue;
 		plog(LLV_DEBUG, LOCATION, NULL, "pair %d:\n", i);
 		print_proppair(LLV_DEBUG, pair[i]);
 		notrans = nprop = 0;
 		for (p = pair[i]; p; p = p->next) {
 			if (p->trns == NULL) {
 				notrans++;
 				break;
+			}
 			for (q = p; q; q = q->tnext)
 				nprop++;
+		}
 #if 0
 		/*
 		 * XXX at this moment, we cannot accept proposal group
 		 * with multiple proposals.  this should be fixed.
 		 */
 		if (pair[i]->next) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"proposal #%u ignored "
 				"(multiple proposal not supported)\n",
 				pair[i]->prop->p_no);
 			notrans++;
+		}
 #endif
 		if (notrans) {
 			for (p = pair[i]; p; p = q) {
 				q = p->next;
 				racoon_free(p);
+			}
 			pair[i] = NULL;
 			num_p--;
 		} else {
 			plog(LLV_DEBUG, LOCATION, NULL,
 				"proposal #%u: %d transform\n",
 				pair[i]->prop->p_no, nprop);
+		}
+	}
+    }
 	/* bark if no proposal is found. */
 	if (num_p <= 0) {
 		plog(LLV_ERROR, LOCATION, NULL,
 			"no Proposal found.\n");
 		goto bad;
+	}
 	return pair;
 bad:
 	if (pair != NULL)
 		racoon_free(pair);
 	return NULL;
+}
 struct prop_pair **
 get_proppair(sa, mode)
 	vchar_t *sa;
 	int mode;
+{
 	return get_proppair_and_doi_sit(sa, mode, NULL, NULL);
+}
 /*
  * check transform payload.
  * OUT:
  *	positive: return the pointer to the payload of valid transform.
  *	0	: No valid transform found.
  */
 static int
 get_transform(prop, pair, num_p)
 	struct isakmp_pl_p *prop;
 	struct prop_pair **pair;
 	int *num_p;
+{
 	int tlen; /* total length of all transform in a proposal */
 	caddr_t bp;
 	struct isakmp_pl_t *trns;
 	int trnslen;
 	vchar_t *pbuf = NULL;
 	struct isakmp_parse_t *pa;
 	struct prop_pair *p = NULL, *q;
 	int num_t;
 	bp = (caddr_t)prop + sizeof(struct isakmp_pl_p) + prop->spi_size;
 	tlen = ntohs(prop->h.len)
 		- (sizeof(struct isakmp_pl_p) + prop->spi_size);
 	pbuf = isakmp_parsewoh(ISAKMP_NPTYPE_T, (struct isakmp_gen *)bp, tlen);
 	if (pbuf == NULL)
 		return -1;
 	/* check and get transform for use */
 	num_t = 0;
 	for (pa = (struct isakmp_parse_t *)pbuf->v;
 	     pa->type != ISAKMP_NPTYPE_NONE;
 	     pa++) {
 		num_t++;
 		/* check the value of next payload */
 		if (pa->type != ISAKMP_NPTYPE_T) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"Invalid payload type=%u\n", pa->type);
 			break;
+		}
 		trns = (struct isakmp_pl_t *)pa->ptr;
 		trnslen = pa->len;
 		plog(LLV_DEBUG, LOCATION, NULL,
 			"transform #%u len=%u\n", trns->t_no, trnslen);
 		/* check transform ID */
 		if (prop->proto_id >= ARRAYLEN(check_transform)) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"unsupported proto_id %u\n",
 				prop->proto_id);
 			continue;
+		}
 		if (prop->proto_id >= ARRAYLEN(check_attributes)) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"unsupported proto_id %u\n",
 				prop->proto_id);
 			continue;
+		}
 		if (!check_transform[prop->proto_id]
 		 || !check_attributes[prop->proto_id]) {
 			plog(LLV_WARNING, LOCATION, NULL,
 				"unsupported proto_id %u\n",
 				prop->proto_id);
 			continue;
+		}
 		if (check_transform[prop->proto_id](trns->t_id) < 0)
 			continue;
 		/* check data attributes */
 		if (check_attributes[prop->proto_id](trns) != 0)
 			continue;
 		p = racoon_calloc(1, sizeof(*p));
 		if (p == NULL) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"failed to get buffer.\n");
 			vfree(pbuf);
 			return -1;
+		}
 		p->prop = prop;
 		p->trns = trns;
 		/* need to preserve the order */
 		for (q = pair[prop->p_no]; q && q->next; q = q->next)
+			;
 		if (q && q->prop == p->prop) {
 			for (/*nothing*/; q && q->tnext; q = q->tnext)
+				;
 			q->tnext = p;
 		} else {
 			if (q)
 				q->next = p;
 			else {
 				pair[prop->p_no] = p;
 				(*num_p)++;
+			}
+		}
+	}
 	vfree(pbuf);
 	return 0;
+}
 /*
  * make a new SA payload from prop_pair.
  * NOTE: this function make spi value clear.
  */
 vchar_t *
 get_sabyproppair(doitype, sittype, pair)
 	u_int32_t doitype, sittype;
 	struct prop_pair *pair;
+{
 	vchar_t *newsa;
 	int newtlen;
 	u_int8_t *np_p = NULL;
 	struct prop_pair *p;
 	int prophlen, trnslen;
 	caddr_t bp;
 	newtlen = sizeof(struct ipsecdoi_sa_b);
 	for (p = pair; p; p = p->next) {
 		newtlen += sizeof(struct isakmp_pl_p);
 		newtlen += p->prop->spi_size;
 		newtlen += ntohs(p->trns->h.len);
+	}
 	newsa = vmalloc(newtlen);
 	if (newsa == NULL) {
 		plog(LLV_ERROR, LOCATION, NULL, "failed to get newsa.\n");
 		return NULL;
+	}
 	bp = newsa->v;
 	((struct isakmp_gen *)bp)->len = htons(newtlen);
 	/* update some of values in SA header */
 	((struct ipsecdoi_sa_b *)bp)->doi = htonl(doitype);
 	((struct ipsecdoi_sa_b *)bp)->sit = htonl(sittype);
 	bp += sizeof(struct ipsecdoi_sa_b);
 	/* create proposal payloads */
 	for (p = pair; p; p = p->next) {
 		prophlen = sizeof(struct isakmp_pl_p)
 				+ p->prop->spi_size;
 		trnslen = ntohs(p->trns->h.len);
 		if (np_p)
 			*np_p = ISAKMP_NPTYPE_P;
 		/* create proposal */
 		memcpy(bp, p->prop, prophlen);
 		((struct isakmp_pl_p *)bp)->h.np = ISAKMP_NPTYPE_NONE;
 		((struct isakmp_pl_p *)bp)->h.len = htons(prophlen + trnslen);
 		((struct isakmp_pl_p *)bp)->num_t = 1;
 		np_p = &((struct isakmp_pl_p *)bp)->h.np;
 		memset(bp + sizeof(struct isakmp_pl_p), 0, p->prop->spi_size);
 		bp += prophlen;
 		/* create transform */
 		memcpy(bp, p->trns, trnslen);
 		((struct isakmp_pl_t *)bp)->h.np = ISAKMP_NPTYPE_NONE;
 		((struct isakmp_pl_t *)bp)->h.len = htons(trnslen);
 		bp += trnslen;
+	}
 	return newsa;
+}
 /*
  * update responder's spi
  */
 int
 ipsecdoi_updatespi(iph2)
 	struct ph2handle *iph2;
+{
 	struct prop_pair **pair, *p;
 	struct saprop *pp;
 	struct saproto *pr;
 	int i;
 	int error = -1;
 	u_int8_t *spi;
 	pair = get_proppair(iph2->sa_ret, IPSECDOI_TYPE_PH2);
 	if (pair == NULL)
 		return -1;
 	for (i = 0; i < MAXPROPPAIRLEN; i++) {
 		if (pair[i])
 			break;
+	}
 	if (i == MAXPROPPAIRLEN || pair[i]->tnext) {
 		/* multiple transform must be filtered by selectph2proposal.*/
 		goto end;
+	}
 	pp = iph2->approval;
 	/* create proposal payloads */
 	for (p = pair[i]; p; p = p->next) {
 		/*
 		 * find a proposal/transform with matching proto_id/t_id.
 		 * we have analyzed validity already, in cmpsaprop_alloc().
 		 */
 		for (pr = pp->head; pr; pr = pr->next) {
 			if (p->prop->proto_id == pr->proto_id &&
 			    p->trns->t_id == pr->head->trns_id) {
 				break;
+			}
+		}
 		if (!pr)
 			goto end;
 		/*
 		 * XXX SPI bits are left-filled, for use with IPComp.
 		 * we should be switching to variable-length spi field...
 		 */
 		spi = (u_int8_t *)&pr->spi;
 		spi += sizeof(pr->spi);
 		spi -= pr->spisize;
 		memcpy((caddr_t)p->prop + sizeof(*p->prop), spi, pr->spisize);
+	}
 	error = 0;
 end:
 	free_proppair(pair);
 	return error;
+}
 /*
  * make a new SA payload from prop_pair.
  */
 vchar_t *
 get_sabysaprop(pp0, sa0)
 	struct saprop *pp0;
 	vchar_t *sa0;
+{
 	struct prop_pair **pair = NULL;
 	vchar_t *newsa = NULL;
 	int newtlen;
 	u_int8_t *np_p = NULL;
 	struct prop_pair *p = NULL;
 	struct saprop *pp;
 	struct saproto *pr;
 	struct satrns *tr;
 	int prophlen, trnslen;
 	caddr_t bp;
 	int error = -1;
 	/* get proposal pair */
 	pair = get_proppair(sa0, IPSECDOI_TYPE_PH2);
 	if (pair == NULL)
 		goto out;
 	newtlen = sizeof(struct ipsecdoi_sa_b);
 	for (pp = pp0; pp; pp = pp->next) {
 		if (pair[pp->prop_no] == NULL)
 			goto out;
 		for (pr = pp->head; pr; pr = pr->next) {
 			newtlen += (sizeof(struct isakmp_pl_p)
 				+ pr->spisize);
 			for (tr = pr->head; tr; tr = tr->next) {
 				for (p = pair[pp->prop_no]; p; p = p->tnext) {
 					if (tr->trns_no == p->trns->t_no)
 						break;
+				}
 				if (p == NULL)
 					goto out;
 				newtlen += ntohs(p->trns->h.len);
+			}
+		}
+	}
 	newsa = vmalloc(newtlen);
 	if (newsa == NULL) {
 		plog(LLV_ERROR, LOCATION, NULL, "failed to get newsa.\n");
 		goto out;
+	}
 	bp = newsa->v;
 	/* some of values of SA must be updated in the out of this function */
 	((struct isakmp_gen *)bp)->len = htons(newtlen);
 	bp += sizeof(struct ipsecdoi_sa_b);
 	/* create proposal payloads */
 	for (pp = pp0; pp; pp = pp->next) {
 		for (pr = pp->head; pr; pr = pr->next) {
 			prophlen = sizeof(struct isakmp_pl_p)
 					+ p->prop->spi_size;
 			for (tr = pr->head; tr; tr = tr->next) {
 				for (p = pair[pp->prop_no]; p; p = p->tnext) {
 					if (tr->trns_no == p->trns->t_no)
 						break;
+				}
 				if (p == NULL)
 					goto out;
 				trnslen = ntohs(p->trns->h.len);
 				if (np_p)
 					*np_p = ISAKMP_NPTYPE_P;
 				/* create proposal */
 				memcpy(bp, p->prop, prophlen);
 				((struct isakmp_pl_p *)bp)->h.np = ISAKMP_NPTYPE_NONE;
 				((struct isakmp_pl_p *)bp)->h.len = htons(prophlen + trnslen);
 				((struct isakmp_pl_p *)bp)->num_t = 1;
 				np_p = &((struct isakmp_pl_p *)bp)->h.np;
 				bp += prophlen;
 				/* create transform */
 				memcpy(bp, p->trns, trnslen);
 				((struct isakmp_pl_t *)bp)->h.np = ISAKMP_NPTYPE_NONE;
 				((struct isakmp_pl_t *)bp)->h.len = htons(trnslen);
 				bp += trnslen;
+			}
+		}
+	}
 	error = 0;
 out:
 	if (pair != NULL)
 		racoon_free(pair);
 	if (error != 0) {
 		if (newsa != NULL) {
 			vfree(newsa);
 			newsa = NULL;
+		}
+	}
 	return newsa;
+}
 /*
  * If some error happens then return 0.  Although 0 means that lifetime is zero,
  * such a value should not be accepted.
  * Also 0 of lifebyte should not be included in a packet although 0 means not
  * to care of it.
  */
 static u_int32_t
 ipsecdoi_set_ld(buf)
 	vchar_t *buf;
+{
 	u_int32_t ld;
 	if (buf == 0)
 		return 0;
 	switch (buf->l) {
 	case 2:
 		ld = ntohs(*(u_int16_t *)buf->v);
 		break;
 	case 4:
 		ld = ntohl(*(u_int32_t *)buf->v);
 		break;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"length %zu of life duration "
 			"isn't supported.\n", buf->l);
 		return 0;
+	}
 	return ld;
+}
 /*
  * parse responder-lifetime attributes from payload
  */
 int
 ipsecdoi_parse_responder_lifetime(notify, lifetime_sec, lifetime_kb)
 	struct isakmp_pl_n *notify;
 	u_int32_t *lifetime_sec;
 	u_int32_t *lifetime_kb;
+{
 	struct isakmp_data *d;
 	int flag, type, tlen, ld_type = -1;
 	u_int16_t lorv;
 	u_int32_t value;
 	tlen = ntohs(notify->h.len) - sizeof(*notify) - notify->spi_size;
         d = (struct isakmp_data *)((char *)(notify + 1) +
 		notify->spi_size);
 	while (tlen >= sizeof(struct isakmp_data)) {
 		type = ntohs(d->type) & ~ISAKMP_GEN_MASK;
 		flag = ntohs(d->type) & ISAKMP_GEN_MASK;
 		lorv = ntohs(d->lorv);
 		plog(LLV_DEBUG, LOCATION, NULL,
 			"type=%s, flag=0x%04x, lorv=%s\n",
 			s_ipsecdoi_attr(type), flag,
 			s_ipsecdoi_attr_v(type, lorv));
 		switch (type) {
 		case IPSECDOI_ATTR_SA_LD_TYPE:
 			if (! flag) {
 				plog(LLV_ERROR, LOCATION, NULL,
 					"must be TV when LD_TYPE.\n");
 				return -1;
+			}
 			ld_type = lorv;
 			break;
 		case IPSECDOI_ATTR_SA_LD:
 			if (flag)
 				value = lorv;
 			else if (lorv == 2)
 				value = ntohs(*(u_int16_t *)(d + 1));
 			else if (lorv == 4)
 				value = ntohl(*(u_int32_t *)(d + 1));
 			else {
 				plog(LLV_ERROR, LOCATION, NULL,
 					"payload length %d for lifetime "
 					"data length is unsupported.\n", lorv);
 				return -1;
+			}
 			switch (ld_type) {
 			case IPSECDOI_ATTR_SA_LD_TYPE_SEC:
 				if (lifetime_sec != NULL)
 					*lifetime_sec = value;
 				plog(LLV_INFO, LOCATION, NULL,
 					"received RESPONDER-LIFETIME: %d "
 					"seconds\n", value);
 				break;
 			case IPSECDOI_ATTR_SA_LD_TYPE_KB:
 				if (lifetime_kb != NULL)
 					*lifetime_kb = value;
 				plog(LLV_INFO, LOCATION, NULL,
 					"received RESPONDER-LIFETIME: %d "
 					"kbytes\n", value);
 				break;
 			default:
 				plog(LLV_ERROR, LOCATION, NULL,
 					"lifetime data received without "
 					"lifetime data type.\n");
 				return -1;
+			}
 			break;
+		}
 		if (flag) {
 			tlen -= sizeof(*d);
 			d = (struct isakmp_data *)((char *)d
 				+ sizeof(*d));
 		} else {
 			tlen -= (sizeof(*d) + lorv);
 			d = (struct isakmp_data *)((char *)d
 				+ sizeof(*d) + lorv);
+		}
+	}
 	return 0;
+}
 /*%%%*/
 /*
  * check DOI
  */
 static int
 check_doi(doi)
 	u_int32_t doi;
+{
 	switch (doi) {
 	case IPSEC_DOI:
 		return 0;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"invalid value of DOI 0x%08x.\n", doi);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check situation
  */
 static int
 check_situation(sit)
 	u_int32_t sit;
+{
 	switch (sit) {
 	case IPSECDOI_SIT_IDENTITY_ONLY:
 		return 0;
 	case IPSECDOI_SIT_SECRECY:
 	case IPSECDOI_SIT_INTEGRITY:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"situation 0x%08x unsupported yet.\n", sit);
 		return -1;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"invalid situation 0x%08x.\n", sit);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check protocol id in main mode
  */
 static int
 check_prot_main(proto_id)
 	int proto_id;
+{
 	switch (proto_id) {
 	case IPSECDOI_PROTO_ISAKMP:
 		return 0;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"Illegal protocol id=%u.\n", proto_id);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check protocol id in quick mode
  */
 static int
 check_prot_quick(proto_id)
 	int proto_id;
+{
 	switch (proto_id) {
 	case IPSECDOI_PROTO_IPSEC_AH:
 	case IPSECDOI_PROTO_IPSEC_ESP:
 		return 0;
 	case IPSECDOI_PROTO_IPCOMP:
 		return 0;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"invalid protocol id %d.\n", proto_id);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 static int
 check_spi_size(proto_id, size)
 	int proto_id, size;
+{
 	switch (proto_id) {
 	case IPSECDOI_PROTO_ISAKMP:
 		if (size != 0) {
 			/* WARNING */
 			plog(LLV_WARNING, LOCATION, NULL,
 				"SPI size isn't zero, but IKE proposal.\n");
+		}
 		return 0;
 	case IPSECDOI_PROTO_IPSEC_AH:
 	case IPSECDOI_PROTO_IPSEC_ESP:
 		if (size != 4) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"invalid SPI size=%d for IPSEC proposal.\n",
 				size);
 			return -1;
+		}
 		return 0;
 	case IPSECDOI_PROTO_IPCOMP:
 		if (size != 2 && size != 4) {
 			plog(LLV_ERROR, LOCATION, NULL,
 				"invalid SPI size=%d for IPCOMP proposal.\n",
 				size);
 			return -1;
+		}
 		return 0;
 	default:
 		/* ??? */
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check transform ID in ISAKMP.
  */
 static int
 check_trns_isakmp(t_id)
 	int t_id;
+{
 	switch (t_id) {
 	case IPSECDOI_KEY_IKE:
 		return 0;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"invalid transform-id=%u in proto_id=%u.\n",
 			t_id, IPSECDOI_KEY_IKE);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check transform ID in AH.
  */
 static int
 check_trns_ah(t_id)
 	int t_id;
+{
 	switch (t_id) {
 	case IPSECDOI_AH_MD5:
 	case IPSECDOI_AH_SHA:
 	case IPSECDOI_AH_SHA256:
 	case IPSECDOI_AH_SHA384:
 	case IPSECDOI_AH_SHA512:
 		return 0;
 	case IPSECDOI_AH_DES:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"not support transform-id=%u in AH.\n", t_id);
 		return -1;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"invalid transform-id=%u in AH.\n", t_id);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check transform ID in ESP.
  */
 static int
 check_trns_esp(t_id)
 	int t_id;
+{
 	switch (t_id) {
 	case IPSECDOI_ESP_DES:
 	case IPSECDOI_ESP_3DES:
 	case IPSECDOI_ESP_NULL:
 	case IPSECDOI_ESP_RC5:
 	case IPSECDOI_ESP_CAST:
 	case IPSECDOI_ESP_BLOWFISH:
 	case IPSECDOI_ESP_AES:
 	case IPSECDOI_ESP_AESGCM16:
 	case IPSECDOI_ESP_TWOFISH:
 	case IPSECDOI_ESP_CAMELLIA:
 		return 0;
 	case IPSECDOI_ESP_DES_IV32:
 	case IPSECDOI_ESP_DES_IV64:
 	case IPSECDOI_ESP_IDEA:
 	case IPSECDOI_ESP_3IDEA:
 	case IPSECDOI_ESP_RC4:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"not support transform-id=%u in ESP.\n", t_id);
 		return -1;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"invalid transform-id=%u in ESP.\n", t_id);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check transform ID in IPCOMP.
  */
 static int
 check_trns_ipcomp(t_id)
 	int t_id;
+{
 	switch (t_id) {
 	case IPSECDOI_IPCOMP_OUI:
 	case IPSECDOI_IPCOMP_DEFLATE:
 	case IPSECDOI_IPCOMP_LZS:
 		return 0;
 	default:
 		plog(LLV_ERROR, LOCATION, NULL,
 			"invalid transform-id=%u in IPCOMP.\n", t_id);
 		return -1;
+	}
 	/* NOT REACHED */
+}
 /*
  * check data attributes in IKE.
  */
 static int
 check_attr_isakmp(trns)
 	struct isakmp_pl_t *trns;
+{
 	struct isakmp_data *d;
 	int tlen;
 	int flag, type;
 	u_int16_t lorv;
 	tlen = ntohs(trns->h.len) - sizeof(struct isakmp_pl_t);
 	d = (struct isakmp_data *)((caddr_t)trns + sizeof(struct isakmp_pl_t));
 	while (tlen > 0) {
 		type = ntohs(d->type) & ~ISAKMP_GEN_MASK;
 		flag = ntohs(d->type) & ISAKMP_GEN_MASK;
 		lorv = ntohs(d->lorv);
 		plog(LLV_DEBUG, LOCATION, NULL,
 			"type=%s, flag=0x%04x, lorv=%s\n",
 			s_oakley_attr(type), flag,
 			s_oakley_attr_v(type, lorv));
 		/*
 		 * some of the attributes must be encoded in TV.
 		 * see RFC2409 Appendix A "Attribute Classes".
 		 */
 		switch (type) {
 		case OAKLEY_ATTR_ENC_ALG:
 		case OAKLEY_ATTR_HASH_ALG:
 		case OAKLEY_ATTR_AUTH_METHOD:
 		case OAKLEY_ATTR_GRP_DESC:
 		case OAKLEY_ATTR_GRP_TYPE:
 		case OAKLEY_ATTR_SA_LD_TYPE:
 		case OAKLEY_ATTR_PRF:
 		case OAKLEY_ATTR_KEY_LEN:
 		case OAKLEY_ATTR_FIELD_SIZE:
 			if (!flag) {	/* TLV*/
 				plog(LLV_ERROR, LOCATION, NULL,
 					"oakley attribute %d must be TV.\n",
 					type);
 				return -1;
+			}
 			break;
+		}
 		/* sanity check for TLV.  length must be specified. */
 		if (!flag && lorv == 0) {	/*TLV*/
 			plog(LLV_ERROR, LOCATION, NULL,
 				"invalid length %d for TLV attribute %d.\n",
 				lorv, type);
 			return -1;
+		}
 		switch (type) {
 		case OAKLEY_ATTR_ENC_ALG:
 			if (!alg_oakley_encdef_ok(lorv)) {
 				plog(LLV_ERROR, LOCATION, NULL,
 					"invalied encryption algorithm=%d.\n",
 					lorv);
 				return -1;
+			}
 			break;
 		case OAKLEY_ATTR_HASH_ALG:
 			if (!alg_oakley_hashdef_ok(lorv)) {
 				plog(LLV_ERROR, LOCATION, NULL,
 					"invalied hash algorithm=%d.\n",
 					lorv);
 				return -1;
+			}
 			break;
 		case OAKLEY_ATTR_AUTH_METHOD:
 			switch (lorv) {
 			case OAKLEY_ATTR_AUTH_METHOD_PSKEY:
 			case OAKLEY_ATTR_AUTH_METHOD_RSASIG:
 #ifdef ENABLE_HYBRID
 			case OAKLEY_ATTR_AUTH_METHOD_HYBRID_RSA_I:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSASIG_I:
 #endif
 #if defined(ENABLE_HYBRID) || defined(HAVE_GSSAPI)
 				/* These two authentication method IDs overlap. */
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_PSKEY_I:
 			/*case OAKLEY_ATTR_AUTH_METHOD_GSSAPI_KRB:*/
 #endif
 				break;
 			case OAKLEY_ATTR_AUTH_METHOD_DSSSIG:
 #ifdef ENABLE_HYBRID
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_PSKEY_R:
 			case OAKLEY_ATTR_AUTH_METHOD_HYBRID_RSA_R:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSASIG_R:
 			case OAKLEY_ATTR_AUTH_METHOD_HYBRID_DSS_I:
 			case OAKLEY_ATTR_AUTH_METHOD_HYBRID_DSS_R:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_DSSSIG_I:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_DSSSIG_R:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAENC_I:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAENC_R:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAREV_I:
 			case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAREV_R:
 #endif
 			case OAKLEY_ATTR_AUTH_METHOD_RSAENC:
 			case OAKLEY_ATTR_AUTH_METHOD_RSAREV:
 				plog(LLV_ERROR, LOCATION, NULL,
 					"auth method %s isn't supported.\n",
 					s_oakley_attr_method(lorv));
 				return -1;
 			default:
 				plog(LLV_ERROR, LOCATION, NULL,
 					"invalid auth method %d.\n",
 					lorv);
 				return -1;
+			}
 			break;
 		case OAKLEY_ATTR_GRP_DESC:
 			if (!alg_oakley_dhdef_ok(lorv)) {
 				plog(LLV_ERROR, LOCATION, NULL,
 					"invalid DH group %d.\n",
 					lorv);
 				return -1;
+			}
 			break;
 		case OAKLEY_ATTR_GRP_TYPE:
 			switch (lorv) {
 			case OAKLEY_ATTR_GRP_TYPE_MODP:
 				break;
 			default:
 				plog(LLV_ERROR, LOCATION, NULL,
 					"unsupported DH group type %d.\n",
 					lorv);
 				return -1;
+			}
 			break;
 		case OAKLEY_ATTR_GRP_PI:
 		case OAKLEY_ATTR_GRP_GEN_ONE:
 			/* sanity checks? */
 			break;
 		case OAKLEY_ATTR_GRP_GEN_TWO:
 		case OAKLEY_ATTR_GRP_CURVE_A:
 		case OAKLEY_ATTR_GRP_CURVE_B:
 			plog(LLV_ERROR, LOCATION, NULL,
 				"attr type=%u isn't supported.\n", type);
 			return -1;
 		case OAKLEY_ATTR_SA_LD_TYPE:
 			switch (lorv) {
 			case OAKLEY_ATTR_SA_LD_TYPE_SEC:
 			case OAKLEY_ATTR_SA_LD_TYPE_KB:
 				break;
 			default:
 				plog(LLV_ERROR, LOCATION, NULL,
 					"invalid life type %d.\n", lorv);
 				return -1;
+			}
 			break;
 		case OAKLEY_ATTR_SA_LD:
 			/* should check the value */
 			break;
 		case OAKLEY_ATTR_PRF:
 		case OAKLEY_ATTR_KEY_LEN:
 			break;