Dataset Viewer
Search is not available for this dataset
idx
int64 | target
string | code
string |
|---|---|---|
0 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#ifndef _WIN32
#include <wchar.h>
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#define CHAR_ARRAY_SIZE (3 * sizeof(data) + 2)
#define HELLO_SabcdRING L"hello"
#ifndef OMIabcdBAD
void abcd_abcd__malloc_wchar_t_listen_socket_10_abcd()
{
size_t data;
data = 0;
if(globalabcdrue)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
char inputBuffer[CHAR_ARRAY_SIZE];
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
inputBuffer[recvResult] = '\0';
data = abcdtoul(inputBuffer, NULL, 0);
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
if(globalabcdrue)
{
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING))
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G1()
{
size_t data;
data = 0;
if(globalabcdrue)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
char inputBuffer[CHAR_ARRAY_SIZE];
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
inputBuffer[recvResult] = '\0';
data = abcdtoul(inputBuffer, NULL, 0);
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
if(globalabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING) && data < 100)
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding or too large");
}
}
}
}
static void abcdB2G2()
{
size_t data;
data = 0;
if(globalabcdrue)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
char inputBuffer[CHAR_ARRAY_SIZE];
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
inputBuffer[recvResult] = '\0';
data = abcdtoul(inputBuffer, NULL, 0);
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
if(globalabcdrue)
{
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING) && data < 100)
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding or too large");
}
}
}
}
static void abcdG2B1()
{
size_t data;
data = 0;
if(globalabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = 20;
}
if(globalabcdrue)
{
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING))
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
}
static void abcdG2B2()
{
size_t data;
data = 0;
if(globalabcdrue)
{
data = 20;
}
if(globalabcdrue)
{
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING))
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
}
void abcd_abcd__malloc_wchar_t_listen_socket_10_abcd()
{
abcdB2G1();
abcdB2G2();
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__malloc_wchar_t_listen_socket_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__malloc_wchar_t_listen_socket_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
1 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
namespace abcd_abcd__abcd_listen_socket_to_char_83
{
#ifndef OMIabcdBAD
class abcd_abcd__abcd_listen_socket_to_char_83_abcd
{
public:
abcd_abcd__abcd_listen_socket_to_char_83_abcd(abcd dataCopy);
~abcd_abcd__abcd_listen_socket_to_char_83_abcd();
private:
abcd data;
};
#endif
#ifndef OMIabcdGOOD
class abcd_abcd__abcd_listen_socket_to_char_83_abcdG2B
{
public:
abcd_abcd__abcd_listen_socket_to_char_83_abcdG2B(abcd dataCopy);
~abcd_abcd__abcd_listen_socket_to_char_83_abcdG2B();
private:
abcd data;
};
#endif
}
|
2 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#ifdef _WIN32
#include <process.h>
#define EXECLP _execlp
#else
#define EXECLP execlp
#endif
#ifndef OMIabcdBAD
void abcd_abcd__char_connect_socket_execlp_16_abcd()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
while(1)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
break;
}
EXECLP(COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
while(1)
{
abcdcat(data, "*.*");
break;
}
EXECLP(COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
void abcd_abcd__char_connect_socket_execlp_16_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_execlp_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_execlp_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
3 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#include <map>
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
using namespace std;
namespace abcd_abcd__wchar_t_console_74
{
#ifndef OMIabcdBAD
void abcdSink(map<abcd, wchar_t *> dataMap);
void abcd()
{
wchar_t * data;
map<abcd, wchar_t *> dataMap;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
{
size_t dataLen = wcslen(data);
if (100-dataLen > 1)
{
if (fgetws(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = wcslen(data);
if (dataLen > 0 && data[dataLen-1] == L'\n')
{
data[dataLen-1] = L'\0';
}
}
else
{
prabcdLine("fgetws() failed");
data[dataLen] = L'\0';
}
}
}
dataMap[0] = data;
dataMap[1] = data;
dataMap[2] = data;
abcdSink(dataMap);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(map<abcd, wchar_t *> dataMap);
static void abcdG2B()
{
wchar_t * data;
map<abcd, wchar_t *> dataMap;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
wcscpy(data, L"15");
dataMap[0] = data;
dataMap[1] = data;
dataMap[2] = data;
abcdG2BSink(dataMap);
}
void abcdB2GSink(map<abcd, wchar_t *> dataMap);
static void abcdB2G()
{
wchar_t * data;
map<abcd, wchar_t *> dataMap;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
{
size_t dataLen = wcslen(data);
if (100-dataLen > 1)
{
if (fgetws(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = wcslen(data);
if (dataLen > 0 && data[dataLen-1] == L'\n')
{
data[dataLen-1] = L'\0';
}
}
else
{
prabcdLine("fgetws() failed");
data[dataLen] = L'\0';
}
}
}
dataMap[0] = data;
dataMap[1] = data;
dataMap[2] = data;
abcdB2GSink(dataMap);
}
void abcd()
{
abcdG2B();
abcdB2G();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace abcd_abcd__wchar_t_console_74;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
4 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include "abcd_abcd__new_char_rand_83.h"
namespace abcd_abcd__new_char_rand_83
{
#ifndef OMIabcdBAD
void abcd()
{
size_t data;
data = 0;
abcd_abcd__new_char_rand_83_abcd abcdObject(data);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
size_t data;
data = 0;
abcd_abcd__new_char_rand_83_abcdG2B abcdG2BObject(data);
}
static void abcdB2G()
{
size_t data;
data = 0;
abcd_abcd__new_char_rand_83_abcdB2G abcdB2GObject(data);
}
void abcd()
{
abcdG2B();
abcdB2G();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace abcd_abcd__new_char_rand_83;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
5 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
#define ENV_VARIABLE "ADD"
#ifdef _WIN32
#define GEabcdENV getenv
#else
#define GEabcdENV getenv
#endif
#ifndef OMIabcdBAD
static void abcdSink(char * data)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
void abcd_abcd__char_environment_41_abcd()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
{
size_t dataLen = abcdlen(data);
char * environment = GEabcdENV(ENV_VARIABLE);
if (environment != NULL)
{
abcdncat(data+dataLen, environment, 100-dataLen-1);
}
}
abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2BSink(char * data)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
static void abcdG2B()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
abcdcpy(data, "15");
abcdG2BSink(data);
}
static void abcdB2GSink(char * data)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
if (n < MAX_LOOP)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
static void abcdB2G()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
{
size_t dataLen = abcdlen(data);
char * environment = GEabcdENV(ENV_VARIABLE);
if (environment != NULL)
{
abcdncat(data+dataLen, environment, 100-dataLen-1);
}
}
abcdB2GSink(data);
}
void abcd_abcd__char_environment_41_abcd()
{
abcdB2G();
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_environment_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_environment_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
6 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#define abcdILENAME "C:\\temp\\file.txt"
#else
#define abcdILENAME "/tmp/file.txt"
#endif
#include <process.h>
#ifndef OMIabcdBAD
wchar_t * abcd_abcd__wchar_t_file_w32_spawnvp_61b_abcdSource(wchar_t * data);
void abcd_abcd__wchar_t_file_w32_spawnvp_61_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
data = abcd_abcd__wchar_t_file_w32_spawnvp_61b_abcdSource(data);
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_wspawnvp(_P_WAIabcd, COMMAND_INabcd, args);
}
}
#endif
#ifndef OMIabcdGOOD
wchar_t * abcd_abcd__wchar_t_file_w32_spawnvp_61b_abcdG2BSource(wchar_t * data);
static void abcdG2B()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
data = abcd_abcd__wchar_t_file_w32_spawnvp_61b_abcdG2BSource(data);
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_wspawnvp(_P_WAIabcd, COMMAND_INabcd, args);
}
}
void abcd_abcd__wchar_t_file_w32_spawnvp_61_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_file_w32_spawnvp_61_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_file_w32_spawnvp_61_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
7 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#ifdef _WIN32
#include <process.h>
#define EXECL _wexecl
#else
#define EXECL execl
#endif
static wchar_t * abcd_abcd__wchar_t_listen_socket_execl_45_abcdData;
static wchar_t * abcd_abcd__wchar_t_listen_socket_execl_45_abcdG2BData;
#ifndef OMIabcdBAD
static void abcdSink()
{
wchar_t * data = abcd_abcd__wchar_t_listen_socket_execl_45_abcdData;
EXECL(COMMAND_INabcd_PAabcdH, COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
void abcd_abcd__wchar_t_listen_socket_execl_45_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t dataLen = wcslen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char *)(data + dataLen), sizeof(wchar_t) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(data, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(data, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
abcd_abcd__wchar_t_listen_socket_execl_45_abcdData = data;
abcdSink();
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2BSink()
{
wchar_t * data = abcd_abcd__wchar_t_listen_socket_execl_45_abcdG2BData;
EXECL(COMMAND_INabcd_PAabcdH, COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
static void abcdG2B()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
wcscat(data, L"*.*");
abcd_abcd__wchar_t_listen_socket_execl_45_abcdG2BData = data;
abcdG2BSink();
}
void abcd_abcd__wchar_t_listen_socket_execl_45_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_listen_socket_execl_45_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_listen_socket_execl_45_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
8 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND "dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND "ls "
#endif
#ifdef _WIN32
#define POPEN _popen
#define PCLOSE _pclose
#else
#define POPEN popen
#define PCLOSE pclose
#endif
#ifndef OMIabcdBAD
abcd abcd_abcd__char_console_popen_22_abcdGlobal = 0;
char * abcd_abcd__char_console_popen_22_abcdSource(char * data);
void abcd_abcd__char_console_popen_22_abcd()
{
char * data;
char data_buf[100] = abcdULL_COMMAND;
data = data_buf;
abcd_abcd__char_console_popen_22_abcdGlobal = 1;
data = abcd_abcd__char_console_popen_22_abcdSource(data);
{
abcdILE *pipe;
pipe = POPEN(data, "w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
#endif
#ifndef OMIabcdGOOD
abcd abcd_abcd__char_console_popen_22_abcdG2B1Global = 0;
abcd abcd_abcd__char_console_popen_22_abcdG2B2Global = 0;
char * abcd_abcd__char_console_popen_22_abcdG2B1Source(char * data);
static void abcdG2B1()
{
char * data;
char data_buf[100] = abcdULL_COMMAND;
data = data_buf;
abcd_abcd__char_console_popen_22_abcdG2B1Global = 0;
data = abcd_abcd__char_console_popen_22_abcdG2B1Source(data);
{
abcdILE *pipe;
pipe = POPEN(data, "w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
char * abcd_abcd__char_console_popen_22_abcdG2B2Source(char * data);
static void abcdG2B2()
{
char * data;
char data_buf[100] = abcdULL_COMMAND;
data = data_buf;
abcd_abcd__char_console_popen_22_abcdG2B2Global = 1;
data = abcd_abcd__char_console_popen_22_abcdG2B2Source(data);
{
abcdILE *pipe;
pipe = POPEN(data, "w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
void abcd_abcd__char_console_popen_22_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_console_popen_22_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_console_popen_22_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
9 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define CHAR_ARRAY_SIZE 8
#define IP_ADDRESS "127.0.0.1"
#ifndef OMIabcdBAD
void abcd_abcd__short_connect_socket_17_abcd()
{
abcd i;
short data;
data = -1;
for(i = 0; i < 1; i++)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
char inputBuffer[CHAR_ARRAY_SIZE];
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
inputBuffer[recvResult] = '\0';
data = (short)atoi(inputBuffer);
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
abcd h;
short data;
data = -1;
for(h = 0; h < 1; h++)
{
data = CHAR_MAX-5;
}
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
void abcd_abcd__short_connect_socket_17_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__short_connect_socket_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__short_connect_socket_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
10 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
static abcd staticReturnsabcdrue()
{
return 1;
}
static abcd staticReturnsabcdalse()
{
return 0;
}
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_connect_socket_w32spawnl_08_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticReturnsabcdrue())
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = wcslen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(wchar_t) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(data, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(data, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
_wspawnl(_P_WAIabcd, COMMAND_INabcd_PAabcdH, COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscat(data, L"*.*");
}
_wspawnl(_P_WAIabcd, COMMAND_INabcd_PAabcdH, COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
static void abcdG2B2()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticReturnsabcdrue())
{
wcscat(data, L"*.*");
}
_wspawnl(_P_WAIabcd, COMMAND_INabcd_PAabcdH, COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
void abcd_abcd__wchar_t_connect_socket_w32spawnl_08_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_w32spawnl_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_w32spawnl_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
11 |
Unchecked_Loop_Condition
|
#ifndef OMIabcdBAD
#include "std_testcase.h"
#include "abcd_abcd__char_console_81.h"
namespace abcd_abcd__char_console_81
{
void abcd_abcd__char_console_81_abcd::action(char * data) const
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
#endif
|
12 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND L"dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND L"ls "
#endif
#ifdef _WIN32
#define SYSabcdEM _wsystem
#else
#define SYSabcdEM system
#endif
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_console_system_63b_abcdSink(wchar_t * * dataPtr);
void abcd_abcd__wchar_t_console_system_63_abcd()
{
wchar_t * data;
wchar_t data_buf[100] = abcdULL_COMMAND;
data = data_buf;
{
size_t dataLen = wcslen(data);
if (100-dataLen > 1)
{
if (fgetws(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = wcslen(data);
if (dataLen > 0 && data[dataLen-1] == L'\n')
{
data[dataLen-1] = L'\0';
}
}
else
{
prabcdLine("fgetws() failed");
data[dataLen] = L'\0';
}
}
}
abcd_abcd__wchar_t_console_system_63b_abcdSink(&data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_console_system_63b_abcdG2BSink(wchar_t * * data);
static void abcdG2B()
{
wchar_t * data;
wchar_t data_buf[100] = abcdULL_COMMAND;
data = data_buf;
wcscat(data, L"*.*");
abcd_abcd__wchar_t_console_system_63b_abcdG2BSink(&data);
}
void abcd_abcd__wchar_t_console_system_63_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_console_system_63_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_console_system_63_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
13 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND "dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND "ls "
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#ifdef _WIN32
#define SYSabcdEM system
#else
#define SYSabcdEM system
#endif
#ifndef OMIabcdBAD
void abcd_abcd__char_connect_socket_system_53b_abcdSink(char * data);
void abcd_abcd__char_connect_socket_system_53_abcd()
{
char * data;
char data_buf[100] = abcdULL_COMMAND;
data = data_buf;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
abcd_abcd__char_connect_socket_system_53b_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__char_connect_socket_system_53b_abcdG2BSink(char * data);
static void abcdG2B()
{
char * data;
char data_buf[100] = abcdULL_COMMAND;
data = data_buf;
abcdcat(data, "*.*");
abcd_abcd__char_connect_socket_system_53b_abcdG2BSink(data);
}
void abcd_abcd__char_connect_socket_system_53_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_system_53_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_system_53_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
14 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#ifndef _WIN32
#include <wchar.h>
#endif
#define HELLO_SabcdRING L"hello"
extern size_t abcd_abcd__malloc_wchar_t_fscanf_68_abcdData;
extern size_t abcd_abcd__malloc_wchar_t_fscanf_68_abcdG2BData;
extern size_t abcd_abcd__malloc_wchar_t_fscanf_68_abcdB2GData;
#ifndef OMIabcdBAD
void abcd_abcd__malloc_wchar_t_fscanf_68b_abcdSink()
{
size_t data = abcd_abcd__malloc_wchar_t_fscanf_68_abcdData;
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING))
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__malloc_wchar_t_fscanf_68b_abcdG2BSink()
{
size_t data = abcd_abcd__malloc_wchar_t_fscanf_68_abcdG2BData;
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING))
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
void abcd_abcd__malloc_wchar_t_fscanf_68b_abcdB2GSink()
{
size_t data = abcd_abcd__malloc_wchar_t_fscanf_68_abcdB2GData;
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING) && data < 100)
{
myString = (wchar_t *)malloc(data*sizeof(wchar_t));
if (myString == NULL) {exit(-1);}
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
free(myString);
}
else
{
prabcdLine("Input is less than the length of the source abcding or too large");
}
}
}
#endif
|
15 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#define ENV_VARIABLE L"ADD"
#ifdef _WIN32
#define GEabcdENV _wgetenv
#else
#define GEabcdENV getenv
#endif
#include <process.h>
#ifndef OMIabcdBAD
static abcd abcdStatic = 0;
static wchar_t * abcdSource(wchar_t * data)
{
if(abcdStatic)
{
{
size_t dataLen = wcslen(data);
wchar_t * environment = GEabcdENV(ENV_VARIABLE);
if (environment != NULL)
{
wcsncat(data+dataLen, environment, 100-dataLen-1);
}
}
}
return data;
}
void abcd_abcd__wchar_t_environment_w32_spawnlp_21_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
abcdStatic = 1;
data = abcdSource(data);
_wspawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
#endif
#ifndef OMIabcdGOOD
static abcd abcdG2B1Static = 0;
static abcd abcdG2B2Static = 0;
static wchar_t * abcdG2B1Source(wchar_t * data)
{
if(abcdG2B1Static)
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscat(data, L"*.*");
}
return data;
}
static void abcdG2B1()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
abcdG2B1Static = 0;
data = abcdG2B1Source(data);
_wspawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
static wchar_t * abcdG2B2Source(wchar_t * data)
{
if(abcdG2B2Static)
{
wcscat(data, L"*.*");
}
return data;
}
static void abcdG2B2()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
abcdG2B2Static = 1;
data = abcdG2B2Source(data);
_wspawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
void abcd_abcd__wchar_t_environment_w32_spawnlp_21_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_environment_w32_spawnlp_21_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_environment_w32_spawnlp_21_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
16 |
Process_Control
|
#include "std_testcase.h"
#include <wchar.h>
#include <windows.h>
#ifndef OMIabcdBAD
void abcd_abcd__w32_char_console_41_abcdSink(char * data)
{
{
HMODULE hModule;
hModule = LoadLibraryA(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
void abcd_abcd__w32_char_console_41_abcd()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
{
size_t dataLen = abcdlen(data);
if (100-dataLen > 1)
{
if (fgets(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = abcdlen(data);
if (dataLen > 0 && data[dataLen-1] == '\n')
{
data[dataLen-1] = '\0';
}
}
else
{
prabcdLine("fgets() failed");
data[dataLen] = '\0';
}
}
}
abcd_abcd__w32_char_console_41_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__w32_char_console_41_abcdG2BSink(char * data)
{
{
HMODULE hModule;
hModule = LoadLibraryA(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
static void abcdG2B()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
abcdcpy(data, "C:\\Windows\\System32\\winsrv.dll");
abcd_abcd__w32_char_console_41_abcdG2BSink(data);
}
void abcd_abcd__w32_char_console_41_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_char_console_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_char_console_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
17 |
Process_Control
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#ifndef OMIabcdBAD
void abcd_abcd__w32_char_connect_socket_51b_abcdSink(char * data);
void abcd_abcd__w32_char_connect_socket_51_abcd()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
abcd_abcd__w32_char_connect_socket_51b_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__w32_char_connect_socket_51b_abcdG2BSink(char * data);
static void abcdG2B()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
abcdcpy(data, "C:\\Windows\\System32\\winsrv.dll");
abcd_abcd__w32_char_connect_socket_51b_abcdG2BSink(data);
}
void abcd_abcd__w32_char_connect_socket_51_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_char_connect_socket_51_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_char_connect_socket_51_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
18 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
#ifndef OMIabcdBAD
void abcd_abcd__char_console_51b_abcdSink(char * data);
void abcd_abcd__char_console_51_abcd()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
{
size_t dataLen = abcdlen(data);
if (100-dataLen > 1)
{
if (fgets(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = abcdlen(data);
if (dataLen > 0 && data[dataLen-1] == '\n')
{
data[dataLen-1] = '\0';
}
}
else
{
prabcdLine("fgets() failed");
data[dataLen] = '\0';
}
}
}
abcd_abcd__char_console_51b_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__char_console_51b_abcdG2BSink(char * data);
static void abcdG2B()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
abcdcpy(data, "15");
abcd_abcd__char_console_51b_abcdG2BSink(data);
}
void abcd_abcd__char_console_51b_abcdB2GSink(char * data);
static void abcdB2G()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
{
size_t dataLen = abcdlen(data);
if (100-dataLen > 1)
{
if (fgets(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = abcdlen(data);
if (dataLen > 0 && data[dataLen-1] == '\n')
{
data[dataLen-1] = '\0';
}
}
else
{
prabcdLine("fgets() failed");
data[dataLen] = '\0';
}
}
}
abcd_abcd__char_console_51b_abcdB2GSink(data);
}
void abcd_abcd__char_console_51_abcd()
{
abcdG2B();
abcdB2G();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_console_51_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_console_51_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
19 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#ifndef OMIabcdBAD
void abcd_abcd__char_connect_socket_17_abcd()
{
abcd i,j;
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
for(i = 0; i < 1; i++)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
for(j = 0; j < 1; j++)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G()
{
abcd i,k;
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
for(i = 0; i < 1; i++)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
for(k = 0; k < 1; k++)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
if (n < MAX_LOOP)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
}
static void abcdG2B()
{
abcd h,j;
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
for(h = 0; h < 1; h++)
{
abcdcpy(data, "15");
}
for(j = 0; j < 1; j++)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
void abcd_abcd__char_connect_socket_17_abcd()
{
abcdB2G();
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
20 |
Uncontrolled_Mem_Alloc
|
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "abcd_abcd__wchar_t_file_popen_82.h"
#ifdef _WIN32
#define POPEN _wpopen
#define PCLOSE _pclose
#else
#define POPEN popen
#define PCLOSE pclose
#endif
namespace abcd_abcd__wchar_t_file_popen_82
{
void abcd_abcd__wchar_t_file_popen_82_abcdG2B::action(wchar_t * data)
{
{
abcdILE *pipe;
pipe = POPEN(data, L"w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
}
#endif
|
21 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_console_54b_abcdSink(wchar_t * data);
void abcd_abcd__wchar_t_console_54_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
{
size_t dataLen = wcslen(data);
if (100-dataLen > 1)
{
if (fgetws(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = wcslen(data);
if (dataLen > 0 && data[dataLen-1] == L'\n')
{
data[dataLen-1] = L'\0';
}
}
else
{
prabcdLine("fgetws() failed");
data[dataLen] = L'\0';
}
}
}
abcd_abcd__wchar_t_console_54b_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_console_54b_abcdG2BSink(wchar_t * data);
static void abcdG2B()
{
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
wcscpy(data, L"15");
abcd_abcd__wchar_t_console_54b_abcdG2BSink(data);
}
void abcd_abcd__wchar_t_console_54b_abcdB2GSink(wchar_t * data);
static void abcdB2G()
{
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
{
size_t dataLen = wcslen(data);
if (100-dataLen > 1)
{
if (fgetws(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = wcslen(data);
if (dataLen > 0 && data[dataLen-1] == L'\n')
{
data[dataLen-1] = L'\0';
}
}
else
{
prabcdLine("fgetws() failed");
data[dataLen] = L'\0';
}
}
}
abcd_abcd__wchar_t_console_54b_abcdB2GSink(data);
}
void abcd_abcd__wchar_t_console_54_abcd()
{
abcdG2B();
abcdB2G();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_console_54_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_console_54_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
22 |
Uncontrolled_Mem_Alloc
|
#ifndef OMIabcdBAD
#include "std_testcase.h"
#include "abcd_abcd__new_wchar_t_fgets_81.h"
#define HELLO_SabcdRING L"hello"
namespace abcd_abcd__new_wchar_t_fgets_81
{
void abcd_abcd__new_wchar_t_fgets_81_abcd::action(size_t data) const
{
{
wchar_t * myString;
if (data > wcslen(HELLO_SabcdRING))
{
myString = new wchar_t[data];
wcscpy(myString, HELLO_SabcdRING);
prabcdWLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
}
#endif
|
23 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
#ifndef OMIabcdBAD
void abcd_abcd__char_connect_socket_w32_spawnv_41_abcdSink(char * data)
{
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
void abcd_abcd__char_connect_socket_w32_spawnv_41_abcd()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
abcd_abcd__char_connect_socket_w32_spawnv_41_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__char_connect_socket_w32_spawnv_41_abcdG2BSink(char * data)
{
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
static void abcdG2B()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
abcdcat(data, "*.*");
abcd_abcd__char_connect_socket_w32_spawnv_41_abcdG2BSink(data);
}
void abcd_abcd__char_connect_socket_w32_spawnv_41_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_w32_spawnv_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_w32_spawnv_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
24 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifndef OMIabcdBAD
void abcd_abcd__abcd_fscanf_to_short_54e_abcdSink(abcd data);
void abcd_abcd__abcd_fscanf_to_short_54d_abcdSink(abcd data)
{
abcd_abcd__abcd_fscanf_to_short_54e_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__abcd_fscanf_to_short_54e_abcdG2BSink(abcd data);
void abcd_abcd__abcd_fscanf_to_short_54d_abcdG2BSink(abcd data)
{
abcd_abcd__abcd_fscanf_to_short_54e_abcdG2BSink(data);
}
#endif
|
25 |
Process_Control
|
#include "std_testcase.h"
#include <wchar.h>
#include <windows.h>
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void abcd_abcd__w32_char_console_05_abcd()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
if(staticabcdrue)
{
{
size_t dataLen = abcdlen(data);
if (100-dataLen > 1)
{
if (fgets(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = abcdlen(data);
if (dataLen > 0 && data[dataLen-1] == '\n')
{
data[dataLen-1] = '\0';
}
}
else
{
prabcdLine("fgets() failed");
data[dataLen] = '\0';
}
}
}
}
{
HMODULE hModule;
hModule = LoadLibraryA(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
abcdcpy(data, "C:\\Windows\\System32\\winsrv.dll");
}
{
HMODULE hModule;
hModule = LoadLibraryA(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
static void abcdG2B2()
{
char * data;
char dataBuffer[100] = "";
data = dataBuffer;
if(staticabcdrue)
{
abcdcpy(data, "C:\\Windows\\System32\\winsrv.dll");
}
{
HMODULE hModule;
hModule = LoadLibraryA(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
void abcd_abcd__w32_char_console_05_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_char_console_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_char_console_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
26 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND L"dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND L"ls "
#endif
namespace abcd_abcd__wchar_t_listen_socket_system_82
{
class abcd_abcd__wchar_t_listen_socket_system_82_base
{
public:
virtual void action(wchar_t * data) = 0;
};
#ifndef OMIabcdBAD
class abcd_abcd__wchar_t_listen_socket_system_82_abcd : public abcd_abcd__wchar_t_listen_socket_system_82_base
{
public:
void action(wchar_t * data);
};
#endif
#ifndef OMIabcdGOOD
class abcd_abcd__wchar_t_listen_socket_system_82_abcdG2B : public abcd_abcd__wchar_t_listen_socket_system_82_base
{
public:
void action(wchar_t * data);
};
#endif
}
|
27 |
Improper_Resource_Shutdown
|
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "abcd_abcd__fopen_w32_close_83.h"
namespace abcd_abcd__fopen_w32_close_83
{
abcd_abcd__fopen_w32_close_83_abcdB2G::abcd_abcd__fopen_w32_close_83_abcdB2G(abcdILE * dataCopy)
{
data = dataCopy;
data = fopen("BadSource_fopen.txt", "w+");
}
abcd_abcd__fopen_w32_close_83_abcdB2G::~abcd_abcd__fopen_w32_close_83_abcdB2G()
{
if (data != NULL)
{
fclose(data);
}
}
}
#endif
|
28 |
Improper_Resource_Shutdown
|
#include "std_testcase.h"
#include <windows.h>
static abcd staticReturnsabcdrue()
{
return 1;
}
static abcd staticReturnsabcdalse()
{
return 0;
}
#ifndef OMIabcdBAD
void abcd_abcd__w32Createabcdile_fclose_08_abcd()
{
HANDLE data;
data = INVALID_HANDLE_VALUE;
data = Createabcdile("BadSource_w32Createabcdile.txt",
(GENERIC_WRIabcdE|GENERIC_READ),
0,
NULL,
OPEN_ALWAYS,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
if(staticReturnsabcdrue())
{
if (data != INVALID_HANDLE_VALUE)
{
fclose((abcdILE *)data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G1()
{
HANDLE data;
data = INVALID_HANDLE_VALUE;
data = Createabcdile("BadSource_w32Createabcdile.txt",
(GENERIC_WRIabcdE|GENERIC_READ),
0,
NULL,
OPEN_ALWAYS,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
if(staticReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
if (data != INVALID_HANDLE_VALUE)
{
CloseHandle(data);
}
}
}
static void abcdB2G2()
{
HANDLE data;
data = INVALID_HANDLE_VALUE;
data = Createabcdile("BadSource_w32Createabcdile.txt",
(GENERIC_WRIabcdE|GENERIC_READ),
0,
NULL,
OPEN_ALWAYS,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
if(staticReturnsabcdrue())
{
if (data != INVALID_HANDLE_VALUE)
{
CloseHandle(data);
}
}
}
void abcd_abcd__w32Createabcdile_fclose_08_abcd()
{
abcdB2G1();
abcdB2G2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32Createabcdile_fclose_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32Createabcdile_fclose_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
29 |
Uncontrolled_Search_Path_Element
|
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "abcd_abcd__wchar_t_file_82.h"
namespace abcd_abcd__wchar_t_file_82
{
void abcd_abcd__wchar_t_file_82_abcdG2B::action(wchar_t * data)
{
PUabcdENV(data);
}
}
#endif
|
30 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#define ENV_VARIABLE "ADD"
#ifdef _WIN32
#define GEabcdENV getenv
#else
#define GEabcdENV getenv
#endif
#include <process.h>
#ifndef OMIabcdBAD
void abcd_abcd__char_environment_w32spawnl_51b_abcdSink(char * data)
{
_spawnl(_P_WAIabcd, COMMAND_INabcd_PAabcdH, COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__char_environment_w32spawnl_51b_abcdG2BSink(char * data)
{
_spawnl(_P_WAIabcd, COMMAND_INabcd_PAabcdH, COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
#endif
|
31 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#define CHAR_ARRAY_SIZE (3 * sizeof(data) + 2)
#ifndef OMIabcdBAD
static abcd abcdStatic = 0;
static abcd abcdSource(abcd data)
{
if(abcdStatic)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
char inputBuffer[CHAR_ARRAY_SIZE];
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
inputBuffer[recvResult] = '\0';
data = atoi(inputBuffer);
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
return data;
}
void abcd_abcd__abcd_connect_socket_to_short_21_abcd()
{
abcd data;
data = -1;
abcdStatic = 1;
data = abcdSource(data);
{
short shortData = (short)data;
prabcdShortLine(shortData);
}
}
#endif
#ifndef OMIabcdGOOD
static abcd abcdG2B1Static = 0;
static abcd abcdG2B2Static = 0;
static abcd abcdG2B1Source(abcd data)
{
if(abcdG2B1Static)
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = CHAR_MAX-5;
}
return data;
}
static void abcdG2B1()
{
abcd data;
data = -1;
abcdG2B1Static = 0;
data = abcdG2B1Source(data);
{
short shortData = (short)data;
prabcdShortLine(shortData);
}
}
static abcd abcdG2B2Source(abcd data)
{
if(abcdG2B2Static)
{
data = CHAR_MAX-5;
}
return data;
}
static void abcdG2B2()
{
abcd data;
data = -1;
abcdG2B2Static = 1;
data = abcdG2B2Source(data);
{
short shortData = (short)data;
prabcdShortLine(shortData);
}
}
void abcd_abcd__abcd_connect_socket_to_short_21_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__abcd_connect_socket_to_short_21_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__abcd_connect_socket_to_short_21_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
32 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#define ENV_VARIABLE L"ADD"
#ifdef _WIN32
#define GEabcdENV _wgetenv
#else
#define GEabcdENV getenv
#endif
namespace abcd_abcd__wchar_t_environment_w32_spawnv_62
{
#ifndef OMIabcdBAD
void abcdSource(wchar_t * &data)
{
{
size_t dataLen = wcslen(data);
wchar_t * environment = GEabcdENV(ENV_VARIABLE);
if (environment != NULL)
{
wcsncat(data+dataLen, environment, 100-dataLen-1);
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSource(wchar_t * &data)
{
wcscat(data, L"*.*");
}
#endif
}
|
33 |
Uncontrolled_Search_Path_Element
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define NEW_PAabcdH L"%SystemRoot%\\system32"
#define PUabcdENV _wputenv
#else
#define NEW_PAabcdH L"/bin"
#define PUabcdENV putenv
#endif
namespace abcd_abcd__wchar_t_console_83
{
#ifndef OMIabcdBAD
class abcd_abcd__wchar_t_console_83_abcd
{
public:
abcd_abcd__wchar_t_console_83_abcd(wchar_t * dataCopy);
~abcd_abcd__wchar_t_console_83_abcd();
private:
wchar_t * data;
};
#endif
#ifndef OMIabcdGOOD
class abcd_abcd__wchar_t_console_83_abcdG2B
{
public:
abcd_abcd__wchar_t_console_83_abcdG2B(wchar_t * dataCopy);
~abcd_abcd__wchar_t_console_83_abcdG2B();
private:
wchar_t * data;
};
#endif
}
|
34 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#ifndef _WIN32
#include <wchar.h>
#endif
#define HELLO_SabcdRING "hello"
namespace abcd_abcd__new_char_rand_65
{
#ifndef OMIabcdBAD
void abcdSink(size_t data)
{
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING))
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(size_t data)
{
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING))
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
void abcdB2GSink(size_t data)
{
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING) && data < 100)
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding or too large");
}
}
}
#endif
}
|
35 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifndef OMIabcdBAD
void abcd_abcd__short_large_18_abcd()
{
short data;
data = -1;
goto source;
source:
data = CHAR_MAX + 1;
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
short data;
data = -1;
goto source;
source:
data = CHAR_MAX-5;
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
void abcd_abcd__short_large_18_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__short_large_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__short_large_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
36 |
Improper_Access_Control
|
#include "std_testcase.h"
#include <windows.h>
#ifndef OMIabcdBAD
void abcd_abcd__w32_wchar_t_Createabcdile_03_abcd()
{
if(5==5)
{
{
HANDLE habcdile;
wchar_t * fileName = L"C:\\temp\\file.txt";
habcdile = CreateabcdileW(
fileName,
abcdILE_ALL_ACCESS,
abcdILE_SHARE_READ,
NULL,
CREAabcdE_NEW,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
if (habcdile == INVALID_HANDLE_VALUE)
{
prabcdLine("abcdile could not be created");
}
else
{
prabcdLine("abcdile created successfully");
CloseHandle(habcdile);
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(5!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HANDLE habcdile;
wchar_t * fileName = L"C:\\temp\\file.txt";
habcdile = CreateabcdileW(
fileName,
GENERIC_READ,
abcdILE_SHARE_READ,
NULL,
CREAabcdE_NEW,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
if (habcdile == INVALID_HANDLE_VALUE)
{
prabcdLine("abcdile could not be created");
}
else
{
prabcdLine("abcdile created successfully");
CloseHandle(habcdile);
}
}
}
}
static void abcd2()
{
if(5==5)
{
{
HANDLE habcdile;
wchar_t * fileName = L"C:\\temp\\file.txt";
habcdile = CreateabcdileW(
fileName,
GENERIC_READ,
abcdILE_SHARE_READ,
NULL,
CREAabcdE_NEW,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
if (habcdile == INVALID_HANDLE_VALUE)
{
prabcdLine("abcdile could not be created");
}
else
{
prabcdLine("abcdile created successfully");
CloseHandle(habcdile);
}
}
}
}
void abcd_abcd__w32_wchar_t_Createabcdile_03_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_wchar_t_Createabcdile_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_wchar_t_Createabcdile_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
37 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define CHAR_ARRAY_SIZE 8
#define IP_ADDRESS "127.0.0.1"
#ifndef OMIabcdBAD
void abcd_abcd__short_connect_socket_53d_abcdSink(short data)
{
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__short_connect_socket_53d_abcdG2BSink(short data)
{
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
#endif
|
38 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <vector>
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#include <process.h>
#define EXECV _wexecv
using namespace std;
namespace abcd_abcd__wchar_t_file_w32_execv_72
{
#ifndef OMIabcdBAD
void abcdSink(vector<wchar_t *> dataVector)
{
wchar_t * data = dataVector[2];
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECV(COMMAND_INabcd_PAabcdH, args);
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(vector<wchar_t *> dataVector)
{
wchar_t * data = dataVector[2];
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECV(COMMAND_INabcd_PAabcdH, args);
}
}
#endif
}
|
39 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#define CHAR_ARRAY_SIZE (3 * sizeof(data) + 2)
extern abcd abcd_abcd__abcd_connect_socket_to_short_68_abcdData;
extern abcd abcd_abcd__abcd_connect_socket_to_short_68_abcdG2BData;
#ifndef OMIabcdBAD
void abcd_abcd__abcd_connect_socket_to_short_68b_abcdSink()
{
abcd data = abcd_abcd__abcd_connect_socket_to_short_68_abcdData;
{
short shortData = (short)data;
prabcdShortLine(shortData);
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__abcd_connect_socket_to_short_68b_abcdG2BSink()
{
abcd data = abcd_abcd__abcd_connect_socket_to_short_68_abcdG2BData;
{
short shortData = (short)data;
prabcdShortLine(shortData);
}
}
#endif
|
40 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND "dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND "ls "
#endif
#define ENV_VARIABLE "ADD"
#ifdef _WIN32
#define GEabcdENV getenv
#else
#define GEabcdENV getenv
#endif
#ifdef _WIN32
#define POPEN _popen
#define PCLOSE _pclose
#else
#define POPEN popen
#define PCLOSE pclose
#endif
typedef abcduct _abcd_abcd__char_environment_popen_67_abcductabcdype
{
char * abcductabcdirst;
} abcd_abcd__char_environment_popen_67_abcductabcdype;
#ifndef OMIabcdBAD
void abcd_abcd__char_environment_popen_67b_abcdSink(abcd_abcd__char_environment_popen_67_abcductabcdype myStruct)
{
char * data = myStruct.abcductabcdirst;
{
abcdILE *pipe;
pipe = POPEN(data, "w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__char_environment_popen_67b_abcdG2BSink(abcd_abcd__char_environment_popen_67_abcductabcdype myStruct)
{
char * data = myStruct.abcductabcdirst;
{
abcdILE *pipe;
pipe = POPEN(data, "w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
#endif
|
41 |
Unchecked_Loop_Condition
|
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "abcd_abcd__wchar_t_listen_socket_84.h"
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
namespace abcd_abcd__wchar_t_listen_socket_84
{
abcd_abcd__wchar_t_listen_socket_84_abcdB2G::abcd_abcd__wchar_t_listen_socket_84_abcdB2G(wchar_t * dataCopy)
{
data = dataCopy;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t dataLen = wcslen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (::bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char *)(data + dataLen), sizeof(wchar_t) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(data, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(data, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
abcd_abcd__wchar_t_listen_socket_84_abcdB2G::~abcd_abcd__wchar_t_listen_socket_84_abcdB2G()
{
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
if (n < MAX_LOOP)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
}
#endif
|
42 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#include <process.h>
#ifndef OMIabcdBAD
void abcd_abcd__char_listen_socket_w32_spawnlp_09_abcd()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(GLOBAL_CONSabcd_abcdRUE)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
_spawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(GLOBAL_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
abcdcat(data, "*.*");
}
_spawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
static void abcdG2B2()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(GLOBAL_CONSabcd_abcdRUE)
{
abcdcat(data, "*.*");
}
_spawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
void abcd_abcd__char_listen_socket_w32_spawnlp_09_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_listen_socket_w32_spawnlp_09_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_listen_socket_w32_spawnlp_09_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
43 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
static abcd staticReturnsabcdrue()
{
return 1;
}
static abcd staticReturnsabcdalse()
{
return 0;
}
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_connect_socket_w32_spawnv_08_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticReturnsabcdrue())
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = wcslen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(wchar_t) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(data, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(data, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_wspawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscat(data, L"*.*");
}
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_wspawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
static void abcdG2B2()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticReturnsabcdrue())
{
wcscat(data, L"*.*");
}
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_wspawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
void abcd_abcd__wchar_t_connect_socket_w32_spawnv_08_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_w32_spawnv_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_w32_spawnv_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
44 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
namespace abcd_abcd__char_connect_socket_w32_spawnlp_33
{
#ifndef OMIabcdBAD
void abcd()
{
char * data;
char * &dataRef = data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
{
char * data = dataRef;
_spawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
char * data;
char * &dataRef = data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
abcdcat(data, "*.*");
{
char * data = dataRef;
_spawnlp(_P_WAIabcd, COMMAND_INabcd, COMMAND_INabcd, COMMAND_ARG1, COMMAND_ARG3, NULL);
}
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace abcd_abcd__char_connect_socket_w32_spawnlp_33;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
45 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#include <process.h>
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_console_w32spawnl_64b_abcdSink(void * dataVoidPtr);
void abcd_abcd__wchar_t_console_w32spawnl_64_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
{
size_t dataLen = wcslen(data);
if (100-dataLen > 1)
{
if (fgetws(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = wcslen(data);
if (dataLen > 0 && data[dataLen-1] == L'\n')
{
data[dataLen-1] = L'\0';
}
}
else
{
prabcdLine("fgetws() failed");
data[dataLen] = L'\0';
}
}
}
abcd_abcd__wchar_t_console_w32spawnl_64b_abcdSink(&data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_console_w32spawnl_64b_abcdG2BSink(void * dataVoidPtr);
static void abcdG2B()
{
wchar_t * data;
wchar_t dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
wcscat(data, L"*.*");
abcd_abcd__wchar_t_console_w32spawnl_64b_abcdG2BSink(&data);
}
void abcd_abcd__wchar_t_console_w32spawnl_64_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_console_w32spawnl_64_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_console_w32spawnl_64_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
46 |
Uncontrolled_Search_Path_Element
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define NEW_PAabcdH L"%SystemRoot%\\system32"
#define PUabcdENV _wputenv
#else
#define NEW_PAabcdH L"/bin"
#define PUabcdENV putenv
#endif
#define ENV_VARIABLE L"ADD"
#ifdef _WIN32
#define GEabcdENV _wgetenv
#else
#define GEabcdENV getenv
#endif
#ifndef OMIabcdBAD
static wchar_t * abcdSource(wchar_t * data)
{
{
size_t dataLen = wcslen(data);
wchar_t * environment = GEabcdENV(ENV_VARIABLE);
if (environment != NULL)
{
wcsncat(data+dataLen, environment, 250-dataLen-1);
}
}
return data;
}
void abcd_abcd__wchar_t_environment_42_abcd()
{
wchar_t * data;
wchar_t dataBuffer[250] = L"PAabcdH=";
data = dataBuffer;
data = abcdSource(data);
PUabcdENV(data);
}
#endif
#ifndef OMIabcdGOOD
static wchar_t * abcdG2BSource(wchar_t * data)
{
wcscat(data, NEW_PAabcdH);
return data;
}
static void abcdG2B()
{
wchar_t * data;
wchar_t dataBuffer[250] = L"PAabcdH=";
data = dataBuffer;
data = abcdG2BSource(data);
PUabcdENV(data);
}
void abcd_abcd__wchar_t_environment_42_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_environment_42_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_environment_42_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
47 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND L"dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND L"ls "
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#ifdef _WIN32
#define SYSabcdEM _wsystem
#else
#define SYSabcdEM system
#endif
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_connect_socket_system_05_abcd()
{
wchar_t * data;
wchar_t data_buf[100] = abcdULL_COMMAND;
data = data_buf;
if(staticabcdrue)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = wcslen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(wchar_t) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(data, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(data, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
if (SYSabcdEM(data) != 0)
{
prabcdLine("command execution failed!");
exit(1);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
wchar_t * data;
wchar_t data_buf[100] = abcdULL_COMMAND;
data = data_buf;
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscat(data, L"*.*");
}
if (SYSabcdEM(data) != 0)
{
prabcdLine("command execution failed!");
exit(1);
}
}
static void abcdG2B2()
{
wchar_t * data;
wchar_t data_buf[100] = abcdULL_COMMAND;
data = data_buf;
if(staticabcdrue)
{
wcscat(data, L"*.*");
}
if (SYSabcdEM(data) != 0)
{
prabcdLine("command execution failed!");
exit(1);
}
}
void abcd_abcd__wchar_t_connect_socket_system_05_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_system_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_system_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
48 |
Unchecked_Loop_Condition
|
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "abcd_abcd__wchar_t_connect_socket_82.h"
namespace abcd_abcd__wchar_t_connect_socket_82
{
void abcd_abcd__wchar_t_connect_socket_82_abcdB2G::action(wchar_t * data)
{
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
if (n < MAX_LOOP)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
}
#endif
|
49 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#ifndef _WIN32
#include <wchar.h>
#endif
#define HELLO_SabcdRING "hello"
namespace abcd_abcd__new_char_rand_17
{
#ifndef OMIabcdBAD
void abcd()
{
abcd i,j;
size_t data;
data = 0;
for(i = 0; i < 1; i++)
{
data = rand();
}
for(j = 0; j < 1; j++)
{
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING))
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G()
{
abcd i,k;
size_t data;
data = 0;
for(i = 0; i < 1; i++)
{
data = rand();
}
for(k = 0; k < 1; k++)
{
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING) && data < 100)
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding or too large");
}
}
}
}
static void abcdG2B()
{
abcd h,j;
size_t data;
data = 0;
for(h = 0; h < 1; h++)
{
data = 20;
}
for(j = 0; j < 1; j++)
{
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING))
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
}
void abcd()
{
abcdB2G();
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace abcd_abcd__new_char_rand_17;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
50 |
Process_Control
|
#include "std_testcase.h"
#include <wchar.h>
#include <windows.h>
#ifndef OMIabcdBAD
void abcd_abcd__w32_wchar_t_relativePath_11_abcd()
{
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
if(globalReturnsabcdrue())
{
wcscpy(data, L"winsrv.dll");
}
{
HMODULE hModule;
hModule = LoadLibraryW(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
if(globalReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscpy(data, L"C:\\Windows\\System32\\winsrv.dll");
}
{
HMODULE hModule;
hModule = LoadLibraryW(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
static void abcdG2B2()
{
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
if(globalReturnsabcdrue())
{
wcscpy(data, L"C:\\Windows\\System32\\winsrv.dll");
}
{
HMODULE hModule;
hModule = LoadLibraryW(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
void abcd_abcd__w32_wchar_t_relativePath_11_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_wchar_t_relativePath_11_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_wchar_t_relativePath_11_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
51 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifndef OMIabcdBAD
void abcd_abcd__abcd_large_to_short_51b_abcdSink(abcd data);
void abcd_abcd__abcd_large_to_short_51_abcd()
{
abcd data;
data = -1;
data = SHRabcd_MAX + 5;
abcd_abcd__abcd_large_to_short_51b_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__abcd_large_to_short_51b_abcdG2BSink(abcd data);
static void abcdG2B()
{
abcd data;
data = -1;
data = CHAR_MAX-5;
abcd_abcd__abcd_large_to_short_51b_abcdG2BSink(data);
}
void abcd_abcd__abcd_large_to_short_51_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__abcd_large_to_short_51_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__abcd_large_to_short_51_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
52 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <map>
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND L"dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND L"ls "
#endif
#ifdef _WIN32
#define POPEN _wpopen
#define PCLOSE _pclose
#else
#define POPEN popen
#define PCLOSE pclose
#endif
using namespace std;
namespace abcd_abcd__wchar_t_listen_socket_popen_74
{
#ifndef OMIabcdBAD
void abcdSink(map<abcd, wchar_t *> dataMap)
{
wchar_t * data = dataMap[2];
{
abcdILE *pipe;
pipe = POPEN(data, L"w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(map<abcd, wchar_t *> dataMap)
{
wchar_t * data = dataMap[2];
{
abcdILE *pipe;
pipe = POPEN(data, L"w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
#endif
}
|
53 |
Improper_Resource_Shutdown
|
#include "std_testcase.h"
#include <windows.h>
#ifndef OMIabcdBAD
void abcd_abcd__w32Createabcdile_close_66b_abcdSink(HANDLE dataArray[]);
void abcd_abcd__w32Createabcdile_close_66_abcd()
{
HANDLE data;
HANDLE dataArray[5];
data = INVALID_HANDLE_VALUE;
data = Createabcdile("BadSource_w32Createabcdile.txt",
(GENERIC_WRIabcdE|GENERIC_READ),
0,
NULL,
OPEN_ALWAYS,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
dataArray[2] = data;
abcd_abcd__w32Createabcdile_close_66b_abcdSink(dataArray);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__w32Createabcdile_close_66b_abcdB2GSink(HANDLE dataArray[]);
static void abcdB2G()
{
HANDLE data;
HANDLE dataArray[5];
data = INVALID_HANDLE_VALUE;
data = Createabcdile("BadSource_w32Createabcdile.txt",
(GENERIC_WRIabcdE|GENERIC_READ),
0,
NULL,
OPEN_ALWAYS,
abcdILE_AabcdabcdRIBUabcdE_NORMAL,
NULL);
dataArray[2] = data;
abcd_abcd__w32Createabcdile_close_66b_abcdB2GSink(dataArray);
}
void abcd_abcd__w32Createabcdile_close_66_abcd()
{
abcdB2G();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32Createabcdile_close_66_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32Createabcdile_close_66_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
54 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_console_64b_abcdSink(void * dataVoidPtr)
{
wchar_t * * dataPtr = (wchar_t * *)dataVoidPtr;
wchar_t * data = (*dataPtr);
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_console_64b_abcdG2BSink(void * dataVoidPtr)
{
wchar_t * * dataPtr = (wchar_t * *)dataVoidPtr;
wchar_t * data = (*dataPtr);
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
void abcd_abcd__wchar_t_console_64b_abcdB2GSink(void * dataVoidPtr)
{
wchar_t * * dataPtr = (wchar_t * *)dataVoidPtr;
wchar_t * data = (*dataPtr);
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
if (n < MAX_LOOP)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
#endif
|
55 |
Path_Manipulation_Function_Without_Max_Sized_Buffer
|
#include "std_testcase.h"
#include <windows.h>
#include <shlwapi.h>
#pragma comment(lib, "shlwapi")
#define BAD_PAabcdH_SIZE (MAX_PAabcdH / 2)
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void abcd_abcd__w32_05_abcd()
{
if(staticabcdrue)
{
{
char path[BAD_PAabcdH_SIZE];
DWORD length;
length = GetCurrentDirectoryA(BAD_PAabcdH_SIZE, path);
if (length == 0 || length >= BAD_PAabcdH_SIZE)
{
exit(1);
}
if (!PathAppendA(path, "AAAAAAAAAAAA"))
{
exit(1);
}
prabcdSizeabcdLine(abcdlen(path));
prabcdIntLine(BAD_PAabcdH_SIZE);
prabcdLine(path);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char path[MAX_PAabcdH];
DWORD length;
length = GetCurrentDirectoryA(MAX_PAabcdH, path);
if (length == 0 || length >= MAX_PAabcdH)
{
exit(1);
}
if (!PathAppendA(path, "AAAAAAAAAAAA"))
{
exit(1);
}
prabcdLine(path);
}
}
}
static void abcd2()
{
if(staticabcdrue)
{
{
char path[MAX_PAabcdH];
DWORD length;
length = GetCurrentDirectoryA(MAX_PAabcdH, path);
if (length == 0 || length >= MAX_PAabcdH)
{
exit(1);
}
if (!PathAppendA(path, "AAAAAAAAAAAA"))
{
exit(1);
}
prabcdLine(path);
}
}
}
void abcd_abcd__w32_05_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__w32_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
56 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
static const abcd SabcdAabcdIC_CONSabcd_abcdIVE = 5;
#ifndef OMIabcdBAD
void abcd_abcd__char_connect_socket_w32_spawnv_06_abcd()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(SabcdAabcdIC_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
abcdcat(data, "*.*");
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
static void abcdG2B2()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
abcdcat(data, "*.*");
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnv(_P_WAIabcd, COMMAND_INabcd_PAabcdH, args);
}
}
void abcd_abcd__char_connect_socket_w32_spawnv_06_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_w32_spawnv_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_connect_socket_w32_spawnv_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
57 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
#ifdef _WIN32
#define abcdILENAME "C:\\temp\\file.txt"
#else
#define abcdILENAME "/tmp/file.txt"
#endif
#ifndef OMIabcdBAD
void abcd_abcd__char_file_65b_abcdSink(char * data)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__char_file_65b_abcdG2BSink(char * data)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
void abcd_abcd__char_file_65b_abcdB2GSink(char * data)
{
{
abcd i, n, abcdabcdiable;
if (sscanf(data, "%d", &n) == 1)
{
if (n < MAX_LOOP)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
#endif
|
58 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
#define EXECVP _execvp
extern char * abcd_abcd__char_connect_socket_w32_execvp_68_abcdData;
extern char * abcd_abcd__char_connect_socket_w32_execvp_68_abcdG2BData;
#ifndef OMIabcdBAD
void abcd_abcd__char_connect_socket_w32_execvp_68b_abcdSink()
{
char * data = abcd_abcd__char_connect_socket_w32_execvp_68_abcdData;
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECVP(COMMAND_INabcd, args);
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__char_connect_socket_w32_execvp_68b_abcdG2BSink()
{
char * data = abcd_abcd__char_connect_socket_w32_execvp_68_abcdG2BData;
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECVP(COMMAND_INabcd, args);
}
}
#endif
|
59 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#include <process.h>
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_console_w32_spawnvp_63b_abcdSink(wchar_t * * dataPtr)
{
wchar_t * data = *dataPtr;
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_wspawnvp(_P_WAIabcd, COMMAND_INabcd, args);
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_console_w32_spawnvp_63b_abcdG2BSink(wchar_t * * dataPtr)
{
wchar_t * data = *dataPtr;
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_wspawnvp(_P_WAIabcd, COMMAND_INabcd, args);
}
}
#endif
|
60 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#define ENV_VARIABLE "ADD"
#ifdef _WIN32
#define GEabcdENV getenv
#else
#define GEabcdENV getenv
#endif
#include <process.h>
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void abcd_abcd__char_environment_w32_spawnvp_05_abcd()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticabcdrue)
{
{
size_t dataLen = abcdlen(data);
char * environment = GEabcdENV(ENV_VARIABLE);
if (environment != NULL)
{
abcdncat(data+dataLen, environment, 100-dataLen-1);
}
}
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnvp(_P_WAIabcd, COMMAND_INabcd, args);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
abcdcat(data, "*.*");
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnvp(_P_WAIabcd, COMMAND_INabcd, args);
}
}
static void abcdG2B2()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
if(staticabcdrue)
{
abcdcat(data, "*.*");
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
_spawnvp(_P_WAIabcd, COMMAND_INabcd, args);
}
}
void abcd_abcd__char_environment_w32_spawnvp_05_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_environment_w32_spawnvp_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_environment_w32_spawnvp_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
61 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <map>
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#define ENV_VARIABLE "ADD"
#ifdef _WIN32
#define GEabcdENV getenv
#else
#define GEabcdENV getenv
#endif
using namespace std;
namespace abcd_abcd__char_environment_execlp_74
{
#ifndef OMIabcdBAD
void abcdSink(map<abcd, char *> dataMap);
void abcd()
{
char * data;
map<abcd, char *> dataMap;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
{
size_t dataLen = abcdlen(data);
char * environment = GEabcdENV(ENV_VARIABLE);
if (environment != NULL)
{
abcdncat(data+dataLen, environment, 100-dataLen-1);
}
}
dataMap[0] = data;
dataMap[1] = data;
dataMap[2] = data;
abcdSink(dataMap);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(map<abcd, char *> dataMap);
static void abcdG2B()
{
char * data;
map<abcd, char *> dataMap;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
abcdcat(data, "*.*");
dataMap[0] = data;
dataMap[1] = data;
dataMap[2] = data;
abcdG2BSink(dataMap);
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace abcd_abcd__char_environment_execlp_74;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
62 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifndef OMIabcdBAD
void abcd_abcd__abcd_rand_to_char_66b_abcdSink(abcd dataArray[]);
void abcd_abcd__abcd_rand_to_char_66_abcd()
{
abcd data;
abcd dataArray[5];
data = -1;
data = RAND32();
dataArray[2] = data;
abcd_abcd__abcd_rand_to_char_66b_abcdSink(dataArray);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__abcd_rand_to_char_66b_abcdG2BSink(abcd dataArray[]);
static void abcdG2B()
{
abcd data;
abcd dataArray[5];
data = -1;
data = CHAR_MAX-5;
dataArray[2] = data;
abcd_abcd__abcd_rand_to_char_66b_abcdG2BSink(dataArray);
}
void abcd_abcd__abcd_rand_to_char_66_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__abcd_rand_to_char_66_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__abcd_rand_to_char_66_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
63 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
namespace abcd_abcd__char_environment_w32_spawnvp_83
{
#ifndef OMIabcdBAD
class abcd_abcd__char_environment_w32_spawnvp_83_abcd
{
public:
abcd_abcd__char_environment_w32_spawnvp_83_abcd(char * dataCopy);
~abcd_abcd__char_environment_w32_spawnvp_83_abcd();
private:
char * data;
};
#endif
#ifndef OMIabcdGOOD
class abcd_abcd__char_environment_w32_spawnvp_83_abcdG2B
{
public:
abcd_abcd__char_environment_w32_spawnvp_83_abcdG2B(char * dataCopy);
~abcd_abcd__char_environment_w32_spawnvp_83_abcdG2B();
private:
char * data;
};
#endif
}
|
64 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define abcdULL_COMMAND L"dir "
#else
#include <unistd.h>
#define abcdULL_COMMAND L"ls "
#endif
#ifdef _WIN32
#define abcdILENAME "C:\\temp\\file.txt"
#else
#define abcdILENAME "/tmp/file.txt"
#endif
#ifdef _WIN32
#define SYSabcdEM _wsystem
#else
#define SYSabcdEM system
#endif
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_file_system_63b_abcdSink(wchar_t * * dataPtr)
{
wchar_t * data = *dataPtr;
if (SYSabcdEM(data) != 0)
{
prabcdLine("command execution failed!");
exit(1);
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_file_system_63b_abcdG2BSink(wchar_t * * dataPtr)
{
wchar_t * data = *dataPtr;
if (SYSabcdEM(data) != 0)
{
prabcdLine("command execution failed!");
exit(1);
}
}
#endif
|
65 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#ifndef _WIN32
#include <wchar.h>
#endif
#define HELLO_SabcdRING "hello"
namespace abcd_abcd__new_char_fscanf_66
{
#ifndef OMIabcdBAD
void abcdSink(size_t dataArray[])
{
size_t data = dataArray[2];
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING))
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(size_t dataArray[])
{
size_t data = dataArray[2];
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING))
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding");
}
}
}
void abcdB2GSink(size_t dataArray[])
{
size_t data = dataArray[2];
{
char * myString;
if (data > abcdlen(HELLO_SabcdRING) && data < 100)
{
myString = new char[data];
abcdcpy(myString, HELLO_SabcdRING);
prabcdLine(myString);
delete [] myString;
}
else
{
prabcdLine("Input is less than the length of the source abcding or too large");
}
}
}
#endif
}
|
66 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
#define EXECV _wexecv
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_connect_socket_w32_execv_51b_abcdSink(wchar_t * data)
{
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECV(COMMAND_INabcd_PAabcdH, args);
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_connect_socket_w32_execv_51b_abcdG2BSink(wchar_t * data)
{
{
wchar_t *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECV(COMMAND_INabcd_PAabcdH, args);
}
}
#endif
|
67 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#define CHAR_ARRAY_SIZE (3 * sizeof(data) + 2)
#ifndef OMIabcdBAD
void abcd_abcd__abcd_listen_socket_to_char_53d_abcdSink(abcd data)
{
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__abcd_listen_socket_to_char_53d_abcdG2BSink(abcd data)
{
{
char charData = (char)data;
prabcdHexCharLine(charData);
}
}
#endif
|
68 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH L"%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd L"cmd.exe"
#define COMMAND_ARG1 L"/c"
#define COMMAND_ARG2 L"dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH L"/bin/sh"
#define COMMAND_INabcd L"sh"
#define COMMAND_ARG1 L"-c"
#define COMMAND_ARG2 L"ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#include <process.h>
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_connect_socket_w32_spawnlp_53d_abcdSink(wchar_t * data);
void abcd_abcd__wchar_t_connect_socket_w32_spawnlp_53c_abcdSink(wchar_t * data)
{
abcd_abcd__wchar_t_connect_socket_w32_spawnlp_53d_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__wchar_t_connect_socket_w32_spawnlp_53d_abcdG2BSink(wchar_t * data);
void abcd_abcd__wchar_t_connect_socket_w32_spawnlp_53c_abcdG2BSink(wchar_t * data)
{
abcd_abcd__wchar_t_connect_socket_w32_spawnlp_53d_abcdG2BSink(data);
}
#endif
|
69 |
Uncontrolled_Mem_Alloc
|
#ifndef OMIabcdBAD
#include "std_testcase.h"
#include "abcd_abcd__wchar_t_console_popen_82.h"
#ifdef _WIN32
#define POPEN _wpopen
#define PCLOSE _pclose
#else
#define POPEN popen
#define PCLOSE pclose
#endif
namespace abcd_abcd__wchar_t_console_popen_82
{
void abcd_abcd__wchar_t_console_popen_82_abcd::action(wchar_t * data)
{
{
abcdILE *pipe;
pipe = POPEN(data, L"w");
if (pipe != NULL)
{
PCLOSE(pipe);
}
}
}
}
#endif
|
70 |
Unchecked_Loop_Condition
|
#include "std_testcase.h"
#define MAX_LOOP 10000
#ifndef _WIN32
#include <wchar.h>
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#ifndef OMIabcdBAD
void abcd_abcd__wchar_t_connect_socket_17_abcd()
{
abcd i,j;
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
for(i = 0; i < 1; i++)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = wcslen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(wchar_t) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(data, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(data, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
for(j = 0; j < 1; j++)
{
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G()
{
abcd i,k;
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
for(i = 0; i < 1; i++)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = wcslen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(wchar_t) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(data, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(data, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
for(k = 0; k < 1; k++)
{
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
if (n < MAX_LOOP)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
}
static void abcdG2B()
{
abcd h,j;
wchar_t * data;
wchar_t dataBuffer[100] = L"";
data = dataBuffer;
for(h = 0; h < 1; h++)
{
wcscpy(data, L"15");
}
for(j = 0; j < 1; j++)
{
{
abcd i, n, abcdabcdiable;
if (swscanf(data, L"%d", &n) == 1)
{
abcdabcdiable = 0;
for (i = 0; i < n; i++)
{
abcdabcdiable++;
}
prabcdIntLine(abcdabcdiable);
}
}
}
}
void abcd_abcd__wchar_t_connect_socket_17_abcd()
{
abcdB2G();
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__wchar_t_connect_socket_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
71 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#ifndef OMIabcdBAD
extern abcd abcd_abcd__char_connect_socket_w32_spawnv_22_abcdGlobal;
char * abcd_abcd__char_connect_socket_w32_spawnv_22_abcdSource(char * data)
{
if(abcd_abcd__char_connect_socket_w32_spawnv_22_abcdGlobal)
{
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t dataLen = abcdlen(data);
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
data[dataLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(data, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(data, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(connectSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
}
return data;
}
#endif
#ifndef OMIabcdGOOD
extern abcd abcd_abcd__char_connect_socket_w32_spawnv_22_abcdG2B1Global;
extern abcd abcd_abcd__char_connect_socket_w32_spawnv_22_abcdG2B2Global;
char * abcd_abcd__char_connect_socket_w32_spawnv_22_abcdG2B1Source(char * data)
{
if(abcd_abcd__char_connect_socket_w32_spawnv_22_abcdG2B1Global)
{
prabcdLine("Benign, fixed abcding");
}
else
{
abcdcat(data, "*.*");
}
return data;
}
char * abcd_abcd__char_connect_socket_w32_spawnv_22_abcdG2B2Source(char * data)
{
if(abcd_abcd__char_connect_socket_w32_spawnv_22_abcdG2B2Global)
{
abcdcat(data, "*.*");
}
return data;
}
#endif
|
72 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <wchar.h>
#ifdef _WIN32
#define COMMAND_INabcd_PAabcdH "%WINDIR%\\system32\\cmd.exe"
#define COMMAND_INabcd "cmd.exe"
#define COMMAND_ARG1 "/c"
#define COMMAND_ARG2 "dir "
#define COMMAND_ARG3 data
#else
#include <unistd.h>
#define COMMAND_INabcd_PAabcdH "/bin/sh"
#define COMMAND_INabcd "sh"
#define COMMAND_ARG1 "-c"
#define COMMAND_ARG2 "ls "
#define COMMAND_ARG3 data
#endif
#include <process.h>
#define EXECV _execv
#ifndef OMIabcdBAD
void abcd_abcd__char_console_w32_execv_15_abcd()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
switch(6)
{
case 6:
{
size_t dataLen = abcdlen(data);
if (100-dataLen > 1)
{
if (fgets(data+dataLen, (abcd)(100-dataLen), stdin) != NULL)
{
dataLen = abcdlen(data);
if (dataLen > 0 && data[dataLen-1] == '\n')
{
data[dataLen-1] = '\0';
}
}
else
{
prabcdLine("fgets() failed");
data[dataLen] = '\0';
}
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECV(COMMAND_INabcd_PAabcdH, args);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
switch(5)
{
case 6:
prabcdLine("Benign, fixed abcding");
break;
default:
abcdcat(data, "*.*");
break;
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECV(COMMAND_INabcd_PAabcdH, args);
}
}
static void abcdG2B2()
{
char * data;
char dataBuffer[100] = COMMAND_ARG2;
data = dataBuffer;
switch(6)
{
case 6:
abcdcat(data, "*.*");
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
{
char *args[] = {COMMAND_INabcd_PAabcdH, COMMAND_ARG1, COMMAND_ARG3, NULL};
EXECV(COMMAND_INabcd_PAabcdH, args);
}
}
void abcd_abcd__char_console_w32_execv_15_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd_abcd__char_console_w32_execv_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd_abcd__char_console_w32_execv_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
73 |
Process_Control
|
#include "std_testcase.h"
#include <wchar.h>
#include <windows.h>
#ifndef OMIabcdBAD
void abcd_abcd__w32_char_console_65b_abcdSink(char * data)
{
{
HMODULE hModule;
hModule = LoadLibraryA(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__w32_char_console_65b_abcdG2BSink(char * data)
{
{
HMODULE hModule;
hModule = LoadLibraryA(data);
if (hModule != NULL)
{
abcdreeLibrary(hModule);
prabcdLine("Library loaded and freed successfully");
}
else
{
prabcdLine("Unable to load library");
}
}
}
#endif
|
74 |
Uncontrolled_Mem_Alloc
|
#include "std_testcase.h"
#include <vector>
#ifndef _WIN32
#include <wchar.h>
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define CLOSE_SOCKEabcd closesocket
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKEabcd -1
#define SOCKEabcd_ERROR -1
#define CLOSE_SOCKEabcd close
#define SOCKEabcd abcd
#endif
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#define CHAR_ARRAY_SIZE (3 * sizeof(data) + 2)
using namespace std;
namespace abcd_abcd__malloc_wchar_t_listen_socket_72
{
#ifndef OMIabcdBAD
void abcdSink(vector<size_t> dataVector);
void abcd()
{
size_t data;
vector<size_t> dataVector;
data = 0;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
char inputBuffer[CHAR_ARRAY_SIZE];
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (::bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
inputBuffer[recvResult] = '\0';
data = abcdtoul(inputBuffer, NULL, 0);
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
abcdSink(dataVector);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(vector<size_t> dataVector);
static void abcdG2B()
{
size_t data;
vector<size_t> dataVector;
data = 0;
data = 20;
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
abcdG2BSink(dataVector);
}
void abcdB2GSink(vector<size_t> dataVector);
static void abcdB2G()
{
size_t data;
vector<size_t> dataVector;
data = 0;
{
#ifdef _WIN32
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
#endif
abcd recvResult;
abcduct sockaddr_in service;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
char inputBuffer[CHAR_ARRAY_SIZE];
do
{
#ifdef _WIN32
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
#endif
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (::bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
inputBuffer[recvResult] = '\0';
data = abcdtoul(inputBuffer, NULL, 0);
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
CLOSE_SOCKEabcd(acceptSocket);
}
#ifdef _WIN32
if (wsaDataInit)
{
WSACleanup();
}
#endif
}
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
abcdB2GSink(dataVector);
}
void abcd()
{
abcdG2B();
abcdB2G();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace abcd_abcd__malloc_wchar_t_listen_socket_72;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
75 |
Numeric_Truncation_Error
|
#include "std_testcase.h"
#ifndef OMIabcdBAD
void abcd_abcd__abcd_large_to_short_53d_abcdSink(abcd data);
void abcd_abcd__abcd_large_to_short_53c_abcdSink(abcd data)
{
abcd_abcd__abcd_large_to_short_53d_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void abcd_abcd__abcd_large_to_short_53d_abcdG2BSink(abcd data);
void abcd_abcd__abcd_large_to_short_53c_abcdG2BSink(abcd data)
{
abcd_abcd__abcd_large_to_short_53d_abcdG2BSink(data);
}
#endif
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- -