dapinvoke.c

来自「ftam等标准协议服务器和客户端的源代码。」· C语言 代码 · 共 708 行 · 第 1/2 页

		        if(roi1->roi_error.roe_id == old_id)
		        {
			    /* Ferret error away for later */
			    result_roi = roi1;
		        }
		        else if(roi1->roi_error.roe_id == (old_id + 1))
		        {
			    if (roi1->roi_error.roe_error != DSE_ABANDON_FAILED)
			    {
				LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to abandon correctly"));
				return(dapreject (di, DP_INVOKE, roi1->roi_error.roe_id, NULLCP, "Error mistyped for abandon"));
			    }
			    else
			    {
				struct DSE_abandon_fail * af;
			        if(decode_DAS_AbandonFailedParm (roi1->roi_error.roe_param, 1, NULLIP, NULLVP, &af) != OK)
				{
				    LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to decode abandonFailed"));
				    return(dapreject (di, DP_INVOKE, old_id, NULLCP, "Abandon error decoding failed"));
				}
				else
				{
				    LLOG(log_dsap, LLOG_NOTICE, ("Abandon failed error!!!"));
				    ab_err.dse_un.dse_un_abandon_fail = *af; /* struct copy */
				    free ((char *)af);
				    ab_err.dse_type = DSE_ABANDON_FAILED;
				    log_ds_error(&ab_err);
				    ds_error_free(&ab_err);
				}
			    }
		        }
		        else
		        {
			    LLOG(log_dsap, LLOG_EXCEPTIONS, ("Abandon sent : event for neither op nor abandon op returned!!"));
			    return(dapreject (di, DP_INVOKE, roi1->roi_error.roe_id, NULLCP, "Unrecognised op id"));
		        }
		        break;

		    default:
		        LLOG(log_dsap, LLOG_FATAL, ("Unexpected roi_type : %d", roi1->roi_type));
		        return(dapreject (di, DP_INVOKE, -1, NULLCP, "Unrecognised event"));
		}
	        break;

	    case NOTOK:
		ros_log(rop1, "RO-INVOKE.REQUEST");
		if (ROS_FATAL (rop2->rop_reason))
		{
		    return (ros2daplose (di, "DapInterrupt", rop2));
		}
		else
		{
		    return (dapreject (di, DP_ROS, -1, NULLCP, "DapInterrupt: Non-fatal reject"));
		}

	    case DONE:
		LLOG(log_dsap, LLOG_EXCEPTIONS, ("Responder has sent Finish!"));
		return(daplose (di, DP_ROS, NULLCP, "Received Finish"));

            default:
		LLOG(log_dsap, LLOG_FATAL, ("Unknown return from RoInvokeRequest : %d", ret1));
		return(daplose (di, DP_ROS, NULLCP, "RoInvokeRequest error"));
        }

	ret2 = RoWaitRequest(sd, NOTOK, roi2);

	DLOG(log_dsap, LLOG_DEBUG, ("Abandon RoInvoke returns: %d", ret1));

	switch(ret2)
	{
	    case OK:
	    /* What have we got? */
		switch(roi2->roi_type)
		{
		    case ROI_RESULT:
		        if(roi2->roi_result.ror_id == old_id)
		        {
			    /* Ferret result away for later */
			    result_roi = roi2;
		        }
		        else if(roi2->roi_result.ror_id == (old_id + 1))
		        {
			    RORFREE (&(roi2->roi_result));
		        }
		        else
		        {
			    LLOG(log_dsap, LLOG_EXCEPTIONS, ("ARRGH! Abandon sent and event for neither op nor abandon op returned!!"));
			    return(dapreject (di, DP_INVOKE, roi1->roi_result.ror_id, NULLCP, "Unexpected operation identifier"));
		        }
		        break;

		    case ROI_ERROR:
#ifdef PDU_DUMP
	    pdu_dump (roi1->roi_error.roe_param,DUMP_ERR,op);
#endif

		        if(roi2->roi_error.roe_id == old_id)
		        {
			    /* Ferret error away for later */
			    result_roi = roi2;
		        }
		        else if(roi2->roi_error.roe_id == (old_id + 1))
		        {
			    if (roi2->roi_error.roe_error != DSE_ABANDON_FAILED)
			    {
				LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to abandon correctly"));
				return(dapreject (di, DP_INVOKE, roi2->roi_error.roe_id, NULLCP, "Error mistyped for abandon"));
			    }
			    else
			    {
				
				struct DSE_abandon_fail * af;
			        if(decode_DAS_AbandonFailedParm (roi2->roi_error.roe_param, 1, NULLIP, NULLVP, &af) != OK)
				{
				    LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to decode abandonFailed"));
				    return(dapreject (di, DP_INVOKE, old_id, NULLCP, "Abandon error decoding failed"));
				}
				else
				{
				    LLOG(log_dsap, LLOG_NOTICE, ("Abandon failed error!!!"));
				    ab_err.dse_un.dse_un_abandon_fail = *af; /*struct copy */
				    free ((char *) af);
				    ab_err.dse_type = DSE_ABANDON_FAILED;
				    log_ds_error(&ab_err);
				    ds_error_free(&ab_err);
				}
			    }
		        }
		        else
		        {
			    LLOG(log_dsap, LLOG_EXCEPTIONS, ("Abandon sent : event for neither op nor abandon op returned!!"));
			    return(dapreject (di, DP_INVOKE, roi1->roi_error.roe_id, NULLCP, "Unrecognised op id"));
		        }
		        break;

		    default:
		        LLOG(log_dsap, LLOG_FATAL, ("Unexpected roi_type : %d", roi2->roi_type));
		        return(dapreject (di, DP_INVOKE, -1, NULLCP, "Unrecognised event"));
		}
		break;

	    case NOTOK:
		ros_log(rop2, "RO-WAIT.REQUEST (Abandon)");
		if (ROS_FATAL (rop1->rop_reason))
		{
		    return (ros2daplose (di, "DapInterrupt", rop2));
		}
		else
		{
		    return (dapreject (di, DP_ROS, -1, NULLCP, "DapInterrupt: Non-fatal reject"));
		}

	    case DONE:
		LLOG(log_dsap, LLOG_EXCEPTIONS, ("Responder has sent Finish!"));
		return(daplose (di, DP_ROS, NULLCP, "Received Finish"));

            default:
		LLOG(log_dsap, LLOG_FATAL, ("Unknown return from RoInvokeRequest : %d", ret2));
		return(daplose (di, DP_ROS, NULLCP, "RoInvokeRequest error"));
        }
    }

    switch(result_roi->roi_type)
    {
	case ROI_RESULT:
	    return (DapDecodeResult (sd, &(result_roi->roi_result), di));

	case ROI_ERROR:
	    return (DapDecodeError (sd, &(result_roi->roi_error), di));

	default:
	    return (dapreject (di, DP_ROS, old_id, NULLCP, "DapInterrupt erroneous"));
    }
}

#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;
	}

	if (strcmp (type,DUMP_ERR) == 0)
		oper = "oper";

	(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

#ifdef	HEAVY_DEBUG
pdu_arg_log (pe,op)
PE pe;
int op;
{
    /* 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 logged",op));
    }
}

pdu_res_log (pe, op)
PE	  pe;
int	  op;
{
    /* PDU Level Logging */
    switch (op)
    {
	case OP_READ:
	    PLOG (log_dsap, print_DAS_ReadResult, pe, "Read", 1);
	    break;

	case OP_COMPARE:
	    PLOG (log_dsap, print_DAS_CompareResult, pe, "Compare", 1);
	    break;
	case OP_ABANDON:
	    PLOG (log_dsap, print_DAS_AbandonResult, pe, "Abandon", 1);
	    break;
	case OP_LIST:
	    PLOG (log_dsap, print_DAS_ListResult, pe, "List", 1);
	    break;
	case OP_SEARCH:
	    PLOG (log_dsap, print_DAS_SearchResult, pe, "Search", 1);
	    break;
	case OP_ADDENTRY:
	    PLOG (log_dsap, print_DAS_AddEntryResult, pe, "AddEntry", 1);
	    break;
	case OP_REMOVEENTRY:
	    PLOG (log_dsap, print_DAS_RemoveEntryResult, pe, "RemoveEntry",1);
	    break;
	case OP_MODIFYENTRY:
	    PLOG (log_dsap, print_DAS_ModifyEntryResult, pe, "ModifyEntry",1);
	    break;
	case OP_MODIFYRDN:
	    PLOG (log_dsap, print_DAS_ModifyRDNResult, pe, "ModifyRDN", 1);
	    break;
	case OP_GETEDB:
	    PLOG (log_dsap, print_Quipu_GetEntryDataBlockResult, pe, "GetEDB", 1);
	    break;
	default:
	    LLOG (log_dsap, LLOG_PDUS, ("Unknown operation (%d) - no result PDU logged",op));
    }
}
#endif