/* #pragma ident	"@(#)g_dsp_status.c	1.17	04/02/23 SMI" */

/*
 * Copyright 1996 by Sun Microsystems, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appears in all copies and
 * that both that copyright notice and this permission notice appear in
 * supporting documentation, and that the name of Sun Microsystems not be used
 * in advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission. Sun Microsystems makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 * SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/*
 *  glue routine gss_display_status
 *
 */

#include "mglueP.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* local function */
static OM_uint32 displayMajor(OM_uint32, OM_uint32 *, gss_buffer_t);

OM_uint32 KRB5_CALLCONV
gss_display_status (minor_status,
                    status_value,
                    status_type,
                    req_mech_type,
                    message_context,
                    status_string)

OM_uint32 *		minor_status;
OM_uint32		status_value;
int			status_type;
gss_OID			req_mech_type;
OM_uint32 *		message_context;
gss_buffer_t		status_string;

{
    gss_OID		mech_type = (gss_OID) req_mech_type;
    gss_mechanism	mech;
    gss_OID_desc	m_oid = { 0, 0 };

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

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

    if (minor_status == NULL ||
	message_context == NULL ||
	status_string == GSS_C_NO_BUFFER)

	return (GSS_S_CALL_INACCESSIBLE_WRITE);

    /* we handle major status codes, and the mechs do the minor */
    if (status_type == GSS_C_GSS_CODE)
	return (displayMajor(status_value, message_context,
			     status_string));

    /*
     * must be the minor status - let mechs do the work
     * select the appropriate underlying mechanism routine and
     * call it.
     */

    /* In this version, we only handle status codes that have been
       mapped to a flat numbering space.  Look up the value we got
       passed.  If it's not found, complain.  */
    if (status_value == 0) {
	status_string->value = gssalloc_strdup("Unknown error");
	if (status_string->value == NULL) {
	    *minor_status = ENOMEM;
	    map_errcode(minor_status);
	    return GSS_S_FAILURE;
	}
	status_string->length = strlen(status_string->value);
	*message_context = 0;
	*minor_status = 0;
	return GSS_S_COMPLETE;
    }
    {
	int err;
	OM_uint32 m_status = 0, status;

	err = gssint_mecherrmap_get(status_value, &m_oid, &m_status);
	if (err) {
	    *minor_status = err;
	    map_errcode(minor_status);
	    return GSS_S_BAD_STATUS;
	}
	if (m_oid.length == 0) {
	    /* Magic flag for com_err values.  */
	    status = g_display_com_err_status(minor_status, m_status, status_string);
	    if (status != GSS_S_COMPLETE)
		map_errcode(minor_status);
	    return status;
	}
	mech_type = &m_oid;
	status_value = m_status;
    }

    mech = gssint_get_mechanism (mech_type);

    if (mech && mech->gss_display_status) {
	OM_uint32 r;

	r = mech->gss_display_status(minor_status,
				     status_value, status_type, mech_type,
				     message_context, status_string);
	/* How's this for weird?  If we get an error returning the
	   mechanism-specific error code, we save away the
	   mechanism-specific error code describing the error.  */
	if (r != GSS_S_COMPLETE)
	    map_error(minor_status, mech);
	return r;
    }

    if (!mech)
	return (GSS_S_BAD_MECH);

    return (GSS_S_UNAVAILABLE);
}

/*
 * function to map the major error codes
 * it uses case statements so that the strings could be wrapped by gettext
 * msgCtxt is interpreted as:
 *	0 - first call
 *	1 - routine error
 *	>= 2 - the supplementary error code bit shifted by 1
 */
static OM_uint32
displayMajor(status, msgCtxt, outStr)
OM_uint32 status;
OM_uint32 *msgCtxt;
gss_buffer_t outStr;
{
	OM_uint32 oneVal, mask = 0x1, currErr;
	char *errStr = NULL;
	int i, haveErr = 0;

	/* take care of the success value first */
	if (status == GSS_S_COMPLETE)
	    errStr = _("The routine completed successfully");
	else if (*msgCtxt == 0 && (oneVal = GSS_CALLING_ERROR(status))) {
		switch (oneVal) {
		case GSS_S_CALL_INACCESSIBLE_READ:
			errStr = _("A required input parameter could not be "
				   "read");
			break;

		case GSS_S_CALL_INACCESSIBLE_WRITE:
			errStr = _("A required output parameter could not be "
				   "written");
			break;

		case GSS_S_CALL_BAD_STRUCTURE:
			errStr = _("A parameter was malformed");
			break;

		default:
			errStr = _("An invalid status code was supplied");
			break;
		}

		/* we now need to determine new value of msgCtxt */
		if (GSS_ROUTINE_ERROR(status))
			*msgCtxt = 1;
		else if ((oneVal = GSS_SUPPLEMENTARY_INFO(status)) != 0)
			*msgCtxt = (OM_uint32)(oneVal << 1);
		else
			*msgCtxt = 0;

	} else if ((*msgCtxt == 0 || *msgCtxt == 1) &&
		(oneVal = GSS_ROUTINE_ERROR(status))) {
		switch (oneVal) {
		case GSS_S_BAD_MECH:
			errStr = _("An unsupported mechanism was requested");
			break;

		case GSS_S_BAD_NAME:
			errStr = _("An invalid name was supplied");
			break;

		case GSS_S_BAD_NAMETYPE:
			errStr = _("A supplied name was of an unsupported "
				   "type");
			break;

		case GSS_S_BAD_BINDINGS:
			errStr = _("Incorrect channel bindings were supplied");
			break;

		case GSS_S_BAD_SIG: /* same as GSS_S_BAD_MIC: */
			errStr = _("A token had an invalid Message Integrity "
				   "Check (MIC)");
			break;

		case GSS_S_NO_CRED:
			errStr = _("No credentials were supplied, or the "
				   "credentials were unavailable or "
				   "inaccessible");
			break;

		case GSS_S_NO_CONTEXT:
			errStr = _("No context has been established");
			break;

		case GSS_S_DEFECTIVE_TOKEN:
			errStr = _("Invalid token was supplied");
			break;

		case GSS_S_DEFECTIVE_CREDENTIAL:
			errStr = _("Invalid credential was supplied");
			break;

		case GSS_S_CREDENTIALS_EXPIRED:
			errStr = _("The referenced credential has expired");
			break;

		case GSS_S_CONTEXT_EXPIRED:
			errStr = _("The referenced context has expired");
			break;

		case GSS_S_FAILURE:
			errStr = _("Unspecified GSS failure.  Minor code "
				   "may provide more information");
			break;

		case GSS_S_BAD_QOP:
			errStr = _("The quality-of-protection (QOP) "
				   "requested could not be provided");
			break;

		case GSS_S_UNAUTHORIZED:
			errStr = _("The operation is forbidden by local "
				   "security policy");
			break;

		case GSS_S_UNAVAILABLE:
			errStr = _("The operation or option is not "
				   "available or unsupported");
			break;

		case GSS_S_DUPLICATE_ELEMENT:
			errStr = _("The requested credential element "
				   "already exists");
			break;

		case GSS_S_NAME_NOT_MN:
			errStr = _("The provided name was not mechanism "
				   "specific (MN)");
			break;

		case GSS_S_BAD_STATUS:
		default:
			errStr = _("An invalid status code was supplied");
		}

		/* we must determine if the caller should call us again */
		if ((oneVal = GSS_SUPPLEMENTARY_INFO(status)) != 0)
			*msgCtxt = (OM_uint32)(oneVal << 1);
		else
			*msgCtxt = 0;

	} else if ((*msgCtxt == 0 || *msgCtxt >= 2) &&
		(oneVal = GSS_SUPPLEMENTARY_INFO(status))) {
		/*
		 * if msgCtxt is not 0, then it should encode
		 * the supplementary error code we should be printing
		 */
		if (*msgCtxt >= 2)
			oneVal = (OM_uint32) (*msgCtxt) >> 1;
		else
			oneVal = GSS_SUPPLEMENTARY_INFO(status);

		/* we display the errors LSB first */
		for (i = 0; i < 16; i++) {
			if (oneVal & mask) {
				haveErr = 1;
				break;
			}
			mask <<= 1;
		}

		/* isolate the bit or if not found set to illegal value */
		if (haveErr)
			currErr = oneVal & mask;
		else
			currErr = 1 << 17; /* illegal value */

		switch (currErr) {
		case GSS_S_CONTINUE_NEEDED:
			errStr = _("The routine must be called again to "
				   "complete its function");
			break;

		case GSS_S_DUPLICATE_TOKEN:
			errStr = _("The token was a duplicate of an earlier "
				   "token");
			break;

		case GSS_S_OLD_TOKEN:
			errStr = _("The token's validity period has expired");
			break;

		case GSS_S_UNSEQ_TOKEN:
			errStr = _("A later token has already been processed");
			break;

		case GSS_S_GAP_TOKEN:
			errStr = _("An expected per-message token was not "
				   "received");
			break;

		default:
			errStr = _("An invalid status code was supplied");
		}

		/*
		 * we must check if there is any other supplementary errors
		 * if found, then turn off current bit, and store next value
		 * in msgCtxt shifted by 1 bit
		 */
		if (!haveErr)
			*msgCtxt = 0;
		else if (GSS_SUPPLEMENTARY_INFO(oneVal) ^ mask)
			*msgCtxt = (OM_uint32)
				((GSS_SUPPLEMENTARY_INFO(oneVal) ^ mask) << 1);
		else
			*msgCtxt = 0;
	}

	if (errStr == NULL)
		errStr = "An invalid status code was supplied";

	/* now copy the status code and return to caller */
	outStr->length = strlen(errStr);
	outStr->value = gssalloc_strdup(errStr);
	if (outStr->value == NULL) {
		outStr->length = 0;
		return (GSS_S_FAILURE);
	}

	return (GSS_S_COMPLETE);
} /* displayMajor */