![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to revoke.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 revoke.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common |
1.1 root 1: /* revoke.c - Certificate List attribute syntax */
2:
3: /* This syntax is still at the testing stage. Accordingly, quipu should
4: * not load this syntax (just in case).
5: */
6:
7:
8: #ifndef lint
9: static char *rcsid = "$Header: /f/osi/dsap/common/RCS/revoke.c,v 7.2 90/01/11 18:35:36 mrose Exp $";
10: #endif
11:
12: /*
13: * $Header: /f/osi/dsap/common/RCS/revoke.c,v 7.2 90/01/11 18:35:36 mrose Exp $
14: *
15: *
16: * $Log: revoke.c,v $
17: * Revision 7.2 90/01/11 18:35:36 mrose
18: * real-sync
19: *
20: * Revision 7.1 89/12/19 16:19:31 mrose
21: * sync
22: *
23: * Revision 7.0 89/11/23 21:47:45 mrose
24: * Release 6.0
25: *
26: */
27:
28: /*
29: * NOTICE
30: *
31: * Acquisition, use, and distribution of this module and related
32: * materials are subject to the restrictions of a license agreement.
33: * Consult the Preface in the User's Manual for the full terms of
34: * this agreement.
35: *
36: */
37:
38:
39: #include <stdio.h>
40:
41: #include "quipu/util.h"
42: #include "quipu/entry.h"
43: #include "quipu/bind.h"
44:
45: PE enc_revoke(parm)
46: struct revocation_list *parm;
47: {
48: PE pe;
49: encode_AF_CertificateList(&pe, 0, 0, NULLCP, parm);
50: return (pe);
51: }
52:
53: struct revocation_list *dec_revoke(pe)
54: PE pe;
55: {
56: struct revocation_list *result;
57:
58: if (decode_AF_CertificateList(pe, 0, NULLIP, NULLVP, &result) == NOTOK)
59: return (struct revocation_list *) 0;
60: return (result);
61: }
62:
63: struct revocation_list *str2revoke(str)
64: char *str;
65: {
66: struct revocation_list *result;
67: struct revoked_certificate *cert;
68: struct revoked_certificate **last;
69: OID oid;
70: char *ptr;
71:
72: result = (struct revocation_list *) calloc(1, sizeof(*result));
73: if (result == (struct revocation_list *) 0)
74: return (result);
75:
76: ptr = index(str, '#');
77: if (ptr)
78: {
79: *ptr = '\0';
80: ptr++;
81: }
82: else
83: return (struct revocation_list *) 0;
84:
85: oid = name2oid(str);
86: if (oid == NULLOID)
87: {
88: parse_error("Invalid OID %s", str);
89: return (struct revocation_list *) 0;
90: }
91: result->sig.alg.algorithm = oid;
92:
93: str = ptr;
94: ptr = index(str, '#');
95: if (ptr)
96: {
97: *ptr = '\0';
98: ptr++;
99: }
100: else
101: return (struct revocation_list *) 0;
102:
103: str2alg(str, &(result->sig.alg));
104:
105: str=ptr;
106: ptr = index(str, '#');
107: if (ptr)
108: {
109: *ptr = '\0';
110: ptr++;
111: }
112:
113: str2encrypted(str, &(result->sig.encrypted), &(result->sig.n_bits));
114:
115: str=ptr;
116: ptr = index(str, '#');
117: if (ptr)
118: {
119: *ptr = '\0';
120: ptr++;
121: }
122:
123: result->issuer = str2dn(str);
124:
125: str=ptr;
126: ptr = index(str, '#');
127: if (ptr)
128: {
129: *ptr = '\0';
130: ptr++;
131: }
132: else
133: return (struct revocation_list *) 0;
134:
135: oid = name2oid(str);
136: if (oid == NULLOID)
137: {
138: parse_error("Invalid OID %s", str);
139: return (struct revocation_list *) 0;
140: }
141: result->alg.algorithm = oid;
142:
143: str=ptr;
144: ptr = index(str, '#');
145: if (ptr)
146: {
147: *ptr = '\0';
148: ptr++;
149: }
150: else return (struct revocation_list *) 0;
151:
152: str2alg(str, &(result->alg));
153:
154: str=ptr;
155: ptr = index(str, '#');
156: if (ptr)
157: {
158: *ptr = '\0';
159: ptr++;
160: }
161: /* This may be the end of the string */
162:
163: result->last_update = strdup(str);
164:
165: if ((str = ptr) == NULLCP)
166: return (result);
167: ptr = index(str, '#');
168: if (ptr == NULLCP)
169: return(result);
170:
171: *ptr = '\0';
172: ptr++;
173:
174: oid = name2oid(str);
175: result->sig2.alg.algorithm = oid;
176:
177: str=ptr;
178: ptr = index(str, '#');
179: if (ptr)
180: {
181: *ptr = '\0';
182: ptr++;
183: }
184: else
185: return (struct revocation_list *) 0;
186:
187: str2alg(str, &(result->sig2.alg));
188:
189: str=ptr;
190: ptr = index(str, '#');
191: if (ptr)
192: {
193: *ptr = '\0';
194: ptr++;
195: }
196: /* This may be the end of the string */
197:
198: str2encrypted(str, &(result->sig2.encrypted), &(result->sig2.n_bits));
199:
200: last = (struct revoked_certificate **) &(result->revoked);
201:
202: while (str = ptr, ((ptr = index(str, '#')) != NULLCP))
203: {
204: *ptr = '\0';
205: ptr++;
206:
207: cert = (struct revoked_certificate *) calloc(1, sizeof(*cert));
208: if (cert == (struct revoked_certificate *) 0)
209: return ((struct revocation_list *) 0);
210:
211: *last = cert;
212: last = &(cert->next);
213: cert->next = (struct revoked_certificate *) 0;
214:
215: cert->subject = str2dn(str);
216: if (cert->subject == NULLDN)
217: {
218: parse_error("Invalid DN %s", str);
219: return ((struct revocation_list *) 0);
220: }
221:
222: str=ptr;
223: ptr = index(str, '#');
224: if (ptr)
225: {
226: *ptr = '\0';
227: ptr++;
228: }
229: else
230: return (struct revocation_list *) 0;
231:
232: oid = name2oid(str);
233: if (oid == NULLOID)
234: {
235: parse_error("Invalid OID %s", str);
236: return (struct revocation_list *) 0;
237: }
238:
239: cert->alg.algorithm = oid;
240:
241: str=ptr;
242: ptr = index(str, '#');
243: if (ptr)
244: {
245: *ptr = '\0';
246: ptr++;
247: }
248: else
249: return (struct revocation_list *) 0;
250:
251: str2alg(str, &(cert->alg));
252:
253: str=ptr;
254: ptr = index(str, '#');
255: if (ptr)
256: {
257: *ptr = '\0';
258: ptr++;
259: }
260: else
261: return (struct revocation_list *) 0;
262:
263: cert->serial = atoi(str);
264:
265: str=ptr;
266: ptr = index(str, '#');
267: if (ptr)
268: {
269: *ptr = '\0';
270: ptr++;
271: }
272: /* may be the end of the string */
273:
274: cert->revocation_date = strdup(str);
275:
276: }
277:
278: return (result);
279: }
280:
281: print_revoked(ps, parm, format)
282: PS ps;
283: struct revoked_certificate *parm;
284: int format;
285: {
286: struct revoked_certificate *tmp;
287:
288: tmp = parm;
289: while (tmp)
290: {
291: dn_print(ps, tmp->subject, EDBOUT);
292: ps_printf(ps, "#");
293: print_algid(ps, &(tmp->alg), format);
294: ps_printf(ps, "%d#", tmp->serial);
295: ps_printf(ps, "%s#", tmp->revocation_date);
296: tmp = tmp->next;
297: }
298: }
299:
300: print_revoke(ps, parm, format)
301: PS ps;
302: struct revocation_list *parm;
303: int format;
304: {
305: print_algid(ps, &(parm->sig.alg), format);
306: print_encrypted(ps, parm->sig.encrypted, parm->sig.n_bits, format);
307:
308: dn_print(ps, parm->issuer, EDBOUT);
309: ps_printf(ps, "#");
310: print_algid(ps, &(parm->alg), format);
311: utcprint(ps, parm->last_update, format);
312: ps_printf(ps, "#");
313: if (parm->revoked)
314: {
315: print_algid(ps, &(parm->sig2.alg), format);
316: print_encrypted(ps, parm->sig2.encrypted,
317: parm->sig2.n_bits, format);
318: print_revoked(ps, parm->revoked, format);
319: }
320:
321: }
322:
323: struct revocation_list *revoke_cpy(parm)
324: struct revocation_list *parm;
325: {
326: return (parm);
327: }
328:
329: revoke_cmp(a, b)
330: struct revocation_list *a, *b;
331: {
332: int ret;
333:
334: ret = dn_cmp(a->issuer, b->issuer);
335: if (ret != 0)
336: return (ret);
337: ret = strcmp(a->last_update, b->last_update);
338: if (ret != 0)
339: return (ret);
340:
341: return (0);
342: }
343:
344: /* ARGSUSED */
345:
346: revoke_free(parm)
347: struct signature *parm;
348: {
349: }
350:
351: revoke_syntax()
352: {
353: (void) add_attribute_syntax(
354: "CertificateList",
355: (IFP)enc_revoke, (IFP)dec_revoke,
356: (IFP)str2revoke, print_revoke,
357: (IFP)revoke_cpy, revoke_cmp,
358: revoke_free, NULLCP,
359: NULLIFP, TRUE);
360: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.