⟦fd061fae7⟧

TextFile

/* ds_inv.c - Invoke Directory Operations */

#ifndef lint
static char *rcsid = "$Header: /f/osi/dsap/net/RCS/ds_inv.c,v 7.0 89/11/23 21:48:13 mrose Rel $";
#endif

/*
 * $Header: /f/osi/dsap/net/RCS/ds_inv.c,v 7.0 89/11/23 21:48:13 mrose Rel $
 *
 *
 * $Log:	ds_inv.c,v $
 * Revision 7.0  89/11/23  21:48:13  mrose
 * Release 6.0
 * 
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include "rosap.h"
#include "quipu/util.h"
#include "quipu/connection.h"

extern  LLog    * log_dsap;
extern  int       dsap_ad;      /* Association descriptor */
extern  int       dsap_id;      /* Last id sent */
extern  char    * dsa_address;  /* address of default dsa */
void ros_log ();

#ifdef PDU_DUMP
#define DUMP_ARG 	"arg"
#define DUMP_RES 	"res"
#define DUMP_ERR 	"err"
#endif

ds_invoke(op, pe, resp_type, resp_pe)
int             op;
PE              pe;
int             *resp_type;
PE              *resp_pe;
{
    DLOG(log_dsap, LLOG_FATAL, ("Better have a good reason for using ds_invoke"));
    return(dap_invoke(dsap_ad, &(dsap_id), op, pe, resp_type, resp_pe));
}

dap_invoke(ad, id, op, pe, resp_type, resp_pe)
int		  ad;
int		* id;
int               op;
PE                pe;
int             * resp_type;
PE              * resp_pe;
{
    struct RoSAPindication      roi_s;
    struct RoSAPindication      *roi = &roi_s;
    struct RoSAPpreject         *rop = &(roi->roi_preject);
    int                         inv_ret;

    ++(*id);

    DLOG(log_dsap, LLOG_TRACE, ("dap_invoke(ad,id,op, ...) <%d,%d,%d, ...>", ad, (*id), op));

#ifdef PDU_DUMP
    pdu_dump (pe,DUMP_ARG,op);
#endif

#ifdef	HEAVY_DEBUG
    /* PDU Level Logging */
    switch (op) {
	case OP_READ:
	    PLOG (log_dsap, print_DAS_ReadArgument, pe, "Read", 0);
	    break;
	case OP_COMPARE:
	    PLOG (log_dsap, print_DAS_CompareArgument, pe, "Compare", 0);
	    break;
	case OP_ABANDON:
	    PLOG (log_dsap, print_DAS_AbandonArgument, pe, "Abandon", 0);
	    break;
	case OP_LIST:
	    PLOG (log_dsap, print_DAS_ListArgument, pe, "List", 0);
	    break;
	case OP_SEARCH:
	    PLOG (log_dsap, print_DAS_SearchArgument, pe, "Search", 0);
	    break;
	case OP_ADDENTRY:
	    PLOG (log_dsap, print_DAS_AddEntryArgument, pe, "AddEntry", 0);
	    break;
	case OP_REMOVEENTRY:
	    PLOG (log_dsap, print_DAS_RemoveEntryArgument, pe, "RemoveEntry", 0);
	    break;
	case OP_MODIFYENTRY:
	    PLOG (log_dsap, print_DAS_ModifyEntryArgument, pe, "ModifyEntry", 0);
	    break;
	case OP_MODIFYRDN:
	    PLOG (log_dsap, print_DAS_ModifyRDNArgument, pe, "ModifyRDN", 0);
	    break;
	case OP_GETEDB:
	    PLOG (log_dsap, print_Quipu_GetEntryDataBlockArgument, pe, "GetEDB", 0);
	    break;
	default:
		LLOG (log_dsap, LLOG_PDUS, ("Unknown operation (%d) - no argument PDU dump",op));
    }
#endif

    *resp_type = 0;
    inv_ret = RoIntrRequest(ad,op,pe,(*id),NULLIP,ROS_NOPRIO,roi);

    pe_free (pe);

    DLOG(log_dsap, LLOG_NOTICE, ("RoIntrReq: returned %d", inv_ret));

    switch(inv_ret)
    {
    case OK:
	DLOG(log_dsap, LLOG_TRACE, ("ds_invoke() : RoInvokeRequest OK"));
	switch(roi->roi_type)
	{
	case ROI_RESULT:
	    if(roi->roi_result.ror_id != (*id))
	    {
		LLOG(log_dsap, LLOG_EXCEPTIONS, ("RoIntrReq returned event for id other than that requested"));
	    }
	    *resp_type = op;
	    *resp_pe = roi->roi_result.ror_result;
#ifdef PDU_DUMP
	    pdu_dump (*resp_pe,DUMP_RES,op);
#endif
#ifdef	HEAVY_DEBUG
	    /* PDU Level Logging */
	    switch (op) {
		case OP_READ:
		    PLOG (log_dsap, print_DAS_ReadResult, *resp_pe, "Read", 1);
		    break;
		case OP_COMPARE:
		    PLOG (log_dsap, print_DAS_CompareResult, *resp_pe, "Compare", 1);
		    break;
		case OP_ABANDON:
		    PLOG (log_dsap, print_DAS_AbandonResult, *resp_pe, "Abandon", 1);
		    break;
		case OP_LIST:
		    PLOG (log_dsap, print_DAS_ListResult, *resp_pe, "List", 1);
		    break;
		case OP_SEARCH:
		    PLOG (log_dsap, print_DAS_SearchResult, *resp_pe, "Search", 1);
		    break;
		case OP_ADDENTRY:
		    PLOG (log_dsap, print_DAS_AddEntryResult, *resp_pe, "AddEntry", 1);
		    break;
		case OP_REMOVEENTRY:
		    PLOG (log_dsap, print_DAS_RemoveEntryResult, *resp_pe, "RemoveEntry",1);
		    break;
		case OP_MODIFYENTRY:
		    PLOG (log_dsap, print_DAS_ModifyEntryResult, *resp_pe, "ModifyEntry",1);
		    break;
		case OP_MODIFYRDN:
		    PLOG (log_dsap, print_DAS_ModifyRDNResult, *resp_pe, "ModifyRDN", 1);
		    break;
		case OP_GETEDB:
		    PLOG (log_dsap, print_Quipu_GetEntryDataBlockResult, *resp_pe, "GetEDB", 1);
		    break;
		default:
		    LLOG (log_dsap, LLOG_PDUS, ("Unknown operation (%d) - no result PDU dump",op));
	    }
#endif
	    return(DS_OK);

	case ROI_ERROR:
	    if(roi->roi_error.roe_id != (*id))
	    {
		LLOG(log_dsap, LLOG_EXCEPTIONS, ("RoIntrReq returned event for id other than that requested"));
	    }
	    *resp_type = roi->roi_error.roe_error;
	    *resp_pe = roi->roi_error.roe_param;
#ifdef PDU_DUMP
	    pdu_dump (*resp_pe,DUMP_ERR,op);
#endif
	    /* PLOG (log_dsap, print_OPError, *resp_pe, "OperationError", 1); */
	    return(DS_ERROR_REMOTE);

	default:
	    LLOG(log_dsap, LLOG_FATAL, ("Unknown roi_type : %d", roi->roi_type));
	    return(DS_ERROR_PROVIDER);
	}

    case NOTOK:
	ros_log(rop, "RO-INVOKE.REQUEST");
	if(ROS_FATAL(rop->rop_reason) || (rop->rop_reason == ROS_PARAMETER))
	{
	    LLOG(log_dsap, LLOG_FATAL, ("RoIntr fatal PReject"));
	}
	if ((*resp_type = rop->rop_reason) == ROS_INTERRUPTED) {
	    return(attempt_abandon(ad, id, op, resp_pe, resp_type));
	}
	return(DS_ERROR_PROVIDER);

    case DONE:
	/*
	* Assume A-RELEASE.INDICATION since RO-END.INDICATION is obsolete.
	*/
	LLOG(log_dsap, LLOG_EXCEPTIONS, ("Responder has sent Finish!"));
	return(DS_ERROR_PROVIDER);

    default:
	LLOG(log_dsap, LLOG_FATAL, ("Unknown return from RoInvokeRequest : %d", inv_ret));

    }

    return(DS_ERROR_PROVIDER);
}


#ifdef PDU_DUMP

static int pdu_count = -1;
static char * pdu_dir = NULLCP;

pdu_dump_init (dir)
char * dir;
{
	pdu_count = 0;
	pdu_dir = strdup (dir);
	LLOG (log_dsap, LLOG_NOTICE, ("PDU Tracing enabled - %s",dir));
	
	(void) mkdir (pdu_dir,0755);
}

pdu_dump (pe,type,op)
PE pe;
char * type;
int op;
{
char filename [BUFSIZE];
char * oper;
PS ps;
FILE * fptr;

	if ( pdu_count == -1)
		return;

	if (strcmp (type,DUMP_ARG) == 0)
		pdu_count++;

	switch (op) {
		case OP_READ:
			oper = "read";
			break;
		case OP_COMPARE:
			oper = "compare";
			break;
		case OP_ABANDON:	/* Humm ... */
			oper = "abandon";
			break;
		case OP_LIST:
			oper = "list";
			break;
		case OP_SEARCH:
			oper = "search";
			break;
		case OP_ADDENTRY:
			oper = "add";
			break;
		case OP_REMOVEENTRY:
			oper = "remove";
			break;
		case OP_MODIFYENTRY:
			oper = "modify";
			break;
		case OP_MODIFYRDN:
			oper = "modifyrdn";
			break;
		case OP_GETEDB:
			oper = "getedb";
			break;
		case 100:	/* special case for bind */
			oper = "bind";
			break;
	}

	(void) sprintf (filename, "%s/%s_%s.%d",pdu_dir,oper,type,pdu_count);
	DLOG (log_dsap,LLOG_DEBUG,("Writing PDU to file %s",filename));

	if ((fptr = fopen (filename,"w")) == (FILE *) NULL) {
		LLOG(log_dsap,LLOG_EXCEPTIONS,("Cant open PDU file %s",filename));
		return;
	}

	ps = ps_alloc (std_open);
	if (std_setup (ps,fptr) != OK) {
		(void) fclose (fptr);
		return;
	}
		
	(void) pe2pl (ps,pe);

	(void) fclose (fptr);
	ps_free (ps);
}
#endif
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦fd061fae7⟧ TextFile

Derivation

TextFile
