自学教程：C++ tls_new函数代码示例

BOOL transport_tsg_connect(rdpTransport* transport, const char* hostname, UINT16 port){	rdpTsg* tsg = tsg_new(transport);	tsg->transport = transport;	transport->tsg = tsg;	transport->SplitInputOutput = TRUE;	if (transport->TlsIn == NULL)		transport->TlsIn = tls_new(transport->settings);	transport->TlsIn->sockfd = transport->TcpIn->sockfd;	if (transport->TlsOut == NULL)		transport->TlsOut = tls_new(transport->settings);	transport->TlsOut->sockfd = transport->TcpOut->sockfd;	if (tls_connect(transport->TlsIn) != TRUE)		return FALSE;	if (tls_connect(transport->TlsOut) != TRUE)		return FALSE;	if (!tsg_connect(tsg, hostname, port))		return FALSE;	return TRUE;}

boolean transport_tsg_connect(rdpTransport* transport, const char* hostname, uint16 port){	rdpTsg* tsg = tsg_new(transport);	tsg->transport = transport;	transport->tsg = tsg;	if (transport->tls_in == NULL)		transport->tls_in = tls_new(transport->settings);	transport->tls_in->sockfd = transport->tcp_in->sockfd;	if (transport->tls_out == NULL)		transport->tls_out = tls_new(transport->settings);	transport->tls_out->sockfd = transport->tcp_out->sockfd;	if (tls_connect(transport->tls_in) != true)		return false;	if (tls_connect(transport->tls_out) != true)		return false;	if (!tsg_connect(tsg, hostname, port))		return false;	return true;}

BOOL transport_connect_tls(rdpTransport* transport){	if (transport->layer == TRANSPORT_LAYER_TSG)	{		transport->TsgTls = tls_new(transport->settings);		transport->TsgTls->methods = BIO_s_tsg();		transport->TsgTls->tsg = (void*) transport->tsg;		transport->layer = TRANSPORT_LAYER_TSG_TLS;		if (tls_connect(transport->TsgTls) != TRUE)		{			if (!connectErrorCode)				connectErrorCode = TLSCONNECTERROR;			tls_free(transport->TsgTls);			transport->TsgTls = NULL;			return FALSE;		}		return TRUE;	}	if (transport->TlsIn == NULL)		transport->TlsIn = tls_new(transport->settings);	if (transport->TlsOut == NULL)		transport->TlsOut = transport->TlsIn;	transport->layer = TRANSPORT_LAYER_TLS;	transport->TlsIn->sockfd = transport->TcpIn->sockfd;	if (tls_connect(transport->TlsIn) != TRUE)	{		if (!connectErrorCode)			connectErrorCode = TLSCONNECTERROR;		tls_free(transport->TlsIn);		if (transport->TlsIn == transport->TlsOut)			transport->TlsIn = transport->TlsOut = NULL;		else			transport->TlsIn = NULL;		return FALSE;	}	return TRUE;}

static int _handle_proceedtls_default(xmpp_conn_t * const conn,			      xmpp_stanza_t * const stanza,			      void * const userdata){    char *name;    name = xmpp_stanza_get_name(stanza);    xmpp_debug(conn->ctx, "xmpp",	"handle proceedtls called for %s", name);    if (strcmp(name, "proceed") == 0) {        xmpp_debug(conn->ctx, "xmpp", "proceeding with TLS");	conn->tls = tls_new(conn->ctx, conn->sock);	if (!tls_start(conn->tls))	{	    xmpp_debug(conn->ctx, "xmpp", "Couldn't start TLS! error %d", tls_error(conn->tls));	    tls_free(conn->tls);	    conn->tls = NULL;	    conn->tls_failed = 1;	    /* failed tls spoils the connection, so disconnect */	    xmpp_disconnect(conn);	}	else	{            conn->secured = 1;            conn_prepare_reset(conn, auth_handle_open);	    conn_open_stream(conn);	}    }    return 0;}

int conn_tls_start(xmpp_conn_t * const conn){    int rc;    if (conn->tls_disabled) {        conn->tls = NULL;        rc = XMPP_EINVOP;    } else {        conn->tls = tls_new(conn);        rc = conn->tls == NULL ? XMPP_EMEM : 0;    }    if (conn->tls != NULL) {        if (tls_start(conn->tls)) {            conn->secured = 1;        } else {            rc = XMPP_EINT;            conn->error = tls_error(conn->tls);            tls_free(conn->tls);            conn->tls = NULL;            conn->tls_failed = 1;        }    }    if (rc != 0) {        xmpp_debug(conn->ctx, "conn", "Couldn't start TLS! "                   "error %d tls_error %d", rc, conn->error);    }    return rc;}

int conn_tls_start(xmpp_conn_t * const conn){    int rc;    if (conn->tls_disabled) {        conn->tls = NULL;        rc = -ENOSYS;    } else {        conn->tls = tls_new(conn->ctx, conn->sock);        rc = conn->tls == NULL ? -ENOMEM : 0;    }    if (conn->tls != NULL) {        if (tls_start(conn->tls)) {            conn->secured = 1;            conn_prepare_reset(conn, auth_handle_open);        } else {            rc = tls_error(conn->tls);            conn->error = rc;            tls_free(conn->tls);            conn->tls = NULL;            conn->tls_failed = 1;        }    }    if (rc != 0)        xmpp_debug(conn->ctx, "conn", "Couldn't start TLS! error %d", rc);    return rc;}

boolean transport_connect_nla(rdpTransport* transport){	if (transport->tls == NULL)		transport->tls = tls_new();	transport->layer = TRANSPORT_LAYER_TLS;	transport->tls->sockfd = transport->tcp->sockfd;	if (tls_connect(transport->tls) != True)		return False;	/* Network Level Authentication */	if (transport->settings->authentication != True)		return True;	if (transport->credssp == NULL)		transport->credssp = credssp_new(transport);	if (credssp_authenticate(transport->credssp) < 0)	{		printf("Authentication failure, check credentials./n"			"If credentials are valid, the NTLMSSP implementation may be to blame./n");		credssp_free(transport->credssp);		return False;	}	credssp_free(transport->credssp);	return True;}

BOOL transport_connect_tls(rdpTransport* transport){	if (transport->layer == TRANSPORT_LAYER_TSG)		return TRUE;	if (transport->TlsIn == NULL)		transport->TlsIn = tls_new(transport->settings);	if (transport->TlsOut == NULL)		transport->TlsOut = transport->TlsIn;	transport->layer = TRANSPORT_LAYER_TLS;	transport->TlsIn->sockfd = transport->TcpIn->sockfd;	if (tls_connect(transport->TlsIn) != TRUE)	{		if (!connectErrorCode)			connectErrorCode = TLSCONNECTERROR;		tls_free(transport->TlsIn);		if (transport->TlsIn == transport->TlsOut)			transport->TlsIn = transport->TlsOut = NULL;		else			transport->TlsIn = NULL;		return FALSE;	}	return TRUE;}

static void _tcp_accept(uv_stream_t *master, int status, bool tls){	if (status != 0) {		return;	}	uv_stream_t *client = handle_alloc(master->loop);	if (!client) {		return;	}	memset(client, 0, sizeof(*client));	io_create(master->loop, (uv_handle_t *)client, SOCK_STREAM);	if (uv_accept(master, client) != 0) {		uv_close((uv_handle_t *)client, io_free);		return;	}	/* Set deadlines for TCP connection and start reading.	 * It will re-check every half of a request time limit if the connection	 * is idle and should be terminated, this is an educated guess. */	struct session *session = client->data;	session->has_tls = tls;	if (tls && !session->tls_ctx) {		session->tls_ctx = tls_new(master->loop->data);	}	uv_timer_t *timer = &session->timeout;	uv_timer_init(master->loop, timer);	timer->data = client;	uv_timer_start(timer, tcp_timeout_trigger, KR_CONN_RTT_MAX/2, KR_CONN_RTT_MAX/2);	io_start_read((uv_handle_t *)client);}

BOOL transport_connect_tls(rdpTransport* transport){	int tlsStatus;	rdpTls* tls = NULL;	rdpContext* context = transport->context;	rdpSettings* settings = transport->settings;	if (!(tls = tls_new(settings)))		return FALSE;	transport->tls = tls;	if (transport->GatewayEnabled)		transport->layer = TRANSPORT_LAYER_TSG_TLS;	else		transport->layer = TRANSPORT_LAYER_TLS;	tls->hostname = settings->ServerHostname;	tls->port = settings->ServerPort;	if (tls->port == 0)		tls->port = 3389;	tls->isGatewayTransport = FALSE;	tlsStatus = tls_connect(tls, transport->frontBio);	if (tlsStatus < 1)	{		if (tlsStatus < 0)		{			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_TLS_CONNECT_FAILED);		}		else		{			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_CONNECT_CANCELLED);		}		return FALSE;	}	transport->frontBio = tls->bio;	BIO_callback_ctrl(tls->bio, BIO_CTRL_SET_CALLBACK, (bio_info_cb*) transport_ssl_cb);	SSL_set_app_data(tls->ssl, transport);	if (!transport->frontBio)	{		WLog_ERR(TAG, "unable to prepend a filtering TLS bio");		return FALSE;	}	return TRUE;}

struct tls *tls_client(void){	struct tls *ctx;	if ((ctx = tls_new()) == NULL)		return (NULL);	ctx->flags |= TLS_CLIENT;	return (ctx);}

struct tls *tls_server(void){	struct tls *ctx;	if ((ctx = tls_new()) == NULL)		return (NULL);	ctx->flags |= TLS_SERVER;	return (ctx);}

struct tls *tls_server_conn(struct tls *ctx){	struct tls *conn_ctx;	if ((conn_ctx = tls_new()) == NULL)		return (NULL);	conn_ctx->flags |= TLS_SERVER_CONN;	return (conn_ctx);}

tbool transport_connect_tls(rdpTransport* transport){    if (transport->tls == NULL)        transport->tls = tls_new(transport->settings);    transport->layer = TRANSPORT_LAYER_TLS;    transport->tls->sockfd = transport->tcp->sockfd;    if (tls_connect(transport->tls) == false)        return false;    return true;}

BOOL transport_tsg_connect(rdpTransport* transport, const char* hostname, UINT16 port){	rdpTsg* tsg = tsg_new(transport);	tsg->transport = transport;	transport->tsg = tsg;	transport->SplitInputOutput = TRUE;	if (!transport->TlsIn)		transport->TlsIn = tls_new(transport->settings);	transport->TlsIn->sockfd = transport->TcpIn->sockfd;	transport->TlsIn->hostname = transport->settings->GatewayHostname;	transport->TlsIn->port = transport->settings->GatewayPort;	if (transport->TlsIn->port == 0)		transport->TlsIn->port = 443;	if (!transport->TlsOut)		transport->TlsOut = tls_new(transport->settings);	transport->TlsOut->sockfd = transport->TcpOut->sockfd;	transport->TlsOut->hostname = transport->settings->GatewayHostname;	transport->TlsOut->port = transport->settings->GatewayPort;	if (transport->TlsOut->port == 0)		transport->TlsOut->port = 443;	if (!tls_connect(transport->TlsIn))		return FALSE;	if (!tls_connect(transport->TlsOut))		return FALSE;	if (!tsg_connect(tsg, hostname, port))		return FALSE;	return TRUE;}

boolean transport_connect_tls(rdpTransport* transport){	if (transport->tls == NULL)		transport->tls = tls_new();	transport->layer = TRANSPORT_LAYER_TLS;	transport->tls->sockfd = transport->tcp->sockfd;	if (tls_connect(transport->tls) != True)		return False;	return True;}

boolean transport_accept_tls(rdpTransport* transport){	if (transport->tls == NULL)		transport->tls = tls_new();	transport->layer = TRANSPORT_LAYER_TLS;	transport->tls->sockfd = transport->tcp->sockfd;	if (tls_accept(transport->tls, transport->settings->cert_file, transport->settings->privatekey_file) != True)		return False;	return True;}

BOOL transport_accept_nla(rdpTransport* transport){	freerdp* instance;	rdpSettings* settings;	settings = transport->settings;	instance = (freerdp*) settings->instance;	if (!transport->TlsIn)		transport->TlsIn = tls_new(transport->settings);	if (!transport->TlsOut)		transport->TlsOut = transport->TlsIn;	transport->layer = TRANSPORT_LAYER_TLS;	if (!tls_accept(transport->TlsIn, transport->TcpIn->bufferedBio, settings->CertificateFile, settings->PrivateKeyFile))		return FALSE;	transport->frontBio = transport->TlsIn->bio;	/* Network Level Authentication */	if (!settings->Authentication)		return TRUE;	if (!transport->credssp)	{		transport->credssp = credssp_new(instance, transport, settings);		transport_set_nla_mode(transport, TRUE);	}	if (credssp_authenticate(transport->credssp) < 0)	{		fprintf(stderr, "client authentication failure/n");		transport_set_nla_mode(transport, FALSE);		credssp_free(transport->credssp);		transport->credssp = NULL;		tls_set_alert_code(transport->TlsIn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DESCRIPTION_ACCESS_DENIED);		return FALSE;	}	/* don't free credssp module yet, we need to copy the credentials from it first */	transport_set_nla_mode(transport, FALSE);	return TRUE;}

BOOL transport_accept_tls(rdpTransport* transport){	rdpSettings* settings = transport->settings;	if (!transport->tls)		transport->tls = tls_new(transport->settings);	transport->layer = TRANSPORT_LAYER_TLS;	if (!tls_accept(transport->tls, transport->frontBio, settings))		return FALSE;	transport->frontBio = transport->tls->bio;	return TRUE;}

boolean transport_connect_nla(rdpTransport* transport){	freerdp* instance;	rdpSettings* settings;	if (transport->tls == NULL)		transport->tls = tls_new(transport->settings);	transport->layer = TRANSPORT_LAYER_TLS;	transport->tls->sockfd = transport->tcp->sockfd;	if (tls_connect(transport->tls) != true)	{		if (!connectErrorCode)                    			connectErrorCode = TLSCONNECTERROR;                      		tls_free(transport->tls);		transport->tls = NULL;		return false;	}	/* Network Level Authentication */	if (transport->settings->authentication != true)		return true;	settings = transport->settings;	instance = (freerdp*) settings->instance;	if (transport->credssp == NULL)		transport->credssp = credssp_new(instance, transport->tls, settings);	if (credssp_authenticate(transport->credssp) < 0)	{		if (!connectErrorCode)                    			connectErrorCode = AUTHENTICATIONERROR;                      		printf("Authentication failure, check credentials./n"			"If credentials are valid, the NTLMSSP implementation may be to blame./n");		credssp_free(transport->credssp);		return false;	}	credssp_free(transport->credssp);	return true;}

BOOL transport_accept_tls(rdpTransport* transport){	if (transport->TlsIn == NULL)		transport->TlsIn = tls_new(transport->settings);	if (transport->TlsOut == NULL)		transport->TlsOut = transport->TlsIn;	transport->layer = TRANSPORT_LAYER_TLS;	transport->TlsIn->sockfd = transport->TcpIn->sockfd;	if (tls_accept(transport->TlsIn, transport->settings->CertificateFile, transport->settings->PrivateKeyFile) != TRUE)		return FALSE;	return TRUE;}

BOOL transport_accept_tls(rdpTransport* transport){	if (!transport->TlsIn)		transport->TlsIn = tls_new(transport->settings);	if (!transport->TlsOut)		transport->TlsOut = transport->TlsIn;	transport->layer = TRANSPORT_LAYER_TLS;	if (!tls_accept(transport->TlsIn, transport->TcpIn->bufferedBio, transport->settings->CertificateFile, transport->settings->PrivateKeyFile))		return FALSE;	transport->frontBio = transport->TlsIn->bio;	return TRUE;}

BOOL transport_accept_nla(rdpTransport* transport){	rdpSettings* settings = transport->settings;	freerdp* instance = (freerdp*) settings->instance;	if (!transport->tls)		transport->tls = tls_new(transport->settings);	transport->layer = TRANSPORT_LAYER_TLS;	if (!tls_accept(transport->tls, transport->frontBio, settings))		return FALSE;	transport->frontBio = transport->tls->bio;	/* Network Level Authentication */	if (!settings->Authentication)		return TRUE;	if (!transport->nla)	{		transport->nla = nla_new(instance, transport, settings);		transport_set_nla_mode(transport, TRUE);	}	if (nla_authenticate(transport->nla) < 0)	{		WLog_Print(transport->log, WLOG_ERROR, "client authentication failure");		transport_set_nla_mode(transport, FALSE);		nla_free(transport->nla);		transport->nla = NULL;		tls_set_alert_code(transport->tls, TLS_ALERT_LEVEL_FATAL,		                   TLS_ALERT_DESCRIPTION_ACCESS_DENIED);		tls_send_alert(transport->tls);		return FALSE;	}	/* don't free nla module yet, we need to copy the credentials from it first */	transport_set_nla_mode(transport, FALSE);	return TRUE;}

boolean transport_accept_nla(rdpTransport* transport){	if (transport->tls == NULL)		transport->tls = tls_new();	transport->layer = TRANSPORT_LAYER_TLS;	transport->tls->sockfd = transport->tcp->sockfd;	if (tls_accept(transport->tls, transport->settings->cert_file, transport->settings->privatekey_file) != True)		return False;	/* Network Level Authentication */	if (transport->settings->authentication != True)		return True;	/* Blocking here until NLA is complete */	return True;}

boolean transport_connect_tls(rdpTransport* transport){	if (transport->tls == NULL)		transport->tls = tls_new(transport->settings);	transport->layer = TRANSPORT_LAYER_TLS;	transport->tls->sockfd = transport->tcp->sockfd;	if (tls_connect(transport->tls) != true)	{		if (!connectErrorCode)                    			connectErrorCode = TLSCONNECTERROR;                      		tls_free(transport->tls);		transport->tls = NULL;		return false;	}	return true;}

BOOL transport_accept_nla(rdpTransport* transport){	freerdp* instance;	rdpSettings* settings;	if (transport->TlsIn == NULL)		transport->TlsIn = tls_new(transport->settings);	if (transport->TlsOut == NULL)		transport->TlsOut = transport->TlsIn;	transport->layer = TRANSPORT_LAYER_TLS;	transport->TlsIn->sockfd = transport->TcpIn->sockfd;	if (tls_accept(transport->TlsIn, transport->settings->CertificateFile, transport->settings->PrivateKeyFile) != TRUE)		return FALSE;	/* Network Level Authentication */	if (transport->settings->Authentication != TRUE)		return TRUE;	settings = transport->settings;	instance = (freerdp*) settings->instance;	if (transport->credssp == NULL)		transport->credssp = credssp_new(instance, transport, settings);	if (credssp_authenticate(transport->credssp) < 0)	{		fprintf(stderr, "client authentication failure/n");		credssp_free(transport->credssp);		transport->credssp = NULL;		return FALSE;	}	/* don't free credssp module yet, we need to copy the credentials from it first */	return TRUE;}

boolean transport_accept_nla(rdpTransport* transport){	freerdp* instance;	rdpSettings* settings;	if (transport->tls == NULL)		transport->tls = tls_new(transport->settings);	transport->layer = TRANSPORT_LAYER_TLS;	transport->tls->sockfd = transport->tcp->sockfd;	if (tls_accept(transport->tls, transport->settings->cert_file, transport->settings->privatekey_file) != true)		return false;	/* Network Level Authentication */	if (transport->settings->authentication != true)		return true;	settings = transport->settings;	instance = (freerdp*) settings->instance;	if (transport->credssp == NULL)		transport->credssp = credssp_new(instance, transport->tls, settings);	if (credssp_authenticate(transport->credssp) < 0)	{		printf("client authentication failure/n");		credssp_free(transport->credssp);		return false;	}	credssp_free(transport->credssp);	return true;}

BOOL transport_tsg_connect(rdpTransport* transport, const char* hostname, UINT16 port){	rdpTsg* tsg;	int tls_status;	freerdp* instance;	rdpContext* context;	rdpSettings *settings = transport->settings;	instance = (freerdp*) transport->settings->instance;	context = instance->context;	tsg = tsg_new(transport);	if (!tsg)		return FALSE;	tsg->transport = transport;	transport->tsg = tsg;	transport->SplitInputOutput = TRUE;	if (!transport->TlsIn)	{		transport->TlsIn = tls_new(settings);		if (!transport->TlsIn)			return FALSE;	}	if (!transport->TlsOut)	{		transport->TlsOut = tls_new(settings);		if (!transport->TlsOut)			return FALSE;	}	/* put a decent default value for gateway port */	if (!settings->GatewayPort)		settings->GatewayPort = 443;	transport->TlsIn->hostname = transport->TlsOut->hostname = settings->GatewayHostname;	transport->TlsIn->port = transport->TlsOut->port = settings->GatewayPort;	transport->TlsIn->isGatewayTransport = TRUE;	tls_status = tls_connect(transport->TlsIn, transport->TcpIn->bufferedBio);	if (tls_status < 1)	{		if (tls_status < 0)		{			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_TLS_CONNECT_FAILED);		}		else		{			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_CONNECT_CANCELLED);		}		return FALSE;	}	transport->TlsOut->isGatewayTransport = TRUE;	tls_status = tls_connect(transport->TlsOut, transport->TcpOut->bufferedBio);	if (tls_status < 1)	{		if (tls_status < 0)		{			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_TLS_CONNECT_FAILED);		}		else		{			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_CONNECT_CANCELLED);		}		return FALSE;	}	if (!tsg_connect(tsg, hostname, port))		return FALSE;	transport->frontBio = BIO_new(BIO_s_tsg());	transport->frontBio->ptr = tsg;	return TRUE;}

BOOL transport_connect_tls(rdpTransport* transport){	rdpSettings *settings = transport->settings;	rdpTls *targetTls;	BIO *targetBio;	int tls_status;	freerdp* instance;	rdpContext* context;	instance = (freerdp*) transport->settings->instance;	context = instance->context;	if (transport->layer == TRANSPORT_LAYER_TSG)	{		transport->TsgTls = tls_new(transport->settings);		transport->layer = TRANSPORT_LAYER_TSG_TLS;		targetTls = transport->TsgTls;		targetBio = transport->frontBio;	}	else	{		if (!transport->TlsIn)			transport->TlsIn = tls_new(settings);		if (!transport->TlsOut)			transport->TlsOut = transport->TlsIn;		targetTls = transport->TlsIn;		targetBio = transport->TcpIn->bufferedBio;		transport->layer = TRANSPORT_LAYER_TLS;	}	targetTls->hostname = settings->ServerHostname;	targetTls->port = settings->ServerPort;	if (targetTls->port == 0)		targetTls->port = 3389;	targetTls->isGatewayTransport = FALSE;	tls_status = tls_connect(targetTls, targetBio);	if (tls_status < 1)	{		if (tls_status < 0)		{			if (!connectErrorCode)				connectErrorCode = TLSCONNECTERROR;			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_TLS_CONNECT_FAILED);		}		else		{			if (!freerdp_get_last_error(context))				freerdp_set_last_error(context, FREERDP_ERROR_CONNECT_CANCELLED);		}		return FALSE;	}	transport->frontBio = targetTls->bio;	if (!transport->frontBio)	{		fprintf(stderr, "%s: unable to prepend a filtering TLS bio", __FUNCTION__);		return FALSE;	}	return TRUE;}

rdpRdg* rdg_new(rdpTransport* transport){	rdpRdg* rdg;	RPC_CSTR stringUuid;	char bracedUuid[40];	RPC_STATUS rpcStatus;	assert(transport != NULL);	rdg = (rdpRdg*) calloc(1, sizeof(rdpRdg));	if (rdg)	{		rdg->state = RDG_CLIENT_STATE_INITIAL;		rdg->context = transport->context;		rdg->settings = rdg->context->settings;		rdg->extAuth = HTTP_EXTENDED_AUTH_NONE;		if (rdg->settings->GatewayAccessToken)			rdg->extAuth = HTTP_EXTENDED_AUTH_PAA;		UuidCreate(&rdg->guid);		rpcStatus = UuidToStringA(&rdg->guid, &stringUuid);		if (rpcStatus == RPC_S_OUT_OF_MEMORY)			goto rdg_alloc_error;		sprintf_s(bracedUuid, sizeof(bracedUuid), "{%s}", stringUuid);		RpcStringFreeA(&stringUuid);		rdg->tlsOut = tls_new(rdg->settings);		if (!rdg->tlsOut)			goto rdg_alloc_error;		rdg->tlsIn = tls_new(rdg->settings);		if (!rdg->tlsIn)			goto rdg_alloc_error;		rdg->http = http_context_new();		if (!rdg->http)			goto rdg_alloc_error;		http_context_set_uri(rdg->http, "/remoteDesktopGateway/");		http_context_set_accept(rdg->http, "*/*");		http_context_set_cache_control(rdg->http, "no-cache");		http_context_set_pragma(rdg->http, "no-cache");		http_context_set_connection(rdg->http, "Keep-Alive");		http_context_set_user_agent(rdg->http, "MS-RDGateway/1.0");		http_context_set_host(rdg->http, rdg->settings->GatewayHostname);		http_context_set_rdg_connection_id(rdg->http, bracedUuid);		if (!rdg->http->URI || !rdg->http->Accept || !rdg->http->CacheControl ||		    !rdg->http->Pragma || !rdg->http->Connection || !rdg->http->UserAgent		    || !rdg->http->Host || !rdg->http->RdgConnectionId)		{			goto rdg_alloc_error;		}		if (rdg->extAuth != HTTP_EXTENDED_AUTH_NONE)		{			switch (rdg->extAuth)			{				case HTTP_EXTENDED_AUTH_PAA:					http_context_set_rdg_auth_scheme(rdg->http, "PAA");					if (!rdg->http->RdgAuthScheme)						goto rdg_alloc_error;					break;				default:					WLog_DBG(TAG, "RDG extended authentication method %d not supported", rdg->extAuth);			}		}		rdg->frontBio = BIO_new(BIO_s_rdg());		if (!rdg->frontBio)			goto rdg_alloc_error;		BIO_set_data(rdg->frontBio, rdg);		InitializeCriticalSection(&rdg->writeSection);	}	return rdg;rdg_alloc_error:	rdg_free(rdg);	return NULL;}