[apple/security.git] / libsecurity_cdsa_utils / lib / cuTimeStr.cpp

/*
 * Copyright (c) 2002 Apple Computer, Inc. All Rights Reserved.
 * 
 * The contents of this file constitute Original Code as defined in and are
 * subject to the Apple Public Source License Version 1.2 (the 'License').
 * You may not use this file except in compliance with the License. Please obtain
 * a copy of the License at http://www.apple.com/publicsource and read it before
 * using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
 * specific language governing rights and limitations under the License.
 */
 
/*
 * cuTimeStr.cpp - time string routines
 */
#include "cuTimeStr.h" 
#include "cuCdsaUtils.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <pthread.h>

/*
 * Given a string containing either a UTC-style or "generalized time"
 * time string, convert to a struct tm (in GMT/UTC). Returns nonzero on
 * error. 
 */
int cuTimeStringToTm(
	const char			*str,
	unsigned			len,
	struct tm			*tmp)
{
	char 		szTemp[5];
	unsigned 	isUtc = 0;
	unsigned	noSeconds = 0;
	int             x;
	unsigned 	i;
	char 		*cp;

	if((str == NULL) || (len == 0) || (tmp == NULL)) {
    	return 1;
  	}
  	
  	/* tolerate NULL terminated or not */
  	if(str[len - 1] == '\0') {
  		len--;
  	}
  	switch(len) {
		case UTC_TIME_NOSEC_LEN:		// 2-digit year, no seconds, not y2K compliant
			isUtc = 1;
			noSeconds = 1;
			break;
  		case UTC_TIME_STRLEN:			// 2-digit year, not Y2K compliant
  			isUtc = 1;
  			break;
  		case GENERALIZED_TIME_STRLEN:	// 4-digit year
  			break;
  		default:						// unknown format 
  			return 1;
  	}
  	
  	cp = (char *)str;
  	
	/* check that all characters except last are digits */
	for(i=0; i<(len - 1); i++) {
		if ( !(isdigit(cp[i])) ) {
		  	return 1;
		}
	}

  	/* check last character is a 'Z' */
  	if(cp[len - 1] != 'Z' )	{
		return 1;
  	}

  	/* YEAR */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	if(!isUtc) {
		/* two more digits */
		szTemp[2] = *cp++;
		szTemp[3] = *cp++;
		szTemp[4] = '\0';
	}
	else { 
		szTemp[2] = '\0';
	}
	x = atoi( szTemp );
	if(isUtc) {
		/* 
		 * 2-digit year. 
		 *   0  <= year <  50 : assume century 21
		 *   50 <= year <  70 : illegal per PKIX, though we tolerate
		 *   70 <  year <= 99 : assume century 20
		 */
		if(x < 50) {
			x += 2000;
		}
		/*
		else if(x < 70) {
			return 1;
		}
		*/
		else {
			/* century 20 */
			x += 1900;			
		}
	}
  	/* by definition - tm_year is year - 1900 */
  	tmp->tm_year = x - 1900;

  	/* MONTH */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	/* in the string, months are from 1 to 12 */
	if((x > 12) || (x <= 0)) {
    	return 1;
	}
	/* in a tm, 0 to 11 */
  	tmp->tm_mon = x - 1;

 	/* DAY */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	/* 1..31 in both formats */
	if((x > 31) || (x <= 0)) {
		return 1;
	}
  	tmp->tm_mday = x;

	/* HOUR */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	if((x > 23) || (x < 0)) {
		return 1;
	}
	tmp->tm_hour = x;

  	/* MINUTE */
	szTemp[0] = *cp++;
	szTemp[1] = *cp++;
	szTemp[2] = '\0';
	x = atoi( szTemp );
	if((x > 59) || (x < 0)) {
		return 1;
	}
  	tmp->tm_min = x;

  	/* SECOND */
	if(noSeconds) {
		tmp->tm_sec = 0;
	}
	else {
		szTemp[0] = *cp++;
		szTemp[1] = *cp++;
		szTemp[2] = '\0';
		x = atoi( szTemp );
		if((x > 59) || (x < 0)) {
			return 1;
		}
		tmp->tm_sec = x;
	}
	return 0;
}

#define MAX_TIME_STR_LEN  	30

/* protects time(), gmtime() */
static pthread_mutex_t timeMutex = PTHREAD_MUTEX_INITIALIZER;	

char *cuTimeAtNowPlus(int secFromNow, 
	timeSpec spec)
{
	struct tm utc;
	char *outStr;
	time_t baseTime;
	
	pthread_mutex_lock(&timeMutex);
	baseTime = time(NULL);
	baseTime += (time_t)secFromNow;
	utc = *gmtime(&baseTime);
	pthread_mutex_unlock(&timeMutex);
	
	outStr = (char *)APP_MALLOC(MAX_TIME_STR_LEN);
	
	switch(spec) {
		case TIME_UTC:
			/* UTC - 2 year digits - code which parses this assumes that
			 * (2-digit) years between 0 and 49 are in century 21 */
			if(utc.tm_year >= 100) {
				utc.tm_year -= 100;
			}
			sprintf(outStr, "%02d%02d%02d%02d%02d%02dZ",
				utc.tm_year /* + 1900 */, utc.tm_mon + 1,
				utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
			break;
		case TIME_GEN:
			sprintf(outStr, "%04d%02d%02d%02d%02d%02dZ",
				/* note year is relative to 1900, hopefully it'll 
				 * have four valid digits! */
				utc.tm_year + 1900, utc.tm_mon + 1,
				utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
			break;
		case TIME_CSSM:
			sprintf(outStr, "%04d%02d%02d%02d%02d%02d",
				/* note year is relative to 1900, hopefully it'll have 
				 * four valid digits! */
				utc.tm_year + 1900, utc.tm_mon + 1,
				utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
			break;
	}
	return outStr;
}

/*
 * Convert a CSSM_X509_TIME, which can be in any of three forms (UTC,
 * generalized, or CSSM_TIMESTRING) into a CSSM_TIMESTRING. Caller
 * must free() the result. Returns NULL if x509time is badly formed. 
 */
char *cuX509TimeToCssmTimestring(
	const CSSM_X509_TIME 	*x509Time,
	unsigned				*rtnLen)		// for caller's convenience
{
	int len = (int)x509Time->time.Length;
	const char *inStr = (char *)x509Time->time.Data;	
											// not NULL terminated!
	char *rtn;
	
	*rtnLen = 0;
	if((len == 0) || (inStr == NULL)) {
		return NULL;
	}
	rtn = (char *)malloc(CSSM_TIME_STRLEN + 1);
	rtn[0] = '\0';
	switch(len) {
		case UTC_TIME_STRLEN:
		{
			/* infer century and prepend to output */
			char tmp[3];
			int year;
			tmp[0] = inStr[0];
			tmp[1] = inStr[1];
			tmp[2] = '\0';
			year = atoi(tmp);
			
			/* 
			 *   0  <= year <  50 : assume century 21
			 *   50 <= year <  70 : illegal per PKIX
			 *   70 <  year <= 99 : assume century 20
			 */
			if(year < 50) {
				/* century 21 */
				strcpy(rtn, "20");
			}
			else if(year < 70) {
				free(rtn);
				return NULL;
			}
			else {
				/* century 20 */
				strcpy(rtn, "19");
			}
			memmove(rtn + 2, inStr, len - 1);		// don't copy the Z
			break;
		}
		case CSSM_TIME_STRLEN:
			memmove(rtn, inStr, len);				// trivial case
			break;
		case GENERALIZED_TIME_STRLEN:
			memmove(rtn, inStr, len - 1);			// don't copy the Z
			break;
		
		default:
			free(rtn);
			return NULL;
	}
	rtn[CSSM_TIME_STRLEN] = '\0';
	*rtnLen = CSSM_TIME_STRLEN;
	return rtn;
}
Commit	Line	Data
b1ab9ed8 A	1	/*
	2	* Copyright (c) 2002 Apple Computer, Inc. All Rights Reserved.
	3	*
	4	* The contents of this file constitute Original Code as defined in and are
	5	* subject to the Apple Public Source License Version 1.2 (the 'License').
	6	* You may not use this file except in compliance with the License. Please obtain
	7	* a copy of the License at http://www.apple.com/publicsource and read it before
	8	* using this file.
	9	*
	10	* This Original Code and all software distributed under the License are
	11	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
	12	* OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
	13	* LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
	14	* PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
	15	* specific language governing rights and limitations under the License.
	16	*/
	17
	18	/*
	19	* cuTimeStr.cpp - time string routines
	20	*/
	21	#include "cuTimeStr.h"
	22	#include "cuCdsaUtils.h"
	23	#include <string.h>
	24	#include <stdlib.h>
	25	#include <stdio.h>
	26	#include <ctype.h>
	27	#include <pthread.h>
	28
	29	/*
	30	* Given a string containing either a UTC-style or "generalized time"
	31	* time string, convert to a struct tm (in GMT/UTC). Returns nonzero on
	32	* error.
	33	*/
	34	int cuTimeStringToTm(
	35	const char *str,
	36	unsigned len,
	37	struct tm *tmp)
	38	{
	39	char szTemp[5];
	40	unsigned isUtc = 0;
	41	unsigned noSeconds = 0;
427c49bc	42	int x;
b1ab9ed8 A	43	unsigned i;
	44	char *cp;
	45
	46	if((str == NULL) \|\| (len == 0) \|\| (tmp == NULL)) {
	47	return 1;
	48	}
	49
	50	/* tolerate NULL terminated or not */
	51	if(str[len - 1] == '\0') {
	52	len--;
	53	}
	54	switch(len) {
	55	case UTC_TIME_NOSEC_LEN: // 2-digit year, no seconds, not y2K compliant
	56	isUtc = 1;
	57	noSeconds = 1;
	58	break;
	59	case UTC_TIME_STRLEN: // 2-digit year, not Y2K compliant
	60	isUtc = 1;
	61	break;
	62	case GENERALIZED_TIME_STRLEN: // 4-digit year
	63	break;
	64	default: // unknown format
	65	return 1;
	66	}
	67
	68	cp = (char *)str;
	69
	70	/* check that all characters except last are digits */
	71	for(i=0; i<(len - 1); i++) {
	72	if ( !(isdigit(cp[i])) ) {
	73	return 1;
	74	}
	75	}
	76
	77	/* check last character is a 'Z' */
	78	if(cp[len - 1] != 'Z' ) {
	79	return 1;
	80	}
	81
	82	/* YEAR */
	83	szTemp[0] = *cp++;
	84	szTemp[1] = *cp++;
	85	if(!isUtc) {
	86	/* two more digits */
	87	szTemp[2] = *cp++;
	88	szTemp[3] = *cp++;
	89	szTemp[4] = '\0';
	90	}
	91	else {
	92	szTemp[2] = '\0';
	93	}
	94	x = atoi( szTemp );
	95	if(isUtc) {
	96	/*
	97	* 2-digit year.
	98	* 0 <= year < 50 : assume century 21
	99	* 50 <= year < 70 : illegal per PKIX, though we tolerate
	100	* 70 < year <= 99 : assume century 20
	101	*/
	102	if(x < 50) {
	103	x += 2000;
	104	}
	105	/*
	106	else if(x < 70) {
107	return 1;
108	}
109	*/
110	else {
111	/* century 20 */
112	x += 1900;
113	}
114	}
115	/* by definition - tm_year is year - 1900 */
116	tmp->tm_year = x - 1900;
117
118	/* MONTH */
119	szTemp[0] = *cp++;
120	szTemp[1] = *cp++;
121	szTemp[2] = '\0';
122	x = atoi( szTemp );
123	/* in the string, months are from 1 to 12 */
124	if((x > 12) \|\| (x <= 0)) {
125	return 1;
126	}
127	/* in a tm, 0 to 11 */
128	tmp->tm_mon = x - 1;
129
130	/* DAY */
131	szTemp[0] = *cp++;
132	szTemp[1] = *cp++;
133	szTemp[2] = '\0';
134	x = atoi( szTemp );
135	/* 1..31 in both formats */
136	if((x > 31) \|\| (x <= 0)) {
137	return 1;
138	}
139	tmp->tm_mday = x;
140
141	/* HOUR */
142	szTemp[0] = *cp++;
143	szTemp[1] = *cp++;
144	szTemp[2] = '\0';
145	x = atoi( szTemp );
146	if((x > 23) \|\| (x < 0)) {
147	return 1;
148	}
149	tmp->tm_hour = x;
150
151	/* MINUTE */
152	szTemp[0] = *cp++;
153	szTemp[1] = *cp++;
154	szTemp[2] = '\0';
155	x = atoi( szTemp );
156	if((x > 59) \|\| (x < 0)) {
157	return 1;
158	}
159	tmp->tm_min = x;
160
161	/* SECOND */
162	if(noSeconds) {
163	tmp->tm_sec = 0;
164	}
165	else {
166	szTemp[0] = *cp++;
167	szTemp[1] = *cp++;
168	szTemp[2] = '\0';
169	x = atoi( szTemp );
170	if((x > 59) \|\| (x < 0)) {
171	return 1;
172	}
173	tmp->tm_sec = x;
174	}
175	return 0;
176	}
177
178	#define MAX_TIME_STR_LEN 30
179
180	/* protects time(), gmtime() */
181	static pthread_mutex_t timeMutex = PTHREAD_MUTEX_INITIALIZER;
182
183	char *cuTimeAtNowPlus(int secFromNow,
184	timeSpec spec)
185	{
186	struct tm utc;
187	char *outStr;
188	time_t baseTime;
189
190	pthread_mutex_lock(&timeMutex);
191	baseTime = time(NULL);
192	baseTime += (time_t)secFromNow;
193	utc = *gmtime(&baseTime);
194	pthread_mutex_unlock(&timeMutex);
195
196	outStr = (char *)APP_MALLOC(MAX_TIME_STR_LEN);
197
198	switch(spec) {
199	case TIME_UTC:
200	/* UTC - 2 year digits - code which parses this assumes that
201	* (2-digit) years between 0 and 49 are in century 21 */
202	if(utc.tm_year >= 100) {
203	utc.tm_year -= 100;
204	}
205	sprintf(outStr, "%02d%02d%02d%02d%02d%02dZ",
206	utc.tm_year /* + 1900 */, utc.tm_mon + 1,
207	utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
208	break;
209	case TIME_GEN:
210	sprintf(outStr, "%04d%02d%02d%02d%02d%02dZ",
211	/* note year is relative to 1900, hopefully it'll
212	* have four valid digits! */
213	utc.tm_year + 1900, utc.tm_mon + 1,
214	utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
215	break;
216	case TIME_CSSM:
217	sprintf(outStr, "%04d%02d%02d%02d%02d%02d",
218	/* note year is relative to 1900, hopefully it'll have
219	* four valid digits! */
220	utc.tm_year + 1900, utc.tm_mon + 1,
221	utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec);
222	break;
223	}
224	return outStr;
225	}
226
227	/*
228	* Convert a CSSM_X509_TIME, which can be in any of three forms (UTC,
229	* generalized, or CSSM_TIMESTRING) into a CSSM_TIMESTRING. Caller
230	* must free() the result. Returns NULL if x509time is badly formed.
231	*/
232	char *cuX509TimeToCssmTimestring(
233	const CSSM_X509_TIME *x509Time,
234	unsigned *rtnLen) // for caller's convenience
235	{
427c49bc	236	int len = (int)x509Time->time.Length;
b1ab9ed8 A	237	const char inStr = (char )x509Time->time.Data;
	238	// not NULL terminated!
	239	char *rtn;
	240
	241	*rtnLen = 0;
	242	if((len == 0) \|\| (inStr == NULL)) {
	243	return NULL;
	244	}
	245	rtn = (char *)malloc(CSSM_TIME_STRLEN + 1);
	246	rtn[0] = '\0';
	247	switch(len) {
	248	case UTC_TIME_STRLEN:
	249	{
	250	/* infer century and prepend to output */
	251	char tmp[3];
	252	int year;
	253	tmp[0] = inStr[0];
	254	tmp[1] = inStr[1];
	255	tmp[2] = '\0';
	256	year = atoi(tmp);
	257
	258	/*
	259	* 0 <= year < 50 : assume century 21
	260	* 50 <= year < 70 : illegal per PKIX
	261	* 70 < year <= 99 : assume century 20
	262	*/
	263	if(year < 50) {
	264	/* century 21 */
	265	strcpy(rtn, "20");
	266	}
	267	else if(year < 70) {
	268	free(rtn);
	269	return NULL;
	270	}
	271	else {
	272	/* century 20 */
	273	strcpy(rtn, "19");
	274	}
	275	memmove(rtn + 2, inStr, len - 1); // don't copy the Z
	276	break;
	277	}
	278	case CSSM_TIME_STRLEN:
	279	memmove(rtn, inStr, len); // trivial case
	280	break;
	281	case GENERALIZED_TIME_STRLEN:
	282	memmove(rtn, inStr, len - 1); // don't copy the Z
	283	break;
	284
	285	default:
	286	free(rtn);
	287	return NULL;
	288	}
	289	rtn[CSSM_TIME_STRLEN] = '\0';
	290	*rtnLen = CSSM_TIME_STRLEN;
	291	return rtn;
	292	}
	293