alpha64

skeletons/INTEGER.c

@@ -379,24 +379,24 @@ asn_long2INTEGER(INTEGER_t *st, long value) {
 	 * a) shall not all be ones; and
 	 * b) shall not all be zero.
 	 */
-	for(p = pstart; p < pend1; p += add) {
+	for(p = pstart; p != pend1; p += add) {
 		switch(*p) {
-		case 0x00: if((p[1] & 0x80) == 0)
+		case 0x00: if((*(p+add) & 0x80) == 0)
 				continue;
 			break;
-		case 0xff: if((p[1] & 0x80))
+		case 0xff: if((*(p+add) & 0x80))
 				continue;
 			break;
 		}
 		break;
 	}
 	/* Copy the integer body */
-	for(pstart = p, bp = buf; p <= pend1;)
-		*bp++ = *p++;
+	for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add)
+		*bp++ = *p;
 
 	if(st->buf) FREEMEM(st->buf);
 	st->buf = buf;
-	st->size = p - pstart;
+	st->size = bp - buf;
 
 	return 0;
 }

skeletons/OCTET_STRING.c

@@ -914,8 +914,8 @@ static ssize_t OCTET_STRING__convert_binary(void *sptr, void *chunk_buf, size_t
  * Something like strtod(), but with stricter rules.
  */
 static int
-OS__strtoent(int base, char *buf, char *end, long *return_value) {
-	long val = 0;
+OS__strtoent(int base, char *buf, char *end, int32_t *return_value) {
+	int32_t val = 0;
 	char *p;
 
 	for(p = buf; p < end; p++) {
@@ -981,7 +981,7 @@ static ssize_t OCTET_STRING__convert_entrefs(void *sptr, void *chunk_buf, size_t
 		if(len == 1 /* "&" */) goto want_more;
 		if(p[1] == 0x23 /* '#' */) {
 			char *pval;	/* Pointer to start of digits */
-			long val;	/* Entity reference value */
+			int32_t val;	/* Entity reference value */
 			int base;
 
 			if(len == 2 /* "&#" */) goto want_more;

skeletons/REAL.c

@@ -2,12 +2,16 @@
  * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
+#if	defined(__alpha)
+#define	_ISOC99_SOURCE	/* For quiet NAN, indirectly through bits/nan.h */
+#define	_BSD_SOURCE	/* To reintroduce finite(3) */
+#endif
 #include <asn_internal.h>
-#include <REAL.h>
 #include <stdlib.h>	/* for strtod(3) */
 #include <math.h>
 #include <errno.h>
 #include <assert.h>
+#include <REAL.h>
 
 #undef	INT_MAX
 #define	INT_MAX	((int)(((unsigned int)-1) >> 1))

skeletons/ber_decoder.c

@@ -255,8 +255,8 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
 			 * Inner TLV specifies length which is inconsistent
 			 * with the outer TLV's length value.
 			 */
-			ASN_DEBUG("Outer TLV is %d and inner is %d",
-				limit_len, tlv_len);
+			ASN_DEBUG("Outer TLV is %ld and inner is %ld",
+				(long)limit_len, (long)tlv_len);
 			RETURN(RC_FAIL);
 		}
 

skeletons/ber_tlv_length.c

@@ -54,8 +54,8 @@ ber_fetch_length(int _is_constructed, void *bufptr, size_t size,
 
 			/*
 			 * Here length may be very close or equal to 2G.
-			 * However, the arithmetics used in other decoders
-			 * often add some (small) quantities to the length,
+			 * However, the arithmetics used in some decoders
+			 * may add some (small) quantities to the length,
 			 * to check the resulting value against some limits.
 			 * This may result in integer wrap-around.
 			 */

skeletons/tests/check-INTEGER.c

@@ -44,6 +44,7 @@ check(uint8_t *buf, int size, long check_long, int check_ret) {
 	printf(" (%ld, %d) vs (%ld, %d)\n",
 		rlong, ret, check_long, check_ret);
 	assert(ret == check_ret);
+	printf("%ld %ld\n", rlong, check_long);
 	assert(rlong == check_long);
 
 	if(check_ret == 0) {
@@ -134,7 +135,7 @@ main(int ac, char **av) {
 	CHECK(buf8, 0x7F7E7D7C, 0);
 	CHECK(buf9, 0x7F7E7D7C, 0);
 	CHECK(buf10, 0x7F7E7D7C, 0);
-	CHECK(buf11, 0x80000000, 0);
+	CHECK(buf11, -2147483648, 0);	/* 0x80000000 */
 	CHECK(buf12, -32768, 0);
 	CHECK(buf13, -128, 0);
 

skeletons/tests/check-OCTET_STRING.c

@@ -89,6 +89,7 @@ main() {
 	check(UTF8, "z", "<z z z>a&#32;b</z z z>", "a b");
 	check(UTF8, "z", "<z>a&#32323;b</z>", "a\347\271\203b");
 	check(UTF8, "z", "<z>a&#3000000000;b</z>", "a&#3000000000;b");
+	check(UTF8, "z", "<z>a&#5000000000;b</z>", "a&#5000000000;b");
 	check(UTF8, "z", "<z>a&#300</z>", "a&#300");
 	check(UTF8, "z", "<z>a&#-300;</z>", "a&#-300;");
 	check(UTF8, "z", "<z>a<ff/>b</z>", "a\014b");

skeletons/tests/check-length.c

@@ -87,6 +87,7 @@ main() {
 	uint8_t buf1[] = { 0x85, 0x00, 0x01, 0x02, 0x03, 0x04 };
 	uint8_t buf2[] = { 0x85, 0x00, 0x7f, 0xff, 0x03, 0x04 };
 	uint8_t buf3[] = { 0x85, 0x00, 0x7f, 0xff, 0xff, 0x04 };
+	uint8_t buf4[] = { 0x89, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x04 };
 	ber_tlv_len_t tlv_len;
 	ssize_t ret;
 	int i;
@@ -104,9 +105,15 @@ main() {
 	printf("ret=%ld, len=%ld\n", (long)ret, (long)tlv_len);
 	assert(ret == sizeof(buf2));
 
-	ret = ber_fetch_length(0, buf3, sizeof(buf3), &tlv_len);
-	printf("ret=%ld\n", (long)ret);
-	assert(ret == -1);
+	if(sizeof(tlv_len) == 4) {
+		ret = ber_fetch_length(0, buf3, sizeof(buf3), &tlv_len);
+		printf("ret=%ld\n", (long)ret);
+		assert(ret == -1);
+	} else if(sizeof(tlv_len) == 8) {
+		ret = ber_fetch_length(0, buf4, sizeof(buf4), &tlv_len);
+		printf("ret=%ld\n", (long)ret);
+		assert(ret == -1);
+	}
 
 	return 0;
 }

skeletons/xer_support.c

@@ -88,7 +88,7 @@ _charclass[256] = {
 /*
  * Parser itself
  */
-int pxml_parse(int *stateContext, void *xmlbuf, size_t size, pxml_callback_f *cb, void *key) {
+ssize_t pxml_parse(int *stateContext, void *xmlbuf, size_t size, pxml_callback_f *cb, void *key) {
 	pstate_e state = (pstate_e)*stateContext;
 	char *chunk_start = (char *)xmlbuf;
 	char *p = chunk_start;