![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to di_block.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 di_block.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / quipu |
1.1 ! root 1: /* di_block.c - routines to handle operation activity blocks */ ! 2: ! 3: #ifndef lint ! 4: static char *rcsid = "$Header: /f/osi/quipu/RCS/di_block.c,v 7.2 90/07/09 14:45:34 mrose Exp $"; ! 5: #endif ! 6: ! 7: /* ! 8: * $Header: /f/osi/quipu/RCS/di_block.c,v 7.2 90/07/09 14:45:34 mrose Exp $ ! 9: * ! 10: * ! 11: * $Log: di_block.c,v $ ! 12: * Revision 7.2 90/07/09 14:45:34 mrose ! 13: * sync ! 14: * ! 15: * Revision 7.1 89/12/19 16:20:09 mrose ! 16: * sync ! 17: * ! 18: * Revision 7.0 89/11/23 22:17:00 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/connection.h" ! 36: #include "tsap.h" ! 37: #include "tailor.h" ! 38: ! 39: extern LLog * log_dsap; ! 40: ! 41: extern time_t timenow; ! 42: ! 43: struct di_block *di_alloc() ! 44: { ! 45: struct di_block * di_ret; ! 46: ! 47: di_ret = (struct di_block *) calloc(1,sizeof(struct di_block)); ! 48: ! 49: return(di_ret); ! 50: } ! 51: ! 52: di_free(di) ! 53: struct di_block *di; ! 54: { ! 55: DLOG(log_dsap, LLOG_TRACE, ("di_free()")); ! 56: ! 57: switch (di->di_state) { ! 58: case DI_GLOBAL: break; ! 59: case DI_TASK: break; ! 60: case DI_OPERATION: break; ! 61: default: ! 62: DLOG(log_dsap, LLOG_TRACE, ("di_free() of unknown type %d",di->di_state)); ! 63: return; ! 64: } ! 65: ! 66: dn_free(di->di_dn); ! 67: ! 68: dn_free(di->di_target); ! 69: ! 70: if(di->di_accesspoints != NULLACCESSPOINT) ! 71: aps_free(di->di_accesspoints); ! 72: ! 73: di->di_state = -1; ! 74: ! 75: free((char *)di); ! 76: } ! 77: ! 78: di_extract(old_di) ! 79: struct di_block * old_di; ! 80: { ! 81: struct di_block * di; ! 82: struct di_block **next_di; ! 83: ! 84: LLOG(log_dsap, LLOG_TRACE, ("di_extract")); ! 85: #ifdef DEBUG ! 86: di_log(old_di); ! 87: #endif ! 88: ! 89: switch(old_di->di_type) ! 90: { ! 91: case DI_GLOBAL: ! 92: next_di = &(deferred_dis); ! 93: for(di=deferred_dis; di!=NULL_DI_BLOCK; di=di->di_next) ! 94: { ! 95: if(di == old_di) ! 96: break; ! 97: ! 98: next_di = &(di->di_next); ! 99: } ! 100: if(di == NULL_DI_BLOCK) ! 101: { ! 102: LLOG(log_dsap, LLOG_EXCEPTIONS, ("di_block has escaped from global list")); ! 103: } ! 104: else ! 105: { ! 106: (*next_di) = di->di_next; ! 107: } ! 108: break; ! 109: case DI_OPERATION: ! 110: break; ! 111: case DI_TASK: ! 112: break; ! 113: default: ! 114: break; ! 115: } ! 116: ! 117: di_free(old_di); ! 118: } ! 119: ! 120: di_desist(di) ! 121: struct di_block * di; ! 122: { ! 123: struct di_block * di_tmp1; ! 124: struct di_block * di_tmp1_next; ! 125: struct di_block * di_tmp2; ! 126: struct di_block **di_p2; ! 127: ! 128: DLOG(log_dsap, LLOG_TRACE, ("di_desist()")); ! 129: ! 130: for(di_tmp1=di; di_tmp1 != NULL_DI_BLOCK; di_tmp1 = di_tmp1_next) ! 131: { ! 132: di_tmp1_next = di_tmp1->di_next; ! 133: ! 134: switch(di->di_state) ! 135: { ! 136: case DI_ACCESSPOINT: ! 137: case DI_COMPLETE: ! 138: break; ! 139: case DI_DEFERRED: ! 140: di_p2 = &(di_tmp1->di_perform->on_wake_list); ! 141: for(di_tmp2=di_tmp1->di_perform->on_wake_list; di_tmp2!=NULL_DI_BLOCK; di_tmp2=di_tmp2->di_wake_next) ! 142: { ! 143: if(di_tmp2 == di_tmp1) ! 144: break; ! 145: ! 146: di_p2 = &(di_tmp2->di_wake_next); ! 147: } ! 148: if(di_tmp2 == NULL_DI_BLOCK) ! 149: { ! 150: LLOG(log_dsap, LLOG_EXCEPTIONS, ("di_desist - di_block lost from performing operations wake up list")); ! 151: } ! 152: else ! 153: { ! 154: (*di_p2) = di_tmp2->di_wake_next; ! 155: } ! 156: break; ! 157: } ! 158: di_free(di_tmp1); ! 159: } ! 160: } ! 161: ! 162: di_log(di) ! 163: struct di_block * di; ! 164: { ! 165: DLOG (log_dsap,LLOG_DEBUG, ("di_block [%x] , state = %d, type = %d", ! 166: di, di->di_state, di->di_type)); ! 167: } ! 168: ! 169: di_list_log(di) ! 170: struct di_block *di; ! 171: { ! 172: struct di_block * di_tmp; ! 173: ! 174: DLOG(log_dsap, LLOG_DEBUG, ("di_list:")); ! 175: #ifdef DEBUG ! 176: for(di_tmp = di; di_tmp!=NULL_DI_BLOCK; di_tmp=di_tmp->di_next) ! 177: { ! 178: di_log(di_tmp); ! 179: } ! 180: #endif ! 181: DLOG(log_dsap, LLOG_DEBUG, ("di_list ends.")); ! 182: } ! 183: ! 184: ! 185: ! 186: static struct dn_seq * prefer_dsa_list = NULLDNSEQ; ! 187: ! 188: prefer_dsa (str) ! 189: char * str; ! 190: { ! 191: struct dn_seq * dsa, *loop; ! 192: ! 193: if (( dsa=str2dnseq(str)) == NULLDNSEQ) { ! 194: LLOG (log_dsap,LLOG_EXCEPTIONS,("Invalid prefered DSA name %s",str)); ! 195: return; ! 196: } ! 197: ! 198: if (prefer_dsa_list == NULLDNSEQ) ! 199: prefer_dsa_list = dsa; ! 200: else { ! 201: for (loop = prefer_dsa_list; loop->dns_next != NULLDNSEQ; loop=loop->dns_next) ! 202: ; ! 203: loop->dns_next = dsa; ! 204: } ! 205: } ! 206: ! 207: static di_prefer_dsa (a,b) ! 208: DN a,b; ! 209: { ! 210: int x,y; ! 211: ! 212: if (prefer_dsa_list == NULLDNSEQ) { ! 213: DLOG (log_dsap,LLOG_TRACE,("NO DSAs to chose from")); ! 214: return 0; /* not fussy !!! */ ! 215: } ! 216: ! 217: if ((b == NULLDN) || (a == NULLDN)) { ! 218: DLOG (log_dsap,LLOG_NOTICE,("di_pref DNs NULL")); ! 219: return 0; /* safty catch - don't think it can happen */ ! 220: } ! 221: ! 222: if ((x = dn_in_dnseq (a,prefer_dsa_list)) == 0) ! 223: if ((y = dn_in_dnseq (b,prefer_dsa_list)) == 0) ! 224: return 0; ! 225: else { ! 226: DLOG (log_dsap,LLOG_TRACE,("DSA selected on preference")); ! 227: return -1; ! 228: } ! 229: ! 230: if ((y = dn_in_dnseq (b,prefer_dsa_list)) == 0) { ! 231: DLOG (log_dsap,LLOG_TRACE,("DSA selected on preference")); ! 232: return 1; ! 233: } ! 234: ! 235: if ( x != y ) { ! 236: DLOG (log_dsap,LLOG_TRACE,("DSA selected on preference")); ! 237: return ( x > y ? -1 : 1 ); ! 238: } ! 239: ! 240: return 0; ! 241: ! 242: } ! 243: ! 244: static di_ap2comp (di) ! 245: struct di_block **di; ! 246: { ! 247: struct di_block *loop; ! 248: Entry eptr; ! 249: ! 250: /* replace DI_ACCESSPOINT with DI_COMPLETE if possible... */ ! 251: /* (data may have been cached since creating DI_ACCESSPOINT) */ ! 252: ! 253: for (loop= *di; loop!=NULL_DI_BLOCK; loop=loop->di_next) { ! 254: if (loop->di_state != DI_ACCESSPOINT) ! 255: continue; ! 256: ! 257: if (loop->di_reftype == RT_NONSPECIFICSUBORDINATE) ! 258: continue; /* can't split these - all must be followed... */ ! 259: ! 260: if (loop->di_accesspoints->ap_next == NULLACCESSPOINT) { ! 261: if ((eptr=local_find_entry (loop->di_accesspoints->ap_name,FALSE)) != NULLENTRY) ! 262: if (eptr->e_dsainfo != NULLDSA) { ! 263: loop->di_entry = eptr; ! 264: loop->di_state = DI_COMPLETE; ! 265: aps_free (loop->di_accesspoints); ! 266: loop->di_accesspoints = NULLACCESSPOINT; ! 267: } ! 268: } else ! 269: LLOG (log_dsap,LLOG_EXCEPTIONS,("Many access points, but not a RT_NONSPECIFICSUBORDINATE")); ! 270: } ! 271: ! 272: } ! 273: ! 274: dsa_reliable (cn,good,when) ! 275: struct connection * cn; ! 276: char good; ! 277: time_t when; ! 278: { ! 279: Entry ptr; ! 280: ! 281: if ( (ptr=local_find_entry(cn->cn_dn,FALSE)) == NULLENTRY) ! 282: return; ! 283: ! 284: if (ptr->e_dsainfo == NULLDSA) ! 285: return; ! 286: ! 287: ptr->e_dsainfo->dsa_last_attempt = when; ! 288: if (good) { ! 289: ptr->e_dsainfo->dsa_last_success = when; ! 290: ptr->e_dsainfo->dsa_failures = 0; ! 291: } else ! 292: ptr->e_dsainfo->dsa_failures++; ! 293: } ! 294: ! 295: static di_cmp_reliability (a,b) ! 296: struct di_block *a, *b; ! 297: { ! 298: extern time_t retry_timeout; ! 299: struct dsa_info *da, *db; ! 300: ! 301: /* If we have used a DSA recently, with no failures - use it again */ ! 302: ! 303: if ((da = a->di_entry->e_dsainfo) == NULLDSA) ! 304: return 0; ! 305: if ((db = b->di_entry->e_dsainfo) == NULLDSA) ! 306: return 0; ! 307: ! 308: if (da->dsa_last_attempt == (time_t)0) { ! 309: if (db->dsa_failures == 0) { ! 310: if ((db->dsa_last_success != (time_t)0) ! 311: && (timenow - db->dsa_last_attempt < retry_timeout)) ! 312: return -1; /* b worked recently */ ! 313: } else if (timenow - db->dsa_last_attempt < retry_timeout) ! 314: return 1; /* b failed recently */ ! 315: return 0; /* have not tried either recently */ ! 316: ! 317: } else if (db->dsa_last_attempt == (time_t)0) { ! 318: if (da->dsa_failures == 0) { ! 319: if ((da->dsa_last_success != (time_t)0) ! 320: && (timenow - da->dsa_last_attempt < retry_timeout)) ! 321: return 1; /* a worked recentdlry */ ! 322: } else if (timenow - da->dsa_last_attempt < retry_timeout) ! 323: return -1; /* a failed recently */ ! 324: return 0; /* have not tried either recently */ ! 325: } ! 326: ! 327: if (da->dsa_failures == 0) { ! 328: if (db->dsa_failures == 0) ! 329: return 0; /* both OK */ ! 330: return 1; /* a worked last time, b failed - use a */ ! 331: } ! 332: ! 333: if (db->dsa_failures == 0) ! 334: return -1; /* b worked last time, a failed - use b */ ! 335: ! 336: /* both failed last time - see if either have suceeded recently */ ! 337: ! 338: if ((timenow - da->dsa_last_success) > retry_timeout ) { ! 339: if ((timenow - db->dsa_last_success) > retry_timeout) ! 340: return 0; /* too long ago to tell */ ! 341: return -1; /* use b it worked not that long ago... */ ! 342: } ! 343: if ((timenow - db->dsa_last_success) > retry_timeout) ! 344: return 1; /* use a it worked not that long ago... */ ! 345: ! 346: /* neither has worked recently chose some other way */ ! 347: return 0; ! 348: } ! 349: ! 350: static di_cmp_address (a,b) ! 351: struct di_block *a, *b; ! 352: { ! 353: struct NSAPaddr *na; ! 354: struct NSAPaddr *nb; ! 355: struct NSAPaddr nas; ! 356: struct TSAPaddr *ta2norm(); ! 357: struct TSAPaddr *ta; ! 358: struct TSAPaddr *tb; ! 359: int *ip; ! 360: extern DN mydsadn; ! 361: DN dnptr, mydnptr, dna,dnb; ! 362: int ma,mb; ! 363: ! 364: /* select DSA with best looking address !!! */ ! 365: ! 366: if (a->di_state == DI_COMPLETE) { ! 367: ta = &(a->di_entry->e_dsainfo->dsa_addr->pa_addr.sa_addr); ! 368: tb = &(b->di_entry->e_dsainfo->dsa_addr->pa_addr.sa_addr); ! 369: dna = a->di_dn; ! 370: dnb = b->di_dn; ! 371: } else { ! 372: /* Use 1 access point only */ ! 373: ta = &(a->di_accesspoints->ap_address->pa_addr.sa_addr); ! 374: tb = &(b->di_accesspoints->ap_address->pa_addr.sa_addr); ! 375: } ! 376: ! 377: /* ta2norm return a static buffer */ ! 378: ta = ta2norm (ta); ! 379: nas = *(ta->ta_addrs); /* struct copy */ ! 380: na = &nas; ! 381: tb = ta2norm (tb); ! 382: nb = tb->ta_addrs; ! 383: ! 384: /* normalised, so look for first "na" match with ts_communities */ ! 385: for (ip = ts_communities; *ip; ip++) { ! 386: if (*ip == na->na_community) { ! 387: if (*ip == nb->na_community) ! 388: break; /* same primary community */ ! 389: return 1; /* 'a' preferred */ ! 390: } ! 391: if (*ip == nb->na_community) ! 392: return -1; /* 'b' preferred */ ! 393: } ! 394: ! 395: /* Look at the DSA name to detect locality */ ! 396: ma=0; ! 397: for (dnptr=dna, mydnptr=mydsadn ; ! 398: (dnptr!=NULLDN) && (mydnptr!=NULLDN) ; ! 399: dnptr=dnptr->dn_parent, mydnptr=mydnptr->dn_parent) { ! 400: if (rdn_cmp(dnptr->dn_rdn,mydnptr->dn_rdn) == 0) ! 401: ma++; ! 402: } ! 403: ! 404: mb=0; ! 405: for (dnptr=dnb, mydnptr=mydsadn ; ! 406: (dnptr!=NULLDN) && (mydnptr!=NULLDN) ; ! 407: dnptr=dnptr->dn_parent, mydnptr=mydnptr->dn_parent) { ! 408: if (rdn_cmp(dnptr->dn_rdn,mydnptr->dn_rdn) == 0) ! 409: mb++; ! 410: } ! 411: ! 412: if (ma != mb) ! 413: return (ma > mb ? 1 : -1); ! 414: ! 415: /* check the DMD - NYI */ ! 416: return 0; ! 417: } ! 418: ! 419: static di_cmp (a,b) ! 420: struct di_block *a, *b; ! 421: /* ! 422: * Select best di_block ! 423: * rule 1: deferred dsa infos have lowest preference, ! 424: * complete have highest. ! 425: * ! 426: * If two block have same state, select using ! 427: * preference 1: quipu DSAs with quipu context ! 428: * preference 2: quipu DSAs ! 429: * preference 3: reliable DSAs ! 430: * preference 4: local DSAs ! 431: */ ! 432: { ! 433: int x,y; ! 434: ! 435: if (a->di_state != b->di_state) ! 436: return (a->di_state > b->di_state ? -1 : 1); /* rule 1 */ ! 437: ! 438: switch (a->di_state) { ! 439: case DI_DEFERRED: ! 440: break; ! 441: case DI_ACCESSPOINT: ! 442: if ((x = di_cmp_address(a,b)) != 0) { ! 443: DLOG (log_dsap,LLOG_TRACE,("AP selected on address")); ! 444: return x; /* preference 4 - no info to asses 1,2 or 3 */ ! 445: } ! 446: break; ! 447: case DI_COMPLETE: ! 448: x = quipu_ctx_supported (a->di_entry); ! 449: y = quipu_ctx_supported (b->di_entry); ! 450: if ( x != y ) { ! 451: DLOG (log_dsap,LLOG_TRACE,("DSA selected on context")); ! 452: return ( x > y ? 1 : -1); /* preference 1 or 2 */ ! 453: } ! 454: ! 455: if ((x=di_cmp_reliability (a,b)) != 0) { ! 456: DLOG (log_dsap,LLOG_TRACE,("DSA selected on relibility")); ! 457: return x; /* preference 3 */ ! 458: } ! 459: ! 460: if ((x=di_cmp_address(a,b)) != 0) { ! 461: DLOG (log_dsap,LLOG_TRACE,("DSA selected on address")); ! 462: return x; /* preference 4 */ ! 463: } ! 464: ! 465: break; ! 466: } ! 467: ! 468: return (di_prefer_dsa(a->di_dn, b->di_dn)); ! 469: } ! 470: ! 471: ! 472: sort_dsa_list (dsas) ! 473: struct di_block **dsas; ! 474: { ! 475: struct di_block *trail; ! 476: struct di_block *old_di, *new_di; ! 477: struct di_block *result; ! 478: char changed = FALSE; ! 479: ! 480: /* turn access point into complete references if possible */ ! 481: di_ap2comp (dsas); ! 482: ! 483: result = *dsas; ! 484: if ((old_di = result->di_next) == NULL_DI_BLOCK) ! 485: return; /* only 1 - must be sorted !!! */ ! 486: ! 487: result->di_next = NULL_DI_BLOCK; ! 488: ! 489: for(; old_di != NULL_DI_BLOCK; ) { ! 490: trail = NULL_DI_BLOCK; ! 491: for(new_di = result; new_di != NULL_DI_BLOCK; new_di= new_di->di_next) { ! 492: if ( di_cmp (old_di,new_di) > 0 ) { ! 493: if (trail == NULL_DI_BLOCK) { ! 494: result = old_di; ! 495: old_di = old_di->di_next; ! 496: result->di_next = new_di; ! 497: } else { ! 498: trail->di_next = old_di; ! 499: old_di = old_di->di_next; ! 500: trail->di_next->di_next = new_di; ! 501: } ! 502: changed = TRUE; ! 503: break; ! 504: } ! 505: trail = new_di; ! 506: } ! 507: if (new_di == NULL_DI_BLOCK) { ! 508: trail->di_next = old_di; ! 509: old_di = old_di->di_next; ! 510: trail->di_next->di_next = NULL_DI_BLOCK; ! 511: } ! 512: } ! 513: *dsas = result; ! 514: ! 515: if (changed) { ! 516: LLOG (log_dsap,LLOG_TRACE,("DSA order changed")); ! 517: #ifdef DEBUG ! 518: di_list_log (result); ! 519: #endif ! 520: } else ! 521: DLOG (log_dsap,LLOG_TRACE,("DSA order not changed")); ! 522: ! 523: } ! 524: ! 525: static int common_address (a,tb) ! 526: struct di_block *a; ! 527: struct TSAPaddr *tb; ! 528: { ! 529: struct TSAPaddr *ta; ! 530: struct NSAPaddr *na; ! 531: struct NSAPaddr *nb; ! 532: int x,y; ! 533: ! 534: /* select DSA with best looking address !!! */ ! 535: ! 536: if (a->di_state == DI_DEFERRED) ! 537: return FALSE; ! 538: ! 539: if (a->di_state == DI_COMPLETE) ! 540: ta = &(a->di_entry->e_dsainfo->dsa_addr->pa_addr.sa_addr); ! 541: else ! 542: /* Use 1 access point only */ ! 543: ta = &(a->di_accesspoints->ap_address->pa_addr.sa_addr); ! 544: ! 545: /* compare ta and tb to see if they have a network in common */ ! 546: for (na=ta->ta_addrs , x = ta->ta_naddr - 1 ; ! 547: x >= 0; ! 548: na++, x-- ) { ! 549: for (nb=tb->ta_addrs , y = tb->ta_naddr - 1 ; ! 550: y >= 0; ! 551: nb++, y-- ) { ! 552: if (na->na_community == nb->na_community) ! 553: return TRUE; ! 554: } ! 555: } ! 556: return FALSE; ! 557: } ! 558: ! 559: ! 560: struct di_block * select_refer_dsa(di,tk) ! 561: struct di_block *di; ! 562: struct task_act *tk; ! 563: { ! 564: struct di_block *best; ! 565: struct di_block *loop; ! 566: Entry eptr; ! 567: struct TSAPaddr *ta; ! 568: DN rdsa; ! 569: ! 570: /* return the di block of the best DSA the other end should be ! 571: to contact... ! 572: If it can't contact any - return NULL ! 573: */ ! 574: ! 575: if (di != NULL_DI_BLOCK) ! 576: best = di; ! 577: else ! 578: best = NULL_DI_BLOCK; ! 579: ! 580: /* First set - find out who the remote end is... */ ! 581: if (tk->tk_conn->cn_ctx == DS_CTX_X500_DAP) ! 582: return best; /* we will chain anyway - unless prevented by service control... */ ! 583: ! 584: rdsa = tk->tk_conn->cn_dn; ! 585: if ((eptr=local_find_entry (rdsa,FALSE)) == NULLENTRY) ! 586: return best; /* no way of knowing */ ! 587: ! 588: if (eptr->e_dsainfo == NULLDSA) ! 589: return best; /* no way of knowing */ ! 590: ! 591: ta = &(eptr->e_dsainfo->dsa_addr->pa_addr.sa_addr); ! 592: ta = ta2norm (ta); /* calculate subnets... */ ! 593: ! 594: for (loop=di; loop!=NULL_DI_BLOCK; loop=loop->di_next) ! 595: if (common_address (loop,ta)) ! 596: return loop; ! 597: ! 598: /* nothing on the same network - chain if possible !!! */ ! 599: return NULL_DI_BLOCK; ! 600: } ! 601:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.