1 files changed, 163 insertions, 114 deletions

diff --git a/src/lib/libcrypto/x509/x509_att.c b/src/lib/libcrypto/x509/x509_att.c
index 7f924fbe39..5699568998 100644
--- a/src/lib/libcrypto/x509/x509_att.c
+++ b/src/lib/libcrypto/x509/x509_att.c
@@ -5,21 +5,21 @@
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
- * 
+ *
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
  * apply to all code found in this distribution, be it the RC4, RSA,
  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  * included with this distribution is covered by the same copyright terms
  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
+ *
  * Copyright remains Eric Young's, and as such any Copyright notices in
  * the code are not to be removed.
  * If this package is used in a product, Eric Young should be given attribution
  * as the author of the parts of the library used.
  * This can be in the form of a textual message at program startup or
  * in documentation (online or textual) provided with the package.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -34,10 +34,10 @@
  *     Eric Young (eay@cryptsoft.com)"
  *    The word 'cryptographic' can be left out if the rouines from the library
  *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
+ * 4. If you include any Windows specific code (or a derivative thereof) from
  *    the apps directory (application code) you must include an acknowledgement:
  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -49,7 +49,7 @@
  * 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.
- * 
+ *
  * The licence and distribution terms for any publically available version or
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
@@ -65,134 +65,152 @@
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 
-int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
+int
+X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
 {
         return sk_X509_ATTRIBUTE_num(x);
 }
 
-int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
-                          int lastpos)
+int
+X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
+    int lastpos)
 {
         ASN1_OBJECT *obj;
 
-        obj=OBJ_nid2obj(nid);
-        if (obj == NULL) return(-2);
-        return(X509at_get_attr_by_OBJ(x,obj,lastpos));
+        obj = OBJ_nid2obj(nid);
+        if (obj == NULL)
+                return (-2);
+        return (X509at_get_attr_by_OBJ(x, obj, lastpos));
 }
 
-int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, ASN1_OBJECT *obj,
-                          int lastpos)
+int
+X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, ASN1_OBJECT *obj,
+    int lastpos)
 {
         int n;
         X509_ATTRIBUTE *ex;
 
-        if (sk == NULL) return(-1);
+        if (sk == NULL)
+                return (-1);
         lastpos++;
         if (lastpos < 0)
-                lastpos=0;
-        n=sk_X509_ATTRIBUTE_num(sk);
-        for ( ; lastpos < n; lastpos++) {
-                ex=sk_X509_ATTRIBUTE_value(sk,lastpos);
-                if (OBJ_cmp(ex->object,obj) == 0)
-                        return(lastpos);
-                }
-        return(-1);
+                lastpos = 0;
+        n = sk_X509_ATTRIBUTE_num(sk);
+        for (; lastpos < n; lastpos++) {
+                ex = sk_X509_ATTRIBUTE_value(sk, lastpos);
+                if (OBJ_cmp(ex->object, obj) == 0)
+                        return (lastpos);
+        }
+        return (-1);
 }
 
-X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
+X509_ATTRIBUTE *
+X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
 {
         if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
                 return NULL;
         else
-                return sk_X509_ATTRIBUTE_value(x,loc);
+                return sk_X509_ATTRIBUTE_value(x, loc);
 }
 
-X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
+X509_ATTRIBUTE *
+X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
 {
         X509_ATTRIBUTE *ret;
 
         if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
-                return(NULL);
-        ret=sk_X509_ATTRIBUTE_delete(x,loc);
-        return(ret);
+                return (NULL);
+        ret = sk_X509_ATTRIBUTE_delete(x, loc);
+        return (ret);
 }
 
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
-                                         X509_ATTRIBUTE *attr)
+STACK_OF(X509_ATTRIBUTE) *
+X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr)
 {
-        X509_ATTRIBUTE *new_attr=NULL;
-        STACK_OF(X509_ATTRIBUTE) *sk=NULL;
+        X509_ATTRIBUTE *new_attr = NULL;
+        STACK_OF(X509_ATTRIBUTE) *sk = NULL;
 
         if (x == NULL) {
                 X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER);
                 goto err2;
-        } 
+        }
 
         if (*x == NULL) {
-                if ((sk=sk_X509_ATTRIBUTE_new_null()) == NULL)
+                if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
                         goto err;
         } else
                 sk= *x;
 
-        if ((new_attr=X509_ATTRIBUTE_dup(attr)) == NULL)
+        if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL)
                 goto err2;
-        if (!sk_X509_ATTRIBUTE_push(sk,new_attr))
+        if (!sk_X509_ATTRIBUTE_push(sk, new_attr))
                 goto err;
         if (*x == NULL)
-                *x=sk;
-        return(sk);
+                *x = sk;
+        return (sk);
+
 err:
-        X509err(X509_F_X509AT_ADD1_ATTR,ERR_R_MALLOC_FAILURE);
+        X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_MALLOC_FAILURE);
 err2:
-        if (new_attr != NULL) X509_ATTRIBUTE_free(new_attr);
-        if (sk != NULL) sk_X509_ATTRIBUTE_free(sk);
-        return(NULL);
+        if (new_attr != NULL)
+                X509_ATTRIBUTE_free(new_attr);
+        if (sk != NULL)
+                sk_X509_ATTRIBUTE_free(sk);
+        return (NULL);
 }
 
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x,
-                        const ASN1_OBJECT *obj, int type,
-                        const unsigned char *bytes, int len)
+STACK_OF(X509_ATTRIBUTE) *
+X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj,
+    int type, const unsigned char *bytes, int len)
 {
         X509_ATTRIBUTE *attr;
         STACK_OF(X509_ATTRIBUTE) *ret;
+
         attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
-        if(!attr) return 0;
+        if (!attr)
+                return 0;
         ret = X509at_add1_attr(x, attr);
         X509_ATTRIBUTE_free(attr);
         return ret;
 }
 
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x,
-                        int nid, int type,
-                        const unsigned char *bytes, int len)
+STACK_OF(X509_ATTRIBUTE) *
+X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type,
+    const unsigned char *bytes, int len)
 {
         X509_ATTRIBUTE *attr;
         STACK_OF(X509_ATTRIBUTE) *ret;
+
         attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
-        if(!attr) return 0;
+        if (!attr)
+                return 0;
         ret = X509at_add1_attr(x, attr);
         X509_ATTRIBUTE_free(attr);
         return ret;
 }
 
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x,
-                        const char *attrname, int type,
-                        const unsigned char *bytes, int len)
+STACK_OF(X509_ATTRIBUTE) *
+X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname,
+    int type, const unsigned char *bytes, int len)
 {
         X509_ATTRIBUTE *attr;
         STACK_OF(X509_ATTRIBUTE) *ret;
+
         attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
-        if(!attr) return 0;
+        if (!attr)
+                return 0;
         ret = X509at_add1_attr(x, attr);
         X509_ATTRIBUTE_free(attr);
         return ret;
 }
 
-void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
-                                ASN1_OBJECT *obj, int lastpos, int type)
+void *
+X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, ASN1_OBJECT *obj,
+    int lastpos, int type)
 {
         int i;
         X509_ATTRIBUTE *at;
+
         i = X509at_get_attr_by_OBJ(x, obj, lastpos);
         if (i == -1)
                 return NULL;
@@ -204,96 +222,112 @@ void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
         return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
 }
 
-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
-             int atrtype, const void *data, int len)
+X509_ATTRIBUTE *
+X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype,
+    const void *data, int len)
 {
         ASN1_OBJECT *obj;
         X509_ATTRIBUTE *ret;
 
-        obj=OBJ_nid2obj(nid);
+        obj = OBJ_nid2obj(nid);
         if (obj == NULL) {
-                X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID,X509_R_UNKNOWN_NID);
-                return(NULL);
+                X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID,
+                    X509_R_UNKNOWN_NID);
+                return (NULL);
         }
-        ret=X509_ATTRIBUTE_create_by_OBJ(attr,obj,atrtype,data,len);
-        if (ret == NULL) ASN1_OBJECT_free(obj);
-        return(ret);
+        ret = X509_ATTRIBUTE_create_by_OBJ(attr, obj, atrtype, data, len);
+        if (ret == NULL)
+                ASN1_OBJECT_free(obj);
+        return (ret);
 }
 
-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
-             const ASN1_OBJECT *obj, int atrtype, const void *data, int len)
+X509_ATTRIBUTE *
+X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj,
+    int atrtype, const void *data, int len)
 {
         X509_ATTRIBUTE *ret;
 
         if ((attr == NULL) || (*attr == NULL)) {
-                if ((ret=X509_ATTRIBUTE_new()) == NULL) {
-                        X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,ERR_R_MALLOC_FAILURE);
-                        return(NULL);
+                if ((ret = X509_ATTRIBUTE_new()) == NULL) {
+                        X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,
+                            ERR_R_MALLOC_FAILURE);
+                        return (NULL);
                 }
-        }
-        else
+        } else
                 ret= *attr;
 
-        if (!X509_ATTRIBUTE_set1_object(ret,obj))
+        if (!X509_ATTRIBUTE_set1_object(ret, obj))
                 goto err;
-        if (!X509_ATTRIBUTE_set1_data(ret,atrtype,data,len))
+        if (!X509_ATTRIBUTE_set1_data(ret, atrtype, data, len))
                 goto err;
 
-        if ((attr != NULL) && (*attr == NULL)) *attr=ret;
-        return(ret);
+        if ((attr != NULL) && (*attr == NULL))
+                *attr = ret;
+        return (ret);
+
 err:
         if ((attr == NULL) || (ret != *attr))
                 X509_ATTRIBUTE_free(ret);
-        return(NULL);
+        return (NULL);
 }
 
-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
-                const char *atrname, int type, const unsigned char *bytes, int len)
+X509_ATTRIBUTE *
+X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname,
+    int type, const unsigned char *bytes, int len)
 {
         ASN1_OBJECT *obj;
         X509_ATTRIBUTE *nattr;
 
-        obj=OBJ_txt2obj(atrname, 0);
+        obj = OBJ_txt2obj(atrname, 0);
         if (obj == NULL) {
                 X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT,
-                                                X509_R_INVALID_FIELD_NAME);
+                    X509_R_INVALID_FIELD_NAME);
                 ERR_add_error_data(2, "name=", atrname);
-                return(NULL);
+                return (NULL);
         }
-        nattr = X509_ATTRIBUTE_create_by_OBJ(attr,obj,type,bytes,len);
+        nattr = X509_ATTRIBUTE_create_by_OBJ(attr, obj, type, bytes, len);
         ASN1_OBJECT_free(obj);
         return nattr;
 }
 
-int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
+int
+X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
 {
         if ((attr == NULL) || (obj == NULL))
-                return(0);
+                return (0);
         ASN1_OBJECT_free(attr->object);
-        attr->object=OBJ_dup(obj);
-        return(1);
+        attr->object = OBJ_dup(obj);
+        return (1);
 }
 
-int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data, int len)
+int
+X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data,
+    int len)
 {
         ASN1_TYPE *ttmp;
         ASN1_STRING *stmp = NULL;
         int atype = 0;
-        if (!attr) return 0;
-        if(attrtype & MBSTRING_FLAG) {
+
+        if (!attr)
+                return 0;
+        if (attrtype & MBSTRING_FLAG) {
                 stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
-                                                OBJ_obj2nid(attr->object));
-                if(!stmp) {
-                        X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_ASN1_LIB);
+                    OBJ_obj2nid(attr->object));
+                if (!stmp) {
+                        X509err(X509_F_X509_ATTRIBUTE_SET1_DATA,
+                            ERR_R_ASN1_LIB);
                         return 0;
                 }
                 atype = stmp->type;
         } else if (len != -1){
-                if(!(stmp = ASN1_STRING_type_new(attrtype))) goto err;
-                if(!ASN1_STRING_set(stmp, data, len)) goto err;
+                if (!(stmp = ASN1_STRING_type_new(attrtype)))
+                        goto err;
+                if (!ASN1_STRING_set(stmp, data, len))
+                        goto err;
                 atype = attrtype;
         }
-        if(!(attr->value.set = sk_ASN1_TYPE_new_null())) goto err;
+        if (!(attr->value.set = sk_ASN1_TYPE_new_null()))
+                goto err;
         attr->single = 0;
         /* This is a bit naughty because the attribute should really have
          * at least one value but some types use and zero length SET and
@@ -301,49 +335,64 @@ int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *dat
          */
         if (attrtype == 0)
                 return 1;
-        if(!(ttmp = ASN1_TYPE_new())) goto err;
+        if (!(ttmp = ASN1_TYPE_new()))
+                goto err;
         if ((len == -1) && !(attrtype & MBSTRING_FLAG)) {
                 if (!ASN1_TYPE_set1(ttmp, attrtype, data))
                         goto err;
         } else
                 ASN1_TYPE_set(ttmp, atype, stmp);
-        if(!sk_ASN1_TYPE_push(attr->value.set, ttmp)) goto err;
+        if (!sk_ASN1_TYPE_push(attr->value.set, ttmp))
+                goto err;
         return 1;
-        err:
+
+err:
         X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE);
         return 0;
 }
 
-int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr)
+int
+X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr)
 {
-        if(!attr->single) return sk_ASN1_TYPE_num(attr->value.set);
-        if(attr->value.single) return 1;
+        if (!attr->single)
+                return sk_ASN1_TYPE_num(attr->value.set);
+        if (attr->value.single)
+                return 1;
         return 0;
 }
 
-ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
+ASN1_OBJECT *
+X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
 {
-        if (attr == NULL) return(NULL);
-        return(attr->object);
+        if (attr == NULL)
+                return (NULL);
+        return (attr->object);
 }
 
-void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
-                                        int atrtype, void *data)
+void *
+X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data)
 {
         ASN1_TYPE *ttmp;
+
         ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
-        if(!ttmp) return NULL;
-        if(atrtype != ASN1_TYPE_get(ttmp)){
+        if (!ttmp)
+                return NULL;
+        if (atrtype != ASN1_TYPE_get(ttmp)){
                 X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE);
                 return NULL;
         }
         return ttmp->value.ptr;
 }
 
-ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
+ASN1_TYPE *
+X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
 {
-        if (attr == NULL) return(NULL);
-        if(idx >= X509_ATTRIBUTE_count(attr)) return NULL;
-        if(!attr->single) return sk_ASN1_TYPE_value(attr->value.set, idx);
-        else return attr->value.single;
+        if (attr == NULL)
+                return (NULL);
+        if (idx >= X509_ATTRIBUTE_count(attr))
+                return NULL;
+        if (!attr->single)
+                return sk_ASN1_TYPE_value(attr->value.set, idx);
+        else
+                return attr->value.single;
 }