DataMuseum.dk

top - metrics - download

    Length: 17772 (0x456c)
    Types: TextFile
    Names: »mindicate.c«

└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
    └─⟦e83f91978⟧ »EurOpenD22/isode/osimis-2.0.tar.Z« 
        └─⟦d846658bd⟧ 
            └─⟦this⟧ »osimis/msap/mindicate.c« 

TextFile

/*
 * Copyright (c) 1988 University College London
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the Department of Computer Science, University College London.
 * The name of the University may not be used to
 * endorse or promote products derived from this software without
 * specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/* Routines to realise the M-XXX.indication primitives */

/*
 * By George Pavlou, April 1990
 */

#include <stdio.h>
#include "isode/rosap.h"
#include "msap.h"

#define NULLOP	((struct RoSAPinvoke *) 0)
#define NULLRES	((struct RoSAPresult *) 0)
#define NULLERR	((struct RoSAPerror *) 0)

static int  eventrepind(), linkedreplyind(), getind(), setind(),
	    actionind(), createind(), deleteind();
static int  eventrepres(), getres(), setres(), actionres(),
	    createres(), deleteres(), merror();
static int  parsefail(), rosfail();


/* LINTLIBRARY */

int  M_WaitReq (msd, secs, mi)
int msd, secs;
struct MSAPindication * mi;
{
    struct RoSAPindication rois;
    (void) RoWaitRequest(msd, secs, &rois);
    switch (rois.roi_type) {
    case ROI_PREJECT:
	return rosfail(&rois.roi_preject, mi);

    case ROI_FINISH:
	mi->mi_type = MI_TERM;
	mi->mi_term.mt_reason = rois.roi_finish.acf_reason;
	ACFFREE(&rois.roi_finish);
	return OK;

    case ROI_INVOKE:
	switch (rois.roi_invoke.rox_op) {
	case M_EVENT_REP:
	    mi->mi_type = MI_EVENT_REP;
	    return eventrepind(&rois.roi_invoke, mi);
	case M_EVENT_REPC:
	    mi->mi_type = MI_EVENT_REPC;
	    return eventrepind(&rois.roi_invoke, mi);
	case M_LINKED_REPLY:
	    mi->mi_type = MI_LINKED_REPLY;
	    return linkedreplyind(&rois.roi_invoke, mi);
	case M_GET:
	    mi->mi_type = MI_GET;
	    return getind(&rois.roi_invoke, mi);
	case M_SET:
	    mi->mi_type = MI_SET;
	    return setind(&rois.roi_invoke, mi);
	case M_SETC:
	    mi->mi_type = MI_SETC;
	    return setind(&rois.roi_invoke, mi);
	case M_ACTION:
	    mi->mi_type = MI_ACTION;
	    return actionind(&rois.roi_invoke, mi);
	case M_ACTIONC:
	    mi->mi_type = MI_ACTIONC;
	    return actionind(&rois.roi_invoke, mi);
	case M_CREATE:
	    mi->mi_type = MI_CREATE;
	    return createind(&rois.roi_invoke, mi);
	case M_DELETE:
	    mi->mi_type = MI_DELETE;
	    return deleteind(&rois.roi_invoke, mi);
	default:
	    mi->mi_type = MI_PREJECT;
	    mi->mi_preject.mr_reason = MI_UNKNOWN;
	    (void) strncpy(mi->mi_preject.mr_data,
				"Unknown Operation", MR_SIZE);
	    return NOTOK;
	}

    case ROI_RESULT:
	switch (rois.roi_result.ror_op) {
	case M_EVENT_REPC:
	    mi->mi_type = MI_EVENT_REP_RES;
	    return eventrepres(&rois.roi_result, mi);
	case M_GET:
	    mi->mi_type = MI_GET_RES;
	    return getres(&rois.roi_result, mi);
	case M_SETC:
	    mi->mi_type = MI_SET_RES;
	    return setres(&rois.roi_result, mi);
	case M_ACTIONC:
	    mi->mi_type = MI_ACTION_RES;
	    return actionres(&rois.roi_result, mi);
	case M_CREATE:
	    mi->mi_type = MI_CREATE_RES;
	    return createres(&rois.roi_result, mi);
	case M_DELETE:
	    mi->mi_type = MI_DELETE_RES;
	    return deleteres(&rois.roi_result, mi);
	default:
	    mi->mi_type = MI_PREJECT;
	    mi->mi_preject.mr_reason = MI_UNKNOWN;
	    (void) strncpy(mi->mi_preject.mr_data,
				"Unknown Result", MR_SIZE);
	    return NOTOK;
	}

    case ROI_ERROR:
	mi->mi_type = MI_ERROR;
	return merror(&rois.roi_error, mi);

    default:
	mi->mi_type = MI_PREJECT;
	mi->mi_preject.mr_reason = MI_UNKNOWN;
	(void) strncpy( mi->mi_preject.mr_data, "Unknown indication \
returned by RoWaitReq", MR_SIZE);
	return NOTOK;
    }
}


static int  eventrepind (op, mi)
struct RoSAPinvoke * op;
struct MSAPindication * mi;
{
    mi->mi_eventrepv.id = op->rox_id;
    mi->mi_eventrepv.args.ea_time = NULLCP;
    mi->mi_eventrepv.args.ea_info = NULLPE;
    if (parse_CMIP_EventReportArgument(op->rox_args, 1,
		NULLIP, NULLVP, &mi->mi_eventrepv.args) == NOTOK)
	return parsefail("EventReportArgument", op, NULLRES, NULLERR, mi);
    ROXFREE(op);
    return OK;
}


static int  linkedreplyind (op, mi)
struct RoSAPinvoke * op;
struct MSAPindication * mi;
{
    (void) bzero((char *) &mi->mi_linkedreplyv.args,
					sizeof mi->mi_linkedreplyv.args);
    mi->mi_linkedreplyv.id = op->rox_id;
    if (parse_CMIP_LinkedReplyArgument(op->rox_args, 1,
		NULLIP, NULLVP, &mi->mi_linkedreplyv.args) == NOTOK)
	return parsefail("EventReportArgument", op, NULLRES, NULLERR, mi);
    ROXFREE(op);
    return OK;
}


static int  getind (op, mi)
struct RoSAPinvoke * op;
struct MSAPindication * mi;
{
    mi->mi_getv.id = op->rox_id;
    mi->mi_getv.args.ga_access = NULL;
    mi->mi_getv.args.ga_sync = s_bestEffort;
    mi->mi_getv.args.ga_scope.sc_type = Sc_BaseObject;
    mi->mi_getv.args.ga_filter = NULLFILTER;
    mi->mi_getv.args.ga_nattrs = 0;
    if (parse_CMIP_GetArgument(op->rox_args, 1, NULLIP, NULLVP,
				&mi->mi_getv.args)
	    == NOTOK)
	return parsefail("GetArgument", op, NULLRES, NULLERR, mi);
    ROXFREE(op);
    return OK;
}


static int  setind (op, mi)
struct RoSAPinvoke * op;
struct MSAPindication * mi;
{
    register int i;
    mi->mi_setv.id = op->rox_id;
    mi->mi_setv.args.sa_access = NULL;
    mi->mi_setv.args.sa_sync = s_bestEffort;
    mi->mi_setv.args.sa_scope.sc_type = Sc_BaseObject;
    mi->mi_setv.args.sa_filter = NULLFILTER;
    for (i = 0; i < M_MAXATTRS; i++) {
	mi->mi_setv.args.sa_attrs[i].mp_val = NULLPE;
	mi->mi_setv.args.sa_attrs[i].mp_modify = m_replace;
    }
    if (parse_CMIP_SetArgument(op->rox_args, 1, NULLIP, NULLVP,
				&mi->mi_setv.args)
		== NOTOK)
	return parsefail("SetArgument", op, NULLRES, NULLERR, mi);
    ROXFREE(op);
    return OK;
}


static int  actionind (op, mi)
struct RoSAPinvoke * op;
struct MSAPindication * mi;
{
    mi->mi_actionv.id = op->rox_id;
    mi->mi_actionv.args.aa_access = NULL;
    mi->mi_actionv.args.aa_sync = s_bestEffort;
    mi->mi_actionv.args.aa_scope.sc_type = Sc_BaseObject;
    mi->mi_actionv.args.aa_filter = NULLFILTER;
    if (parse_CMIP_ActionArgument(op->rox_args, 1,
			NULLIP, NULLVP, &mi->mi_actionv.args) == NOTOK)
	return parsefail("ActionArgument", op, NULLRES, NULLERR, mi);
    ROXFREE(op);
    return OK;
}


static int  createind (op, mi)
struct RoSAPinvoke * op;
struct MSAPindication * mi;
{
    mi->mi_createv.id = op->rox_id;
    mi->mi_createv.args.ca_instype = CA_OBJECT_INST;
    mi->mi_createv.args.ca_inst.mn_type = MN_DN;
    mi->mi_createv.args.ca_inst.mn_dn = NULLDN;
    mi->mi_createv.args.ca_access = NULL;
    mi->mi_createv.args.ca_refinst.mn_type = MN_DN;
    mi->mi_createv.args.ca_refinst.mn_dn = NULLDN;
    mi->mi_createv.args.ca_nattrs = 0;
    if (parse_CMIP_CreateArgument(op->rox_args, 1,
			NULLIP, NULLVP, &mi->mi_createv.args) == NOTOK)
	return parsefail("CreateArgument", op, NULLRES, NULLERR, mi);
    ROXFREE(op);
    return OK;
}


static int  deleteind (op, mi)
struct RoSAPinvoke * op;
struct MSAPindication * mi;
{
    mi->mi_deletev.id = op->rox_id;
    mi->mi_deletev.args.da_access = NULL;
    mi->mi_deletev.args.da_sync = s_bestEffort;
    mi->mi_deletev.args.da_scope.sc_type = Sc_BaseObject;
    mi->mi_deletev.args.da_filter = NULLFILTER;
    if (parse_CMIP_DeleteArgument(op->rox_args, 1,
			NULLIP, NULLVP, &mi->mi_deletev.args) == NOTOK)
	return parsefail("DeleteArgument", op, NULLRES, NULLERR, mi);
    ROXFREE(op);
    return OK;
}


static int  eventrepres (res, mi)
struct RoSAPresult * res;
struct MSAPindication * mi;
{
    mi->mi_eventrepr.id = res->ror_id;
    mi->mi_eventrepr.result.er_class.mid_type = MID_GLOBAL;
    mi->mi_eventrepr.result.er_class.mid_global = NULLOID;
    mi->mi_eventrepr.result.er_inst.mn_type = MN_DN;
    mi->mi_eventrepr.result.er_inst.mn_dn = NULLDN;
    mi->mi_eventrepr.result.er_time = NULLCP;
    mi->mi_eventrepr.result.er_reply.mp_id.mid_type = MID_GLOBAL;
    mi->mi_eventrepr.result.er_reply.mp_id.mid_global = NULLOID;
    mi->mi_eventrepr.result.er_reply.mp_val = NULLPE;
    if (parse_CMIP_EventReportResult(res->ror_result, 1,
			NULLIP, NULLVP, &mi->mi_eventrepr.result) == NOTOK)
	return parsefail("EventReportResult", NULLOP, res, NULLERR, mi);
    RORFREE(res);
    return OK;
}


static int  getres (res, mi)
struct RoSAPresult * res;
struct MSAPindication * mi;
{
    register int i;
    mi->mi_getr.id = res->ror_id;
    mi->mi_getr.result.gr_class.mid_type = MID_GLOBAL;
    mi->mi_getr.result.gr_class.mid_global = NULLOID;
    mi->mi_getr.result.gr_inst.mn_type = MN_DN;
    mi->mi_getr.result.gr_inst.mn_dn = NULLDN;
    mi->mi_getr.result.gr_time = NULLCP;
    mi->mi_getr.result.gr_nattrs = 0;
    for (i = 0; i < M_MAXATTRS; i++)
	mi->mi_getr.result.gr_attrs[i].mp_error = m_noError;
    if (parse_CMIP_GetResult(res->ror_result, 1,
			NULLIP, NULLVP, &mi->mi_getr.result) == NOTOK)
	return parsefail("GetResult", NULLOP, res, NULLERR, mi);
    RORFREE(res);
    return OK;
}


static int  setres (res, mi)
struct RoSAPresult * res;
struct MSAPindication * mi;
{
    register int i;
    mi->mi_setr.id = res->ror_id;
    mi->mi_setr.result.sr_class.mid_type = MID_GLOBAL;
    mi->mi_setr.result.sr_class.mid_global = NULLOID;
    mi->mi_setr.result.sr_inst.mn_type = MN_DN;
    mi->mi_setr.result.sr_inst.mn_dn = NULLDN;
    mi->mi_setr.result.sr_time = NULLCP;
    mi->mi_setr.result.sr_nattrs = 0;
    for (i = 0; i < M_MAXATTRS; i++)
	mi->mi_setr.result.sr_attrs[i].mp_error = m_noError;
    if (parse_CMIP_SetResult(res->ror_result, 1,
			NULLIP, NULLVP, &mi->mi_setr.result) == NOTOK)
	return parsefail("SetResult", NULLOP, res, NULLERR, mi);
    RORFREE(res);
    return OK;
}


static int  actionres (res, mi)
struct RoSAPresult * res;
struct MSAPindication * mi;
{
    mi->mi_actionr.id = res->ror_id;
    mi->mi_actionr.result.ar_class.mid_type = MID_GLOBAL;
    mi->mi_actionr.result.ar_class.mid_global = NULLOID;
    mi->mi_actionr.result.ar_inst.mn_type = MN_DN;
    mi->mi_actionr.result.ar_inst.mn_dn = NULLDN;
    mi->mi_actionr.result.ar_time = NULLCP;
    mi->mi_actionr.result.ar_reply.mp_id.mid_type = MID_GLOBAL;
    mi->mi_actionr.result.ar_reply.mp_id.mid_global = NULLOID;
    mi->mi_actionr.result.ar_reply.mp_val = NULLPE;
    if (parse_CMIP_ActionResult(res->ror_result, 1,
			NULLIP, NULLVP, &mi->mi_actionr.result) == NOTOK)
	return parsefail("ActionResult", NULLOP, res, NULLERR, mi);
    RORFREE(res);
    return OK;
}


static int  createres (res, mi)
struct RoSAPresult * res;
struct MSAPindication * mi;
{
    mi->mi_creater.id = res->ror_id;
    mi->mi_creater.result.cr_class.mid_type = MID_GLOBAL;
    mi->mi_creater.result.cr_class.mid_global = NULLOID;
    mi->mi_creater.result.cr_inst.mn_type = MN_DN;
    mi->mi_creater.result.cr_inst.mn_dn = NULLDN;
    mi->mi_creater.result.cr_time = NULLCP;
    mi->mi_creater.result.cr_nattrs = 0;
    if (parse_CMIP_CreateResult(res->ror_result, 1,
			NULLIP, NULLVP, &mi->mi_creater.result) == NOTOK)
	return parsefail("CreateResult", NULLOP, res, NULLERR, mi);
    RORFREE(res);
    return OK;
}


static int  deleteres (res, mi)
struct RoSAPresult * res;
struct MSAPindication * mi;
{
    mi->mi_deleter.id = res->ror_id;
    mi->mi_deleter.result.dr_class.mid_type = MID_GLOBAL;
    mi->mi_deleter.result.dr_class.mid_global = NULLOID;
    mi->mi_deleter.result.dr_inst.mn_type = MN_DN;
    mi->mi_deleter.result.dr_inst.mn_dn = NULLDN;
    mi->mi_deleter.result.dr_time = NULLCP;
    if (parse_CMIP_DeleteResult(res->ror_result, 1,
			NULLIP, NULLVP, &mi->mi_deleter.result) == NOTOK)
	return parsefail("DeleteResult", NULLOP, res, NULLERR, mi);
    RORFREE(res);
    return OK;
}


static int  merror (err, mi)
struct RoSAPerror * err;
struct MSAPindication * mi;
{
    (void) bzero((char *) &mi->mi_error.info, sizeof mi->mi_error.info);

    switch (mi->mi_errtype = (CMISerrors) (err->roe_error+1)) {
    case m_noSuchObjectClass:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_ObjectClass(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info.me_class) == NOTOK)
	    return parsefail("ObjectClass", NULLOP, NULLRES, err, mi);
	break;

    case m_noSuchObjectInstance:
    case m_duplicateManagedObjectInstance:
    case m_noSuchReferenceObject:
    case m_invalidObjectInstance:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_ObjectInstance(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info.me_inst) == NOTOK)
	    return parsefail("ObjectInstance", NULLOP, NULLRES, err, mi);
	break;

    case m_accessDenied:
    case m_invalidOperation:
	mi->mi_error.id = err->roe_id;
	break;

    case m_syncNotSupported:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_CMISSync(err->roe_param, 1, NULLIP, NULLVP,
			(int *) &mi->mi_error.info.me_sync) == NOTOK)
	    return parsefail("CMISSync", NULLOP, NULLRES, err, mi);
	break;

    case m_invalidFilter:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_CMISFilter(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info.me_filter) == NOTOK)
	    return parsefail("CMISFilter", NULLOP, NULLRES, err, mi);
	break;

    case m_noSuchAttribute:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_AttributeId(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info.me_id) == NOTOK)
	    return parsefail("AttributeId", NULLOP, NULLRES, err, mi);
	break;

    case m_invalidAttributeValue:
	mi->mi_error.id = err->roe_id;
	{
	CMISparam attr;
	if (parse_CMIP_Attribute(err->roe_param, 1, NULLIP, NULLVP,
			&attr) == NOTOK)
	    return parsefail("Attribute", NULLOP, NULLRES, err, mi);
	mi -> mi_error.info.me_id  = attr.mp_id;	/* struct copy */
	mi -> mi_error.info.me_val = attr.mp_val;
	}
	break;

    case m_getListError:
	mi->mi_getr.id = err->roe_id;
	if (parse_CMIP_GetListError(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_getr.result) == NOTOK)
	    return parsefail("GetListError", NULLOP, NULLRES, err, mi);
	break;

    case m_setListError:
	mi->mi_setr.id = err->roe_id;
	if (parse_CMIP_SetListError(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_setr.result) == NOTOK)
	    return parsefail("SetListError", NULLOP, NULLRES, err, mi);
	break;

    case m_noSuchAction:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_NoSuchAction(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info) == NOTOK)
	    return parsefail("NoSuchAction", NULLOP, NULLRES, err, mi);
	break;

    case m_processingFailure:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_ProcessingFailure(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info) == NOTOK)
	    return parsefail("ProcessingFailure", NULLOP, NULLRES, err, mi);
	break;

    case m_noSuchEventType:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_NoSuchEventType(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info) == NOTOK)
	    return parsefail("NoSuchEventType", NULLOP, NULLRES, err, mi);
	break;

    case m_noSuchArgument:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_NoSuchArgument(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info) == NOTOK)
	    return parsefail("NoSuchArgument", NULLOP, NULLRES, err, mi);
	break;

    case m_invalidArgumentValue:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_InvalidArgumentValue(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info) == NOTOK)
	    return parsefail("InvalidArgumentValue", NULLOP, NULLRES, err, mi);
	break;

    case m_invalidScope:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_Scope(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info.me_scope) == NOTOK)
	    return parsefail("Scope", NULLOP, NULLRES, err, mi);
	break;

    case m_missingAttributeValue:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_AttributeIdList(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info.me_id) == NOTOK)
	    return parsefail("AttributeIdList", NULLOP, NULLRES, err, mi);
	break;

    case m_classInstanceConflict:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_BaseManagedObjectId(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info) == NOTOK)
	    return parsefail("BaseManagedObjectId", NULLOP, NULLRES, err, mi);
	break;
	
    case m_complexityLimitation:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_ComplexityLimitation(err->roe_param, 1, NULLIP, NULLVP,
			&mi->mi_error.info) == NOTOK)
	    return parsefail("ComplexityLimitation", NULLOP, NULLRES, err, mi);
	break;
	
    case m_invalidOperator:
	mi->mi_error.id = err->roe_id;
	if (parse_CMIP_ModifyOperator(err->roe_param, 1, NULLIP, NULLVP,
			(int*) &mi->mi_error.info.me_modify) == NOTOK)
	    return parsefail("ModifyOperator", NULLOP, NULLRES, err, mi);
	break;
	
    default:
	(void) fprintf(stderr, "Invalid Error Type: %d\n", mi->mi_errtype);
	return NOTOK;
    }
    ROEFREE(err);
    return OK;
}


static int  parsefail (s, op, res, err, mi)
char * s;
struct RoSAPinvoke * op;
struct RoSAPresult * res;
struct RoSAPerror * err;
struct MSAPindication * mi;
{
    mi->mi_preject.mr_id = mi->mi_getv.id;
    mi->mi_type = MI_PREJECT;
    mi->mi_preject.mr_reason = MA_BADARGS;
    (void) sprintf(mi->mi_preject.mr_data, "%.*s: Badly formed packet received",
	MR_SIZE-35, s);
    if (op)
	ROXFREE(op)
    else
    if (res)
	RORFREE(res)
    else
    if (err)
	ROEFREE(err);
    return NOTOK;
}


static int  rosfail (rpp, mi)
struct RoSAPpreject * rpp;
struct MSAPindication * mi;
{
    mi->mi_type = MI_PREJECT;
    mi->mi_preject.mr_reason = rpp->rop_reason;
    mi->mi_preject.mr_id = rpp->rop_id;
    (void) strncpy(mi->mi_preject.mr_data, rpp->rop_data, MR_SIZE);
    ROPFREE(rpp);
    return NOTOK;
}