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