Attachment #84133 for bug #128690

View | Details | Raw Unified | Return to bug 128690
Collapse All | Expand All

Lines 312-318 int Executef(int silent, char *format, . Link Here

(-)Src.orig/Common/m_multi.c (-1 / +1 lines)
312	char buffer[512];	312	char buffer[512];
313		313
314	va_start(argptr, format);	314	va_start(argptr, format);
315	vsprintf(buffer, format, argptr);	315	vsnprintf(buffer, sizeof(buffer), format, argptr);
316	va_end(argptr);	316	va_end(argptr);
317	return Con_Execute(buffer, silent);	317	return Con_Execute(buffer, silent);
318	}	318	}

Lines 81-87 void XG_Dev(const char *format, ...) Link Here

(-)Src.orig/Common/p_xgline.c (-1 / +1 lines)
81	if(!xgDev)	81	if(!xgDev)
82	return;	82	return;
83	va_start(args, format);	83	va_start(args, format);
84	vsprintf(buffer, format, args);	84	vsnprintf(buffer, sizeof(buffer), format, args);
85	strcat(buffer, "\n");	85	strcat(buffer, "\n");
86	Con_Message(buffer);	86	Con_Message(buffer);
87	va_end(args);	87	va_end(args);




	if(var->flags & CVF_PROTECTED)
		equals = ':';

	Con_Printf("%s", prefix);
	switch (var->type)
	{
	case CVT_NULL:

	char    buffer[4096];

	va_start(argptr, command);
	vsnprintf(buffer, sizeof(buffer), command, argptr);
	va_end(argptr);
	return Con_Execute(buffer, silent);
}

	prbuff = malloc(65536);

	// Format the message to prbuff.
	vsnprintf(prbuff, sizeof(prbuff), format, args);

	if(consoleDump)
		fprintf(outFile, "%s", prbuff);

		buffer = malloc(0x10000);

		va_start(argptr, message);
		vsnprintf(buffer, sizeof(buffer), message, argptr);
		va_end(argptr);

#ifdef UNIX

			printf("%s", buffer);

		// Also print in the console.
		Con_Printf("%s", buffer);

		free(buffer);
	}

		fprintf(outFile, "Con_Error: Stack overflow imminent, aborting...\n");

		va_start(argptr, error);
		vsnprintf(buff, sizeof(buff), error, argptr);
		va_end(argptr);
		Sys_MessageBox(buff, true);


	Dir_ChDir(&ddRuntimeDir);

	va_start(argptr, error);
	vsnprintf(err, sizeof(err), error, argptr);
	va_end(argptr);
	fprintf(outFile, "%s\n", err);


Lines 82-88 void DD_ErrorBox(boolean error, char *fo Link Here

(-)Src.orig/dd_pinit.c (-1 / +1 lines)
82	va_list args;	82	va_list args;
83		83
84	va_start(args, format);	84	va_start(args, format);
85	vsprintf(buff, format, args);	85	vsnprintf(buff, sizeof(buff), format, args);
86	va_end(args);	86	va_end(args);
87	#ifdef WIN32	87	#ifdef WIN32
88	MessageBox(NULL, buff, "Doomsday " DOOMSDAY_VERSION_TEXT,	88	MessageBox(NULL, buff, "Doomsday " DOOMSDAY_VERSION_TEXT,




  va_list args;

  va_start(args, str);
  vsnprintf(message_buf, sizeof(message_buf), str, args);
  va_end(args);

  (* cur_funcs->fatal_error)("\nError: *** %s ***\n\n", message_buf);

  va_list args;

  va_start(args, str);
  vsnprintf(message_buf, sizeof(message_buf), str, args);
  va_end(args);

  (* cur_funcs->fatal_error)("\nINTERNAL ERROR: *** %s ***\n\n", message_buf);

  va_list args;

  va_start(args, str);
  vsnprintf(message_buf, sizeof(message_buf), str, args);
  va_end(args);

  (* cur_funcs->print_msg)("%s", message_buf);

  va_list args;

  va_start(args, str);
  vsnprintf(message_buf, sizeof(message_buf), str, args);
  va_end(args);

  (* cur_funcs->print_msg)("Warning: %s", message_buf);

  if (cur_info->mini_warnings)
  {
    va_start(args, str);
    vsnprintf(message_buf, sizeof(message_buf), str, args);
    va_end(args);

    (* cur_funcs->print_msg)("Warning: %s", message_buf);


#if DEBUG_ENABLED
  va_start(args, str);
  vsnprintf(message_buf, sizeof(message_buf), str, args);
  va_end(args);

  PrintDebug("MiniWarn: %s", message_buf);

Lines 202-208 static void fatal_error(const char *str, Link Here

(-)Src.orig/dpMapLoad/maploader.c (-2 / +2 lines)
202	va_list args;	202	va_list args;
203		203
204	va_start(args, str);	204	va_start(args, str);
205	vsprintf(buffer, str, args);	205	vsnprintf(buffer, sizeof(buffer), str, args);
206	va_end(args);	206	va_end(args);
207		207
208	Con_Error(buffer);	208	Con_Error(buffer);
Lines 218-224 static void print_msg(const char *str, . Link Here
218	va_list args;	218	va_list args;
219		219
220	va_start(args, str);	220	va_start(args, str);
221	vsprintf(buffer, str, args);	221	vsnprintf(buffer, sizeof(buffer), str, args);
222	va_end(args);	222	va_end(args);
223		223
224	Con_Message(buffer);	224	Con_Message(buffer);

Lines 75-81 void DP(const char *format, ...) Link Here

(-)Src.orig/drD3D/main.cpp (-1 / +1 lines)
75	va_list args;	75	va_list args;
76	char buf[2048];	76	char buf[2048];
77	va_start(args, format);	77	va_start(args, format);
78	vsprintf(buf, format, args);	78	vsnprintf(buf, sizeof(buf), format, args);
79	va_end(args);	79	va_end(args);
80	Con_Message("%s\n", buf);	80	Con_Message("%s\n", buf);
81	}	81	}

Lines 185-191 void Str_Appendf(ddstring_t * ds, const Link Here

(-)Src.orig/m_string.c (-1 / +1 lines)
185		185
186	// Print the message into the buffer.	186	// Print the message into the buffer.
187	va_start(args, format);	187	va_start(args, format);
188	vsprintf(buf, format, args);	188	vsnprintf(buf, sizeof(buf), format, args);
189	va_end(args);	189	va_end(args);
190	Str_Append(ds, buf);	190	Str_Append(ds, buf);
191	}	191	}

Lines 171-177 int N_MasterSendAnnouncement(void *parm) Link Here

(-)Src.orig/sys_master.c (-1 / +1 lines)
171	memset(buf, 0, sizeof(buf));	171	memset(buf, 0, sizeof(buf));
172	while(recv(s, buf, sizeof(buf) - 1, 0) > 0)	172	while(recv(s, buf, sizeof(buf) - 1, 0) > 0)
173	{	173	{
174	Con_Printf(buf);	174	Con_Printf("%s", buf);
175	memset(buf, 0, sizeof(buf));	175	memset(buf, 0, sizeof(buf));
176	}	176	}
177	*/	177	*/

Lines 779-785 int DM_WinCDCommand(char *returnInfo, in Link Here

(-)Src.orig/sys_musd_win.c (-1 / +1 lines)
779	MCIERROR error;	779	MCIERROR error;
780		780
781	va_start(args, format);	781	va_start(args, format);
782	vsprintf(buf, format, args);	782	vsnprintf(buf, sizeof(buf), format, args);
783	va_end(args);	783	va_end(args);
784		784
785	if((error = mciSendString(buf, returnInfo, returnLength, NULL)))	785	if((error = mciSendString(buf, returnInfo, returnLength, NULL)))

Lines 95-101 void N_SockPrintf(socket_t s, const char Link Here

(-)Src.orig/sys_sock.c (-1 / +1 lines)
95		95
96	// Print the message into the buffer.	96	// Print the message into the buffer.
97	va_start(args, format);	97	va_start(args, format);
98	length = vsprintf(buf, format, args);	98	length = vsnprintf(buf, sizeof(buf), format, args);
99	va_end(args);	99	va_end(args);
100		100
101	if(length > sizeof(buf))	101	if(length > sizeof(buf))

Lines 137-143 void SW_Printf(const char *format, ...) Link Here

(-)Src.orig/sys_stwin.c (-1 / +1 lines)
137	return;	137	return;
138		138
139	va_start(args, format);	139	va_start(args, format);
140	printedChars += vsprintf(buf, format, args);	140	printedChars += vsnprintf(buf, sizeof(buf), format, args);
141	va_end(args);	141	va_end(args);
142		142
143	if(printedChars > 32768)	143	if(printedChars > 32768)

Return to bug 128690

Lines 988-994 static void printcvar(cvar_t *var, char Link Here

(-)Src.orig/con_main.c (-7 / +7 lines)
988	if(var->flags & CVF_PROTECTED)	988	if(var->flags & CVF_PROTECTED)
989	equals = ':';	989	equals = ':';
990		990
991	Con_Printf(prefix);	991	Con_Printf("%s", prefix);
992	switch (var->type)	992	switch (var->type)
993	{	993	{
994	case CVT_NULL:	994	case CVT_NULL:
Lines 1304-1310 int Con_Executef(int silent, const char Link Here
1304	char buffer[4096];	1304	char buffer[4096];
1305		1305
1306	va_start(argptr, command);	1306	va_start(argptr, command);
1307	vsprintf(buffer, command, argptr);	1307	vsnprintf(buffer, sizeof(buffer), command, argptr);
1308	va_end(argptr);	1308	va_end(argptr);
1309	return Con_Execute(buffer, silent);	1309	return Con_Execute(buffer, silent);
1310	}	1310	}
Lines 1966-1972 void conPrintf(int flags, const char *fo Link Here
1966	prbuff = malloc(65536);	1966	prbuff = malloc(65536);
1967		1967
1968	// Format the message to prbuff.	1968	// Format the message to prbuff.
1969	vsprintf(prbuff, format, args);	1969	vsnprintf(prbuff, sizeof(prbuff), format, args);
1970		1970
1971	if(consoleDump)	1971	if(consoleDump)
1972	fprintf(outFile, "%s", prbuff);	1972	fprintf(outFile, "%s", prbuff);
Lines 2765-2771 void Con_Message(const char *message, .. Link Here
2765	buffer = malloc(0x10000);	2765	buffer = malloc(0x10000);
2766		2766
2767	va_start(argptr, message);	2767	va_start(argptr, message);
2768	vsprintf(buffer, message, argptr);	2768	vsnprintf(buffer, sizeof(buffer), message, argptr);
2769	va_end(argptr);	2769	va_end(argptr);
2770		2770
2771	#ifdef UNIX	2771	#ifdef UNIX
Lines 2782-2788 void Con_Message(const char *message, .. Link Here
2782	printf("%s", buffer);	2782	printf("%s", buffer);
2783		2783
2784	// Also print in the console.	2784	// Also print in the console.
2785	Con_Printf(buffer);	2785	Con_Printf("%s", buffer);
2786		2786
2787	free(buffer);	2787	free(buffer);
2788	}	2788	}
Lines 2806-2812 void Con_Error(const char *error, ...) Link Here
2806	fprintf(outFile, "Con_Error: Stack overflow imminent, aborting...\n");	2806	fprintf(outFile, "Con_Error: Stack overflow imminent, aborting...\n");
2807		2807
2808	va_start(argptr, error);	2808	va_start(argptr, error);
2809	vsprintf(buff, error, argptr);	2809	vsnprintf(buff, sizeof(buff), error, argptr);
2810	va_end(argptr);	2810	va_end(argptr);
2811	Sys_MessageBox(buff, true);	2811	Sys_MessageBox(buff, true);
2812		2812
Lines 2821-2827 void Con_Error(const char *error, ...) Link Here
2821	Dir_ChDir(&ddRuntimeDir);	2821	Dir_ChDir(&ddRuntimeDir);
2822		2822
2823	va_start(argptr, error);	2823	va_start(argptr, error);
2824	vsprintf(err, error, argptr);	2824	vsnprintf(err, sizeof(err), error, argptr);
2825	va_end(argptr);	2825	va_end(argptr);
2826	fprintf(outFile, "%s\n", err);	2826	fprintf(outFile, "%s\n", err);
2827		2827

Lines 54-60 void FatalError(const char *str, ...) Link Here

(-)Src.orig/dpMapLoad/glBSP/system.c (-6 / +6 lines)
54	va_list args;	54	va_list args;
55		55
56	va_start(args, str);	56	va_start(args, str);
57	vsprintf(message_buf, str, args);	57	vsnprintf(message_buf, sizeof(message_buf), str, args);
58	va_end(args);	58	va_end(args);
59		59
60	(* cur_funcs->fatal_error)("\nError: * %s *\n\n", message_buf);	60	(* cur_funcs->fatal_error)("\nError: * %s *\n\n", message_buf);
Lines 68-74 void InternalError(const char *str, ...) Link Here
68	va_list args;	68	va_list args;
69		69
70	va_start(args, str);	70	va_start(args, str);
71	vsprintf(message_buf, str, args);	71	vsnprintf(message_buf, sizeof(message_buf), str, args);
72	va_end(args);	72	va_end(args);
73		73
74	(* cur_funcs->fatal_error)("\nINTERNAL ERROR: * %s *\n\n", message_buf);	74	(* cur_funcs->fatal_error)("\nINTERNAL ERROR: * %s *\n\n", message_buf);
Lines 82-88 void PrintMsg(const char *str, ...) Link Here
82	va_list args;	82	va_list args;
83		83
84	va_start(args, str);	84	va_start(args, str);
85	vsprintf(message_buf, str, args);	85	vsnprintf(message_buf, sizeof(message_buf), str, args);
86	va_end(args);	86	va_end(args);
87		87
88	(* cur_funcs->print_msg)("%s", message_buf);	88	(* cur_funcs->print_msg)("%s", message_buf);
Lines 100-106 void PrintWarn(const char *str, ...) Link Here
100	va_list args;	100	va_list args;
101		101
102	va_start(args, str);	102	va_start(args, str);
103	vsprintf(message_buf, str, args);	103	vsnprintf(message_buf, sizeof(message_buf), str, args);
104	va_end(args);	104	va_end(args);
105		105
106	(* cur_funcs->print_msg)("Warning: %s", message_buf);	106	(* cur_funcs->print_msg)("Warning: %s", message_buf);
Lines 122-128 void PrintMiniWarn(const char *str, ...) Link Here
122	if (cur_info->mini_warnings)	122	if (cur_info->mini_warnings)
123	{	123	{
124	va_start(args, str);	124	va_start(args, str);
125	vsprintf(message_buf, str, args);	125	vsnprintf(message_buf, sizeof(message_buf), str, args);
126	va_end(args);	126	va_end(args);
127		127
128	(* cur_funcs->print_msg)("Warning: %s", message_buf);	128	(* cur_funcs->print_msg)("Warning: %s", message_buf);
Lines 132-138 void PrintMiniWarn(const char *str, ...) Link Here
132		132
133	#if DEBUG_ENABLED	133	#if DEBUG_ENABLED
134	va_start(args, str);	134	va_start(args, str);
135	vsprintf(message_buf, str, args);	135	vsnprintf(message_buf, sizeof(message_buf), str, args);
136	va_end(args);	136	va_end(args);
137		137
138	PrintDebug("MiniWarn: %s", message_buf);	138	PrintDebug("MiniWarn: %s", message_buf);