Annotation of 43BSDReno/contrib/isode-beta/acsap/aetdbm.c, revision 1.1.1.1

1.1       root        1: /* aetdbm.c - application entity titles -- dbm lookup */
                      2: 
                      3: #ifndef        lint
                      4: static char *rcsid = "$Header: /f/osi/acsap/RCS/aetdbm.c,v 7.0 89/11/23 21:22:05 mrose Rel $";
                      5: #endif
                      6: 
                      7: /* 
                      8:  * $Header: /f/osi/acsap/RCS/aetdbm.c,v 7.0 89/11/23 21:22:05 mrose Rel $
                      9:  *
                     10:  *
                     11:  * $Log:       aetdbm.c,v $
                     12:  * Revision 7.0  89/11/23  21:22:05  mrose
                     13:  * Release 6.0
                     14:  * 
                     15:  */
                     16: 
                     17: /*
                     18:  *                               NOTICE
                     19:  *
                     20:  *    Acquisition, use, and distribution of this module and related
                     21:  *    materials are subject to the restrictions of a license agreement.
                     22:  *    Consult the Preface in the User's Manual for the full terms of
                     23:  *    this agreement.
                     24:  *
                     25:  */
                     26: 
                     27: 
                     28: /* LINTLIBRARY */
                     29: 
                     30: #include <stdio.h>
                     31: #include "psap.h"
                     32: #include "isoaddrs.h"
                     33: #include "tailor.h"
                     34: 
                     35: #ifdef AETDBM
                     36: #undef NULL
                     37: #include <dbm.h>
                     38: 
                     39: /*    DATA */
                     40: 
                     41: struct dbm_entry {
                     42:     struct isoentity   dbm_entity;
                     43: 
                     44:     unsigned int       dbm_elements[NELEM + 1];
                     45: };
                     46: 
                     47: 
                     48: static char *isoentities = "isoentities";
                     49: 
                     50: static int inited = 0;
                     51: 
                     52: static unsigned int elements[NELEM + 1];
                     53: static char objent[BUFSIZ];
                     54: 
                     55: /*  */
                     56: 
                     57: int    str2aet_dbm (designator, qualifier, iep)
                     58: char   *designator,
                     59:        *qualifier;
                     60: struct isoentity *iep;
                     61: {
                     62:     char   *cp,
                     63:            defent[BUFSIZ];
                     64:     register struct isoentity  *ie;
                     65:     struct isoentity ids,
                     66:                     ies;
                     67:     register struct dbm_entry *entry;
                     68:     datum   key,
                     69:            value;
                     70: 
                     71:     if (inited == 0) {
                     72:        if (dbminit (cp = isodefile (isoentities, 0)) < 0) {
                     73:            SLOG (addr_log, LLOG_EXCEPTIONS, NULLCP,
                     74:                  ("unable to initialize %s", cp));
                     75: 
                     76:            return str2aet_seq (designator, qualifier, iep);
                     77:        }
                     78: 
                     79:        inited = 1;
                     80:     }
                     81: 
                     82:     (void) sprintf (objent, "%s-%s", designator, qualifier);
                     83: 
                     84:     ie = &ies;
                     85: 
                     86:     key.dsize = strlen (key.dptr = objent) + 1;
                     87:     value = fetch (key);
                     88:     if (entry = (struct dbm_entry *) value.dptr) {
                     89:        if (value.dsize != sizeof *entry) {
                     90:            SLOG (addr_log, LLOG_EXCEPTIONS, NULLCP,
                     91:                  ("isoentities dbm corrupt!"));
                     92: 
                     93:            return str2aet_seq (designator, qualifier, iep);
                     94:        }
                     95: 
                     96:        bcopy ((char *) &entry -> dbm_entity, (char *) ie, sizeof *ie);
                     97:        bcopy ((char *) entry -> dbm_elements, (char *) elements,
                     98:               sizeof elements);
                     99:        ie -> ie_identifier.oid_elements = elements;
                    100:        ie -> ie_descriptor = objent;
                    101:     }
                    102:     else {
                    103:        (void) sprintf (defent, "%s-%s", "default", qualifier);
                    104:        key.dsize = strlen (key.dptr = defent) + 1;
                    105:        value = fetch (key);
                    106:        if (entry = (struct dbm_entry *) value.dptr) {
                    107:            if (value.dsize != sizeof *entry) {
                    108:                SLOG (addr_log, LLOG_EXCEPTIONS, NULLCP,
                    109:                      ("isoentities dbm corrupt!"));
                    110: 
                    111:                return str2aet_seq (designator, qualifier, iep);
                    112:            }
                    113: 
                    114:            bcopy ((char *) &entry -> dbm_entity, (char *) ie, sizeof *ie);
                    115:            bcopy ((char *) entry -> dbm_elements, (char *) elements,
                    116:                   sizeof elements);
                    117:            ie -> ie_identifier.oid_elements = elements;
                    118:            ie -> ie_descriptor = objent;
                    119:        }
                    120:        else
                    121:            return NOTOK;
                    122: 
                    123:        (void) sprintf (defent, "%s-%s", designator, "default");
                    124:        key.dsize = strlen (key.dptr = defent) + 1;
                    125:        value = fetch (key);
                    126:        if (entry = (struct dbm_entry *) value.dptr) {
                    127:            if (value.dsize != sizeof *entry) {
                    128:                SLOG (addr_log, LLOG_EXCEPTIONS, NULLCP,
                    129:                      ("isoentities dbm corrupt!"));
                    130: 
                    131:                return str2aet_seq (designator, qualifier, iep);
                    132:            }
                    133: 
                    134:            bcopy ((char *) &entry -> dbm_entity, (char *) &ids, sizeof ids);
                    135:            ids.ie_identifier.oid_elements = entry -> dbm_elements;
                    136:            ids.ie_descriptor = objent;
                    137: 
                    138:            bcopy ((char *) ids.ie_addr.pa_addr.sa_addr.ta_addrs,
                    139:                   (char *) ie -> ie_addr.pa_addr.sa_addr.ta_addrs,
                    140:                   sizeof ie -> ie_addr.pa_addr.sa_addr.ta_addrs);
                    141:            ie -> ie_addr.pa_addr.sa_addr.ta_naddr =
                    142:                ids.ie_addr.pa_addr.sa_addr.ta_naddr;
                    143:        }
                    144:     }
                    145: 
                    146:     *iep = *ie;            /* struct copy */
                    147: 
                    148:     return OK;
                    149: }
                    150: #endif

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.