int main(int ac, char **av)
{
int lc;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
TEST_EXP_ENOS(exp_enos);
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
s2e_enable_forking();
s2e_make_symbolic(&path, sizeof(path), "path");
TEST(chroot(path));
s2e_disable_forking();
s2e_kill_state(0, "program done");
if (TEST_RETURN != -1)
tst_resm(TFAIL, "call succeeded unexpectedly");
else if (errno != EPERM)
tst_resm(TFAIL | TTERRNO, "chroot failed unexpectedly");
else
tst_resm(TPASS, "chroot set errno to EPERM.");
}
cleanup();
tst_exit();
}
int main(int argc, char *argv[])
{
char **vector;
int args;
s2e_disable_all_apic_interrupts();
s2e_enable_forking();
s2e_make_symbolic(&args, sizeof(args), "Number of arguments");
if (args < 1 || args > 4)
{
s2e_get_example(&args, sizeof(args));
printf("Bad value for args: %d\n", args);
s2e_kill_state(0, "bad value for args");
return 2;
}
printf("Good value for args\n"); fflush(stdout);
args= 5;
s2e_get_example(&args, sizeof(args));
printf("Got value for args: %d\n", args);
fflush(stdout);
printf("Before malloc vector\n");
vector= malloc((args+1)*sizeof(*vector));
printf("After malloc vector\n");
s2e_kill_state(0, "after malloc");
}
int main(int ac, char **av)
{
int lc;
char *msg;
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/* set the expected errnos... */
TEST_EXP_ENOS(exp_enos);
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* Call setpgid(2)
*/
s2e_enable_forking();
s2e_make_symbolic(&pgid,sizeof(pgid),"pgid");
TEST(setpgid(pid, pgid));
s2e_disable_forking();
s2e_kill_state(0,"program done!");
/* check return code */
if (TEST_RETURN == -1) {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL, "setpgid(%d, %d) Failed, errno=%d : %s",
pid, pgid, TEST_ERRNO, strerror(TEST_ERRNO));
} else {
/***************************************************************
* only perform functional verification if flag set (-f not given)
***************************************************************/
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS, "setpgid(%d, %d) returned %ld",
pid, pgid, TEST_RETURN);
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
tst_exit();
}
static void handler_fork(const char **args)
{
if (!strcmp(args[0], "disable") || !strcmp(args[0], "0")) {
s2e_disable_forking();
} else {
s2e_enable_forking();
}
}
int main(int ac, char **av)
{
int test_index = 0;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
#if defined(__powerpc__) || defined(__powerpc64__) /* for PPC, kernel version > 2.6.21 needed */
if (tst_kvercmp(2, 16, 22) < 0) {
tst_brkm(TCONF, NULL,
"System doesn't support execution of the test");
}
#else
/* For other archs, need kernel version > 2.6.16 */
if (tst_kvercmp(2, 6, 17) < 0) {
tst_brkm(TCONF, NULL,
"System doesn't support execution of the test");
}
#endif
setup();
for (test_index = 0; test_index < TST_TOTAL; test_index++) {
s2e_enable_forking();
s2e_make_symbolic(&test_data[test_index],sizeof(test_data[test_index]),"test_index");
TEST(syncfilerange
(*(test_data[test_index].fd),
test_data[test_index].offset,
test_data[test_index].nbytes,
test_data[test_index].flags));
s2e_disable_forking();
s2e_kill_state(0,"program done!");
if (TEST_RETURN != -1) {
tst_resm(TFAIL,
"call succeeded unexpectedly (%ld != -1)",
TEST_RETURN);
continue;
}
TEST_ERROR_LOG(TEST_ERRNO);
if (TEST_ERRNO == test_data[test_index].error) {
tst_resm(TPASS | TTERRNO, "got expected error");
} else {
tst_resm(TFAIL | TTERRNO, "got unexpected error; "
"expected %d", test_data[test_index].error);
}
}
cleanup();
tst_exit();
}
int main() {
s2e_enable_forking();
p.type=PERF_TYPE_SOFTWARE;
// s2e_make_symbolic(&(p.type), sizeof(p.type), "type");
// s2e_make_symbolic(&(p.size), sizeof(p.size), "size");
s2e_make_symbolic(&(p.config), sizeof(p.config), "config");
syscall(336, &p, 0, -1, -1, 0);
s2e_disable_forking();
s2e_kill_state(0, "ok!");
return 0;
}
int main(int ac, char **av)
{
int lc;
char *msg;
int tc;
msg = parse_opts(ac, av, NULL, NULL);
if (msg != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (tc = 0; tc < TST_TOTAL; tc++) {
s2e_enable_forking();
s2e_make_symbolic(&test_cases[tc].mode, sizeof(test_cases[tc].mode), "mode");
TEST(access(test_cases[tc].file, test_cases[tc].mode));
if (TEST_RETURN == -1 && test_cases[tc].experrno == 0) {
tst_resm(TFAIL | TTERRNO,
"access(%s, %s) failed",
test_cases[tc].file,
test_cases[tc].string);
} else if (TEST_RETURN != -1
&& test_cases[tc].experrno != 0) {
tst_resm(TFAIL,
"access(%s, %s) returned %ld, "
"exp -1, errno:%d",
test_cases[tc].file,
test_cases[tc].string, TEST_RETURN,
test_cases[tc].experrno);
} else {
if (STD_FUNCTIONAL_TEST) {
tst_resm(TPASS,
"access(%s, %s) returned %ld",
test_cases[tc].file,
test_cases[tc].string,
TEST_RETURN);
}
}
}
}
cleanup();
s2e_disable_forking();
s2e_kill_state(0, "program done!");
tst_exit();
}
int main(int argc, char *argv[])
{
int lc;
char *msg;
int s;
if ((msg = parse_opts(argc, argv, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); ++lc) {
tst_count = 0;
for (testno = 0; testno < TST_TOTAL; ++testno) {
s2e_enable_forking();
s2e_make_symbolic(&tdat[testno],sizeof(tdat[testno]),"tdat[testno]");
TEST((s = socketpair(tdat[testno].domain,
tdat[testno].type,
tdat[testno].proto,
tdat[testno].sv)));
s2e_disable_forking();
s2e_kill_state(0,"program done!");
if (TEST_RETURN >= 0) {
TEST_RETURN = 0; /* > 0 equivalent */
} else {
TEST_ERROR_LOG(TEST_ERRNO);
}
if (TEST_RETURN != tdat[testno].retval ||
(TEST_RETURN &&
(TEST_ERRNO != tdat[testno].experrno
&& TEST_ERRNO != EPROTONOSUPPORT))) {
tst_resm(TFAIL,
"%s ; returned"
" %d (expected %d), errno %d (expected"
" %d)", tdat[testno].desc, s,
tdat[testno].retval, TEST_ERRNO,
tdat[testno].experrno);
} else {
tst_resm(TPASS, "%s successful",
tdat[testno].desc);
}
(void)close(s);
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
TEST_EXP_ENOS(exp_enos);
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
s2e_enable_forking();
s2e_make_symbolic(&args[i].value, sizeof(int), "args[i].value");
TEST(fpathconf(fd, args[i].value));
s2e_disable_forking();
s2e_kill_state(0, "program done");
if (TEST_RETURN == -1 && args[i].defined) {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL | TTERRNO,
"fpathconf(fd, %s) failed",
args[i].define_tag);
} else {
if (STD_FUNCTIONAL_TEST) {
tst_resm(TPASS,
"fpathconf(fd, %s) returned %ld",
args[i].define_tag,
TEST_RETURN);
}
}
}
}
cleanup();
tst_exit();
}
int main() {
uint64_t x;
uint64_t max = 10;
//Make x symbolic
s2e_make_symbolic(&x, sizeof(x), "x");
s2e_enable_forking();
uint64_t f1 = factorial1(x, max);
uint64_t f2 = factorial2(x, max);
//Check the equivalence of the two functions for each path
s2e_assert(f1 == f2);
//In case of success, terminate the state with the
//appropriate message
s2e_kill_state(0, "Success");
return 0;
}
int main(int ac,char **av)
{
system("echo \"ABCDEFG123\" > demo.txt");
char *filename = "demo.txt";
int length = 10;
int prot = PROT_READ;
int flags = MAP_PRIVATE;
int offset = 0;
char *addr;
int fd = open(filename, O_RDONLY);
if (fd == -1)
exit(0);
s2e_enable_forking();
s2e_make_symbolic(&(length),sizeof(length), "symbolic_var_length");
s2e_make_symbolic(&(prot),sizeof(prot), "symbolic_var_prot");
s2e_make_symbolic(&(flags),sizeof(flags), "symbolic_var_flags");
s2e_make_symbolic(&(offset),sizeof(offset), "symbolic_var_offset");
addr = mmap(NULL, length, prot, flags, fd, offset);
write(STDOUT_FILENO, addr, length);
s2e_disable_forking();
close(fd);
s2e_kill_state(0,"program done!");
/*
s2e_enable_forking();
s2e_make_symbolic(&(x),sizeof(x), "symbolic_var_x");
s2e_disable_forking();
s2e_kill_state(0,"program done!");
return 0;
*/
}
int main(int ac,char **av)
{
struct msghdr msghdr;
struct iovec iovector[10];
int i,s;
struct sockaddr_in sockad;
char msg[128];
struct cmsghdr *cmsg,*cm2;
char opts[12];
s=socket(PF_INET, /*SOCK_STREAM*/ SOCK_DGRAM, 0);
sockad.sin_family = AF_INET;
sockad.sin_addr.s_addr=inet_addr("127.0.0.1");
sockad.sin_port=htons(8080);
connect(s,(struct sockaddr *) &sockad, sizeof(sockad));
memset(msg,'v',sizeof(msg));
memset(opts,0,sizeof(opts));
#define VV 1024*1024
cmsg = malloc(VV);
memset(cmsg,0,VV);
cmsg->cmsg_len = sizeof(struct cmsghdr) + sizeof(opts);
cmsg->cmsg_level = SOL_IP;
cmsg->cmsg_type = IP_RETOPTS;
memcpy(CMSG_DATA(cmsg), opts, sizeof(opts));
int flags = 0;
msghdr.msg_flags = 0;
msghdr.msg_name = &sockad;
msghdr.msg_namelen = sizeof(sockad);
msghdr.msg_control=cmsg;
msghdr.msg_controllen= cmsg->cmsg_len;
msghdr.msg_iov = iovector;
msghdr.msg_iovlen = 1;
iovector[0].iov_base = msg;
iovector[0].iov_len = sizeof(msg);
system("sync");
s2e_enable_forking();
s2e_make_symbolic(&(flags), sizeof(flags), "flags");
// s2e_make_symbolic(&(msghdr.msg_namelen), sizeof(msghdr.msg_namelen), "msghdr.msg_namelen");
// s2e_make_symbolic(&(msghdr.msg_controllen), sizeof(msghdr.msg_controllen), "msghdr.msg_controllen");
// s2e_make_symbolic(&(msghdr.msg_iovlen), sizeof(msghdr.msg_iovlen), "msghdr.msg_iovlen");
// s2e_make_symbolic(&(msghdr.msg_flags), sizeof(msghdr.msg_flags), "msghdr.msg_flags");
// s2e_make_symbolic(&(cmsg->cmsg_len),sizeof(cmsg->cmsg_len), "cmsg->cmsg_len");
// s2e_make_symbolic(&(cmsg->cmsg_level),sizeof(cmsg->cmsg_level), "cmsg->cmsg_level");
s2e_make_symbolic(&(cmsg->cmsg_type),sizeof(cmsg->cmsg_type), "cmsg->cmsg_type");
// s2e_make_symbolic(&(iovector[0].iov_len), sizeof(iovector[0].iov_len), "iovector[0].iov_len");
/*
s2e_make_symbolic(&(cm2->cmsg_len),sizeof(cm2->cmsg_len), "cm2->cmsg_len");
s2e_make_symbolic(&(cm2->cmsg_level),sizeof(cm2->cmsg_level), "cm2->cmsg_level");
s2e_make_symbolic(&(cm2->cmsg_type),sizeof(cm2->cmsg_type), "cm2->cmsg_type");
*/
if (i = sendmsg(s, &msghdr, flags) < 0)
perror("sendmsg");
s2e_disable_forking();
s2e_kill_state(0,"program done!");
return 42;
}
static void __s2e_init_env(int *argcPtr, char ***argvPtr)
{
int argc = *argcPtr;
char** argv = *argvPtr;
int new_argc = 0, n_args;
char* new_argv[1024];
unsigned max_len, min_argvs, max_argvs;
char** final_argv;
char sym_arg_name[5] = "arg";
unsigned sym_arg_num = 0;
int k=0, i;
int concolic_mode = 0;
sym_arg_name[4] = '\0';
// Load the process map and get the info about the current process
procmap_entry_t* proc_map = load_process_map();
display_process_map(proc_map);
register_module(proc_map, argv[0]);
register_module(proc_map, "init_env.so");
#ifndef DEBUG_NATIVE
s2e_codeselector_select_module("init_env.so");
#endif
// Recognize --help when it is the sole argument.
if (argc == 2 && __streq(argv[1], "--help")) {
__emit_error("s2e_init_env\n\n"
"usage: (s2e_init_env) [options] [program arguments]\n"
"\n"
" -select-process - Enable forking in the current process only\n"
" -select-process-userspace - Enable forking in userspace-code of the\n"
" current process only\n"
" -select-process-code - Enable forking in the code section of the current binary only\n"
" -concolic - Augment existing concrete arguments with symbolic values\n"
" -sym-arg <N> - Replace by a symbolic argument of length N\n"
" -sym-args <MIN> <MAX> <N> - Replace by at least MIN arguments and at most\n"
" MAX arguments, each with maximum length N\n\n");
}
#ifndef DEBUG_NATIVE
s2e_enable_forking();
#endif
while (k < argc) {
if (__streq(argv[k], "--concolic") || __streq(argv[k], "-concolic")) {
concolic_mode = 1;
++k;
}
else if (__streq(argv[k], "--sym-arg") || __streq(argv[k], "-sym-arg")) {
const char *msg = "--sym-arg expects an integer argument <max-len>";
if (++k == argc)
__emit_error(msg);
max_len = __str_to_int(argv[k++], msg);
sym_arg_name[3] = '0' + sym_arg_num++;
__add_arg(&new_argc, new_argv,
__get_sym_str(max_len, sym_arg_name),
1024);
}
else if (__streq(argv[k], "--sym-args") || __streq(argv[k], "-sym-args")) {
const char *msg =
"--sym-args expects three integer arguments <min-argvs> <max-argvs> <max-len>";
if (k+3 >= argc)
__emit_error(msg);
k++;
min_argvs = __str_to_int(argv[k++], msg);
max_argvs = __str_to_int(argv[k++], msg);
max_len = __str_to_int(argv[k++], msg);
n_args = s2e_range(min_argvs, max_argvs+1, "n_args");
for (i=0; i < n_args; i++) {
sym_arg_name[3] = '0' + sym_arg_num++;
__add_arg(&new_argc, new_argv,
__get_sym_str(max_len, sym_arg_name),
1024);
}
}
else if (__streq(argv[k], "--select-process") || __streq(argv[k], "-select-process")) {
k++;
myprintf("Forks will be restricted to the current address space\n");
s2e_codeselector_enable_address_space(0);
}
else if (__streq(argv[k], "--select-process-userspace") || __streq(argv[k], "-select-process-userspace")) {
k++;
myprintf("Forks will be restricted to the user-mode portion of the current address space\n");
s2e_codeselector_enable_address_space(1);
}
else if (__streq(argv[k], "--select-process-code") || __streq(argv[k], "-select-process-code")) {
k++;
const char *process_base_name = __base_name(argv[0]);
myprintf("Forks will be restricted to %s\n", process_base_name);
s2e_codeselector_select_module(process_base_name);
}
else {
/* simply copy arguments */
if (concolic_mode) {
sym_arg_name[3] = '0' + k;
s2e_make_concolic(argv[k], strlen(argv[k]), sym_arg_name);
}
__add_arg(&new_argc, new_argv, argv[k++], 1024);
}
}
final_argv = (char**) malloc((new_argc+1) * sizeof(*final_argv));
memcpy(final_argv, new_argv, new_argc * sizeof(*final_argv));
final_argv[new_argc] = 0;
*argcPtr = new_argc;
*argvPtr = final_argv;
}
int main(int ac, char **av)
{
struct sysinfo *sys_buf;
int lc;
char *msg;
float l1, l2, l3;
unsigned long l1_up, l2_up, l3_up;
sys_buf = (struct sysinfo *)malloc(sizeof(struct sysinfo));
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) {
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
}
setup(); /* Global setup */
/* The following loop checks looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
s2e_enable_forking();
s2e_make_symbolic(&sys_buf,sizeof(sys_buf),"sys_buf");
TEST(sysinfo(sys_buf));
s2e_disable_forking();
s2e_kill_state(0,"program done!");
/* check return code */
if (TEST_RETURN == -1) {
/* To gather stats on errnos returned, log the errno */
tst_brkm(TFAIL, cleanup, "sysinfo() Failed, errno=%d"
" : %s", TEST_ERRNO, strerror(TEST_ERRNO));
} else {
/* Test succeeded */
/* This portion of the code generates information
* used by sysinfo03 to test the functionality of
* sysinfo.
*/
if (ac == 2 && !strncmp(av[1], "TEST3", 5)) {
tst_resm(TINFO, "Generating info for "
"sysinfo03");
l1 = sys_buf->loads[0] / 60000.0;
l2 = sys_buf->loads[1] / 60000.0;
l3 = sys_buf->loads[2] / 60000.0;
l1_up = l1 * 100;
l2_up = l2 * 100;
l3_up = l3 * 100;
sys_buf->loads[0] = sys_buf->loads[0] / 10;
sys_buf->loads[1] = sys_buf->loads[1] / 10;
sys_buf->loads[2] = sys_buf->loads[2] / 10;
printf("uptime %lu\n", sys_buf->uptime);
printf("load1 %lu\n", sys_buf->loads[0]);
printf("load2 %lu\n", sys_buf->loads[1]);
printf("load3 %lu\n", sys_buf->loads[2]);
printf("l1 %lu\n", l1_up);
printf("l2 %lu\n", l2_up);
printf("l3 %lu\n", l3_up);
printf("totalram %lu\n", sys_buf->totalram);
printf("freeram %lu\n", sys_buf->freeram);
printf("sharedram %lu\n", sys_buf->sharedram);
printf("bufferram %lu\n", sys_buf->bufferram);
printf("totalswap %lu\n",
sys_buf->totalswap / (1024 * 1024));
printf("freeswap %lu\n", sys_buf->freeswap);
printf("procs %lu\n",
(unsigned long)sys_buf->procs);
} else {
tst_resm(TPASS,
"Test to check the return code PASSED");
}
}
}
cleanup();
tst_exit();
}
void main()
{
s2e_enable_forking();
int s;
struct sockaddr_in addr;
addr.sin_family = AF_INET;//?
// s2e_make_symbolic(&(addr.sin_family), sizeof(addr.sin_family), "sin_family");
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
addr.sin_port=htons(8080);
int socket1 = PF_INET;//?
int sockettype = SOCK_DGRAM;//?
int socket3 = 0;//?
// s2e_make_symbolic(&socket1, sizeof(socket1), "socket1");
// s2e_make_symbolic(&sockettype, sizeof(sockettype), "sockettype");
// s2e_make_symbolic(&socket3, sizeof(socket3), "socket3");
s = socket(socket1, sockettype, socket3);//---socket
int level = SOL_SOCKET;//?
int options = SO_REUSEADDR;//?
char* val = malloc(4);
memset(val, 't', sizeof(val));
int setlen = sizeof(val);//?
s2e_make_symbolic(&level, sizeof(level), "set_level");
s2e_make_symbolic(&options, sizeof(options), "set_options");
s2e_make_symbolic(&setlen, sizeof(setlen), "set_len");
setsockopt(s, level, options, &val, setlen);//---setsockopt
/*
int alen = sizeof(addr);//?
s2e_make_symbolic(&alen, sizeof(alen), "bind_len");
bind(s, &addr, alen);//---bind
int addr_size = sizeof(addr);//?
s2e_make_symbolic(&addr_size, sizeof(addr_size), "connet_addr_size");
connect(s, &addr, addr_size);//---connect
int qlen = sizeof(addr);//?
s2e_make_symbolic(&qlen, sizeof(qlen), "listen_len");
listen(s, qlen);//---listen
int addr_size2 = sizeof(addr);//?
s2e_make_symbolic(&addr_size2, sizeof(int), "accept_addr_size");
accept(s, &addr, addr_size2);//---accept
char* buf = malloc(4);
memset(buf,'v',sizeof(buf));
int nbytes = sizeof(buf);//?
int flags = MSG_DONTROUTE;//?
s2e_make_symbolic(&nbytes, sizeof(int), "send_len");
s2e_make_symbolic(&flags, sizeof(int), "send_flags");
send(s, buf, nbytes, flags);///---send
int clen = sizeof(addr);//?
s2e_make_symbolic(&clen, sizeof(int), "sendto_addr_len");
sendto(s, buf, nbytes, flags, &addr, clen);//sendto
char* buf_recv = malloc(10);
int recv_len = sizeof(buf_recv);//?
int recv_flag = MSG_OOB;//?
s2e_make_symbolic(&recv_len, sizeof(int), "recv_len");
s2e_make_symbolic(&recv_flag, sizeof(int), "recv_flag");
recv(s, buf_recv, recv_len, recv_flag);//---recv
*/
close(s);
s2e_disable_forking();
s2e_kill_state(0, "program done!");
}
int main(int ac, char **av)
{
DIR *ddir, *opendir();
int fd;
char *filname = "chdirtest";
char *filenames[3];
int lc;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
TEST_EXP_ENOS(exp_enos);
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
SAFE_CHDIR(cleanup, testdir);
fd = SAFE_CREAT(cleanup, filname, 0000);
SAFE_CLOSE(cleanup, fd);
if ((ddir = opendir(".")) == NULL)
tst_brkm(TBROK | TERRNO, cleanup, "opendir(.) failed");
filenames[0] = ".";
filenames[1] = "..";
filenames[2] = filname;
checknames(filenames, sizeof(filenames) / sizeof(filenames[0]),
ddir);
closedir(ddir);
s2e_enable_forking();
s2e_make_symbolic(filname, 20, "filename");
TEST(chdir(filname));
s2e_disable_forking();
s2e_kill_state(0, "program done!");
if (TEST_RETURN != -1)
tst_resm(TFAIL, "call succeeded unexpectedly");
else if (TEST_ERRNO != ENOTDIR)
tst_resm(TFAIL | TTERRNO,
"failed unexpectedly; wanted ENOTDIR");
else
tst_resm(TPASS, "failed as expected with ENOTDIR");
if (unlink(filname) == -1)
tst_brkm(TBROK | TERRNO, cleanup,
"Couldn't remove file");
SAFE_CHDIR(cleanup, "..");
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
char buffer[MAX_SIZE]; /* temporary buffer to hold symlink contents */
int lc;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* Call readlink(2) to read the contents of
* symlink into a buffer.
*/
s2e_enable_forking();
s2e_make_symbolic(&SYMFILE,sizeof(SYMFILE),"SYMFILE");
TEST(readlink(SYMFILE, buffer, sizeof(buffer)));
s2e_disable_forking();
s2e_kill_state(0,"program done!");
if (TEST_RETURN == -1) {
tst_resm(TFAIL,
"readlink() on %s failed, errno=%d : %s",
SYMFILE, TEST_ERRNO, strerror(TEST_ERRNO));
continue;
}
/*
* Perform functional verification if test
* executed without (-f) option.
*/
if (STD_FUNCTIONAL_TEST) {
/*
* Compare the return value of readlink()
* with the expected value which is the
* strlen() of testfile.
*/
if (TEST_RETURN == exp_val) {
/* Check for the contents of buffer */
if (memcmp(buffer, TESTFILE, exp_val) != 0) {
tst_resm(TFAIL, "Pathname %s and buffer"
" contents %s differ",
TESTFILE, buffer);
} else {
tst_resm(TPASS, "readlink() "
"functionality on '%s' is "
"correct", SYMFILE);
}
} else {
tst_resm(TFAIL, "readlink() return value %ld "
"does't match, Expected %d",
TEST_RETURN, exp_val);
}
} else {
tst_resm(TPASS, "call succeeded");
}
}
cleanup();
tst_exit();
}
static void
do_test(int lfd, struct sockaddr_in *conn_addr,
int closeonexec_flag, int nonblock_flag)
{
int connfd, acceptfd;
int fdf, flf, fdf_pass, flf_pass;
struct sockaddr_in claddr;
socklen_t addrlen;
#ifdef DEBUG
tst_resm(TINFO, "=======================================\n");
#endif
connfd = socket(AF_INET, SOCK_STREAM, 0);
if (connfd == -1)
die("Socket Error");
if (connect(connfd, (struct sockaddr *)conn_addr,
sizeof(struct sockaddr_in)) == -1)
die("Connect Error");
addrlen = sizeof(struct sockaddr_in);
s2e_enable_forking();
s2e_make_symbolic(claddr, sizeof(struct sockaddr), "calddr");
s2e_make_symbolic(&addrlen, sizeof(struct sockaddr_in), "addrlen");
#if !(__GLIBC_PREREQ(2, 10))
acceptfd = accept4_01(lfd, (struct sockaddr *)&claddr, &addrlen,
closeonexec_flag | nonblock_flag);
#else
acceptfd = accept4(lfd, (struct sockaddr *)&claddr, &addrlen,
closeonexec_flag | nonblock_flag);
#endif
s2e_disable_forking();
s2e_kill_state(0, "program done!");
if (acceptfd == -1) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"syscall __NR_accept4 not supported");
} else {
tst_brkm(TBROK | TERRNO, cleanup, "accept4 failed");
}
}
fdf = fcntl(acceptfd, F_GETFD);
if (fdf == -1)
die("fcntl:F_GETFD");
fdf_pass = ((fdf & FD_CLOEXEC) != 0) ==
((closeonexec_flag & SOCK_CLOEXEC) != 0);
#ifdef DEBUG
tst_resm(TINFO, "Close-on-exec flag is %sset (%s); ",
(fdf & FD_CLOEXEC) ? "" : "not ", fdf_pass ? "OK" : "failed");
#endif
if (!fdf_pass)
tst_resm(TFAIL,
"Close-on-exec flag mismatch, should be %x, actual %x",
fdf & FD_CLOEXEC, closeonexec_flag & SOCK_CLOEXEC);
flf = fcntl(acceptfd, F_GETFL);
if (flf == -1)
die("fcntl:F_GETFD");
flf_pass = ((flf & O_NONBLOCK) != 0) ==
((nonblock_flag & SOCK_NONBLOCK) != 0);
#ifdef DEBUG
tst_resm(TINFO, "nonblock flag is %sset (%s)\n",
(flf & O_NONBLOCK) ? "" : "not ", flf_pass ? "OK" : "failed");
#endif
if (!flf_pass)
tst_resm(TFAIL,
"nonblock flag mismatch, should be %x, actual %x",
fdf & O_NONBLOCK, nonblock_flag & SOCK_NONBLOCK);
close(acceptfd);
close(connfd);
if (fdf_pass && flf_pass)
tst_resm(TPASS, "Test passed");
}
int main(int ac, char **av)
{
int lc;
char *msg;
int i;
/* Disable test if the version of the kernel is less than 2.6.16 */
if ((tst_kvercmp(2, 6, 16)) < 0) {
tst_resm(TWARN, "This test can only run on kernels that are ");
tst_resm(TWARN, "2.6.16 and higher");
exit(0);
}
/***************************************************************
* parse standard options
***************************************************************/
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
/***************************************************************
* perform global setup for test
***************************************************************/
setup();
/***************************************************************
* check looping state if -c option given
***************************************************************/
for (lc = 0; TEST_LOOPING(lc); lc++) {
setup_every_copy();
tst_count = 0;
/*
* Call futimesat
*/
for (i = 0; i < TST_TOTAL; i++) {
gettimeofday(×[0], NULL);
gettimeofday(×[1], NULL);
s2e_enable_forking();
s2e_make_symbolic(&fds[i], sizeof(int), "fds[i]");
s2e_make_symbolic(filenames[i], 10, "filenames");
s2e_make_symbolic(times, sizeof(struct timeval) * 2, "times");
TEST(myfutimesat(fds[i], filenames[i], times));
s2e_disable_forking();
s2e_kill_state(0, "program done");
/* check return code */
if (TEST_ERRNO == expected_errno[i]) {
/***************************************************************
* only perform functional verification if flag set (-f not given)
***************************************************************/
if (STD_FUNCTIONAL_TEST) {
/* No Verification test, yet... */
tst_resm(TPASS,
"futimesat() returned the expected errno %d: %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
}
} else {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
"futimesat() Failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
return (0);
}
int main (void) {
char buf[32];
memset (buf, '\0', sizeof (buf) );
char given;
char symb;
// for non-symbolic:
/*
char str[3];
memset (str, '\0', 3);
printf("Enter two characters: ");
if (!fgets(str, sizeof(str), stdin))
return 1;
symb = str[0];
given = str[1];
*/
// for symbolic:
//s2e_disable_all_apic_interrupts(); // make faster
given = 'a';
s2e_enable_forking (); // Enable forking on symbolic conditions.
s2e_make_symbolic (&(symb), 1 * sizeof (char), "symb");
// saves state
// forks to creates a new state with symbolic (random) values for str[0] and str[1]
// note, this means it only created and ran 1 set of symbolic value
snprintf (buf, sizeof (buf), "Running S2E Tutorial1\n");
/*s2e_get_example (&(symb), 1 * sizeof (char) ); // gets the symbolic values that were used which reached this point
snprintf (buf, sizeof (buf), "Running S2E Tutorial1:%02x%02x%c%c:\n", (unsigned char) symb, (unsigned char) given, symb, given);*/
s2e_message (buf);
printf ("%s\n", buf);
if (symb == '\0') {
printf ("No input char\n");
s2e_get_example (&(symb), 1 * sizeof (char) ); // gets the symbolic values that were used which reached this point
snprintf (buf, sizeof (buf), "s2e_get_example4:%02x%02x%c%c:\n", (unsigned char) symb, (unsigned char) given, symb, given);
s2e_warning (buf);
printf ("%s\n", buf);
} else {
s2e_get_example (&(symb), 1 * sizeof (char) ); // gets the symbolic values that were used which reached this point
snprintf (buf, sizeof (buf), "s2e_get_example1:%02x%02x%c%c:\n", (unsigned char) symb, (unsigned char) given, symb, given);
s2e_warning (buf);
printf ("%s\n", buf);
if (symb == given) {
//s2e_warning ("symb equals 1\n");
printf ("Chars are the same: %c == %c\n", symb, given);
s2e_get_example (&(symb), 1 * sizeof (char) ); // gets the symbolic values that were used which reached this point
snprintf (buf, sizeof (buf), "s2e_get_example2:%02x%02x%c%c:\n", (unsigned char) symb, (unsigned char) given, symb, given);
s2e_warning (buf);
printf ("%s\n", buf);
}
}
//s2e_disable_forking ();
s2e_get_example (&(symb), 1 * sizeof (char) ); // gets the symbolic values that were used which reached this point
snprintf (buf, sizeof (buf), "s2e_get_example3:%02x%02x%c%c:\n", (unsigned char) symb, (unsigned char) given, symb, given);
s2e_warning (buf);
printf ("%s\n", buf);
s2e_kill_state (0, "program terminated");
return 0;
}
