![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to update.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 update.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / quipu |
1.1 root 1: /* update.c - write EDB back to disk after modify */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/quipu/RCS/update.c,v 7.3 90/07/09 14:46:49 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/quipu/RCS/update.c,v 7.3 90/07/09 14:46:49 mrose Exp $
9: *
10: *
11: * $Log: update.c,v $
12: * Revision 7.3 90/07/09 14:46:49 mrose
13: * sync
14: *
15: * Revision 7.2 90/03/15 11:19:14 mrose
16: * quipu-sync
17: *
18: * Revision 7.1 89/12/19 16:20:54 mrose
19: * sync
20: *
21: * Revision 7.0 89/11/23 22:18:18 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 "quipu/util.h"
38: #include "quipu/entry.h"
39: #include "tailor.h"
40: #include "quipu/read.h"
41: #include "quipu/dua.h"
42: #include "quipu/connection.h"
43:
44: #ifndef NO_STATS
45: extern LLog * log_stat;
46: #endif
47: extern int dn_print ();
48: extern char *new_version ();
49:
50: extern LLog * log_dsap;
51: extern char remote_lookup;
52: extern int local_slave_size;
53: extern int slave_edbs;
54: extern DN mydsadn;
55: struct oper_act * oper_alloc();
56: struct oper_act * make_get_edb_op();
57:
58: /* routine name is historic - not significant */
59:
60: journal (myentry)
61: Entry myentry;
62: {
63: char * filename, *dn2edbfile();
64: char savefile [LINESIZE], newfile[LINESIZE];
65: DN dn;
66: extern char * treedir;
67: extern char * parse_file;
68: Entry liststart;
69: extern int errno;
70:
71: if (myentry == NULLENTRY) {
72: LLOG (log_dsap,LLOG_FATAL,("update edb problem"));
73: return NOTOK;
74: }
75:
76: if ((myentry->e_parent != NULLENTRY) && (myentry->e_parent->e_leaf)) {
77: liststart = myentry;
78: dn = get_copy_dn (liststart->e_parent);
79: if ((filename = dn2edbfile (dn)) == NULLCP) {
80: dn_free (dn);
81: return NOTOK;
82: }
83: myentry->e_parent->e_leaf = FALSE; /* not a leaf now !! */
84:
85: if ( write_edb(liststart,filename) != OK)
86: return NOTOK;
87: } else {
88: if (myentry->e_parent == NULLENTRY) {
89: liststart = myentry;
90: dn = NULLDN;
91: } else {
92: liststart = myentry->e_parent->e_child;
93: dn = get_copy_dn (liststart->e_parent);
94: }
95: if ((filename = dn2edbfile (dn)) == NULLCP) {
96: dn_free (dn);
97: return NOTOK;
98: }
99:
100: (void) strcpy (newfile,filename);
101: (void) strcat (newfile,".new");
102:
103: if ( write_edb(liststart,newfile) != OK) {
104: (void) unlink (newfile);
105: return NOTOK;
106: }
107:
108: (void) strcpy (savefile,filename);
109: (void) strcat (savefile,".bak");
110:
111: (void) unlink (savefile);
112: if (link (filename, savefile) == NOTOK)
113: SLOG (log_dsap, LLOG_EXCEPTIONS, savefile,
114: ("unable to link %s to", filename));
115: if (rename (newfile, filename) == NOTOK) {
116: SLOG (log_dsap, LLOG_EXCEPTIONS, filename,
117: ("unable to rename %s to", newfile));
118: if (link (savefile, filename) == NOTOK
119: && !fileexists (filename))
120: LLOG (log_dsap, LLOG_EXCEPTIONS,
121: ("and couldn't get old file back - PANIC!!!"));
122: return NOTOK;
123: }
124: }
125:
126: return OK;
127: }
128:
129: modify_attr (eptr,who)
130: Entry eptr;
131: DN who;
132: {
133: AttributeType at;
134: AttributeValue av;
135: AV_Sequence avs;
136: Attr_Sequence as, old;
137: extern int no_last_mod;
138:
139: if (no_last_mod)
140: return;
141:
142: if ((at = AttrT_new (LAST_MOD_OID)) == NULLAttrT) {
143: LLOG (log_dsap, LLOG_EXCEPTIONS, ("last mod oid missing"));
144: return;
145: }
146:
147: av = AttrV_alloc ();
148: av->av_syntax = str2syntax ("UTCTime");
149: av->av_struct = (caddr_t) new_version();
150:
151: avs = avs_comp_new(av);
152:
153: if ((old = as_find_type (eptr->e_attributes,at)) == NULLATTR) {
154: as = as_comp_new (at,avs,NULLACL_INFO);
155: eptr->e_attributes = as_merge (eptr->e_attributes,as);
156: } else {
157: avs_free (old->attr_value);
158: old->attr_value = avs;
159: AttrT_free (at);
160: }
161:
162: if ((at = AttrT_new (MOD_BY_OID)) == NULLAttrT) {
163: LLOG (log_dsap, LLOG_EXCEPTIONS, ("last mod by oid missing"));
164: return;
165: }
166:
167: av = AttrV_alloc ();
168: av->av_syntax = str2syntax ("DN");
169: av->av_struct = (caddr_t) dn_cpy (who);
170:
171: avs = avs_comp_new(av);
172:
173: if ((old = as_find_type (eptr->e_attributes,at)) == NULLATTR) {
174: as = as_comp_new (at,avs,NULLACL_INFO);
175: eptr->e_attributes = as_merge (eptr->e_attributes,as);
176: } else {
177: avs_free (old->attr_value);
178: old->attr_value = avs;
179: AttrT_free (at);
180: }
181: }
182:
183: static allowed_to_send (a,b)
184: register DN a,b;
185: {
186: /* Return TRUE if the DNs are the same */
187: /* Return TRUE if all components of 'a' match, but 'b' has one extra */
188: /* False otherwise */
189:
190: if ((a == NULLDN) || (b == NULLDN))
191: return FALSE;
192:
193: for (; a != NULLDN && b != NULLDN ; a = a->dn_parent, b = b->dn_parent)
194: if ( dn_comp_cmp (a,b) == NOTOK)
195: return FALSE;
196:
197: if (( b == NULLDN) || (b->dn_parent == NULLDN))
198: return TRUE;
199: else
200: return FALSE;
201:
202: }
203:
204:
205: do_get_edb (arg,error,result,binddn)
206: struct getedb_arg *arg;
207: struct DSError *error;
208: struct getedb_result *result;
209: DN binddn;
210: {
211: Entry eptr;
212: Entry my_entry;
213: AV_Sequence avs;
214: struct edb_info * dsainfo;
215: char proceed = FALSE;
216: struct dn_seq * dnseq;
217: struct di_block * di;
218:
219: DLOG (log_dsap,LLOG_DEBUG,("getedb '%s'",arg->ga_version));
220:
221: switch(really_find_entry (arg->ga_entry,FALSE,NULLDNSEQ,FALSE,&(eptr),error,&(di)))
222: {
223: case DS_OK:
224: /*
225: * Entry has been found and returned via eptr.
226: * Go through and process this entry.
227: */
228: break;
229:
230: case DS_CONTINUE:
231: /*
232: * Get edb operations should never generate referrals.
233: * Free the di_blocks generated and return an error.
234: */
235: error->dse_type = DSE_SERVICEERROR;
236: error->ERR_SERVICE.DSE_sv_problem = DSE_SV_CHAININGREQUIRED;
237: return (DS_X500_ERROR);
238:
239: case DS_X500_ERROR:
240: /* something wrong with the request - error should be filled out */
241: return(DS_X500_ERROR);
242:
243: default:
244: LLOG(log_dsap, LLOG_EXCEPTIONS, ("do_get_edb() - really_find_entry() failed"));
245: error->dse_type = DSE_SERVICEERROR;
246: error->ERR_SERVICE.DSE_sv_problem = DSE_SV_DITERROR;
247: return (DS_X500_ERROR);
248: }
249:
250: if ((my_entry = local_find_entry (mydsadn,TRUE)) == NULLENTRY)
251: fatal (84,"my entry has gone - no getedb");
252:
253: /* Check we will send to this DSA */
254: for (avs = my_entry->e_dsainfo->dsa_attr ; avs != NULLAV; avs=avs->avseq_next) {
255: if (avs->avseq_av.av_struct == NULL)
256: continue;
257: dsainfo = (struct edb_info *) avs->avseq_av.av_struct;
258: if (dn_cmp(dsainfo->edb_name,arg->ga_entry) == 0) {
259: for (dnseq=dsainfo->edb_allowed; dnseq!=NULLDNSEQ; dnseq=dnseq->dns_next) {
260: if (allowed_to_send(dnseq->dns_dn,binddn)) {
261: proceed = TRUE;
262: break;
263: }
264: }
265: }
266: if (proceed)
267: break;
268: }
269:
270: if (!proceed) {
271: error->dse_type = DSE_SECURITYERROR;
272: error->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
273: return (DS_ERROR_REMOTE);
274: }
275:
276: if ((eptr->e_child == NULLENTRY)
277: || ((eptr->e_child->e_data != E_DATA_MASTER)
278: && (eptr->e_child->e_data != E_TYPE_SLAVE))) {
279: error->dse_type = DSE_SERVICEERROR;
280: error->ERR_SERVICE.DSE_sv_problem = DSE_SV_DITERROR;
281: return (DS_X500_ERROR);
282: }
283:
284: if (eptr->e_edbversion != NULLCP) {
285: DLOG(log_dsap, LLOG_DEBUG, ("edb_ver = %s", eptr->e_edbversion));
286:
287: if (lexequ (arg->ga_version,eptr->e_edbversion) == 0) {
288: result->gr_version = eptr->e_edbversion;
289: result->gr_edb = NULLENTRY;
290: result->gr_next = NULL_GETRESULT;
291: return (DS_OK);
292: }
293: } else
294: eptr->e_edbversion = new_version();
295:
296: result->gr_version = eptr->e_edbversion;
297: result->gr_edb = eptr->e_child;
298: result->gr_next = NULL_GETRESULT;
299: return (DS_OK);
300: }
301:
302: slave_update ()
303: {
304: extern time_t lastedb_update, timenow;
305:
306: (void) update_aux (NULLDN, 0);
307: lastedb_update = timenow;
308: }
309:
310: update_aux (dn, isroot)
311: DN dn;
312: int isroot;
313: {
314: Entry my_entry, make_path();
315: Entry find_sibling();
316: extern DN mydsadn;
317: struct edb_info * dsainfo;
318: Entry eptr;
319: static char *version = NULLCP;
320: AV_Sequence avs;
321: AV_Sequence avs_head;
322: int success;
323:
324: DLOG (log_dsap,LLOG_TRACE,("slave update"));
325:
326: if ((my_entry = local_find_entry (mydsadn,TRUE)) == NULLENTRY)
327: fatal (82,"Can't update slaves - my entry has gone");
328:
329: avs_head = avs_cpy(my_entry->e_dsainfo->dsa_attr);
330:
331: for (avs = avs_head ; avs != NULLAV; avs=avs->avseq_next)
332: {
333: if (avs->avseq_av.av_struct == NULL)
334: continue;
335: dsainfo = (struct edb_info *) avs->avseq_av.av_struct;
336: if (dsainfo->edb_getfrom == NULLDN)
337: continue; /* not an EDB to update */
338: if ((dn || isroot) && dn_cmp (dn, dsainfo -> edb_name) != OK)
339: continue; /* not an EDB this time */
340:
341: if ((eptr = local_find_entry (dsainfo->edb_name,FALSE)) == NULLENTRY) {
342: version = "0000000000Z";
343: eptr = make_path (dsainfo->edb_name);
344: }
345: else
346: {
347: if((version = eptr->e_edbversion) == NULLCP)
348: {
349: LLOG(log_dsap, LLOG_NOTICE, ("update_aux: edbversion was NULLCP"));
350: version = "0000000000Z";
351: }
352: }
353:
354: success = send_get_edb(version, dsainfo->edb_name, dsainfo->edb_getfrom);
355:
356: if(dn || isroot)
357: break;
358:
359: dsa_wait (0); /* accept any results of previous ops */
360:
361: }
362: avs_free (avs_head);
363:
364: return((dn || isroot) ? success : OK);
365: }
366:
367: int send_get_edb (version,dn,from)
368: char * version;
369: DN dn,from;
370: {
371: struct di_block * di;
372: struct DSError error;
373: struct oper_act * on;
374: char buffer[BUFSIZ];
375: PS ps;
376:
377: switch(get_dsa_info(from, NULLDNSEQ, &(error), &(di)))
378: {
379: case DS_OK:
380: /*
381: * di is a completed dsa info block
382: * Make a get_edb operation from it, attempt to send the operation
383: * and link the operation onto the global list of get_edb
384: * operations.
385: */
386: if (ps = ps_alloc (str_open)) {
387: if (str_setup (ps, buffer, sizeof buffer, 1) != NOTOK) {
388: ps_printf (ps, "contact ");
389: dn_print (ps, from, EDBOUT);
390: ps_printf (ps, " for ");
391: if (dn)
392: dn_print (ps, dn, EDBOUT);
393: *ps -> ps_ptr = NULL;
394:
395: LLOG (log_dsap, LLOG_NOTICE, ("%s", buffer));
396: }
397:
398: (void) ps_free (ps);
399: }
400:
401: #ifdef DEBUG
402: DLOG(log_dsap, LLOG_DEBUG, ("send_get_edb - get_dsa_info OK:"));
403: di_list_log(di);
404: #endif
405: if((on = make_get_edb_op(dn, version, di)) == NULLOPER)
406: {
407: /* Flake out screaming */
408: LLOG(log_dsap, LLOG_EXCEPTIONS, ("make_get_edb_op failed for send_get_edb"));
409: return(NOTOK);
410: }
411:
412: if(oper_chain(on) != OK)
413: {
414: LLOG(log_dsap, LLOG_NOTICE, ("Could not chain a getEDB operation"));
415: return(NOTOK);
416: }
417:
418: on->on_next_task = get_edb_ops;
419: get_edb_ops = on;
420: return(OK);
421:
422: case DS_CONTINUE:
423: /*
424: * di is a deferred dsa info block
425: * make the operation and suspend waiting for the di_block to be
426: * woken up.
427: */
428: #ifdef DEBUG
429: DLOG(log_dsap, LLOG_DEBUG, ("send_get_edb - get_dsa_info CONT:"));
430: di_list_log(di);
431: #endif
432: if((on = make_get_edb_op(dn, version, di)) == NULLOPER)
433: {
434: /* Flake out screaming */
435: LLOG(log_dsap, LLOG_EXCEPTIONS, ("make_get_edb_op failed for send_get_edb"));
436: return(NOTOK);
437: }
438:
439: on->on_state = ON_DEFERRED;
440:
441: on->on_next_task = get_edb_ops;
442: get_edb_ops = on;
443:
444: if (ps = ps_alloc (str_open)) {
445: if (str_setup (ps, buffer, sizeof buffer, 1) != NOTOK) {
446: ps_printf (ps, "contact ");
447: dn_print (ps, from, EDBOUT);
448: ps_printf (ps, " for ");
449: if (dn)
450: dn_print (ps, dn, EDBOUT);
451: *ps -> ps_ptr = NULL;
452:
453: LLOG (log_dsap, LLOG_NOTICE, ("%s", buffer));
454: }
455:
456: (void) ps_free (ps);
457: }
458:
459: return(OK);
460:
461: case DS_X500_ERROR:
462: /* Error encountered generating di_block */
463: LLOG(log_dsap, LLOG_NOTICE, ("send_get_edb - get_dsa_info returned X500 ERROR"));
464: log_ds_error (&error);
465: ds_error_free (&error);
466: return(NOTOK);
467:
468: default:
469: LLOG(log_dsap, LLOG_EXCEPTIONS, ("send_get_edb - get_dsa_info unexpected return"));
470: return(NOTOK);
471: }
472: /* NOTREACHED */
473: }
474:
475: process_edb(on)
476: struct oper_act * on;
477: {
478: extern DN mydsadn;
479: Entry make_path(), find_sibling();
480: Entry new_entry, old_entry, temp, sibl, next;
481: Entry eptr;
482: /* up 'n' down to make sure first child !!! */
483: struct DSError error;
484: struct getedb_result * result = &(on->on_resp.di_result.dr_res.dcr_dsres.res_ge);
485: int entry_cnt = 0;
486:
487: if ((eptr = local_find_entry (on->on_req.dca_dsarg.arg_ge.ga_entry,FALSE)) == NULLENTRY) {
488: pslog (log_dsap,LLOG_EXCEPTIONS,"Updating something which does not exist !!!",
489: dn_print,(caddr_t)on->on_req.dca_dsarg.arg_ge.ga_entry);
490: return;
491: }
492:
493: if ((new_entry = result->gr_edb) == NULLENTRY) {
494: DLOG (log_dsap, LLOG_NOTICE,(" EDBs are the same (%d): %s",on->on_id,on->on_getedb_ver));
495: return;
496: } else {
497: DLOG (log_dsap, LLOG_NOTICE,(" EDB updated from (%d): %s to: %s", on->on_id,on->on_getedb_ver, result->gr_version));
498: ;
499: }
500:
501: #ifndef NO_STATS
502: {
503: DN tmp_dn;
504: tmp_dn = get_copy_dn (eptr);
505: pslog (log_stat,LLOG_NOTICE,"Slave update",dn_print,(caddr_t)tmp_dn);
506: dn_free (tmp_dn);
507: }
508: #endif
509:
510: if (eptr->e_edbversion)
511: free (eptr->e_edbversion);
512:
513: if (result->gr_version == NULLCP) {
514: eptr->e_edbversion = "Unknown";
515: LLOG(log_dsap, LLOG_EXCEPTIONS, ("EDBRES: NULL version"));
516: } else
517: eptr->e_edbversion = strdup (result->gr_version);
518:
519: for (temp = new_entry; temp != NULLENTRY; temp=temp->e_sibling) {
520: temp->e_parent = eptr;
521: if (unravel_attribute (temp,&error) != OK) {
522: LLOG (log_dsap,LLOG_EXCEPTIONS, ("Error in new EDB - continuing with old"));
523: log_ds_error (&error);
524: return;
525: }
526: }
527:
528: for (temp = new_entry; temp != NULLENTRY; temp=temp->e_sibling) {
529: entry_cnt++;
530: if ((old_entry = find_sibling (temp->e_name,eptr->e_child)) != NULLENTRY) {
531: temp->e_leaf = old_entry->e_leaf;
532: temp->e_allchildrenpresent = old_entry->e_allchildrenpresent;
533: temp->e_child = old_entry->e_child;
534: for (sibl = temp->e_child; sibl != NULLENTRY; sibl=sibl->e_sibling)
535: sibl->e_parent = temp;
536: if (old_entry->e_edbversion != NULLCP)
537: temp->e_edbversion = strdup (old_entry->e_edbversion);
538: }
539:
540: }
541:
542: if (eptr->e_child == NULLENTRY)
543: slave_edbs++;
544:
545: for (temp = eptr->e_child; temp != NULLENTRY; temp=next) {
546: next = temp->e_sibling;
547: local_slave_size--;
548: entry_free (temp);
549: }
550:
551: sync (); /* Photos - no evidence - just a guess !!! */
552:
553: local_slave_size += entry_cnt;
554: eptr->e_child = new_entry;
555: eptr->e_allchildrenpresent = TRUE;
556: eptr->e_leaf = FALSE;
557:
558: #ifdef TURBO_DISK
559: if (turbo_writeall(new_entry) != OK)
560: fatal (-79,"Lost old EDB, can't write new one!!!");
561: #else
562: if (journal (new_entry) != OK)
563: fatal (-79,"Lost old EDB, can't write new one !!!");
564: #endif
565:
566: if (local_find_entry (mydsadn,TRUE) == NULLENTRY)
567: fatal (-80,"My entry has disappeared from the DIT !!!");
568: }
569:
570: /*
571: * get_edb_fail_wakeup suffices for both fail and error conditions
572: * arising on a get edb operation.
573: */
574: get_edb_fail_wakeup(on)
575: struct oper_act * on;
576: {
577: struct oper_act * on_tmp;
578: struct oper_act **on_p;
579:
580: DLOG(log_dsap, LLOG_TRACE, ("get_edb_fail_wakeup"));
581:
582: /* Should do extra logging here */
583:
584: on_p = &(get_edb_ops);
585: for(on_tmp = get_edb_ops; on_tmp != NULLOPER; on_tmp = on_tmp->on_next_task)
586: {
587: if(on_tmp == on)
588: break;
589:
590: on_p = &(on_tmp->on_next_task);
591: }
592:
593: if(on_tmp != NULLOPER)
594: {
595: (*on_p) = on_tmp->on_next_task;
596: }
597: else
598: {
599: LLOG(log_dsap, LLOG_EXCEPTIONS, ("get_edb_fail_wakeup - op escaped from get_edb_ops (the global list)"));
600: }
601:
602: oper_conn_extract(on);
603: oper_free(on);
604: }
605:
606: struct oper_act * make_get_edb_op(dn, version, di)
607: DN dn;
608: char * version;
609: struct di_block * di;
610: {
611: struct di_block * di_tmp;
612: struct oper_act * on_tmp;
613: struct getedb_arg * arg;
614:
615: DLOG(log_dsap, LLOG_TRACE, ("make_get_edb_op"));
616:
617: if((on_tmp = oper_alloc()) == NULLOPER)
618: {
619: LLOG(log_dsap, LLOG_EXCEPTIONS, ("make_get_edb_op - out of memory"));
620: return(NULLOPER);
621: }
622:
623: on_tmp->on_type = ON_TYPE_GET_EDB;
624: on_tmp->on_arg = &(on_tmp->on_req);
625: on_tmp->on_req.dca_dsarg.arg_type = OP_GETEDB;
626: on_tmp->on_getedb_ver = version;
627:
628: arg = &(on_tmp->on_req.dca_dsarg.arg_ge);
629:
630: arg->ga_entry = dn_cpy(dn);
631: arg->ga_version = strdup(version);
632: DLOG(log_dsap, LLOG_NOTICE, ("EDBARG: ver = %s", arg->ga_version));
633:
634: on_tmp->on_dsas = di;
635: for(di_tmp=di; di_tmp!=NULL_DI_BLOCK; di_tmp=di_tmp->di_next)
636: {
637: #ifdef DEBUG
638: DLOG(log_dsap, LLOG_DEBUG, ("Linking a di_block to this op"));
639: di_log(di_tmp);
640: #endif
641: di_tmp->di_type = DI_OPERATION;
642: di_tmp->di_oper = on_tmp;
643: }
644:
645: return(on_tmp);
646: }
647:
648: get_edb_extract(on)
649: struct oper_act * on;
650: {
651: struct oper_act * on_tmp;
652: struct oper_act **next_on;
653:
654: next_on = &(get_edb_ops);
655: for(on_tmp=get_edb_ops; on_tmp!=NULLOPER; on_tmp=on_tmp->on_next_task)
656: {
657: if(on_tmp == on)
658: break;
659: next_on = &(on_tmp->on_next_task);
660: }
661: if(on_tmp != NULLOPER)
662: {
663: (*next_on) = on_tmp->on_next_task;
664: }
665: else
666: {
667: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Not on get_edb list"));
668: }
669: }
670:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.