Fix warnings in rxkad
[openafs.git] / src / rxkad / v5der.c
1 #include "asn1_err.h"
2 #include <errno.h>
3 /*
4  * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan
5  * (Royal Institute of Technology, Stockholm, Sweden). 
6  * All rights reserved. 
7  *
8  * Redistribution and use in source and binary forms, with or without 
9  * modification, are permitted provided that the following conditions 
10  * are met: 
11  *
12  * 1. Redistributions of source code must retain the above copyright 
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright 
16  *    notice, this list of conditions and the following disclaimer in the 
17  *    documentation and/or other materials provided with the distribution. 
18  *
19  * 3. Neither the name of the Institute nor the names of its contributors 
20  *    may be used to endorse or promote products derived from this software 
21  *    without specific prior written permission. 
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
33  * SUCH DAMAGE. 
34  */
35
36
37 /* RCSID("Heimdal: der_get.c,v 1.33 2002/09/03 16:21:49 nectar Exp $"); */
38
39
40 /* 
41  * All decoding functions take a pointer `p' to first position in
42  * which to read, from the left, `len' which means the maximum number
43  * of characters we are able to read, `ret' were the value will be
44  * returned and `size' where the number of used bytes is stored.
45  * Either 0 or an error code is returned.
46  */
47
48 static int
49 der_get_unsigned(const unsigned char *p, size_t len, unsigned *ret,
50                  size_t * size)
51 {
52     unsigned val = 0;
53     size_t oldlen = len;
54
55     while (len--)
56         val = val * 256 + *p++;
57     *ret = val;
58     if (size)
59         *size = oldlen;
60     return 0;
61 }
62
63 int
64 der_get_int(const unsigned char *p, size_t len, int *ret, size_t * size)
65 {
66     int val = 0;
67     size_t oldlen = len;
68
69     if (len > 0) {
70         val = (signed char)*p++;
71         while (--len)
72             val = val * 256 + *p++;
73     }
74     *ret = val;
75     if (size)
76         *size = oldlen;
77     return 0;
78 }
79
80 int
81 der_get_length(const unsigned char *p, size_t len, size_t * val,
82                size_t * size)
83 {
84     size_t v;
85
86     if (len <= 0)
87         return ASN1_OVERRUN;
88     --len;
89     v = *p++;
90     if (v < 128) {
91         *val = v;
92         if (size)
93             *size = 1;
94     } else {
95         int e;
96         size_t l;
97         unsigned tmp;
98
99         if (v == 0x80) {
100             *val = ASN1_INDEFINITE;
101             if (size)
102                 *size = 1;
103             return 0;
104         }
105         v &= 0x7F;
106         if (len < v)
107             return ASN1_OVERRUN;
108         e = der_get_unsigned(p, v, &tmp, &l);
109         if (e)
110             return e;
111         *val = tmp;
112         if (size)
113             *size = l + 1;
114     }
115     return 0;
116 }
117
118 int
119 der_get_general_string(const unsigned char *p, size_t len,
120                        general_string * str, size_t * size)
121 {
122     char *s;
123
124     s = malloc(len + 1);
125     if (s == NULL)
126         return ENOMEM;
127     memcpy(s, p, len);
128     s[len] = '\0';
129     *str = s;
130     if (size)
131         *size = len;
132     return 0;
133 }
134
135 int
136 der_get_octet_string(const unsigned char *p, size_t len, octet_string * data,
137                      size_t * size)
138 {
139     data->length = len;
140     data->data = malloc(len);
141     if (data->data == NULL && data->length != 0)
142         return ENOMEM;
143     memcpy(data->data, p, len);
144     if (size)
145         *size = len;
146     return 0;
147 }
148
149 int
150 der_get_oid(const unsigned char *p, size_t len, oid * data, size_t * size)
151 {
152     int n;
153     size_t oldlen = len;
154
155     if (len < 1)
156         return ASN1_OVERRUN;
157
158     data->components = malloc(len * sizeof(*data->components));
159     if (data->components == NULL && len != 0)
160         return ENOMEM;
161     data->components[0] = (*p) / 40;
162     data->components[1] = (*p) % 40;
163     --len;
164     ++p;
165     for (n = 2; len > 0; ++n) {
166         unsigned u = 0;
167
168         do {
169             --len;
170             u = u * 128 + (*p++ % 128);
171         } while (len > 0 && p[-1] & 0x80);
172         data->components[n] = u;
173     }
174     if (p[-1] & 0x80) {
175         free_oid(data);
176         return ASN1_OVERRUN;
177     }
178     data->length = n;
179     if (size)
180         *size = oldlen;
181     return 0;
182 }
183
184 int
185 der_get_tag(const unsigned char *p, size_t len, Der_class * class,
186             Der_type * type, int *tag, size_t * size)
187 {
188     if (len < 1)
189         return ASN1_OVERRUN;
190     *class = (Der_class) (((*p) >> 6) & 0x03);
191     *type = (Der_type) (((*p) >> 5) & 0x01);
192     *tag = (*p) & 0x1F;
193     if (size)
194         *size = 1;
195     return 0;
196 }
197
198 int
199 der_match_tag(const unsigned char *p, size_t len, Der_class class,
200               Der_type type, int tag, size_t * size)
201 {
202     size_t l;
203     Der_class thisclass;
204     Der_type thistype;
205     int thistag;
206     int e;
207
208     e = der_get_tag(p, len, &thisclass, &thistype, &thistag, &l);
209     if (e)
210         return e;
211     if (class != thisclass || type != thistype)
212         return ASN1_BAD_ID;
213     if (tag > thistag)
214         return ASN1_MISPLACED_FIELD;
215     if (tag < thistag)
216         return ASN1_MISSING_FIELD;
217     if (size)
218         *size = l;
219     return 0;
220 }
221
222 int
223 der_match_tag_and_length(const unsigned char *p, size_t len, Der_class class,
224                          Der_type type, int tag, size_t * length_ret,
225                          size_t * size)
226 {
227     size_t l, ret = 0;
228     int e;
229
230     e = der_match_tag(p, len, class, type, tag, &l);
231     if (e)
232         return e;
233     p += l;
234     len -= l;
235     ret += l;
236     e = der_get_length(p, len, length_ret, &l);
237     if (e)
238         return e;
239     p += l;
240     len -= l;
241     ret += l;
242     if (size)
243         *size = ret;
244     return 0;
245 }
246
247 int
248 decode_integer(const unsigned char *p, size_t len, int *num, size_t * size)
249 {
250     size_t ret = 0;
251     size_t l, reallen;
252     int e;
253
254     e = der_match_tag(p, len, UNIV, PRIM, UT_Integer, &l);
255     if (e)
256         return e;
257     p += l;
258     len -= l;
259     ret += l;
260     e = der_get_length(p, len, &reallen, &l);
261     if (e)
262         return e;
263     p += l;
264     len -= l;
265     ret += l;
266     if (reallen > len)
267         return ASN1_OVERRUN;
268     e = der_get_int(p, reallen, num, &l);
269     if (e)
270         return e;
271     p += l;
272     len -= l;
273     ret += l;
274     if (size)
275         *size = ret;
276     return 0;
277 }
278
279 int
280 decode_unsigned(const unsigned char *p, size_t len, unsigned *num,
281                 size_t * size)
282 {
283     size_t ret = 0;
284     size_t l, reallen;
285     int e;
286
287     e = der_match_tag(p, len, UNIV, PRIM, UT_Integer, &l);
288     if (e)
289         return e;
290     p += l;
291     len -= l;
292     ret += l;
293     e = der_get_length(p, len, &reallen, &l);
294     if (e)
295         return e;
296     p += l;
297     len -= l;
298     ret += l;
299     if (reallen > len)
300         return ASN1_OVERRUN;
301     e = der_get_unsigned(p, reallen, num, &l);
302     if (e)
303         return e;
304     p += l;
305     len -= l;
306     ret += l;
307     if (size)
308         *size = ret;
309     return 0;
310 }
311
312 int
313 decode_enumerated(const unsigned char *p, size_t len, unsigned *num,
314                   size_t * size)
315 {
316     size_t ret = 0;
317     size_t l, reallen;
318     int e;
319
320     e = der_match_tag(p, len, UNIV, PRIM, UT_Enumerated, &l);
321     if (e)
322         return e;
323     p += l;
324     len -= l;
325     ret += l;
326     e = der_get_length(p, len, &reallen, &l);
327     if (e)
328         return e;
329     p += l;
330     len -= l;
331     ret += l;
332     e = der_get_unsigned(p, reallen, num, &l);
333     if (e)
334         return e;
335     p += l;
336     len -= l;
337     ret += l;
338     if (size)
339         *size = ret;
340     return 0;
341 }
342
343 int
344 decode_general_string(const unsigned char *p, size_t len,
345                       general_string * str, size_t * size)
346 {
347     size_t ret = 0;
348     size_t l;
349     int e;
350     size_t slen;
351
352     e = der_match_tag(p, len, UNIV, PRIM, UT_GeneralString, &l);
353     if (e)
354         return e;
355     p += l;
356     len -= l;
357     ret += l;
358
359     e = der_get_length(p, len, &slen, &l);
360     if (e)
361         return e;
362     p += l;
363     len -= l;
364     ret += l;
365     if (len < slen)
366         return ASN1_OVERRUN;
367
368     e = der_get_general_string(p, slen, str, &l);
369     if (e)
370         return e;
371     p += l;
372     len -= l;
373     ret += l;
374     if (size)
375         *size = ret;
376     return 0;
377 }
378
379 int
380 decode_octet_string(const unsigned char *p, size_t len, octet_string * k,
381                     size_t * size)
382 {
383     size_t ret = 0;
384     size_t l;
385     int e;
386     size_t slen;
387
388     e = der_match_tag(p, len, UNIV, PRIM, UT_OctetString, &l);
389     if (e)
390         return e;
391     p += l;
392     len -= l;
393     ret += l;
394
395     e = der_get_length(p, len, &slen, &l);
396     if (e)
397         return e;
398     p += l;
399     len -= l;
400     ret += l;
401     if (len < slen)
402         return ASN1_OVERRUN;
403
404     e = der_get_octet_string(p, slen, k, &l);
405     if (e)
406         return e;
407     p += l;
408     len -= l;
409     ret += l;
410     if (size)
411         *size = ret;
412     return 0;
413 }
414
415 int
416 decode_oid(const unsigned char *p, size_t len, oid * k, size_t * size)
417 {
418     size_t ret = 0;
419     size_t l;
420     int e;
421     size_t slen;
422
423     e = der_match_tag(p, len, UNIV, PRIM, UT_OID, &l);
424     if (e)
425         return e;
426     p += l;
427     len -= l;
428     ret += l;
429
430     e = der_get_length(p, len, &slen, &l);
431     if (e)
432         return e;
433     p += l;
434     len -= l;
435     ret += l;
436     if (len < slen)
437         return ASN1_OVERRUN;
438
439     e = der_get_oid(p, slen, k, &l);
440     if (e)
441         return e;
442     p += l;
443     len -= l;
444     ret += l;
445     if (size)
446         *size = ret;
447     return 0;
448 }
449
450 static void
451 generalizedtime2time(const char *s, time_t * t)
452 {
453     struct tm tm;
454
455     memset(&tm, 0, sizeof(tm));
456     sscanf(s, "%04d%02d%02d%02d%02d%02dZ", &tm.tm_year, &tm.tm_mon,
457            &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
458     tm.tm_year -= 1900;
459     tm.tm_mon -= 1;
460     *t = timegm(&tm);
461 }
462
463 int
464 decode_generalized_time(const unsigned char *p, size_t len, time_t * t,
465                         size_t * size)
466 {
467     octet_string k;
468     char *times;
469     size_t ret = 0;
470     size_t l;
471     int e;
472     size_t slen;
473
474     e = der_match_tag(p, len, UNIV, PRIM, UT_GeneralizedTime, &l);
475     if (e)
476         return e;
477     p += l;
478     len -= l;
479     ret += l;
480
481     e = der_get_length(p, len, &slen, &l);
482     if (e)
483         return e;
484     p += l;
485     len -= l;
486     ret += l;
487     if (len < slen)
488         return ASN1_OVERRUN;
489     e = der_get_octet_string(p, slen, &k, &l);
490     if (e)
491         return e;
492     p += l;
493     len -= l;
494     ret += l;
495     times = realloc(k.data, k.length + 1);
496     if (times == NULL) {
497         free(k.data);
498         return ENOMEM;
499     }
500     times[k.length] = 0;
501     generalizedtime2time(times, t);
502     free(times);
503     if (size)
504         *size = ret;
505     return 0;
506 }
507
508
509 int
510 fix_dce(size_t reallen, size_t * len)
511 {
512     if (reallen == ASN1_INDEFINITE)
513         return 1;
514     if (*len < reallen)
515         return -1;
516     *len = reallen;
517     return 0;
518 }
519
520 /*
521  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
522  * (Royal Institute of Technology, Stockholm, Sweden). 
523  * All rights reserved. 
524  *
525  * Redistribution and use in source and binary forms, with or without 
526  * modification, are permitted provided that the following conditions 
527  * are met: 
528  *
529  * 1. Redistributions of source code must retain the above copyright 
530  *    notice, this list of conditions and the following disclaimer. 
531  *
532  * 2. Redistributions in binary form must reproduce the above copyright 
533  *    notice, this list of conditions and the following disclaimer in the 
534  *    documentation and/or other materials provided with the distribution. 
535  *
536  * 3. Neither the name of the Institute nor the names of its contributors 
537  *    may be used to endorse or promote products derived from this software 
538  *    without specific prior written permission. 
539  *
540  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
541  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
542  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
543  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
544  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
545  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
546  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
547  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
548  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
549  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
550  * SUCH DAMAGE. 
551  */
552
553
554 /* RCSID("Heimdal: der_put.c,v 1.27 2001/09/25 23:37:25 assar Exp $"); */
555
556 /*
557  * All encoding functions take a pointer `p' to first position in
558  * which to write, from the right, `len' which means the maximum
559  * number of characters we are able to write.  The function returns
560  * the number of characters written in `size' (if non-NULL).
561  * The return value is 0 or an error.
562  */
563
564 static int
565 der_put_unsigned(unsigned char *p, size_t len, unsigned val, size_t * size)
566 {
567     unsigned char *base = p;
568
569     if (val) {
570         while (len > 0 && val) {
571             *p-- = val % 256;
572             val /= 256;
573             --len;
574         }
575         if (val != 0)
576             return ASN1_OVERFLOW;
577         else {
578             *size = base - p;
579             return 0;
580         }
581     } else if (len < 1)
582         return ASN1_OVERFLOW;
583     else {
584         *p = 0;
585         *size = 1;
586         return 0;
587     }
588 }
589
590 int
591 der_put_int(unsigned char *p, size_t len, int val, size_t * size)
592 {
593     unsigned char *base = p;
594
595     if (val >= 0) {
596         do {
597             if (len < 1)
598                 return ASN1_OVERFLOW;
599             *p-- = val % 256;
600             len--;
601             val /= 256;
602         } while (val);
603         if (p[1] >= 128) {
604             if (len < 1)
605                 return ASN1_OVERFLOW;
606             *p-- = 0;
607             len--;
608         }
609     } else {
610         val = ~val;
611         do {
612             if (len < 1)
613                 return ASN1_OVERFLOW;
614             *p-- = ~(val % 256);
615             len--;
616             val /= 256;
617         } while (val);
618         if (p[1] < 128) {
619             if (len < 1)
620                 return ASN1_OVERFLOW;
621             *p-- = 0xff;
622             len--;
623         }
624     }
625     *size = base - p;
626     return 0;
627 }
628
629
630 int
631 der_put_length(unsigned char *p, size_t len, size_t val, size_t * size)
632 {
633     if (len < 1)
634         return ASN1_OVERFLOW;
635     if (val < 128) {
636         *p = val;
637         *size = 1;
638         return 0;
639     } else {
640         size_t l;
641         int e;
642
643         e = der_put_unsigned(p, len - 1, val, &l);
644         if (e)
645             return e;
646         p -= l;
647         *p = 0x80 | l;
648         *size = l + 1;
649         return 0;
650     }
651 }
652
653 int
654 der_put_general_string(unsigned char *p, size_t len,
655                        const general_string * str, size_t * size)
656 {
657     size_t slen = strlen(*str);
658
659     if (len < slen)
660         return ASN1_OVERFLOW;
661     p -= slen;
662     len -= slen;
663     memcpy(p + 1, *str, slen);
664     *size = slen;
665     return 0;
666 }
667
668 int
669 der_put_octet_string(unsigned char *p, size_t len, const octet_string * data,
670                      size_t * size)
671 {
672     if (len < data->length)
673         return ASN1_OVERFLOW;
674     p -= data->length;
675     len -= data->length;
676     memcpy(p + 1, data->data, data->length);
677     *size = data->length;
678     return 0;
679 }
680
681 int
682 der_put_oid(unsigned char *p, size_t len, const oid * data, size_t * size)
683 {
684     unsigned char *base = p;
685     int n;
686
687     for (n = data->length - 1; n >= 2; --n) {
688         unsigned u = data->components[n];
689
690         if (len < 1)
691             return ASN1_OVERFLOW;
692         *p-- = u % 128;
693         u /= 128;
694         --len;
695         while (u > 0) {
696             if (len < 1)
697                 return ASN1_OVERFLOW;
698             *p-- = 128 + u % 128;
699             u /= 128;
700             --len;
701         }
702     }
703     if (len < 1)
704         return ASN1_OVERFLOW;
705     *p-- = 40 * data->components[0] + data->components[1];
706     *size = base - p;
707     return 0;
708 }
709
710 int
711 der_put_tag(unsigned char *p, size_t len, Der_class class, Der_type type,
712             int tag, size_t * size)
713 {
714     if (len < 1)
715         return ASN1_OVERFLOW;
716     *p = (class << 6) | (type << 5) | tag;      /* XXX */
717     *size = 1;
718     return 0;
719 }
720
721 int
722 der_put_length_and_tag(unsigned char *p, size_t len, size_t len_val,
723                        Der_class class, Der_type type, int tag, size_t * size)
724 {
725     size_t ret = 0;
726     size_t l;
727     int e;
728
729     e = der_put_length(p, len, len_val, &l);
730     if (e)
731         return e;
732     p -= l;
733     len -= l;
734     ret += l;
735     e = der_put_tag(p, len, class, type, tag, &l);
736     if (e)
737         return e;
738     p -= l;
739     len -= l;
740     ret += l;
741     *size = ret;
742     return 0;
743 }
744
745 int
746 encode_integer(unsigned char *p, size_t len, const int *data, size_t * size)
747 {
748     int num = *data;
749     size_t ret = 0;
750     size_t l;
751     int e;
752
753     e = der_put_int(p, len, num, &l);
754     if (e)
755         return e;
756     p -= l;
757     len -= l;
758     ret += l;
759     e = der_put_length_and_tag(p, len, l, UNIV, PRIM, UT_Integer, &l);
760     if (e)
761         return e;
762     p -= l;
763     len -= l;
764     ret += l;
765     *size = ret;
766     return 0;
767 }
768
769 int
770 encode_unsigned(unsigned char *p, size_t len, const unsigned *data,
771                 size_t * size)
772 {
773     unsigned num = *data;
774     size_t ret = 0;
775     size_t l;
776     int e;
777
778     e = der_put_unsigned(p, len, num, &l);
779     if (e)
780         return e;
781     p -= l;
782     len -= l;
783     ret += l;
784     e = der_put_length_and_tag(p, len, l, UNIV, PRIM, UT_Integer, &l);
785     if (e)
786         return e;
787     p -= l;
788     len -= l;
789     ret += l;
790     *size = ret;
791     return 0;
792 }
793
794 int
795 encode_enumerated(unsigned char *p, size_t len, const unsigned *data,
796                   size_t * size)
797 {
798     unsigned num = *data;
799     size_t ret = 0;
800     size_t l;
801     int e;
802
803     e = der_put_int(p, len, num, &l);
804     if (e)
805         return e;
806     p -= l;
807     len -= l;
808     ret += l;
809     e = der_put_length_and_tag(p, len, l, UNIV, PRIM, UT_Enumerated, &l);
810     if (e)
811         return e;
812     p -= l;
813     len -= l;
814     ret += l;
815     *size = ret;
816     return 0;
817 }
818
819 int
820 encode_general_string(unsigned char *p, size_t len,
821                       const general_string * data, size_t * size)
822 {
823     size_t ret = 0;
824     size_t l;
825     int e;
826
827     e = der_put_general_string(p, len, data, &l);
828     if (e)
829         return e;
830     p -= l;
831     len -= l;
832     ret += l;
833     e = der_put_length_and_tag(p, len, l, UNIV, PRIM, UT_GeneralString, &l);
834     if (e)
835         return e;
836     p -= l;
837     len -= l;
838     ret += l;
839     *size = ret;
840     return 0;
841 }
842
843 int
844 encode_octet_string(unsigned char *p, size_t len, const octet_string * k,
845                     size_t * size)
846 {
847     size_t ret = 0;
848     size_t l;
849     int e;
850
851     e = der_put_octet_string(p, len, k, &l);
852     if (e)
853         return e;
854     p -= l;
855     len -= l;
856     ret += l;
857     e = der_put_length_and_tag(p, len, l, UNIV, PRIM, UT_OctetString, &l);
858     if (e)
859         return e;
860     p -= l;
861     len -= l;
862     ret += l;
863     *size = ret;
864     return 0;
865 }
866
867 int
868 encode_oid(unsigned char *p, size_t len, const oid * k, size_t * size)
869 {
870     size_t ret = 0;
871     size_t l;
872     int e;
873
874     e = der_put_oid(p, len, k, &l);
875     if (e)
876         return e;
877     p -= l;
878     len -= l;
879     ret += l;
880     e = der_put_length_and_tag(p, len, l, UNIV, PRIM, UT_OID, &l);
881     if (e)
882         return e;
883     p -= l;
884     len -= l;
885     ret += l;
886     *size = ret;
887     return 0;
888 }
889
890 int
891 time2generalizedtime(time_t t, octet_string * s)
892 {
893     struct tm *tm;
894
895     s->data = malloc(16);
896     if (s->data == NULL)
897         return ENOMEM;
898     s->length = 15;
899     tm = gmtime(&t);
900     sprintf(s->data, "%04d%02d%02d%02d%02d%02dZ", tm->tm_year + 1900,
901             tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
902     return 0;
903 }
904
905 int
906 encode_generalized_time(unsigned char *p, size_t len, const time_t * t,
907                         size_t * size)
908 {
909     size_t ret = 0;
910     size_t l;
911     octet_string k;
912     int e;
913
914     e = time2generalizedtime(*t, &k);
915     if (e)
916         return e;
917     e = der_put_octet_string(p, len, &k, &l);
918     free(k.data);
919     if (e)
920         return e;
921     p -= l;
922     len -= l;
923     ret += l;
924     e = der_put_length_and_tag(p, len, k.length, UNIV, PRIM,
925                                UT_GeneralizedTime, &l);
926     if (e)
927         return e;
928     p -= l;
929     len -= l;
930     ret += l;
931     *size = ret;
932     return 0;
933 }
934
935 /*
936  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
937  * (Royal Institute of Technology, Stockholm, Sweden). 
938  * All rights reserved. 
939  *
940  * Redistribution and use in source and binary forms, with or without 
941  * modification, are permitted provided that the following conditions 
942  * are met: 
943  *
944  * 1. Redistributions of source code must retain the above copyright 
945  *    notice, this list of conditions and the following disclaimer. 
946  *
947  * 2. Redistributions in binary form must reproduce the above copyright 
948  *    notice, this list of conditions and the following disclaimer in the 
949  *    documentation and/or other materials provided with the distribution. 
950  *
951  * 3. Neither the name of the Institute nor the names of its contributors 
952  *    may be used to endorse or promote products derived from this software 
953  *    without specific prior written permission. 
954  *
955  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
956  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
957  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
958  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
959  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
960  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
961  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
962  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
963  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
964  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
965  * SUCH DAMAGE. 
966  */
967
968
969 /* RCSID("Heimdal: der_free.c,v 1.8 2001/09/25 13:39:26 assar Exp $"); */
970
971 void
972 free_general_string(general_string * str)
973 {
974     free(*str);
975 }
976
977 void
978 free_octet_string(octet_string * k)
979 {
980     free(k->data);
981 }
982
983 void
984 free_oid(oid * k)
985 {
986     free(k->components);
987 }
988
989 /*
990  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
991  * (Royal Institute of Technology, Stockholm, Sweden). 
992  * All rights reserved. 
993  *
994  * Redistribution and use in source and binary forms, with or without 
995  * modification, are permitted provided that the following conditions 
996  * are met: 
997  *
998  * 1. Redistributions of source code must retain the above copyright 
999  *    notice, this list of conditions and the following disclaimer. 
1000  *
1001  * 2. Redistributions in binary form must reproduce the above copyright 
1002  *    notice, this list of conditions and the following disclaimer in the 
1003  *    documentation and/or other materials provided with the distribution. 
1004  *
1005  * 3. Neither the name of the Institute nor the names of its contributors 
1006  *    may be used to endorse or promote products derived from this software 
1007  *    without specific prior written permission. 
1008  *
1009  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
1010  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
1011  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
1012  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
1013  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
1014  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
1015  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
1016  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
1017  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
1018  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
1019  * SUCH DAMAGE. 
1020  */
1021
1022
1023 /* RCSID("Heimdal: der_length.c,v 1.12 2001/09/25 13:39:26 assar Exp $"); */
1024
1025 static size_t
1026 len_unsigned(unsigned val)
1027 {
1028     size_t ret = 0;
1029
1030     do {
1031         ++ret;
1032         val /= 256;
1033     } while (val);
1034     return ret;
1035 }
1036
1037 static size_t
1038 len_int(int val)
1039 {
1040     size_t ret = 0;
1041
1042     if (val == 0)
1043         return 1;
1044     while (val > 255 || val < -255) {
1045         ++ret;
1046         val /= 256;
1047     }
1048     if (val != 0) {
1049         ++ret;
1050         if ((signed char)val != val)
1051             ++ret;
1052         val /= 256;
1053     }
1054     return ret;
1055 }
1056
1057 static size_t
1058 len_oid(const oid * oid)
1059 {
1060     size_t ret = 1;
1061     int n;
1062
1063     for (n = 2; n < oid->length; ++n) {
1064         unsigned u = oid->components[n];
1065
1066         ++ret;
1067         u /= 128;
1068         while (u > 0) {
1069             ++ret;
1070             u /= 128;
1071         }
1072     }
1073     return ret;
1074 }
1075
1076 size_t
1077 length_len(size_t len)
1078 {
1079     if (len < 128)
1080         return 1;
1081     else
1082         return len_unsigned(len) + 1;
1083 }
1084
1085 size_t
1086 length_integer(const int *data)
1087 {
1088     size_t len = len_int(*data);
1089
1090     return 1 + length_len(len) + len;
1091 }
1092
1093 size_t
1094 length_unsigned(const unsigned *data)
1095 {
1096     size_t len = len_unsigned(*data);
1097
1098     return 1 + length_len(len) + len;
1099 }
1100
1101 size_t
1102 length_enumerated(const unsigned *data)
1103 {
1104     size_t len = len_int(*data);
1105
1106     return 1 + length_len(len) + len;
1107 }
1108
1109 size_t
1110 length_general_string(const general_string * data)
1111 {
1112     char *str = *data;
1113     size_t len = strlen(str);
1114     return 1 + length_len(len) + len;
1115 }
1116
1117 size_t
1118 length_octet_string(const octet_string * k)
1119 {
1120     return 1 + length_len(k->length) + k->length;
1121 }
1122
1123 size_t
1124 length_oid(const oid * k)
1125 {
1126     size_t len = len_oid(k);
1127
1128     return 1 + length_len(len) + len;
1129 }
1130
1131 size_t
1132 length_generalized_time(const time_t * t)
1133 {
1134     octet_string k;
1135     size_t ret;
1136
1137     time2generalizedtime(*t, &k);
1138     ret = 1 + length_len(k.length) + k.length;
1139     free(k.data);
1140     return ret;
1141 }
1142
1143 /*
1144  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
1145  * (Royal Institute of Technology, Stockholm, Sweden). 
1146  * All rights reserved. 
1147  *
1148  * Redistribution and use in source and binary forms, with or without 
1149  * modification, are permitted provided that the following conditions 
1150  * are met: 
1151  *
1152  * 1. Redistributions of source code must retain the above copyright 
1153  *    notice, this list of conditions and the following disclaimer. 
1154  *
1155  * 2. Redistributions in binary form must reproduce the above copyright 
1156  *    notice, this list of conditions and the following disclaimer in the 
1157  *    documentation and/or other materials provided with the distribution. 
1158  *
1159  * 3. Neither the name of the Institute nor the names of its contributors 
1160  *    may be used to endorse or promote products derived from this software 
1161  *    without specific prior written permission. 
1162  *
1163  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
1164  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
1165  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
1166  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
1167  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
1168  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
1169  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
1170  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
1171  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
1172  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
1173  * SUCH DAMAGE. 
1174  */
1175
1176
1177 /* RCSID("Heimdal: der_copy.c,v 1.9 2001/09/25 13:39:25 assar Exp $"); */
1178
1179 int
1180 copy_general_string(const general_string * from, general_string * to)
1181 {
1182     *to = malloc(strlen(*from) + 1);
1183     if (*to == NULL)
1184         return ENOMEM;
1185     strcpy(*to, *from);
1186     return 0;
1187 }
1188
1189 int
1190 copy_octet_string(const octet_string * from, octet_string * to)
1191 {
1192     to->length = from->length;
1193     to->data = malloc(to->length);
1194     if (to->length != 0 && to->data == NULL)
1195         return ENOMEM;
1196     memcpy(to->data, from->data, to->length);
1197     return 0;
1198 }
1199
1200 int
1201 copy_oid(const oid * from, oid * to)
1202 {
1203     to->length = from->length;
1204     to->components = malloc(to->length * sizeof(*to->components));
1205     if (to->length != 0 && to->components == NULL)
1206         return ENOMEM;
1207     memcpy(to->components, from->components, to->length);
1208     return 0;
1209 }
1210
1211 /*
1212  * Copyright (c) 1997 Kungliga Tekniska Högskolan
1213  * (Royal Institute of Technology, Stockholm, Sweden). 
1214  * All rights reserved. 
1215  *
1216  * Redistribution and use in source and binary forms, with or without 
1217  * modification, are permitted provided that the following conditions 
1218  * are met: 
1219  *
1220  * 1. Redistributions of source code must retain the above copyright 
1221  *    notice, this list of conditions and the following disclaimer. 
1222  *
1223  * 2. Redistributions in binary form must reproduce the above copyright 
1224  *    notice, this list of conditions and the following disclaimer in the 
1225  *    documentation and/or other materials provided with the distribution. 
1226  *
1227  * 3. Neither the name of the Institute nor the names of its contributors 
1228  *    may be used to endorse or promote products derived from this software 
1229  *    without specific prior written permission. 
1230  *
1231  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
1232  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
1233  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
1234  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
1235  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
1236  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
1237  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
1238  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
1239  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
1240  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
1241  * SUCH DAMAGE. 
1242  */
1243
1244
1245 /* RCSID("Heimdal: timegm.c,v 1.7 1999/12/02 17:05:02 joda Exp $"); */
1246
1247 #ifndef HAVE_TIMEGM
1248
1249 static int
1250 is_leap(unsigned y)
1251 {
1252     y += 1900;
1253     return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
1254 }
1255
1256 time_t
1257 timegm(struct tm * tm)
1258 {
1259     static const unsigned ndays[2][12] = {
1260         {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
1261         {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
1262     };
1263     time_t res = 0;
1264     unsigned i;
1265
1266     for (i = 70; i < tm->tm_year; ++i)
1267         res += is_leap(i) ? 366 : 365;
1268
1269     for (i = 0; i < tm->tm_mon; ++i)
1270         res += ndays[is_leap(tm->tm_year)][i];
1271     res += tm->tm_mday - 1;
1272     res *= 24;
1273     res += tm->tm_hour;
1274     res *= 60;
1275     res += tm->tm_min;
1276     res *= 60;
1277     res += tm->tm_sec;
1278     return res;
1279 }
1280
1281 #endif /* HAVE_TIMEGM */