Remove references to o_time.h
[openssl.git] / crypto / asn1 / a_utctm.c
index ba34945..2da5f25 100644 (file)
 
 #include <stdio.h>
 #include <time.h>
-#ifdef VMS
-#include <descrip.h>
-#include <lnmdef.h>
-#include <starlet.h>
-#endif
 #include "cryptlib.h"
 #include <openssl/asn1.h>
+#include "asn1_locl.h"
 
-ASN1_UTCTIME *ASN1_UTCTIME_new(void)
-{ return M_ASN1_UTCTIME_new(); }
-
-void ASN1_UTCTIME_free(ASN1_UTCTIME *x)
-{ return M_ASN1_UTCTIME_free(x); }
-
+#if 0
 int i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **pp)
        {
 #ifndef CHARSET_EBCDIC
@@ -119,10 +110,12 @@ err:
        return(NULL);
        }
 
-int ASN1_UTCTIME_check(ASN1_UTCTIME *d)
+#endif
+
+int asn1_utctime_to_tm(struct tm *tm, const ASN1_UTCTIME *d)
        {
-       static int min[8]={ 0, 1, 1, 0, 0, 0, 0, 0};
-       static int max[8]={99,12,31,23,59,59,12,59};
+       static const int min[8]={ 0, 1, 1, 0, 0, 0, 0, 0};
+       static const int max[8]={99,12,31,23,59,59,12,59};
        char *a;
        int n,i,l,o;
 
@@ -136,7 +129,12 @@ int ASN1_UTCTIME_check(ASN1_UTCTIME *d)
                {
                if ((i == 5) && ((a[o] == 'Z') ||
                        (a[o] == '+') || (a[o] == '-')))
-                       { i++; break; }
+                       {
+                       i++;
+                       if (tm)
+                               tm->tm_sec = 0;
+                       break;
+                       }
                if ((a[o] < '0') || (a[o] > '9')) goto err;
                n= a[o]-'0';
                if (++o > l) goto err;
@@ -146,11 +144,36 @@ int ASN1_UTCTIME_check(ASN1_UTCTIME *d)
                if (++o > l) goto err;
 
                if ((n < min[i]) || (n > max[i])) goto err;
+               if (tm)
+                       {
+                       switch(i)
+                               {
+                       case 0:
+                               tm->tm_year = n < 50 ? n + 100 : n;
+                               break;
+                       case 1:
+                               tm->tm_mon = n - 1;
+                               break;
+                       case 2:
+                               tm->tm_mday = n;
+                               break;
+                       case 3:
+                               tm->tm_hour = n;
+                               break;
+                       case 4:
+                               tm->tm_min = n;
+                               break;
+                       case 5:
+                               tm->tm_sec = n;
+                               break;
+                               }
+                       }
                }
        if (a[o] == 'Z')
                o++;
        else if ((a[o] == '+') || (a[o] == '-'))
                {
+               int offsign = a[o] == '-' ? -1 : 1, offset = 0;
                o++;
                if (o+4 > l) goto err;
                for (i=6; i<8; i++)
@@ -161,15 +184,29 @@ int ASN1_UTCTIME_check(ASN1_UTCTIME *d)
                        if ((a[o] < '0') || (a[o] > '9')) goto err;
                        n=(n*10)+ a[o]-'0';
                        if ((n < min[i]) || (n > max[i])) goto err;
+                       if (tm)
+                               {
+                               if (i == 6)
+                                       offset = n * 3600;
+                               else if (i == 7)
+                                       offset += n * 60;
+                               }
                        o++;
                        }
+               if (offset && !OPENSSL_gmtime_adj(tm, 0, offset * offsign))
+                       return 0;
                }
-       return(o == l);
+       return o == l;
 err:
-       return(0);
+       return 0;
+       }
+
+int ASN1_UTCTIME_check(const ASN1_UTCTIME *d)
+       {
+       return asn1_utctime_to_tm(NULL, d);
        }
 
-int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, char *str)
+int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str)
        {
        ASN1_UTCTIME t;
 
@@ -180,8 +217,10 @@ int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, char *str)
                {
                if (s != NULL)
                        {
-                       ASN1_STRING_set((ASN1_STRING *)s,
-                               (unsigned char *)str,t.length);
+                       if (!ASN1_STRING_set((ASN1_STRING *)s,
+                               (unsigned char *)str,t.length))
+                               return 0;
+                       s->type = V_ASN1_UTCTIME;
                        }
                return(1);
                }
@@ -191,72 +230,51 @@ int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, char *str)
 
 ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
        {
+       return ASN1_UTCTIME_adj(s, t, 0, 0);
+       }
+
+ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
+                               int offset_day, long offset_sec)
+       {
        char *p;
        struct tm *ts;
-#if defined(THREADS) && !defined(WIN32)
        struct tm data;
-#endif
+       size_t len = 20;
 
        if (s == NULL)
                s=M_ASN1_UTCTIME_new();
        if (s == NULL)
                return(NULL);
 
-#if defined(THREADS) && !defined(WIN32)
-       gmtime_r(&t,&data); /* should return &data, but doesn't on some systems, so we don't even look at the return value */
-       ts=&data;
-#else
-       ts=gmtime(&t);
-#endif
-#ifdef VMS
+       ts=OPENSSL_gmtime(&t, &data);
        if (ts == NULL)
-               {
-               static $DESCRIPTOR(tabnam,"LNM$DCL_LOGICAL");
-               static $DESCRIPTOR(lognam,"SYS$TIMEZONE_DIFFERENTIAL");
-               char result[256];
-               unsigned int reslen = 0;
-               struct {
-                       short buflen;
-                       short code;
-                       void *bufaddr;
-                       unsigned int *reslen;
-               } itemlist[] = {
-                       { 0, LNM$_STRING, 0, 0 },
-                       { 0, 0, 0, 0 },
-               };
-               int status;
-
-               /* Get the value for SYS$TIMEZONE_DIFFERENTIAL */
-               itemlist[0].buflen = sizeof(result);
-               itemlist[0].bufaddr = result;
-               itemlist[0].reslen = &reslen;
-               status = sys$trnlnm(0, &tabnam, &lognam, 0, itemlist);
-               if (!(status & 1))
-                       return NULL;
-               result[reslen] = '\0';
+               return(NULL);
 
-               /* Get the numerical value of the equivalence string */
-               status = atoi(result);
+       if (offset_day || offset_sec)
+               { 
+               if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))
+                       return NULL;
+               }
 
-               /* and use it to move time to GMT */
-               t -= status;
+       if((ts->tm_year < 50) || (ts->tm_year >= 150))
+               return NULL;
 
-               /* then convert the result to the time structure */
-               ts=(struct tm *)localtime(&t);
-               }
-#endif
        p=(char *)s->data;
-       if ((p == NULL) || (s->length < 14))
+       if ((p == NULL) || ((size_t)s->length < len))
                {
-               p=Malloc(20);
-               if (p == NULL) return(NULL);
+               p=OPENSSL_malloc(len);
+               if (p == NULL)
+                       {
+                       ASN1err(ASN1_F_ASN1_UTCTIME_ADJ,ERR_R_MALLOC_FAILURE);
+                       return(NULL);
+                       }
                if (s->data != NULL)
-                       Free(s->data);
+                       OPENSSL_free(s->data);
                s->data=(unsigned char *)p;
                }
 
-       sprintf(p,"%02d%02d%02d%02d%02d%02dZ",ts->tm_year%100,
-               ts->tm_mon+1,ts->tm_mday,ts->tm_hour,ts->tm_min,ts->tm_sec);
+       BIO_snprintf(p,len,"%02d%02d%02d%02d%02d%02dZ",ts->tm_year%100,
+                    ts->tm_mon+1,ts->tm_mday,ts->tm_hour,ts->tm_min,ts->tm_sec);
        s->length=strlen(p);
        s->type=V_ASN1_UTCTIME;
 #ifdef CHARSET_EBCDIC_not
@@ -264,3 +282,68 @@ ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
 #endif
        return(s);
        }
+
+
+int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t)
+       {
+       struct tm stm, ttm;
+       int day, sec;
+
+       if (!asn1_utctime_to_tm(&stm, s))
+               return -2;
+
+       if (!OPENSSL_gmtime(&t, &ttm))
+               return -2;
+
+       if (!OPENSSL_gmtime_diff(&day, &sec, &stm, &ttm))
+               return -2;
+
+       if (day > 0)
+               return 1;
+       if (day < 0)
+               return -1;
+       if (sec > 0)
+               return 1;
+       if (sec < 0)
+               return -1;
+       return 0;
+       }
+
+
+#if 0
+time_t ASN1_UTCTIME_get(const ASN1_UTCTIME *s)
+       {
+       struct tm tm;
+       int offset;
+
+       memset(&tm,'\0',sizeof tm);
+
+#define g2(p) (((p)[0]-'0')*10+(p)[1]-'0')
+       tm.tm_year=g2(s->data);
+       if(tm.tm_year < 50)
+               tm.tm_year+=100;
+       tm.tm_mon=g2(s->data+2)-1;
+       tm.tm_mday=g2(s->data+4);
+       tm.tm_hour=g2(s->data+6);
+       tm.tm_min=g2(s->data+8);
+       tm.tm_sec=g2(s->data+10);
+       if(s->data[12] == 'Z')
+               offset=0;
+       else
+               {
+               offset=g2(s->data+13)*60+g2(s->data+15);
+               if(s->data[12] == '-')
+                       offset= -offset;
+               }
+#undef g2
+
+       return mktime(&tm)-offset*60; /* FIXME: mktime assumes the current timezone
+                                      * instead of UTC, and unless we rewrite OpenSSL
+                                      * in Lisp we cannot locally change the timezone
+                                      * without possibly interfering with other parts
+                                      * of the program. timegm, which uses UTC, is
+                                      * non-standard.
+                                      * Also time_t is inappropriate for general
+                                      * UTC times because it may a 32 bit type. */
+       }
+#endif