SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);
SSLerr(SSL_F_DO_DTLS1_WRITE, ERR_R_INTERNAL_ERROR);
int do_dtls1_write(SSL *s, int type, const unsigned char *buf,	unsigned int len, int create_empty_fragment)	{	unsigned char *p,*pseq;	int i,mac_size,clear=0;	int prefix_len = 0;	SSL3_RECORD *wr;	SSL3_BUFFER *wb;	SSL_SESSION *sess;	int bs;	/* first check if there is a SSL3_BUFFER still being written	 * out.  This will happen with non blocking IO */	if (s->s3->wbuf.left != 0)		{		OPENSSL_assert(0); /* XDTLS:  want to see if we ever get here */		return(ssl3_write_pending(s,type,buf,len));		}	/* If we have an alert to send, lets send it */	if (s->s3->alert_dispatch)		{		i=s->method->ssl_dispatch_alert(s);		if (i <= 0)			return(i);		/* if it went, fall through and send more stuff */		}	if (len == 0 && !create_empty_fragment)		return 0;	wr= &(s->s3->wrec);	wb= &(s->s3->wbuf);	sess=s->session;	if (	(sess == NULL) ||		(s->enc_write_ctx == NULL) ||		(s->write_hash == NULL))		clear=1;	if (clear)		mac_size=0;	else		mac_size=EVP_MD_size(s->write_hash);	/* DTLS implements explicit IV, so no need for empty fragments */#if 0	/* 'create_empty_fragment' is true only when this function calls itself */	if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done		&& SSL_version(s) != DTLS1_VERSION)		{		/* countermeasure against known-IV weakness in CBC ciphersuites		 * (see http://www.openssl.org/~bodo/tls-cbc.txt) 		 */		if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA)			{			/* recursive function call with 'create_empty_fragment' set;			 * this prepares and buffers the data for an empty fragment			 * (these 'prefix_len' bytes are sent out later			 * together with the actual payload) */			prefix_len = s->method->do_ssl_write(s, type, buf, 0, 1);			if (prefix_len <= 0)				goto err;			if (s->s3->wbuf.len < (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE)				{				/* insufficient space */				SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);				goto err;				}			}				s->s3->empty_fragment_done = 1;		}#endif	p = wb->buf + prefix_len;	/* write the header */	*(p++)=type&0xff;	wr->type=type;	*(p++)=(s->version>>8);	*(p++)=s->version&0xff;	/* field where we are to write out packet epoch, seq num and len */	pseq=p; 	p+=10;	/* lets setup the record stuff. */	/* Make space for the explicit IV in case of CBC.	 * (this is a bit of a boundary violation, but what the heck).	 */	if ( s->enc_write_ctx && 		(EVP_CIPHER_mode( s->enc_write_ctx->cipher ) & EVP_CIPH_CBC_MODE))		bs = EVP_CIPHER_block_size(s->enc_write_ctx->cipher);	else		bs = 0;	wr->data=p + bs;  /* make room for IV in case of CBC */	wr->length=(int)len;	wr->input=(unsigned char *)buf;	/* we now 'read' from wr->input, wr->length bytes into	 * wr->data */	/* first we compress */	if (s->compress != NULL)		{		if (!ssl3_do_compress(s))			{			SSLerr(SSL_F_DO_SSL3_WRITE,SSL_R_COMPRESSION_FAILURE);			goto err;			}		}	else		{		memcpy(wr->data,wr->input,wr->length);		wr->input=wr->data;		}	/* we should still have the output to wr->data and the input	 * from wr->input.  Length should be wr->length.	 * wr->data still points in the wb->buf */	if (mac_size != 0)		{		s->method->ssl3_enc->mac(s,&(p[wr->length + bs]),1);		wr->length+=mac_size;		}	/* this is true regardless of mac size */	wr->input=p;	wr->data=p;	/* ssl3_enc can only have an error on read */	wr->length += bs;  /* bs != 0 in case of CBC.  The enc fn provides						* the randomness */ 	s->method->ssl3_enc->enc(s,1);	/* record length after mac and block padding *//*	if (type == SSL3_RT_APPLICATION_DATA ||	(type == SSL3_RT_ALERT && ! SSL_in_init(s))) */		/* there's only one epoch between handshake and app data */		s2n(s->d1->w_epoch, pseq);	/* XDTLS: ?? *//*	else	s2n(s->d1->handshake_epoch, pseq); */	l2n6(bytes_to_long_long(s->s3->write_sequence), pseq);	s2n(wr->length,pseq);	/* we should now have	 * wr->data pointing to the encrypted data, which is	 * wr->length long */	wr->type=type; /* not needed but helps for debugging */	wr->length+=DTLS1_RT_HEADER_LENGTH;#if 0  /* this is now done at the message layer */	/* buffer the record, making it easy to handle retransmits */	if ( type == SSL3_RT_HANDSHAKE || type == SSL3_RT_CHANGE_CIPHER_SPEC)		dtls1_buffer_record(s, wr->data, wr->length, 			*((unsigned long long *)&(s->s3->write_sequence[0])));#endif	ssl3_record_sequence_update(&(s->s3->write_sequence[0]));	if (create_empty_fragment)		{		/* we are in a recursive call;		 * just return the length, don't write out anything here		 */		return wr->length;		}	/* now let's set up wb */	wb->left = prefix_len + wr->length;	wb->offset = 0;	/* memorize arguments so that ssl3_write_pending can detect bad write retries later */	s->s3->wpend_tot=len;	s->s3->wpend_buf=buf;	s->s3->wpend_type=type;	s->s3->wpend_ret=len;	/* we now just need to write the buffer */	return ssl3_write_pending(s,type,buf,len);err:	return -1;	}