freerdp: make use of stream macros to access members

channels/rail/client/rail_orders.c

@@ -125,7 +125,7 @@ void rail_send_pdu(rdpRailOrder* rail_order, wStream* s, UINT16 orderType)
 	DEBUG_RAIL("Sending %s PDU, length:%d",
 			RAIL_ORDER_TYPE_STRINGS[((orderType & 0xF0) >> 3) + (orderType & 0x0F)], orderLength);
 
-	rail_send_channel_data(rail_order->plugin, s->buffer, orderLength);
+	rail_send_channel_data(rail_order->plugin, Stream_Buffer(s), orderLength);
 }
 
 void rail_write_high_contrast(wStream* s, HIGH_CONTRAST* high_contrast)

libfreerdp/core/connection.c

@@ -287,6 +287,7 @@ static BOOL rdp_client_establish_keys(rdpRdp* rdp)
 
 	Stream_Write_UINT32(s, length);
 	Stream_Write(s, crypt_client_random, length);
+	Stream_SealLength(s);
 
 	if (transport_write(rdp->mcs->transport, s) < 0)
 	{

libfreerdp/core/fastpath.c

@@ -331,7 +331,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
 
 	if (compressionFlags & PACKET_COMPRESSED)
 	{
-		if (decompress_rdp(rdp->mppc_dec, s->pointer, size, compressionFlags, &roff, &rlen))
+		if (decompress_rdp(rdp->mppc_dec, Stream_Pointer(s), size, compressionFlags, &roff, &rlen))
 		{
 			size = rlen;
 			buffer = rdp->mppc_dec->history_buf + roff;
@@ -760,6 +760,7 @@ BOOL fastpath_send_multiple_input_pdu(rdpFastPath* fastpath, wStream* s, int iNu
 	rdp->sec_flags = 0;
 
 	Stream_SetPosition(s, length);
+	Stream_SealLength(s);
 
 	if (transport_write(fastpath->rdp->transport, s) < 0)
 		return FALSE;
@@ -846,7 +847,7 @@ BOOL fastpath_send_update_pdu(rdpFastPath* fastpath, BYTE updateCode, wStream* s
 
 		if (try_comp)
 		{
-			if (compress_rdp(rdp->mppc_enc, ls->pointer + header_bytes, dlen))
+			if (compress_rdp(rdp->mppc_enc, Stream_Pointer(ls) + header_bytes, dlen))
 			{
 				if (rdp->mppc_enc->flags & PACKET_COMPRESSED)
 				{
@@ -918,6 +919,8 @@ BOOL fastpath_send_update_pdu(rdpFastPath* fastpath, BYTE updateCode, wStream* s
 			security_encrypt(ptr_to_crypt, bytes_to_crypt, rdp);
 		}
 
+		Stream_SealLength(s);
+
 		if (transport_write(fastpath->rdp->transport, update) < 0)
 		{
 			result = FALSE;

libfreerdp/core/freerdp.c

@@ -136,19 +136,19 @@ BOOL freerdp_connect(freerdp* instance)
 			{
 				pcap_get_next_record_header(update->pcap_rfx, &record);
 
-				s->buffer = (BYTE*) realloc(s->buffer, record.length);
+				Stream_Buffer(s) = (BYTE*) realloc(Stream_Buffer(s), record.length);
-				record.data = s->buffer;
+				record.data = Stream_Buffer(s);
-				s->capacity = record.length;
+				Stream_Capacity(s) = record.length;
 
 				pcap_get_next_record_content(update->pcap_rfx, &record);
 				Stream_SetPosition(s, 0);
 
 				update->BeginPaint(update->context);
-				update_recv_surfcmds(update, s->capacity, s);
+				update_recv_surfcmds(update, Stream_Capacity(s), s);
 				update->EndPaint(update->context);
 			}
 
-			free(s->buffer);
+			free(Stream_Buffer(s));
 			return TRUE;
 		}
 	}

libfreerdp/core/gateway/rpc_client.c

@@ -415,7 +415,7 @@ RPC_PDU* rpc_recv_dequeue_pdu(rdpRpc* rpc)
 		if (pdu)
 		{
 			fprintf(stderr, "Receiving PDU (length: %d, CallId: %d)\n", pdu->s->length, pdu->CallId);
-			winpr_HexDump(pdu->s->buffer, pdu->s->length);
+			winpr_HexDump(Stream_Buffer(pdu->s), Stream_Length(pdu->s));
 			fprintf(stderr, "\n");
 		}
 #endif

libfreerdp/core/gcc.c

@@ -399,7 +399,7 @@ BOOL gcc_read_server_data_blocks(wStream* s, rdpSettings* settings, int length)
 
 	while (offset < length)
 	{
-		holdp = s->pointer;
+		holdp = Stream_Pointer(s);
 
 		if (!gcc_read_user_data_header(s, &type, &blockLength))
 		{
@@ -438,7 +438,7 @@ BOOL gcc_read_server_data_blocks(wStream* s, rdpSettings* settings, int length)
 				break;
 		}
 		offset += blockLength;
-		s->pointer = holdp + blockLength;
+		Stream_Pointer(s) = holdp + blockLength;
 	}
 
 	return TRUE;

libfreerdp/core/license.c

@@ -203,10 +203,11 @@ BOOL license_send(rdpLicense* license, wStream* s, BYTE type)
 
 #ifdef WITH_DEBUG_LICENSE
 	fprintf(stderr, "Sending %s Packet, length %d\n", LICENSE_MESSAGE_STRINGS[type & 0x1F], wMsgSize);
-	winpr_HexDump(s->pointer - 4, wMsgSize);
+	winpr_HexDump(Stream_Pointer(s) - 4, wMsgSize);
 #endif
 
 	Stream_SetPosition(s, length);
+	Stream_SealLength(s);
 
 	if (transport_write(license->rdp->transport, s) < 0)
 		return FALSE;

libfreerdp/core/mcs.c

@@ -479,6 +479,7 @@ BOOL mcs_send_connect_initial(rdpMcs* mcs)
 	tpkt_write_header(s, length);
 	tpdu_write_data(s);
 	Stream_SetPointer(s, em);
+	Stream_SealLength(s);
 
 	status = transport_write(mcs->transport, s);
 
@@ -558,6 +559,7 @@ BOOL mcs_send_connect_response(rdpMcs* mcs)
 	tpkt_write_header(s, length);
 	tpdu_write_data(s);
 	Stream_SetPointer(s, em);
+	Stream_SealLength(s);
 
 	ret = transport_write(mcs->transport, s);
 
@@ -600,6 +602,8 @@ BOOL mcs_send_erect_domain_request(rdpMcs* mcs)
 	per_write_integer(s, 0); /* subHeight (INTEGER) */
 	per_write_integer(s, 0); /* subInterval (INTEGER) */
 
+	Stream_SealLength(s);
+
 	if (transport_write(mcs->transport, s) < 0)
 		return FALSE;
 
@@ -636,6 +640,8 @@ BOOL mcs_send_attach_user_request(rdpMcs* mcs)
 
 	mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserRequest, length, 0);
 
+	Stream_SealLength(s);
+
 	if (transport_write(mcs->transport, s) < 0)
 		return FALSE;
 
@@ -680,6 +686,8 @@ BOOL mcs_send_attach_user_confirm(rdpMcs* mcs)
 	mcs->user_id = MCS_GLOBAL_CHANNEL_ID + 1 + mcs->transport->settings->ChannelCount;
 	per_write_integer16(s, mcs->user_id, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
 
+	Stream_SealLength(s);
+
 	transport_write(mcs->transport, s);
 
 	return TRUE;
@@ -724,6 +732,8 @@ BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channel_id)
 	per_write_integer16(s, mcs->user_id, MCS_BASE_CHANNEL_ID);
 	per_write_integer16(s, channel_id, 0);
 
+	Stream_SealLength(s);
+
 	if (transport_write(mcs->transport, s) < 0)
 		return FALSE;
 
@@ -776,6 +786,8 @@ BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channel_id)
 	per_write_integer16(s, channel_id, 0); /* requested (ChannelId) */
 	per_write_integer16(s, channel_id, 0); /* channelId */
 
+	Stream_SealLength(s);
+
 	transport_write(mcs->transport, s);
 
 	return TRUE;

libfreerdp/core/message.c

@@ -154,7 +154,7 @@ static void update_message_SurfaceCommand(rdpContext* context, wStream* s)
 
 	wParam = (wStream*) malloc(sizeof(wStream));
 
-	wParam->capacity = s->capacity;
+	wParam->capacity = Stream_Capacity(s);
 	wParam->buffer = (BYTE*) malloc(wParam->capacity);
 	wParam->pointer = wParam->buffer;
 
@@ -1005,8 +1005,7 @@ int update_message_process_update_class(rdpUpdateProxy* proxy, wMessage* msg, in
 			IFCALL(proxy->SurfaceCommand, msg->context, (wStream*) msg->wParam);
 			{
 				wStream* s = (wStream*) msg->wParam;
-				free(s->buffer);
+				Stream_Free(s, TRUE);
-				free(s);
 			}
 			break;
 

libfreerdp/core/nego.c

@@ -289,6 +289,8 @@ BOOL nego_send_preconnection_pdu(rdpNego* nego)
 		free(wszPCB);
 	}
 
+	Stream_SealLength(s);
+
 	if (transport_write(nego->transport, s) < 0)
 		return FALSE;
 
@@ -688,6 +690,8 @@ BOOL nego_send_negotiation_request(rdpNego* nego)
 	tpdu_write_connection_request(s, length - 5);
 	Stream_SetPointer(s, em);
 
+	Stream_SealLength(s);
+
 	if (transport_write(nego->transport, s) < 0)
 		return FALSE;
 
@@ -843,6 +847,8 @@ BOOL nego_send_negotiation_response(rdpNego* nego)
 	tpdu_write_connection_confirm(s, length - 5);
 	Stream_SetPointer(s, em);
 
+	Stream_SealLength(s);
+
 	if (transport_write(nego->transport, s) < 0)
 		return FALSE;
 

libfreerdp/core/nla.c

@@ -817,7 +817,7 @@ void credssp_read_ts_password_creds(rdpCredssp* credssp, wStream* s)
 	ber_read_octet_string_tag(s, &length);
 	credssp->identity.DomainLength = (UINT32) length;
 	credssp->identity.Domain = (UINT16*) malloc(length);
-	CopyMemory(credssp->identity.Domain, s->pointer, credssp->identity.DomainLength);
+	CopyMemory(credssp->identity.Domain, Stream_Pointer(s), credssp->identity.DomainLength);
 	Stream_Seek(s, credssp->identity.DomainLength);
 	credssp->identity.DomainLength /= 2;
 
@@ -826,7 +826,7 @@ void credssp_read_ts_password_creds(rdpCredssp* credssp, wStream* s)
 	ber_read_octet_string_tag(s, &length);
 	credssp->identity.UserLength = (UINT32) length;
 	credssp->identity.User = (UINT16*) malloc(length);
-	CopyMemory(credssp->identity.User, s->pointer, credssp->identity.UserLength);
+	CopyMemory(credssp->identity.User, Stream_Pointer(s), credssp->identity.UserLength);
 	Stream_Seek(s, credssp->identity.UserLength);
 	credssp->identity.UserLength /= 2;
 
@@ -835,7 +835,7 @@ void credssp_read_ts_password_creds(rdpCredssp* credssp, wStream* s)
 	ber_read_octet_string_tag(s, &length);
 	credssp->identity.PasswordLength = (UINT32) length;
 	credssp->identity.Password = (UINT16*) malloc(length);
-	CopyMemory(credssp->identity.Password, s->pointer, credssp->identity.PasswordLength);
+	CopyMemory(credssp->identity.Password, Stream_Pointer(s), credssp->identity.PasswordLength);
 	Stream_Seek(s, credssp->identity.PasswordLength);
 	credssp->identity.PasswordLength /= 2;
 
@@ -1125,7 +1125,10 @@ void credssp_send(rdpCredssp* credssp)
 		ber_write_octet_string(s, credssp->pubKeyAuth.pvBuffer, credssp->pubKeyAuth.cbBuffer);
 	}
 
+	Stream_SealLength(s);
+
 	transport_write(credssp->transport, s);
+
 	Stream_Free(s, TRUE);
 }
 

libfreerdp/core/orders.c

@@ -1397,7 +1397,7 @@ BOOL update_read_glyph_index_order(wStream* s, ORDER_INFO* orderInfo, GLYPH_INDE
 		if (Stream_GetRemainingLength(s) < glyph_index->cbData)
 			return FALSE;
 
-		memcpy(glyph_index->data, s->pointer, glyph_index->cbData);
+		memcpy(glyph_index->data, Stream_Pointer(s), glyph_index->cbData);
 		Stream_Seek(s, glyph_index->cbData);
 	}
 
@@ -1497,7 +1497,7 @@ BOOL update_read_fast_index_order(wStream* s, ORDER_INFO* orderInfo, FAST_INDEX_
 
 		if (Stream_GetRemainingLength(s) < fast_index->cbData)
 			return FALSE;
-		memcpy(fast_index->data, s->pointer, fast_index->cbData);
+		memcpy(fast_index->data, Stream_Pointer(s), fast_index->cbData);
 		Stream_Seek(s, fast_index->cbData);
 	}
 	return TRUE;
@@ -1538,8 +1538,8 @@ BOOL update_read_fast_glyph_order(wStream* s, ORDER_INFO* orderInfo, FAST_GLYPH_
 		if (Stream_GetRemainingLength(s) < fast_glyph->cbData)
 			return FALSE;
 
-		memcpy(fast_glyph->data, s->pointer, fast_glyph->cbData);
+		memcpy(fast_glyph->data, Stream_Pointer(s), fast_glyph->cbData);
-		phold = s->pointer;
+		phold = Stream_Pointer(s);
 
 		if (!Stream_SafeSeek(s, 1))
 			return FALSE;
@@ -1566,7 +1566,7 @@ BOOL update_read_fast_glyph_order(wStream* s, ORDER_INFO* orderInfo, FAST_GLYPH_
 			Stream_Read(s, glyph->aj, glyph->cb);
 		}
 
-		s->pointer = phold + fast_glyph->cbData;
+		Stream_Pointer(s) = phold + fast_glyph->cbData;
 	}
 	return TRUE;
 }
@@ -2200,7 +2200,7 @@ BOOL update_decompress_brush(wStream* s, BYTE* output, BYTE bpp)
 	BYTE* palette;
 	int bytesPerPixel;
 
-	palette = s->pointer + 16;
+	palette = Stream_Pointer(s) + 16;
 	bytesPerPixel = ((bpp + 1) / 8);
 
 	if (Stream_GetRemainingLength(s) < 16) // 64 / 4
@@ -3044,7 +3044,7 @@ BOOL update_recv_secondary_order(rdpUpdate* update, wStream* s, BYTE flags)
 	Stream_Read_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
 	Stream_Read_UINT8(s, orderType); /* orderType (1 byte) */
 
-	next = s->pointer + ((INT16) orderLength) + 7;
+	next = Stream_Pointer(s) + ((INT16) orderLength) + 7;
 
 #ifdef WITH_DEBUG_ORDERS
 	if (orderType < SECONDARY_DRAWING_ORDER_COUNT)
@@ -3116,7 +3116,8 @@ BOOL update_recv_secondary_order(rdpUpdate* update, wStream* s, BYTE flags)
 			break;
 	}
 
-	s->pointer = next;
+	Stream_Pointer(s) = next;
+
 	return TRUE;
 }
 

libfreerdp/core/rdp.c

@@ -332,9 +332,9 @@ static UINT32 rdp_security_stream_out(rdpRdp* rdp, wStream* s, int length)
 		{
 			if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
 			{
-				data = s->pointer + 12;
+				data = Stream_Pointer(s) + 12;
 
-				length = length - (data - s->buffer);
+				length = length - (data - Stream_Buffer(s));
 				Stream_Write_UINT16(s, 0x10); /* length */
 				Stream_Write_UINT8(s, 0x1); /* TSFIPS_VERSION 1*/
 
@@ -348,20 +348,22 @@ static UINT32 rdp_security_stream_out(rdpRdp* rdp, wStream* s, int length)
 
 				Stream_Write_UINT8(s, pad);
 
-				security_hmac_signature(data, length, s->pointer, rdp);
+				security_hmac_signature(data, length, Stream_Pointer(s), rdp);
 				Stream_Seek(s, 8);
 				security_fips_encrypt(data, length + pad, rdp);
 			}
 			else
 			{
-				data = s->pointer + 8;
+				data = Stream_Pointer(s) + 8;
-				length = length - (data - s->buffer);
+				length = length - (data - Stream_Buffer(s));
+
 				if (sec_flags & SEC_SECURE_CHECKSUM)
-					security_salted_mac_signature(rdp, data, length, TRUE, s->pointer);
+					security_salted_mac_signature(rdp, data, length, TRUE, Stream_Pointer(s));
 				else
-					security_mac_signature(rdp, data, length, s->pointer);
+					security_mac_signature(rdp, data, length, Stream_Pointer(s));
+
 				Stream_Seek(s, 8);
-				security_encrypt(s->pointer, length, rdp);
+				security_encrypt(Stream_Pointer(s), length, rdp);
 			}
 		}
 
@@ -413,13 +415,14 @@ BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channel_id)
 	rdp_write_header(rdp, s, length, channel_id);
 
 	sec_bytes = rdp_get_sec_bytes(rdp);
-	sec_hold = s->pointer;
+	sec_hold = Stream_Pointer(s);
 	Stream_Seek(s, sec_bytes);
 
-	s->pointer = sec_hold;
+	Stream_Pointer(s) = sec_hold;
 	length += rdp_security_stream_out(rdp, s, length);
 
 	Stream_SetPosition(s, length);
+	Stream_SealLength(s);
 
 	if (transport_write(rdp->transport, s) < 0)
 		return FALSE;
@@ -439,15 +442,17 @@ BOOL rdp_send_pdu(rdpRdp* rdp, wStream* s, UINT16 type, UINT16 channel_id)
 	rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID);
 
 	sec_bytes = rdp_get_sec_bytes(rdp);
-	sec_hold = s->pointer;
+	sec_hold = Stream_Pointer(s);
 	Stream_Seek(s, sec_bytes);
 
 	rdp_write_share_control_header(s, length - sec_bytes, type, channel_id);
 
-	s->pointer = sec_hold;
+	Stream_Pointer(s) = sec_hold;
 	length += rdp_security_stream_out(rdp, s, length);
 
 	Stream_SetPosition(s, length);
+	Stream_SealLength(s);
+
 	if (transport_write(rdp->transport, s) < 0)
 		return FALSE;
 
@@ -466,16 +471,18 @@ BOOL rdp_send_data_pdu(rdpRdp* rdp, wStream* s, BYTE type, UINT16 channel_id)
 	rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID);
 
 	sec_bytes = rdp_get_sec_bytes(rdp);
-	sec_hold = s->pointer;
+	sec_hold = Stream_Pointer(s);
 	Stream_Seek(s, sec_bytes);
 
 	rdp_write_share_control_header(s, length - sec_bytes, PDU_TYPE_DATA, channel_id);
 	rdp_write_share_data_header(s, length - sec_bytes, type, rdp->settings->ShareId);
 
-	s->pointer = sec_hold;
+	Stream_Pointer(s) = sec_hold;
 	length += rdp_security_stream_out(rdp, s, length);
 
 	Stream_SetPosition(s, length);
+	Stream_SealLength(s);
+
 	if (transport_write(rdp->transport, s) < 0)
 		return FALSE;
 
@@ -526,7 +533,7 @@ int rdp_recv_data_pdu(rdpRdp* rdp, wStream* s)
 			return -1;	
 		}
 
-		if (decompress_rdp(rdp->mppc_dec, s->pointer, compressed_len - 18, compressed_type, &roff, &rlen))
+		if (decompress_rdp(rdp->mppc_dec, Stream_Pointer(s), compressed_len - 18, compressed_type, &roff, &rlen))
 		{
 			buffer = rdp->mppc_dec->history_buf + roff;
 			cs = StreamPool_Take(rdp->transport->ReceivePool, rlen);
@@ -699,25 +706,25 @@ BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, int length, UINT16 securityFlags)
 		Stream_Read_UINT8(s, version); /* 0x1 */
 		Stream_Read_UINT8(s, pad);
 
-		sig = s->pointer;
+		sig = Stream_Pointer(s);
 		Stream_Seek(s, 8);	/* signature */
 
 		length -= 12;
 
-		if (!security_fips_decrypt(s->pointer, length, rdp))
+		if (!security_fips_decrypt(Stream_Pointer(s), length, rdp))
 		{
 			fprintf(stderr, "FATAL: cannot decrypt\n");
 			return FALSE; /* TODO */
 		}
 
-		if (!security_fips_check_signature(s->pointer, length - pad, sig, rdp))
+		if (!security_fips_check_signature(Stream_Pointer(s), length - pad, sig, rdp))
 		{
 			fprintf(stderr, "FATAL: invalid packet signature\n");
 			return FALSE; /* TODO */
 		}
 
 		/* is this what needs adjusting? */
-		s->capacity -= pad;
+		Stream_Capacity(s) -= pad;
 		return TRUE;
 	}
 
@@ -726,13 +733,14 @@ BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, int length, UINT16 securityFlags)
 
 	Stream_Read(s, wmac, sizeof(wmac));
 	length -= sizeof(wmac);
-	if (!security_decrypt(s->pointer, length, rdp))
+
+	if (!security_decrypt(Stream_Pointer(s), length, rdp))
 		return FALSE;
 
 	if (securityFlags & SEC_SECURE_CHECKSUM)
-		security_salted_mac_signature(rdp, s->pointer, length, FALSE, cmac);
+		security_salted_mac_signature(rdp, Stream_Pointer(s), length, FALSE, cmac);
 	else
-		security_mac_signature(rdp, s->pointer, length, cmac);
+		security_mac_signature(rdp, Stream_Pointer(s), length, cmac);
 
 	if (memcmp(wmac, cmac, sizeof(wmac)) != 0)
 	{
@@ -792,7 +800,7 @@ static int rdp_recv_tpkt_pdu(rdpRdp* rdp, wStream* s)
 			 * [MS-RDPBCGR] 2.2.13.2.1
 			 *  - no share control header, nor the 2 byte pad
 			 */
-			s->pointer -= 2;
+			Stream_Rewind(s, 2);
 			rdp_recv_enhanced_security_redirection_packet(rdp, s);
 			return -1;
 		}

libfreerdp/core/transport.c

@@ -406,29 +406,29 @@ int transport_read_layer(rdpTransport* transport, UINT8* data, int bytes)
 int transport_read(rdpTransport* transport, wStream* s)
 {
 	int status;
-	int pdu_bytes;
+	int pduLength;
-	int stream_bytes;
+	int streamPosition;
 	int transport_status;
 
-	pdu_bytes = 0;
+	pduLength = 0;
 	transport_status = 0;
 
 	/* first check if we have header */
-	stream_bytes = Stream_GetPosition(s);
+	streamPosition = Stream_GetPosition(s);
 
-	if (stream_bytes < 4)
+	if (streamPosition < 4)
 	{
-		status = transport_read_layer(transport, s->buffer + stream_bytes, 4 - stream_bytes);
+		status = transport_read_layer(transport, Stream_Buffer(s) + streamPosition, 4 - streamPosition);
 
 		if (status < 0)
 			return status;
 
 		transport_status += status;
 
-		if ((status + stream_bytes) < 4)
+		if ((status + streamPosition) < 4)
 			return transport_status;
 
-		stream_bytes += status;
+		streamPosition += status;
 	}
 
 	/* if header is present, read in exactly one PDU */
@@ -436,7 +436,7 @@ int transport_read(rdpTransport* transport, wStream* s)
 	{
 		/* TPKT header */
 
-		pdu_bytes = (s->buffer[2] << 8) | s->buffer[3];
+		pduLength = (s->buffer[2] << 8) | s->buffer[3];
 	}
 	else if (s->buffer[0] == 0x30)
 	{
@@ -446,13 +446,13 @@ int transport_read(rdpTransport* transport, wStream* s)
 		{
 			if ((s->buffer[1] & ~(0x80)) == 1)
 			{
-				pdu_bytes = s->buffer[2];
+				pduLength = s->buffer[2];
-				pdu_bytes += 3;
+				pduLength += 3;
 			}
 			else if ((s->buffer[1] & ~(0x80)) == 2)
 			{
-				pdu_bytes = (s->buffer[2] << 8) | s->buffer[3];
+				pduLength = (s->buffer[2] << 8) | s->buffer[3];
-				pdu_bytes += 4;
+				pduLength += 4;
 			}
 			else
 			{
@@ -461,8 +461,8 @@ int transport_read(rdpTransport* transport, wStream* s)
 		}
 		else
 		{
-			pdu_bytes = s->buffer[1];
+			pduLength = s->buffer[1];
-			pdu_bytes += 2;
+			pduLength += 2;
 		}
 	}
 	else
@@ -470,12 +470,12 @@ int transport_read(rdpTransport* transport, wStream* s)
 		/* Fast-Path Header */
 
 		if (s->buffer[1] & 0x80)
-			pdu_bytes = ((s->buffer[1] & 0x7f) << 8) | s->buffer[2];
+			pduLength = ((s->buffer[1] & 0x7F) << 8) | s->buffer[2];
 		else
-			pdu_bytes = s->buffer[1];
+			pduLength = s->buffer[1];
 	}
 
-	status = transport_read_layer(transport, s->buffer + stream_bytes, pdu_bytes - stream_bytes);
+	status = transport_read_layer(transport, Stream_Buffer(s) + streamPosition, pduLength - streamPosition);
 
 	if (status < 0)
 		return status;
@@ -484,10 +484,10 @@ int transport_read(rdpTransport* transport, wStream* s)
 
 #ifdef WITH_DEBUG_TRANSPORT
 	/* dump when whole PDU is read */
-	if (stream_bytes + status >= pdu_bytes)
+	if (streamPosition + status >= pduLength)
 	{
 		fprintf(stderr, "Local < Remote\n");
-		winpr_HexDump(s->buffer, pdu_bytes);
+		winpr_HexDump(Stream_Buffer(s), pduLength);
 	}
 #endif
 
@@ -511,8 +511,8 @@ static int transport_read_nonblocking(rdpTransport* transport)
 
 int transport_write(rdpTransport* transport, wStream* s)
 {
-	int status = -1;
 	int length;
+	int status = -1;
 
 	length = Stream_GetPosition(s);
 	Stream_SetPosition(s, 0);
@@ -521,7 +521,7 @@ int transport_write(rdpTransport* transport, wStream* s)
 	if (length > 0)
 	{
 		fprintf(stderr, "Local > Remote\n");
-		winpr_HexDump(s->buffer, length);
+		winpr_HexDump(Stream_Buffer(s), length);
 	}
 #endif
 
@@ -734,14 +734,6 @@ int transport_check_fds(rdpTransport** ptransport)
 		Stream_SealLength(received);
 		Stream_SetPosition(received, 0);
 
-		/**
-		 * ReceiveCallback return values:
-		 *
-		 * -1: synchronous failure
-		 *  0: synchronous success
-		 *  1: asynchronous return
-		 */
-
 		recv_status = transport->ReceiveCallback(transport, received, transport->ReceiveExtra);
 
 		Stream_Release(received);

libfreerdp/crypto/per.c

@@ -402,7 +402,7 @@ BOOL per_read_octet_string(wStream* s, BYTE* oct_str, int length, int min)
 	if (Stream_GetRemainingLength(s) < length)
 		return FALSE;
 
-	a_oct_str = s->pointer;
+	a_oct_str = Stream_Pointer(s);
 	Stream_Seek(s, length);
 
 	for (i = 0; i < length; i++)

server/Sample/sfreerdp.c

@@ -376,12 +376,12 @@ void tf_peer_dump_rfx(freerdp_peer* client)
 	{
 		pcap_get_next_record_header(pcap_rfx, &record);
 
-		s->buffer = realloc(s->buffer, record.length);
+		Stream_Buffer(s) = realloc(Stream_Buffer(s), record.length);
-		record.data = s->buffer;
+		record.data = Stream_Buffer(s);
-		s->capacity = record.length;
+		Stream_Capacity(s) = record.length;
 
 		pcap_get_next_record_content(pcap_rfx, &record);
-		s->pointer = s->buffer + s->capacity;
+		Stream_Pointer(s) = Stream_Buffer(s) + Stream_Capacity(s);
 
 		if (test_dump_rfx_realtime && test_sleep_tsdiff(&prev_seconds, &prev_useconds, record.header.ts_sec, record.header.ts_usec) == FALSE)
 			break;

winpr/libwinpr/sspi/NTLM/ntlm_message.c

@@ -326,7 +326,7 @@ SECURITY_STATUS ntlm_write_NegotiateMessage(NTLM_CONTEXT* context, PSecBuffer bu
 
 #ifdef WITH_DEBUG_NTLM
 	fprintf(stderr, "NEGOTIATE_MESSAGE (length = %d)\n", length);
-	winpr_HexDump(s->buffer, length);
+	winpr_HexDump(Stream_Buffer(s), length);
 	fprintf(stderr, "\n");
 
 	if (message->NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION)
@@ -610,7 +610,7 @@ SECURITY_STATUS ntlm_write_ChallengeMessage(NTLM_CONTEXT* context, PSecBuffer bu
 	buffer->cbBuffer = length;
 
 	sspi_SecBufferAlloc(&context->ChallengeMessage, length);
-	CopyMemory(context->ChallengeMessage.pvBuffer, s->buffer, length);
+	CopyMemory(context->ChallengeMessage.pvBuffer, Stream_Buffer(s), length);
 
 #ifdef WITH_DEBUG_NTLM
 	fprintf(stderr, "CHALLENGE_MESSAGE (length = %d)\n", length);
@@ -720,7 +720,7 @@ SECURITY_STATUS ntlm_read_AuthenticateMessage(NTLM_CONTEXT* context, PSecBuffer
 
 	length = Stream_GetPosition(s);
 	sspi_SecBufferAlloc(&context->AuthenticateMessage, length);
-	CopyMemory(context->AuthenticateMessage.pvBuffer, s->buffer, length);
+	CopyMemory(context->AuthenticateMessage.pvBuffer, Stream_Buffer(s), length);
 	buffer->cbBuffer = length;
 
 	Stream_SetPosition(s, PayloadBufferOffset);
@@ -1016,7 +1016,7 @@ SECURITY_STATUS ntlm_write_AuthenticateMessage(NTLM_CONTEXT* context, PSecBuffer
 
 	length = Stream_GetPosition(s);
 	sspi_SecBufferAlloc(&context->AuthenticateMessage, length);
-	CopyMemory(context->AuthenticateMessage.pvBuffer, s->buffer, length);
+	CopyMemory(context->AuthenticateMessage.pvBuffer, Stream_Buffer(s), length);
 	buffer->cbBuffer = length;
 
 	if (context->UseMIC)
@@ -1031,7 +1031,7 @@ SECURITY_STATUS ntlm_write_AuthenticateMessage(NTLM_CONTEXT* context, PSecBuffer
 
 #ifdef WITH_DEBUG_NTLM
 	fprintf(stderr, "AUTHENTICATE_MESSAGE (length = %d)\n", length);
-	winpr_HexDump(s->buffer, length);
+	winpr_HexDump(Stream_Buffer(s), length);
 	fprintf(stderr, "\n");
 
 	ntlm_print_negotiate_flags(message->NegotiateFlags);

winpr/libwinpr/utils/collections/StreamPool.c

@@ -127,7 +127,7 @@ wStream* StreamPool_Take(wStreamPool* pool, size_t size)
 	{
 		s = pool->aArray[index];
 
-		if (s->capacity >= size)
+		if (Stream_Capacity(s) >= size)
 		{
 			foundIndex = index;
 			found = TRUE;
@@ -247,7 +247,7 @@ wStream* StreamPool_Find(wStreamPool* pool, BYTE* ptr)
 	{
 		s = pool->uArray[index];
 
-		if ((ptr >= s->buffer) && (ptr < (s->buffer + s->capacity)))
+		if ((ptr >= Stream_Buffer(s)) && (ptr < (Stream_Buffer(s) + Stream_Capacity(s))))
 		{
 			found = TRUE;
 			break;