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 52491 : der_heim_oid_cmp(const heim_oid *p, const heim_oid *q)
38 : {
39 1617 : int c;
40 :
41 52491 : if (p->length == q->length) {
42 43211 : if (p->length == 0)
43 0 : return 0;
44 43211 : return memcmp(p->components,
45 43211 : q->components,
46 41778 : p->length * sizeof(*p->components));
47 : }
48 9280 : if (p->length < q->length) {
49 4659 : if (p->length == 0 ||
50 4659 : (c = memcmp(p->components,
51 4659 : q->components,
52 4635 : p->length * sizeof(*p->components))) == 0)
53 0 : return -1;
54 4659 : return c;
55 : }
56 4621 : if (q->length == 0 ||
57 4621 : (c = memcmp(p->components,
58 4621 : q->components,
59 4461 : q->length * sizeof(*p->components))) == 0)
60 0 : return 1;
61 4461 : return c;
62 : }
63 :
64 : int ASN1CALL
65 289 : der_heim_octet_string_cmp(const heim_octet_string *p,
66 : const heim_octet_string *q)
67 : {
68 0 : int c;
69 :
70 289 : if (p->length == q->length) {
71 289 : if (p->length == 0)
72 0 : return 0;
73 289 : return memcmp(p->data, q->data, p->length);
74 : }
75 0 : if (p->length < q->length) {
76 0 : if (p->length == 0 ||
77 0 : (c = memcmp(p->data, q->data, p->length)) == 0)
78 0 : return -1;
79 0 : return c;
80 : }
81 0 : if (q->length == 0 ||
82 0 : (c = memcmp(p->data, q->data, q->length)) == 0)
83 0 : return 1;
84 0 : return c;
85 : }
86 :
87 : int ASN1CALL
88 0 : der_printable_string_cmp(const heim_printable_string *p,
89 : const heim_printable_string *q)
90 : {
91 0 : return der_heim_octet_string_cmp(p, q);
92 : }
93 :
94 : int ASN1CALL
95 0 : der_ia5_string_cmp(const heim_ia5_string *p,
96 : const heim_ia5_string *q)
97 : {
98 0 : return der_heim_octet_string_cmp(p, q);
99 : }
100 :
101 : int ASN1CALL
102 210 : der_heim_bit_string_cmp(const heim_bit_string *p,
103 : const heim_bit_string *q)
104 : {
105 0 : unsigned char pc, qc;
106 0 : size_t bits;
107 210 : int c = 0;
108 :
109 : /* Compare prefix */
110 210 : if (p->length == 0 && q->length == 0)
111 0 : return 0;
112 210 : if (p->length > 7 && q->length > 7) {
113 210 : if (p->length < q->length)
114 0 : c = memcmp(p->data, q->data, p->length / 8);
115 : else
116 210 : c = memcmp(p->data, q->data, q->length / 8);
117 : }
118 210 : if (c)
119 140 : return c;
120 :
121 : /* Prefixes are equal, c == 0 */
122 :
123 70 : if (p->length == q->length && p->length % 8 == 0)
124 70 : return 0;
125 0 : if (p->length == 0 && q->length)
126 0 : return -1; /* No trailing bits of p to compare to corresponding bits of q */
127 0 : if (q->length == 0 && p->length)
128 0 : return 1; /* No trailing bits of q to compare to corresponding bits of p */
129 :
130 : /* c == 0, lengths are not equal, both are at least 1 bit */
131 0 : pc = ((unsigned char *)p->data)[p->length / 8];
132 0 : qc = ((unsigned char *)q->data)[q->length / 8];
133 0 : if (p->length < q->length)
134 0 : bits = p->length % 8;
135 : else
136 0 : bits = q->length % 8;
137 :
138 0 : if (bits > 0) {
139 0 : if ((pc & 0x80) == 0 && (qc & 0x80) != 0)
140 0 : return -1;
141 0 : if ((pc & 0x80) != 0 && (qc & 0x80) == 0)
142 0 : return 1;
143 : }
144 0 : if (bits > 1) {
145 0 : if ((pc & 0x40) == 0 && (qc & 0x40) != 0)
146 0 : return -1;
147 0 : if ((pc & 0x40) != 0 && (qc & 0x40) == 0)
148 0 : return 1;
149 : }
150 0 : if (bits > 2) {
151 0 : if ((pc & 0x20) == 0 && (qc & 0x20) != 0)
152 0 : return -1;
153 0 : if ((pc & 0x20) != 0 && (qc & 0x20) == 0)
154 0 : return 1;
155 : }
156 0 : if (bits > 3) {
157 0 : if ((pc & 0x10) == 0 && (qc & 0x10) != 0)
158 0 : return -1;
159 0 : if ((pc & 0x10) != 0 && (qc & 0x10) == 0)
160 0 : return 1;
161 : }
162 0 : if (bits > 4) {
163 0 : if ((pc & 0x08) == 0 && (qc & 0x08) != 0)
164 0 : return -1;
165 0 : if ((pc & 0x08) != 0 && (qc & 0x08) == 0)
166 0 : return 1;
167 : }
168 0 : if (bits > 5) {
169 0 : if ((pc & 0x04) == 0 && (qc & 0x04) != 0)
170 0 : return -1;
171 0 : if ((pc & 0x04) != 0 && (qc & 0x04) == 0)
172 0 : return 1;
173 : }
174 0 : if (bits > 6) {
175 0 : if ((pc & 0x02) == 0 && (qc & 0x02) != 0)
176 0 : return -1;
177 0 : if ((pc & 0x02) != 0 && (qc & 0x02) == 0)
178 0 : return 1;
179 : }
180 : /*
181 : * `bits' can't be 8.
182 : *
183 : * All leading `bits' bits of the tail of the shorter of `p' or `q' are
184 : * equal.
185 : */
186 0 : if (p->length < q->length)
187 0 : return -1;
188 0 : if (q->length < p->length)
189 0 : return 1;
190 0 : return 0;
191 : }
192 :
193 : int ASN1CALL
194 709 : der_heim_integer_cmp(const heim_integer *p,
195 : const heim_integer *q)
196 : {
197 709 : if (p->negative != q->negative)
198 0 : return q->negative - p->negative;
199 709 : if (p->length != q->length)
200 217 : return (int)(p->length - q->length);
201 492 : return memcmp(p->data, q->data, p->length);
202 : }
203 :
204 : int ASN1CALL
205 0 : der_heim_bmp_string_cmp(const heim_bmp_string *p, const heim_bmp_string *q)
206 : {
207 0 : int c;
208 :
209 0 : if (p->length == q->length) {
210 0 : if (p->length == 0)
211 0 : return 0;
212 0 : return memcmp(p->data, q->data, p->length * sizeof(q->data[0]));
213 : }
214 0 : if (p->length < q->length) {
215 0 : if (p->length == 0 ||
216 0 : (c = memcmp(p->data, q->data, p->length * sizeof(q->data[0]))) == 0)
217 0 : return -1;
218 0 : return c;
219 : }
220 0 : if (q->length == 0 ||
221 0 : (c = memcmp(p->data, q->data, q->length * sizeof(q->data[0]))) == 0)
222 0 : return 1;
223 0 : return c;
224 : }
225 :
226 : int ASN1CALL
227 0 : der_heim_universal_string_cmp(const heim_universal_string *p,
228 : const heim_universal_string *q)
229 : {
230 0 : int c;
231 :
232 0 : if (p->length == q->length) {
233 0 : if (p->length == 0)
234 0 : return 0;
235 0 : return memcmp(p->data, q->data, p->length * sizeof(q->data[0]));
236 : }
237 0 : if (p->length < q->length) {
238 0 : if (p->length == 0 ||
239 0 : (c = memcmp(p->data, q->data, p->length * sizeof(q->data[0]))) == 0)
240 0 : return -1;
241 0 : return c;
242 : }
243 0 : if (q->length == 0 ||
244 0 : (c = memcmp(p->data, q->data, q->length * sizeof(q->data[0]))) == 0)
245 0 : return 1;
246 0 : return c;
247 : }
|
