n=ssl23_read_bytes(s,11);  if (n != 11) return(n);
int ssl23_get_client_hello(SSL *s)	{	char buf_space[10];	char *buf= &(buf_space[0]);	unsigned char *p,*d,*dd;	unsigned int i;	unsigned int csl,sil,cl;	int n=0,j,tls1=0;	int type=0,use_sslv2_strong=0;	int v[2];	if (s->state ==	SSL23_ST_SR_CLNT_HELLO_A)		{		/* read the initial header */		v[0]=v[1]=0;		if (!ssl3_setup_buffers(s)) goto err;		n=ssl23_read_bytes(s,10);		if (n != 10) return(n); /* n == -1 || n == 0 */		p=s->packet;		memcpy(buf,p,n);		if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO))			{			/*			 * SSLv2 header			 */			if ((p[3] == 0x00) && (p[4] == 0x02))				{				v[0]=p[3]; v[1]=p[4];				/* SSLv2 */				if (!(s->options & SSL_OP_NO_SSLv2))					type=1;				}			else if (p[3] == SSL3_VERSION_MAJOR)				{				v[0]=p[3]; v[1]=p[4];				/* SSLv3/TLSv1 */				if (p[4] >= TLS1_VERSION_MINOR)					{					if (!(s->options & SSL_OP_NO_TLSv1))						{						tls1=1;						/* type=2; */ /* done later to survive restarts */						s->state=SSL23_ST_SR_CLNT_HELLO_B;						}					else if (!(s->options & SSL_OP_NO_SSLv3))						{						/* type=2; */						s->state=SSL23_ST_SR_CLNT_HELLO_B;						}					else if (!(s->options & SSL_OP_NO_SSLv2))						{						type=1;						}					}				else if (!(s->options & SSL_OP_NO_SSLv3))					{					/* type=2; */					s->state=SSL23_ST_SR_CLNT_HELLO_B;					}				else if (!(s->options & SSL_OP_NO_SSLv2))					type=1;				if (s->options & SSL_OP_NON_EXPORT_FIRST)					/* Not only utterly confusing, but broken					 * ('fractured programming'?) -- the details					 * of this block nearly make it work					 * as intended in this environment, but on one					 * of the fine points (w.r.t. restarts) it fails.					 * The obvious fix would be even more devastating					 * to program structure; if you want the functionality,					 * throw this away and implement it in a way					 * that makes sense */					{					STACK_OF(SSL_CIPHER) *sk;					SSL_CIPHER *c;					int ne2,ne3;					j=((p[0]&0x7f)<<8)|p[1];					if (j > (1024*4))						{						SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);						goto err;						}					n=ssl23_read_bytes(s,j+2);					if (n <= 0) return(n);					p=s->packet;					if ((buf=Malloc(n)) == NULL)						{						SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,ERR_R_MALLOC_FAILURE);						goto err;						}					memcpy(buf,p,n);					p+=5;					n2s(p,csl);					p+=4;					sk=ssl_bytes_to_cipher_list(						s,p,csl,NULL);					if (sk != NULL)						{						ne2=ne3=0;						for (j=0; j<sk_SSL_CIPHER_num(sk); j++)							{							c=sk_SSL_CIPHER_value(sk,j);							if (!SSL_C_IS_EXPORT(c))								{								if ((c->id>>24L) == 2L)									ne2=1;								else									ne3=1;								}							}						if (ne2 && !ne3)							{							type=1;							use_sslv2_strong=1;							goto next_bit;							}						}					}				}			}		else if ((p[0] == SSL3_RT_HANDSHAKE) &&			 (p[1] == SSL3_VERSION_MAJOR) &&			 (p[5] == SSL3_MT_CLIENT_HELLO) &&			 (p[9] == p[1]))			{			/*			 * SSLv3 or tls1 header			 */						/* we must look at client_version inside the client hello: */			n=ssl23_read_bytes(s,11);			/* restarts are no problem here, stay in initial state */			if (n != 11)				return(n); /* n == -1 || n == 0 */			v[0]=p[9]; v[1]=p[10];			if (p[2] >= TLS1_VERSION_MINOR)				{				if (!(s->options & SSL_OP_NO_TLSv1))					{					type=3;					tls1=1;					}				else if (!(s->options & SSL_OP_NO_SSLv3))					type=3;				}			else if (!(s->options & SSL_OP_NO_SSLv3))				type=3;			}		else if ((strncmp("GET ", (char *)p,4) == 0) ||			 (strncmp("POST ",(char *)p,5) == 0) ||			 (strncmp("HEAD ",(char *)p,5) == 0) ||			 (strncmp("PUT ", (char *)p,4) == 0))			{			SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST);			goto err;			}		else if (strncmp("CONNECT",(char *)p,7) == 0)			{			SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTPS_PROXY_REQUEST);			goto err;			}		}next_bit:	if (s->state == SSL23_ST_SR_CLNT_HELLO_B)		{		/* we have a SSLv3/TLSv1 in a SSLv2 header		 * (other cases skip this state)* */		type=2;		p=s->packet;		v[0] = p[3];		v[1] = p[4];		n=((p[0]&0x7f)<<8)|p[1];		if (n > (1024*4))			{			SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);			goto err;			}		j=ssl23_read_bytes(s,n+2);		if (j <= 0) return(j);		ssl3_finish_mac(s,&(s->packet[2]),s->packet_length-2);		p=s->packet;		p+=5;		n2s(p,csl);		n2s(p,sil);		n2s(p,cl);		d=(unsigned char *)s->init_buf->data;		if ((csl+sil+cl+11) != s->packet_length)			{			SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_LENGTH_MISMATCH);			goto err;			}		*(d++)=SSL3_VERSION_MAJOR;		if (tls1)			*(d++)=TLS1_VERSION_MINOR;		else			*(d++)=SSL3_VERSION_MINOR;		/* lets populate the random area */		/* get the chalenge_length */		i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl;		memset(d,0,SSL3_RANDOM_SIZE);		memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i);		d+=SSL3_RANDOM_SIZE;		/* no session-id reuse */		*(d++)=0;		/* ciphers */		j=0;		dd=d;		d+=2;		for (i=0; i<csl; i+=3)			{			if (p[i] != 0) continue;			*(d++)=p[i+1];			*(d++)=p[i+2];			j+=2;			}		s2n(j,dd);		/* COMPRESSION */		*(d++)=1;		*(d++)=0;				i=(d-(unsigned char *)s->init_buf->data);		/* get the data reused from the init_buf */		s->s3->tmp.reuse_message=1;		s->s3->tmp.message_type=SSL3_MT_CLIENT_HELLO;		s->s3->tmp.message_size=i;		}	/* imaginary new state (for program structure): */	/* s->state = SSL23_SR_CLNT_HELLO_C */	if (type == 1)		{		/* we are talking sslv2 */		/* we need to clean up the SSLv3/TLSv1 setup and put in the		 * sslv2 stuff. */		if (s->s2 == NULL)			{			if (!ssl2_new(s))				goto err;			}		else			ssl2_clear(s);		if (s->s3 != NULL) ssl3_free(s);		if (!BUF_MEM_grow(s->init_buf,			SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))			{			goto err;			}		s->state=SSL2_ST_GET_CLIENT_HELLO_A;		if ((s->options & SSL_OP_MSIE_SSLV2_RSA_PADDING) ||			use_sslv2_strong)			s->s2->ssl2_rollback=0;		else			s->s2->ssl2_rollback=1;		/* setup the n bytes we have read so we get them from		 * the sslv2 buffer */		s->rstate=SSL_ST_READ_HEADER;		s->packet_length=n;		s->packet= &(s->s2->rbuf[0]);		memcpy(s->packet,buf,n);		s->s2->rbuf_left=n;		s->s2->rbuf_offs=0;		s->method=SSLv2_server_method();		s->handshake_func=s->method->ssl_accept;		}	if ((type == 2) || (type == 3))		{		/* we have SSLv3/TLSv1 (type 2: SSL2 style, type 3: SSL3/TLS style) */		if (!ssl_init_wbio_buffer(s,1)) goto err;		/* we are in this state */		s->state=SSL3_ST_SR_CLNT_HELLO_A;		if (type == 3)			{			/* put the 'n' bytes we have read into the input buffer			 * for SSLv3 */			s->rstate=SSL_ST_READ_HEADER;			s->packet_length=n;			s->packet= &(s->s3->rbuf.buf[0]);			memcpy(s->packet,buf,n);			s->s3->rbuf.left=n;			s->s3->rbuf.offset=0;			}		else			{			s->packet_length=0;			s->s3->rbuf.left=0;			s->s3->rbuf.offset=0;			}		if (tls1)			{			s->version=TLS1_VERSION;			s->method=TLSv1_server_method();			}		else			{			s->version=SSL3_VERSION;			s->method=SSLv3_server_method();			}#if 0 /* ssl3_get_client_hello does this */		s->client_version=(v[0]<<8)|v[1];#endif		s->handshake_func=s->method->ssl_accept;		}		if ((type < 1) || (type > 3))		{		/* bad, very bad */		SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNKNOWN_PROTOCOL);		goto err;		}	s->init_num=0;	if (buf != buf_space) Free(buf);	s->first_packet=1;	return(SSL_accept(s));err:	if (buf != buf_space) Free(buf);	return(-1);	}