Fix strange formatting by indent

Reviewed-by: Tim Hudson <tjh@openssl.org>
2024-12-15 21:13:38 +08:00 · 2015-01-21 12:19:08 +00:00 · 2015-01-21 12:19:08 +00:00 · b853717fc4
commit b853717fc4
parent 1e8f69c6a5
19 changed files with 168 additions and 93 deletions
--- a/crypto/asn1/asn1_par.c
+++ b/crypto/asn1/asn1_par.c
@ -415,14 +415,22 @@ end:
 const char *ASN1_tag2str(int tag)
 {
 	static const char * const tag2str[] = {
-	 "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING", /* 0-4 */
-	 "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL", /* 5-9 */
-	 "ENUMERATED", "<ASN1 11>", "UTF8STRING", "<ASN1 13>", 	    /* 10-13 */
-	"<ASN1 14>", "<ASN1 15>", "SEQUENCE", "SET", 		    /* 15-17 */
-	"NUMERICSTRING", "PRINTABLESTRING", "T61STRING",	    /* 18-20 */
-	"VIDEOTEXSTRING", "IA5STRING", "UTCTIME","GENERALIZEDTIME", /* 21-24 */
-	"GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING",	    /* 25-27 */
-	"UNIVERSALSTRING", "<ASN1 29>", "BMPSTRING"		    /* 28-30 */
+        /* 0-4 */
+	 "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING",
+        /* 5-9 */ 
+	 "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL",
+        /* 10-13 */
+	 "ENUMERATED", "<ASN1 11>", "UTF8STRING", "<ASN1 13>",
+        /* 15-17 */ 
+	"<ASN1 14>", "<ASN1 15>", "SEQUENCE", "SET",
+        /* 18-20 */  
+	"NUMERICSTRING", "PRINTABLESTRING", "T61STRING",
+        /* 21-24 */
+	"VIDEOTEXSTRING", "IA5STRING", "UTCTIME","GENERALIZEDTIME",
+        /* 25-27 */
+	"GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING",
+        /* 28-30 */
+	"UNIVERSALSTRING", "<ASN1 29>", "BMPSTRING"
 	};

 	if((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED))
--- a/crypto/asn1/d2i_pu.c
+++ b/crypto/asn1/d2i_pu.c
@ -97,8 +97,9 @@ EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
 		{
 #ifndef OPENSSL_NO_RSA
 	case EVP_PKEY_RSA:
+		/* TMP UGLY CAST */
 		if ((ret->pkey.rsa=d2i_RSAPublicKey(NULL,
-			(const unsigned char **)pp,length)) == NULL) /* TMP UGLY CAST */
+			(const unsigned char **)pp,length)) == NULL)
 			{
 			ASN1err(ASN1_F_D2I_PUBLICKEY,ERR_R_ASN1_LIB);
 			goto err;
@ -107,8 +108,9 @@ EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
 #endif
 #ifndef OPENSSL_NO_DSA
 	case EVP_PKEY_DSA:
+		/* TMP UGLY CAST */
 		if (!d2i_DSAPublicKey(&(ret->pkey.dsa),
-			(const unsigned char **)pp,length)) /* TMP UGLY CAST */
+			(const unsigned char **)pp,length))
 			{
 			ASN1err(ASN1_F_D2I_PUBLICKEY,ERR_R_ASN1_LIB);
 			goto err;
--- a/crypto/asn1/t_x509.c
+++ b/crypto/asn1/t_x509.c
@ -417,7 +417,8 @@ int ASN1_GENERALIZEDTIME_print(BIO *bp, const ASN1_GENERALIZEDTIME *tm)
 	if (v[i-1] == 'Z') gmt=1;
 	for (i=0; i<12; i++)
 		if ((v[i] > '9') || (v[i] < '0')) goto err;
-	y= (v[0]-'0')*1000+(v[1]-'0')*100 + (v[2]-'0')*10+(v[3]-'0');
+	y= (v[0]-'0')*1000+(v[1]-'0')*100
+		+ (v[2]-'0')*10+(v[3]-'0');
 	M= (v[4]-'0')*10+(v[5]-'0');
 	if ((M > 12) || (M < 1)) goto err;
 	d= (v[6]-'0')*10+(v[7]-'0');
--- a/crypto/asn1/tasn_dec.c
+++ b/crypto/asn1/tasn_dec.c
@ -94,15 +94,24 @@ static int asn1_d2i_ex_primitive(ASN1_VALUE **pval,

 /* Table to convert tags to bit values, used for MSTRING type */
 static const unsigned long tag2bit[32] = {
-0,	0,	0,	B_ASN1_BIT_STRING,	/* tags  0 -  3 */
-B_ASN1_OCTET_STRING,	0,	0,		B_ASN1_UNKNOWN,/* tags  4- 7 */
-B_ASN1_UNKNOWN,	B_ASN1_UNKNOWN,	B_ASN1_UNKNOWN,	B_ASN1_UNKNOWN,/* tags  8-11 */
-B_ASN1_UTF8STRING,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,/* tags 12-15 */
-B_ASN1_SEQUENCE,0,B_ASN1_NUMERICSTRING,B_ASN1_PRINTABLESTRING, /* tags 16-19 */
-B_ASN1_T61STRING,B_ASN1_VIDEOTEXSTRING,B_ASN1_IA5STRING,       /* tags 20-22 */
-B_ASN1_UTCTIME, B_ASN1_GENERALIZEDTIME,			       /* tags 23-24 */	
-B_ASN1_GRAPHICSTRING,B_ASN1_ISO64STRING,B_ASN1_GENERALSTRING,  /* tags 25-27 */
-B_ASN1_UNIVERSALSTRING,B_ASN1_UNKNOWN,B_ASN1_BMPSTRING,B_ASN1_UNKNOWN, /* tags 28-31 */
+    /* tags  0 -  3 */
+0,	0,	0,	B_ASN1_BIT_STRING,	
+    /* tags  4- 7 */
+B_ASN1_OCTET_STRING,	0,	0,		B_ASN1_UNKNOWN,
+    /* tags  8-11 */
+B_ASN1_UNKNOWN,	B_ASN1_UNKNOWN,	B_ASN1_UNKNOWN,	B_ASN1_UNKNOWN,
+    /* tags 12-15 */
+B_ASN1_UTF8STRING,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,
+    /* tags 16-19 */
+B_ASN1_SEQUENCE,0,B_ASN1_NUMERICSTRING,B_ASN1_PRINTABLESTRING,
+    /* tags 20-22 */
+B_ASN1_T61STRING,B_ASN1_VIDEOTEXSTRING,B_ASN1_IA5STRING,
+    /* tags 23-24 */
+B_ASN1_UTCTIME, B_ASN1_GENERALIZEDTIME,
+    /* tags 25-27 */
+B_ASN1_GRAPHICSTRING,B_ASN1_ISO64STRING,B_ASN1_GENERALSTRING,  
+    /* tags 28-31 */
+B_ASN1_UNIVERSALSTRING,B_ASN1_UNKNOWN,B_ASN1_BMPSTRING,B_ASN1_UNKNOWN,
 	};

 unsigned long ASN1_tag2bit(int tag)
--- a/crypto/des/set_key.c
+++ b/crypto/des/set_key.c
@ -183,7 +183,8 @@ static const DES_LONG des_skb[8][64]={
 	0x00090020L,0x00090030L,0x20090020L,0x20090030L,
 	0x00080820L,0x00080830L,0x20080820L,0x20080830L,
 	0x00090820L,0x00090830L,0x20090820L,0x20090830L,
-	},{
+	},
+	{
 	/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
 	0x00000000L,0x02000000L,0x00002000L,0x02002000L,
 	0x00200000L,0x02200000L,0x00202000L,0x02202000L,
@ -201,7 +202,8 @@ static const DES_LONG des_skb[8][64]={
 	0x10200400L,0x12200400L,0x10202400L,0x12202400L,
 	0x10000404L,0x12000404L,0x10002404L,0x12002404L,
 	0x10200404L,0x12200404L,0x10202404L,0x12202404L,
-	},{
+	},
+	{
 	/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
 	0x00000000L,0x00000001L,0x00040000L,0x00040001L,
 	0x01000000L,0x01000001L,0x01040000L,0x01040001L,
@ -219,7 +221,8 @@ static const DES_LONG des_skb[8][64]={
 	0x09000200L,0x09000201L,0x09040200L,0x09040201L,
 	0x08000202L,0x08000203L,0x08040202L,0x08040203L,
 	0x09000202L,0x09000203L,0x09040202L,0x09040203L,
-	},{
+	},
+	{
 	/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
 	0x00000000L,0x00100000L,0x00000100L,0x00100100L,
 	0x00000008L,0x00100008L,0x00000108L,0x00100108L,
@ -237,7 +240,8 @@ static const DES_LONG des_skb[8][64]={
 	0x04020008L,0x04120008L,0x04020108L,0x04120108L,
 	0x04021000L,0x04121000L,0x04021100L,0x04121100L,
 	0x04021008L,0x04121008L,0x04021108L,0x04121108L,
-	},{
+	},
+	{
 	/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
 	0x00000000L,0x10000000L,0x00010000L,0x10010000L,
 	0x00000004L,0x10000004L,0x00010004L,0x10010004L,
@ -255,7 +259,8 @@ static const DES_LONG des_skb[8][64]={
 	0x00101004L,0x10101004L,0x00111004L,0x10111004L,
 	0x20101000L,0x30101000L,0x20111000L,0x30111000L,
 	0x20101004L,0x30101004L,0x20111004L,0x30111004L,
-	},{
+	},
+	{
 	/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
 	0x00000000L,0x08000000L,0x00000008L,0x08000008L,
 	0x00000400L,0x08000400L,0x00000408L,0x08000408L,
@ -273,7 +278,8 @@ static const DES_LONG des_skb[8][64]={
 	0x02000401L,0x0A000401L,0x02000409L,0x0A000409L,
 	0x02020001L,0x0A020001L,0x02020009L,0x0A020009L,
 	0x02020401L,0x0A020401L,0x02020409L,0x0A020409L,
-	},{
+	},
+	{
 	/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
 	0x00000000L,0x00000100L,0x00080000L,0x00080100L,
 	0x01000000L,0x01000100L,0x01080000L,0x01080100L,
@ -291,7 +297,8 @@ static const DES_LONG des_skb[8][64]={
 	0x01200200L,0x01200300L,0x01280200L,0x01280300L,
 	0x00200210L,0x00200310L,0x00280210L,0x00280310L,
 	0x01200210L,0x01200310L,0x01280210L,0x01280310L,
-	},{
+	},
+	{
 	/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
 	0x00000000L,0x04000000L,0x00040000L,0x04040000L,
 	0x00000002L,0x04000002L,0x00040002L,0x04040002L,
@ -309,7 +316,8 @@ static const DES_LONG des_skb[8][64]={
 	0x00000822L,0x04000822L,0x00040822L,0x04040822L,
 	0x00002820L,0x04002820L,0x00042820L,0x04042820L,
 	0x00002822L,0x04002822L,0x00042822L,0x04042822L,
-	}};
+	}
+};

 int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule)
 	{
--- a/crypto/dsa/dsa.h
+++ b/crypto/dsa/dsa.h
@ -146,9 +146,10 @@ struct dsa_method
 	int (*dsa_mod_exp)(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1,
 			BIGNUM *a2, BIGNUM *p2, BIGNUM *m, BN_CTX *ctx,
 			BN_MONT_CTX *in_mont);
+	/* Can be null */
 	int (*bn_mod_exp)(DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p,
 				const BIGNUM *m, BN_CTX *ctx,
-				BN_MONT_CTX *m_ctx); /* Can be null */
+				BN_MONT_CTX *m_ctx);
 	int (*init)(DSA *dsa);
 	int (*finish)(DSA *dsa);
 	int flags;
--- a/crypto/ec/ec_lcl.h
+++ b/crypto/ec/ec_lcl.h
@ -174,8 +174,10 @@ struct ec_method_st {
 	int (*field_sqr)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *);
 	int (*field_div)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *);

-	int (*field_encode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); /* e.g. to Montgomery */
-	int (*field_decode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); /* e.g. from Montgomery */
+	/* e.g. to Montgomery */
+	int (*field_encode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *);
+	/* e.g. from Montgomery */
+	int (*field_decode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *);
 	int (*field_set_to_one)(const EC_GROUP *, BIGNUM *r, BN_CTX *);
 } /* EC_METHOD */;

--- a/crypto/ec/ecp_nistp224.c
+++ b/crypto/ec/ecp_nistp224.c
@ -1093,9 +1093,10 @@ static void batch_mul(felem x_out, felem y_out, felem z_out,

 			if (!skip)
 				{
+				/* value 1 below is argument for "mixed" */
 				point_add(nq[0], nq[1], nq[2],
 					nq[0], nq[1], nq[2],
-					1 /* mixed */, tmp[0], tmp[1], tmp[2]);
+					1, tmp[0], tmp[1], tmp[2]);
 				}
 			else
 				{
--- a/crypto/ec/ecp_nistp256.c
+++ b/crypto/ec/ecp_nistp256.c
@ -1392,8 +1392,8 @@ static void point_add_small(smallfelem x3, smallfelem y3, smallfelem z3,
 * Tables for other points have table[i] = iG for i in 0 .. 16. */

 /* gmul is the table of precomputed base points */
-static const smallfelem gmul[2][16][3] =
-{{{{0, 0, 0, 0},
+static const smallfelem gmul[2][16][3] = {
+ {{{0, 0, 0, 0},
   {0, 0, 0, 0},
   {0, 0, 0, 0}},
  {{0xf4a13945d898c296, 0x77037d812deb33a0, 0xf8bce6e563a440f2, 0x6b17d1f2e12c4247},
@ -1827,7 +1827,8 @@ int ec_GFp_nistp256_point_get_affine_coordinates(const EC_GROUP *group,
 	return 1;
 	}

-static void make_points_affine(size_t num, smallfelem points[/* num */][3], smallfelem tmp_smallfelems[/* num+1 */])
+/* points below is of size |num|, and tmp_smallfelems is of size |num+1| */
+static void make_points_affine(size_t num, smallfelem points[][3], smallfelem tmp_smallfelems[])
 	{
 	/* Runs in constant time, unless an input is the point at infinity
 	 * (which normally shouldn't happen). */
@ -1842,7 +1843,8 @@ static void make_points_affine(size_t num, smallfelem points[/* num */][3], smal
 		(void (*)(void *, const void *)) smallfelem_square_contract,
 		(void (*)(void *, const void *, const void *)) smallfelem_mul_contract,
 		(void (*)(void *, const void *)) smallfelem_inv_contract,
-		(void (*)(void *, const void *)) smallfelem_assign /* nothing to contract */);
+		/* nothing to contract */
+		(void (*)(void *, const void *)) smallfelem_assign);
 	}

 /* Computes scalar*generator + \sum scalars[i]*points[i], ignoring NULL values
--- a/crypto/ec/ecp_nistp521.c
+++ b/crypto/ec/ecp_nistp521.c
@ -1387,7 +1387,8 @@ static const felem gmul[16][3] =

 /* select_point selects the |idx|th point from a precomputation table and
 * copies it to out. */
-static void select_point(const limb idx, unsigned int size, const felem pre_comp[/* size */][3],
+ /* pre_comp below is of the size provided in |size| */
+static void select_point(const limb idx, unsigned int size, const felem pre_comp[][3],
 			 felem out[3])
 	{
 	unsigned i, j;
@ -1707,7 +1708,8 @@ int ec_GFp_nistp521_point_get_affine_coordinates(const EC_GROUP *group,
 	return 1;
 	}

-static void make_points_affine(size_t num, felem points[/* num */][3], felem tmp_felems[/* num+1 */])
+/* points below is of size |num|, and tmp_felems is of size |num+1/ */
+static void make_points_affine(size_t num, felem points[][3], felem tmp_felems[])
 	{
 	/* Runs in constant time, unless an input is the point at infinity
 	 * (which normally shouldn't happen). */
--- a/crypto/ec/ectest.c
+++ b/crypto/ec/ectest.c
@ -1325,43 +1325,70 @@ static const struct nistp_test_params nistp_tests_params[] =
 		/* P-224 */
 		EC_GFp_nistp224_method,
 		224,
-		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001", /* p */
-		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE", /* a */
-		"B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4", /* b */
-		"E84FB0B8E7000CB657D7973CF6B42ED78B301674276DF744AF130B3E", /* Qx */
-		"4376675C6FC5612C21A0FF2D2A89D2987DF7A2BC52183B5982298555", /* Qy */
-		"B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21", /* Gx */
-		"BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34", /* Gy */
-		"FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D", /* order */
-		"3F0C488E987C80BE0FEE521F8D90BE6034EC69AE11CA72AA777481E8", /* d */
+		/* p */
+		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001",
+		/* a */
+		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE",
+		/* b */
+		"B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4",
+		/* Qx */
+		"E84FB0B8E7000CB657D7973CF6B42ED78B301674276DF744AF130B3E",
+		/* Qy */
+		"4376675C6FC5612C21A0FF2D2A89D2987DF7A2BC52183B5982298555",
+		/* Gx */
+		"B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21",
+		/* Gy */
+		"BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34",
+		/* order */
+		"FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D",
+		/* d */
+		"3F0C488E987C80BE0FEE521F8D90BE6034EC69AE11CA72AA777481E8",
 		},
 		{
 		/* P-256 */
 		EC_GFp_nistp256_method,
 		256,
-		"ffffffff00000001000000000000000000000000ffffffffffffffffffffffff", /* p */
-		"ffffffff00000001000000000000000000000000fffffffffffffffffffffffc", /* a */
-		"5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b", /* b */
-		"b7e08afdfe94bad3f1dc8c734798ba1c62b3a0ad1e9ea2a38201cd0889bc7a19", /* Qx */
-		"3603f747959dbf7a4bb226e41928729063adc7ae43529e61b563bbc606cc5e09", /* Qy */
-		"6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296", /* Gx */
-		"4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5", /* Gy */
-		"ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551", /* order */
-		"c477f9f65c22cce20657faa5b2d1d8122336f851a508a1ed04e479c34985bf96", /* d */
+		/* p */
+		"ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
+		/* a */
+		"ffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
+		/* b */
+		"5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
+		/* Qx */
+		"b7e08afdfe94bad3f1dc8c734798ba1c62b3a0ad1e9ea2a38201cd0889bc7a19",
+		/* Qy */
+		"3603f747959dbf7a4bb226e41928729063adc7ae43529e61b563bbc606cc5e09",
+		/* Gx */
+		"6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
+		/* Gy */
+		"4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
+		/* order */
+		"ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
+		/* d */
+		"c477f9f65c22cce20657faa5b2d1d8122336f851a508a1ed04e479c34985bf96",
 		},
 		{
 		/* P-521 */
 		EC_GFp_nistp521_method,
 		521,
-		"1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", /* p */
-		"1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc", /* a */
-		"051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00", /* b */
-		"0098e91eef9a68452822309c52fab453f5f117c1da8ed796b255e9ab8f6410cca16e59df403a6bdc6ca467a37056b1e54b3005d8ac030decfeb68df18b171885d5c4", /* Qx */
-		"0164350c321aecfc1cca1ba4364c9b15656150b4b78d6a48d7d28e7f31985ef17be8554376b72900712c4b83ad668327231526e313f5f092999a4632fd50d946bc2e", /* Qy */
-		"c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66", /* Gx */
-		"11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650", /* Gy */
-		"1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409", /* order */
-		"0100085f47b8e1b8b11b7eb33028c0b2888e304bfc98501955b45bba1478dc184eeedf09b86a5f7c21994406072787205e69a63709fe35aa93ba333514b24f961722", /* d */
+		/* p */
+		"1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+		/* a */
+		"1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc",
+		/* b */
+		"051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00",
+		/* Qx */
+		"0098e91eef9a68452822309c52fab453f5f117c1da8ed796b255e9ab8f6410cca16e59df403a6bdc6ca467a37056b1e54b3005d8ac030decfeb68df18b171885d5c4",
+		/* Qy */
+		"0164350c321aecfc1cca1ba4364c9b15656150b4b78d6a48d7d28e7f31985ef17be8554376b72900712c4b83ad668327231526e313f5f092999a4632fd50d946bc2e",
+		/* Gx */
+		"c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66",
+		/* Gy */
+		"11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650",
+		/* order */
+		"1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409",
+		/* d */
+		"0100085f47b8e1b8b11b7eb33028c0b2888e304bfc98501955b45bba1478dc184eeedf09b86a5f7c21994406072787205e69a63709fe35aa93ba333514b24f961722",
 		},
 	};

--- a/crypto/evp/e_aes_cbc_hmac_sha256.c
+++ b/crypto/evp/e_aes_cbc_hmac_sha256.c
@ -208,10 +208,12 @@ static size_t tls1_1_multi_block_encrypt(EVP_AES_HMAC_SHA256 *key,
 	u64		seqnum;
 #endif

-	if (RAND_bytes((IVs=blocks[0].c),16*x4)<=0)	/* ask for IVs in bulk */
+	/* ask for IVs in bulk */
+	if (RAND_bytes((IVs=blocks[0].c),16*x4)<=0)
 		return 0;

-	ctx = (SHA256_MB_CTX *)(storage+32-((size_t)storage%32));	/* align */
+	/* align */
+	ctx = (SHA256_MB_CTX *)(storage+32-((size_t)storage%32));

 	frag = (unsigned int)inp_len>>(1+n4x);
 	last = (unsigned int)inp_len+frag-(frag<<(1+n4x));
--- a/crypto/evp/e_des3.c
+++ b/crypto/evp/e_des3.c
@ -208,8 +208,8 @@ static int des_ede3_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 	DES_ede3_cfb_encrypt(c,d,1,1,
 			     &data(ctx)->ks1,&data(ctx)->ks2,&data(ctx)->ks3,
 			     (DES_cblock *)ctx->iv,ctx->encrypt);
-	out[n/8]=(out[n/8]&~(0x80 >> (unsigned int)(n%8))) |
-		 ((d[0]&0x80) >> (unsigned int)(n%8));
+	out[n/8]=(out[n/8]&~(0x80 >> (unsigned int)(n%8)))
+		| ((d[0]&0x80) >> (unsigned int)(n%8));
 	}

    return 1;
--- a/crypto/hmac/hmac.h
+++ b/crypto/hmac/hmac.h
@ -88,10 +88,12 @@ typedef struct hmac_ctx_st
 void HMAC_CTX_init(HMAC_CTX *ctx);
 void HMAC_CTX_cleanup(HMAC_CTX *ctx);

-#define HMAC_cleanup(ctx) HMAC_CTX_cleanup(ctx) /* deprecated */
+/* deprecated */
+#define HMAC_cleanup(ctx) HMAC_CTX_cleanup(ctx)

+/* deprecated */
 __owur int HMAC_Init(HMAC_CTX *ctx, const void *key, int len,
-	       const EVP_MD *md); /* deprecated */
+	       const EVP_MD *md);
 /*__owur*/ int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
 		  const EVP_MD *md, ENGINE *impl);
 /*__owur*/ int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len);
--- a/crypto/rsa/rsa.h
+++ b/crypto/rsa/rsa.h
@ -97,14 +97,20 @@ struct rsa_meth_st
 	int (*rsa_priv_dec)(int flen,const unsigned char *from,
 			    unsigned char *to,
 			    RSA *rsa,int padding);
-	int (*rsa_mod_exp)(BIGNUM *r0,const BIGNUM *I,RSA *rsa,BN_CTX *ctx); /* Can be null */
+	/* Can be null */
+	int (*rsa_mod_exp)(BIGNUM *r0,const BIGNUM *I,RSA *rsa,BN_CTX *ctx);
+	/* Can be null */
 	int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 			  const BIGNUM *m, BN_CTX *ctx,
-			  BN_MONT_CTX *m_ctx); /* Can be null */
-	int (*init)(RSA *rsa);		/* called at new */
-	int (*finish)(RSA *rsa);	/* called at free */
-	int flags;			/* RSA_METHOD_FLAG_* things */
-	char *app_data;			/* may be needed! */
+			  BN_MONT_CTX *m_ctx);
+	/* called at new */
+	int (*init)(RSA *rsa);
+	/* called at free */
+	int (*finish)(RSA *rsa);
+	/* RSA_METHOD_FLAG_* things */
+	int flags;
+	/* may be needed! */
+	char *app_data;
 /* New sign and verify functions: some libraries don't allow arbitrary data
 * to be signed/verified: this allows them to be used. Note: for this to work
 * the RSA_public_decrypt() and RSA_private_encrypt() should *NOT* be used
--- a/crypto/sparcv9cap.c
+++ b/crypto/sparcv9cap.c
@ -114,7 +114,8 @@ static int walk_nodename(di_node_t node, di_node_name_t di_node_name)

 	/* This is expected to catch all UltraSPARC flavors prior T1 */
 	if (!strcmp (name,"SUNW,UltraSPARC") ||
-	    !strncmp(name,"SUNW,UltraSPARC-I",17))  /* covers II,III,IV */
+		/* covers II,III,IV */
+	    !strncmp(name,"SUNW,UltraSPARC-I",17))
 		{
 		OPENSSL_sparcv9cap_P[0] |= SPARCV9_PREFER_FPU|SPARCV9_VIS1;

--- a/engines/ccgost/gost94_keyx.c
+++ b/engines/ccgost/gost94_keyx.c
@ -4,8 +4,8 @@
 *         This file is distributed under the same license as OpenSSL *
 *                                                                    *
 *     Implements generation and parsing of GOST_KEY_TRANSPORT for    *
- *     			GOST R 34.10-94 algorithms                            *
- *																	  *
+ *              GOST R 34.10-94 algorithms                            *
+ *                                                                    *
 *          Requires OpenSSL 0.9.9 for compilation                    *
 **********************************************************************/
 #include <string.h>
--- a/engines/e_sureware.c
+++ b/engines/e_sureware.c
@ -37,18 +37,18 @@
 *
 * Copyright@2001 Baltimore Technologies Ltd.
 * All right Reserved.
-*																								*	
-*		THIS FILE IS PROVIDED BY BALTIMORE TECHNOLOGIES ``AS IS'' AND																			*
-*		ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE					* 
-*		IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE				*
-*		ARE DISCLAIMED.  IN NO EVENT SHALL BALTIMORE TECHNOLOGIES BE LIABLE						*
-*		FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL				*
-*		DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS					*
-*		OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)					*
-*		HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT				*
-*		LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY				*
-*		OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF					*
-*		SUCH DAMAGE.																			*
+*                                                                                      *
+*        THIS FILE IS PROVIDED BY BALTIMORE TECHNOLOGIES ``AS IS'' AND                 *
+*        ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE         *
+*        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    *
+*        ARE DISCLAIMED.  IN NO EVENT SHALL BALTIMORE TECHNOLOGIES BE LIABLE           *
+*        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL    *
+*        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS       *
+*        OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)         *
+*        HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT    *
+*        LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY     *
+*        OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF        *
+*        SUCH DAMAGE.                                                                  *
 ====================================================================*/

 #include <stdio.h>
--- a/ssl/t1_enc.c
+++ b/ssl/t1_enc.c
@ -1107,7 +1107,8 @@ int tls1_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
 		co = s->s3->client_opaque_prf_input;
 		col = s->s3->server_opaque_prf_input_len;
 		so = s->s3->server_opaque_prf_input;
-		sol = s->s3->client_opaque_prf_input_len; /* must be same as col (see draft-rescorla-tls-opaque-prf-input-00.txt, section 3.1) */
+		/* must be same as col (see draft-rescorla-tls-opaque-prf-input-00.txt, section 3.1) */
+		sol = s->s3->client_opaque_prf_input_len;
 		}
 #endif