Return to dn_str.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common

Annotation of 43BSDReno/contrib/isode-beta/dsap/common/dn_str.c, revision 1.1.1.1

1.1       root        1: #include "quipu/util.h"
                      2: #include "quipu/name.h"
                      3: 
                      4: static char dn_alias;
                      5: 
                      6: extern int dn_print ();
                      7: extern int dn_cmp ();
                      8: extern int dn_free ();
                      9: 
                     10: DN str2dn (str)
                     11: register char * str;
                     12: {
                     13: register char *ptr;
                     14: char *save,val;
                     15: char * aliasptr;
                     16: DN dn = NULLDN, newdn;
                     17: RDN rdn;
                     18: char * alias2name ();
                     19: char * SkipSpace ();
                     20: 
                     21:        if (str == NULLCP)
                     22:                return (NULLDN);
                     23: 
                     24:        if (*str == '@')
                     25:                str++;          /* Skip leading '@' signs for dish compat */
                     26: 
                     27:        while ( (ptr = index (str,'@')) != 0) {
                     28:                save = ptr++;
                     29:                save--;
                     30:                if (! isspace (*save))
                     31:                        save++;
                     32:                val = *save;
                     33:                *save = 0;
                     34: 
                     35: 
                     36:                if (dn == NULLDN)
                     37:                        /* try str as an alias */
                     38:                        if ((aliasptr = alias2name (SkipSpace(str))) != NULLCP) {
                     39:                                dn_alias = TRUE;
                     40:                                if ((newdn = str2dn(aliasptr)) == NULLDN) {
                     41:                                        parse_error ("Invalid alias '%s'",aliasptr);
                     42:                                        dn_free (dn);
                     43:                                        return (NULLDN);
                     44:                                }
                     45:                                dn = newdn;
                     46:                                *save = val;
                     47:                                str = ptr;
                     48:                                continue;       
                     49:                        }
                     50: 
                     51:                if ((rdn = str2rdn (str)) == NULLRDN) {
                     52:                        dn_free (dn);
                     53:                        return (NULLDN);
                     54:                } 
                     55:                if (dn == NULLDN)
                     56:                        dn = dn_comp_new (rdn);
                     57:                else
                     58:                        dn_append (dn,dn_comp_new (rdn));
                     59:                *save = val;
                     60:                str = ptr;
                     61:        }
                     62: 
                     63: 
                     64:        /* try str as an alias */
                     65:        if (dn == NULLDN)
                     66:                if ((aliasptr = alias2name (SkipSpace(str))) != NULLCP) {
                     67:                        dn_alias = TRUE;
                     68:                        if ((newdn = str2dn(aliasptr)) == NULLDN) {
                     69:                                parse_error ("Invalid alias '%s'",aliasptr);
                     70:                                dn_free (dn);
                     71:                                return (NULLDN);
                     72:                        }
                     73:                        return (newdn);
                     74:                }
                     75: 
                     76:        if ((rdn = str2rdn (str)) == NULLRDN) {
                     77:                dn_free (dn);
                     78:                return (NULLDN);
                     79:        }
                     80: 
                     81:        if (dn == NULLDN)
                     82:                dn = dn_comp_new (rdn);
                     83:        else
                     84:                dn_append (dn,dn_comp_new (rdn));
                     85: 
                     86:        return (dn);
                     87: }
                     88: 
                     89: DN str2dn_aux (str,alias)
                     90: char * str;
                     91: char *alias;
                     92: {
                     93: DN dn;
                     94:        dn_alias = FALSE;
                     95:        dn = str2dn (str);
                     96:        *alias = dn_alias;
                     97:        return (dn);
                     98: }
                     99: 
                    100: DN str2dnX (str)
                    101: register char * str;
                    102: {
                    103: register char * ptr;
                    104: 
                    105:        if ((ptr = rindex (str,'#')) != 0) {
                    106:                /* a bit or reverse compatability... */
                    107:                if (*++ptr != 0) {
                    108:                        parse_error ("invalid # in '%s'",str);
                    109:                        return (NULLDN);
                    110:                } else
                    111:                        *--ptr = 0;
                    112:        }
                    113:        return (str2dn(str));
                    114: }
                    115: 
                    116: DN dn_dec (pe)
                    117: PE pe;
                    118: {
                    119: DN adn;
                    120:        
                    121:        if (decode_IF_DistinguishedName(pe,1,NULLIP,NULLVP,&adn) == NOTOK)
                    122:                return (NULLDN);
                    123: 
                    124:        return (adn);
                    125: }
                    126: 
                    127: PE dn_enc (dn)
                    128: DN dn;
                    129: {
                    130: PE ret_pe;
                    131: 
                    132:        (void) encode_IF_DistinguishedName (&ret_pe,0,0,NULLCP,dn);
                    133:        return (ret_pe);
                    134: }
                    135: 
                    136: dn_syntax ()
                    137: {
                    138:        (void) add_attribute_syntax ("dn",
                    139:                (IFP) dn_enc,   (IFP) dn_dec,
                    140:                (IFP) str2dnX,  dn_print,
                    141:                (IFP) dn_cpy,   dn_cmp,
                    142:                dn_free,        NULLCP,
                    143:                NULLIFP,        TRUE );
                    144: }

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