Use sk_*_new_null() instead of sk_*_new(NULL), since that takes care

[openssl.git] / crypto / x509v3 / v3_genn.c

diff --git a/crypto/x509v3/v3_genn.c b/crypto/x509v3/v3_genn.c
index e7918d6b3cda16cf74dab7fe43b53a1276eb8a25..d44751458eb4f6507b1268fa6489e50f83db359d 100644 (file)
--- a/crypto/x509v3/v3_genn.c
+++ b/crypto/x509v3/v3_genn.c
@@ -59,19 +59,12 @@
 
 #include <stdio.h>
 #include "cryptlib.h"
-#include "asn1.h"
-#include "asn1_mac.h"
-#include "conf.h"
-#include "x509v3.h"
-
-/*
- * ASN1err(ASN1_F_GENERAL_NAME_NEW,ERR_R_MALLOC_FAILURE);
- * ASN1err(ASN1_F_D2I_GENERAL_NAME,ERR_R_MALLOC_FAILURE);
- */
+#include <openssl/asn1.h>
+#include <openssl/asn1_mac.h>
+#include <openssl/conf.h>
+#include <openssl/x509v3.h>
 
-int i2d_GENERAL_NAME(a,pp)
-GENERAL_NAME *a;
-unsigned char **pp;
+int i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **pp)
 {
        unsigned char *p;
        int ret;
@@ -95,12 +88,15 @@ unsigned char **pp;
 
        switch(a->type) {
 
-               case GEN_OTHERNAME:
                case GEN_X400:
                case GEN_EDIPARTY:
                ret = i2d_ASN1_TYPE(a->d.other, pp);
                break;
 
+               case GEN_OTHERNAME:
+               ret = i2d_OTHERNAME(a->d.otherName, pp);
+               break;
+
                case GEN_EMAIL:
                case GEN_DNS:
                case GEN_URI:
@@ -131,10 +127,8 @@ GENERAL_NAME *GENERAL_NAME_new()
        M_ASN1_New_Error(ASN1_F_GENERAL_NAME_NEW);
 }
 
-GENERAL_NAME *d2i_GENERAL_NAME(a,pp,length)
-GENERAL_NAME **a;
-unsigned char **pp;
-long length;
+GENERAL_NAME *d2i_GENERAL_NAME(GENERAL_NAME **a, unsigned char **pp,
+                                                                long length)
 {
        unsigned char _tmp;
        M_ASN1_D2I_vars(a,GENERAL_NAME *,GENERAL_NAME_new);
@@ -146,12 +140,15 @@ long length;
 
        switch(ret->type) {
                /* Just put these in a "blob" for now */
-               case GEN_OTHERNAME:
                case GEN_X400:
                case GEN_EDIPARTY:
                M_ASN1_D2I_get_imp(ret->d.other, d2i_ASN1_TYPE,V_ASN1_SEQUENCE);
                break;
 
+               case GEN_OTHERNAME:
+               M_ASN1_D2I_get_imp(ret->d.otherName, d2i_OTHERNAME,V_ASN1_SEQUENCE);
+               break;
+
                case GEN_EMAIL:
                case GEN_DNS:
                case GEN_URI:
@@ -181,22 +178,24 @@ long length;
        M_ASN1_D2I_Finish(a, GENERAL_NAME_free, ASN1_F_D2I_GENERAL_NAME);
 }
 
-void GENERAL_NAME_free(a)
-GENERAL_NAME *a;
+void GENERAL_NAME_free(GENERAL_NAME *a)
 {
        if (a == NULL) return;
        switch(a->type) {
-               case GEN_OTHERNAME:
                case GEN_X400:
                case GEN_EDIPARTY:
                ASN1_TYPE_free(a->d.other);
                break;
 
+               case GEN_OTHERNAME:
+               OTHERNAME_free(a->d.otherName);
+               break;
+
                case GEN_EMAIL:
                case GEN_DNS:
                case GEN_URI:
 
-               ASN1_IA5STRING_free(a->d.ia5);
+               M_ASN1_IA5STRING_free(a->d.ia5);
                break;
 
                case GEN_DIRNAME:
@@ -204,7 +203,7 @@ GENERAL_NAME *a;
                break;
 
                case GEN_IPADD:
-               ASN1_OCTET_STRING_free(a->d.ip);
+               M_ASN1_OCTET_STRING_free(a->d.ip);
                break;
        
                case GEN_RID:
@@ -212,37 +211,81 @@ GENERAL_NAME *a;
                break;
 
        }
-       Free ((char *)a);
+       OPENSSL_free (a);
 }
 
-/* Now the GeneralNames versions: a SEQUENCE OF GeneralName These are needed as
- * an explicit functions.
+/* Now the GeneralNames versions: a SEQUENCE OF GeneralName. These are needed as
+ * explicit functions.
  */
 
-STACK *GENERAL_NAMES_new()
+STACK_OF(GENERAL_NAME) *GENERAL_NAMES_new()
 {
-       return sk_new(NULL);
+       return sk_GENERAL_NAME_new_null();
 }
 
-void GENERAL_NAMES_free(a)
-STACK *a;
+void GENERAL_NAMES_free(STACK_OF(GENERAL_NAME) *a)
 {
-       sk_pop_free(a, GENERAL_NAME_free);
+       sk_GENERAL_NAME_pop_free(a, GENERAL_NAME_free);
 }
 
-STACK *d2i_GENERAL_NAMES(a,pp,length)
-STACK **a;
-unsigned char **pp;
-long length;
+STACK_OF(GENERAL_NAME) *d2i_GENERAL_NAMES(STACK_OF(GENERAL_NAME) **a,
+                                        unsigned char **pp, long length)
 {
-return d2i_ASN1_SET(a, pp, length, (char *(*)())d2i_GENERAL_NAME,
+return d2i_ASN1_SET_OF_GENERAL_NAME(a, pp, length, d2i_GENERAL_NAME,
                         GENERAL_NAME_free, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);
 }
 
-int i2d_GENERAL_NAMES(a,pp)
-STACK *a;
-unsigned char **pp;
+int i2d_GENERAL_NAMES(STACK_OF(GENERAL_NAME) *a, unsigned char **pp)
 {
-return i2d_ASN1_SET(a, pp, i2d_GENERAL_NAME, V_ASN1_SEQUENCE,
+return i2d_ASN1_SET_OF_GENERAL_NAME(a, pp, i2d_GENERAL_NAME, V_ASN1_SEQUENCE,
                                                 V_ASN1_UNIVERSAL, IS_SEQUENCE);
 }
+
+IMPLEMENT_STACK_OF(GENERAL_NAME)
+IMPLEMENT_ASN1_SET_OF(GENERAL_NAME)
+
+int i2d_OTHERNAME(OTHERNAME *a, unsigned char **pp)
+{
+       int v = 0;
+       M_ASN1_I2D_vars(a);
+
+       M_ASN1_I2D_len(a->type_id, i2d_ASN1_OBJECT);
+       M_ASN1_I2D_len_EXP_opt(a->value, i2d_ASN1_TYPE, 0, v);
+
+       M_ASN1_I2D_seq_total();
+
+       M_ASN1_I2D_put(a->type_id, i2d_ASN1_OBJECT);
+       M_ASN1_I2D_put_EXP_opt(a->value, i2d_ASN1_TYPE, 0, v);
+
+       M_ASN1_I2D_finish();
+}
+
+OTHERNAME *OTHERNAME_new(void)
+{
+       OTHERNAME *ret=NULL;
+       ASN1_CTX c;
+       M_ASN1_New_Malloc(ret, OTHERNAME);
+       ret->type_id = OBJ_nid2obj(NID_undef);
+       M_ASN1_New(ret->value, ASN1_TYPE_new);
+       return (ret);
+       M_ASN1_New_Error(ASN1_F_OTHERNAME_NEW);
+}
+
+OTHERNAME *d2i_OTHERNAME(OTHERNAME **a, unsigned char **pp, long length)
+{
+       M_ASN1_D2I_vars(a,OTHERNAME *,OTHERNAME_new);
+       M_ASN1_D2I_Init();
+       M_ASN1_D2I_start_sequence();
+       M_ASN1_D2I_get(ret->type_id, d2i_ASN1_OBJECT);
+       M_ASN1_D2I_get_EXP_opt(ret->value, d2i_ASN1_TYPE, 0);
+       M_ASN1_D2I_Finish(a, OTHERNAME_free, ASN1_F_D2I_OTHERNAME);
+}
+
+void OTHERNAME_free(OTHERNAME *a)
+{
+       if (a == NULL) return;
+       ASN1_OBJECT_free(a->type_id);
+       ASN1_TYPE_free(a->value);
+       OPENSSL_free (a);
+}
+