DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - metrics - download
Index: T d

⟦7b9140b8c⟧ TextFile

    Length: 8875 (0x22ab)
    Types: TextFile
    Names: »dsa_work.c«

Derivation

└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
    └─⟦35176feda⟧ »EurOpenD22/isode/isode-6.tar.Z« 
        └─⟦de7628f85⟧ 
            └─⟦this⟧ »isode-6.0/quipu/dsa_work.c«

TextFile

/* dsa_work.c - do some work on an active task. */

#ifndef lint
static char *rcsid = "$Header: /f/osi/quipu/RCS/dsa_work.c,v 7.1 89/12/19 16:20:32 mrose Exp $";
#endif

/*
 * $Header: /f/osi/quipu/RCS/dsa_work.c,v 7.1 89/12/19 16:20:32 mrose Exp $
 *
 *
 * $Log:	dsa_work.c,v $
 * Revision 7.1  89/12/19  16:20:32  mrose
 * sync
 * 
 * Revision 7.0  89/11/23  22:17:26  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.
 *
 */


#include "acsap.h"
#include "quipu/util.h"
#include "quipu/common.h"
#include "quipu/connection.h"

extern LLog * log_dsap;

dsa_work(tk)
register        struct task_act * tk;
{
struct DSArgument   *arg;
struct DSError      *err;
struct DSResult     *res;
DN                  orig;
DN                  base;
struct ds_search_task	**local;
struct ds_search_task	**refer;
int                 dsa_ret;
struct di_block	    * di;
char		    dsp;

    if(tk->tk_conn->cn_ctx == CN_CTX_X500_DAP)
    {
	orig = dn_cpy(tk->tk_conn->cn_who);
	base = NULLDN;
	dsp = FALSE;
    }
    else
    {
	/* Need to take GetEDB into account !! */
	orig = dn_cpy(tk->tk_req.dca_charg.cha_originator);
	base = dn_cpy(tk->tk_req.dca_charg.cha_target);
	dsp = TRUE;
    }


    DLOG (log_dsap,LLOG_TRACE,( "Apply operation"));

    arg = &(tk->tk_req.dca_dsarg);
    res = &(tk->tk_resp.resp_res.dcr_dsres);
    err = &(tk->tk_resp.resp_err);
    local = &(tk->local_st);
    refer = &(tk->refer_st);

#ifndef NO_STATS
    if (*local == NULL_ST)
	    log_x500_event (arg,tk->tk_conn->cn_ctx,orig,base,tk->tk_conn->cn_ad);
#endif

    if (!dsp && (tk->tk_conn->cn_authen == DBA_AUTH_NONE)) {
	dn_free (orig);
	orig = NULLDN;
    }

    switch(arg->arg_type)
    {
    case OP_READ:
	dsa_ret = do_ds_read(&(arg->arg_rd), err, &(res->res_rd), orig, base, &(di), dsp, 
		tk->tk_conn->cn_ctx == CN_CTX_QUIPU_DSP);
    break;

    case OP_COMPARE:
	dsa_ret = do_ds_compare(&(arg->arg_cm), err, &(res->res_cm), orig, base, &(di),dsp);
    break;

    case OP_ABANDON:
	LLOG(log_dsap, LLOG_FATAL, ("Abandon being applied!"));
	dsa_ret = do_ds_abandon(&(arg->arg_ab), err);
    break;

    case OP_LIST:
	dsa_ret = do_ds_list(&(arg->arg_ls), err, &(res->res_ls), orig, base, &(di),dsp);
    break;

    case OP_SEARCH:
	dsa_ret = do_ds_search(&(arg->arg_sr), err, &(res->res_sr), orig, base, 
		local, refer, &(di), dsp,
		tk->tk_conn->cn_ctx == CN_CTX_QUIPU_DSP,
		tk->tk_timed ? tk->tk_timeout : (time_t) 0);

	search_continue (tk);
    break;

    case OP_ADDENTRY:
	dsa_ret = do_ds_addentry(&(arg->arg_ad), err, orig, base, &(di),dsp);
    break;

    case OP_REMOVEENTRY:
	dsa_ret = do_ds_removeentry(&(arg->arg_rm), err, orig, base, &(di),dsp);
    break;

    case OP_MODIFYENTRY:
	dsa_ret = do_ds_modifyentry(&(arg->arg_me), err, orig, base, &(di),dsp);
    break;

    case OP_MODIFYRDN:
	dsa_ret = do_ds_modifyrdn(&(arg->arg_mr), err, orig, base, &(di),dsp);
    break;

    case OP_GETEDB:
	dn_free(orig);
	if (tk->tk_conn->cn_initiator == INITIATED_BY_THIS)
		orig = dn_cpy(tk->tk_conn->cn_what);
	else
		orig = dn_cpy(tk->tk_conn->cn_who);
	dsa_ret = do_get_edb (&(arg->arg_ge), err, &(res->res_ge), orig);
    break;

    default:
	LLOG (log_dsap,LLOG_EXCEPTIONS,( "Unknown operation type!"));
    break;
    }

    DLOG (log_dsap,LLOG_TRACE,( "Activity applied"));

    switch(dsa_ret)
    {
    case DS_OK:
	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_OK"));
	/* Task completed successfully: send result */
	tk->tk_result = &(tk->tk_resp.resp_res);
	tk->tk_result->dcr_dsres.result_type = tk->tk_req.dca_dsarg.arg_type;
	tk->tk_resp.resp_type = RESP_TYPE_RET;
	tk->tk_resp.ret_type = RET_TYPE_RES;

	if((tk->referred_st != NULL_ST) || (tk->tk_operlist != NULLOPER))
	{
	    tk->tk_state = TK_PASSIVE;
	    break; /* Go wait for operations to return */
	}
	tk->tk_resp.resp_type = RESP_TYPE_RET;
	tk->tk_resp.ret_type = RET_TYPE_RES;
	task_conn_extract(tk);
	task_result(tk);
	task_extract(tk);
	break;
    case DS_X500_ERROR:
	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_X500_ERROR"));
	/* Task produced error: send error */
	tk->tk_type = ACT_TYPE_RESP;
	tk->tk_resp.resp_type = RESP_TYPE_RET;
	tk->tk_resp.ret_type = RET_TYPE_ERR;
	tk->tk_error = &(tk->tk_resp.resp_err);
	task_conn_extract(tk);
	task_error(tk);
	if (tk->tk_req.dca_dsarg.arg_type == OP_SEARCH) {
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_un.srr_unit);
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_next);
	}
	task_extract(tk);
	break;
    case DS_CONTINUE:
	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_CONTINUE"));
#ifdef DEBUG
	di_list_log(di);
#endif
	/* Task produced list of dsas: chain operation or send referral */
	if(task_chain(tk, di) != OK)
	{
	    task_conn_extract(tk);
	    task_error(tk);
	    if (tk->tk_req.dca_dsarg.arg_type == OP_SEARCH) {
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_un.srr_unit);
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_next);
	    }
	    task_extract(tk);
	}
	else
		{
	    tk->tk_state = TK_PASSIVE;
	}
	break;
    case DS_SUSPEND:
	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_SUSPEND"));
	/* Task has suspended itself to check network and other tasks */
	if((tk->referred_st != NULL_ST) || (tk->tk_operlist != NULLOPER))
		/* doing things over the net - no need to hurry !!! */
		tk->tk_prio = DSA_PRIO_LOW;
	tk->tk_state = TK_SUSPEND;
	break;
    default:
	/* Local error */
	LLOG(log_dsap, LLOG_EXCEPTIONS, ("dsa_work - do_ds_OP() failed"));
	tk->tk_resp.resp_err.dse_type = DSE_SERVICEERROR;
	tk->tk_resp.resp_err.ERR_SERVICE.DSE_sv_problem = DSE_SV_DITERROR;
	task_conn_extract(tk);
	task_error(tk);
	if (tk->tk_req.dca_dsarg.arg_type == OP_SEARCH) {
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_un.srr_unit);
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
		free ((char *)tk->tk_resp.resp_res.dcr_dsres.res_sr.srr_next);
	}
	task_extract(tk);
	break;
    }

    dn_free(orig);
    dn_free(base);
}

search_continue (tk)
struct task_act * tk;
{
struct ds_search_result * tk_sr = &(tk->tk_resp.resp_res.dcr_dsres.res_sr);

	/* Set up next part of search result to collate remote sub-searches */
	if(tk_sr->srr_next == NULLSRR)
	{
	    DLOG(log_dsap, LLOG_DEBUG, ("Allocating a search result"));
	    tk_sr->srr_next = (struct ds_search_result *) calloc(1, sizeof(struct ds_search_result));
	    tk_sr->srr_next->srr_correlated = TRUE;
	    tk_sr->srr_next->srr_un.srr_unit = (struct ds_search_unit *) calloc(1, sizeof(struct ds_search_unit));
	    tk_sr->srr_next->CSR_limitproblem = LSR_NOLIMITPROBLEM;
	}

	/* Map any new elements in the refer list onto opers */
	subtask_chain(tk);

	if((tk->local_st != NULL_ST) && (tk->tk_state == TK_PASSIVE))
	{
	    tk->tk_state = TK_ACTIVE;
	}
}


#ifndef NO_STATS
log_x500_event (arg,context,orig,dsptarget,ad)
struct DSArgument   *arg;
int context;
DN dsptarget,orig;
int ad;
{
extern LLog * log_stat;
char * op;
int dn_print ();
DN daptarget = NULLDN;
char buf [LINESIZE];

	switch (arg->arg_type) {
		case OP_READ:		op = "Read";		
					daptarget = arg->arg_rd.rda_object;
					break;
		case OP_COMPARE:	op = "Compare";		
					daptarget = arg->arg_cm.cma_object;
					break;
		case OP_ABANDON:	op = "Abandon";		break;
		case OP_LIST:		op = "List";		
					daptarget = arg->arg_ls.lsa_object;
					break;
		case OP_SEARCH:		op = "Search";		
					daptarget = arg->arg_sr.sra_baseobject;
					break;
		case OP_ADDENTRY:	op = "Add";	
					daptarget = arg->arg_ad.ada_object;
					break;
		case OP_REMOVEENTRY:	op = "Remove";	
					daptarget = arg->arg_rm.rma_object;
					break;
		case OP_MODIFYENTRY:	op = "Modify";	
					daptarget = arg->arg_me.mea_object;
					break;
		case OP_MODIFYRDN:	op = "Modifyrdn";	
					daptarget = arg->arg_mr.mra_object;
					break;
		case OP_GETEDB:		op = "Getedb";		
					if (dsptarget == NULLDN) {
						dsptarget = arg->arg_ge.ga_entry;
#ifdef REMOVE_FOR_6_0
						daptarget = arg->arg_ge.ga_entry;
#endif
					}
					break;
		default:		op = "Unknown op"; 	break;
	}

	if (context == CN_CTX_X500_DAP) {
		(void) sprintf (buf,"%s (%d)",op,ad);
		(void) dn_decode (daptarget);
       		pslog (log_stat,LLOG_NOTICE,buf,dn_print,(caddr_t)daptarget);
	} else {
		(void) sprintf (buf,"%s (%d)",op,ad);
		(void) dn_decode (dsptarget);
        	pslog (log_stat,LLOG_NOTICE,buf,dn_print,(caddr_t)dsptarget);
		if (arg->arg_type != OP_GETEDB) {
			(void) dn_decode (orig);
			pslog (log_stat,LLOG_TRACE,"DAP Originator",dn_print,(caddr_t)orig);
		}
	}
}
#endif