/**
* Advance past the reti (or virtual reti) according to |step|.
* Return 0 if successful, or nonzero if an unhandled trap occurred.
*/
static int exit_syscall(struct context* ctx,
const struct rep_trace_step* step,
int stepi)
{
int i, emu = step->syscall.emu;
if (!emu) {
int ret = cont_syscall_boundary(ctx, emu, stepi);
if (ret) {
return ret;
}
}
for (i = 0; i < step->syscall.num_emu_args; ++i) {
set_child_data(ctx);
}
if (step->syscall.emu_ret) {
set_return_value(ctx);
}
validate_args(step->syscall.no, STATE_SYSCALL_EXIT, ctx);
if (emu) {
/* XXX verify that this can't be interrupted by a
* breakpoint trap */
step_exit_syscall_emu(ctx);
}
return 0;
}
int main(int argc, char *argv[]) {
struct arguments args;
/* Process arguments */
init_args(&args);
if (parse_args(argc, argv, &args) < 0) return -1;
validate_args(&args);
if (args.verbose) print_args(&args);
switch (args.mode) {
case CLI_MODE:
tun_cli(&args);
break;
case SERV_MODE:
tun_serv(&args);
break;
case FULLMESH_MODE:
tun_peer(&args);
break;
default:
break;
}
return 0;
}
static void emulate_signal_delivery()
{
/* We are now at the exact point in the child where the signal
* was recorded, emulate it using the next trace line (records
* the state at sighandler entry). */
struct context* ctx = rep_sched_get_thread();
pid_t tid = ctx->child_tid;
struct trace_frame* trace = &ctx->trace;
/* Restore the signal-hander frame data, if there was one. */
if (!set_child_data(ctx)) {
/* No signal handler. Advance execution to the point
* we recorded. */
reset_hpc(ctx, 0);
/* TODO what happens if we step on a breakpoint? */
advance_to(ctx, ctx->trace.rbc, &trace->recorded_regs,
/*no signal*/0, DONT_STEPI);
/* (|advance_to()| just asserted that the registers
* match what was recorded.) */
} else {
/* Signal handler; we just set up the callframe.
* Continuing execution will run that code. */
write_child_main_registers(tid, &trace->recorded_regs);
}
/* Delivered the signal. */
ctx->child_sig = 0;
validate_args(ctx->trace.stop_reason, -1, ctx);
}
int main(int argc, char **argv) {
app_args_t args;
parse_args(args, argc, argv);
if (!validate_args(args)) {
return -1;
}
tty_handle_t handle;
int ret = tty_open_device(&handle, args.device.c_str());
if (TTY_ERR_OK != ret) {
PERR("failed to open TTY device.\n");
return -1;
}
tty_config_t config = {
4800,
TTY_DATA_8,
TTY_PARITY_NONE,
TTY_STOP_1,
TTY_FLOW_NONE,
0,
};
ret = tty_set_config(handle, &config);
if (TTY_ERR_OK != ret) {
PERR("failed to set configuration.\n");
} else {
do_action(handle);
}
tty_close_device(handle);
return 0;
}
int
main (int argc, char *argv[])
{
struct args *args = parse_args (argc, argv);
validate_args (args);
JBDATA *data =
classify_components (args->num_input_files, args->input_files,
args->thresh, args->weight);
/* Render output of leptonica's classifier, if requested */
if (args->debug_render_pages)
{
int i;
PIXA *pa = jbDataRender (data, 0);
for (i = 0; i < pa->n; i++)
{
PIX *pix = pa->pix[i];
char filename[512];
sprintf (filename, "rendered_%05d.png", i);
pixWrite (filename, pix, IFF_PNG);
}
}
struct mapping *maps = NULL;
int num_fonts = register_mappings (data, &maps);
char *tmpdirname = NULL;
if (!args->debug_skip_font_gen)
{
tmpdirname = generate_fonts (data, maps, num_fonts, args->debug_tmpdir);
}
generate_pdf (args->outname, tmpdirname, num_fonts, args->num_input_files,
data, maps, args->debug_draw_borders);
/* clean up tmpdir */
if (!args->debug_no_clean_tmpdir)
{
/* This may not be Windows compatible */
if (nftw (tmpdirname, delete_file, 64, FTW_DEPTH | FTW_PHYS) == -1)
{
error_quit ("Failed to clean up tmpdir.");
}
}
if (args->debug_tmpdir == NULL)
{
free (tmpdirname);
}
free (maps);
jbDataDestroy (&data);
free (args->input_files);
free (args);
return 0;
}
/*
* main
*/
int
main (int argc, char **argv)
{
struct event_base *event_loop = NULL;
if (!validate_args(argc, argv))
usage();
= parse_config_file(argv[argc - 1]); //TODO: set return type and create a variable to catch the returning value
/* Handle a FILE_WRITE command. */
static void process_file_write(taper_state_t * state,
struct cmdargs * cmdargs) {
dump_info_t dump_state;
char * holding_disk_file;
guint64 splitsize;
char * argnames[] = {"command", /* 0 */
"handle", /* 1 */
"filename", /* 2 */
"hostname", /* 3 */
"diskname", /* 4 */
"level", /* 5 */
"datestamp", /* 6 */
"splitsize", /* 7 */
NULL };
validate_args(cmdargs, argnames);
dump_state.handle = g_strdup(cmdargs->argv[1]);
holding_disk_file = g_strdup(cmdargs->argv[2]);
dump_state.hostname = g_strdup(cmdargs->argv[3]);
dump_state.diskname = g_strdup(cmdargs->argv[4]);
errno = 0;
dump_state.level = strtol(cmdargs->argv[5], NULL, 10);
if (errno != 0) {
error("error [taper FILE-WRITE: Invalid dump level %s]",
cmdargs->argv[5]);
g_assert_not_reached();
}
dump_state.timestamp = strdup(cmdargs->argv[6]);
errno = 0;
splitsize = g_ascii_strtoull(cmdargs->argv[7], NULL, 10);
if (errno != 0) {
error("error [taper FILE-WRITE: Invalid splitsize %s]",
cmdargs->argv[7]);
g_assert_not_reached();
}
dump_state.id_string = g_strdup_printf("%s:%s.%d", dump_state.hostname,
dump_state.diskname,
dump_state.level);
dump_state.source = taper_source_new(dump_state.handle, FILE_WRITE,
holding_disk_file, -1,
NULL, splitsize, -1);
/* FIXME: This should be handled properly. */
g_assert(dump_state.source != NULL);
run_device_output(state, &dump_state);
free_dump_info(&dump_state);
amfree(holding_disk_file);
}
int Snmp::set( Pdu &pdu, UdpTarget &target, Snmp_Result * cb)
{
ACE_TRACE("Snmp::set");
int rc;
if ((rc = validate_args(pdu, target)) != 0)
return rc;
pdu.set_type( sNMP_PDU_SET);
check_default_port(target);
return run_transaction(pdu, target, cb);
}
/**
* Advance to the next syscall entry (or virtual entry) according to
* |step|. Return 0 if successful, or nonzero if an unhandled trap
* occurred.
*/
static int enter_syscall(struct context* ctx,
const struct rep_trace_step* step,
int stepi)
{
int ret;
if ((ret = cont_syscall_boundary(ctx, step->syscall.emu, stepi))) {
return ret;
}
validate_args(step->syscall.no, STATE_SYSCALL_ENTRY, ctx);
return ret;
}
/*
* Main
*/
int main(int argc, char * argv[]) {
(void)initialize();
(void)validate_args(argc, argv);
if (!(load(argv[1]))) {
printf("\nLoader Test Failed\n");
return 1; /* EXIT */
} else {
printf("\nLoader Test Passed\n");
return 0;
}
}
/**
* @brief Parses and validates the command line options of the application.
*
* @param po::variables_map& vm The destination for parsed arguments
* @param int argc The number of arguments
* @param char**argv The raw arguments
*
* @return Whether the arguments are valid.
*/
bool parse_args(po::variables_map& vm, int argc, char**argv)
{
po::options_description desc("Usage");
desc.add_options()
("help,h", "Displays this message.")
("version,v", "Prints the program's version.")
("pe", po::value<std::vector<std::string> >(), "The PE to analyze. Also accepted as a positional argument. "
"Multiple files may be specified.")
("recursive,r", "Scan all files in a directory (subdirectories will be ignored).")
("output,o", po::value<std::string>(), "The output format. May be 'raw' (default) or 'json'.")
("dump,d", po::value<std::vector<std::string> >(),
"Dump PE information. Available choices are any combination of: "
"all, summary, dos (dos header), pe (pe header), opt (pe optional header), sections, "
"imports, exports, resources, version, debug, tls, config (image load configuration)")
("hashes", "Calculate various hashes of the file (may slow down the analysis!)")
("extract,x", po::value<std::string>(), "Extract the PE resources to the target directory.")
("plugins,p", po::value<std::vector<std::string> >(),
"Analyze the binary with additional plugins. (may slow down the analysis!)");
po::positional_options_description p;
p.add("pe", -1);
try
{
po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
po::notify(vm);
}
catch(po::error& e)
{
PRINT_ERROR << "Could not parse the command line (" << e.what() << ")." << std::endl << std::endl;
return false;
}
if (vm.count("version"))
{
std::stringstream ss;
ss << "Manalyze " MANALYZE_VERSION " (Ivan Kwiatkowski, GPLv3 License) compiled with:" << std::endl;
ss << "* Boost " BOOST_LIB_VERSION " (Boost.org, Boost Software License)" << std::endl;
ss << "* Yara " << YR_MAJOR_VERSION << "." << YR_MINOR_VERSION << "." << YR_MICRO_VERSION << ". (Victor M. Alvarez, Apache 2.0 License)" << std::endl;
ss << "* hash-library " << HASH_LIBRARY_VERSION << " (Stephan Brumme, ZLib License)." << std::endl;
std::cout << ss.str();
exit(0);
}
else if (vm.count("help") || !vm.count("pe"))
{
print_help(desc, argv[0]);
exit(0);
}
return validate_args(vm, desc, argv);
}
// one way, best of luck, non-confirmed alert
int Snmp::trap( Pdu &pdu, UdpTarget &target)
{
ACE_TRACE("Snmp::trap");
int rc;
if ((rc = validate_args(pdu, target)) != 0)
return rc;
pdu.set_type( sNMP_PDU_V1TRAP);
check_default_port(target, DEF_TRAP_PORT);
// 2. write request to agent
transaction trans(pdu, target, iv_snmp_session_);
if (trans.send() > 0) // expect number of bytes sent on
return 0;
last_transaction_status_ = SNMP_CLASS_INTERNAL_ERROR;
return -1;
}
int main(int argc, char*argv[])
{
// create glib loop and register a ctrl+c handler
GMainLoop* loop = g_main_loop_new(NULL, FALSE);
handle_control_c(loop);
int result;
if (validate_args(argc, argv) == false)
{
result = 1;
}
else
{
if(platform_init() == 0)
{
char *json_path = argv[1];
GATEWAY_HANDLE gateway = Gateway_CreateFromJson(json_path);
if(gateway == NULL)
{
LogError("An error ocurred while creating the gateway.");
result = 1;
}
else
{
result = 0;
printf("Gateway is running.\r\n");
// run the glib loop
g_main_loop_run(loop);
printf("Gateway is quitting\r\n");
Gateway_Destroy(gateway);
}
platform_deinit();
}
else
{
LogError("Failed to initialize the platform");
result = 1;
}
}
return result;
}
/* Captures requested data from archiver and saves to file. */
int main(int argc, char **argv)
{
char *server = getenv("FA_ARCHIVE_SERVER");
if (server != NULL)
server_name = server;
output_file = stdout;
FILE *stream;
bool ok =
parse_args(argc, argv) &&
validate_args() &&
connect_server(&stream) &&
IF_(output_filename != NULL,
TEST_NULL_(
output_file = fopen(output_filename, "w"),
"Unable to open output file \"%s\"", output_filename)) &&
request_data(stream) &&
check_response(stream) &&
initialise_signal() &&
capture_and_save(stream);
return ok ? 0 : 1;
}
int read_stimuli(char *filename)
{
FILE *id;
int n,i;
int here;
int inada;
int line=0;
char buf[BUF_LEN+1];
pchar err_msg;
if (verbose) printf("Reading stimuli from \"%s\"...\n",filename);
if ((id=fopen(filename,"r+")) == (FILE *) 0) {
puts("File does not exist");
return 0;
}
for (n=0;n<5;++n) {
if (!fgets(buf,BUF_LEN,id))
goto end_of_file;
++line;
}
if (strlen(global_msg) != strlen(buf)) {
err_msg=global_msg;
goto invalid_file_format;
}
if (!fgets(buf,BUF_LEN,id))
goto end_of_file;
++line;
if (sscanf(buf,global_str,&num_trials,&num_stimuli,&num_categories,
&num_choices_per_category,&max_same_categories,
&ms_btwn_stim,&ms_btwn_trials,&total_ms_on) != 8)
goto unexpected_args;
validate_args();
if (!init_arrays()) {
fclose(id);
return 0;
}
for (n=0;n<2;++n) {
if (!fgets(buf,BUF_LEN,id))
goto end_of_file;
++line;
}
if (strlen(color_msg) != strlen(buf)) {
err_msg=color_msg;
goto invalid_file_format;
}
if (!fgets(buf,BUF_LEN,id))
goto end_of_file;
++line;
if (get_colors_from == COLORS_FROM_STM_FILE) {
if (sscanf(buf,color_str,&_palette[0],&_palette[1],&_palette[2],
&_palette[3],&_palette[4],&_palette[5],&_palette[6]) != 7)
goto unexpected_args;
}
/* Else use the ones parsed in from .cfg file, if at all */
for (n=0;n<2;++n) {
if (!fgets(buf,BUF_LEN,id))
goto end_of_file;
++line;
}
if (strlen(stm_msg) != strlen(buf)) {
err_msg=stm_msg;
goto invalid_file_format;
}
for (n=0,here=0;n<num_trials;++n) {
for (i=0;i<num_stimuli;++i,++here) {
if (!fgets(buf,BUF_LEN,id))
goto end_of_file;
++line;
if (sscanf(buf,stm_str,&inada,&inada,
&_color[here],&_shape[here],
&_num[here],&_size[here],&_filled[here],&_pattern[here],
&_matches[here],&inada) != 10)
goto unexpected_args;
BOUNDED(_shape[here],0,num_choices_per_category-1);
BOUNDED(_num[here],0,num_choices_per_category-1);
BOUNDED(_size[here],0,num_choices_per_category-1);
BOUNDED(_filled[here],0,num_choices_per_category-1);
if(use_many_colors) {
BOUNDED(_color[here],0,MAX_COLORS-1);
BOUNDED(_pattern[here],0,MAX_PATTERNS-1);
}
else {
BOUNDED(_color[here],0,num_choices_per_category-1);
BOUNDED(_pattern[here],0,num_choices_per_category-1);
}
_Orig_stim[here] = item_val(here); // for randomization purposes
}
}
fclose(id);
calc_matches();
return 1;
unexpected_args:
if (verbose) printf("Unexpected args on line %i\n", line);
fclose(id);
return 0;
end_of_file:
puts("File ended too early");
fclose(id);
return 0;
invalid_file_format:
printf("Invalid file format. Expects as line %i:\n",line);
puts(err_msg);
fclose(id);
return 0;
}
int read_data(FILE *id,int line)
{
static init=0;
int n,i;
int here;
int len;
int inada;
char Lbuf[BUF_LEN+1];
if (!init) {
init=1;
if (!fgets(Lbuf,BUF_LEN,id))
goto error;
}
for (n=0;n<23;++n,++line) {
switch(n) {
case 0: strcpy(user_name,&Lbuf[6]); len=strlen(user_name); user_name[len-1]='\0'; break;
case 1: strcpy(date_str,&Lbuf[6]); len=strlen(date_str); date_str[len-1]='\0'; break;
case 2: strcpy(time_str,&Lbuf[6]); len=strlen(time_str); time_str[len-1]='\0'; break;
case 3: break;
case 4:
if (strncmp(Lbuf,"Sex:",4)!=0) {
n= 12;
played_before=1;
goto Parse_Exp_Type;
}
if (sscanf(Lbuf,"Sex: %i\n", &sex)!=1)
goto error;
played_before=0;
break;
case 5: if (sscanf(Lbuf,"Age: %i\n", &age)!=1) goto error; break;
case 6: if (sscanf(Lbuf,"Years_ed: %i\n", &years_ed)!=1) goto error; break;
case 7: break;
case 8: break;
case 9: if (sscanf(Lbuf," Family data: %i %i %i %i %i %i\n",
&familyH[0],&familyH[1],&familyH[2],&familyH[3],&familyH[4],&familyH[5])!=6)
goto error;
break;
case 10: if (sscanf(Lbuf," Briggs data: %i %i %i %i %i %i %i %i %i %i %i %i\n",
&indivH[0],&indivH[1],&indivH[2],&indivH[3],&indivH[4],&indivH[5],
&indivH[6],&indivH[7],&indivH[8],&indivH[9],&indivH[10],&indivH[11])!=12)
goto error;
break;
case 11: break;
Parse_Exp_Type:
case 12: if (sscanf(Lbuf,"Experiment Type: %s",exp_type_str)!=1) goto error; break;
case 13: strcpy(selfeval_str,&Lbuf[11]); len=strlen(selfeval_str); selfeval_str[len-1]='\0'; break;
case 14: break;
case 15: break;
case 16: if (sscanf(Lbuf,global_str,
&num_trials, &num_stimuli, &num_categories,&num_choices_per_category,
&max_same_categories,&ms_btwn_stim,&ms_btwn_trials,&total_ms_on) != 8)
goto error;
break;
case 17: break;
case 18: break;
case 19: if (sscanf(Lbuf,color_str,&_palette[0],&_palette[1],&_palette[2],
&_palette[3],&_palette[4],&_palette[5],&_palette[6]) != 7)
goto error;
break;
case 20: break;
case 21: break; // **STIMULI**
case 22: if (strcmp(Lbuf,stm_msg)!=0) goto error; break;
}
if (!fgets(Lbuf,BUF_LEN,id))
goto error;
}
validate_args();
if (!init_arrays())
goto error;
/** Read STIMULI **/
for (n=0,here=0;n<num_trials;++n) {
for (i=0;i<num_stimuli;++i,++here) {
++line;
if (sscanf(Lbuf,stm_str,&inada,&inada,
&_color[here],&_shape[here],
&_num[here],&_size[here],&_filled[here],&_pattern[here],
&_matches[here],&inada) != 10)
goto error;
if (!fgets(Lbuf,BUF_LEN,id))
goto error;
}
}
/** Read RESPONSE DATA **/
for (n=0;n<2;++n,++line)
if (!fgets(Lbuf,BUF_LEN,id))
goto error;
if (strcmp(Lbuf,dat_msg)!=0)
goto error;
for (n=0;n<num_trials;++n,++line) {
if (!fgets(Lbuf,BUF_LEN,id))
goto error;
if (sscanf(Lbuf,dat_str,
&inada,&_choice[n],
&inada,&inada,&inada,&inada,&inada,&inada,&inada, // item descipt
&inada, // item_number
&_match_min[n],
&_match_max[n],
&_time[n]) != 13)
goto error;
}
/** Read and discard previous analysis, up to start of appended file **/
while(1) {
if (!fgets(Lbuf,BUF_LEN,id))
return -1; // since end of file
if (strncmp(Lbuf,"Name:",5)==0)
break;
++line;
}
return line; // so can print error messages in appended file
error:
printf("Unexpected args on line %i\n", line);
return -1;
}
struct neuronet *netcreat(int nl, int *nn, int ninp)
{
int i, nperc;
double *w;
struct neuronet *res;
if (validate_args(nl, nn, ninp) != 0) {
net_errno = NET_EINVAL;
goto exit_failure;
}
if ((res = malloc(sizeof(struct neuronet))) == NULL) {
net_errno = NET_ENOMEM;
goto exit_failure;
}
res->nl = nl;
if ((res->nn = (int *)malloc(sizeof(int) * nl)) == NULL) {
net_errno = NET_ENOMEM;
goto free_net;
}
if ((res->nw = (int *)malloc(sizeof(int) * nl)) == NULL) {
net_errno = NET_ENOMEM;
goto free_nn;
}
memcpy(res->nn, nn, sizeof(int) * nl);
res->nw[0] = ninp;
srand(time(NULL));
for (i = 1; i < nl; i++)
res->nw[i] = res->nn[i - 1];
res->total_nw = 0;
nperc = ninp;
for (i = 0; i < nl; i++) {
res->total_nw += nn[i] * nperc;
nperc = nn[i];
}
res->total_nn = 0;
for (i = 0; i < nl; i++)
res->total_nn += nn[i];
if((w = (double *)malloc(sizeof(double) * res->total_nw)) == NULL) {
net_errno = NET_ENOMEM;
goto free_nw;
}
res->g = (double *)malloc(sizeof(double) * res->total_nw);
for (i = 0; i < res->total_nw; i++)
*w++ = (double)rand()/(double)RAND_MAX * 2.0 - 1.0;
res->w = w - res->total_nw;
return res;
free_nw:
free(res->nw);
free_nn:
free(res->nn);
free_net:
free(res);
exit_failure:
return NULL;
}
/* Handle a PORT_WRITE command. */
static void process_port_write(taper_state_t * state,
struct cmdargs * cmdargs) {
dump_info_t dump_state;
guint64 splitsize;
guint64 fallback_splitsize;
char * split_diskbuffer;
char * argnames[] = {"command", /* 0 */
"handle", /* 1 */
"hostname", /* 2 */
"diskname", /* 3 */
"level", /* 4 */
"datestamp", /* 5 */
"splitsize", /* 6 */
"split_diskbuffer", /* 7 */
"fallback_splitsize", /* 8 */
NULL };
validate_args(cmdargs, argnames);
dump_state.handle = g_strdup(cmdargs->argv[1]);
dump_state.hostname = g_strdup(cmdargs->argv[2]);
dump_state.diskname = g_strdup(cmdargs->argv[3]);
errno = 0;
dump_state.level = strtol(cmdargs->argv[4], NULL, 10);
if (errno != 0) {
error("error [taper PORT-WRITE: Invalid dump level %s]",
cmdargs->argv[4]);
g_assert_not_reached();
}
dump_state.timestamp = strdup(cmdargs->argv[5]);
errno = 0;
splitsize = g_ascii_strtoull(cmdargs->argv[6], NULL, 10);
if (errno != 0) {
error("error [taper PORT-WRITE: Invalid splitsize %s]",
cmdargs->argv[6]);
g_assert_not_reached();
}
if (strcmp(cmdargs->argv[7], "NULL") == 0) {
split_diskbuffer = NULL;
} else {
split_diskbuffer = g_strdup(cmdargs->argv[7]);
}
errno = 0;
fallback_splitsize = g_ascii_strtoull(cmdargs->argv[8], NULL, 10);
if (errno != 0) {
error("error [taper PORT-WRITE: Invalid fallback_splitsize %s]",
cmdargs->argv[8]);
g_assert_not_reached();
}
dump_state.id_string = g_strdup_printf("%s:%s.%d", dump_state.hostname,
dump_state.diskname,
dump_state.level);
if (!open_read_socket(&dump_state, split_diskbuffer, splitsize,
fallback_splitsize)) {
free(split_diskbuffer);
return;
}
free(split_diskbuffer);
run_device_output(state, &dump_state);
free_dump_info(&dump_state);
}
int main(int argc, char **argv)
{
char temp1[100], temp2[100];
char *url= NULL, * remotehost=NULL, * user=NULL, * password=NULL, * database=NULL, * dbpassword=NULL;
char default_remotehost[]="127.0.0.1";
char default_user[]="_SYSTEM";
char default_password[]="";
char default_database[]="";
char default_dbpassword[]="";
int port, itarget, sh;
char c;
logo();
if(argc<2)
{
usage(argv[0]);
return -1;
}
// set defaults
port=-1;
itarget=0;
sh=0;
// ------------
while((c = getopt(argc, argv, "h:p:s:t:u:P:d:D:x:"))!= EOF)
{
switch (c)
{
case 'h':
remotehost=optarg;
break;
case 's':
sscanf(optarg, "%d", &sh);
sh--;
break;
case 't':
sscanf(optarg, "%d", &itarget);
itarget--;
break;
case 'p':
sscanf(optarg, "%d", &port);
break;
case 'u':
user=optarg;
break;
case 'P':
password=optarg;
break;
case 'd':
database=optarg;
break;
case 'x':
url=optarg;
break;
default:
usage(argv[0]);
return -1;
}
}
if(validate_args( port, sh, itarget)==-1) return -1;
if(remotehost == NULL) remotehost=default_remotehost;
if(user == NULL) user=default_user;
if(password == NULL) password=default_password;
if(dbpassword == NULL) dbpassword=default_dbpassword;
if(database == NULL) database=default_database;
if(url == NULL) url="";
memset(temp1,0,sizeof(temp1));
memset(temp2,0,sizeof(temp2));
memset(temp1, '\x20' , 58 - strlen(remotehost) -1);
printf(" # Host : %s%s# \n", remotehost, temp1);
if(port!=-1)
{
sprintf(temp2, "%d", port);
memset(temp1,0,sizeof(temp1));
memset(temp1, '\x20' , 58 - strlen(temp2) -1);
printf(" # Port : %s%s# \n", temp2, temp1);
}else
{
sprintf(temp2, "%s", database);
memset(temp1,0,sizeof(temp1));
memset(temp1, '\x20' , 58 - strlen(temp2) -1);
printf(" # Database: %s%s# \n", temp2, temp1);
}
sprintf(temp2, "%s", user);
memset(temp1,0,sizeof(temp1));
memset(temp1, '\x20' , 58 - strlen(temp2) -1);
printf(" # User : %s%s# \n", temp2, temp1);
memset(temp1,0,sizeof(temp1));
memset(temp2,0,sizeof(temp2));
sprintf(temp2, "%s", shellcodes[sh].name );
memset(temp1, '\x20' , 58 - strlen(temp2) -1);
printf(" # Shellcde: %s%s# \n", temp2, temp1);
if(sh==1)
{
memset(temp1,0,sizeof(temp1));
memset(temp2,0,sizeof(temp2));
sprintf(temp2, "%s", url );
memset(temp1, '\x20' , 58 - strlen(temp2) -1);
printf(" # URL : %s%s# \n", temp2, temp1);
}
memset(temp1,0,sizeof(temp1));
memset(temp1, '\x20' , 58 - strlen(targets[itarget].t) -1);
printf(" # Target : %s%s# \n", targets[itarget].t, temp1);
printf(" # ------------------------------------------------------------------- # \n");
fflush(stdout);
char buf[20000];
memset(buf,0,sizeof(buf));
printf("[+] Constructing attacking buffer... ");
fflush(stdout);
make_buffer((char *)buf,itarget,sh, url);
printf("done\n");
if(send_buffer(remotehost,port, user, password, dbpassword, database, buf)==-1)
{
fprintf(stdout, "[-] Cannot exploit server %s\n", remotehost);
return -1;
}
return 0;
}
/*
* transform_replica -- transforming one poolset into another
*/
int
replica_transform(struct pool_set *set_in, struct pool_set *set_out,
unsigned flags)
{
LOG(3, "set_in %p, set_out %p", set_in, set_out);
int ret = 0;
/* validate user arguments */
if (validate_args(set_in, set_out))
return -1;
/* check if the source poolset is healthy */
struct poolset_health_status *set_in_hs = NULL;
if (replica_check_poolset_health(set_in, &set_in_hs, flags)) {
ERR("source poolset health check failed");
return -1;
}
if (!replica_is_poolset_healthy(set_in_hs)) {
ERR("source poolset is broken");
ret = -1;
errno = EINVAL;
goto free_hs_in;
}
struct poolset_health_status *set_out_hs = NULL;
if (replica_create_poolset_health_status(set_out, &set_out_hs)) {
ERR("creating poolset health status failed");
ret = -1;
goto free_hs_in;
}
/* check if the poolsets are transformable */
struct poolset_compare_status *set_in_cs = NULL;
struct poolset_compare_status *set_out_cs = NULL;
if (compare_poolsets(set_in, set_out, &set_in_cs, &set_out_cs)) {
ERR("comparing poolsets failed");
ret = -1;
goto free_hs_out;
}
enum transform_op operation = identify_transform_operation(set_in_cs,
set_out_cs, set_in_hs, set_out_hs);
if (operation == NOT_TRANSFORMABLE) {
LOG(1, "poolsets are not transformable");
ret = -1;
errno = EINVAL;
goto free_cs;
}
if (operation == RM_HDRS) {
if (!is_dry_run(flags) &&
remove_hdrs(set_in, set_out, set_in_hs,
flags)) {
ERR("removing headers failed; falling back to the "
"input poolset");
if (replica_sync(set_in, set_in_hs,
flags | IS_TRANSFORMED)) {
LOG(1, "falling back to the input poolset "
"failed");
} else {
LOG(1, "falling back to the input poolset "
"succeeded");
}
ret = -1;
}
goto free_cs;
}
if (operation == ADD_HDRS) {
if (!is_dry_run(flags) &&
add_hdrs(set_in, set_out, set_in_hs, flags)) {
ERR("adding headers failed; falling back to the "
"input poolset");
if (replica_sync(set_in, set_in_hs,
flags | IS_TRANSFORMED)) {
LOG(1, "falling back to the input poolset "
"failed");
} else {
LOG(1, "falling back to the input poolset "
"succeeded");
}
ret = -1;
}
goto free_cs;
}
if (operation == ADD_REPLICAS) {
/*
* check if any of the parts that are to be added already exists
*/
if (do_added_parts_exist(set_out, set_out_hs)) {
ERR("some parts being added already exist");
ret = -1;
errno = EINVAL;
goto free_cs;
}
}
/* signal that sync is called by transform */
if (replica_sync(set_out, set_out_hs, flags | IS_TRANSFORMED)) {
ret = -1;
goto free_cs;
}
if (operation == RM_REPLICAS) {
if (!is_dry_run(flags) && delete_replicas(set_in, set_in_cs))
ret = -1;
}
free_cs:
Free(set_in_cs);
Free(set_out_cs);
free_hs_out:
replica_free_poolset_health_status(set_out_hs);
free_hs_in:
replica_free_poolset_health_status(set_in_hs);
return ret;
}
struct passed_args *parse_passed_arguments (int argc, char* argv[]) {
/*
The main function for parsing the arguments passed to the program
*/
struct passed_args *args = malloc(sizeof(struct passed_args));
assert(NULL != args);
args->help_flag = 0;
args->verbose_flag = 0;
args->set_index_bits_num = 0;
args->associativity_num = 0;
args->block_bits_num = 0;
args->trace_file = NULL;
int c; // getopt_long stores parsed short options here
const char *short_opts = "hvs:E:b:t:";
static int help_flag;
opterr = 0; // disable printing error messages by getopt_long
while (1) {
static struct option long_options[] =
{
{"help", no_argument, &help_flag, 1},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long(argc, argv,
short_opts, long_options, &option_index);
/* Detect the end of the options */
if (-1 == c) {
break;
}
switch (c) {
/* Case for long options */
case 0:
break;
case 'h':
args->help_flag = 1;
break;
case 'v':
args->verbose_flag = 1;
break;
case 's':
case 'E':
case 'b':
if (NULL == optarg) no_argument_passed(c);
store_char_param (c, optarg, args);
break;
case 't':
if (NULL == optarg) no_argument_passed (c);
store_string_param (c, optarg, args);
break;
case '?':
default:
bad_argument_passed();
break;
}
}
if (help_flag) {
args->help_flag = 1;
}
validate_args(args);
return args;
}
/*
* sync_replica -- synchronize data across replicas within a poolset
*/
int
replica_sync(struct pool_set *set, struct poolset_health_status *s_hs,
unsigned flags)
{
LOG(3, "set %p, flags %u", set, flags);
int ret = 0;
struct poolset_health_status *set_hs = NULL;
/* check if we already know the poolset health status */
if (s_hs == NULL) {
/* validate poolset before checking its health */
if (validate_args(set))
return -1;
/* examine poolset's health */
if (replica_check_poolset_health(set, &set_hs, flags)) {
ERR("poolset health check failed");
return -1;
}
/* check if poolset is broken; if not, nothing to do */
if (replica_is_poolset_healthy(set_hs)) {
LOG(1, "Poolset is healthy");
goto out;
}
} else {
set_hs = s_hs;
}
/* find one good replica; it will be the source of data */
unsigned healthy_replica = replica_find_healthy_replica(set_hs);
if (healthy_replica == UNDEF_REPLICA) {
ERR("no healthy replica found");
ret = -1;
goto out;
}
/* in dry-run mode we can stop here */
if (is_dry_run(flags)) {
LOG(1, "Sync in dry-run mode finished successfully");
goto out;
}
/* recreate broken parts */
if (recreate_broken_parts(set, set_hs, flags)) {
ERR("recreating broken parts failed");
ret = -1;
goto out;
}
/* open all part files */
if (replica_open_poolset_part_files(set)) {
ERR("opening poolset part files failed");
ret = -1;
goto out;
}
/* map all replicas */
if (util_poolset_open(set)) {
ERR("opening poolset failed");
ret = -1;
goto out;
}
/* this is required for opening remote pools */
set->poolsize = set_hs->replica[healthy_replica]->pool_size;
/* open all remote replicas */
if (open_remote_replicas(set, set_hs)) {
ERR("opening remote replicas failed");
ret = -1;
goto out;
}
/* update uuid fields in the set structure with part headers */
if (fill_struct_uuids(set, healthy_replica, set_hs, flags)) {
ERR("gathering uuids failed");
ret = -1;
goto out;
}
/* create headers for broken parts */
if (!is_dry_run(flags)) {
if (create_headers_for_broken_parts(set, healthy_replica,
set_hs)) {
ERR("creating headers for broken parts failed");
ret = -1;
goto out;
}
}
if (is_dry_run(flags))
goto out;
/* create all remote replicas */
if (create_remote_replicas(set, set_hs, flags)) {
ERR("creating remote replicas failed");
ret = -1;
goto out;
}
/* check and copy data if possible */
if (copy_data_to_broken_parts(set, healthy_replica,
flags, set_hs)) {
ERR("copying data to broken parts failed");
ret = -1;
goto out;
}
/* update uuids of replicas and parts */
if (update_uuids(set, set_hs)) {
ERR("updating uuids failed");
ret = -1;
goto out;
}
/* grant permissions to all created parts */
if (grant_created_parts_perm(set, healthy_replica, set_hs)) {
ERR("granting permissions to created parts failed");
ret = -1;
}
out:
if (s_hs == NULL)
replica_free_poolset_health_status(set_hs);
return ret;
}
int main(int argc, char *argv[])
{
static const struct option long_opts[] = {
/* commands */
{"inject", required_argument, NULL, c_INJECT},
{"remove", required_argument, NULL, c_REMOVE},
{"hexdump", required_argument, NULL, c_HEXDUMP},
/* options */
{"output", required_argument, NULL, o_OUTPUT},
/* flags */
{"force", no_argument, NULL, f_FORCE},
{"p8", no_argument, NULL, f_P8},
{"verbose", no_argument, NULL, f_VERBOSE},
{"help", no_argument, NULL, f_HELP},
{0, 0, 0, 0}
};
static const char *short_opts = "I:R:H:o:fpvh";
int rc = EXIT_FAILURE;
if (argc == 1)
usage(args.short_name, false), exit(rc);
int opt = 0, idx = 0;
while ((opt = getopt_long(argc, argv, short_opts, long_opts,
&idx)) != -1)
if (process_argument(&args, opt, optarg) < 0)
goto error;
/* getopt_long doesn't know what to do with orphans, */
/* so we'll scoop them up here, and deal with them later */
while (optind < argc)
if (process_option(&args, argv[optind++]) < 0)
goto error;
if (args.verbose == f_VERBOSE)
args_dump(&args);
if (validate_args(&args) < 0)
goto error;
if (process_args(&args) < 0)
goto error;
rc = EXIT_SUCCESS;
if (false) {
err_t *err;
error:
err = err_get();
assert(err != NULL);
fprintf(stderr, "%s: %s : %s(%d) : (code=%d) %.*s\n",
program_invocation_short_name,
err_type_name(err), err_file(err), err_line(err),
err_code(err), err_size(err), (char *)err_data(err));
}
return rc;
}
