/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 *  glue routine for gss_init_sec_context
 */
#include <mechglueP.h>
#include "gssapiP_generic.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static OM_uint32
val_init_sec_ctx_args(
	OM_uint32 *minor_status,
	gss_ctx_id_t *context_handle,
	gss_name_t target_name,
	gss_OID *actual_mech_type,
	gss_buffer_t output_token)
{

	/* Initialize outputs. */

	if (minor_status != NULL)
		*minor_status = 0;

	if (actual_mech_type != NULL)
		*actual_mech_type = GSS_C_NO_OID;

	if (output_token != GSS_C_NO_BUFFER) {
		output_token->length = 0;
		output_token->value = NULL;
	}

	/* Validate arguments. */

	if (minor_status == NULL)
		return (GSS_S_CALL_INACCESSIBLE_WRITE);

	if (context_handle == NULL)
		return (GSS_S_CALL_INACCESSIBLE_WRITE | GSS_S_NO_CONTEXT);

	if (target_name == NULL)
		return (GSS_S_CALL_INACCESSIBLE_READ | GSS_S_BAD_NAME);

	if (output_token == NULL)
		return (GSS_S_CALL_INACCESSIBLE_WRITE);

	return (GSS_S_COMPLETE);
}

OM_uint32
gss_init_sec_context(minor_status,
			claimant_cred_handle,
			context_handle,
			target_name,
			req_mech_type,
			req_flags,
			time_req,
			input_chan_bindings,
			input_token,
			actual_mech_type,
			output_token,
			ret_flags,
			time_rec)

OM_uint32 *			minor_status;
const gss_cred_id_t		claimant_cred_handle;
gss_ctx_id_t 			*context_handle;
const gss_name_t		target_name;
const gss_OID			req_mech_type;
OM_uint32			req_flags;
OM_uint32			time_req;
const gss_channel_bindings_t	input_chan_bindings;
const gss_buffer_t		input_token;
gss_OID *			actual_mech_type;
gss_buffer_t			output_token;
OM_uint32 *			ret_flags;
OM_uint32 *			time_rec;

{
	OM_uint32		status, temp_minor_status;
	gss_union_name_t	union_name;
	gss_union_cred_t	union_cred;
	gss_name_t		internal_name;
	gss_union_ctx_id_t	union_ctx_id;
	gss_OID			mech_type = GSS_C_NULL_OID;
	gss_mechanism		mech;
	gss_cred_id_t		input_cred_handle;

	status = val_init_sec_ctx_args(minor_status,
				context_handle,
				target_name,
				actual_mech_type,
				output_token);
	if (status != GSS_S_COMPLETE)
		return (status);

	if (req_mech_type)
		mech_type = (gss_OID)req_mech_type;

	union_name = (gss_union_name_t)target_name;

	/*
	 * obtain the gss mechanism information for the requested
	 * mechanism.  If mech_type is NULL, set it to the resultant
	 * mechanism
	 */
	mech = __gss_get_mechanism(mech_type);
	if (mech == NULL)
		return (GSS_S_BAD_MECH);

	if (mech->gss_init_sec_context == NULL)
		return (GSS_S_UNAVAILABLE);

	if (mech_type == GSS_C_NULL_OID)
		mech_type = &mech->mech_type;

	/*
	 * If target_name is mechanism_specific, then it must match the
	 * mech_type that we're about to use.  Otherwise, do an import on
	 * the external_name form of the target name.
	 */
	if (union_name->mech_type &&
			g_OID_equal(union_name->mech_type, mech_type)) {
		internal_name = union_name->mech_name;
	} else {
		if ((status = __gss_import_internal_name(minor_status,
					mech_type, union_name,
					&internal_name)) != GSS_S_COMPLETE)
			return (status);
	}

	/*
	 * if context_handle is GSS_C_NO_CONTEXT, allocate a union context
	 * descriptor to hold the mech type information as well as the
	 * underlying mechanism context handle. Otherwise, cast the
	 * value of *context_handle to the union context variable.
	 */
	if (*context_handle == GSS_C_NO_CONTEXT) {
		status = GSS_S_FAILURE;
		union_ctx_id = (gss_union_ctx_id_t)
			malloc(sizeof (gss_union_ctx_id_desc));
		if (union_ctx_id == NULL)
			goto end;

		if (generic_gss_copy_oid(&temp_minor_status, mech_type,
				&union_ctx_id->mech_type) != GSS_S_COMPLETE) {
			free(union_ctx_id);
			goto end;
		}

		/* copy the supplied context handle */
		union_ctx_id->internal_ctx_id = *context_handle;
	} else
		union_ctx_id = (gss_union_ctx_id_t)*context_handle;

	/*
	 * get the appropriate cred handle from the union cred struct.
	 * defaults to GSS_C_NO_CREDENTIAL if there is no cred, which will
	 * use the default credential.
	 */
	union_cred = (gss_union_cred_t)claimant_cred_handle;
	input_cred_handle = __gss_get_mechanism_cred(union_cred, mech_type);

	/*
	 * now call the approprate underlying mechanism routine
	 */

	status = mech->gss_init_sec_context(
				mech->context,
				minor_status,
				input_cred_handle,
				&union_ctx_id->internal_ctx_id,
				internal_name,
				mech_type,
				req_flags,
				time_req,
				input_chan_bindings,
				input_token,
				actual_mech_type,
				output_token,
				ret_flags,
				time_rec);

	if (status != GSS_S_COMPLETE && status != GSS_S_CONTINUE_NEEDED) {
		/*
		 * the spec says (the preferred) method is to delete all
		 * context info on the first call to init, and on all
		 * subsequent calls make the caller responsible for
		 * calling gss_delete_sec_context
		 */
		map_error(minor_status, mech);
		if (*context_handle == GSS_C_NO_CONTEXT) {
			free(union_ctx_id->mech_type->elements);
			free(union_ctx_id->mech_type);
			free(union_ctx_id);
		}
	} else if (*context_handle == GSS_C_NO_CONTEXT)
		*context_handle = (gss_ctx_id_t)union_ctx_id;

end:
	if (union_name->mech_name == NULL ||
		union_name->mech_name != internal_name) {
		(void) __gss_release_internal_name(&temp_minor_status,
					mech_type, &internal_name);
	}

	return (status);
}