![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to get_dsa_info.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 get_dsa_info.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / quipu |
1.1 root 1: /* get_dsa_info.c - Get DSA info given its distinguished name */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/quipu/RCS/get_dsa_info.c,v 7.2 89/12/19 16:20:36 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/quipu/RCS/get_dsa_info.c,v 7.2 89/12/19 16:20:36 mrose Exp $
9: *
10: *
11: * $Log: get_dsa_info.c,v $
12: * Revision 7.2 89/12/19 16:20:36 mrose
13: * sync
14: *
15: * Revision 7.1 89/11/24 16:21:59 mrose
16: * sync
17: *
18: * Revision 7.0 89/11/23 22:17:42 mrose
19: * Release 6.0
20: *
21: */
22:
23: /*
24: * NOTICE
25: *
26: * Acquisition, use, and distribution of this module and related
27: * materials are subject to the restrictions of a license agreement.
28: * Consult the Preface in the User's Manual for the full terms of
29: * this agreement.
30: *
31: */
32:
33:
34: #include "quipu/util.h"
35: #include "quipu/read.h"
36: #include "quipu/entry.h"
37: #include "quipu/dua.h"
38: #include "quipu/bind.h"
39: #include "quipu/connection.h"
40:
41: extern LLog * log_dsap;
42: extern DN mydsadn;
43:
44: struct oper_act * oper_alloc();
45: struct di_block * di_alloc();
46: struct oper_act * make_get_dsa_info_op();
47:
48: /*
49: * This routine is used to read the info (including presentation address)
50: * for a dsa given its distinguished name.
51: * This is called during the DSA initialisation, to find the name THIS dsa.
52: */
53:
54: int get_dsa_info(dn, dn_stack, err, di_p)
55: DN dn;
56: struct dn_seq * dn_stack;
57: struct DSError * err;
58: struct di_block **di_p;
59: {
60: struct di_block * di_tmp;
61: struct di_block * di_lookup;
62: struct oper_act * on = NULLOPER;
63: int res;
64:
65: DLOG (log_dsap,LLOG_TRACE,("get_dsa_info()"));
66:
67: if (dn_in_dnseq(dn, dn_stack))
68: {
69: LLOG (log_dsap,LLOG_NOTICE,("get_dsa_info - loop detected"));
70: err->dse_type = DSE_SERVICEERROR;
71: err->dse_un.dse_un_service.DSE_sv_problem = DSE_SV_LOOPDETECT;
72: return(DS_X500_ERROR);
73: }
74:
75: /* if asking about me, use my cached entry */
76: if (dn_cmp (dn,mydsadn) == 0)
77: {
78: LLOG (log_dsap,LLOG_NOTICE,("get_dsa_info - referring to self :-)"));
79: err->dse_type = DSE_SERVICEERROR;
80: err->dse_un.dse_un_service.DSE_sv_problem = DSE_SV_DITERROR;
81: return(DS_X500_ERROR);
82: }
83:
84:
85: (*di_p) = di_alloc();
86: (*di_p)->di_type = DI_TASK;
87: (*di_p)->di_dn = dn_cpy(dn);
88: (*di_p)->di_target = NULLDN;
89: (*di_p)->di_reftype = RT_UNDEFINED;
90: (*di_p)->di_rdn_resolved = CR_RDNRESOLVED_NOTDEFINED;
91: (*di_p)->di_aliasedRDNs = CR_NOALIASEDRDNS;
92:
93: /*
94: * Check for a GetDSAInfo operation already in the pipeline.
95: */
96: for(di_tmp=deferred_dis; di_tmp != NULL_DI_BLOCK; di_tmp=di_tmp->di_next)
97: {
98: if(dn_cmp(dn, di_tmp->di_dn) == 0)
99: {
100: (*di_p)->di_state = DI_DEFERRED;
101: (*di_p)->di_entry = NULLENTRY;
102:
103: /* link to the performing operation */
104: (*di_p)->di_perform = di_tmp->di_perform;
105:
106: /* Add to wake list leaving global block first to be woken */
107: (*di_p)->di_wake_next = di_tmp->di_wake_next;
108: di_tmp->di_wake_next = (*di_p);
109:
110: DLOG(log_dsap, LLOG_DEBUG, ("Found global deferred di_block:"));
111: #ifdef DEBUG
112: di_list_log((*di_p));
113: #endif
114: return(DS_CONTINUE);
115: }
116: }
117:
118: if ((res = really_find_entry(dn, TRUE, dn_stack, FALSE, &((*di_p)->di_entry), err, &(di_lookup))) == DS_OK)
119: /* is it really OK ??? */
120: if (((*di_p)->di_entry ->e_data == E_TYPE_CONSTRUCTOR)
121: || ((*di_p)->di_entry->e_dsainfo == NULL)
122: || ((*di_p)->di_entry->e_dsainfo->dsa_addr == NULLPA)) {
123: DN dn_found;
124: DLOG(log_dsap, LLOG_NOTICE, ("rfe returned a constructor"));
125: dn_found = get_copy_dn((*di_p)->di_entry);
126: res = constructor_dsa_info(dn_found,dn_stack,FALSE,(*di_p)->di_entry,err,&(di_lookup));
127: dn_free (dn_found);
128: }
129:
130: switch (res)
131: {
132: case DS_OK:
133: /* really_find_entry has found the entry and placed it in di_entry */
134: DLOG(log_dsap, LLOG_DEBUG, ("get_dsa_info - really_fe returns DS_OK"));
135: (*di_p)->di_state = DI_COMPLETE;
136: #ifdef DEBUG
137: di_list_log((*di_p));
138: #endif
139: return(DS_OK);
140:
141: case DS_CONTINUE:
142: /*
143: * A list of di_blocks (di_lookup) has been generated by get_dsa_info.
144: * These should be used to chain the get_dsa_info operation.
145: * Attempt to generate an operation using the di_blocks returned
146: * and if successful, defer the current di_block to it.
147: */
148: DLOG(log_dsap, LLOG_DEBUG, ("gdi rfe returned DS_CONT:"));
149: #ifdef DEBUG
150: di_list_log(di_lookup);
151: #endif
152: if((on = make_get_dsa_info_op(dn, di_lookup)) == NULLOPER)
153: {
154: /* Flake out screaming */
155: LLOG(log_dsap, LLOG_EXCEPTIONS, ("make_get_dsa_info_op failed for get_dsa_info"));
156: free((char *)*di_p);
157: (*di_p) = NULL_DI_BLOCK;
158: err->dse_type = DSE_SERVICEERROR;
159: err->ERR_SERVICE.DSE_sv_problem = DSE_SV_UNABLETOPROCEED;
160: return(DS_X500_ERROR);
161: }
162:
163: if(oper_chain(on) != OK)
164: {
165: /* Flake out screaming */
166: LLOG(log_dsap, LLOG_NOTICE, ("send_op failed for get_dsa_info"));
167: free((char *)*di_p);
168: (*di_p) = NULL_DI_BLOCK;
169: err->dse_type = DSE_SERVICEERROR;
170: err->ERR_SERVICE.DSE_sv_problem = DSE_SV_UNABLETOPROCEED;
171: return(DS_X500_ERROR);
172: }
173:
174: di_tmp = di_alloc();
175: di_tmp->di_dn = dn_cpy(dn);
176: DLOG(log_dsap, LLOG_DEBUG, ("get_dsa_info allocates di_block with dn[%x]", di_tmp->di_dn));
177: di_tmp->di_state = DI_DEFERRED;
178: di_tmp->di_type = DI_GLOBAL;
179: di_tmp->di_perform = on;
180: on->on_wake_list = di_tmp; /* wake globals first */
181:
182: (*di_p)->di_state = DI_DEFERRED;
183: (*di_p)->di_perform = on;
184:
185: /* Add to wake list leaving global block first to be woken */
186: (*di_p)->di_wake_next = NULL_DI_BLOCK;
187: di_tmp->di_wake_next = (*di_p);
188:
189: di_tmp->di_next = deferred_dis;
190: deferred_dis = di_tmp;
191:
192: DLOG(log_dsap, LLOG_DEBUG, ("gdi DS_CONT: generated:"));
193: #ifdef DEBUG
194: di_list_log((*di_p));
195: #endif
196: return(DS_CONTINUE);
197:
198: case DS_X500_ERROR:
199: /* something wrong with the request - err should be filled out */
200: DLOG(log_dsap, LLOG_DEBUG, ("gdi X500_ERROR"));
201: free((char *)*di_p);
202: (*di_p) = NULL_DI_BLOCK;
203: return(DS_X500_ERROR);
204:
205: default:
206: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Unexpected return from read_dsa_info"));
207: free((char *)*di_p);
208: (*di_p) = NULL_DI_BLOCK;
209: err->dse_type = DSE_SERVICEERROR;
210: err->ERR_SERVICE.DSE_sv_problem = DSE_SV_UNABLETOPROCEED;
211: return(DS_X500_ERROR);
212: }
213: }
214:
215: dsa_info_result_wakeup(on)
216: struct oper_act * on;
217: {
218: EntryInfo * ent_res;
219: Entry di_ent;
220: struct di_block * di;
221: struct di_block * next_di;
222: struct di_block **di_p;
223: Entry cache_dsp_entry();
224:
225: DLOG(log_dsap, LLOG_DEBUG, ("dsa_info_result_wakeup()"));
226:
227: /*
228: * Cache the entry returned, flake out if it is not unravellable,
229: * otherwise grab a reference to the unravelled entry.
230: */
231:
232: ent_res = &(on->on_resp.di_result.dr_res.dcr_dsres.res_rd.rdr_entry);
233: if((di_ent = cache_dsp_entry (ent_res)) == NULLENTRY)
234: {
235: LLOG (log_dsap, LLOG_EXCEPTIONS, ("dsa_info_result_wakeup - cache_dsp_entry failure"));
236: dsa_info_error_wakeup(on);
237: return;
238: }
239:
240: DLOG(log_dsap, LLOG_DEBUG, ("dsa_info_result_wakeup - cached dsa_info"));
241:
242: /*
243: * First block on the wake up list should be the global marker.
244: * Verify this and remove it.
245: */
246: if(on->on_wake_list->di_type != DI_GLOBAL)
247: {
248: LLOG(log_dsap, LLOG_EXCEPTIONS, ("First di_block to wake not global"));
249: }
250: else
251: {
252: di_p = &(deferred_dis);
253: for(di = deferred_dis; di != NULL_DI_BLOCK; di=(*di_p))
254: {
255: if(di == on->on_wake_list)
256: break;
257:
258: di_p = &(di->di_next);
259: }
260: if(di == NULL_DI_BLOCK)
261: {
262: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Global di_block wasn't on global list"));
263: }
264: else
265: {
266: (*di_p)=di->di_next;
267: }
268: }
269:
270: DLOG(log_dsap, LLOG_DEBUG, ("dsa_info_result_wakeup - dealt with global block"));
271:
272: for(di = on->on_wake_list->di_wake_next; di != NULL_DI_BLOCK; di = next_di)
273: {
274: next_di = di->di_wake_next;
275: di->di_state = DI_COMPLETE;
276: di->di_entry = di_ent;
277:
278: switch(di->di_type)
279: {
280: case DI_OPERATION:
281: if (di->di_oper == NULLOPER) {
282: di_free (di);
283: break;
284: }
285: if(di->di_oper->on_state == ON_DEFERRED)
286: {
287: if (oper_chain(di->di_oper) != OK) {
288: LLOG (log_dsap,LLOG_EXCEPTIONS, ("oper_chain failed in dsa_info_wakeup"));
289: di_free(di);
290: }
291: }
292: break;
293:
294: case DI_TASK:
295: task_dsa_info_wakeup(di);
296: di_free(di);
297: break;
298:
299: default:
300: LLOG(log_dsap, LLOG_EXCEPTIONS, ("get_dsa_info_aux - unknown di-type %d",di->di_type));
301: oper_extract(on);
302: return;
303: }
304: }
305:
306: DLOG(log_dsap, LLOG_DEBUG, ("dsa_info_result_wakeup - woke all blocks"));
307:
308: /*
309: * Everthing should have been woken up by now so the di_blocks on
310: * the wake list and the operation itself can be extracted.
311: */
312: di_free(on->on_wake_list);
313:
314: oper_extract(on);
315: }
316:
317: dsa_info_error_wakeup(on)
318: struct oper_act * on;
319: {
320: struct DSError * err = &(on->on_resp.di_error.de_err);
321: struct di_block * di;
322:
323: /*
324: * Error can fall into 3 categories:
325: * 1) Problem with remote DSA performing operation - try another;
326: * 2) A referral error - follow the referral;
327: * 3) An error with the operation itself;
328: */
329:
330: switch(err->dse_type)
331: {
332: case DSE_NOERROR:
333: LLOG(log_dsap, LLOG_NOTICE, ("dsa_info_error_wakeup - No Error!"));
334: dsa_info_fail_wakeup(on);
335: return;
336: case DSE_REFERRAL:
337: LLOG(log_dsap, LLOG_NOTICE, ("dsa_info_error_wakeup - DAP Referral!"));
338: case DSE_DSAREFERRAL:
339: if(oper_rechain(on) == OK)
340: return;
341: /* Fall through */
342: default:
343: DLOG(log_dsap, LLOG_DEBUG, ("dsa_info_error_wakeup - Assuming all non-referral errors are to be propogated"));
344: /* Lose the di_block */
345: for(di=on->on_wake_list; di!=NULL_DI_BLOCK; di=di->di_wake_next)
346: {
347: switch(di->di_type)
348: {
349: case DI_OPERATION:
350: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Should wake oper"));
351: oper_log(di->di_oper);
352: break;
353: case DI_TASK:
354: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Should wake task"));
355: task_log(di->di_task);
356: break;
357: case DI_GLOBAL:
358: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Should wake global"));
359: break;
360: default:
361: LLOG(log_dsap, LLOG_EXCEPTIONS, ("dsa_info_error_wakeup - invalid di_type"));
362: break;
363: }
364: }
365: return;
366: }
367: }
368:
369:
370: dsa_info_fail_wakeup(on)
371: struct oper_act * on;
372: {
373: /*
374: * Last attempt to get dsa info failed somehow.
375: * If there are any more "di_block"s to attempt it must be
376: * worth a go (perhaps this depends on the failure which
377: * has occurrred).
378: */
379: if(on->on_dsas)
380: {
381: if(oper_chain(on) == OK)
382: return;
383: }
384:
385: if(on->on_dsas)
386: {
387: /* oper_chain must be awaiting deferred di_blocks */
388: return;
389: }
390:
391: /*
392: * There is nowhere left to chain this operation to so no way to get
393: * the dsa info required. Walk through the wake up list extracting,
394: * waking things up and tidying up afterwords.
395: */
396: }
397:
398: char * get_entry_passwd (as)
399: Attr_Sequence as;
400: {
401: extern AttributeType at_password;
402: Attr_Sequence at;
403:
404: if ((at = as_find_type (as,at_password)) == NULLATTR)
405: return (NULLCP);
406:
407: if (at->attr_value == NULLAV)
408: return (NULLCP);
409:
410: if (at->attr_value->avseq_av.av_struct == NULL)
411: return (NULLCP);
412:
413: return( (char *)at->attr_value->avseq_av.av_struct);
414:
415: }
416:
417: make_dsa_bind_arg (arg)
418: struct ds_bind_arg *arg;
419: {
420: #ifdef NEXT_VERSION
421: Entry my_entry;
422: char * passwd;
423:
424: arg->dba_version = DBA_VERSION_V1988;
425: arg->dba_auth_type = DBA_AUTH_SIMPLE;
426: arg->dba_time1 = NULLCP;
427: arg->dba_time2 = NULLCP;
428:
429: if ((my_entry = local_find_entry (mydsadn ,TRUE)) == NULLENTRY) {
430: arg->dba_dn = NULLDN;
431: arg->dba_auth_type = DBA_AUTH_NONE;
432: arg->dba_passwd[0] = 0;
433: arg->dba_passwd_len = 0;
434: } else {
435: arg->dba_dn = dn_cpy(mydsadn);
436: if ( (passwd = get_entry_passwd(my_entry->e_attributes)) != NULLCP) {
437: (void) strncpy (arg->dba_passwd,passwd,DBA_MAX_PASSWD_LEN);
438: arg->dba_passwd_len = strlen (passwd);
439: } else {
440: arg->dba_auth_type = DBA_AUTH_NONE;
441: arg->dba_passwd[0] = 0;
442: arg->dba_passwd_len = 0;
443: }
444: }
445: #else
446: arg->dba_version = DBA_VERSION_V1988;
447: arg->dba_auth_type = DBA_AUTH_SIMPLE;
448: arg->dba_time1 = NULLCP;
449: arg->dba_time2 = NULLCP;
450: arg->dba_passwd[0] = 0;
451: arg->dba_passwd_len = 0;
452: arg->dba_dn = dn_cpy(mydsadn);
453: #endif
454: }
455:
456: struct oper_act * make_get_dsa_info_op(dn, di)
457: DN dn;
458: struct di_block * di;
459: {
460: struct di_block * di_tmp;
461: struct oper_act * on_tmp;
462: struct ds_read_arg * arg;
463:
464: DLOG(log_dsap, LLOG_TRACE, ("make_get_dsa_info_op"));
465:
466: if((on_tmp = oper_alloc()) == NULLOPER)
467: {
468: LLOG(log_dsap, LLOG_EXCEPTIONS, ("make_get_dsa_info_op - out of memory"));
469: return(NULLOPER);
470: }
471:
472: on_tmp->on_type = ON_TYPE_GET_DSA_INFO;
473: on_tmp->on_arg = &(on_tmp->on_req);
474: set_my_chain_args(&(on_tmp->on_req.dca_charg), dn);
475:
476: on_tmp->on_req.dca_dsarg.arg_type = OP_READ;
477: arg = &(on_tmp->on_req.dca_dsarg.arg_rd);
478:
479: set_my_common_args(&(arg->rda_common));
480: arg->rda_common.ca_servicecontrol.svc_prio = SVC_PRIO_HIGH;
481:
482: arg->rda_object = dn_cpy(dn); /* The important bit */
483: arg->rda_eis.eis_allattributes = TRUE;
484: arg->rda_eis.eis_select = NULLATTR;
485: arg->rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
486:
487: on_tmp->on_dsas = di;
488: for(di_tmp=di; di_tmp!=NULL_DI_BLOCK; di_tmp=di_tmp->di_next)
489: {
490: di_tmp->di_type = DI_OPERATION;
491: di_tmp->di_oper = on_tmp;
492: }
493:
494: return(on_tmp);
495: }
496:
497: set_my_chain_args(cha, dn)
498: struct chain_arg * cha;
499: DN dn;
500: {
501: cha->cha_originator = dn_cpy(mydsadn);
502: cha->cha_target = dn_cpy(dn);
503: cha->cha_progress.op_resolution_phase = OP_PHASE_NOTSTARTED;
504: cha->cha_progress.op_nextrdntoberesolved = OP_PHASE_NOTDEFINED;
505: cha->cha_trace = NULLTRACEINFO;
506: cha->cha_aliasderef = CA_NO_ALIASDEREFERENCED;
507: cha->cha_aliasedrdns = CA_NO_ALIASDEREFERENCED;
508: cha->cha_returnrefs = FALSE;
509: cha->cha_reftype = RT_SUBORDINATE;
510: cha->cha_domaininfo = NULLPE;
511: cha->cha_timelimit = NULLCP;
512: }
513:
514: set_my_common_args(ca)
515: struct common_args * ca;
516: {
517: ca->ca_servicecontrol.svc_options = SVC_OPT_PREFERCHAIN;
518: ca->ca_servicecontrol.svc_prio = SVC_PRIO_HIGH;
519: ca->ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
520: ca->ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
521: ca->ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
522: ca->ca_requestor = dn_cpy(mydsadn);
523: ca->ca_progress.op_resolution_phase = OP_PHASE_NOTSTARTED;
524: ca->ca_progress.op_nextrdntoberesolved = OP_PHASE_NOTDEFINED;
525: ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
526: ca->ca_security = (struct security_parms *) NULL;
527: ca->ca_sig = (struct signature *) NULL;
528: ca->ca_extensions = (struct extension *) NULL;
529: }
530:
531: quipu_ctx_supported (ptr)
532: Entry ptr;
533: {
534: AV_Sequence avs, oc_avs();
535: Attr_Sequence as;
536: extern OID quipu_dsa_oid;
537: extern AttributeType at_applctx;
538: char dap_only = TRUE;
539: char res = 1;
540: static OID dsp = NULLOID;
541: static OID quipu_dsp = NULLOID;
542:
543: /* return 0 if "ptr" is not a quipu DSA */
544: /* return 1 if "ptr" represents a quipu_dsa (by objectclass) */
545: /* return 2 if "ptr" represents a quipu_dsa with quipu context */
546: /* return -1 if "ptr" represents a DAP only DSA */
547:
548: /* Should we use QuipuDSP to a non-Quipu DSA, if is claims
549: * to support it - currently implemented as "NO" ?
550: */
551:
552: if ((avs = oc_avs(ptr->e_attributes)) == NULLAV)
553: /* no objectclass attribute !!! */
554: return 0;
555:
556: if (!check_in_oc (quipu_dsa_oid,avs))
557: res = 0; /* not a quipu DSA */
558:
559: if (( as = as_find_type (ptr->e_attributes,at_applctx)) == NULLATTR)
560: return 1;
561:
562: if (dsp == NULLOID) {
563: /* will both be null first time around... */
564: dsp = oid_cpy (DIR_SYSTEM_AC);
565: quipu_dsp = oid_cpy (DIR_QUIPU_AC);
566: }
567:
568: for (avs=as->attr_value; avs != NULLAV; avs=avs->avseq_next) {
569: if ((res != 0) && (oid_cmp ((OID)avs->avseq_av.av_struct, quipu_dsp) == 0 ))
570: return 2;
571: if (oid_cmp ((OID)avs->avseq_av.av_struct, dsp) == 0 )
572: dap_only = FALSE;
573: }
574:
575: if (dap_only)
576: return -1;
577:
578: return res;
579: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.