diff options
Diffstat (limited to 'src/lib/libcrypto/txt_db/txt_db.c')
-rw-r--r-- | src/lib/libcrypto/txt_db/txt_db.c | 372 |
1 files changed, 0 insertions, 372 deletions
diff --git a/src/lib/libcrypto/txt_db/txt_db.c b/src/lib/libcrypto/txt_db/txt_db.c deleted file mode 100644 index 26df76a9c2..0000000000 --- a/src/lib/libcrypto/txt_db/txt_db.c +++ /dev/null | |||
@@ -1,372 +0,0 @@ | |||
1 | /* $OpenBSD: txt_db.c,v 1.18 2014/07/11 08:44:49 jsing Exp $ */ | ||
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This package is an SSL implementation written | ||
6 | * by Eric Young (eay@cryptsoft.com). | ||
7 | * The implementation was written so as to conform with Netscapes SSL. | ||
8 | * | ||
9 | * This library is free for commercial and non-commercial use as long as | ||
10 | * the following conditions are aheared to. The following conditions | ||
11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
13 | * included with this distribution is covered by the same copyright terms | ||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
15 | * | ||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
17 | * the code are not to be removed. | ||
18 | * If this package is used in a product, Eric Young should be given attribution | ||
19 | * as the author of the parts of the library used. | ||
20 | * This can be in the form of a textual message at program startup or | ||
21 | * in documentation (online or textual) provided with the package. | ||
22 | * | ||
23 | * Redistribution and use in source and binary forms, with or without | ||
24 | * modification, are permitted provided that the following conditions | ||
25 | * are met: | ||
26 | * 1. Redistributions of source code must retain the copyright | ||
27 | * notice, this list of conditions and the following disclaimer. | ||
28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
29 | * notice, this list of conditions and the following disclaimer in the | ||
30 | * documentation and/or other materials provided with the distribution. | ||
31 | * 3. All advertising materials mentioning features or use of this software | ||
32 | * must display the following acknowledgement: | ||
33 | * "This product includes cryptographic software written by | ||
34 | * Eric Young (eay@cryptsoft.com)" | ||
35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
36 | * being used are not cryptographic related :-). | ||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
38 | * the apps directory (application code) you must include an acknowledgement: | ||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
40 | * | ||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
51 | * SUCH DAMAGE. | ||
52 | * | ||
53 | * The licence and distribution terms for any publically available version or | ||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
55 | * copied and put under another distribution licence | ||
56 | * [including the GNU Public Licence.] | ||
57 | */ | ||
58 | |||
59 | #include <stdio.h> | ||
60 | #include <stdlib.h> | ||
61 | #include <string.h> | ||
62 | |||
63 | #include <openssl/buffer.h> | ||
64 | #include <openssl/txt_db.h> | ||
65 | |||
66 | #undef BUFSIZE | ||
67 | #define BUFSIZE 512 | ||
68 | |||
69 | TXT_DB * | ||
70 | TXT_DB_read(BIO *in, int num) | ||
71 | { | ||
72 | TXT_DB *ret = NULL; | ||
73 | int er = 1; | ||
74 | int esc = 0; | ||
75 | long ln = 0; | ||
76 | int i, add, n; | ||
77 | int size = BUFSIZE; | ||
78 | int offset = 0; | ||
79 | char *p, *f; | ||
80 | OPENSSL_STRING *pp; | ||
81 | BUF_MEM *buf = NULL; | ||
82 | |||
83 | if ((buf = BUF_MEM_new()) == NULL) | ||
84 | goto err; | ||
85 | if (!BUF_MEM_grow(buf, size)) | ||
86 | goto err; | ||
87 | |||
88 | if ((ret = malloc(sizeof(TXT_DB))) == NULL) | ||
89 | goto err; | ||
90 | ret->num_fields = num; | ||
91 | ret->index = NULL; | ||
92 | ret->qual = NULL; | ||
93 | if ((ret->data = sk_OPENSSL_PSTRING_new_null()) == NULL) | ||
94 | goto err; | ||
95 | if ((ret->index = reallocarray(NULL, num, sizeof(*ret->index))) == NULL) | ||
96 | goto err; | ||
97 | if ((ret->qual = reallocarray(NULL, num, sizeof(*(ret->qual)))) == NULL) | ||
98 | goto err; | ||
99 | for (i = 0; i < num; i++) { | ||
100 | ret->index[i] = NULL; | ||
101 | ret->qual[i] = NULL; | ||
102 | } | ||
103 | |||
104 | add = (num + 1)*sizeof(char *); | ||
105 | buf->data[size-1] = '\0'; | ||
106 | offset = 0; | ||
107 | for (;;) { | ||
108 | if (offset != 0) { | ||
109 | size += BUFSIZE; | ||
110 | if (!BUF_MEM_grow_clean(buf, size)) | ||
111 | goto err; | ||
112 | } | ||
113 | buf->data[offset] = '\0'; | ||
114 | BIO_gets(in, &(buf->data[offset]), size - offset); | ||
115 | ln++; | ||
116 | if (buf->data[offset] == '\0') | ||
117 | break; | ||
118 | if ((offset == 0) && (buf->data[0] == '#')) | ||
119 | continue; | ||
120 | i = strlen(&(buf->data[offset])); | ||
121 | offset += i; | ||
122 | if (buf->data[offset-1] != '\n') | ||
123 | continue; | ||
124 | else { | ||
125 | buf->data[offset-1] = '\0'; /* blat the '\n' */ | ||
126 | if (!(p = malloc(add + offset))) | ||
127 | goto err; | ||
128 | offset = 0; | ||
129 | } | ||
130 | pp = (char **)p; | ||
131 | p += add; | ||
132 | n = 0; | ||
133 | pp[n++] = p; | ||
134 | i = 0; | ||
135 | f = buf->data; | ||
136 | |||
137 | esc = 0; | ||
138 | for (;;) { | ||
139 | if (*f == '\0') | ||
140 | break; | ||
141 | if (*f == '\t') { | ||
142 | if (esc) | ||
143 | p--; | ||
144 | else { | ||
145 | *(p++)='\0'; | ||
146 | f++; | ||
147 | if (n >= num) | ||
148 | break; | ||
149 | pp[n++] = p; | ||
150 | continue; | ||
151 | } | ||
152 | } | ||
153 | esc=(*f == '\\'); | ||
154 | *(p++)= *(f++); | ||
155 | } | ||
156 | *(p++)='\0'; | ||
157 | if ((n != num) || (*f != '\0')) { | ||
158 | fprintf(stderr, "wrong number of fields on line %ld (looking for field %d, got %d, '%s' left)\n",ln,num,n,f); | ||
159 | er = 2; | ||
160 | goto err; | ||
161 | } | ||
162 | pp[n] = p; | ||
163 | if (!sk_OPENSSL_PSTRING_push(ret->data, pp)) { | ||
164 | fprintf(stderr, "failure in sk_push\n"); | ||
165 | er = 2; | ||
166 | goto err; | ||
167 | } | ||
168 | } | ||
169 | er = 0; | ||
170 | |||
171 | err: | ||
172 | BUF_MEM_free(buf); | ||
173 | if (er) { | ||
174 | if (er == 1) | ||
175 | fprintf(stderr, "malloc failure\n"); | ||
176 | if (ret != NULL) { | ||
177 | if (ret->data != NULL) | ||
178 | sk_OPENSSL_PSTRING_free(ret->data); | ||
179 | free(ret->index); | ||
180 | free(ret->qual); | ||
181 | free(ret); | ||
182 | } | ||
183 | return (NULL); | ||
184 | } else | ||
185 | return (ret); | ||
186 | } | ||
187 | |||
188 | OPENSSL_STRING * | ||
189 | TXT_DB_get_by_index(TXT_DB *db, int idx, OPENSSL_STRING *value) | ||
190 | { | ||
191 | OPENSSL_STRING *ret; | ||
192 | LHASH_OF(OPENSSL_STRING) *lh; | ||
193 | |||
194 | if (idx >= db->num_fields) { | ||
195 | db->error = DB_ERROR_INDEX_OUT_OF_RANGE; | ||
196 | return (NULL); | ||
197 | } | ||
198 | lh = db->index[idx]; | ||
199 | if (lh == NULL) { | ||
200 | db->error = DB_ERROR_NO_INDEX; | ||
201 | return (NULL); | ||
202 | } | ||
203 | ret = lh_OPENSSL_STRING_retrieve(lh, value); | ||
204 | db->error = DB_ERROR_OK; | ||
205 | return (ret); | ||
206 | } | ||
207 | |||
208 | int | ||
209 | TXT_DB_create_index(TXT_DB *db, int field, int (*qual)(OPENSSL_STRING *), | ||
210 | LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp) | ||
211 | { | ||
212 | LHASH_OF(OPENSSL_STRING) *idx; | ||
213 | OPENSSL_STRING *r; | ||
214 | int i, n; | ||
215 | |||
216 | if (field >= db->num_fields) { | ||
217 | db->error = DB_ERROR_INDEX_OUT_OF_RANGE; | ||
218 | return (0); | ||
219 | } | ||
220 | /* FIXME: we lose type checking at this point */ | ||
221 | if ((idx = (LHASH_OF(OPENSSL_STRING) *)lh_new(hash, cmp)) == NULL) { | ||
222 | db->error = DB_ERROR_MALLOC; | ||
223 | return (0); | ||
224 | } | ||
225 | n = sk_OPENSSL_PSTRING_num(db->data); | ||
226 | for (i = 0; i < n; i++) { | ||
227 | r = sk_OPENSSL_PSTRING_value(db->data, i); | ||
228 | if ((qual != NULL) && (qual(r) == 0)) | ||
229 | continue; | ||
230 | if ((r = lh_OPENSSL_STRING_insert(idx, r)) != NULL) { | ||
231 | db->error = DB_ERROR_INDEX_CLASH; | ||
232 | db->arg1 = sk_OPENSSL_PSTRING_find(db->data, r); | ||
233 | db->arg2 = i; | ||
234 | lh_OPENSSL_STRING_free(idx); | ||
235 | return (0); | ||
236 | } | ||
237 | } | ||
238 | if (db->index[field] != NULL) | ||
239 | lh_OPENSSL_STRING_free(db->index[field]); | ||
240 | db->index[field] = idx; | ||
241 | db->qual[field] = qual; | ||
242 | return (1); | ||
243 | } | ||
244 | |||
245 | long | ||
246 | TXT_DB_write(BIO *out, TXT_DB *db) | ||
247 | { | ||
248 | long i, j,n, nn, l, tot = 0; | ||
249 | char *p, **pp, *f; | ||
250 | BUF_MEM *buf = NULL; | ||
251 | long ret = -1; | ||
252 | |||
253 | if ((buf = BUF_MEM_new()) == NULL) | ||
254 | goto err; | ||
255 | n = sk_OPENSSL_PSTRING_num(db->data); | ||
256 | nn = db->num_fields; | ||
257 | for (i = 0; i < n; i++) { | ||
258 | pp = sk_OPENSSL_PSTRING_value(db->data, i); | ||
259 | |||
260 | l = 0; | ||
261 | for (j = 0; j < nn; j++) { | ||
262 | if (pp[j] != NULL) | ||
263 | l += strlen(pp[j]); | ||
264 | } | ||
265 | if (!BUF_MEM_grow_clean(buf, (int)(l*2 + nn))) | ||
266 | goto err; | ||
267 | |||
268 | p = buf->data; | ||
269 | for (j = 0; j < nn; j++) { | ||
270 | f = pp[j]; | ||
271 | if (f != NULL) | ||
272 | for (;;) { | ||
273 | if (*f == '\0') | ||
274 | break; | ||
275 | if (*f == '\t') | ||
276 | *(p++) = '\\'; | ||
277 | *(p++) = *(f++); | ||
278 | } | ||
279 | *(p++) = '\t'; | ||
280 | } | ||
281 | p[-1] = '\n'; | ||
282 | j = p - buf->data; | ||
283 | if (BIO_write(out, buf->data, (int)j) != j) | ||
284 | goto err; | ||
285 | tot += j; | ||
286 | } | ||
287 | ret = tot; | ||
288 | |||
289 | err: | ||
290 | if (buf != NULL) | ||
291 | BUF_MEM_free(buf); | ||
292 | return (ret); | ||
293 | } | ||
294 | |||
295 | int | ||
296 | TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *row) | ||
297 | { | ||
298 | int i; | ||
299 | OPENSSL_STRING *r; | ||
300 | |||
301 | for (i = 0; i < db->num_fields; i++) { | ||
302 | if (db->index[i] != NULL) { | ||
303 | if ((db->qual[i] != NULL) && (db->qual[i](row) == 0)) | ||
304 | continue; | ||
305 | r = lh_OPENSSL_STRING_retrieve(db->index[i], row); | ||
306 | if (r != NULL) { | ||
307 | db->error = DB_ERROR_INDEX_CLASH; | ||
308 | db->arg1 = i; | ||
309 | db->arg_row = r; | ||
310 | goto err; | ||
311 | } | ||
312 | } | ||
313 | } | ||
314 | /* We have passed the index checks, now just append and insert */ | ||
315 | if (!sk_OPENSSL_PSTRING_push(db->data, row)) { | ||
316 | db->error = DB_ERROR_MALLOC; | ||
317 | goto err; | ||
318 | } | ||
319 | |||
320 | for (i = 0; i < db->num_fields; i++) { | ||
321 | if (db->index[i] != NULL) { | ||
322 | if ((db->qual[i] != NULL) && (db->qual[i](row) == 0)) | ||
323 | continue; | ||
324 | (void)lh_OPENSSL_STRING_insert(db->index[i], row); | ||
325 | } | ||
326 | } | ||
327 | return (1); | ||
328 | |||
329 | err: | ||
330 | return (0); | ||
331 | } | ||
332 | |||
333 | void | ||
334 | TXT_DB_free(TXT_DB *db) | ||
335 | { | ||
336 | int i, n; | ||
337 | char **p, *max; | ||
338 | |||
339 | if (db == NULL) | ||
340 | return; | ||
341 | |||
342 | if (db->index != NULL) { | ||
343 | for (i = db->num_fields - 1; i >= 0; i--) | ||
344 | if (db->index[i] != NULL) | ||
345 | lh_OPENSSL_STRING_free(db->index[i]); | ||
346 | free(db->index); | ||
347 | } | ||
348 | free(db->qual); | ||
349 | if (db->data != NULL) { | ||
350 | for (i = sk_OPENSSL_PSTRING_num(db->data) - 1; i >= 0; i--) { | ||
351 | /* check if any 'fields' have been allocated | ||
352 | * from outside of the initial block */ | ||
353 | p = sk_OPENSSL_PSTRING_value(db->data, i); | ||
354 | max = p[db->num_fields]; /* last address */ | ||
355 | if (max == NULL) /* new row */ | ||
356 | { | ||
357 | for (n = 0; n < db->num_fields; n++) | ||
358 | free(p[n]); | ||
359 | } else { | ||
360 | for (n = 0; n < db->num_fields; n++) { | ||
361 | if (((p[n] < (char *)p) || | ||
362 | (p[n] > max)) && | ||
363 | (p[n] != NULL)) | ||
364 | free(p[n]); | ||
365 | } | ||
366 | } | ||
367 | free(sk_OPENSSL_PSTRING_value(db->data, i)); | ||
368 | } | ||
369 | sk_OPENSSL_PSTRING_free(db->data); | ||
370 | } | ||
371 | free(db); | ||
372 | } | ||