import openssl-0.9.7-beta1

1 files changed, 224 insertions, 135 deletions

diff --git a/src/lib/libcrypto/objects/obj_dat.c b/src/lib/libcrypto/objects/obj_dat.c
index 34866ebbd2..3ff64bb8d1 100644
--- a/src/lib/libcrypto/objects/obj_dat.c
+++ b/src/lib/libcrypto/objects/obj_dat.c
@@ -59,23 +59,29 @@
 #include <stdio.h>
 #include <ctype.h>
 #include "cryptlib.h"
-#include "lhash.h"
-#include "asn1.h"
-#include "objects.h"
+#include <openssl/lhash.h>
+#include <openssl/asn1.h>
+#include <openssl/objects.h>
 
 /* obj_dat.h is generated from objects.h by obj_dat.pl */
+#ifndef OPENSSL_NO_OBJECT
 #include "obj_dat.h"
-
-#ifndef NOPROTO
-static int sn_cmp(ASN1_OBJECT **a, ASN1_OBJECT **b);
-static int ln_cmp(ASN1_OBJECT **a, ASN1_OBJECT **b);
-static int obj_cmp(ASN1_OBJECT **a, ASN1_OBJECT **b);
 #else
-static int sn_cmp();
-static int ln_cmp();
-static int obj_cmp();
+/* You will have to load all the objects needed manually in the application */
+#define NUM_NID 0
+#define NUM_SN 0
+#define NUM_LN 0
+#define NUM_OBJ 0
+static unsigned char lvalues[1];
+static ASN1_OBJECT nid_objs[1];
+static ASN1_OBJECT *sn_objs[1];
+static ASN1_OBJECT *ln_objs[1];
+static ASN1_OBJECT *obj_objs[1];
 #endif
 
+static int sn_cmp(const void *a, const void *b);
+static int ln_cmp(const void *a, const void *b);
+static int obj_cmp(const void *a, const void *b);
 #define ADDED_DATA      0
 #define ADDED_SNAME     1
 #define ADDED_LNAME     2
@@ -90,23 +96,26 @@ typedef struct added_obj_st
 static int new_nid=NUM_NID;
 static LHASH *added=NULL;
 
-static int sn_cmp(ap,bp)
-ASN1_OBJECT **ap;
-ASN1_OBJECT **bp;
-        { return(strcmp((*ap)->sn,(*bp)->sn)); }
+static int sn_cmp(const void *a, const void *b)
+        {
+        const ASN1_OBJECT * const *ap = a, * const *bp = b;
+        return(strcmp((*ap)->sn,(*bp)->sn));
+        }
 
-static int ln_cmp(ap,bp)
-ASN1_OBJECT **ap;
-ASN1_OBJECT **bp;
-        { return(strcmp((*ap)->ln,(*bp)->ln)); }
+static int ln_cmp(const void *a, const void *b)
+        { 
+        const ASN1_OBJECT * const *ap = a, * const *bp = b;
+        return(strcmp((*ap)->ln,(*bp)->ln));
+        }
 
-static unsigned long add_hash(ca)
-ADDED_OBJ *ca;
+/* static unsigned long add_hash(ADDED_OBJ *ca) */
+static unsigned long add_hash(const void *ca_void)
         {
-        ASN1_OBJECT *a;
+        const ASN1_OBJECT *a;
         int i;
         unsigned long ret=0;
         unsigned char *p;
+        ADDED_OBJ *ca = (ADDED_OBJ *)ca_void;
 
         a=ca->obj;
         switch (ca->type)
@@ -127,18 +136,21 @@ ADDED_OBJ *ca;
                 ret=a->nid;
                 break;
         default:
-                abort();
+                /* abort(); */
+                return 0;
                 }
         ret&=0x3fffffffL;
         ret|=ca->type<<30L;
         return(ret);
         }
 
-static int add_cmp(ca,cb)
-ADDED_OBJ *ca,*cb;
+/* static int add_cmp(ADDED_OBJ *ca, ADDED_OBJ *cb) */
+static int add_cmp(const void *ca_void, const void *cb_void)
         {
         ASN1_OBJECT *a,*b;
         int i;
+        ADDED_OBJ *ca = (ADDED_OBJ *)ca_void;
+        ADDED_OBJ *cb = (ADDED_OBJ *)cb_void;
 
         i=ca->type-cb->type;
         if (i) return(i);
@@ -161,50 +173,52 @@ ADDED_OBJ *ca,*cb;
         case ADDED_NID:
                 return(a->nid-b->nid);
         default:
-                abort();
+                /* abort(); */
+                return 0;
                 }
         }
 
-static int init_added()
+static int init_added(void)
         {
         if (added != NULL) return(1);
         added=lh_new(add_hash,add_cmp);
         return(added != NULL);
         }
 
-static void cleanup1(a)
-ADDED_OBJ *a;
+static void cleanup1(ADDED_OBJ *a)
         {
         a->obj->nid=0;
         a->obj->flags|=ASN1_OBJECT_FLAG_DYNAMIC|
-                        ASN1_OBJECT_FLAG_DYNAMIC_STRINGS;
+                        ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
+                        ASN1_OBJECT_FLAG_DYNAMIC_DATA;
         }
 
-static void cleanup2(a)
-ADDED_OBJ *a;
+static void cleanup2(ADDED_OBJ *a)
         { a->obj->nid++; }
 
-static void cleanup3(a)
-ADDED_OBJ *a;
+static void cleanup3(ADDED_OBJ *a)
         {
         if (--a->obj->nid == 0)
                 ASN1_OBJECT_free(a->obj);
-        Free(a);
+        OPENSSL_free(a);
         }
 
-void OBJ_cleanup()
+static IMPLEMENT_LHASH_DOALL_FN(cleanup1, ADDED_OBJ *)
+static IMPLEMENT_LHASH_DOALL_FN(cleanup2, ADDED_OBJ *)
+static IMPLEMENT_LHASH_DOALL_FN(cleanup3, ADDED_OBJ *)
+
+void OBJ_cleanup(void)
         {
         if (added == NULL) return;
         added->down_load=0;
-        lh_doall(added,cleanup1); /* zero counters */
-        lh_doall(added,cleanup2); /* set counters */
-        lh_doall(added,cleanup3); /* free objects */
+        lh_doall(added,LHASH_DOALL_FN(cleanup1)); /* zero counters */
+        lh_doall(added,LHASH_DOALL_FN(cleanup2)); /* set counters */
+        lh_doall(added,LHASH_DOALL_FN(cleanup3)); /* free objects */
         lh_free(added);
         added=NULL;
         }
 
-int OBJ_new_nid(num)
-int num;
+int OBJ_new_nid(int num)
         {
         int i;
 
@@ -213,27 +227,22 @@ int num;
         return(i);
         }
 
-int OBJ_add_object(obj)
-ASN1_OBJECT *obj;
+int OBJ_add_object(const ASN1_OBJECT *obj)
         {
         ASN1_OBJECT *o;
-        ADDED_OBJ *ao[4],*aop;
+        ADDED_OBJ *ao[4]={NULL,NULL,NULL,NULL},*aop;
         int i;
 
         if (added == NULL)
                 if (!init_added()) return(0);
         if ((o=OBJ_dup(obj)) == NULL) goto err;
-        ao[ADDED_DATA]=NULL;
-        ao[ADDED_SNAME]=NULL;
-        ao[ADDED_LNAME]=NULL;
-        ao[ADDED_NID]=NULL;
-        ao[ADDED_NID]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+        if (!(ao[ADDED_NID]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err;
         if ((o->length != 0) && (obj->data != NULL))
-                ao[ADDED_DATA]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+                ao[ADDED_DATA]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
         if (o->sn != NULL)
-                ao[ADDED_SNAME]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+                ao[ADDED_SNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
         if (o->ln != NULL)
-                ao[ADDED_LNAME]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+                ao[ADDED_LNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
 
         for (i=ADDED_DATA; i<=ADDED_NID; i++)
                 {
@@ -241,23 +250,24 @@ ASN1_OBJECT *obj;
                         {
                         ao[i]->type=i;
                         ao[i]->obj=o;
-                        aop=(ADDED_OBJ *)lh_insert(added,(char *)ao[i]);
+                        aop=(ADDED_OBJ *)lh_insert(added,ao[i]);
                         /* memory leak, buit should not normally matter */
                         if (aop != NULL)
-                                Free(aop);
+                                OPENSSL_free(aop);
                         }
                 }
-        o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS);
+        o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
+                        ASN1_OBJECT_FLAG_DYNAMIC_DATA);
+
         return(o->nid);
 err:
         for (i=ADDED_DATA; i<=ADDED_NID; i++)
-                if (ao[i] != NULL) Free(ao[i]);
-        if (o != NULL) Free(o);
+                if (ao[i] != NULL) OPENSSL_free(ao[i]);
+        if (o != NULL) OPENSSL_free(o);
         return(NID_undef);
         }
 
-ASN1_OBJECT *OBJ_nid2obj(n)
-int n;
+ASN1_OBJECT *OBJ_nid2obj(int n)
         {
         ADDED_OBJ ad,*adp;
         ASN1_OBJECT ob;
@@ -278,7 +288,7 @@ int n;
                 ad.type=ADDED_NID;
                 ad.obj= &ob;
                 ob.nid=n;
-                adp=(ADDED_OBJ *)lh_retrieve(added,(char *)&ad);
+                adp=(ADDED_OBJ *)lh_retrieve(added,&ad);
                 if (adp != NULL)
                         return(adp->obj);
                 else
@@ -289,8 +299,7 @@ int n;
                 }
         }
 
-char *OBJ_nid2sn(n)
-int n;
+const char *OBJ_nid2sn(int n)
         {
         ADDED_OBJ ad,*adp;
         ASN1_OBJECT ob;
@@ -311,7 +320,7 @@ int n;
                 ad.type=ADDED_NID;
                 ad.obj= &ob;
                 ob.nid=n;
-                adp=(ADDED_OBJ *)lh_retrieve(added,(char *)&ad);
+                adp=(ADDED_OBJ *)lh_retrieve(added,&ad);
                 if (adp != NULL)
                         return(adp->obj->sn);
                 else
@@ -322,8 +331,7 @@ int n;
                 }
         }
 
-char *OBJ_nid2ln(n)
-int n;
+const char *OBJ_nid2ln(int n)
         {
         ADDED_OBJ ad,*adp;
         ASN1_OBJECT ob;
@@ -344,7 +352,7 @@ int n;
                 ad.type=ADDED_NID;
                 ad.obj= &ob;
                 ob.nid=n;
-                adp=(ADDED_OBJ *)lh_retrieve(added,(char *)&ad);
+                adp=(ADDED_OBJ *)lh_retrieve(added,&ad);
                 if (adp != NULL)
                         return(adp->obj->ln);
                 else
@@ -355,8 +363,7 @@ int n;
                 }
         }
 
-int OBJ_obj2nid(a)
-ASN1_OBJECT *a;
+int OBJ_obj2nid(const ASN1_OBJECT *a)
         {
         ASN1_OBJECT **op;
         ADDED_OBJ ad,*adp;
@@ -369,56 +376,136 @@ ASN1_OBJECT *a;
         if (added != NULL)
                 {
                 ad.type=ADDED_DATA;
-                ad.obj=a;
-                adp=(ADDED_OBJ *)lh_retrieve(added,(char *)&ad);
+                ad.obj=(ASN1_OBJECT *)a; /* XXX: ugly but harmless */
+                adp=(ADDED_OBJ *)lh_retrieve(added,&ad);
                 if (adp != NULL) return (adp->obj->nid);
                 }
         op=(ASN1_OBJECT **)OBJ_bsearch((char *)&a,(char *)obj_objs,NUM_OBJ,
-                sizeof(ASN1_OBJECT *),(int (*)())obj_cmp);
+                sizeof(ASN1_OBJECT *),obj_cmp);
         if (op == NULL)
                 return(NID_undef);
         return((*op)->nid);
         }
 
-int OBJ_txt2nid(s)
-char *s;
+/* Convert an object name into an ASN1_OBJECT
+ * if "noname" is not set then search for short and long names first.
+ * This will convert the "dotted" form into an object: unlike OBJ_txt2nid
+ * it can be used with any objects, not just registered ones.
+ */
+
+ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name)
         {
-        int ret;
+        int nid = NID_undef;
+        ASN1_OBJECT *op=NULL;
+        unsigned char *buf,*p;
+        int i, j;
 
-        ret=OBJ_sn2nid(s);
-        if (ret == NID_undef)
-                {
-                ret=OBJ_ln2nid(s);
-                if (ret == NID_undef)
-                        {
-                        ASN1_OBJECT *op=NULL;
-                        unsigned char *buf,*p;
-                        int i;
+        if(!no_name) {
+                if( ((nid = OBJ_sn2nid(s)) != NID_undef) ||
+                        ((nid = OBJ_ln2nid(s)) != NID_undef) ) 
+                                        return OBJ_nid2obj(nid);
+        }
 
-                        i=a2d_ASN1_OBJECT(NULL,0,s,-1);
-                        if (i <= 0)
-                                {
-                                /* clear the error */
-                                ERR_get_error();
-                                return(0);
-                                }
+        /* Work out size of content octets */
+        i=a2d_ASN1_OBJECT(NULL,0,s,-1);
+        if (i <= 0) {
+                /* Clear the error */
+                ERR_get_error();
+                return NULL;
+        }
+        /* Work out total size */
+        j = ASN1_object_size(0,i,V_ASN1_OBJECT);
+
+        if((buf=(unsigned char *)OPENSSL_malloc(j)) == NULL) return NULL;
+
+        p = buf;
+        /* Write out tag+length */
+        ASN1_put_object(&p,0,i,V_ASN1_OBJECT,V_ASN1_UNIVERSAL);
+        /* Write out contents */
+        a2d_ASN1_OBJECT(p,i,s,-1);
+        
+        p=buf;
+        op=d2i_ASN1_OBJECT(NULL,&p,i);
+        OPENSSL_free(buf);
+        return op;
+        }
+
+int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name)
+{
+        int i,idx=0,n=0,len,nid;
+        unsigned long l;
+        unsigned char *p;
+        const char *s;
+        char tbuf[32];
+
+        if (buf_len <= 0) return(0);
 
-                        if ((buf=(unsigned char *)Malloc(i)) == NULL)
-                                return(NID_undef);
-                        a2d_ASN1_OBJECT(buf,i,s,-1);
-                        p=buf;
-                        op=d2i_ASN1_OBJECT(NULL,&p,i);
-                        if (op == NULL) return(NID_undef);
-                        ret=OBJ_obj2nid(op);
-                        ASN1_OBJECT_free(op);
-                        Free(buf);
+        if ((a == NULL) || (a->data == NULL)) {
+                buf[0]='\0';
+                return(0);
+        }
+
+        if (no_name || (nid=OBJ_obj2nid(a)) == NID_undef) {
+                len=a->length;
+                p=a->data;
+
+                idx=0;
+                l=0;
+                while (idx < a->length) {
+                        l|=(p[idx]&0x7f);
+                        if (!(p[idx] & 0x80)) break;
+                        l<<=7L;
+                        idx++;
+                }
+                idx++;
+                i=(int)(l/40);
+                if (i > 2) i=2;
+                l-=(long)(i*40);
+
+                sprintf(tbuf,"%d.%lu",i,l);
+                i=strlen(tbuf);
+                strncpy(buf,tbuf,buf_len);
+                buf_len-=i;
+                buf+=i;
+                n+=i;
+
+                l=0;
+                for (; idx<len; idx++) {
+                        l|=p[idx]&0x7f;
+                        if (!(p[idx] & 0x80)) {
+                                sprintf(tbuf,".%lu",l);
+                                i=strlen(tbuf);
+                                if (buf_len > 0)
+                                        strncpy(buf,tbuf,buf_len);
+                                buf_len-=i;
+                                buf+=i;
+                                n+=i;
+                                l=0;
                         }
+                        l<<=7L;
                 }
-        return(ret);
+        } else {
+                s=OBJ_nid2ln(nid);
+                if (s == NULL)
+                        s=OBJ_nid2sn(nid);
+                strncpy(buf,s,buf_len);
+                n=strlen(s);
         }
+        buf[buf_len-1]='\0';
+        return(n);
+}
 
-int OBJ_ln2nid(s)
-char *s;
+int OBJ_txt2nid(const char *s)
+{
+        ASN1_OBJECT *obj;
+        int nid;
+        obj = OBJ_txt2obj(s, 0);
+        nid = OBJ_obj2nid(obj);
+        ASN1_OBJECT_free(obj);
+        return nid;
+}
+
+int OBJ_ln2nid(const char *s)
         {
         ASN1_OBJECT o,*oo= &o,**op;
         ADDED_OBJ ad,*adp;
@@ -428,17 +515,16 @@ char *s;
                 {
                 ad.type=ADDED_LNAME;
                 ad.obj= &o;
-                adp=(ADDED_OBJ *)lh_retrieve(added,(char *)&ad);
+                adp=(ADDED_OBJ *)lh_retrieve(added,&ad);
                 if (adp != NULL) return (adp->obj->nid);
                 }
         op=(ASN1_OBJECT **)OBJ_bsearch((char *)&oo,(char *)ln_objs,NUM_LN,
-                sizeof(ASN1_OBJECT *),(int (*)())ln_cmp);
+                sizeof(ASN1_OBJECT *),ln_cmp);
         if (op == NULL) return(NID_undef);
         return((*op)->nid);
         }
 
-int OBJ_sn2nid(s)
-char *s;
+int OBJ_sn2nid(const char *s)
         {
         ASN1_OBJECT o,*oo= &o,**op;
         ADDED_OBJ ad,*adp;
@@ -448,37 +534,31 @@ char *s;
                 {
                 ad.type=ADDED_SNAME;
                 ad.obj= &o;
-                adp=(ADDED_OBJ *)lh_retrieve(added,(char *)&ad);
+                adp=(ADDED_OBJ *)lh_retrieve(added,&ad);
                 if (adp != NULL) return (adp->obj->nid);
                 }
         op=(ASN1_OBJECT **)OBJ_bsearch((char *)&oo,(char *)sn_objs,NUM_SN,
-                sizeof(ASN1_OBJECT *),(int (*)())sn_cmp);
+                sizeof(ASN1_OBJECT *),sn_cmp);
         if (op == NULL) return(NID_undef);
         return((*op)->nid);
         }
 
-static int obj_cmp(ap, bp)
-ASN1_OBJECT **ap;
-ASN1_OBJECT **bp;
+static int obj_cmp(const void *ap, const void *bp)
         {
         int j;
-        ASN1_OBJECT *a= *ap;
-        ASN1_OBJECT *b= *bp;
+        ASN1_OBJECT *a= *(ASN1_OBJECT **)ap;
+        ASN1_OBJECT *b= *(ASN1_OBJECT **)bp;
 
         j=(a->length - b->length);
         if (j) return(j);
         return(memcmp(a->data,b->data,a->length));
         }
 
-char *OBJ_bsearch(key,base,num,size,cmp)
-char *key;
-char *base;
-int num;
-int size;
-int (*cmp)();
+const char *OBJ_bsearch(const char *key, const char *base, int num, int size,
+        int (*cmp)(const void *, const void *))
         {
         int l,h,i,c;
-        char *p;
+        const char *p;
 
         if (num == 0) return(NULL);
         l=0;
@@ -495,14 +575,24 @@ int (*cmp)();
                 else
                         return(p);
                 }
+#ifdef CHARSET_EBCDIC
+/* THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and
+ * I don't have perl (yet), we revert to a *LINEAR* search
+ * when the object wasn't found in the binary search.
+ */
+        for (i=0; i<num; ++i) {
+                p= &(base[i*size]);
+                if ((*cmp)(key,p) == 0)
+                        return p;
+        }
+#endif
         return(NULL);
         }
 
-int OBJ_create_objects(in)
-BIO *in;
+int OBJ_create_objects(BIO *in)
         {
         MS_STATIC char buf[512];
-        int i,num= -1;
+        int i,num=0;
         char *o,*s,*l=NULL;
 
         for (;;)
@@ -511,26 +601,26 @@ BIO *in;
                 i=BIO_gets(in,buf,512);
                 if (i <= 0) return(num);
                 buf[i-1]='\0';
-                if (!isalnum(buf[0])) return(num);
+                if (!isalnum((unsigned char)buf[0])) return(num);
                 o=s=buf;
-                while (isdigit(*s) || (*s == '.'))
+                while (isdigit((unsigned char)*s) || (*s == '.'))
                         s++;
                 if (*s != '\0')
                         {
                         *(s++)='\0';
-                        while (isspace(*s))
+                        while (isspace((unsigned char)*s))
                                 s++;
                         if (*s == '\0')
                                 s=NULL;
                         else
                                 {
                                 l=s;
-                                while ((*l != '\0') && !isspace(*l))
+                                while ((*l != '\0') && !isspace((unsigned char)*l))
                                         l++;
                                 if (*l != '\0')
                                         {
                                         *(l++)='\0';
-                                        while (isspace(*l))
+                                        while (isspace((unsigned char)*l))
                                                 l++;
                                         if (*l == '\0') l=NULL;
                                         }
@@ -544,13 +634,10 @@ BIO *in;
                 if (!OBJ_create(o,s,l)) return(num);
                 num++;
                 }
-        return(num);
+        /* return(num); */
         }
 
-int OBJ_create(oid,sn,ln)
-char *oid;
-char *sn;
-char *ln;
+int OBJ_create(const char *oid, const char *sn, const char *ln)
         {
         int ok=0;
         ASN1_OBJECT *op=NULL;
@@ -560,19 +647,21 @@ char *ln;
         i=a2d_ASN1_OBJECT(NULL,0,oid,-1);
         if (i <= 0) return(0);
 
-        if ((buf=(unsigned char *)Malloc(i)) == NULL)
+        if ((buf=(unsigned char *)OPENSSL_malloc(i)) == NULL)
                 {
                 OBJerr(OBJ_F_OBJ_CREATE,OBJ_R_MALLOC_FAILURE);
                 return(0);
                 }
         i=a2d_ASN1_OBJECT(buf,i,oid,-1);
+        if (i == 0)
+                goto err;
         op=(ASN1_OBJECT *)ASN1_OBJECT_create(OBJ_new_nid(1),buf,i,sn,ln);
         if (op == NULL) 
                 goto err;
         ok=OBJ_add_object(op);
 err:
         ASN1_OBJECT_free(op);
-        Free((char *)buf);
+        OPENSSL_free(buf);
         return(ok);
         }