int
main (
int argc,
char *argv[]
)
{
// Try to set real-time scheduling class. Requires login as
// superuser or administrator.
set_rt ();
// parsing arguments options:
// -w <num data readers>
// -p <primer samples>
// -s <stats samples>
// -d <data size>
// -p <num primer samples>
// -s <num stats samples>
// -r <stats output file>
// -top <test's topic name>
// -n <network settings file>
// -q <QoS policies file>
int parsing_status = parse_sub_args (argc, argv);
switch (DATA_SIZE) {
case 4:
DDS_ReturnCode_t (*ptr2readertakefunc4) (TP_Test_Bytes4DataReader,
DDS_sequence_TP_Test_Bytes4 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc4 = &TP_Test_Bytes4DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc4) (TP_Test_Bytes4DataReader,
DDS_sequence_TP_Test_Bytes4 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc4 = &TP_Test_Bytes4DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes4,
DDS_sequence_TP_Test_Bytes4,
TP_Test_Bytes4DataReader,
TP_Test_Bytes4DataWriter> (argc, argv, ptr2readertakefunc4, ptr2readerreturnloanfunc4);
break;
case 8:
DDS_ReturnCode_t (*ptr2readertakefunc8) (TP_Test_Bytes8DataReader,
DDS_sequence_TP_Test_Bytes8 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc8 = &TP_Test_Bytes8DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc8) (TP_Test_Bytes8DataReader,
DDS_sequence_TP_Test_Bytes8 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc8 = &TP_Test_Bytes8DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes8,
DDS_sequence_TP_Test_Bytes8,
TP_Test_Bytes8DataReader,
TP_Test_Bytes8DataWriter> (argc, argv, ptr2readertakefunc8, ptr2readerreturnloanfunc8);
break;
case 16:
DDS_ReturnCode_t (*ptr2readertakefunc16) (TP_Test_Bytes16DataReader,
DDS_sequence_TP_Test_Bytes16 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc16 = &TP_Test_Bytes16DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc16) (TP_Test_Bytes16DataReader,
DDS_sequence_TP_Test_Bytes16 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc16 = &TP_Test_Bytes16DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes16,
DDS_sequence_TP_Test_Bytes16,
TP_Test_Bytes16DataReader,
TP_Test_Bytes16DataWriter> (argc, argv, ptr2readertakefunc16, ptr2readerreturnloanfunc16);
break;
case 32:
DDS_ReturnCode_t (*ptr2readertakefunc32) (TP_Test_Bytes32DataReader,
DDS_sequence_TP_Test_Bytes32 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc32 = &TP_Test_Bytes32DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc32) (TP_Test_Bytes32DataReader,
DDS_sequence_TP_Test_Bytes32 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc32 = &TP_Test_Bytes32DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes32,
DDS_sequence_TP_Test_Bytes32,
TP_Test_Bytes32DataReader,
TP_Test_Bytes32DataWriter> (argc, argv, ptr2readertakefunc32, ptr2readerreturnloanfunc32);
break;
case 64:
DDS_ReturnCode_t (*ptr2readertakefunc64) (TP_Test_Bytes64DataReader,
DDS_sequence_TP_Test_Bytes64 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc64 = &TP_Test_Bytes64DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc64) (TP_Test_Bytes64DataReader,
DDS_sequence_TP_Test_Bytes64 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc64 = &TP_Test_Bytes64DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes64,
DDS_sequence_TP_Test_Bytes64,
TP_Test_Bytes64DataReader,
TP_Test_Bytes64DataWriter> (argc, argv, ptr2readertakefunc64, ptr2readerreturnloanfunc64);
break;
case 128:
DDS_ReturnCode_t (*ptr2readertakefunc128) (TP_Test_Bytes128DataReader,
DDS_sequence_TP_Test_Bytes128 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc128 = &TP_Test_Bytes128DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc128) (TP_Test_Bytes128DataReader,
DDS_sequence_TP_Test_Bytes128 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc128 = &TP_Test_Bytes128DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes128,
DDS_sequence_TP_Test_Bytes128,
TP_Test_Bytes128DataReader,
TP_Test_Bytes128DataWriter> (argc, argv, ptr2readertakefunc128, ptr2readerreturnloanfunc128);
break;
case 256:
DDS_ReturnCode_t (*ptr2readertakefunc256) (TP_Test_Bytes256DataReader,
DDS_sequence_TP_Test_Bytes256 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc256 = &TP_Test_Bytes256DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc256) (TP_Test_Bytes256DataReader,
DDS_sequence_TP_Test_Bytes256 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc256 = &TP_Test_Bytes256DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes256,
DDS_sequence_TP_Test_Bytes256,
TP_Test_Bytes256DataReader,
TP_Test_Bytes256DataWriter> (argc, argv, ptr2readertakefunc256, ptr2readerreturnloanfunc256);
break;
case 512:
DDS_ReturnCode_t (*ptr2readertakefunc512) (TP_Test_Bytes512DataReader,
DDS_sequence_TP_Test_Bytes512 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc512 = &TP_Test_Bytes512DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc512) (TP_Test_Bytes512DataReader,
DDS_sequence_TP_Test_Bytes512 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc512 = &TP_Test_Bytes512DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes512,
DDS_sequence_TP_Test_Bytes512,
TP_Test_Bytes512DataReader,
TP_Test_Bytes512DataWriter> (argc, argv, ptr2readertakefunc512, ptr2readerreturnloanfunc512);
break;
case 1024:
DDS_ReturnCode_t (*ptr2readertakefunc1024) (TP_Test_Bytes1024DataReader,
DDS_sequence_TP_Test_Bytes1024 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc1024 = &TP_Test_Bytes1024DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc1024) (TP_Test_Bytes1024DataReader,
DDS_sequence_TP_Test_Bytes1024 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc1024 = &TP_Test_Bytes1024DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes1024,
DDS_sequence_TP_Test_Bytes1024,
TP_Test_Bytes1024DataReader,
TP_Test_Bytes1024DataWriter> (argc, argv, ptr2readertakefunc1024, ptr2readerreturnloanfunc1024);
break;
case 2048:
DDS_ReturnCode_t (*ptr2readertakefunc2048) (TP_Test_Bytes2048DataReader,
DDS_sequence_TP_Test_Bytes2048 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc2048 = &TP_Test_Bytes2048DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc2048) (TP_Test_Bytes2048DataReader,
DDS_sequence_TP_Test_Bytes2048 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc2048 = &TP_Test_Bytes2048DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes2048,
DDS_sequence_TP_Test_Bytes2048,
TP_Test_Bytes2048DataReader,
TP_Test_Bytes2048DataWriter> (argc, argv, ptr2readertakefunc2048, ptr2readerreturnloanfunc2048);
break;
case 4096:
DDS_ReturnCode_t (*ptr2readertakefunc4096) (TP_Test_Bytes4096DataReader,
DDS_sequence_TP_Test_Bytes4096 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc4096 = &TP_Test_Bytes4096DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc4096) (TP_Test_Bytes4096DataReader,
DDS_sequence_TP_Test_Bytes4096 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc4096 = &TP_Test_Bytes4096DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes4096,
DDS_sequence_TP_Test_Bytes4096,
TP_Test_Bytes4096DataReader,
TP_Test_Bytes4096DataWriter> (argc, argv, ptr2readertakefunc4096, ptr2readerreturnloanfunc4096);
break;
case 8192:
DDS_ReturnCode_t (*ptr2readertakefunc8192) (TP_Test_Bytes8192DataReader,
DDS_sequence_TP_Test_Bytes8192 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc8192 = &TP_Test_Bytes8192DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc8192) (TP_Test_Bytes8192DataReader,
DDS_sequence_TP_Test_Bytes8192 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc8192 = &TP_Test_Bytes8192DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes8192,
DDS_sequence_TP_Test_Bytes8192,
TP_Test_Bytes8192DataReader,
TP_Test_Bytes8192DataWriter> (argc, argv, ptr2readertakefunc8192, ptr2readerreturnloanfunc8192);
break;
case 16384:
DDS_ReturnCode_t (*ptr2readertakefunc16384) (TP_Test_Bytes16384DataReader,
DDS_sequence_TP_Test_Bytes16384 *,
DDS_SampleInfoSeq *,
const DDS_long,
const DDS_SampleStateMask,
const DDS_ViewStateMask,
const DDS_InstanceStateMask);
ptr2readertakefunc16384 = &TP_Test_Bytes16384DataReader_take;
DDS_ReturnCode_t (*ptr2readerreturnloanfunc16384) (TP_Test_Bytes16384DataReader,
DDS_sequence_TP_Test_Bytes16384 *,
DDS_SampleInfoSeq *);
ptr2readerreturnloanfunc16384 = &TP_Test_Bytes16384DataReader_return_loan;
TypeSpecificMain <TP_Test_Bytes16384,
DDS_sequence_TP_Test_Bytes16384,
TP_Test_Bytes16384DataReader,
TP_Test_Bytes16384DataWriter> (argc, argv, ptr2readertakefunc16384, ptr2readerreturnloanfunc16384);
break;
default:
printf ("Sub: DATA_SIZE not supported!\n");
break;
}
return 0;
}
int main(int argc, char **argv, char **envp)
{
handle_t *handle;
char *token = NULL, **args;
int ac, i, status, ret;
pid_t pid;
long ptraceOpts;
char *argv0;
if (argc < 3)
usage();
if (argv[1][0] != '-')
usage();
/*
* XXX handle is huge because of branch_site (Which is a massive array)
* so we must use heap. In the future move branch_site from array to
* list or tree for fast lookup.
*/
handle = (handle_t *)heapAlloc(sizeof(handle_t));
memset((void *)handle, 0, sizeof(handle_t));
memset((void *)&opts, 0, sizeof(opts));
if (argv[1][0] != '-')
usage();
if (argv[1][1] != 'b' && argv[1][1] != 'p') {
for (token = (argv[1] + 1); *token != '\0'; token++) {
switch(*token) {
case 'v':
opts.verbose++;
break;
case 's':
opts.strings++;
break;
case 'c':
opts.cflow++;
break;
case 'e':
opts.elfdata++;
break;
case 'f':
opts.ehframe++;
break;
case 't':
opts.threads++;
break;
case 'd':
opts.debug++;
break;
default:
printf("Unknown option: '%c'\n", *token);
usage();
}
}
if (argc < 4)
usage();
if (argv[2][0] != '-')
usage();
if (argv[2][1] == 'b')
handle->path = strdup(argv[3]);
else
if (argv[2][1] == 'p')
handle->pid = atoi(argv[3]);
else
usage();
argv0 = handle->path ? xstrdup(argv[3]) : get_path(handle->pid);
ac = parse_sub_args(&argv[4], argc - 4, &handle->args, argv0);
} else {
if (argv[1][0] != '-')
usage();
if (argv[1][1] == 'b')
handle->path = strdup(argv[2]);
else
if (argv[1][1] == 'p')
handle->pid = atoi(argv[2]);
else
usage();
argv0 = handle->path ? xstrdup(argv[2]) : get_path(handle->pid);
ac = parse_sub_args(&argv[3], argc - 3, &handle->args, argv0);
}
switch(__ELF_NATIVE_CLASS) {
case 32:
opts.arch = 32;
break;
case 64:
opts.arch = 64;
break;
default:
fprintf(stderr, "[!] Unsupported architecture: %d\n", __ELF_NATIVE_CLASS);
exit(0);
}
handle->arch = opts.arch;
pid = handle->pid;
if (pid) {
if (opts.verbose)
printf("[+] Attaching to pid: %d\n", pid);
opts.attach++;
handle->path = get_path(handle->pid);
}
if (!validate_em_type(handle->path)) {
printf("[!] ELF Architecture is set to %d, the target %s is not the same architecture\n", opts.arch, handle->path);
exit(-1);
}
/*
* process_binary() will create the mapping of branch instructions
* and layout of the executable, so that we can instrument it before
* execution.
*/
if ((ret = process_binary(handle) < 0)) {
fprintf(stderr, "process_binary() failed on [%s]\n", handle->path);
exit(-1);
}
if (!opts.attach) {
if ((pid = fork()) < 0) {
perror("fork");
exit(-1);
}
if (pid == 0) {
if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) == -1) {
perror("PTRACE_TRACEME");
exit(-1);
}
ptraceOpts = PTRACE_O_TRACECLONE|PTRACE_O_TRACEFORK|PTRACE_O_TRACEEXEC|PTRACE_O_TRACEEXIT|PTRACE_O_EXITKILL;
ptrace(PTRACE_SETOPTIONS, 0, 0, ptraceOpts);
execve(handle->path, handle->args, envp);
exit(0);
}
wait(&status);
handle->pid = pid;
if (opts.debug)
printf("[+] Calling instrument_process()\n");
instrument_process(handle);
if (opts.debug)
printf("[+] Calling examine_process()\n");
examine_process(handle);
goto done;
}
printf("Attaching to %d\n", handle->pid);
if (ptrace(PTRACE_ATTACH, handle->pid, NULL, NULL) == -1) {
perror("PTRACE_ATTACH");
exit(-1);
}
wait(&status);
// waitpid(handle->pid, &status, WUNTRACED);
instrument_process(handle);
examine_process(handle);
for (i = 0; i < ac; i++)
printf("arg[%d]: %s\n", i, handle->args[i]);
done:
free(handle);
exit(0);
}
