![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dn_seq.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 / dsap / common|
Return to dn_seq.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common |
1.1 root 1: /* dn_seq.c - General Directory Name Sequence routines */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/dsap/common/RCS/dn_seq.c,v 7.0 89/11/23 21:42:06 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/dsap/common/RCS/dn_seq.c,v 7.0 89/11/23 21:42:06 mrose Rel $
9: *
10: *
11: * $Log: dn_seq.c,v $
12: * Revision 7.0 89/11/23 21:42:06 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 "quipu/util.h"
31: #include "quipu/entry.h"
32:
33: dn_seq_free (dnseq)
34: struct dn_seq * dnseq;
35: {
36: struct dn_seq * ptr;
37: struct dn_seq * next;
38:
39: for (ptr=dnseq ; ptr!=NULLDNSEQ; ptr=next ) {
40: next = ptr->dns_next;
41: dn_free (ptr->dns_dn);
42: free ((char *) ptr);
43: }
44:
45: }
46:
47: struct dn_seq * dn_seq_cpy (dnseq)
48: struct dn_seq * dnseq;
49: {
50: register struct dn_seq * ptr;
51: struct dn_seq * ptr2;
52: struct dn_seq * result = NULLDNSEQ;
53:
54:
55: for (ptr=dnseq ; ptr!=NULLDNSEQ; ptr=ptr->dns_next ) {
56: ptr2 = dn_seq_alloc();
57: ptr2 -> dns_next = result;
58: result = ptr2;
59: result->dns_dn = dn_cpy (ptr->dns_dn);
60: }
61: return (result);
62: }
63:
64:
65: check_dnseq (dnseq,who)
66: struct dn_seq * dnseq;
67: DN who;
68: {
69: register struct dn_seq * ptr;
70:
71: for (ptr=dnseq; ptr!=NULLDNSEQ; ptr=ptr->dns_next) {
72: if (dn_cmp (who,ptr->dns_dn) == OK)
73: return (OK);
74: }
75:
76: return (NOTOK);
77: }
78:
79: dn_seq_cmp (a,b)
80: struct dn_seq * a, * b;
81: {
82: struct dn_seq * dns1;
83: struct dn_seq * dns2;
84:
85: if((a == NULLDNSEQ) && (b == NULLDNSEQ))
86: return(0);
87:
88: if(a==NULLDNSEQ)
89: return(-1);
90:
91: if(b==NULLDNSEQ)
92: return(1);
93:
94: for (dns1=a; dns1!=NULLDNSEQ; dns1=dns1->dns_next)
95: {
96: for (dns2=b; dns2!=NULLDNSEQ; dns2=dns2->dns_next)
97: {
98: if(dn_cmp (dns1->dns_dn,dns2->dns_dn) == 0)
99: break;
100: }
101: if(dns2 == NULLDNSEQ)
102: return(1);
103: }
104:
105: for (dns2=b; dns2!=NULLDNSEQ; dns2=dns2->dns_next)
106: {
107: for (dns1=a; dns1!=NULLDNSEQ; dns1=dns1->dns_next)
108: {
109: if(dn_cmp (dns1->dns_dn,dns2->dns_dn) == 0)
110: break;
111: }
112: if(dns1 == NULLDNSEQ)
113: return(-1);
114: }
115:
116: return (0);
117: }
118:
119: check_dnseq_prefix (dnseq,who)
120: struct dn_seq * dnseq;
121: DN who;
122: {
123: struct dn_seq * ptr;
124:
125: for (ptr=dnseq; ptr!=NULLDNSEQ; ptr=ptr->dns_next) {
126: if (dn_cmp_prefix (ptr->dns_dn,who) == OK)
127: return (OK);
128: }
129:
130: return (NOTOK);
131: }
132:
133: dn_seq_print (ps,dnseq,format)
134: PS ps;
135: struct dn_seq * dnseq;
136: int format;
137: {
138: if (dnseq == NULLDNSEQ)
139: return;
140:
141: dn_print (ps,dnseq->dns_dn,EDBOUT);
142: for (dnseq=dnseq->dns_next; dnseq!=NULLDNSEQ; dnseq=dnseq->dns_next) {
143: if (format == READOUT)
144: ps_print (ps," AND ");
145: else
146: ps_print (ps,"$");
147: dn_print (ps,dnseq->dns_dn,EDBOUT);
148: }
149: }
150:
151: struct dn_seq * str2dnseq (str)
152: register char * str;
153: {
154: register char *ptr;
155: register char *save,val;
156: struct dn_seq * dns = NULLDNSEQ;
157: struct dn_seq * newdns;
158:
159: while ( (ptr = index (str,'$')) != 0) {
160: save = ptr++;
161: save--;
162: if (! isspace (*save))
163: save++;
164: val = *save;
165: *save = 0;
166: newdns = dn_seq_alloc();
167: if ((newdns->dns_dn = str2dn (str)) == NULLDN) {
168: dn_seq_free (dns);
169: free ((char *) newdns);
170: return (NULLDNSEQ);
171: }
172: newdns->dns_next = dns;
173: dns = newdns;
174: *save = val;
175: str = ptr;
176: }
177:
178: if ((ptr = rindex (str,'#')) != 0) {
179: /* a bit or reverse compatability... */
180: if (*++ptr != 0) {
181: parse_error ("invalid # in sequence '%s'",str);
182: dn_seq_free (dns);
183: return (NULLDNSEQ);
184: }
185: else
186: *--ptr = 0;
187: }
188:
189: newdns = dn_seq_alloc();
190: if ((newdns->dns_dn = str2dn (str)) == NULLDN) {
191: dn_seq_free (dns);
192: free ((char *) newdns);
193: return (NULLDNSEQ);
194: }
195: newdns->dns_next = dns;
196: dns = newdns;
197:
198: return (dns);
199: }
200:
201: int dn_in_dnseq(dn, dnseq)
202: DN dn;
203: struct dn_seq * dnseq;
204: {
205: struct dn_seq * ptr;
206: register int i = 1;
207:
208: for(ptr=dnseq; ptr!=NULLDNSEQ; ptr=ptr->dns_next, i++)
209: {
210: if(dn_cmp(dn, ptr->dns_dn) == 0)
211: break;
212: }
213:
214: if(ptr == NULLDNSEQ)
215: return(FALSE);
216:
217: return(i);
218: }
219:
220: struct dn_seq * dn_seq_push(dn,dnseq)
221: DN dn;
222: struct dn_seq * dnseq;
223: {
224: struct dn_seq * ret;
225:
226: ret = dn_seq_alloc();
227:
228: ret->dns_dn = dn_cpy(dn);
229: ret->dns_next = dnseq;
230:
231: return(ret);
232: }
233:
234: struct dn_seq * dn_seq_pop(dnseq)
235: struct dn_seq * dnseq;
236: {
237: struct dn_seq * ret;
238:
239: if(dnseq == NULLDNSEQ)
240: return(NULLDNSEQ);
241:
242: ret = dnseq->dns_next;
243:
244: dn_free(dnseq->dns_dn);
245: free((char *)dnseq);
246:
247: return(ret);
248: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.