1 /* $MirOS: src/lib/libssl/src/crypto/x509v3/v3_utl.c,v 1.4 2007/05/17 16:38:17 tg Exp $ */
2 
3 /* v3_utl.c */
4 /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
5  * project.
6  */
7 /* ====================================================================
8  * Copyright (c) 1999-2003 The OpenSSL Project.  All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  *
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in
19  *    the documentation and/or other materials provided with the
20  *    distribution.
21  *
22  * 3. All advertising materials mentioning features or use of this
23  *    software must display the following acknowledgment:
24  *    "This product includes software developed by the OpenSSL Project
25  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
26  *
27  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
28  *    endorse or promote products derived from this software without
29  *    prior written permission. For written permission, please contact
30  *    licensing@OpenSSL.org.
31  *
32  * 5. Products derived from this software may not be called "OpenSSL"
33  *    nor may "OpenSSL" appear in their names without prior written
34  *    permission of the OpenSSL Project.
35  *
36  * 6. Redistributions of any form whatsoever must retain the following
37  *    acknowledgment:
38  *    "This product includes software developed by the OpenSSL Project
39  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
42  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
44  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
45  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
46  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
47  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
48  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
50  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
51  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
52  * OF THE POSSIBILITY OF SUCH DAMAGE.
53  * ====================================================================
54  *
55  * This product includes cryptographic software written by Eric Young
56  * (eay@cryptsoft.com).  This product includes software written by Tim
57  * Hudson (tjh@cryptsoft.com).
58  *
59  */
60 /* X509 v3 extension utilities */
61 
62 #include <stdio.h>
63 #include <ctype.h>
64 #include "cryptlib.h"
65 #include <openssl/conf.h>
66 #include <openssl/x509v3.h>
67 
68 __RCSID("$MirOS: src/lib/libssl/src/crypto/x509v3/v3_utl.c,v 1.4 2007/05/17 16:38:17 tg Exp $");
69 
70 static char *strip_spaces(char *name);
71 static int sk_strcmp(const char * const *a, const char * const *b);
72 static STACK *get_email(X509_NAME *name, GENERAL_NAMES *gens);
73 static void str_free(void *str);
74 static int append_ia5(STACK **sk, ASN1_IA5STRING *email);
75 
76 static int ipv4_from_asc(unsigned char *v4, const char *in);
77 static int ipv6_from_asc(unsigned char *v6, const char *in);
78 static int ipv6_cb(const char *elem, int len, void *usr);
79 static int ipv6_hex(unsigned char *out, const char *in, int inlen);
80 
81 /* Add a CONF_VALUE name value pair to stack */
82 
X509V3_add_value(const char * name,const char * value,STACK_OF (CONF_VALUE)** extlist)83 int X509V3_add_value(const char *name, const char *value,
84 						STACK_OF(CONF_VALUE) **extlist)
85 {
86 	CONF_VALUE *vtmp = NULL;
87 	char *tname = NULL, *tvalue = NULL;
88 	if(name && !(tname = BUF_strdup(name))) goto err;
89 	if(value && !(tvalue = BUF_strdup(value))) goto err;
90 	if(!(vtmp = (CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE)))) goto err;
91 	if(!*extlist && !(*extlist = sk_CONF_VALUE_new_null())) goto err;
92 	vtmp->section = NULL;
93 	vtmp->name = tname;
94 	vtmp->value = tvalue;
95 	if(!sk_CONF_VALUE_push(*extlist, vtmp)) goto err;
96 	return 1;
97 	err:
98 	X509V3err(X509V3_F_X509V3_ADD_VALUE,ERR_R_MALLOC_FAILURE);
99 	if(vtmp) OPENSSL_free(vtmp);
100 	if(tname) OPENSSL_free(tname);
101 	if(tvalue) OPENSSL_free(tvalue);
102 	return 0;
103 }
104 
X509V3_add_value_uchar(const char * name,const unsigned char * value,STACK_OF (CONF_VALUE)** extlist)105 int X509V3_add_value_uchar(const char *name, const unsigned char *value,
106 			   STACK_OF(CONF_VALUE) **extlist)
107     {
108     return X509V3_add_value(name,(const char *)value,extlist);
109     }
110 
111 /* Free function for STACK_OF(CONF_VALUE) */
112 
X509V3_conf_free(CONF_VALUE * conf)113 void X509V3_conf_free(CONF_VALUE *conf)
114 {
115 	if(!conf) return;
116 	if(conf->name) OPENSSL_free(conf->name);
117 	if(conf->value) OPENSSL_free(conf->value);
118 	if(conf->section) OPENSSL_free(conf->section);
119 	OPENSSL_free(conf);
120 }
121 
X509V3_add_value_bool(const char * name,int asn1_bool,STACK_OF (CONF_VALUE)** extlist)122 int X509V3_add_value_bool(const char *name, int asn1_bool,
123 						STACK_OF(CONF_VALUE) **extlist)
124 {
125 	if(asn1_bool) return X509V3_add_value(name, "TRUE", extlist);
126 	return X509V3_add_value(name, "FALSE", extlist);
127 }
128 
X509V3_add_value_bool_nf(char * name,int asn1_bool,STACK_OF (CONF_VALUE)** extlist)129 int X509V3_add_value_bool_nf(char *name, int asn1_bool,
130 						STACK_OF(CONF_VALUE) **extlist)
131 {
132 	if(asn1_bool) return X509V3_add_value(name, "TRUE", extlist);
133 	return 1;
134 }
135 
136 
i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD * method,ASN1_ENUMERATED * a)137 char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *method, ASN1_ENUMERATED *a)
138 {
139 	BIGNUM *bntmp = NULL;
140 	char *strtmp = NULL;
141 	if(!a) return NULL;
142 	if(!(bntmp = ASN1_ENUMERATED_to_BN(a, NULL)) ||
143 	    !(strtmp = BN_bn2dec(bntmp)) )
144 		X509V3err(X509V3_F_I2S_ASN1_ENUMERATED,ERR_R_MALLOC_FAILURE);
145 	BN_free(bntmp);
146 	return strtmp;
147 }
148 
i2s_ASN1_INTEGER(X509V3_EXT_METHOD * method,ASN1_INTEGER * a)149 char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, ASN1_INTEGER *a)
150 {
151 	BIGNUM *bntmp = NULL;
152 	char *strtmp = NULL;
153 	if(!a) return NULL;
154 	if(!(bntmp = ASN1_INTEGER_to_BN(a, NULL)) ||
155 	    !(strtmp = BN_bn2dec(bntmp)) )
156 		X509V3err(X509V3_F_I2S_ASN1_INTEGER,ERR_R_MALLOC_FAILURE);
157 	BN_free(bntmp);
158 	return strtmp;
159 }
160 
s2i_ASN1_INTEGER(X509V3_EXT_METHOD * method,char * value)161 ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, char *value)
162 {
163 	BIGNUM *bn = NULL;
164 	ASN1_INTEGER *aint;
165 	int isneg, ishex;
166 	int ret;
167 	bn = BN_new();
168 	if (!value) {
169 		X509V3err(X509V3_F_S2I_ASN1_INTEGER,X509V3_R_INVALID_NULL_VALUE);
170 		return 0;
171 	}
172 	if (value[0] == '-') {
173 		value++;
174 		isneg = 1;
175 	} else isneg = 0;
176 
177 	if (value[0] == '0' && ((value[1] == 'x') || (value[1] == 'X'))) {
178 		value += 2;
179 		ishex = 1;
180 	} else ishex = 0;
181 
182 	if (ishex) ret = BN_hex2bn(&bn, value);
183 	else ret = BN_dec2bn(&bn, value);
184 
185 	if (!ret) {
186 		X509V3err(X509V3_F_S2I_ASN1_INTEGER,X509V3_R_BN_DEC2BN_ERROR);
187 		return 0;
188 	}
189 
190 	if (isneg && BN_is_zero(bn)) isneg = 0;
191 
192 	aint = BN_to_ASN1_INTEGER(bn, NULL);
193 	BN_free(bn);
194 	if (!aint) {
195 		X509V3err(X509V3_F_S2I_ASN1_INTEGER,X509V3_R_BN_TO_ASN1_INTEGER_ERROR);
196 		return 0;
197 	}
198 	if (isneg) aint->type |= V_ASN1_NEG;
199 	return aint;
200 }
201 
X509V3_add_value_int(const char * name,ASN1_INTEGER * aint,STACK_OF (CONF_VALUE)** extlist)202 int X509V3_add_value_int(const char *name, ASN1_INTEGER *aint,
203 	     STACK_OF(CONF_VALUE) **extlist)
204 {
205 	char *strtmp;
206 	int ret;
207 	if(!aint) return 1;
208 	if(!(strtmp = i2s_ASN1_INTEGER(NULL, aint))) return 0;
209 	ret = X509V3_add_value(name, strtmp, extlist);
210 	OPENSSL_free(strtmp);
211 	return ret;
212 }
213 
X509V3_get_value_bool(CONF_VALUE * value,int * asn1_bool)214 int X509V3_get_value_bool(CONF_VALUE *value, int *asn1_bool)
215 {
216 	char *btmp;
217 	if(!(btmp = value->value)) goto err;
218 	if(!strcmp(btmp, "TRUE") || !strcmp(btmp, "true")
219 		 || !strcmp(btmp, "Y") || !strcmp(btmp, "y")
220 		|| !strcmp(btmp, "YES") || !strcmp(btmp, "yes")) {
221 		*asn1_bool = 0xff;
222 		return 1;
223 	} else if(!strcmp(btmp, "FALSE") || !strcmp(btmp, "false")
224 		 || !strcmp(btmp, "N") || !strcmp(btmp, "n")
225 		|| !strcmp(btmp, "NO") || !strcmp(btmp, "no")) {
226 		*asn1_bool = 0;
227 		return 1;
228 	}
229 	err:
230 	X509V3err(X509V3_F_X509V3_GET_VALUE_BOOL,X509V3_R_INVALID_BOOLEAN_STRING);
231 	X509V3_conf_err(value);
232 	return 0;
233 }
234 
X509V3_get_value_int(CONF_VALUE * value,ASN1_INTEGER ** aint)235 int X509V3_get_value_int(CONF_VALUE *value, ASN1_INTEGER **aint)
236 {
237 	ASN1_INTEGER *itmp;
238 	if(!(itmp = s2i_ASN1_INTEGER(NULL, value->value))) {
239 		X509V3_conf_err(value);
240 		return 0;
241 	}
242 	*aint = itmp;
243 	return 1;
244 }
245 
246 #define HDR_NAME	1
247 #define HDR_VALUE	2
248 
249 /*#define DEBUG*/
250 
STACK_OF(CONF_VALUE)251 STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line)
252 {
253 	char *p, *q, c;
254 	char *ntmp, *vtmp;
255 	STACK_OF(CONF_VALUE) *values = NULL;
256 	char *linebuf;
257 	int state;
258 	/* We are going to modify the line so copy it first */
259 	linebuf = BUF_strdup(line);
260 	state = HDR_NAME;
261 	ntmp = NULL;
262 	/* Go through all characters */
263 	for(p = linebuf, q = linebuf; (c = *p) && (c!='\r') && (c!='\n'); p++) {
264 
265 		switch(state) {
266 			case HDR_NAME:
267 			if(c == ':') {
268 				state = HDR_VALUE;
269 				*p = 0;
270 				ntmp = strip_spaces(q);
271 				if(!ntmp) {
272 					X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_NAME);
273 					goto err;
274 				}
275 				q = p + 1;
276 			} else if(c == ',') {
277 				*p = 0;
278 				ntmp = strip_spaces(q);
279 				q = p + 1;
280 #if 0
281 				printf("%s\n", ntmp);
282 #endif
283 				if(!ntmp) {
284 					X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_NAME);
285 					goto err;
286 				}
287 				X509V3_add_value(ntmp, NULL, &values);
288 			}
289 			break ;
290 
291 			case HDR_VALUE:
292 			if(c == ',') {
293 				state = HDR_NAME;
294 				*p = 0;
295 				vtmp = strip_spaces(q);
296 #if 0
297 				printf("%s\n", ntmp);
298 #endif
299 				if(!vtmp) {
300 					X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_VALUE);
301 					goto err;
302 				}
303 				X509V3_add_value(ntmp, vtmp, &values);
304 				ntmp = NULL;
305 				q = p + 1;
306 			}
307 
308 		}
309 	}
310 
311 	if(state == HDR_VALUE) {
312 		vtmp = strip_spaces(q);
313 #if 0
314 		printf("%s=%s\n", ntmp, vtmp);
315 #endif
316 		if(!vtmp) {
317 			X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_VALUE);
318 			goto err;
319 		}
320 		X509V3_add_value(ntmp, vtmp, &values);
321 	} else {
322 		ntmp = strip_spaces(q);
323 #if 0
324 		printf("%s\n", ntmp);
325 #endif
326 		if(!ntmp) {
327 			X509V3err(X509V3_F_X509V3_PARSE_LIST, X509V3_R_INVALID_NULL_NAME);
328 			goto err;
329 		}
330 		X509V3_add_value(ntmp, NULL, &values);
331 	}
332 OPENSSL_free(linebuf);
333 return values;
334 
335 err:
336 OPENSSL_free(linebuf);
337 sk_CONF_VALUE_pop_free(values, X509V3_conf_free);
338 return NULL;
339 
340 }
341 
342 /* Delete leading and trailing spaces from a string */
strip_spaces(char * name)343 static char *strip_spaces(char *name)
344 {
345 	char *p, *q;
346 	/* Skip over leading spaces */
347 	p = name;
348 	while(isspace((unsigned char)*p)) p++;
349 	if(!*p) return NULL;
350 	q = p + strlen(p) - 1;
351 	while((q != p) && isspace((unsigned char)*q)) q--;
352 	if(p != q) q[1] = 0;
353 	if(!*p) return NULL;
354 	return p;
355 }
356 
357 /* V2I name comparison function: returns zero if 'name' matches
358  * cmp or cmp.*
359  */
360 
name_cmp(const char * name,const char * cmp)361 int name_cmp(const char *name, const char *cmp)
362 {
363 	int len, ret;
364 	char c;
365 	len = strlen(cmp);
366 	if((ret = strncmp(name, cmp, len))) return ret;
367 	c = name[len];
368 	if(!c || (c=='.')) return 0;
369 	return 1;
370 }
371 
sk_strcmp(const char * const * a,const char * const * b)372 static int sk_strcmp(const char * const *a, const char * const *b)
373 {
374 	return strcmp(*a, *b);
375 }
376 
X509_get1_email(X509 * x)377 STACK *X509_get1_email(X509 *x)
378 {
379 	GENERAL_NAMES *gens;
380 	STACK *ret;
381 	gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
382 	ret = get_email(X509_get_subject_name(x), gens);
383 	sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
384 	return ret;
385 }
386 
X509_REQ_get1_email(X509_REQ * x)387 STACK *X509_REQ_get1_email(X509_REQ *x)
388 {
389 	GENERAL_NAMES *gens;
390 	STACK_OF(X509_EXTENSION) *exts;
391 	STACK *ret;
392 	exts = X509_REQ_get_extensions(x);
393 	gens = X509V3_get_d2i(exts, NID_subject_alt_name, NULL, NULL);
394 	ret = get_email(X509_REQ_get_subject_name(x), gens);
395 	sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
396 	sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
397 	return ret;
398 }
399 
400 
get_email(X509_NAME * name,GENERAL_NAMES * gens)401 static STACK *get_email(X509_NAME *name, GENERAL_NAMES *gens)
402 {
403 	STACK *ret = NULL;
404 	X509_NAME_ENTRY *ne;
405 	ASN1_IA5STRING *email;
406 	GENERAL_NAME *gen;
407 	int i;
408 	/* Now add any email address(es) to STACK */
409 	i = -1;
410 	/* First supplied X509_NAME */
411 	while((i = X509_NAME_get_index_by_NID(name,
412 					 NID_pkcs9_emailAddress, i)) >= 0) {
413 		ne = X509_NAME_get_entry(name, i);
414 		email = X509_NAME_ENTRY_get_data(ne);
415 		if(!append_ia5(&ret, email)) return NULL;
416 	}
417 	for(i = 0; i < sk_GENERAL_NAME_num(gens); i++)
418 	{
419 		gen = sk_GENERAL_NAME_value(gens, i);
420 		if(gen->type != GEN_EMAIL) continue;
421 		if(!append_ia5(&ret, gen->d.ia5)) return NULL;
422 	}
423 	return ret;
424 }
425 
str_free(void * str)426 static void str_free(void *str)
427 {
428 	OPENSSL_free(str);
429 }
430 
append_ia5(STACK ** sk,ASN1_IA5STRING * email)431 static int append_ia5(STACK **sk, ASN1_IA5STRING *email)
432 {
433 	char *emtmp;
434 	/* First some sanity checks */
435 	if(email->type != V_ASN1_IA5STRING) return 1;
436 	if(!email->data || !email->length) return 1;
437 	if(!*sk) *sk = sk_new(sk_strcmp);
438 	if(!*sk) return 0;
439 	/* Don't add duplicates */
440 	if(sk_find(*sk, (char *)email->data) != -1) return 1;
441 	emtmp = BUF_strdup((char *)email->data);
442 	if(!emtmp || !sk_push(*sk, emtmp)) {
443 		X509_email_free(*sk);
444 		*sk = NULL;
445 		return 0;
446 	}
447 	return 1;
448 }
449 
X509_email_free(STACK * sk)450 void X509_email_free(STACK *sk)
451 {
452 	sk_pop_free(sk, str_free);
453 }
454 
455 /* Convert IP addresses both IPv4 and IPv6 into an
456  * OCTET STRING compatible with RFC3280.
457  */
458 
a2i_IPADDRESS(const char * ipasc)459 ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc)
460 	{
461 	unsigned char ipout[16];
462 	ASN1_OCTET_STRING *ret;
463 	int iplen;
464 
465 	/* If string contains a ':' assume IPv6 */
466 
467 	if (strchr(ipasc, ':'))
468 		{
469 		if (!ipv6_from_asc(ipout, ipasc))
470 			return NULL;
471 		iplen = 16;
472 		}
473 	else
474 		{
475 		if (!ipv4_from_asc(ipout, ipasc))
476 			return NULL;
477 		iplen = 4;
478 		}
479 
480 	ret = ASN1_OCTET_STRING_new();
481 	if (!ret)
482 		return NULL;
483 	if (!ASN1_OCTET_STRING_set(ret, ipout, iplen))
484 		{
485 		ASN1_OCTET_STRING_free(ret);
486 		return NULL;
487 		}
488 	return ret;
489 	}
490 
ipv4_from_asc(unsigned char * v4,const char * in)491 static int ipv4_from_asc(unsigned char *v4, const char *in)
492 	{
493 	int a0, a1, a2, a3;
494 	if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
495 		return 0;
496 	if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
497 		|| (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
498 		return 0;
499 	v4[0] = a0;
500 	v4[1] = a1;
501 	v4[2] = a2;
502 	v4[3] = a3;
503 	return 1;
504 	}
505 
506 typedef struct {
507 		/* Temporary store for IPV6 output */
508 		unsigned char tmp[16];
509 		/* Total number of bytes in tmp */
510 		int total;
511 		/* The position of a zero (corresponding to '::') */
512 		int zero_pos;
513 		/* Number of zeroes */
514 		int zero_cnt;
515 	} IPV6_STAT;
516 
517 
ipv6_from_asc(unsigned char * v6,const char * in)518 static int ipv6_from_asc(unsigned char *v6, const char *in)
519 	{
520 	IPV6_STAT v6stat;
521 	v6stat.total = 0;
522 	v6stat.zero_pos = -1;
523 	v6stat.zero_cnt = 0;
524 	/* Treat the IPv6 representation as a list of values
525 	 * separated by ':'. The presence of a '::' will parse
526  	 * as one, two or three zero length elements.
527 	 */
528 	if (!CONF_parse_list(in, ':', 0, ipv6_cb, &v6stat))
529 		return 0;
530 
531 	/* Now for some sanity checks */
532 
533 	if (v6stat.zero_pos == -1)
534 		{
535 		/* If no '::' must have exactly 16 bytes */
536 		if (v6stat.total != 16)
537 			return 0;
538 		}
539 	else
540 		{
541 		/* If '::' must have less than 16 bytes */
542 		if (v6stat.total == 16)
543 			return 0;
544 		/* More than three zeroes is an error */
545 		if (v6stat.zero_cnt > 3)
546 			return 0;
547 		/* Can only have three zeroes if nothing else present */
548 		else if (v6stat.zero_cnt == 3)
549 			{
550 			if (v6stat.total > 0)
551 				return 0;
552 			}
553 		/* Can only have two zeroes if at start or end */
554 		else if (v6stat.zero_cnt == 2)
555 			{
556 			if ((v6stat.zero_pos != 0)
557 				&& (v6stat.zero_pos != v6stat.total))
558 				return 0;
559 			}
560 		else
561 		/* Can only have one zero if *not* start or end */
562 			{
563 			if ((v6stat.zero_pos == 0)
564 				|| (v6stat.zero_pos == v6stat.total))
565 				return 0;
566 			}
567 		}
568 
569 	/* Format result */
570 
571 	/* Copy initial part */
572 	if (v6stat.zero_pos > 0)
573 		memcpy(v6, v6stat.tmp, v6stat.zero_pos);
574 	/* Zero middle */
575 	if (v6stat.total != 16)
576 		memset(v6 + v6stat.zero_pos, 0, 16 - v6stat.total);
577 	/* Copy final part */
578 	if (v6stat.total != v6stat.zero_pos)
579 		memcpy(v6 + v6stat.zero_pos + 16 - v6stat.total,
580 			v6stat.tmp + v6stat.zero_pos,
581 			v6stat.total - v6stat.zero_pos);
582 
583 	return 1;
584 	}
585 
ipv6_cb(const char * elem,int len,void * usr)586 static int ipv6_cb(const char *elem, int len, void *usr)
587 	{
588 	IPV6_STAT *s = usr;
589 	/* Error if 16 bytes written */
590 	if (s->total == 16)
591 		return 0;
592 	if (len == 0)
593 		{
594 		/* Zero length element, corresponds to '::' */
595 		if (s->zero_pos == -1)
596 			s->zero_pos = s->total;
597 		/* If we've already got a :: its an error */
598 		else if (s->zero_pos != s->total)
599 			return 0;
600 		s->zero_cnt++;
601 		}
602 	else
603 		{
604 		/* If more than 4 characters could be final a.b.c.d form */
605 		if (len > 4)
606 			{
607 			/* Need at least 4 bytes left */
608 			if (s->total > 12)
609 				return 0;
610 			/* Must be end of string */
611 			if (elem[len])
612 				return 0;
613 			if (!ipv4_from_asc(s->tmp + s->total, elem))
614 				return 0;
615 			s->total += 4;
616 			}
617 		else
618 			{
619 			if (!ipv6_hex(s->tmp + s->total, elem, len))
620 				return 0;
621 			s->total += 2;
622 			}
623 		}
624 	return 1;
625 	}
626 
627 /* Convert a string of up to 4 hex digits into the corresponding
628  * IPv6 form.
629  */
630 
ipv6_hex(unsigned char * out,const char * in,int inlen)631 static int ipv6_hex(unsigned char *out, const char *in, int inlen)
632 	{
633 	unsigned char c;
634 	unsigned int num = 0;
635 	if (inlen > 4)
636 		return 0;
637 	while(inlen--)
638 		{
639 		c = *in++;
640 		num <<= 4;
641 		if ((c >= '0') && (c <= '9'))
642 			num |= c - '0';
643 		else if ((c >= 'A') && (c <= 'F'))
644 			num |= c - 'A' + 10;
645 		else if ((c >= 'a') && (c <= 'f'))
646 			num |=  c - 'a' + 10;
647 		else
648 			return 0;
649 		}
650 	out[0] = num >> 8;
651 	out[1] = num & 0xff;
652 	return 1;
653 	}
654