Cosmetic touchups.
authorTrevor <unsafe@trevp.net>
Mon, 24 Jun 2013 22:59:05 +0000 (15:59 -0700)
committerBen Laurie <ben@links.org>
Fri, 28 Jun 2013 15:01:12 +0000 (16:01 +0100)
ssl/ssl_cert.c
ssl/ssl_lib.c
ssl/ssl_rsa.c
ssl/t1_lib.c

index f86511d..81b5811 100644 (file)
@@ -350,15 +350,15 @@ CERT *ssl_cert_dup(CERT *cert)
                if (cert->pkeys[i].serverinfo != NULL)
                        {
                        /* Just copy everything. */
-                       ret->pkeys[i].serverinfo_length =
-                               cert->pkeys[i].serverinfo_length;
                        ret->pkeys[i].serverinfo =
-                               OPENSSL_malloc(ret->pkeys[i].serverinfo_length);
+                               OPENSSL_malloc(cert->pkeys[i].serverinfo_length);
                        if (ret->pkeys[i].serverinfo == NULL)
                                {
                                SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
                                return NULL;
                                }
+                       ret->pkeys[i].serverinfo_length =
+                               cert->pkeys[i].serverinfo_length;
                        memcpy(ret->pkeys[i].serverinfo,
                               cert->pkeys[i].serverinfo,
                               cert->pkeys[i].serverinfo_length);
@@ -488,6 +488,7 @@ void ssl_cert_clear_certs(CERT *c)
                        {
                        OPENSSL_free(cpk->serverinfo);
                        cpk->serverinfo = NULL;
+                       cpk->serverinfo_length = 0;
                        }
 #endif
                /* Clear all flags apart from explicit sign */
index b08e826..a48e09e 100644 (file)
@@ -1702,16 +1702,17 @@ int SSL_CTX_set_custom_cli_ext(SSL_CTX *ctx, unsigned short ext_type,
                               custom_cli_ext_first_cb_fn fn1, 
                               custom_cli_ext_second_cb_fn fn2, void* arg)
        {
-       /* Check for duplicates */
        size_t i;
        custom_cli_ext_record* record;
 
+       /* Check for duplicates */
        for (i=0; i < ctx->custom_cli_ext_records_count; i++)
                if (ext_type == ctx->custom_cli_ext_records[i].ext_type)
                        return 0;
 
        ctx->custom_cli_ext_records = OPENSSL_realloc(ctx->custom_cli_ext_records,
-                                                                                                               (ctx->custom_cli_ext_records_count+1) * sizeof(custom_cli_ext_record));
+                                                     (ctx->custom_cli_ext_records_count + 1) * 
+                                                     sizeof(custom_cli_ext_record));
        if (!ctx->custom_cli_ext_records) {
                ctx->custom_cli_ext_records_count = 0;
                return 0;
@@ -1726,19 +1727,20 @@ int SSL_CTX_set_custom_cli_ext(SSL_CTX *ctx, unsigned short ext_type,
        }
 
 int SSL_CTX_set_custom_srv_ext(SSL_CTX *ctx, unsigned short ext_type,
-                                                                                                                        custom_srv_ext_first_cb_fn fn1, 
-                                                                                                                        custom_srv_ext_second_cb_fn fn2, void* arg)
+                              custom_srv_ext_first_cb_fn fn1, 
+                              custom_srv_ext_second_cb_fn fn2, void* arg)
        {
-       /* Check for duplicates */
        size_t i;
        custom_srv_ext_record* record;
 
+       /* Check for duplicates */      
        for (i=0; i < ctx->custom_srv_ext_records_count; i++)
                if (ext_type == ctx->custom_srv_ext_records[i].ext_type)
                        return 0;
 
        ctx->custom_srv_ext_records = OPENSSL_realloc(ctx->custom_srv_ext_records,
-                                                                                                               (ctx->custom_srv_ext_records_count+1) * sizeof(custom_srv_ext_record));
+                                                     (ctx->custom_srv_ext_records_count + 1) * 
+                                                     sizeof(custom_srv_ext_record));
        if (!ctx->custom_srv_ext_records) {
                ctx->custom_srv_ext_records_count = 0;
                return 0;
index 507a3d1..77abcfc 100644 (file)
@@ -1096,7 +1096,7 @@ int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
                return 0;
                }
        ctx->cert->key->serverinfo = OPENSSL_realloc(ctx->cert->key->serverinfo,
-                                                                                               serverinfo_length);
+                                                    serverinfo_length);
        if (ctx->cert->key->serverinfo == NULL)
                {
                SSLerr(SSL_F_SSL_CTX_USE_SERVERINFO,ERR_R_MALLOC_FAILURE);
index 8bed38d..07cb096 100644 (file)
@@ -2364,19 +2364,19 @@ static int ssl_scan_clienthello_tlsext(SSL *s, unsigned char **p, unsigned char
                                record = &s->ctx->custom_srv_ext_records[i];
                                if (type == record->ext_type)
                                        {
-                                       /* Error on duplicate TLS Extensions */
                                        size_t j;
 
+                                       /* Error on duplicate TLS Extensions */
                                        for (j = 0; j < s->s3->tlsext_custom_types_count; j++)
                                                {
-                                               if (s->s3->tlsext_custom_types[j] == type)
+                                               if (type == s->s3->tlsext_custom_types[j])
                                                        {
                                                        *al = TLS1_AD_DECODE_ERROR;
                                                        return 0;
                                                        }
                                                }
 
-                                       /* Callback */
+                                       /* NULL callback still notes the extension */ 
                                        if (record->fn1 && !record->fn1(s, type, data, size, al, record->arg))
                                                return 0;
                                                
@@ -2384,7 +2384,7 @@ static int ssl_scan_clienthello_tlsext(SSL *s, unsigned char **p, unsigned char
                                        s->s3->tlsext_custom_types_count++;
                                        s->s3->tlsext_custom_types = OPENSSL_realloc(
                                                        s->s3->tlsext_custom_types,
-                                                       s->s3->tlsext_custom_types_count*2);
+                                                       s->s3->tlsext_custom_types_count * 2);
                                        if (s->s3->tlsext_custom_types == NULL)
                                                {
                                                s->s3->tlsext_custom_types = 0;
@@ -2392,7 +2392,7 @@ static int ssl_scan_clienthello_tlsext(SSL *s, unsigned char **p, unsigned char
                                                return 0;
                                                }
                                        s->s3->tlsext_custom_types[
-                                                       s->s3->tlsext_custom_types_count-1] = type;
+                                                       s->s3->tlsext_custom_types_count - 1] = type;
                                        }                                               
                                }
                        }