libfreerdp-core: cleanup of tcp.c, secure.c, nego.c

9 files changed, 99 insertions, 85 deletions

diff --git a/libfreerdp-core/iso.c b/libfreerdp-core/iso.c
index 9cd8f73..f73341a 100644
--- a/libfreerdp-core/iso.c
+++ b/libfreerdp-core/iso.c
@@ -69,7 +69,7 @@ x224_send_dst_src_class(rdpIso * iso, uint8 code)
 {
 	STREAM s;
 
-	s = tcp_init(iso->tcp, 11);
+	s = network_stream_init(iso->net, 11);
 
 	tpkt_output_header(s, 11);
 
@@ -104,7 +104,7 @@ x224_send_connection_request(rdpIso * iso)
 		length += 8;
 
 	/* FIXME: Use x224_send_dst_src_class */
-	s = tcp_init(iso->tcp, length);
+	s = network_stream_init(iso->net, length);
 
 	tpkt_output_header(s, length);
 
@@ -268,7 +268,7 @@ STREAM
 iso_init(rdpIso * iso, int length)
 {
 	STREAM s;
-	s = tcp_init(iso->tcp, length + 7);
+	s = network_stream_init(iso->net, length + 7);
 	s_push_layer(s, iso_hdr, 7);
 	return s;
 }
@@ -278,7 +278,7 @@ STREAM
 iso_fp_init(rdpIso * iso, int length)
 {
 	STREAM s;
-	s = tcp_init(iso->tcp, length + 3);
+	s = network_stream_init(iso->net, length + 3);
 	s_push_layer(s, iso_hdr, 3);
 	return s;
 }
@@ -399,11 +399,7 @@ void
 iso_disconnect(rdpIso * iso)
 {
 	x224_send_dst_src_class(iso, X224_TPDU_DISCONNECT_REQUEST);
-#ifndef DISABLE_TLS
-	if (iso->net->tls)
-		tls_disconnect(iso->net->tls);
-#endif
-	tcp_disconnect(iso->tcp);
+	network_disconnect(iso->net);
 }
 
 rdpIso *
@@ -418,8 +414,7 @@ iso_new(struct rdp_network * net)
 		memset(self, 0, sizeof(rdpIso));
 		self->net = net;
 		self->mcs = net->mcs;
-		self->tcp = tcp_new(self);
-		self->nego = nego_new(self);
+		self->nego = net->nego;
 	}
 
 	return self;
@@ -430,9 +425,6 @@ iso_free(rdpIso * iso)
 {
 	if (iso != NULL)
 	{
-		tcp_free(iso->tcp);
-		if (iso->nego != NULL)
-			nego_free(iso->nego);
 		xfree(iso);
 	}
 }
diff --git a/libfreerdp-core/iso.h b/libfreerdp-core/iso.h
index ac52c8a..f9e3669 100644
--- a/libfreerdp-core/iso.h
+++ b/libfreerdp-core/iso.h
@@ -30,7 +30,6 @@ struct rdp_iso
 {
 	char* cookie;
 	struct _NEGO * nego;
-	struct rdp_tcp * tcp;
 	struct rdp_mcs * mcs;
 	struct rdp_network * net;
 };
diff --git a/libfreerdp-core/nego.c b/libfreerdp-core/nego.c
index 31698f9..0d960bd 100644
--- a/libfreerdp-core/nego.c
+++ b/libfreerdp-core/nego.c
@@ -69,7 +69,7 @@ int nego_tcp_connect(NEGO *nego)
 {
 	if (nego->tcp_connected == 0)
 	{
-		if (tcp_connect(nego->iso->tcp, nego->hostname, nego->port) == False)
+		if (tcp_connect(nego->net->tcp, nego->hostname, nego->port) == False)
 		{
 			nego->tcp_connected = 0;
 			return 0;
@@ -93,7 +93,7 @@ int nego_tcp_connect(NEGO *nego)
 int nego_tcp_disconnect(NEGO *nego)
 {
 	if (nego->tcp_connected)
-		tcp_disconnect(nego->iso->tcp);
+		tcp_disconnect(nego->net->tcp);
 
 	nego->tcp_connected = 0;
 	return 1;
@@ -110,8 +110,8 @@ void nego_attempt_nla(NEGO *nego)
 	nego->requested_protocols = PROTOCOL_NLA | PROTOCOL_TLS;
 
 	nego_tcp_connect(nego);
-	x224_send_connection_request(nego->iso);
-	tpkt_recv(nego->iso, &code, NULL);
+	x224_send_connection_request(nego->net->iso);
+	tpkt_recv(nego->net->iso, &code, NULL);
 
 	if (nego->state != NEGO_STATE_FINAL)
 	{
@@ -137,8 +137,8 @@ void nego_attempt_tls(NEGO *nego)
 	nego->requested_protocols = PROTOCOL_TLS;
 
 	nego_tcp_connect(nego);
-	x224_send_connection_request(nego->iso);
-	tpkt_recv(nego->iso, &code, NULL);
+	x224_send_connection_request(nego->net->iso);
+	tpkt_recv(nego->net->iso, &code, NULL);
 
 	if (nego->state != NEGO_STATE_FINAL)
 	{
@@ -162,9 +162,9 @@ void nego_attempt_rdp(NEGO *nego)
 	nego->requested_protocols = PROTOCOL_RDP;
 
 	nego_tcp_connect(nego);
-	x224_send_connection_request(nego->iso);
+	x224_send_connection_request(nego->net->iso);
 
-	if (tpkt_recv(nego->iso, &code, NULL) == NULL)
+	if (tpkt_recv(nego->net->iso, &code, NULL) == NULL)
 		nego->state = NEGO_STATE_FAIL;
 	else
 		nego->state = NEGO_STATE_FINAL;
@@ -278,14 +278,14 @@ void nego_process_negotiation_failure(NEGO *nego, STREAM s)
  * @return
  */
 
-NEGO* nego_new(struct rdp_iso * iso)
+NEGO* nego_new(struct rdp_network * net)
 {
 	NEGO *nego = (NEGO*) xmalloc(sizeof(NEGO));
 
 	if (nego != NULL)
 	{
 		memset(nego, '\0', sizeof(NEGO));
-		nego->iso = iso;
+		nego->net = net;
 		nego_init(nego);
 	}
 
diff --git a/libfreerdp-core/nego.h b/libfreerdp-core/nego.h
index e1a5bfc..a179e19 100644
--- a/libfreerdp-core/nego.h
+++ b/libfreerdp-core/nego.h
@@ -22,7 +22,7 @@
 
 #include "frdp.h"
 #include "stream.h"
-#include "iso.h"
+#include "network.h"
 
 enum _NEGO_STATE
 {
@@ -41,7 +41,7 @@ struct _NEGO
 	char *hostname;
 	NEGO_STATE state;
 	int tcp_connected;
-	struct rdp_iso * iso;
+	struct rdp_network * net;
 	uint32 selected_protocol;
 	uint32 requested_protocols;
 	uint8 enabled_protocols[3];
@@ -60,7 +60,7 @@ void nego_recv(NEGO *nego, STREAM s);
 void nego_process_negotiation_response(NEGO *nego, STREAM s);
 void nego_process_negotiation_failure(NEGO *nego, STREAM s);
 
-NEGO* nego_new(rdpIso * iso);
+NEGO* nego_new(struct rdp_network * net);
 void nego_init(NEGO *nego);
 void nego_free(NEGO *nego);
 
diff --git a/libfreerdp-core/network.c b/libfreerdp-core/network.c
index abb873c..389dc1b 100644
--- a/libfreerdp-core/network.c
+++ b/libfreerdp-core/network.c
@@ -21,6 +21,27 @@
 
 #include "network.h"
 
+/* Initialize and return STREAM.
+ * The stream will have room for at least min_size.
+ * The tcp layers out stream will be used. */
+
+STREAM
+network_stream_init(rdpNetwork * net, uint32 min_size)
+{
+	STREAM result = &(net->out);
+
+	if (min_size > result->size)
+	{
+		result->data = (uint8 *) xrealloc(result->data, min_size);
+		result->size = min_size;
+	}
+
+	result->p = result->data;
+	result->end = result->data + result->size;
+
+	return result;
+}
+
 #ifndef DISABLE_TLS
 
 /* verify SSL/TLS connection integrity. 2 checks are carried out. First make sure that the
@@ -177,6 +198,16 @@ network_connect(rdpNetwork * net, char* server, char* username, int port)
 }
 
 void
+network_disconnect(rdpNetwork * net)
+{
+#ifndef DISABLE_TLS
+	if (net->tls)
+		tls_disconnect(net->tls);
+#endif
+	tcp_disconnect(net->tcp);
+}
+
+void
 network_send(rdpNetwork * net, STREAM s)
 {
 #ifndef DISABLE_TLS
@@ -260,9 +291,13 @@ network_new(rdpRdp * rdp)
 	{
 		memset(self, 0, sizeof(rdpNetwork));
 		self->rdp = rdp;
+		self->sec = rdp->sec;
 		self->mcs = mcs_new(self);
+		self->tcp = tcp_new(self);
+		self->nego = nego_new(self);
 		self->iso = iso_new(self);
 		self->license = license_new(self);
+		self->sec->net = self;
 
 		self->in.size = 4096;
 		self->in.data = (uint8 *) xmalloc(self->in.size);
@@ -281,6 +316,22 @@ network_free(rdpNetwork * net)
 	{
 		xfree(net->in.data);
 		xfree(net->out.data);
+
+		if (net->tcp != NULL)
+			tcp_free(net->tcp);
+
+		if (net->iso != NULL)
+			iso_free(net->iso);
+
+		if (net->mcs != NULL)
+			mcs_free(net->mcs);
+
+		if (net->nego != NULL)
+			nego_free(net->nego);
+
+		if (net->license != NULL)
+			license_free(net->license);
+
 		xfree(net);
 	}
 }
diff --git a/libfreerdp-core/network.h b/libfreerdp-core/network.h
index 52fbf7c..24891f0 100644
--- a/libfreerdp-core/network.h
+++ b/libfreerdp-core/network.h
@@ -40,6 +40,7 @@ struct rdp_network
 	char* username;
 	struct stream in;
 	struct stream out;
+	struct _NEGO * nego;
 	struct rdp_rdp * rdp;
 	struct rdp_tcp * tcp;
 	struct rdp_sec * sec;
@@ -51,18 +52,20 @@ struct rdp_network
 };
 typedef struct rdp_network rdpNetwork;
 
+STREAM
+network_stream_init(rdpNetwork * net, uint32 min_size);
 RD_BOOL
 network_connect(rdpNetwork * net, char* server, char* username, int port);
+void
+network_disconnect(rdpNetwork * net);
 
 void
 network_send(rdpNetwork * net, STREAM s);
-
 STREAM
 network_recv(rdpNetwork * net, STREAM s, uint32 length);
 
 rdpNetwork*
 network_new(rdpRdp * rdp);
-
 void
 network_free(rdpNetwork * net);
 
diff --git a/libfreerdp-core/rdp.c b/libfreerdp-core/rdp.c
index e8c9949..1ee0d23 100644
--- a/libfreerdp-core/rdp.c
+++ b/libfreerdp-core/rdp.c
@@ -1750,16 +1750,12 @@ rdp_new(struct rdp_set *settings, struct rdp_inst *inst)
 		self->buffer_size = 2048;
 		self->buffer = xmalloc(self->buffer_size);
 		memset(self->buffer, 0, self->buffer_size);
-		self->net = network_new(self);
 		self->sec = sec_new(self);
+		self->net = network_new(self);
 		self->orders = orders_new(self);
 		self->pcache = pcache_new(self);
 		self->cache = cache_new(self);
 		self->ext = ext_new(self);
-
-		self->net->rdp = self;
-		self->net->sec = self->sec;
-		self->net->tcp = self->net->iso->tcp;
 	}
 	return self;
 }
diff --git a/libfreerdp-core/tcp.c b/libfreerdp-core/tcp.c
index 2f6ea62..cbb9e21 100644
--- a/libfreerdp-core/tcp.c
+++ b/libfreerdp-core/tcp.c
@@ -80,6 +80,7 @@ tcp_socket_ok(int sck)
 			return True;
 		}
 	}
+
 	return False;
 }
 
@@ -93,13 +94,16 @@ tcp_can_send(int sck, int millis)
 
 	time.tv_sec = millis / 1000;
 	time.tv_usec = (millis * 1000) % 1000000;
+
 	FD_ZERO(&wfds);
 	FD_SET(sck, &wfds);
 	sel_count = select(sck + 1, 0, &wfds, 0, &time);
+
 	if (sel_count > 0)
 	{
 		return tcp_socket_ok(sck);
 	}
+
 	return False;
 }
 
@@ -113,33 +117,17 @@ tcp_can_recv(int sck, int millis)
 
 	time.tv_sec = millis / 1000;
 	time.tv_usec = (millis * 1000) % 1000000;
+
 	FD_ZERO(&rfds);
 	FD_SET(sck, &rfds);
 	sel_count = select(sck + 1, &rfds, 0, 0, &time);
+
 	if (sel_count > 0)
 	{
 		return tcp_socket_ok(sck);
 	}
-	return False;
-}
-
-/* Initialize and return STREAM.
- * The stream will have room for at least minsize.
- * The tcp layers out stream will be used. */
-STREAM
-tcp_init(rdpTcp * tcp, uint32 minsize)
-{
-	STREAM result = &(tcp->out);
 
-	if (minsize > result->size)
-	{
-		result->data = (uint8 *) xrealloc(result->data, minsize);
-		result->size = minsize;
-	}
-
-	result->p = result->data;
-	result->end = result->data + result->size;
-	return result;
+	return False;
 }
 
 void
@@ -163,7 +151,7 @@ tcp_write(rdpTcp * tcp, STREAM s)
 				}
 				else
 				{
-					ui_error(tcp->iso->net->rdp->inst, "send: %s\n", TCP_STRERROR);
+					ui_error(tcp->net->rdp->inst, "send: %s\n", TCP_STRERROR);
 					return;
 				}
 			}
@@ -177,7 +165,7 @@ tcp_read(rdpTcp * tcp, char* b, int length)
 {
 	int rcvd = 0;
 
-	if (!ui_select(tcp->iso->mcs->net->sec->rdp->inst, tcp->sock))
+	if (!ui_select(tcp->net->sec->rdp->inst, tcp->sock))
 		return -1; /* user quit */
 
 	rcvd = recv(tcp->sock, b, length, 0);
@@ -191,13 +179,13 @@ tcp_read(rdpTcp * tcp, char* b, int length)
 		}
 		else
 		{
-			ui_error(tcp->iso->mcs->net->rdp->inst, "recv: %s\n", TCP_STRERROR);
+			ui_error(tcp->net->rdp->inst, "recv: %s\n", TCP_STRERROR);
 			return -1;
 		}
 	}
 	else if (rcvd == 0)
 	{
-		ui_error(tcp->iso->mcs->net->rdp->inst, "Connection closed\n");
+		ui_error(tcp->net->rdp->inst, "Connection closed\n");
 			return -1;
 	}
 
@@ -228,7 +216,7 @@ tcp_connect(rdpTcp * tcp, char * server, int port)
 
 	if ((n = getaddrinfo(server, tcp_port_rdp_s, &hints, &res)))
 	{
-		ui_error(tcp->iso->mcs->net->sec->rdp->inst, "getaddrinfo: %s\n", gai_strerror(n));
+		ui_error(tcp->net->rdp->inst, "getaddrinfo: %s\n", gai_strerror(n));
 		return False;
 	}
 
@@ -250,7 +238,7 @@ tcp_connect(rdpTcp * tcp, char * server, int port)
 
 	if (sock == -1)
 	{
-		ui_error(tcp->iso->mcs->net->sec->rdp->inst, "%s: unable to connect\n", server);
+		ui_error(tcp->net->rdp->inst, "%s: unable to connect\n", server);
 		return False;
 	}
 
@@ -267,13 +255,13 @@ tcp_connect(rdpTcp * tcp, char * server, int port)
 	}
 	else if ((servaddr.sin_addr.s_addr = inet_addr(server)) == INADDR_NONE)
 	{
-		ui_error(tcp->iso->mcs->sec->rdp->inst, "%s: unable to resolve host\n", server);
+		ui_error(tcp->net->rdp->inst, "%s: unable to resolve host\n", server);
 		return False;
 	}
 
 	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
 	{
-		ui_error(tcp->iso->mcs->sec->rdp->inst, "socket: %s\n", TCP_STRERROR);
+		ui_error(tcp->net->rdp->inst, "socket: %s\n", TCP_STRERROR);
 		return False;
 	}
 
@@ -282,7 +270,7 @@ tcp_connect(rdpTcp * tcp, char * server, int port)
 
 	if (connect(sock, (struct sockaddr *) &servaddr, sizeof(struct sockaddr)) < 0)
 	{
-		ui_error(tcp->iso->mcs->sec->rdp->inst, "connect: %s\n", TCP_STRERROR);
+		ui_error(tcp->net->rdp->inst, "connect: %s\n", TCP_STRERROR);
 		TCP_CLOSE(sock);
 		return False;
 	}
@@ -360,24 +348,19 @@ tcp_get_address(rdpTcp * tcp)
 }
 
 rdpTcp *
-tcp_new(struct rdp_iso * iso)
+tcp_new(struct rdp_network * net)
 {
 	rdpTcp * self;
 
 	self = (rdpTcp *) xmalloc(sizeof(rdpTcp));
+
 	if (self != NULL)
 	{
 		memset(self, 0, sizeof(rdpTcp));
-		self->iso = iso;
-
-		self->in.size = 4096;
-		self->in.data = (uint8 *) xmalloc(self->in.size);
-
-		self->out.size = 4096;
-		self->out.data = (uint8 *) xmalloc(self->out.size);
-
+		self->net = net;
 		self->sock = -1;
 	}
+
 	return self;
 }
 
@@ -386,8 +369,6 @@ tcp_free(rdpTcp * tcp)
 {
 	if (tcp != NULL)
 	{
-		xfree(tcp->in.data);
-		xfree(tcp->out.data);
 		xfree(tcp);
 	}
 }
diff --git a/libfreerdp-core/tcp.h b/libfreerdp-core/tcp.h
index 1af3cf7..b06954c 100644
--- a/libfreerdp-core/tcp.h
+++ b/libfreerdp-core/tcp.h
@@ -27,11 +27,9 @@
 struct rdp_tcp
 {
 	int sock;
-	struct rdp_iso * iso;
-	int tcp_port_rdp;
 	char ipaddr[32];
-	struct stream in;
-	struct stream out;
+	int tcp_port_rdp;
+	struct rdp_network * net;
 #ifdef _WIN32
 	WSAEVENT wsa_event;
 #endif
@@ -47,12 +45,6 @@ RD_BOOL
 tcp_can_send(int sck, int millis);
 RD_BOOL
 tcp_can_recv(int sck, int millis);
-STREAM
-tcp_init(rdpTcp * tcp, uint32 minsize);
-void
-tcp_send(rdpTcp * tcp, STREAM s);
-STREAM
-tcp_recv(rdpTcp * tcp, STREAM s, uint32 length);
 RD_BOOL
 tcp_connect(rdpTcp * tcp, char * server, int port);
 void
@@ -60,7 +52,7 @@ tcp_disconnect(rdpTcp * tcp);
 char *
 tcp_get_address(rdpTcp * tcp);
 rdpTcp *
-tcp_new(struct rdp_iso * iso);
+tcp_new(struct rdp_network * net);
 void
 tcp_free(rdpTcp * tcp);