[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / contrib / isode / quipu / dsa_work.c

/* 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.5 91/02/22 09:39:13 mrose Interim $";
#endif

/*
 * $Header: /f/osi/quipu/RCS/dsa_work.c,v 7.5 91/02/22 09:39:13 mrose Interim $
 *
 *
 * $Log:	dsa_work.c,v $
 * Revision 7.5  91/02/22  09:39:13  mrose
 * Interim 6.8
 * 
 * Revision 7.4  90/10/17  11:54:10  mrose
 * sync
 * 
 * Revision 7.3  90/07/09  14:46:05  mrose
 * sync
 * 
 * Revision 7.2  90/03/15  11:19:02  mrose
 * quipu-sync
 * 
 * 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 = NULLDN;
DN                  base = NULLDN;
struct ds_search_task	**local;
struct ds_search_task	**refer;
int                 dsa_ret;
struct di_block	    * di;
char		    dsp;

    arg = &(tk->tk_dx.dx_arg.dca_dsarg);
    res = &(tk->tk_resp.di_result.dr_res.dcr_dsres);
    err = &(tk->tk_resp.di_error.de_err);
    local = &(tk->local_st);
    refer = &(tk->refer_st);

    if(tk->tk_conn->cn_ctx == DS_CTX_X500_DAP)
    {
	orig = tk->tk_conn->cn_dn;
	dsp = FALSE;
    }
    else
    {
	if (tk->tk_dx.dx_arg.dca_charg.cha_originator == NULLDN) {
	    switch (arg->arg_type) {
		case OP_READ:		orig = arg->arg_rd.rda_common.ca_requestor;
					break;
		case OP_COMPARE:	orig = arg->arg_cm.cma_common.ca_requestor;
					break;
		case OP_LIST:		orig = arg->arg_ls.lsa_common.ca_requestor;
					break;
		case OP_SEARCH:		orig = arg->arg_sr.sra_common.ca_requestor;
					break;
		case OP_ADDENTRY:	orig = arg->arg_ad.ada_common.ca_requestor;
					break;
		case OP_REMOVEENTRY:	orig = arg->arg_rm.rma_common.ca_requestor;
					break;
		case OP_MODIFYENTRY:	orig = arg->arg_me.mea_common.ca_requestor;
					break;
		case OP_MODIFYRDN:	orig = arg->arg_mr.mra_common.ca_requestor;
					break;
		default:		orig = NULLDN;
					break;
	    }
	} else
		orig = tk->tk_dx.dx_arg.dca_charg.cha_originator;

	if (tk->tk_dx.dx_arg.dca_charg.cha_target == NULLDN) {
	    switch (arg->arg_type) {
		case OP_READ:		base = arg->arg_rd.rda_object;
					break;
		case OP_COMPARE:	base = arg->arg_cm.cma_object;
					break;
		case OP_LIST:		base = arg->arg_ls.lsa_object;
					break;
		case OP_SEARCH:		base = arg->arg_sr.sra_baseobject;
					break;
		case OP_ADDENTRY:	base = arg->arg_ad.ada_object;
					break;
		case OP_REMOVEENTRY:	base = arg->arg_rm.rma_object;
					break;
		case OP_MODIFYENTRY:	base = arg->arg_me.mea_object;
					break;
		case OP_MODIFYRDN:	base = arg->arg_mr.mra_object;
					break;
		case OP_GETEDB:		base = arg->arg_ge.ga_entry;
					break;
		default:		base = NULLDN;
					break;
	    }
	} else 
		base = tk->tk_dx.dx_arg.dca_charg.cha_target;

	dsp = TRUE;
	
    }


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

#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)) {
	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 == DS_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 == DS_CTX_QUIPU_DSP,
		tk->tk_timed ? tk->tk_timeout : (time_t) 0,
		tk->tk_dx.dx_arg.dca_charg.cha_entryonly);
	
        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:
	orig = tk->tk_conn->cn_dn;
	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.di_result.dr_res);
	tk->tk_result->dcr_dsres.result_type = tk->tk_dx.dx_arg.dca_dsarg.arg_type;
	tk->tk_resp.di_type = DI_RESULT;

	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.di_type = DI_RESULT;
	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_resp.di_type = DI_ERROR;
	tk->tk_error = &(tk->tk_resp.di_error.de_err);
	task_conn_extract(tk);
	task_error(tk);
	if (tk->tk_dx.dx_arg.dca_dsarg.arg_type == OP_SEARCH) {
		free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_un.srr_unit);
		free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
		free ((char *)tk->tk_resp.di_result.dr_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_dx.dx_arg.dca_dsarg.arg_type == OP_SEARCH) {
		free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_un.srr_unit);
		free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
		free ((char *)tk->tk_resp.di_result.dr_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.di_error.de_err.dse_type = DSE_SERVICEERROR;
	tk->tk_resp.di_error.de_err.ERR_SERVICE.DSE_sv_problem = DSE_SV_DITERROR;
	task_conn_extract(tk);
	task_error(tk);
	if (tk->tk_dx.dx_arg.dca_dsarg.arg_type == OP_SEARCH) {
		free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_un.srr_unit);
		free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
		free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next);
	}
	task_extract(tk);
	break;
    }

}

search_continue (tk)
struct task_act * tk;
{
struct ds_search_result * tk_sr = &(tk->tk_resp.di_result.dr_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;
					}
					break;
		default:		op = "Unknown op"; 	break;
	}

	if (context == DS_CTX_X500_DAP) {
		(void) sprintf (buf,"%s (%d)",op,ad);
       		pslog (log_stat,LLOG_NOTICE,buf,dn_print,(caddr_t)daptarget);
	} else {
		(void) sprintf (buf,"%s (%d)",op,ad);
        	pslog (log_stat,LLOG_NOTICE,buf,dn_print,(caddr_t)dsptarget);
		if (arg->arg_type != OP_GETEDB) {
			pslog (log_stat,LLOG_TRACE,"DAP Originator",dn_print,(caddr_t)orig);
		}
	}
}
#endif
Commit	Line	Data
9e8e5516 C	1	/* dsa_work.c - do some work on an active task. */
	2
	3	#ifndef lint
	4	static char *rcsid = "$Header: /f/osi/quipu/RCS/dsa_work.c,v 7.5 91/02/22 09:39:13 mrose Interim $";
	5	#endif
	6
	7	/*
	8	* $Header: /f/osi/quipu/RCS/dsa_work.c,v 7.5 91/02/22 09:39:13 mrose Interim $
	9	*
	10	*
	11	* $Log: dsa_work.c,v $
	12	* Revision 7.5 91/02/22 09:39:13 mrose
	13	* Interim 6.8
	14	*
	15	* Revision 7.4 90/10/17 11:54:10 mrose
	16	* sync
	17	*
	18	* Revision 7.3 90/07/09 14:46:05 mrose
	19	* sync
	20	*
	21	* Revision 7.2 90/03/15 11:19:02 mrose
	22	* quipu-sync
	23	*
	24	* Revision 7.1 89/12/19 16:20:32 mrose
	25	* sync
	26	*
	27	* Revision 7.0 89/11/23 22:17:26 mrose
	28	* Release 6.0
	29	*
	30	*/
	31
	32	/*
	33	* NOTICE
	34	*
	35	* Acquisition, use, and distribution of this module and related
	36	* materials are subject to the restrictions of a license agreement.
	37	* Consult the Preface in the User's Manual for the full terms of
	38	* this agreement.
	39	*
	40	*/
	41
	42
	43	#include "acsap.h"
	44	#include "quipu/util.h"
	45	#include "quipu/common.h"
	46	#include "quipu/connection.h"
	47
	48	extern LLog * log_dsap;
	49
	50	dsa_work(tk)
	51	register struct task_act * tk;
	52	{
	53	struct DSArgument *arg;
	54	struct DSError *err;
	55	struct DSResult *res;
	56	DN orig = NULLDN;
	57	DN base = NULLDN;
	58	struct ds_search_task **local;
	59	struct ds_search_task **refer;
	60	int dsa_ret;
	61	struct di_block * di;
	62	char dsp;
	63
	64	arg = &(tk->tk_dx.dx_arg.dca_dsarg);
65	res = &(tk->tk_resp.di_result.dr_res.dcr_dsres);
66	err = &(tk->tk_resp.di_error.de_err);
67	local = &(tk->local_st);
68	refer = &(tk->refer_st);
69
70	if(tk->tk_conn->cn_ctx == DS_CTX_X500_DAP)
71	{
72	orig = tk->tk_conn->cn_dn;
73	dsp = FALSE;
74	}
75	else
76	{
77	if (tk->tk_dx.dx_arg.dca_charg.cha_originator == NULLDN) {
78	switch (arg->arg_type) {
79	case OP_READ: orig = arg->arg_rd.rda_common.ca_requestor;
80	break;
81	case OP_COMPARE: orig = arg->arg_cm.cma_common.ca_requestor;
82	break;
83	case OP_LIST: orig = arg->arg_ls.lsa_common.ca_requestor;
84	break;
85	case OP_SEARCH: orig = arg->arg_sr.sra_common.ca_requestor;
86	break;
87	case OP_ADDENTRY: orig = arg->arg_ad.ada_common.ca_requestor;
88	break;
89	case OP_REMOVEENTRY: orig = arg->arg_rm.rma_common.ca_requestor;
90	break;
91	case OP_MODIFYENTRY: orig = arg->arg_me.mea_common.ca_requestor;
92	break;
93	case OP_MODIFYRDN: orig = arg->arg_mr.mra_common.ca_requestor;
94	break;
95	default: orig = NULLDN;
96	break;
97	}
98	} else
99	orig = tk->tk_dx.dx_arg.dca_charg.cha_originator;
100
101	if (tk->tk_dx.dx_arg.dca_charg.cha_target == NULLDN) {
102	switch (arg->arg_type) {
103	case OP_READ: base = arg->arg_rd.rda_object;
104	break;
105	case OP_COMPARE: base = arg->arg_cm.cma_object;
106	break;
107	case OP_LIST: base = arg->arg_ls.lsa_object;
108	break;
109	case OP_SEARCH: base = arg->arg_sr.sra_baseobject;
110	break;
111	case OP_ADDENTRY: base = arg->arg_ad.ada_object;
112	break;
113	case OP_REMOVEENTRY: base = arg->arg_rm.rma_object;
114	break;
115	case OP_MODIFYENTRY: base = arg->arg_me.mea_object;
116	break;
117	case OP_MODIFYRDN: base = arg->arg_mr.mra_object;
118	break;
119	case OP_GETEDB: base = arg->arg_ge.ga_entry;
120	break;
121	default: base = NULLDN;
122	break;
123	}
124	} else
125	base = tk->tk_dx.dx_arg.dca_charg.cha_target;
126
127	dsp = TRUE;
128
129	}
130
131
132	DLOG (log_dsap,LLOG_TRACE,( "Apply operation"));
133
134	#ifndef NO_STATS
135	if (*local == NULL_ST)
136	log_x500_event (arg,tk->tk_conn->cn_ctx,orig,base,tk->tk_conn->cn_ad);
137	#endif
138
139	if (!dsp && (tk->tk_conn->cn_authen == DBA_AUTH_NONE)) {
140	orig = NULLDN;
141	}
142
143	switch(arg->arg_type)
144	{
145	case OP_READ:
146	dsa_ret = do_ds_read(&(arg->arg_rd), err, &(res->res_rd), orig, base, &(di), dsp,
147	tk->tk_conn->cn_ctx == DS_CTX_QUIPU_DSP);
148	break;
149
150	case OP_COMPARE:
151	dsa_ret = do_ds_compare(&(arg->arg_cm), err, &(res->res_cm), orig, base, &(di),dsp);
152	break;
153
154	case OP_ABANDON:
155	LLOG(log_dsap, LLOG_FATAL, ("Abandon being applied!"));
156	dsa_ret = do_ds_abandon(&(arg->arg_ab), err);
157	break;
158
159	case OP_LIST:
160	dsa_ret = do_ds_list(&(arg->arg_ls), err, &(res->res_ls), orig, base, &(di),dsp);
161	break;
162
163	case OP_SEARCH:
164
165	dsa_ret = do_ds_search(&(arg->arg_sr), err, &(res->res_sr), orig, base,
166	local, refer, &(di), dsp,
167	tk->tk_conn->cn_ctx == DS_CTX_QUIPU_DSP,
168	tk->tk_timed ? tk->tk_timeout : (time_t) 0,
169	tk->tk_dx.dx_arg.dca_charg.cha_entryonly);
170
171	search_continue (tk);
172
173	break;
174
175	case OP_ADDENTRY:
176	dsa_ret = do_ds_addentry(&(arg->arg_ad), err, orig, base, &(di),dsp);
177	break;
178
179	case OP_REMOVEENTRY:
180	dsa_ret = do_ds_removeentry(&(arg->arg_rm), err, orig, base, &(di),dsp);
181	break;
182
183	case OP_MODIFYENTRY:
184	dsa_ret = do_ds_modifyentry(&(arg->arg_me), err, orig, base, &(di),dsp);
185	break;
186
187	case OP_MODIFYRDN:
188	dsa_ret = do_ds_modifyrdn(&(arg->arg_mr), err, orig, base, &(di),dsp);
189	break;
190
191	case OP_GETEDB:
192	orig = tk->tk_conn->cn_dn;
193	dsa_ret = do_get_edb (&(arg->arg_ge), err, &(res->res_ge), orig);
194	break;
195
196	default:
197	LLOG (log_dsap,LLOG_EXCEPTIONS,( "Unknown operation type!"));
198	break;
199	}
200
201	DLOG (log_dsap,LLOG_TRACE,( "Activity applied"));
202
203	switch(dsa_ret)
204	{
205	case DS_OK:
206	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_OK"));
207	/* Task completed successfully: send result */
208	tk->tk_result = &(tk->tk_resp.di_result.dr_res);
209	tk->tk_result->dcr_dsres.result_type = tk->tk_dx.dx_arg.dca_dsarg.arg_type;
210	tk->tk_resp.di_type = DI_RESULT;
211
212	if((tk->referred_st != NULL_ST) \|\| (tk->tk_operlist != NULLOPER))
213	{
214	tk->tk_state = TK_PASSIVE;
215	break; /* Go wait for operations to return */
216	}
217	tk->tk_resp.di_type = DI_RESULT;
218	task_conn_extract(tk);
219	task_result(tk);
220	task_extract(tk);
221	break;
222	case DS_X500_ERROR:
223	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_X500_ERROR"));
224	/* Task produced error: send error */
225	tk->tk_resp.di_type = DI_ERROR;
226	tk->tk_error = &(tk->tk_resp.di_error.de_err);
227	task_conn_extract(tk);
228	task_error(tk);
229	if (tk->tk_dx.dx_arg.dca_dsarg.arg_type == OP_SEARCH) {
230	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_un.srr_unit);
231	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
232	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next);
233	}
234	task_extract(tk);
235	break;
236	case DS_CONTINUE:
237	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_CONTINUE"));
238	#ifdef DEBUG
239	di_list_log(di);
240	#endif
241	/* Task produced list of dsas: chain operation or send referral */
242	if(task_chain(tk, di) != OK)
243	{
244	task_conn_extract(tk);
245	task_error(tk);
246	if (tk->tk_dx.dx_arg.dca_dsarg.arg_type == OP_SEARCH) {
247	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_un.srr_unit);
248	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
249	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next);
250	}
251	task_extract(tk);
252	}
253	else
254	{
255	tk->tk_state = TK_PASSIVE;
256	}
257	break;
258	case DS_SUSPEND:
259	DLOG (log_dsap,LLOG_DEBUG,( "dsa_work - DS_SUSPEND"));
260	/* Task has suspended itself to check network and other tasks */
261	if((tk->referred_st != NULL_ST) \|\| (tk->tk_operlist != NULLOPER))
262	/* doing things over the net - no need to hurry !!! */
263	tk->tk_prio = DSA_PRIO_LOW;
264	tk->tk_state = TK_SUSPEND;
265	break;
266	default:
267	/* Local error */
268	LLOG(log_dsap, LLOG_EXCEPTIONS, ("dsa_work - do_ds_OP() failed"));
269	tk->tk_resp.di_error.de_err.dse_type = DSE_SERVICEERROR;
270	tk->tk_resp.di_error.de_err.ERR_SERVICE.DSE_sv_problem = DSE_SV_DITERROR;
271	task_conn_extract(tk);
272	task_error(tk);
273	if (tk->tk_dx.dx_arg.dca_dsarg.arg_type == OP_SEARCH) {
274	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_un.srr_unit);
275	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next->srr_un.srr_unit);
276	free ((char *)tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr.srr_next);
277	}
278	task_extract(tk);
279	break;
280	}
281
282	}
283
284	search_continue (tk)
285	struct task_act * tk;
286	{
287	struct ds_search_result * tk_sr = &(tk->tk_resp.di_result.dr_res.dcr_dsres.res_sr);
288
289	/* Set up next part of search result to collate remote sub-searches */
290	if(tk_sr->srr_next == NULLSRR)
291	{
292	DLOG(log_dsap, LLOG_DEBUG, ("Allocating a search result"));
293	tk_sr->srr_next = (struct ds_search_result *) calloc(1, sizeof(struct ds_search_result));
294	tk_sr->srr_next->srr_correlated = TRUE;
295	tk_sr->srr_next->srr_un.srr_unit = (struct ds_search_unit *) calloc(1, sizeof(struct ds_search_unit));
296	tk_sr->srr_next->CSR_limitproblem = LSR_NOLIMITPROBLEM;
297	}
298
299	/* Map any new elements in the refer list onto opers */
300	subtask_chain(tk);
301
302	if((tk->local_st != NULL_ST) && (tk->tk_state == TK_PASSIVE))
303	{
304	tk->tk_state = TK_ACTIVE;
305	}
306	}
307
308
309	#ifndef NO_STATS
310	log_x500_event (arg,context,orig,dsptarget,ad)
311	struct DSArgument *arg;
312	int context;
313	DN dsptarget,orig;
314	int ad;
315	{
316	extern LLog * log_stat;
317	char * op;
318	int dn_print ();
319	DN daptarget = NULLDN;
320	char buf [LINESIZE];
321
322	switch (arg->arg_type) {
323	case OP_READ: op = "Read";
324	daptarget = arg->arg_rd.rda_object;
325	break;
326	case OP_COMPARE: op = "Compare";
327	daptarget = arg->arg_cm.cma_object;
328	break;
329	case OP_ABANDON: op = "Abandon"; break;
330	case OP_LIST: op = "List";
331	daptarget = arg->arg_ls.lsa_object;
332	break;
333	case OP_SEARCH: op = "Search";
334	daptarget = arg->arg_sr.sra_baseobject;
335	break;
336	case OP_ADDENTRY: op = "Add";
337	daptarget = arg->arg_ad.ada_object;
338	break;
339	case OP_REMOVEENTRY: op = "Remove";
340	daptarget = arg->arg_rm.rma_object;
341	break;
342	case OP_MODIFYENTRY: op = "Modify";
343	daptarget = arg->arg_me.mea_object;
344	break;
345	case OP_MODIFYRDN: op = "Modifyrdn";
346	daptarget = arg->arg_mr.mra_object;
347	break;
348	case OP_GETEDB: op = "Getedb";
349	if (dsptarget == NULLDN) {
350	dsptarget = arg->arg_ge.ga_entry;
351	}
352	break;
353	default: op = "Unknown op"; break;
354	}
355
356	if (context == DS_CTX_X500_DAP) {
357	(void) sprintf (buf,"%s (%d)",op,ad);
358	pslog (log_stat,LLOG_NOTICE,buf,dn_print,(caddr_t)daptarget);
359	} else {
360	(void) sprintf (buf,"%s (%d)",op,ad);
361	pslog (log_stat,LLOG_NOTICE,buf,dn_print,(caddr_t)dsptarget);
362	if (arg->arg_type != OP_GETEDB) {
363	pslog (log_stat,LLOG_TRACE,"DAP Originator",dn_print,(caddr_t)orig);
364	}
365	}
366	}
367	#endif