[thirdparty/openssl.git] / ssl / d1_lib.c

/* ssl/d1_lib.c */
/* 
 * DTLS implementation written by Nagendra Modadugu
 * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.  
 */
/* ====================================================================
 * Copyright (c) 1999-2005 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    openssl-core@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT 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.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>
#define USE_SOCKETS
#include <openssl/objects.h>
#include "ssl_locl.h"

#ifdef OPENSSL_SYS_WIN32
#include <sys/timeb.h>
#endif

static void get_current_time(struct timeval *t);
const char dtls1_version_str[]="DTLSv1" OPENSSL_VERSION_PTEXT;

SSL3_ENC_METHOD DTLSv1_enc_data={
    dtls1_enc,
	tls1_mac,
	tls1_setup_key_block,
	tls1_generate_master_secret,
	tls1_change_cipher_state,
	tls1_final_finish_mac,
	TLS1_FINISH_MAC_LENGTH,
	tls1_cert_verify_mac,
	TLS_MD_CLIENT_FINISH_CONST,TLS_MD_CLIENT_FINISH_CONST_SIZE,
	TLS_MD_SERVER_FINISH_CONST,TLS_MD_SERVER_FINISH_CONST_SIZE,
	tls1_alert_code,
	};

long dtls1_default_timeout(void)
	{
	/* 2 hours, the 24 hours mentioned in the DTLSv1 spec
	 * is way too long for http, the cache would over fill */
	return(60*60*2);
	}

int dtls1_new(SSL *s)
	{
	DTLS1_STATE *d1;

	if (!ssl3_new(s)) return(0);
	if ((d1=OPENSSL_malloc(sizeof *d1)) == NULL) return (0);
	memset(d1,0, sizeof *d1);

	/* d1->handshake_epoch=0; */

	d1->unprocessed_rcds.q=pqueue_new();
	d1->processed_rcds.q=pqueue_new();
	d1->buffered_messages = pqueue_new();
	d1->sent_messages=pqueue_new();
	d1->buffered_app_data.q=pqueue_new();

	if ( s->server)
		{
		d1->cookie_len = sizeof(s->d1->cookie);
		}

	if( ! d1->unprocessed_rcds.q || ! d1->processed_rcds.q 
        || ! d1->buffered_messages || ! d1->sent_messages || ! d1->buffered_app_data.q)
		{
        if ( d1->unprocessed_rcds.q) pqueue_free(d1->unprocessed_rcds.q);
        if ( d1->processed_rcds.q) pqueue_free(d1->processed_rcds.q);
        if ( d1->buffered_messages) pqueue_free(d1->buffered_messages);
		if ( d1->sent_messages) pqueue_free(d1->sent_messages);
		if ( d1->buffered_app_data.q) pqueue_free(d1->buffered_app_data.q);
		OPENSSL_free(d1);
		return (0);
		}

	s->d1=d1;
	s->method->ssl_clear(s);
	return(1);
	}

void dtls1_free(SSL *s)
	{
    pitem *item = NULL;
    hm_fragment *frag = NULL;

	ssl3_free(s);

    while( (item = pqueue_pop(s->d1->unprocessed_rcds.q)) != NULL)
        {
        OPENSSL_free(item->data);
        pitem_free(item);
        }
    pqueue_free(s->d1->unprocessed_rcds.q);

    while( (item = pqueue_pop(s->d1->processed_rcds.q)) != NULL)
        {
        OPENSSL_free(item->data);
        pitem_free(item);
        }
    pqueue_free(s->d1->processed_rcds.q);

    while( (item = pqueue_pop(s->d1->buffered_messages)) != NULL)
        {
        frag = (hm_fragment *)item->data;
        OPENSSL_free(frag->fragment);
        OPENSSL_free(frag);
        pitem_free(item);
        }
    pqueue_free(s->d1->buffered_messages);

    while ( (item = pqueue_pop(s->d1->sent_messages)) != NULL)
        {
        frag = (hm_fragment *)item->data;
        OPENSSL_free(frag->fragment);
        OPENSSL_free(frag);
        pitem_free(item);
        }
	pqueue_free(s->d1->sent_messages);

	while ( (item = pqueue_pop(s->d1->buffered_app_data.q)) != NULL)
		{
		frag = (hm_fragment *)item->data;
		OPENSSL_free(frag->fragment);
		OPENSSL_free(frag);
		pitem_free(item);
		}
	pqueue_free(s->d1->buffered_app_data.q);

	OPENSSL_free(s->d1);
	}

void dtls1_clear(SSL *s)
	{
	ssl3_clear(s);
	if (s->options & SSL_OP_CISCO_ANYCONNECT)
		s->version=DTLS1_BAD_VER;
	else
		s->version=DTLS1_VERSION;
	}

/*
 * As it's impossible to use stream ciphers in "datagram" mode, this
 * simple filter is designed to disengage them in DTLS. Unfortunately
 * there is no universal way to identify stream SSL_CIPHER, so we have
 * to explicitly list their SSL_* codes. Currently RC4 is the only one
 * available, but if new ones emerge, they will have to be added...
 */
const SSL_CIPHER *dtls1_get_cipher(unsigned int u)
	{
	const SSL_CIPHER *ciph = ssl3_get_cipher(u);

	if (ciph != NULL)
		{
		if (ciph->algorithm_enc == SSL_RC4)
			return NULL;
		}

	return ciph;
	}

void dtls1_start_timer(SSL *s)
	{
	/* If timer is not set, initialize duration with 1 second */
	if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0)
		{
		s->d1->timeout_duration = 1;
		}
	
	/* Set timeout to current time */
	get_current_time(&(s->d1->next_timeout));

	/* Add duration to current time */
	s->d1->next_timeout.tv_sec += s->d1->timeout_duration;
	BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &(s->d1->next_timeout));
	}

struct timeval* dtls1_get_timeout(SSL *s, struct timeval* timeleft)
	{
	struct timeval timenow;

	/* If no timeout is set, just return NULL */
	if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0)
		{
		return NULL;
		}

	/* Get current time */
	get_current_time(&timenow);

	/* If timer already expired, set remaining time to 0 */
	if (s->d1->next_timeout.tv_sec < timenow.tv_sec ||
		(s->d1->next_timeout.tv_sec == timenow.tv_sec &&
		 s->d1->next_timeout.tv_usec <= timenow.tv_usec))
		{
		memset(timeleft, 0, sizeof(struct timeval));
		return timeleft;
		}

	/* Calculate time left until timer expires */
	memcpy(timeleft, &(s->d1->next_timeout), sizeof(struct timeval));
	timeleft->tv_sec -= timenow.tv_sec;
	timeleft->tv_usec -= timenow.tv_usec;
	if (timeleft->tv_usec < 0)
		{
		timeleft->tv_sec--;
		timeleft->tv_usec += 1000000;
		}

	return timeleft;
	}

int dtls1_is_timer_expired(SSL *s)
	{
	struct timeval timeleft;

	/* Get time left until timeout, return false if no timer running */
	if (dtls1_get_timeout(s, &timeleft) == NULL)
		{
		return 0;
		}

	/* Return false if timer is not expired yet */
	if (timeleft.tv_sec > 0 || timeleft.tv_usec > 0)
		{
		return 0;
		}

	/* Timer expired, so return true */	
	return 1;
	}

void dtls1_double_timeout(SSL *s)
	{
	s->d1->timeout_duration *= 2;
	if (s->d1->timeout_duration > 60)
		s->d1->timeout_duration = 60;
	dtls1_start_timer(s);
	}

void dtls1_stop_timer(SSL *s)
	{
	/* Reset everything */
	memset(&(s->d1->next_timeout), 0, sizeof(struct timeval));
	s->d1->timeout_duration = 1;
	BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &(s->d1->next_timeout));
	}

static void get_current_time(struct timeval *t)
{
#ifdef OPENSSL_SYS_WIN32
	struct _timeb tb;
	_ftime(&tb);
	t->tv_sec = (long)tb.time;
	t->tv_usec = (long)tb.millitm * 1000;
#elif defined(OPENSSL_SYS_VMS)
	struct timeb tb;
	ftime(&tb);
	t->tv_sec = (long)tb.time;
	t->tv_usec = (long)tb.millitm * 1000;
#else
	gettimeofday(t, NULL);
#endif
}
Commit	Line	Data
36d16f8e BL	1	/* ssl/d1_lib.c */
	2	/*
	3	* DTLS implementation written by Nagendra Modadugu
	4	* (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
	5	*/
	6	/* ====================================================================
	7	* Copyright (c) 1999-2005 The OpenSSL Project. All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	*
	13	* 1. Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	*
	16	* 2. Redistributions in binary form must reproduce the above copyright
	17	* notice, this list of conditions and the following disclaimer in
	18	* the documentation and/or other materials provided with the
	19	* distribution.
	20	*
	21	* 3. All advertising materials mentioning features or use of this
	22	* software must display the following acknowledgment:
	23	* "This product includes software developed by the OpenSSL Project
	24	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	25	*
	26	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	27	* endorse or promote products derived from this software without
	28	* prior written permission. For written permission, please contact
	29	* openssl-core@OpenSSL.org.
	30	*
	31	* 5. Products derived from this software may not be called "OpenSSL"
	32	* nor may "OpenSSL" appear in their names without prior written
	33	* permission of the OpenSSL Project.
	34	*
	35	* 6. Redistributions of any form whatsoever must retain the following
	36	* acknowledgment:
	37	* "This product includes software developed by the OpenSSL Project
	38	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	39	*
	40	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	41	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	42	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	43	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	44	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	45	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	46	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	47	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	49	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	50	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	51	* OF THE POSSIBILITY OF SUCH DAMAGE.
	52	* ====================================================================
	53	*
	54	* This product includes cryptographic software written by Eric Young
	55	* (eay@cryptsoft.com). This product includes software written by Tim
	56	* Hudson (tjh@cryptsoft.com).
	57	*
	58	*/
	59
	60	#include <stdio.h>
9289f21b	61	#define USE_SOCKETS
36d16f8e BL	62	#include <openssl/objects.h>
	63	#include "ssl_locl.h"
	64
eb38b26d DSH	65	#ifdef OPENSSL_SYS_WIN32
	66	#include <sys/timeb.h>
	67	#endif
	68
	69	static void get_current_time(struct timeval *t);
42182852	70	const char dtls1_version_str[]="DTLSv1" OPENSSL_VERSION_PTEXT;
36d16f8e	71
f3b656b2	72	SSL3_ENC_METHOD DTLSv1_enc_data={
36d16f8e BL	73	dtls1_enc,
	74	tls1_mac,
	75	tls1_setup_key_block,
	76	tls1_generate_master_secret,
	77	tls1_change_cipher_state,
	78	tls1_final_finish_mac,
	79	TLS1_FINISH_MAC_LENGTH,
	80	tls1_cert_verify_mac,
	81	TLS_MD_CLIENT_FINISH_CONST,TLS_MD_CLIENT_FINISH_CONST_SIZE,
	82	TLS_MD_SERVER_FINISH_CONST,TLS_MD_SERVER_FINISH_CONST_SIZE,
	83	tls1_alert_code,
	84	};
	85
f3b656b2	86	long dtls1_default_timeout(void)
36d16f8e BL	87	{
	88	/* 2 hours, the 24 hours mentioned in the DTLSv1 spec
	89	* is way too long for http, the cache would over fill */
	90	return(60602);
	91	}
	92
36d16f8e BL	93	int dtls1_new(SSL *s)
	94	{
	95	DTLS1_STATE *d1;
	96
	97	if (!ssl3_new(s)) return(0);
	98	if ((d1=OPENSSL_malloc(sizeof *d1)) == NULL) return (0);
	99	memset(d1,0, sizeof *d1);
	100
	101	/* d1->handshake_epoch=0; */
188b0579	102
36d16f8e	103	d1->unprocessed_rcds.q=pqueue_new();
188b0579 RL	104	d1->processed_rcds.q=pqueue_new();
188b0579 RL	105	d1->buffered_messages = pqueue_new();
36d16f8e	106	d1->sent_messages=pqueue_new();
e5fa864f	107	d1->buffered_app_data.q=pqueue_new();
36d16f8e BL	108
	109	if ( s->server)
	110	{
	111	d1->cookie_len = sizeof(s->d1->cookie);
	112	}
	113
	114	if( ! d1->unprocessed_rcds.q \|\| ! d1->processed_rcds.q
e5fa864f	115	\|\| ! d1->buffered_messages \|\| ! d1->sent_messages \|\| ! d1->buffered_app_data.q)
36d16f8e BL	116	{
	117	if ( d1->unprocessed_rcds.q) pqueue_free(d1->unprocessed_rcds.q);
	118	if ( d1->processed_rcds.q) pqueue_free(d1->processed_rcds.q);
	119	if ( d1->buffered_messages) pqueue_free(d1->buffered_messages);
	120	if ( d1->sent_messages) pqueue_free(d1->sent_messages);
e5fa864f	121	if ( d1->buffered_app_data.q) pqueue_free(d1->buffered_app_data.q);
36d16f8e BL	122	OPENSSL_free(d1);
	123	return (0);
	124	}
	125
	126	s->d1=d1;
	127	s->method->ssl_clear(s);
	128	return(1);
	129	}
	130
	131	void dtls1_free(SSL *s)
	132	{
	133	pitem *item = NULL;
	134	hm_fragment *frag = NULL;
	135
	136	ssl3_free(s);
	137
	138	while( (item = pqueue_pop(s->d1->unprocessed_rcds.q)) != NULL)
	139	{
	140	OPENSSL_free(item->data);
	141	pitem_free(item);
	142	}
	143	pqueue_free(s->d1->unprocessed_rcds.q);
	144
	145	while( (item = pqueue_pop(s->d1->processed_rcds.q)) != NULL)
	146	{
	147	OPENSSL_free(item->data);
	148	pitem_free(item);
	149	}
	150	pqueue_free(s->d1->processed_rcds.q);
	151
	152	while( (item = pqueue_pop(s->d1->buffered_messages)) != NULL)
	153	{
	154	frag = (hm_fragment *)item->data;
	155	OPENSSL_free(frag->fragment);
	156	OPENSSL_free(frag);
	157	pitem_free(item);
	158	}
	159	pqueue_free(s->d1->buffered_messages);
	160
	161	while ( (item = pqueue_pop(s->d1->sent_messages)) != NULL)
	162	{
	163	frag = (hm_fragment *)item->data;
	164	OPENSSL_free(frag->fragment);
	165	OPENSSL_free(frag);
	166	pitem_free(item);
	167	}
	168	pqueue_free(s->d1->sent_messages);
	169
e5fa864f DSH	170	while ( (item = pqueue_pop(s->d1->buffered_app_data.q)) != NULL)
	171	{
	172	frag = (hm_fragment *)item->data;
	173	OPENSSL_free(frag->fragment);
	174	OPENSSL_free(frag);
	175	pitem_free(item);
	176	}
	177	pqueue_free(s->d1->buffered_app_data.q);
	178
36d16f8e BL	179	OPENSSL_free(s->d1);
	180	}
	181
	182	void dtls1_clear(SSL *s)
	183	{
	184	ssl3_clear(s);
8711efb4 DSH	185	if (s->options & SSL_OP_CISCO_ANYCONNECT)
	186	s->version=DTLS1_BAD_VER;
	187	else
	188	s->version=DTLS1_VERSION;
36d16f8e	189	}
5d58f1bb AP	190
	191	/*
	192	* As it's impossible to use stream ciphers in "datagram" mode, this
	193	* simple filter is designed to disengage them in DTLS. Unfortunately
	194	* there is no universal way to identify stream SSL_CIPHER, so we have
	195	* to explicitly list their SSL_* codes. Currently RC4 is the only one
	196	* available, but if new ones emerge, they will have to be added...
	197	*/
babb3798	198	const SSL_CIPHER *dtls1_get_cipher(unsigned int u)
5d58f1bb	199	{
babb3798	200	const SSL_CIPHER *ciph = ssl3_get_cipher(u);
5d58f1bb AP	201
	202	if (ciph != NULL)
	203	{
	204	if (ciph->algorithm_enc == SSL_RC4)
	205	return NULL;
	206	}
	207
	208	return ciph;
	209	}
eb38b26d DSH	210
	211	void dtls1_start_timer(SSL *s)
	212	{
	213	/* If timer is not set, initialize duration with 1 second */
	214	if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0)
	215	{
	216	s->d1->timeout_duration = 1;
	217	}
	218
	219	/* Set timeout to current time */
	220	get_current_time(&(s->d1->next_timeout));
	221
	222	/* Add duration to current time */
	223	s->d1->next_timeout.tv_sec += s->d1->timeout_duration;
	224	BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &(s->d1->next_timeout));
	225	}
	226
	227	struct timeval* dtls1_get_timeout(SSL s, struct timeval timeleft)
	228	{
	229	struct timeval timenow;
	230
	231	/* If no timeout is set, just return NULL */
	232	if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0)
	233	{
	234	return NULL;
	235	}
	236
	237	/* Get current time */
	238	get_current_time(&timenow);
	239
	240	/* If timer already expired, set remaining time to 0 */
	241	if (s->d1->next_timeout.tv_sec < timenow.tv_sec \|\|
	242	(s->d1->next_timeout.tv_sec == timenow.tv_sec &&
	243	s->d1->next_timeout.tv_usec <= timenow.tv_usec))
	244	{
	245	memset(timeleft, 0, sizeof(struct timeval));
	246	return timeleft;
	247	}
	248
	249	/* Calculate time left until timer expires */
	250	memcpy(timeleft, &(s->d1->next_timeout), sizeof(struct timeval));
	251	timeleft->tv_sec -= timenow.tv_sec;
	252	timeleft->tv_usec -= timenow.tv_usec;
	253	if (timeleft->tv_usec < 0)
	254	{
	255	timeleft->tv_sec--;
	256	timeleft->tv_usec += 1000000;
	257	}
	258
	259	return timeleft;
	260	}
	261
	262	int dtls1_is_timer_expired(SSL *s)
	263	{
	264	struct timeval timeleft;
	265
	266	/* Get time left until timeout, return false if no timer running */
	267	if (dtls1_get_timeout(s, &timeleft) == NULL)
	268	{
	269	return 0;
	270	}
	271
	272	/* Return false if timer is not expired yet */
	273	if (timeleft.tv_sec > 0 \|\| timeleft.tv_usec > 0)
274	{
275	return 0;
276	}
277
278	/* Timer expired, so return true */
279	return 1;
280	}
281
282	void dtls1_double_timeout(SSL *s)
283	{
284	s->d1->timeout_duration *= 2;
285	if (s->d1->timeout_duration > 60)
286	s->d1->timeout_duration = 60;
287	dtls1_start_timer(s);
288	}
289
290	void dtls1_stop_timer(SSL *s)
291	{
292	/* Reset everything */
293	memset(&(s->d1->next_timeout), 0, sizeof(struct timeval));
294	s->d1->timeout_duration = 1;
295	BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &(s->d1->next_timeout));
296	}
297
298	static void get_current_time(struct timeval *t)
299	{
300	#ifdef OPENSSL_SYS_WIN32
301	struct _timeb tb;
302	_ftime(&tb);
303	t->tv_sec = (long)tb.time;
304	t->tv_usec = (long)tb.millitm * 1000;
305	#elif defined(OPENSSL_SYS_VMS)
306	struct timeb tb;
307	ftime(&tb);
308	t->tv_sec = (long)tb.time;
309	t->tv_usec = (long)tb.millitm * 1000;
310	#else
311	gettimeofday(t, NULL);
312	#endif
313	}