Unifiy string append functions

(cherry picked from commit f25261e271)

channels/ainput/common/ainput_common.h

@@ -21,59 +21,37 @@
 #ifndef FREERDP_INT_AINPUT_COMMON_H
 #define FREERDP_INT_AINPUT_COMMON_H
 
-#include <assert.h>
 #include <winpr/string.h>
 
 #include <freerdp/channels/ainput.h>
 
-static INLINE void ainput_append(char* buffer, size_t size, const char* what, BOOL separator)
-{
-	size_t have;
-	size_t toadd;
-
-	assert(buffer || (size == 0));
-	assert(what);
-
-	have = strnlen(buffer, size);
-	toadd = strlen(what);
-	if (have > 0)
-		toadd += 1;
-
-	if (size - have < toadd + 1)
-		return;
-
-	if (have > 0)
-		strcat(buffer, separator ? "|" : " ");
-	strcat(buffer, what);
-}
-
 static INLINE const char* ainput_flags_to_string(UINT64 flags, char* buffer, size_t size)
 {
 	char number[32] = { 0 };
 
 	if (flags & AINPUT_FLAGS_HAVE_REL)
-		ainput_append(buffer, size, "AINPUT_FLAGS_HAVE_REL", TRUE);
+		winpr_str_append("AINPUT_FLAGS_HAVE_REL", buffer, size, "|");
 	if (flags & AINPUT_FLAGS_WHEEL)
-		ainput_append(buffer, size, "AINPUT_FLAGS_WHEEL", TRUE);
+		winpr_str_append("AINPUT_FLAGS_WHEEL", buffer, size, "|");
 	if (flags & AINPUT_FLAGS_MOVE)
-		ainput_append(buffer, size, "AINPUT_FLAGS_MOVE", TRUE);
+		winpr_str_append("AINPUT_FLAGS_MOVE", buffer, size, "|");
 	if (flags & AINPUT_FLAGS_DOWN)
-		ainput_append(buffer, size, "AINPUT_FLAGS_DOWN", TRUE);
+		winpr_str_append("AINPUT_FLAGS_DOWN", buffer, size, "|");
 	if (flags & AINPUT_FLAGS_REL)
-		ainput_append(buffer, size, "AINPUT_FLAGS_REL", TRUE);
+		winpr_str_append("AINPUT_FLAGS_REL", buffer, size, "|");
 	if (flags & AINPUT_FLAGS_BUTTON1)
-		ainput_append(buffer, size, "AINPUT_FLAGS_BUTTON1", TRUE);
+		winpr_str_append("AINPUT_FLAGS_BUTTON1", buffer, size, "|");
 	if (flags & AINPUT_FLAGS_BUTTON2)
-		ainput_append(buffer, size, "AINPUT_FLAGS_BUTTON2", TRUE);
+		winpr_str_append("AINPUT_FLAGS_BUTTON2", buffer, size, "|");
 	if (flags & AINPUT_FLAGS_BUTTON3)
-		ainput_append(buffer, size, "AINPUT_FLAGS_BUTTON3", TRUE);
+		winpr_str_append("AINPUT_FLAGS_BUTTON3", buffer, size, "|");
 	if (flags & AINPUT_XFLAGS_BUTTON1)
-		ainput_append(buffer, size, "AINPUT_XFLAGS_BUTTON1", TRUE);
+		winpr_str_append("AINPUT_XFLAGS_BUTTON1", buffer, size, "|");
 	if (flags & AINPUT_XFLAGS_BUTTON2)
-		ainput_append(buffer, size, "AINPUT_XFLAGS_BUTTON2", TRUE);
+		winpr_str_append("AINPUT_XFLAGS_BUTTON2", buffer, size, "|");
 
 	_snprintf(number, sizeof(number), "[0x%08" PRIx64 "]", flags);
-	ainput_append(buffer, size, number, FALSE);
+	winpr_str_append(number, buffer, size, " ");
 
 	return buffer;
 }

channels/rdpdr/server/rdpdr_main.c

@@ -1952,7 +1952,7 @@ static UINT rdpdr_server_drive_query_directory_callback1(RdpdrServerContext* con
 	irp->Callback = rdpdr_server_drive_query_directory_callback2;
 	irp->DeviceId = deviceId;
 	irp->FileId = fileId;
-	strcat(irp->PathName, "\\*.*");
+	winpr_str_append("\\*.*", irp->PathName, ARRAYSIZE(irp->PathName), NULL);
 
 	if (!rdpdr_server_enqueue_irp(context, irp))
 	{

channels/urbdrc/client/libusb/libusb_udevman.c

@@ -511,12 +511,7 @@ static BOOL filter_by_class(uint8_t bDeviceClass, uint8_t bDeviceSubClass)
 
 static BOOL append(char* dst, size_t length, const char* src)
 {
-	size_t slen = strlen(src);
+	return winpr_str_append(src, dst, length, NULL);
-	size_t dlen = strnlen(dst, length);
-	if (dlen + slen >= length)
-		return FALSE;
-	strcat(dst, src);
-	return TRUE;
 }
 
 static BOOL device_is_filtered(struct libusb_device* dev,

client/X11/xf_keyboard.c

@@ -400,18 +400,19 @@ static int xf_keyboard_execute_action_script(xfContext* xfc, XF_MODIFIER_KEYS* m
 	}
 
 	if (mod->Shift)
-		strcat(combination, "Shift+");
+		winpr_str_append("Shift", combination, sizeof(combination), "+");
 
 	if (mod->Ctrl)
-		strcat(combination, "Ctrl+");
+		winpr_str_append("Ctrl", combination, sizeof(combination), "+");
 
 	if (mod->Alt)
-		strcat(combination, "Alt+");
+		winpr_str_append("Alt", combination, sizeof(combination), "+");
 
 	if (mod->Super)
-		strcat(combination, "Super+");
+		winpr_str_append("Super", combination, sizeof(combination), "+");
+
+	winpr_str_append(keyStr, combination, sizeof(combination), NULL);
 
-	strcat(combination, keyStr);
 	count = ArrayList_Count(xfc->keyCombinations);
 
 	for (index = 0; index < count; index++)

client/common/cmdline.c

@@ -211,6 +211,7 @@ static BOOL copy_value(const char* value, char** dst)
 static BOOL append_value(const char* value, char** dst)
 {
 	size_t x = 0, y;
+	size_t size;
 	char* tmp;
 	if (!dst || !value)
 		return FALSE;
@@ -218,14 +219,16 @@ static BOOL append_value(const char* value, char** dst)
 	if (*dst)
 		x = strlen(*dst);
 	y = strlen(value);
-	tmp = realloc(*dst, x + y + 2);
+
+	size = x + y + 2;
+	tmp = realloc(*dst, size);
 	if (!tmp)
 		return FALSE;
 	if (x == 0)
 		tmp[0] = '\0';
 	else
-		strcat(tmp, ",");
+		winpr_str_append(",", tmp, size, NULL);
-	strcat(tmp, value);
+	winpr_str_append(value, tmp, size, NULL);
 	*dst = tmp;
 	return TRUE;
 }

libfreerdp/core/gateway/rdg.c

@@ -257,20 +257,18 @@ static const char* flags_to_string(UINT32 flags, const t_flag_mapping* map, size
 {
 	size_t x = 0;
 	static char buffer[1024] = { 0 };
-	char fields[12];
+	char fields[12] = { 0 };
-	memset(buffer, 0, sizeof(buffer));
 
 	for (x = 0; x < elements; x++)
 	{
-		if (buffer[0] != '\0')
+		const t_flag_mapping* cur = &map[x];
-			strcat(buffer, "|");
 
-		if ((map[x].code & flags) != 0)
+		if ((cur->code & flags) != 0)
-			strcat(buffer, map[x].name);
+			winpr_str_append(cur->name, buffer, sizeof(buffer), "|");
 	}
 
 	sprintf_s(fields, ARRAYSIZE(fields), " [%04" PRIx32 "]", flags);
-	strcat(buffer, fields);
+	winpr_str_append(fields, buffer, sizeof(buffer), NULL);
 	return buffer;
 }
 

libfreerdp/core/info.c

@@ -41,11 +41,13 @@ static const char* const INFO_TYPE_LOGON_STRINGS[4] = { "Logon Info V1", "Logon
 
 /* This define limits the length of the strings in the label field. */
 #define MAX_LABEL_LENGTH 40
-static struct
+struct info_flags_t
 {
 	UINT32 flag;
 	const char* label;
-} const info_flags[] = {
+};
+
+static const struct info_flags_t info_flags[] = {
 	{ INFO_MOUSE, "INFO_MOUSE" },
 	{ INFO_DISABLECTRLALTDEL, "INFO_DISABLECTRLALTDEL" },
 	{ INFO_AUTOLOGON, "INFO_AUTOLOGON" },
@@ -118,12 +120,8 @@ static BOOL rdp_read_info_null_string(UINT32 flags, wStream* s, size_t cbLen, CH
 static char* rdp_info_package_flags_description(UINT32 flags)
 {
 	char* result;
-	size_t maximum_size = 1; /* Reserve space for the terminating '\0' by strcat if all flags set */
+	size_t maximum_size = 1 + MAX_LABEL_LENGTH * ARRAYSIZE(info_flags);
 	size_t i;
-	size_t size;
-
-	for (i = 0; i < ARRAYSIZE(info_flags); i++)
-		maximum_size += strnlen(info_flags[i].label, MAX_LABEL_LENGTH) + 1;
 
 	result = calloc(maximum_size, sizeof(char));
 
@@ -132,18 +130,13 @@ static char* rdp_info_package_flags_description(UINT32 flags)
 
 	for (i = 0; i < ARRAYSIZE(info_flags); i++)
 	{
-		if (info_flags[i].flag & flags)
+		const struct info_flags_t* cur = &info_flags[i];
+		if (cur->flag & flags)
 		{
-			strcat(result, info_flags[i].label);
+			winpr_str_append(cur->label, result, maximum_size, "|");
-			strcat(result, "|");
 		}
 	}
 
-	size = strnlen(result, maximum_size);
-
-	if (size > 0)
-		result[size - 1] = '\0'; /* remove last "|" */
-
 	return result;
 }
 

libfreerdp/core/nego.c

@@ -945,6 +945,28 @@ BOOL nego_process_negotiation_request(rdpNego* nego, wStream* s)
  * @param nego
  * @param s
  */
+static const char* nego_rdp_neg_rsp_flags_str(UINT32 flags)
+{
+	static char buffer[1024] = { 0 };
+
+	_snprintf(buffer, ARRAYSIZE(buffer), "[0x%02" PRIx32 "] ", flags);
+	if (flags & EXTENDED_CLIENT_DATA_SUPPORTED)
+		winpr_str_append("EXTENDED_CLIENT_DATA_SUPPORTED", buffer, sizeof(buffer), "|");
+	if (flags & DYNVC_GFX_PROTOCOL_SUPPORTED)
+		winpr_str_append("DYNVC_GFX_PROTOCOL_SUPPORTED", buffer, sizeof(buffer), "|");
+	if (flags & RDP_NEGRSP_RESERVED)
+		winpr_str_append("RDP_NEGRSP_RESERVED", buffer, sizeof(buffer), "|");
+	if (flags & RESTRICTED_ADMIN_MODE_SUPPORTED)
+		winpr_str_append("RESTRICTED_ADMIN_MODE_SUPPORTED", buffer, sizeof(buffer), "|");
+	if (flags & REDIRECTED_AUTHENTICATION_MODE_SUPPORTED)
+		winpr_str_append("REDIRECTED_AUTHENTICATION_MODE_SUPPORTED", buffer, sizeof(buffer), "|");
+	if ((flags &
+	     ~(EXTENDED_CLIENT_DATA_SUPPORTED | DYNVC_GFX_PROTOCOL_SUPPORTED | RDP_NEGRSP_RESERVED |
+	       RESTRICTED_ADMIN_MODE_SUPPORTED | REDIRECTED_AUTHENTICATION_MODE_SUPPORTED)))
+		winpr_str_append("UNKNOWN", buffer, sizeof(buffer), "|");
+
+	return buffer;
+}
 
 BOOL nego_process_negotiation_response(rdpNego* nego, wStream* s)
 {
@@ -959,6 +981,7 @@ BOOL nego_process_negotiation_response(rdpNego* nego, wStream* s)
 	}
 
 	Stream_Read_UINT8(s, nego->flags);
+	WLog_DBG(TAG, "RDP_NEG_RSP::flags = { %s }", nego_rdp_neg_rsp_flags_str(nego->flags));
 	Stream_Read_UINT16(s, length);
 	Stream_Read_UINT32(s, nego->SelectedProtocol);
 	nego->state = NEGO_STATE_FINAL;

libfreerdp/core/nego.h

@@ -81,6 +81,7 @@ enum RDP_NEG_MSG
 #define DYNVC_GFX_PROTOCOL_SUPPORTED 0x02
 #define RDP_NEGRSP_RESERVED 0x04
 #define RESTRICTED_ADMIN_MODE_SUPPORTED 0x08
+#define REDIRECTED_AUTHENTICATION_MODE_SUPPORTED 0x10
 
 #define PRECONNECTION_PDU_V1_SIZE 16
 #define PRECONNECTION_PDU_V2_MIN_SIZE (PRECONNECTION_PDU_V1_SIZE + 2)

winpr/include/winpr/string.h

@@ -31,6 +31,9 @@ extern "C"
 {
 #endif
 
+	WINPR_API BOOL winpr_str_append(const char* what, char* buffer, size_t size,
+	                                const char* separator);
+
 #ifndef _WIN32
 
 #define CSTR_LESS_THAN 1

winpr/libwinpr/clipboard/synthetic.c

@@ -321,91 +321,107 @@ static void* clipboard_synthesize_image_bmp(wClipboard* clipboard, UINT32 format
  */
 
 static void* clipboard_synthesize_html_format(wClipboard* clipboard, UINT32 formatId,
-                                              const void* data, UINT32* pSize)
+                                              const void* pData, UINT32* pSize)
 {
-	char* pSrcData = NULL;
+	union
+	{
+		const void* cpv;
+		const char* cpc;
+		const BYTE* cpb;
+		WCHAR* pv;
+	} pSrcData;
 	char* pDstData = NULL;
-	INT64 SrcSize = (INT64)*pSize;
+	pSrcData.cpv = NULL;
+
+	WINPR_ASSERT(clipboard);
+	WINPR_ASSERT(pSize);
 
 	if (formatId == ClipboardGetFormatId(clipboard, "text/html"))
 	{
+		const INT64 SrcSize = (INT64)*pSize;
+		const size_t DstSize = SrcSize + 200;
 		char* body;
-		BYTE bom[2];
+		char num[20] = { 0 };
-		char num[20];
+
-		WCHAR* wstr;
+		/* Create a copy, we modify the input data */
+		pSrcData.pv = calloc(1, SrcSize + 1);
+		if (!pSrcData.pv)
+			goto fail;
+		memcpy(pSrcData.pv, pData, SrcSize);
 
 		if (SrcSize > 2)
 		{
-			CopyMemory(bom, data, 2);
+			if (SrcSize > INT_MAX)
-
-			if ((bom[0] == 0xFE) && (bom[1] == 0xFF))
-			{
-				ByteSwapUnicode((WCHAR*)data, SrcSize / 2);
-			}
-
-			if ((bom[0] == 0xFF) && (bom[1] == 0xFE))
-			{
-				wstr = (WCHAR*)&((BYTE*)data)[2];
-				ConvertFromUnicode(CP_UTF8, 0, wstr, (SrcSize - 2) / 2, &pSrcData, 0, NULL, NULL);
-			}
-		}
-
-		if (!pSrcData)
-		{
-			pSrcData = (char*)calloc(1, SrcSize + 1);
-
-			if (!pSrcData)
 				return NULL;
 
-			CopyMemory(pSrcData, data, SrcSize);
+			/* Check the BOM (Byte Order Mark) */
+			if ((pSrcData.cpb[0] == 0xFE) && (pSrcData.cpb[1] == 0xFF))
+				ByteSwapUnicode(pSrcData.pv, (int)(SrcSize / 2));
+
+			/* Check if we have WCHAR, convert to UTF-8 */
+			if ((pSrcData.cpb[0] == 0xFF) && (pSrcData.cpb[1] == 0xFE))
+			{
+				char* utfString = NULL;
+				ConvertFromUnicode(CP_UTF8, 0, &pSrcData.pv[1], (int)(SrcSize - 2) / 2, &utfString,
+				                   0, NULL, NULL);
+				free(pSrcData.pv);
+				pSrcData.cpc = utfString;
+			}
 		}
 
-		pDstData = (char*)calloc(1, SrcSize + 200);
+		pDstData = (char*)calloc(1, DstSize);
 
 		if (!pDstData)
-		{
+			goto fail;
-			free(pSrcData);
-			return NULL;
-		}
 
-		sprintf_s(pDstData, SrcSize + 200,
+		sprintf_s(pDstData, DstSize,
 		          "Version:0.9\r\n"
 		          "StartHTML:0000000000\r\n"
 		          "EndHTML:0000000000\r\n"
 		          "StartFragment:0000000000\r\n"
 		          "EndFragment:0000000000\r\n");
-		body = strstr(pSrcData, "<body");
+		body = strstr(pSrcData.cpc, "<body");
 
 		if (!body)
-			body = strstr(pSrcData, "<BODY");
+			body = strstr(pSrcData.cpc, "<BODY");
 
 		/* StartHTML */
-		sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, SrcSize + 200));
+		sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, DstSize));
 		CopyMemory(&pDstData[23], num, 10);
 
 		if (!body)
-			strcat(pDstData, "<HTML><BODY>");
+		{
+			if (!winpr_str_append("<HTML><BODY>", pDstData, DstSize, NULL))
+				goto fail;
+		}
 
-		strcat(pDstData, "<!--StartFragment-->");
+		if (!winpr_str_append("<!--StartFragment-->", pDstData, DstSize, NULL))
+			goto fail;
 		/* StartFragment */
 		sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, SrcSize + 200));
 		CopyMemory(&pDstData[69], num, 10);
-		strcat(pDstData, pSrcData);
+		if (!winpr_str_append(pSrcData.cpc, pDstData, DstSize, NULL))
+			goto fail;
 		/* EndFragment */
 		sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, SrcSize + 200));
 		CopyMemory(&pDstData[93], num, 10);
-		strcat(pDstData, "<!--EndFragment-->");
+		if (!winpr_str_append("<!--EndFragment-->", pDstData, DstSize, NULL))
+			goto fail;
 
 		if (!body)
-			strcat(pDstData, "</BODY></HTML>");
+		{
-
+			if (!winpr_str_append("</BODY></HTML>", pDstData, DstSize, NULL))
-		/* EndHTML */
+				goto fail;
-		sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, SrcSize + 200));
-		CopyMemory(&pDstData[43], num, 10);
-		*pSize = (UINT32)strlen(pDstData) + 1;
-		free(pSrcData);
 		}
 
+		/* EndHTML */
+		sprintf_s(num, sizeof(num), "%010" PRIuz "", strnlen(pDstData, DstSize));
+		CopyMemory(&pDstData[43], num, 10);
+		*pSize = (UINT32)strnlen(pDstData, DstSize) + 1;
+	}
+
+fail:
+	free(pSrcData.pv);
 	return pDstData;
 }
 

winpr/libwinpr/crt/string.c

@@ -33,6 +33,23 @@
 #include "../log.h"
 #define TAG WINPR_TAG("crt")
 
+BOOL winpr_str_append(const char* what, char* buffer, size_t size, const char* separator)
+{
+	const size_t used = strnlen(buffer, size);
+	const size_t add = strnlen(what, size);
+	const size_t sep_len = separator ? strnlen(separator, size) : 0;
+	const size_t sep = (used > 0) ? sep_len : 0;
+
+	if (used + add + sep >= size)
+		return FALSE;
+
+	if ((used > 0) && (sep_len > 0))
+		strncat(buffer, separator, sep_len);
+
+	strncat(buffer, what, add);
+	return TRUE;
+}
+
 #ifndef _WIN32
 
 char* _strdup(const char* strSource)

winpr/libwinpr/file/generic.c

@@ -24,6 +24,7 @@
 #endif
 
 #include <winpr/crt.h>
+#include <winpr/string.h>
 #include <winpr/path.h>
 #include <winpr/file.h>
 
@@ -541,15 +542,7 @@ DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
 
 static char* append(char* buffer, size_t size, const char* append)
 {
-	const size_t len = strnlen(buffer, size);
+	winpr_str_append(append, buffer, size, "|");
-	if (len == 0)
-		_snprintf(buffer, size, "%s", append);
-	else
-	{
-		strcat(buffer, "|");
-		strcat(buffer, append);
-	}
-
 	return buffer;
 }
 
@@ -588,7 +581,7 @@ static const char* flagsToStr(char* buffer, size_t size, DWORD flags)
 		append(buffer, size, "FILE_ATTRIBUTE_VIRTUAL");
 
 	_snprintf(strflags, sizeof(strflags), " [0x%08" PRIx32 "]", flags);
-	strcat(buffer, strflags);
+	winpr_str_append(strflags, buffer, size, NULL);
 	return buffer;
 }
 

winpr/libwinpr/smartcard/smartcard.c

@@ -1047,103 +1047,47 @@ WINSCARDAPI const char* WINAPI SCardGetCardStateString(DWORD dwCardState)
 
 WINSCARDAPI char* WINAPI SCardGetReaderStateString(DWORD dwReaderState)
 {
-	char* szReaderState = malloc(512);
+	const size_t size = 512;
+	char* buffer = calloc(size, sizeof(char));
 
-	if (!szReaderState)
+	if (!buffer)
 		return NULL;
 
-	szReaderState[0] = '\0';
-
 	if (dwReaderState & SCARD_STATE_IGNORE)
-	{
+		winpr_str_append("SCARD_STATE_IGNORE", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_IGNORE");
-	}
 
 	if (dwReaderState & SCARD_STATE_CHANGED)
-	{
+		winpr_str_append("SCARD_STATE_CHANGED", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_CHANGED");
-	}
 
 	if (dwReaderState & SCARD_STATE_UNKNOWN)
-	{
+		winpr_str_append("SCARD_STATE_UNKNOWN", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_UNKNOWN");
-	}
 
 	if (dwReaderState & SCARD_STATE_UNAVAILABLE)
-	{
+		winpr_str_append("SCARD_STATE_UNAVAILABLE", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_UNAVAILABLE");
-	}
 
 	if (dwReaderState & SCARD_STATE_EMPTY)
-	{
+		winpr_str_append("SCARD_STATE_EMPTY", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_EMPTY");
-	}
 
 	if (dwReaderState & SCARD_STATE_PRESENT)
-	{
+		winpr_str_append("SCARD_STATE_PRESENT", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_PRESENT");
-	}
 
 	if (dwReaderState & SCARD_STATE_ATRMATCH)
-	{
+		winpr_str_append("SCARD_STATE_ATRMATCH", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_ATRMATCH");
-	}
 
 	if (dwReaderState & SCARD_STATE_EXCLUSIVE)
-	{
+		winpr_str_append("SCARD_STATE_EXCLUSIVE", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_EXCLUSIVE");
-	}
 
 	if (dwReaderState & SCARD_STATE_INUSE)
-	{
+		winpr_str_append("SCARD_STATE_INUSE", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_INUSE");
-	}
 
 	if (dwReaderState & SCARD_STATE_MUTE)
-	{
+		winpr_str_append("SCARD_STATE_MUTE", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
-
-		strcat(szReaderState, "SCARD_STATE_MUTE");
-	}
 
 	if (dwReaderState & SCARD_STATE_UNPOWERED)
-	{
+		winpr_str_append("SCARD_STATE_UNPOWERED", buffer, size, "|");
-		if (szReaderState[0])
-			strcat(szReaderState, " | ");
 
-		strcat(szReaderState, "SCARD_STATE_UNPOWERED");
+	if (!buffer[0])
-	}
+		winpr_str_append("SCARD_STATE_UNAWARE", buffer, size, "|");
 
-	if (!szReaderState[0])
+	return buffer;
-		strcat(szReaderState, "SCARD_STATE_UNAWARE");
-
-	return szReaderState;
 }

winpr/libwinpr/sspi/NTLM/ntlm.c

@@ -1309,13 +1309,13 @@ char* ntlm_negotiate_flags_string(char* buffer, size_t size, UINT32 flags)
 				{
 					if (size - len < 1)
 						break;
-					strcat(buffer, "|");
+				    winpr_str_append("|", buffer, size, NULL);
 				    len++;
 			    }
 
 				if (size - len < flen)
 					break;
-				strcat(buffer, str);
+			    winpr_str_append(str, buffer, size, NULL);
 		    }
 	    }