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/src/lib/libssl/d1_srtp.c b/src/lib/libssl/d1_srtp.c
index ab9c41922c..fadd9f381f 100644
--- a/src/lib/libssl/d1_srtp.c
+++ b/src/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