Line data Source code
1 : /*
2 : * Copyright (c) 2003-2005 Kungliga Tekniska Högskolan
3 : * (Royal Institute of Technology, Stockholm, Sweden).
4 : * All rights reserved.
5 : *
6 : * Redistribution and use in source and binary forms, with or without
7 : * modification, are permitted provided that the following conditions
8 : * are met:
9 : *
10 : * 1. Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer.
12 : *
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * 3. Neither the name of the Institute nor the names of its contributors
18 : * may be used to endorse or promote products derived from this software
19 : * without specific prior written permission.
20 : *
21 : * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 : * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 : * SUCH DAMAGE.
32 : */
33 :
34 : #include "der_locl.h"
35 :
36 : int ASN1CALL
37 22235 : der_heim_oid_cmp(const heim_oid *p, const heim_oid *q)
38 : {
39 : int c;
40 :
41 22235 : if (p->length == q->length)
42 42530 : return memcmp(p->components,
43 21265 : q->components,
44 21265 : p->length * sizeof(*p->components));
45 970 : if (p->length < q->length) {
46 228 : c = memcmp(p->components,
47 114 : q->components,
48 114 : p->length * sizeof(*p->components));
49 114 : if (c == 0)
50 0 : return -1;
51 114 : return c;
52 : }
53 1712 : c = memcmp(p->components,
54 856 : q->components,
55 856 : q->length * sizeof(*p->components));
56 856 : if (c == 0)
57 0 : return 1;
58 856 : return c;
59 : }
60 :
61 : int ASN1CALL
62 0 : der_heim_octet_string_cmp(const heim_octet_string *p,
63 : const heim_octet_string *q)
64 : {
65 : int c;
66 :
67 0 : if (p->length == q->length)
68 0 : return memcmp(p->data, q->data, p->length);
69 0 : if (p->length < q->length) {
70 0 : if ((c = memcmp(p->data, q->data, p->length)) == 0)
71 0 : return -1;
72 0 : return c;
73 : }
74 0 : if ((c = memcmp(p->data, q->data, q->length)) == 0)
75 0 : return 1;
76 0 : return c;
77 : }
78 :
79 : int ASN1CALL
80 0 : der_printable_string_cmp(const heim_printable_string *p,
81 : const heim_printable_string *q)
82 : {
83 0 : return der_heim_octet_string_cmp(p, q);
84 : }
85 :
86 : int ASN1CALL
87 0 : der_ia5_string_cmp(const heim_ia5_string *p,
88 : const heim_ia5_string *q)
89 : {
90 0 : return der_heim_octet_string_cmp(p, q);
91 : }
92 :
93 : int ASN1CALL
94 0 : der_heim_bit_string_cmp(const heim_bit_string *p,
95 : const heim_bit_string *q)
96 : {
97 : int r1, r2;
98 : size_t i;
99 0 : if (p->length != q->length)
100 0 : return (int)(p->length - q->length);
101 0 : i = memcmp(p->data, q->data, p->length / 8);
102 0 : if (i)
103 0 : return (int)i;
104 0 : if ((p->length % 8) == 0)
105 0 : return 0;
106 0 : i = (p->length / 8);
107 0 : r1 = ((unsigned char *)p->data)[i];
108 0 : r2 = ((unsigned char *)q->data)[i];
109 0 : i = 8 - (p->length % 8);
110 0 : r1 = r1 >> i;
111 0 : r2 = r2 >> i;
112 0 : return r1 - r2;
113 : }
114 :
115 : int ASN1CALL
116 231 : der_heim_integer_cmp(const heim_integer *p,
117 : const heim_integer *q)
118 : {
119 231 : if (p->negative != q->negative)
120 0 : return q->negative - p->negative;
121 231 : if (p->length != q->length)
122 77 : return (int)(p->length - q->length);
123 154 : return memcmp(p->data, q->data, p->length);
124 : }
125 :
126 : int ASN1CALL
127 0 : der_heim_bmp_string_cmp(const heim_bmp_string *p, const heim_bmp_string *q)
128 : {
129 : int c;
130 :
131 0 : if (p->length == q->length)
132 0 : return memcmp(p->data, q->data, p->length * sizeof(q->data[0]));
133 0 : if (p->length < q->length) {
134 0 : if ((c = memcmp(p->data, q->data, p->length * sizeof(q->data[0]))) == 0)
135 0 : return -1;
136 0 : return c;
137 : }
138 0 : if ((c = memcmp(p->data, q->data, q->length * sizeof(q->data[0]))) == 0)
139 0 : return 1;
140 0 : return c;
141 : }
142 :
143 : int ASN1CALL
144 0 : der_heim_universal_string_cmp(const heim_universal_string *p,
145 : const heim_universal_string *q)
146 : {
147 : int c;
148 :
149 0 : if (p->length == q->length)
150 0 : return memcmp(p->data, q->data, p->length * sizeof(q->data[0]));
151 0 : if (p->length < q->length) {
152 0 : if ((c = memcmp(p->data, q->data, p->length * sizeof(q->data[0]))) == 0)
153 0 : return -1;
154 0 : return c;
155 : }
156 0 : if ((c = memcmp(p->data, q->data, q->length * sizeof(q->data[0]))) == 0)
157 0 : return 1;
158 0 : return c;
159 : }
|
