--- pgp/src/mpiio.c	2018/04/24 16:40:15	1.1.1.4
+++ pgp/src/mpiio.c	2018/04/24 16:42:24	1.1.1.6
@@ -7,10 +7,10 @@
 	Boulder, CO 80304
 	(303) 541-0140
 
-	(c) Copyright 1986-92 by Philip Zimmermann.  All rights reserved.
-	The author assumes no liability for damages resulting from the use 
-	of this software, even if the damage results from defects in this 
-	software.  No warranty is expressed or implied.  
+	(c) Copyright 1986-1994 by Philip Zimmermann.  All rights reserved.
+	The author assumes no liability for damages resulting from the use
+	of this software, even if the damage results from defects in this
+	software.  No warranty is expressed or implied.
 
 	These routines are for multiprecision arithmetic I/O functions for
 	number-theoretic cryptographic algorithms such as ElGamal,
@@ -48,32 +48,35 @@ void putstr(string s); /* Put out null-t
 /*----------------- Following procedures relate to I/O ------------------*/
 
 int string_length(char *s)
-	/* Returns string length, just like strlen() from <string.h> */
-{	int i;
+/* Returns string length, just like strlen() from <string.h> */
+{
+	int i;
 	i = 0;
 	if (s != NULL)
 		while (*s++) i++;
 	return (i);	
-}	/* string_length */
+} /* string_length */
 
 
 #ifdef DEBUG
 static int ctox(int c)
-	/* Returns integer 0-15 if c is an ASCII hex digit, -1 otherwise. */
-{	if ((c >= '0') && (c <= '9'))
+/* Returns integer 0-15 if c is an ASCII hex digit, -1 otherwise. */
+{
+	if ((c >= '0') && (c <= '9'))
 		return(c - '0');
 	if ((c >= 'a') && (c <= 'f'))
 		return((c - 'a') + 10);
 	if ((c >= 'A') && (c <= 'F'))
 		return((c - 'A') + 10);
 	return(-1);		/* error -- not a hex digit */
-}	/* ctox */
+} /* ctox */
 
 
 int str2reg(unitptr reg,string digitstr)
-	/* Converts a possibly-signed digit string into a large binary number.
-	   Returns assumed radix, derived from suffix 'h','o',b','.' */
-{	unit temp[MAX_UNIT_PRECISION],base[MAX_UNIT_PRECISION];
+/* Converts a possibly-signed digit string into a large binary number.
+   Returns assumed radix, derived from suffix 'h','o',b','.' */
+{
+	unit temp[MAX_UNIT_PRECISION],base[MAX_UNIT_PRECISION];
 	int c,i;
 	boolean minus = FALSE;
 	short radix;	/* base 2-16 */
@@ -86,24 +89,20 @@ int str2reg(unitptr reg,string digitstr)
 	
 	switch (c)	/* classify radix select suffix character */
 	{
-	case '.':	radix = 10;
-			break;
-	case 'H':
-	case 'h':	radix = 16;
-			break;
-	case 'O': 
-	case 'o':	radix = 8;
-			break;
-	case 'B':
-	case 'b':	radix = 2;	/* caution! 'b' is a hex digit! */
-			break;
-	default:	radix = 10;
+	  case '.':	radix = 10;	break;
+	  case 'H':
+	  case 'h':	radix = 16;	break;
+	  case 'O': 
+	  case 'o':	radix = 8;	break;
+	  case 'B':	/* caution! 'b' is a hex digit! */
+	  case 'b':	radix = 2;	break;
+	  default:	radix = 10;	break;
 	}
 
 	mp_init(base,radix);
 	if ((minus = (*digitstr == '-')) != 0) digitstr++;
-	while ((c = *digitstr++) != 0)
-	{	if (c==',') continue;	/* allow commas in number */
+	while ((c = *digitstr++) != 0) {
+		if (c==',') continue;	/* allow commas in number */
 		c = ctox(c);
 		if ((c < 0) || (c >= radix)) 
 			break;	/* scan terminated by any non-digit */
@@ -126,29 +125,38 @@ int str2reg(unitptr reg,string digitstr)
 */
 
 static void putstr(string s)
-	/* Put out null-terminated ASCII string via putchar. */
-{	while (*s) putchar(*s++);
-}	/* putstr */
+/* Put out null-terminated ASCII string via putchar. */
+{
+	while (*s)
+		putchar(*s++);
+} /* putstr */
 
 static void puthexbyte(byte b)
-	/* Put out byte in ASCII hex via putchar. */
-{	static char *nibs = "0123456789ABCDEF";
+/* Put out byte in ASCII hex via putchar. */
+{
+#ifdef VMS
+        static char const nibs[] = "0123456789ABCDEF";
+#else
+	static char const nibs[16] = "0123456789ABCDEF";
+#endif
 	putchar(nibs[b >> 4]);
 	putchar(nibs[b & 0x0F]);
-}	/* puthexbyte */
+} /* puthexbyte */
 
 static void puthexw16(word16 w)
-	/* Put out 16-bit word in hex, high byte first. */
-{	puthexbyte((byte)(w >> 8));
+/* Put out 16-bit word in hex, high byte first. */
+{
+	puthexbyte((byte)(w >> 8));
 	puthexbyte((byte)(w & 0xFF));
-}	/* puthexw16 */
+} /* puthexw16 */
 
 #ifdef UNIT32
 static void puthexw32(word32 lw)
-	/* Puts out 32-bit word in hex, high byte first. */
-{	puthexw16((word16)(lw>>16));
+/* Puts out 32-bit word in hex, high byte first. */
+{
+	puthexw16((word16)(lw>>16));
 	puthexw16((word16)(lw & 0xFFFFL));
-}	/* puthexw32 */
+} /* puthexw32 */
 #endif	/* UNIT32 */
 
 
@@ -164,11 +172,12 @@ static void puthexw32(word32 lw)
 
 #ifdef DEBUG
 int display_in_base(string s,unitptr n,short radix)
-	/* Display n in any base, such as base 10.  Returns number of digits. */
-	/*	s is string to label the displayed register.
-		n is multiprecision integer.
-		radix is base, 2-16. 
-	*/
+/*
+ * Display n in any base, such as base 10.  Returns number of digits.
+ * s is string to label the displayed register.
+ * n is multiprecision integer.
+ * radix is base, 2-16. 
+ */
 {
 	char buf[MAX_BIT_PRECISION + (MAX_BIT_PRECISION/8) + 2];
 	unit r[MAX_UNIT_PRECISION],quotient[MAX_UNIT_PRECISION];
@@ -185,21 +194,21 @@ int display_in_base(string s,unitptr n,s
 	if ((s[0] != '\033') || (s[1] != '\0'))
 		putstr(s);
 
-	if ( (radix < 2) || (radix > 16) )
-	{	putstr("****\n");	/* radix out of range -- show error */
+	if ( (radix < 2) || (radix > 16) ) {
+		putstr("****\n");	/* radix out of range -- show error */
 		return(-1);
 	}
 	commaplaces = (radix==10 ? 3 : (radix==16 ? 4 :
 			(radix==2 ? 8 : (radix==8 ? 8 : 1))));
 	mp_move(r,n);
-	if ((radix == 10) && mp_tstminus(r))
-	{	minus = TRUE;
+	if ((radix == 10) && mp_tstminus(r)) {
+		minus = TRUE;
 		mp_neg(r);	/* make r positive */
 	}
 
 	*bp = '\0';
-	do	/* build backwards number string */
-	{	if (++places>1)
+	do {	/* build backwards number string */
+		if (++places>1)
 			if ((places % commaplaces)==1)
 				*++bp = ',';	/* 000,000,000,000 */
 		remainder = mp_shortdiv(quotient,r,radix);
@@ -214,33 +223,34 @@ int display_in_base(string s,unitptr n,s
 			*++bp = ' '; /* pad to line up commas */
 
 	i = string_length(s);
-	while (*bp)
-	{	putchar(*bp);
+	while (*bp) {
+		putchar(*bp);
 		++i;
 		if ((*bp == ',') || commaplaces==1)
-			if (i > (72-commaplaces))
-			{	putchar('\n'); 
+			if (i > (72-commaplaces)) {
+				putchar('\n'); 
 				i=string_length(s);
 				while (i--) putchar(' ');
 				i = string_length(s);
 			}
 		bp--;
 	}
-	switch (radix)
-	{	/* show suffix character to designate radix */
-	case 10: /* decimal */
+
+	/* show suffix character to designate radix */
+	switch (radix) {
+	  case 10: /* decimal */
 		putchar('.');
 		break;
-	case 16: /* hex */
+	  case 16: /* hex */
 		putchar('h');
 		break;
-	case 8: /* octal */
+	  case 8: /* octal */
 		putchar('o');
 		break;
-	case 2: /* binary */
+	  case 2: /* binary */
 		putchar('b');
 		break;
-	default: /* nonstandard radix */
+	  default: /* nonstandard radix */
 		/* printf("(%d)",radix); */ ;	
 	}
 
@@ -251,26 +261,27 @@ int display_in_base(string s,unitptr n,s
 	fill0((byteptr)buf,sizeof(buf));	/* burn the evidence on the stack...*/
 	/* Note that local stack arrays r and quotient are now 0 */
 	return(places);
-}	/* display_in_base */
+} /* display_in_base */
 
 #endif	/* DEBUG */
 
 void mp_display(string s,unitptr r)
-	/* Display register r in hex, with prefix string s. */
-{	short precision;
+/* Display register r in hex, with prefix string s. */
+{
+	short precision;
 	int i,j;
 	putstr(s);
 	normalize(r,precision);	/* strip off leading zeros */
-	if (precision == 0)
-	{	putstr(" 0\n");
+	if (precision == 0) {
+		putstr(" 0\n");
 		return;
 	}
 	make_msbptr(r,precision);
 	i=0;
-	while (precision--)
-	{	if (!(i++ % (16/BYTES_PER_UNIT)))
-		{	if (i>1)
-			{	putchar('\n'); 
+	while (precision--) {
+		if (!(i++ % (16/BYTES_PER_UNIT))) {
+			if (i>1) {
+				putchar('\n'); 
 				j=string_length(s); 
 				while (j--) putchar(' ');
 			}
@@ -280,12 +291,13 @@ void mp_display(string s,unitptr r)
 		post_lowerunit(r);
 	}
 	putchar('\n');
-}	/* mp_display */
+} /* mp_display */
 
 
 word16 checksum(register byteptr buf, register word16 count)
-	/* Returns checksum of buffer. */
-{	word16 cs;
+/* Returns checksum of buffer. */
+{
+	word16 cs;
 	cs = 0;
 	while (count--) cs += *buf++;
 	return(cs);
@@ -293,33 +305,35 @@ word16 checksum(register byteptr buf, re
 
 
 void cbc_xor(register unitptr dst, register unitptr src, word16 bytecount)
-	/*	Performs the XOR necessary for RSA Cipher Block Chaining.
-		The dst buffer ought to have 1 less byte of significance than 
-		the src buffer.  Only the least significant part of the src 
-		buffer is used.  bytecount is the size of a plaintext block.
-	*/
+/*
+ * Performs the XOR necessary for RSA Cipher Block Chaining.
+ * The dst buffer ought to have 1 less byte of significance than 
+ * the src buffer.  Only the least significant part of the src 
+ * buffer is used.  bytecount is the size of a plaintext block.
+ */
 {	short nunits;	/* units of precision */
 	nunits = bytes2units(bytecount)-1;
 	make_lsbptr(dst,global_precision);
-	while (nunits--)
-	{	*dst ^= *post_higherunit(src);
+	while (nunits--) {
+		*dst ^= *post_higherunit(src);
 		post_higherunit(dst);
 		bytecount -= units2bytes(1);
 	}
 	/* on the last unit, don't xor the excess top byte... */
 	*dst ^= (*src & (power_of_2(bytecount<<3)-1));
-}	/* cbc_xor */
+} /* cbc_xor */
 
 
 void hiloswap(byteptr r1,short numbytes)
 	/* Reverses the order of bytes in an array of bytes. */
-{	byteptr r2;
+{
+	byteptr r2;
 	byte b;
 	r2 = &(r1[numbytes-1]);
-	while (r1 < r2)
-	{	b = *r1; *r1++ = *r2; *r2-- = b;
+	while (r1 < r2) {
+		b = *r1; *r1++ = *r2; *r2-- = b;
 	}
-}	/* hiloswap */
+} /* hiloswap */
 
 
 #define byteglue(lo,hi) ((((word16) hi) << 8) + (word16) lo)
@@ -333,40 +347,43 @@ word16 fetch_word16(byte *buf)
 /*	Fetches a 16-bit word from where byte pointer is pointing.
 	buf points to external-format byteorder array.
 */
-{	word16 w0,w1;
+{
+	word16 w0, w1;
 /* Assume MSB external byte ordering */
 	w1 = *buf++;
 	w0 = *buf++;
 	return(w0 + (w1<<8));
-}	/* fetch_word16 */
+} /* fetch_word16 */
 
 
 byte *put_word16(word16 w, byte *buf)
-/*	Puts a 16-bit word to where byte pointer is pointing, and 
-	returns updated byte pointer.
-	buf points to external-format byteorder array.
-*/
+/*
+ * Puts a 16-bit word to where byte pointer is pointing, and 
+ * returns updated byte pointer.
+ * buf points to external-format byteorder array.
+ */
 {
 /* Assume MSB external byte ordering */
 	buf[1] = w & 0xff;
 	w = w>>8;
 	buf[0] = w & 0xff;
 	return(buf+2);
-}	/* put_word16 */
+} /* put_word16 */
 
 
 word32 fetch_word32(byte *buf)
 /*	Fetches a 32-bit word from where byte pointer is pointing.
 	buf points to external-format byteorder array.
 */
-{	word32 w0,w1,w2,w3;
+{
+	word32 w0,w1,w2,w3;
 /* Assume MSB external byte ordering */
 	w3 = *buf++;
 	w2 = *buf++;
 	w1 = *buf++;
 	w0 = *buf++;
 	return(w0 + (w1<<8) + (w2<<16) + (w3<<24));
-}	/* fetch_word32 */
+} /* fetch_word32 */
 
 
 byte *put_word32(word32 w, byte *buf)
@@ -384,7 +401,7 @@ byte *put_word32(word32 w, byte *buf)
 	w = w>>8;
 	buf[0] = w & 0xff;
 	return(buf+4);
-}	/* put_word32 */
+} /* put_word32 */
 
 
 /***	End of functions that must be changed if the external byteorder
@@ -395,14 +412,16 @@ byte *put_word32(word32 w, byte *buf)
 
 
 short mpi2reg(register unitptr r,register byteptr buf)
-/*	Converts a multiprecision integer from the externally-represented 
-	form of a byte array with a 16-bit bitcount in a leading length 
-	word to the internally-used representation as a unit array.
-	Converts to INTERNAL byte order.
-	The same buffer address may be used for both r and buf.
-	Returns number of units in result, or returns -1 on error.
-*/
-{	byte buf2[MAX_BYTE_PRECISION];
+/*
+ * Converts a multiprecision integer from the externally-represented 
+ * form of a byte array with a 16-bit bitcount in a leading length 
+ * word to the internally-used representation as a unit array.
+ * Converts to INTERNAL byte order.
+ * The same buffer address may be used for both r and buf.
+ * Returns number of units in result, or returns -1 on error.
+ */
+{
+	byte buf2[MAX_BYTE_PRECISION];
 	word16 bitcount, bytecount, unitcount, zero_bytes, i;
 
 	/* First, extract 16-bit bitcount prefix from first 2 bytes... */
@@ -412,8 +431,8 @@ short mpi2reg(register unitptr r,registe
 	/* Convert bitcount to bytecount and unitcount... */
 	bytecount = bits2bytes(bitcount);
 	unitcount = bytes2units(bytecount);
-	if (unitcount > global_precision)
-	{	/* precision overflow during conversion. */
+	if (unitcount > global_precision) {
+		/* precision overflow during conversion. */
 		return(-1);	/* precision overflow -- error return */
 	}
 	zero_bytes = units2bytes(global_precision) - bytecount;
@@ -426,26 +445,28 @@ short mpi2reg(register unitptr r,registe
 	mp_move(r,(unitptr)buf2);
 	mp_burn((unitptr)buf2);	/* burn the evidence on the stack */
 	return(unitcount);	/* returns unitcount of reg */
-}	/* mpi2reg */
+} /* mpi2reg */
 
 
 short reg2mpi(register byteptr buf,register unitptr r)
-/*	Converts the multiprecision integer r from the internal form of 
-	a unit array to the normalized externally-represented form of a
-	byte array with a leading 16-bit bitcount word in buf[0] and buf[1].
-	This bitcount length prefix is exact count, not rounded up.
-	Converts to EXTERNAL byte order.
-	The same buffer address may be used for both r and buf.
-	Returns the number of bytes of the result, not counting length prefix.
-*/
-{	byte buf1[MAX_BYTE_PRECISION];
+/*
+ * Converts the multiprecision integer r from the internal form of 
+ * a unit array to the normalized externally-represented form of a
+ * byte array with a leading 16-bit bitcount word in buf[0] and buf[1].
+ * This bitcount length prefix is exact count, not rounded up.
+ * Converts to EXTERNAL byte order.
+ * The same buffer address may be used for both r and buf.
+ * Returns the number of bytes of the result, not counting length prefix.
+ */
+{
+	byte buf1[MAX_BYTE_PRECISION];
 	byteptr buf2;
 	short bytecount,bc;
 	word16 bitcount;
 	bitcount = countbits(r);
 #ifdef DEBUG
-	if (bitcount > MAX_BIT_PRECISION)
-	{	fprintf(stderr, "reg2mpi: bitcount out of range (%d)\n", bitcount);
+	if (bitcount > MAX_BIT_PRECISION) {
+		fprintf(stderr, "reg2mpi: bitcount out of range (%d)\n", bitcount);
 		return 0;
 	}
 #endif
@@ -462,16 +483,17 @@ short reg2mpi(register byteptr buf,regis
 
 	mp_burn((unitptr)buf1);	/* burn the evidence on the stack */
 	return(bc);		/* returns bytecount of mpi, not counting prefix */
-}	/* reg2mpi */
+} /* reg2mpi */
 
 
 #ifdef DEBUG
 
 void dumpbuf(string s, byteptr buf, int bytecount)
-	/* Dump buffer in hex, with string label prefix. */
-{	putstr(s);
-	while (bytecount--)
-	{	puthexbyte(*buf++);
+/* Dump buffer in hex, with string label prefix. */
+{
+	putstr(s);
+	while (bytecount--) {
+		puthexbyte(*buf++);
 		putchar(' ');
 		if ((bytecount & 0x0f)==0)
 			putchar('\n');
@@ -479,15 +501,17 @@ void dumpbuf(string s, byteptr buf, int
 } /* dumpbuf */
 
 void dump_unit_array(string s, unitptr r)
-/*	Dump unit array r as a C array initializer, with string label prefix. 
-	Array is dumped in native unit order.
-*/
-{	int unitcount;
+/*
+ * Dump unit array r as a C array initializer, with string label prefix. 
+ * Array is dumped in native unit order.
+ */
+{
+	int unitcount;
 	unitcount = global_precision;
 	putstr(s);
 	putstr("\n{ ");
-	while (unitcount--)
-	{	putstr("0x");
+	while (unitcount--) {
+		putstr("0x");
 		puthexunit(*r++);
 		putchar(',');
 		if (unitcount && ((unitcount & 0x07)==0))