/* ssl/ssl_ciph.c */

/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

 * All rights reserved.

 *

 * This package is an SSL implementation written

 * by Eric Young (eay@cryptsoft.com).

 * The implementation was written so as to conform with Netscapes SSL.

 * 

 * This library is free for commercial and non-commercial use as long as

 * the following conditions are aheared to.  The following conditions

 * apply to all code found in this distribution, be it the RC4, RSA,

 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

 * included with this distribution is covered by the same copyright terms

 * except that the holder is Tim Hudson (tjh@cryptsoft.com).

 * 

 * Copyright remains Eric Young's, and as such any Copyright notices in

 * the code are not to be removed.

 * If this package is used in a product, Eric Young should be given attribution

 * as the author of the parts of the library used.

 * This can be in the form of a textual message at program startup or

 * in documentation (online or textual) provided with the package.

 * 

 * 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 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. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *    "This product includes cryptographic software written by

 *     Eric Young (eay@cryptsoft.com)"

 *    The word 'cryptographic' can be left out if the rouines from the library

 *    being used are not cryptographic related :-).

 * 4. If you include any Windows specific code (or a derivative thereof) from 

 *    the apps directory (application code) you must include an acknowledgement:

 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

 * 

 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 AUTHOR 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.

 * 

 * The licence and distribution terms for any publically available version or

 * derivative of this code cannot be changed.  i.e. this code cannot simply be

 * copied and put under another distribution licence

 * [including the GNU Public Licence.]

  * Copyright (c) 1998-2006 The OpenSSL 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. All advertising materials mentioning features or use of this

 *    software must display the following acknowledgment:

 *    "This product includes software developed by the OpenSSL Project

 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"

 *

 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to

 *    endorse or promote products derived from this software without

 *    prior written permission. For written permission, please contact

 *    openssl-core@openssl.org.

 *

 * 5. Products derived from this software may not be called "OpenSSL"

 *    nor may "OpenSSL" appear in their names without prior written

 *    permission of the OpenSSL Project.

 *

 * 6. Redistributions of any form whatsoever must retain the following

 *    acknowledgment:

 *    "This product includes software developed by the OpenSSL Project

 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"

 *

 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY

 * EXPRESSED 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 OpenSSL PROJECT OR

 * ITS 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.

 * ====================================================================

 *

 * This product includes cryptographic software written by Eric Young

 * (eay@cryptsoft.com).  This product includes software written by Tim

 * Hudson (tjh@cryptsoft.com).

 *

 */

/* ====================================================================

*/

/* ====================================================================

 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

 * ECC cipher suite support in OpenSSL originally developed by 

 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.

 */

 /*

 © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

 */

#include <stdio.h>

#include <openssl/objects.h>

#include <openssl/comp.h>

#include "ssl_locl.h"

#define SSL_ENC_DES_IDX		0

#define SSL_ENC_3DES_IDX	1

#define SSL_ENC_RC4_IDX		2

#define SSL_ENC_RC2_IDX		3

#define SSL_ENC_IDEA_IDX	4

#define SSL_ENC_eFZA_IDX	5

#define SSL_ENC_NULL_IDX	6

#define SSL_ENC_AES128_IDX	7

#define SSL_ENC_AES256_IDX	8

#define SSL_ENC_NUM_IDX		9

#ifndef EMULATOR

static const EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX]={

	NULL,NULL,NULL,NULL,NULL,NULL,

	};

#else

	GET_STATIC_ARRAY_FROM_TLS(ssl_cipher_methods,ssl_ciph,const EVP_CIPHER *)

	#define ssl_cipher_methods (GET_WSD_VAR_NAME(ssl_cipher_methods,ssl_ciph,s)())

#endif

#define SSL_COMP_NULL_IDX	0

#define SSL_COMP_ZLIB_IDX	1

#define SSL_COMP_NUM_IDX	2

#ifndef EMULATOR

static STACK_OF(SSL_COMP) *ssl_comp_methods=NULL;

#else

	GET_STATIC_VAR_FROM_TLS(ssl_comp_methods,ssl_ciph,STACK_OF(SSL_COMP) *)

	#define ssl_comp_methods (*GET_WSD_VAR_NAME(ssl_comp_methods,ssl_ciph,s)())

#endif

#define SSL_MD_MD5_IDX	0

#define SSL_MD_SHA1_IDX	1

#define SSL_MD_NUM_IDX	2

#ifndef EMULATOR

static const EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX]={

	NULL,NULL,

	};

#else /* EMULATOR */

	GET_STATIC_ARRAY_FROM_TLS(ssl_digest_methods,ssl_ciph,const EVP_MD *)

	#define ssl_digest_methods (GET_WSD_VAR_NAME(ssl_digest_methods,ssl_ciph,s)())

#endif

#define CIPHER_ADD	1

#define CIPHER_KILL	2

#define CIPHER_DEL	3

#define CIPHER_ORD	4

#define CIPHER_SPECIAL	5

typedef struct cipher_order_st

	{

	SSL_CIPHER *cipher;

	int active;

	int dead;

	struct cipher_order_st *next,*prev;

	} CIPHER_ORDER;

static const SSL_CIPHER cipher_aliases[]={

	/* Don't include eNULL unless specifically enabled. */

	/* Don't include ECC in ALL because these ciphers are not yet official. */

	{0,SSL_TXT_ALL, 0,SSL_ALL & ~SSL_eNULL & ~SSL_kECDH & ~SSL_kECDHE, SSL_ALL ,0,0,0,SSL_ALL,SSL_ALL}, /* must be first */

	/* TODO: COMPLEMENT OF ALL and COMPLEMENT OF DEFAULT do not have ECC cipher suites handled properly. */

	{0,SSL_TXT_CMPALL,0,SSL_eNULL,0,0,0,0,SSL_ENC_MASK,0},  /* COMPLEMENT OF ALL */

	{0,SSL_TXT_CMPDEF,0,SSL_ADH, 0,0,0,0,SSL_AUTH_MASK,0},

	{0,SSL_TXT_kKRB5,0,SSL_kKRB5,0,0,0,0,SSL_MKEY_MASK,0},  /* VRS Kerberos5 */

	{0,SSL_TXT_kRSA,0,SSL_kRSA,  0,0,0,0,SSL_MKEY_MASK,0},

	{0,SSL_TXT_kDHr,0,SSL_kDHr,  0,0,0,0,SSL_MKEY_MASK,0},

	{0,SSL_TXT_kDHd,0,SSL_kDHd,  0,0,0,0,SSL_MKEY_MASK,0},

	{0,SSL_TXT_kEDH,0,SSL_kEDH,  0,0,0,0,SSL_MKEY_MASK,0},

	{0,SSL_TXT_kFZA,0,SSL_kFZA,  0,0,0,0,SSL_MKEY_MASK,0},

	{0,SSL_TXT_DH,	0,SSL_DH,    0,0,0,0,SSL_MKEY_MASK,0},

	{0,SSL_TXT_ECC,	0,(SSL_kECDH|SSL_kECDHE), 0,0,0,0,SSL_MKEY_MASK,0},

	{0,SSL_TXT_EDH,	0,SSL_EDH,   0,0,0,0,SSL_MKEY_MASK|SSL_AUTH_MASK,0},

	{0,SSL_TXT_aKRB5,0,SSL_aKRB5,0,0,0,0,SSL_AUTH_MASK,0},  /* VRS Kerberos5 */

	{0,SSL_TXT_aRSA,0,SSL_aRSA,  0,0,0,0,SSL_AUTH_MASK,0},

	{0,SSL_TXT_aDSS,0,SSL_aDSS,  0,0,0,0,SSL_AUTH_MASK,0},

	{0,SSL_TXT_aFZA,0,SSL_aFZA,  0,0,0,0,SSL_AUTH_MASK,0},

	{0,SSL_TXT_aNULL,0,SSL_aNULL,0,0,0,0,SSL_AUTH_MASK,0},

	{0,SSL_TXT_aDH, 0,SSL_aDH,   0,0,0,0,SSL_AUTH_MASK,0},

	{0,SSL_TXT_DSS,	0,SSL_DSS,   0,0,0,0,SSL_AUTH_MASK,0},

	{0,SSL_TXT_DES,	0,SSL_DES,   0,0,0,0,SSL_ENC_MASK,0},

	{0,SSL_TXT_3DES,0,SSL_3DES,  0,0,0,0,SSL_ENC_MASK,0},

	{0,SSL_TXT_RC4,	0,SSL_RC4,   0,0,0,0,SSL_ENC_MASK,0},

	{0,SSL_TXT_RC2,	0,SSL_RC2,   0,0,0,0,SSL_ENC_MASK,0},

#ifndef OPENSSL_NO_IDEA

	{0,SSL_TXT_IDEA,0,SSL_IDEA,  0,0,0,0,SSL_ENC_MASK,0},

#endif

	{0,SSL_TXT_eNULL,0,SSL_eNULL,0,0,0,0,SSL_ENC_MASK,0},

	{0,SSL_TXT_eFZA,0,SSL_eFZA,  0,0,0,0,SSL_ENC_MASK,0},

	{0,SSL_TXT_AES,	0,SSL_AES,   0,0,0,0,SSL_ENC_MASK,0},

	{0,SSL_TXT_MD5,	0,SSL_MD5,   0,0,0,0,SSL_MAC_MASK,0},

	{0,SSL_TXT_SHA1,0,SSL_SHA1,  0,0,0,0,SSL_MAC_MASK,0},

	{0,SSL_TXT_SHA,	0,SSL_SHA,   0,0,0,0,SSL_MAC_MASK,0},

	{0,SSL_TXT_NULL,0,SSL_NULL,  0,0,0,0,SSL_ENC_MASK,0},

	{0,SSL_TXT_KRB5,0,SSL_KRB5,  0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},

	{0,SSL_TXT_RSA,	0,SSL_RSA,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},

	{0,SSL_TXT_ADH,	0,SSL_ADH,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},

	{0,SSL_TXT_FZA,	0,SSL_FZA,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK|SSL_ENC_MASK,0},

	{0,SSL_TXT_SSLV2, 0,SSL_SSLV2, 0,0,0,0,SSL_SSL_MASK,0},

	{0,SSL_TXT_SSLV3, 0,SSL_SSLV3, 0,0,0,0,SSL_SSL_MASK,0},

	{0,SSL_TXT_TLSV1, 0,SSL_TLSV1, 0,0,0,0,SSL_SSL_MASK,0},

	{0,SSL_TXT_EXP   ,0, 0,SSL_EXPORT, 0,0,0,0,SSL_EXP_MASK},

	{0,SSL_TXT_EXPORT,0, 0,SSL_EXPORT, 0,0,0,0,SSL_EXP_MASK},

	{0,SSL_TXT_EXP40, 0, 0, SSL_EXP40, 0,0,0,0,SSL_STRONG_MASK},

	{0,SSL_TXT_EXP56, 0, 0, SSL_EXP56, 0,0,0,0,SSL_STRONG_MASK},

	{0,SSL_TXT_LOW,   0, 0,   SSL_LOW, 0,0,0,0,SSL_STRONG_MASK},

	{0,SSL_TXT_MEDIUM,0, 0,SSL_MEDIUM, 0,0,0,0,SSL_STRONG_MASK},

	{0,SSL_TXT_HIGH,  0, 0,  SSL_HIGH, 0,0,0,0,SSL_STRONG_MASK},

	};

void ssl_load_ciphers(void)

	{

	ssl_cipher_methods[SSL_ENC_DES_IDX]= 

		EVP_get_cipherbyname(SN_des_cbc);

	ssl_cipher_methods[SSL_ENC_3DES_IDX]=

		EVP_get_cipherbyname(SN_des_ede3_cbc);

	ssl_cipher_methods[SSL_ENC_RC4_IDX]=

		EVP_get_cipherbyname(SN_rc4);

	ssl_cipher_methods[SSL_ENC_RC2_IDX]= 

		EVP_get_cipherbyname(SN_rc2_cbc);

#ifndef OPENSSL_NO_IDEA

	ssl_cipher_methods[SSL_ENC_IDEA_IDX]= 

		EVP_get_cipherbyname(SN_idea_cbc);

#else

	ssl_cipher_methods[SSL_ENC_IDEA_IDX]= NULL;

#endif

	ssl_cipher_methods[SSL_ENC_AES128_IDX]=

	  EVP_get_cipherbyname(SN_aes_128_cbc);

	ssl_cipher_methods[SSL_ENC_AES256_IDX]=

	  EVP_get_cipherbyname(SN_aes_256_cbc);

	ssl_digest_methods[SSL_MD_MD5_IDX]=

		EVP_get_digestbyname(SN_md5);

	ssl_digest_methods[SSL_MD_SHA1_IDX]=

		EVP_get_digestbyname(SN_sha1);

	}

#ifndef OPENSSL_NO_COMP

static int sk_comp_cmp(const SSL_COMP * const *a,

			const SSL_COMP * const *b)

	{

	return((*a)->id-(*b)->id);

	}

static void load_builtin_compressions(void)

	{

		int got_write_lock = 0;

	CRYPTO_r_lock(CRYPTO_LOCK_SSL);

	if (ssl_comp_methods == NULL)

		{

		CRYPTO_r_unlock(CRYPTO_LOCK_SSL);

		CRYPTO_w_lock(CRYPTO_LOCK_SSL);

		got_write_lock = 1;

		if (ssl_comp_methods == NULL)

			{

			SSL_COMP *comp = NULL;

			MemCheck_off();

			ssl_comp_methods=sk_SSL_COMP_new(sk_comp_cmp);

			if (ssl_comp_methods != NULL)

				{

				comp=(SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));

				if (comp != NULL)

					{

					comp->method=COMP_zlib();

					if (comp->method

						&& comp->method->type == NID_undef)

						OPENSSL_free(comp);

					else

						{

						comp->id=SSL_COMP_ZLIB_IDX;

						comp->name=comp->method->name;

						sk_SSL_COMP_push(ssl_comp_methods,comp);

						}

					}

				}

			MemCheck_on();

			}

		}

	if (got_write_lock)

		CRYPTO_w_unlock(CRYPTO_LOCK_SSL);

	else

		CRYPTO_r_unlock(CRYPTO_LOCK_SSL);

}

#endif

int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc,

	     const EVP_MD **md, SSL_COMP **comp)

	{

	int i;

	SSL_CIPHER *c;

	c=s->cipher;

	if (c == NULL) return(0);

	if (comp != NULL)

		{

		SSL_COMP ctmp;

#ifndef OPENSSL_NO_COMP

		load_builtin_compressions();

#endif

		*comp=NULL;

		ctmp.id=s->compress_meth;

		if (ssl_comp_methods != NULL)

			{

			i=sk_SSL_COMP_find(ssl_comp_methods,&ctmp);

			if (i >= 0)

				*comp=sk_SSL_COMP_value(ssl_comp_methods,i);

			else

				*comp=NULL;

			}

		}

	if ((enc == NULL) || (md == NULL)) return(0);

	switch (c->algorithms & SSL_ENC_MASK)

		{

	case SSL_DES:

		i=SSL_ENC_DES_IDX;

		break;

	case SSL_3DES:

		i=SSL_ENC_3DES_IDX;

		break;

	case SSL_RC4:

		i=SSL_ENC_RC4_IDX;

		break;

	case SSL_RC2:

		i=SSL_ENC_RC2_IDX;

		break;

	case SSL_IDEA:

		i=SSL_ENC_IDEA_IDX;

		break;

	case SSL_eNULL:

		i=SSL_ENC_NULL_IDX;

		break;

	case SSL_AES:

		switch(c->alg_bits)

			{

		case 128: i=SSL_ENC_AES128_IDX; break;

		case 256: i=SSL_ENC_AES256_IDX; break;

		default: i=-1; break;

			}

		break;

	default:

		i= -1;

		break;

		}

	if ((i < 0) || (i > SSL_ENC_NUM_IDX))

		*enc=NULL;

	else

		{

		if (i == SSL_ENC_NULL_IDX)

			*enc=EVP_enc_null();

		else

			*enc=ssl_cipher_methods[i];

		}

	switch (c->algorithms & SSL_MAC_MASK)

		{

	case SSL_MD5:

		i=SSL_MD_MD5_IDX;

		break;

	case SSL_SHA1:

		i=SSL_MD_SHA1_IDX;

		break;

	default:

		i= -1;

		break;

		}

	if ((i < 0) || (i > SSL_MD_NUM_IDX))

		*md=NULL;

	else

		*md=ssl_digest_methods[i];

	if ((*enc != NULL) && (*md != NULL))

		return(1);

	else

		return(0);

	}

#define ITEM_SEP(a) \

	(((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))

static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,

	     CIPHER_ORDER **tail)

	{

	if (curr == *tail) return;

	if (curr == *head)

		*head=curr->next;

	if (curr->prev != NULL)

		curr->prev->next=curr->next;

	if (curr->next != NULL) /* should always be true */

		curr->next->prev=curr->prev;

	(*tail)->next=curr;

	curr->prev= *tail;

	curr->next=NULL;

	*tail=curr;

	}

static unsigned long ssl_cipher_get_disabled(void)

	{

	unsigned long mask;

	mask = SSL_kFZA;

#ifdef OPENSSL_NO_RSA

	mask |= SSL_aRSA|SSL_kRSA;

#endif

#ifdef OPENSSL_NO_DSA

	mask |= SSL_aDSS;

#endif

#ifdef OPENSSL_NO_DH

	mask |= SSL_kDHr|SSL_kDHd|SSL_kEDH|SSL_aDH;

#endif

#ifdef OPENSSL_NO_KRB5

	mask |= SSL_kKRB5|SSL_aKRB5;

#endif

#ifdef OPENSSL_NO_ECDH

	mask |= SSL_kECDH|SSL_kECDHE;

#endif

#ifdef SSL_FORBID_ENULL

	mask |= SSL_eNULL;

#endif

	mask |= (ssl_cipher_methods[SSL_ENC_DES_IDX ] == NULL) ? SSL_DES :0;

	mask |= (ssl_cipher_methods[SSL_ENC_3DES_IDX] == NULL) ? SSL_3DES:0;

	mask |= (ssl_cipher_methods[SSL_ENC_RC4_IDX ] == NULL) ? SSL_RC4 :0;

	mask |= (ssl_cipher_methods[SSL_ENC_RC2_IDX ] == NULL) ? SSL_RC2 :0;

	mask |= (ssl_cipher_methods[SSL_ENC_IDEA_IDX] == NULL) ? SSL_IDEA:0;

	mask |= (ssl_cipher_methods[SSL_ENC_eFZA_IDX] == NULL) ? SSL_eFZA:0;

	mask |= (ssl_cipher_methods[SSL_ENC_AES128_IDX] == NULL) ? SSL_AES:0;

	mask |= (ssl_digest_methods[SSL_MD_MD5_IDX ] == NULL) ? SSL_MD5 :0;

	mask |= (ssl_digest_methods[SSL_MD_SHA1_IDX] == NULL) ? SSL_SHA1:0;

	return(mask);

	}

static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,

		int num_of_ciphers, unsigned long mask, CIPHER_ORDER *co_list,

		CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)

	{

	int i, co_list_num;

	SSL_CIPHER *c;

	/*

	 * We have num_of_ciphers descriptions compiled in, depending on the

	 * method selected (SSLv2 and/or SSLv3, TLSv1 etc).

	 * These will later be sorted in a linked list with at most num

	 * entries.

	 */

	/* Get the initial list of ciphers */

	co_list_num = 0;	/* actual count of ciphers */

	for (i = 0; i < num_of_ciphers; i++)

		{

		c = ssl_method->get_cipher(i);

		/* drop those that use any of that is not available */

		if ((c != NULL) && c->valid && !(c->algorithms & mask))

			{

			co_list[co_list_num].cipher = c;

			co_list[co_list_num].next = NULL;

			co_list[co_list_num].prev = NULL;

			co_list[co_list_num].active = 0;

			co_list_num++;

#ifdef KSSL_DEBUG

			printf("\t%d: %s %lx %lx\n",i,c->name,c->id,c->algorithms);

#endif	/* KSSL_DEBUG */

			/*

			if (!sk_push(ca_list,(char *)c)) goto err;

			*/

			}

		}

	/*

	 * Prepare linked list from list entries

	 */	

	for (i = 1; i < co_list_num - 1; i++)

		{

		co_list[i].prev = &(co_list[i-1]);

		co_list[i].next = &(co_list[i+1]);

		}

	if (co_list_num > 0)

		{

		(*head_p) = &(co_list[0]);

		(*head_p)->prev = NULL;

		(*head_p)->next = &(co_list[1]);

		(*tail_p) = &(co_list[co_list_num - 1]);

		(*tail_p)->prev = &(co_list[co_list_num - 2]);

		(*tail_p)->next = NULL;

		}

	}