First pass at applying KNF to the OpenSSL code, which almost makes it

readable. This pass is whitespace only and can readily be verified using
tr and md5.

1 files changed, 237 insertions, 260 deletions

diff --git a/lib/libssl/d1_srtp.c b/lib/libssl/d1_srtp.c
index ab9c41922c4..fadd9f381f6 100644
--- a/lib/libssl/d1_srtp.c
+++ b/lib/libssl/d1_srtp.c
@@ -124,371 +124,348 @@
 #include "srtp.h"
 
 
-static SRTP_PROTECTION_PROFILE srtp_known_profiles[]=
-    {
-    {
-    "SRTP_AES128_CM_SHA1_80",
-    SRTP_AES128_CM_SHA1_80,
-    },
-    {
-    "SRTP_AES128_CM_SHA1_32",
-    SRTP_AES128_CM_SHA1_32,
-    },
+static SRTP_PROTECTION_PROFILE srtp_known_profiles[]= {
+	{
+		"SRTP_AES128_CM_SHA1_80",
+		SRTP_AES128_CM_SHA1_80,
+	},
+	{
+		"SRTP_AES128_CM_SHA1_32",
+		SRTP_AES128_CM_SHA1_32,
+	},
 #if 0
-    {
-    "SRTP_NULL_SHA1_80",
-    SRTP_NULL_SHA1_80,
-    },
-    {
-    "SRTP_NULL_SHA1_32",
-    SRTP_NULL_SHA1_32,
-    },
+	{
+		"SRTP_NULL_SHA1_80",
+		SRTP_NULL_SHA1_80,
+	},
+	{
+		"SRTP_NULL_SHA1_32",
+		SRTP_NULL_SHA1_32,
+	},
 #endif
-    {0}
-    };
+	{0}
+};
 
-static int find_profile_by_name(char *profile_name,
-				SRTP_PROTECTION_PROFILE **pptr,unsigned len)
-	{
+static int
+find_profile_by_name(char *profile_name, SRTP_PROTECTION_PROFILE **pptr,
+    unsigned len)
+{
 	SRTP_PROTECTION_PROFILE *p;
 
-	p=srtp_known_profiles;
-	while(p->name)
-		{
-		if((len == strlen(p->name)) && !strncmp(p->name,profile_name,
-							len))
-			{
-			*pptr=p;
+	p = srtp_known_profiles;
+	while (p->name) {
+		if ((len == strlen(p->name)) &&
+		    !strncmp(p->name, profile_name, len)) {
+			*pptr = p;
 			return 0;
-			}
+		}
 
 		p++;
-		}
+	}
 
 	return 1;
-	}
+}
 
-static int find_profile_by_num(unsigned profile_num,
-			       SRTP_PROTECTION_PROFILE **pptr)
-	{
+static int
+find_profile_by_num(unsigned profile_num, SRTP_PROTECTION_PROFILE **pptr)
+{
 	SRTP_PROTECTION_PROFILE *p;
 
-	p=srtp_known_profiles;
-	while(p->name)
-		{
-		if(p->id == profile_num)
-			{
-			*pptr=p;
+	p = srtp_known_profiles;
+	while (p->name) {
+		if (p->id == profile_num) {
+			*pptr = p;
 			return 0;
-			}
-		p++;
 		}
+		p++;
+	}
 
 	return 1;
-	}
+}
 
-static int ssl_ctx_make_profiles(const char *profiles_string,STACK_OF(SRTP_PROTECTION_PROFILE) **out)
-	{
+static int
+ssl_ctx_make_profiles(const char *profiles_string,
+    STACK_OF(SRTP_PROTECTION_PROFILE) **out)
+{
 	STACK_OF(SRTP_PROTECTION_PROFILE) *profiles;
 
 	char *col;
-	char *ptr=(char *)profiles_string;
-    
+	char *ptr = (char *)profiles_string;
+
 	SRTP_PROTECTION_PROFILE *p;
 
-	if(!(profiles=sk_SRTP_PROTECTION_PROFILE_new_null()))
-		{
+	if (!(profiles = sk_SRTP_PROTECTION_PROFILE_new_null())) {
 		SSLerr(SSL_F_SSL_CTX_MAKE_PROFILES, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES);
 		return 1;
-		}
-    
-	do
-		{
-		col=strchr(ptr,':');
-
-		if(!find_profile_by_name(ptr,&p,
-					 col ? col-ptr : (int)strlen(ptr)))
-			{
-			sk_SRTP_PROTECTION_PROFILE_push(profiles,p);
-			}
-		else
-			{
-			SSLerr(SSL_F_SSL_CTX_MAKE_PROFILES,SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE);
-			return 1;
-			}
+	}
 
-		if(col) ptr=col+1;
-		} while (col);
+	do {
+		col = strchr(ptr, ':');
 
-	*out=profiles;
-    
-	return 0;
-	}
-    
-int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx,const char *profiles)
-	{
-	return ssl_ctx_make_profiles(profiles,&ctx->srtp_profiles);
-	}
+		if (!find_profile_by_name(ptr, &p,
+		    col ? col - ptr : (int)strlen(ptr))) {
+			sk_SRTP_PROTECTION_PROFILE_push(profiles, p);
+		} else {
+			SSLerr(SSL_F_SSL_CTX_MAKE_PROFILES, SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE);
+			return 1;
+		}
 
-int SSL_set_tlsext_use_srtp(SSL *s,const char *profiles)
-	{
-	return ssl_ctx_make_profiles(profiles,&s->srtp_profiles);
-	}
+		if (col)
+			ptr = col + 1;
+		} while (col);
 
+	*out = profiles;
 
-STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *s)
-	{
-	if(s != NULL)
-		{
-		if(s->srtp_profiles != NULL)
-			{
+	return 0;
+}
+
+int
+SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles)
+{
+	return ssl_ctx_make_profiles(profiles, &ctx->srtp_profiles);
+}
+
+int
+SSL_set_tlsext_use_srtp(SSL *s, const char *profiles)
+{
+	return ssl_ctx_make_profiles(profiles, &s->srtp_profiles);
+}
+
+
+STACK_OF(SRTP_PROTECTION_PROFILE)
+*SSL_get_srtp_profiles(SSL *s)
+{
+	if (s != NULL) {
+		if (s->srtp_profiles != NULL) {
 			return s->srtp_profiles;
-			}
-		else if((s->ctx != NULL) &&
-			(s->ctx->srtp_profiles != NULL))
-			{
+		} else if ((s->ctx != NULL) &&
+		    (s->ctx->srtp_profiles != NULL)) {
 			return s->ctx->srtp_profiles;
-			}
 		}
+	}
 
 	return NULL;
-	}
+}
 
-SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s)
-	{
+SRTP_PROTECTION_PROFILE
+*SSL_get_selected_srtp_profile(SSL *s)
+{
 	return s->srtp_profile;
-	}
+}
 
 /* Note: this function returns 0 length if there are no 
    profiles specified */
-int ssl_add_clienthello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen)
-	{
-	int ct=0;
+int
+ssl_add_clienthello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen)
+{
+	int ct = 0;
 	int i;
-	STACK_OF(SRTP_PROTECTION_PROFILE) *clnt=0;
+	STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = 0;
 	SRTP_PROTECTION_PROFILE *prof;
-    
-	clnt=SSL_get_srtp_profiles(s);    
-	ct=sk_SRTP_PROTECTION_PROFILE_num(clnt); /* -1 if clnt == 0 */
-
-	if(p)
-		{
-		if(ct==0)
-			{
-			SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT,SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST);
-			return 1;
-			}
 
-		if((2 + ct*2 + 1) > maxlen)
-			{
-			SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT,SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG);
+	clnt = SSL_get_srtp_profiles(s);
+
+	ct = sk_SRTP_PROTECTION_PROFILE_num(clnt); /* -1 if clnt == 0 */
+
+	if (p) {
+		if (ct == 0) {
+			SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT, SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST);
 			return 1;
-			}
+		}
 
-                /* Add the length */
-                s2n(ct * 2, p);
-		for(i=0;i<ct;i++)
-			{
-			prof=sk_SRTP_PROTECTION_PROFILE_value(clnt,i);
-			s2n(prof->id,p);
-			}
+		if ((2 + ct * 2 + 1) > maxlen) {
+			SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT, SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG);
+			return 1;
+		}
 
-                /* Add an empty use_mki value */
-                *p++ = 0;
+		/* Add the length */
+		s2n(ct * 2, p);
+		for (i = 0; i < ct; i++) {
+			prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
+			s2n(prof->id, p);
 		}
 
-	*len=2 + ct*2 + 1;
-    
-	return 0;
+		/* Add an empty use_mki value */
+		*p++ = 0;
 	}
 
+	*len = 2 + ct*2 + 1;
 
-int ssl_parse_clienthello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al)
-	{
-	SRTP_PROTECTION_PROFILE *cprof,*sprof;
-	STACK_OF(SRTP_PROTECTION_PROFILE) *clnt=0,*srvr;
-        int ct;
-        int mki_len;
-	int i,j;
+	return 0;
+}
+
+
+int
+ssl_parse_clienthello_use_srtp_ext(SSL *s, unsigned char *d, int len, int *al)
+{
+	SRTP_PROTECTION_PROFILE *cprof, *sprof;
+	STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = 0, *srvr;
+	int ct;
+	int mki_len;
+	int i, j;
 	int id;
 	int ret;
 
-         /* Length value + the MKI length */
-        if(len < 3)
-		{            
-		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
-		*al=SSL_AD_DECODE_ERROR;
+	/* Length value + the MKI length */
+	if (len < 3) {
+		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+		*al = SSL_AD_DECODE_ERROR;
 		return 1;
-                }
-
-        /* Pull off the length of the cipher suite list */
-        n2s(d, ct);
-        len -= 2;
-        
-        /* Check that it is even */
-	if(ct%2)
-		{
-		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
-		*al=SSL_AD_DECODE_ERROR;
+	}
+
+	/* Pull off the length of the cipher suite list */
+	n2s(d, ct);
+	len -= 2;
+
+	/* Check that it is even */
+	if (ct % 2) {
+		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+		*al = SSL_AD_DECODE_ERROR;
 		return 1;
-		}
-        
-        /* Check that lengths are consistent */
-	if(len < (ct + 1)) 
-		{
-		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
-		*al=SSL_AD_DECODE_ERROR;
+	}
+
+	/* Check that lengths are consistent */
+	if (len < (ct + 1)) {
+		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+		*al = SSL_AD_DECODE_ERROR;
 		return 1;
-		}
+	}
 
-        
-	clnt=sk_SRTP_PROTECTION_PROFILE_new_null();
 
-	while(ct)
-		{
-		n2s(d,id);
-		ct-=2;
-                len-=2;
+	clnt = sk_SRTP_PROTECTION_PROFILE_new_null();
 
-		if(!find_profile_by_num(id,&cprof))
-			{
-			sk_SRTP_PROTECTION_PROFILE_push(clnt,cprof);
-			}
-		else
-			{
+	while (ct) {
+		n2s(d, id);
+		ct -= 2;
+		len -= 2;
+
+		if (!find_profile_by_num(id, &cprof)) {
+			sk_SRTP_PROTECTION_PROFILE_push(clnt, cprof);
+		} else {
 			; /* Ignore */
-			}
 		}
+	}
 
-        /* Now extract the MKI value as a sanity check, but discard it for now */
-        mki_len = *d;
-        d++; len--;
+	/* Now extract the MKI value as a sanity check, but discard it for now */
+	mki_len = *d;
+	d++;
+	len--;
 
-        if (mki_len != len)
-		{
-		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_MKI_VALUE);
-		*al=SSL_AD_DECODE_ERROR;
+	if (mki_len != len) {
+		SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_MKI_VALUE);
+		*al = SSL_AD_DECODE_ERROR;
 		return 1;
-		}
+	}
 
-	srvr=SSL_get_srtp_profiles(s);
+	srvr = SSL_get_srtp_profiles(s);
 
 	/* Pick our most preferred profile. If no profiles have been
 	 configured then the outer loop doesn't run 
 	 (sk_SRTP_PROTECTION_PROFILE_num() = -1)
 	 and so we just return without doing anything */
-	for(i=0;i<sk_SRTP_PROTECTION_PROFILE_num(srvr);i++)
-		{
-		sprof=sk_SRTP_PROTECTION_PROFILE_value(srvr,i);
-
-		for(j=0;j<sk_SRTP_PROTECTION_PROFILE_num(clnt);j++)
-			{
-			cprof=sk_SRTP_PROTECTION_PROFILE_value(clnt,j);
-            
-			if(cprof->id==sprof->id)
-				{
-				s->srtp_profile=sprof;
-				*al=0;
-				ret=0;
+	for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(srvr); i++) {
+		sprof = sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
+
+		for (j = 0; j < sk_SRTP_PROTECTION_PROFILE_num(clnt); j++) {
+			cprof = sk_SRTP_PROTECTION_PROFILE_value(clnt, j);
+
+			if (cprof->id == sprof->id) {
+				s->srtp_profile = sprof;
+				*al = 0;
+				ret = 0;
 				goto done;
-				}
 			}
 		}
+	}
+
+	ret = 0;
 
-	ret=0;
-    
 done:
-	if(clnt) sk_SRTP_PROTECTION_PROFILE_free(clnt);
+	if (clnt)
+		sk_SRTP_PROTECTION_PROFILE_free(clnt);
 
 	return ret;
-	}
-
-int ssl_add_serverhello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen)
-	{
-	if(p)
-		{
-		if(maxlen < 5)
-			{
-			SSLerr(SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT,SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG);
+}
+
+int
+ssl_add_serverhello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen)
+{
+	if (p) {
+		if (maxlen < 5) {
+			SSLerr(SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT, SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG);
 			return 1;
-			}
+		}
 
-		if(s->srtp_profile==0)
-			{
-			SSLerr(SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT,SSL_R_USE_SRTP_NOT_NEGOTIATED);
+		if (s->srtp_profile == 0) {
+			SSLerr(SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT, SSL_R_USE_SRTP_NOT_NEGOTIATED);
 			return 1;
-			}
-                s2n(2, p);
-		s2n(s->srtp_profile->id,p);
-                *p++ = 0;
 		}
-	*len=5;
-    
-	return 0;
+		s2n(2, p);
+		s2n(s->srtp_profile->id, p);
+		*p++ = 0;
 	}
-    
+	*len = 5;
 
-int ssl_parse_serverhello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al)
-	{
+	return 0;
+}
+
+
+int
+ssl_parse_serverhello_use_srtp_ext(SSL *s, unsigned char *d, int len, int *al)
+{
 	unsigned id;
 	int i;
-        int ct;
+	int ct;
 
 	STACK_OF(SRTP_PROTECTION_PROFILE) *clnt;
 	SRTP_PROTECTION_PROFILE *prof;
 
-	if(len!=5)
-		{
-		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
-		*al=SSL_AD_DECODE_ERROR;
+	if (len != 5) {
+		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+		*al = SSL_AD_DECODE_ERROR;
 		return 1;
-		}
+	}
 
-        n2s(d, ct);
-	if(ct!=2)
-		{
-		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
-		*al=SSL_AD_DECODE_ERROR;
+	n2s(d, ct);
+	if (ct != 2) {
+		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+		*al = SSL_AD_DECODE_ERROR;
 		return 1;
-		}
+	}
 
-	n2s(d,id);
-        if (*d)  /* Must be no MKI, since we never offer one */
-		{
-		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_MKI_VALUE);
-		*al=SSL_AD_ILLEGAL_PARAMETER;
+	n2s(d, id);
+	if (*d)  /* Must be no MKI, since we never offer one */
+	{
+		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_MKI_VALUE);
+		*al = SSL_AD_ILLEGAL_PARAMETER;
 		return 1;
-		}
+	}
 
-	clnt=SSL_get_srtp_profiles(s);
+	clnt = SSL_get_srtp_profiles(s);
 
 	/* Throw an error if the server gave us an unsolicited extension */
-	if (clnt == NULL)
-		{
-		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_NO_SRTP_PROFILES);
-		*al=SSL_AD_DECODE_ERROR;
+	if (clnt == NULL) {
+		SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT, SSL_R_NO_SRTP_PROFILES);
+		*al = SSL_AD_DECODE_ERROR;
 		return 1;
-		}
-    
+	}
+
 	/* Check to see if the server gave us something we support
 	   (and presumably offered)
 	*/
-	for(i=0;i<sk_SRTP_PROTECTION_PROFILE_num(clnt);i++)
-		{
-		prof=sk_SRTP_PROTECTION_PROFILE_value(clnt,i);
-	    
-		if(prof->id == id)
-			{
-			s->srtp_profile=prof;
-			*al=0;
+	for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) {
+		prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
+
+		if (prof->id == id) {
+			s->srtp_profile = prof;
+			*al = 0;
 			return 0;
-			}
 		}
-
-	SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT,SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
-	*al=SSL_AD_DECODE_ERROR;
-	return 1;
 	}
 
+	SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+	*al = SSL_AD_DECODE_ERROR;
+	return 1;
+}
 
 #endif