BOOL ShellNotifyIconEx(DWORD action, HWND wnd, UINT id, UINT callbackmsg, HICON icon, const char * tip, const char * balloon_title, const char * balloon_msg)
{
NOTIFYICONDATA nid;
memset(&nid, 0, sizeof(nid));
nid.cbSize = NOTIFYICONDATA_V2_SIZE;
nid.hWnd = wnd;
nid.uID = id;
if (callbackmsg)
{
nid.uFlags |= NIF_MESSAGE;
nid.uCallbackMessage = callbackmsg;
}
if (icon)
{
nid.uFlags |= NIF_ICON;
nid.hIcon = icon;
}
if (tip)
{
nid.uFlags |= NIF_TIP;
_tcsncpy_s(nid.szTip, pfc::stringcvt::string_os_from_utf8(tip), tabsize(nid.szTip) - 1);
}
nid.dwInfoFlags = NIIF_INFO | NIIF_NOSOUND;
//if (balloon_title || balloon_msg)
{
nid.uFlags |= NIF_INFO;
if (balloon_title) _tcsncpy_s(nid.szInfoTitle, pfc::stringcvt::string_os_from_utf8(balloon_title), tabsize(nid.szInfoTitle) - 1);
if (balloon_msg) _tcsncpy_s(nid.szInfo, pfc::stringcvt::string_os_from_utf8(balloon_msg), tabsize(nid.szInfo) - 1);
}
return run_action(action, reinterpret_cast<NOTIFYICONDATA*>(&nid));
}
BOOL ShellNotifyIcon(DWORD action, HWND wnd, UINT id, UINT version, UINT callbackmsg, HICON icon, const char * tip)
{
NOTIFYICONDATA nid;
memset(&nid, 0, sizeof(nid));
nid.cbSize = NOTIFYICONDATA_V2_SIZE;
nid.hWnd = wnd;
nid.uID = id;
nid.uFlags = 0;
if (action & NIM_SETVERSION)
nid.uVersion = version;
if (callbackmsg)
{
nid.uFlags |= NIF_MESSAGE;
nid.uCallbackMessage = callbackmsg;
}
if (icon)
{
nid.uFlags |= NIF_ICON;
nid.hIcon = icon;
}
if (tip)
{
nid.uFlags |= NIF_TIP;
_tcsncpy_s(nid.szTip, pfc::stringcvt::string_os_from_utf8(tip), tabsize(nid.szTip) - 1);
}
return run_action(action, &nid);
}
void
machine::route(const node* from, sched::base *sched_caller, const node::node_id id, simple_tuple* stpl, const uint_val delay)
{
assert(sched_caller != NULL);
if (api::onLocalVM(id)){
/* Belongs to the same process, does not require MPI */
node *node(vm::All->DATABASE->find_node(id));
sched::base *sched_other(sched_caller->find_scheduler(node));
const predicate *pred(stpl->get_predicate());
if(delay > 0) {
work new_work(node, stpl);
sched_caller->new_work_delay(sched_caller, from, new_work, delay);
} else if(pred->is_action_pred()) {
run_action(sched_other, node, stpl->get_tuple(), sched_caller != sched_other);
delete stpl;
} else if(sched_other == sched_caller) {
work new_work(node, stpl);
sched_caller->new_work(from, new_work);
} else {
work new_work(node, stpl);
sched_caller->new_work_other(sched_other, new_work);
}
} else {
/* Send to the correct process */
api::sendMessage(from,id,stpl);
}
}
void
do_default_action(fcode_env_t *env)
{
acf_t a;
CHECK_DEPTH(env, 1, "do_default_action");
a = (acf_t)TOS;
(void) run_action(env, (a-1), 0);
}
void
do_set_action(fcode_env_t *env)
{
acf_t a = (acf_t)TOS;
CHECK_DEPTH(env, 1, "do_set_action");
TOS += sizeof (acf_t);
(void) run_action(env, a, 1);
}
/* Parses wsmouse events. Only button events are picked. */
void
action_wsmouse_event(struct wscons_event evt)
{
if (IS_BUTTON_EVENT(evt.type)) {
switch (evt.type) {
case WSCONS_EVENT_MOUSE_UP:
run_action(evt.value, "up");
break;
case WSCONS_EVENT_MOUSE_DOWN:
run_action(evt.value, "down");
break;
default:
log_warnx("unknown button event");
}
}
}
void try_to_populate(Event *node){
//if the branch is done calculating
if(end_calc_branch(node->time, node->total_damage)){
//node->final_breakdown = node->breakdown;
return;
}
//if the children have already been populated
if(node->children_populated){
return;
}
printf("running action...\n");
//run the appropriate action/event-method on the node
run_action(node);
}
void
perform_action(fcode_env_t *env)
{
int n;
acf_t a;
CHECK_DEPTH(env, 2, "perform_action");
n = POP(DS);
a = (acf_t)POP(DS);
PUSH(DS, (fstack_t)ACF_TO_BODY(a));
if (run_action(env, a, n)) {
system_message(env, "Bad Object action");
}
}
/* scan all robots and run them if necessary - this is a parse.c bit that
gets called in timer_function */
void process_robots(void)
{
robot *rscan;
player *rc;
if (sys_flags & PANIC)
return;
for (rscan = robot_start; rscan; rscan = rscan->next)
{
/* SPANG - MOVE THIS SOMEWHERE ELSE AND DO IT JUST ONCE? */
/* check to make sure robot hasnt fallen off :-) */
if (rscan->counter == 0 && !(rscan->flags & STORED))
{
rc = find_player_absolute_quiet(rscan->lower_name);
/* check for nightmare crashes/etc ;) */
if (!rc)
{
rc = create_player();
rc->fd = -1;
connect_robot_to_prog(rc, rscan->lower_name);
rscan->actual_player = rc;
}
else if (!(rc->flags & PANIC))
{
/* be cheeky here, safetly thing really. set actual_player to rc!
this is actually because i --KNOW-- someone will try logging in
as a robot and that could conceivably blow it away. */
rscan->actual_player = rc;
rscan->counter = rscan->speed;
current_player = rscan->actual_player;
current_room = rscan->actual_player->location;
run_action(rscan);
current_player = 0;
current_room = 0;
}
}
}
}
/*----------------------------------------------------------------------------*/
int
match_entry(packet_t* p, entry_t* e){
window_t *w;
action_t *a;
int target = list_length(e->windows);
int actual = 0;
if (target == 0) {return 0;}
for(w = list_head(e->windows); w != NULL; w = w->next) {
actual = actual + match_window(p, status_register, w);
}
if (actual == target){
PRINTF("[FLT]: Match Found!\n");
for(a = list_head(e->actions); a != NULL; a = a->next) {
run_action(p, status_register, a);
}
e->stats.count++;
return 1;
} else {
return 0;
}
}
int main(int argc, const char **argv)
{
static const char *null_action_argv[] = {NULL};
static struct poptOption popt_help_options[] = {
{ NULL, '\0', POPT_ARG_CALLBACK, help, 0, NULL, NULL },
{ "help", '?', POPT_ARG_NONE, NULL, 0, N_("Show this help message"), NULL },
{ "usage", '\0', POPT_ARG_NONE, NULL, 0, N_("Display brief usage"), NULL },
POPT_TABLEEND
};
static struct poptOption popt_options[] = {
{ NULL, '\0', POPT_ARG_INCLUDE_TABLE, popt_help_options, 0, N_("Help options:"), NULL },
{ "version", '\0', POPT_ARG_NONE, &opt_version_mode, 0, N_("Print package version"), NULL },
{ "verbose", 'v', POPT_ARG_NONE, &opt_verbose, 0, N_("Shows more detailed error messages"), NULL },
{ "debug", '\0', POPT_ARG_NONE, &opt_debug, 0, N_("Show debug messages"), NULL },
{ "batch-mode", 'q', POPT_ARG_NONE, &opt_batch_mode, 0, N_("Do not ask for confirmation"), NULL },
{ "progress-frequency", '\0', POPT_ARG_INT, &opt_progress_frequency, 0, N_("Progress line update (in seconds)"), N_("secs") },
{ "no-wipe", '\0', POPT_ARG_NONE, &opt_no_wipe, 0, N_("Do not wipe device after format"), NULL },
{ "data-device", '\0', POPT_ARG_STRING, &opt_data_device, 0, N_("Path to data device (if separated)"), N_("path") },
{ "journal-size", 'j', POPT_ARG_STRING,&opt_journal_size_str, 0, N_("Journal size"), N_("bytes") },
{ "interleave-sectors", '\0', POPT_ARG_INT, &opt_interleave_sectors, 0, N_("Interleave sectors"), N_("SECTORS") },
{ "journal-watermark", '\0', POPT_ARG_INT, &opt_journal_watermark, 0, N_("Journal watermark"),N_("percent") },
{ "journal-commit-time",'\0', POPT_ARG_INT, &opt_journal_commit_time,0, N_("Journal commit time"), N_("ms") },
{ "bitmap-sectors-per-bit",'\0', POPT_ARG_INT,&opt_bitmap_sectors_per_bit, 0, N_("Number of 512-byte sectors per bit (bitmap mode)."), NULL },
{ "bitmap-flush-time", '\0', POPT_ARG_INT, &opt_bitmap_flush_time, 0, N_("Bitmap mode flush time"), N_("ms") },
{ "tag-size", 't', POPT_ARG_INT, &opt_tag_size, 0, N_("Tag size (per-sector)"), N_("bytes") },
{ "sector-size", 's', POPT_ARG_INT, &opt_sector_size, 0, N_("Sector size"), N_("bytes") },
{ "buffer-sectors", '\0', POPT_ARG_INT, &opt_buffer_sectors, 0, N_("Buffers size"), N_("SECTORS") },
{ "integrity", 'I', POPT_ARG_STRING, &opt_integrity, 0, N_("Data integrity algorithm"), NULL },
{ "integrity-key-size", '\0', POPT_ARG_INT, &opt_integrity_key_size, 0, N_("The size of the data integrity key"), N_("BITS") },
{ "integrity-key-file", '\0', POPT_ARG_STRING, &opt_integrity_key_file, 0, N_("Read the integrity key from a file"), NULL },
{ "journal-integrity", '\0', POPT_ARG_STRING, &opt_journal_integrity, 0, N_("Journal integrity algorithm"), NULL },
{ "journal-integrity-key-size",'\0', POPT_ARG_INT, &opt_journal_integrity_key_size,0, N_("The size of the journal integrity key"), N_("BITS") },
{ "journal-integrity-key-file",'\0', POPT_ARG_STRING, &opt_journal_integrity_key_file,0, N_("Read the journal integrity key from a file"), NULL },
{ "journal-crypt", '\0', POPT_ARG_STRING, &opt_journal_crypt, 0, N_("Journal encryption algorithm"), NULL },
{ "journal-crypt-key-size", '\0', POPT_ARG_INT, &opt_journal_crypt_key_size, 0, N_("The size of the journal encryption key"), N_("BITS") },
{ "journal-crypt-key-file", '\0', POPT_ARG_STRING, &opt_journal_crypt_key_file, 0, N_("Read the journal encryption key from a file"), NULL },
{ "integrity-no-journal", 'D', POPT_ARG_NONE, &opt_integrity_nojournal, 0, N_("Disable journal for integrity device"), NULL },
{ "integrity-recovery-mode", 'R', POPT_ARG_NONE, &opt_integrity_recovery, 0, N_("Recovery mode (no journal, no tag checking)"), NULL },
{ "integrity-bitmap-mode", 'B', POPT_ARG_NONE, &opt_integrity_bitmap, 0, N_("Use bitmap to track changes and disable journal for integrity device"), NULL },
{ "integrity-recalculate", '\0', POPT_ARG_NONE, &opt_integrity_recalculate, 0, N_("Recalculate initial tags automatically."), NULL },
POPT_TABLEEND
};
poptContext popt_context;
struct action_type *action;
const char *aname;
int r;
crypt_set_log_callback(NULL, tool_log, NULL);
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
popt_context = poptGetContext("integrity", argc, argv, popt_options, 0);
poptSetOtherOptionHelp(popt_context,
_("[OPTION...] <action> <action-specific>"));
while ((r = poptGetNextOpt(popt_context)) >= 0) {
}
if (r < -1)
usage(popt_context, EXIT_FAILURE, poptStrerror(r),
poptBadOption(popt_context, POPT_BADOPTION_NOALIAS));
if (opt_version_mode) {
log_std("%s %s\n", PACKAGE_INTEGRITY, PACKAGE_VERSION);
poptFreeContext(popt_context);
exit(EXIT_SUCCESS);
}
if (!(aname = poptGetArg(popt_context)))
usage(popt_context, EXIT_FAILURE, _("Argument <action> missing."),
poptGetInvocationName(popt_context));
action_argc = 0;
action_argv = poptGetArgs(popt_context);
/* Make return values of poptGetArgs more consistent in case of remaining argc = 0 */
if (!action_argv)
action_argv = null_action_argv;
/* Count args, somewhat unnice, change? */
while (action_argv[action_argc] != NULL)
action_argc++;
/* Handle aliases */
if (!strcmp(aname, "create") && action_argc > 1) {
/* create command had historically switched arguments */
if (action_argv[0] && action_argv[1]) {
const char *tmp = action_argv[0];
action_argv[0] = action_argv[1];
action_argv[1] = tmp;
}
aname = "open";
} else if (!strcmp(aname, "remove")) {
aname = "close";
}
for (action = action_types; action->type; action++)
if (strcmp(action->type, aname) == 0)
break;
if (!action->type)
usage(popt_context, EXIT_FAILURE, _("Unknown action."),
poptGetInvocationName(popt_context));
if (action_argc < action->required_action_argc) {
char buf[128];
snprintf(buf, 128,_("%s: requires %s as arguments"), action->type, action->arg_desc);
usage(popt_context, EXIT_FAILURE, buf,
poptGetInvocationName(popt_context));
}
if (!strcmp(aname, "format") && opt_tag_size == 0)
opt_tag_size = DEFAULT_TAG_SIZE;
if (opt_integrity_recalculate && strcmp(aname, "open"))
usage(popt_context, EXIT_FAILURE,
_("Option --integrity-recalculate can be used only for open action."),
poptGetInvocationName(popt_context));
if (opt_interleave_sectors < 0 || opt_journal_watermark < 0 ||
opt_journal_commit_time < 0 || opt_tag_size < 0 ||
opt_sector_size < 0 || opt_buffer_sectors < 0 ||
opt_integrity_key_size < 0 || opt_journal_integrity_key_size < 0 ||
opt_journal_crypt_key_size < 0 || opt_bitmap_flush_time < 0 || opt_bitmap_sectors_per_bit < 0)
usage(popt_context, EXIT_FAILURE,
_("Negative number for option not permitted."),
poptGetInvocationName(popt_context));
if (strcmp(aname, "format") && (opt_journal_size_str || opt_interleave_sectors ||
opt_sector_size || opt_tag_size || opt_no_wipe ))
usage(popt_context, EXIT_FAILURE,
_("Options --journal-size, --interleave-sectors, --sector-size, --tag-size"
" and --no-wipe can be used only for format action.\n"),
poptGetInvocationName(popt_context));
if (opt_journal_size_str &&
tools_string_to_size(NULL, opt_journal_size_str, &opt_journal_size))
usage(popt_context, EXIT_FAILURE, _("Invalid journal size specification."),
poptGetInvocationName(popt_context));
if ((opt_integrity_key_file && !opt_integrity_key_size) ||
(!opt_integrity_key_file && opt_integrity_key_size))
usage(popt_context, EXIT_FAILURE, _("Both key file and key size options must be specified."),
poptGetInvocationName(popt_context));
if (!opt_integrity && opt_integrity_key_file)
usage(popt_context, EXIT_FAILURE, _("Integrity algorithm must be specified if integrity key is used."),
poptGetInvocationName(popt_context));
if ((opt_journal_integrity_key_file && !opt_journal_integrity_key_size) ||
(!opt_journal_integrity_key_file && opt_journal_integrity_key_size))
usage(popt_context, EXIT_FAILURE, _("Both journal integrity key file and key size options must be specified."),
poptGetInvocationName(popt_context));
if (!opt_journal_integrity && opt_journal_integrity_key_file)
usage(popt_context, EXIT_FAILURE, _("Journal integrity algorithm must be specified if journal integrity key is used."),
poptGetInvocationName(popt_context));
if ((opt_journal_crypt_key_file && !opt_journal_crypt_key_size) ||
(!opt_journal_crypt_key_file && opt_journal_crypt_key_size))
usage(popt_context, EXIT_FAILURE, _("Both journal encryption key file and key size options must be specified."),
poptGetInvocationName(popt_context));
if (!opt_journal_crypt && opt_journal_crypt_key_file)
usage(popt_context, EXIT_FAILURE, _("Journal encryption algorithm must be specified if journal encryption key is used."),
poptGetInvocationName(popt_context));
if (opt_integrity_recovery && opt_integrity_bitmap)
usage(popt_context, EXIT_FAILURE, _("Recovery and bitmap mode options are mutually exclusive."),
poptGetInvocationName(popt_context));
if (opt_integrity_bitmap && (opt_journal_integrity_key_file || opt_journal_crypt || opt_journal_watermark || opt_journal_commit_time))
usage(popt_context, EXIT_FAILURE, _("Journal options cannot be used in bitmap mode."),
poptGetInvocationName(popt_context));
if (!opt_integrity_bitmap && (opt_bitmap_flush_time || opt_bitmap_sectors_per_bit))
usage(popt_context, EXIT_FAILURE, _("Bitmap options can be used only in bitmap mode."),
poptGetInvocationName(popt_context));
if (opt_debug) {
opt_verbose = 1;
crypt_set_debug_level(-1);
dbg_version_and_cmd(argc, argv);
}
r = run_action(action);
poptFreeContext(popt_context);
return r;
}
void UnitGroup::exe_assign(int destXLoc, int destYLoc, int targetMobileType, int actionNationRecno)
{
//---------------------------------------//
Unit* unitPtr;
int locX, locY;
int right = 0;
int left = 0;
int midX = 0;
int top = 0;
int bottom = 0;
int midY = 0;
if(size() == 1)
{
unitPtr = get_unit(1);
unitPtr->set_no_longer_in_formation();
unitPtr->assign(destXLoc, destYLoc, actionNationRecno);
return;
}
Location* locPtr;
locPtr = world.get_loc(destXLoc, destYLoc);
int baseObjRecno = locPtr->base_obj_recno(targetMobileType);
// ###### begin Gilbert 6/5 #######//
if( !baseObjRecno )
return;
// ###### end Gilbert 6/5 #######//
BaseObj* thePlace = base_obj_array[baseObjRecno];
int destWidth = thePlace->obj_loc_width();
int destHeight = thePlace->obj_loc_height();
for(int i = 1; i<=size(); i++)
{
unitPtr = get_unit(i);
unitPtr->set_no_longer_in_formation();
locX = unitPtr->next_x_loc();
locY = unitPtr->next_y_loc();
if(locX < destXLoc) //left
left++;
else if(locX > destXLoc+destWidth-1) //right
right++;
else
midX++;
if(locY < destYLoc) //top
top++;
else if(locY > destYLoc+destHeight-1) //bottom
bottom++;
else
midY++;
}
if(!left && !midX) //all at right side
{
run_action( destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno );
return;
}
if(!right && !midX) //all at left side
{
run_action( destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno );
return;
}
if(!top && !midY) //all at bottom side
{
run_action( destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno);
return;
}
if(!bottom && !midY) //all at top side
{
run_action(destXLoc, destYLoc, UNIT_ASSIGN, baseObjRecno);
return;
}
for(i=1; i<=size(); i++)
{
unitPtr = get_unit(i);
unitPtr->assign(destXLoc, destYLoc, actionNationRecno);
}
}
int main(int argc, char *argv[], char *envp[])
{
int action = 0;
int verbose = 0;
int verbose_tmp;
int verbose_custom = 0;
int quiet = 0;
int veid, ret, skiplock = 0;
char buf[256];
vps_param *gparam = NULL, *vps_p = NULL, *cmd_p = NULL;
const char *action_nm;
struct sigaction act;
char *name = NULL, *opt;
_proc_title = argv[0];
_proc_title_len = envp[0] - argv[0];
gparam = init_vps_param();
vps_p = init_vps_param();
cmd_p = init_vps_param();
sigemptyset(&act.sa_mask);
act.sa_handler = SIG_IGN;
act.sa_flags = 0;
sigaction(SIGPIPE, &act, NULL);
while (argc > 1) {
opt = argv[1];
if (!strcmp(opt, "--verbose")) {
if (argc > 2 &&
!parse_int(argv[2], &verbose_tmp))
{
verbose += verbose_tmp;
argc--; argv++;
} else {
verbose++;
}
verbose_custom = 1;
} else if (!strncmp(opt, "--verbose=", 10)) {
if (parse_int(opt + 10, &verbose_tmp)) {
fprintf(stderr, "Invalid value for"
" --verbose\n");
exit(VZ_INVALID_PARAMETER_VALUE);
}
verbose += verbose_tmp;
verbose_custom = 1;
} else if (!strcmp(opt, "--quiet"))
quiet = 1;
else if (!strcmp(opt, "--version")) {
version(stdout);
exit(0);
} else if (!strcmp(opt, "--skiplock"))
skiplock = YES;
else
break;
argc--; argv++;
}
if (argc <= 1)
usage(VZ_INVALID_PARAMETER_SYNTAX);
action_nm = argv[1];
init_log(NULL, 0, 1, verbose, 0, NULL);
if (!strcmp(argv[1], "set")) {
init_modules(&g_action, "set");
action = ACTION_SET;
// status = ST_SET;
} else if (!strcmp(argv[1], "create")) {
init_modules(&g_action, "create");
action = ACTION_CREATE;
// status = ST_CREATE;
} else if (!strcmp(argv[1], "start")) {
init_modules(&g_action, "set");
action = ACTION_START;
// status = ST_START;
} else if (!strcmp(argv[1], "stop")) {
init_modules(&g_action, "set");
action = ACTION_STOP;
// status = ST_STOP;
} else if (!strcmp(argv[1], "restart")) {
action = ACTION_RESTART;
// status = ST_RESTART;
} else if (!strcmp(argv[1], "destroy")) {
action = ACTION_DESTROY;
// status = ST_DESTROY;
} else if (!strcmp(argv[1], "mount")) {
action = ACTION_MOUNT;
// status = ST_MOUNT;
} else if (!strcmp(argv[1], "umount")) {
action = ACTION_UMOUNT;
// status = ST_UMOUNT;
} else if (!strcmp(argv[1], "exec3")) {
action = ACTION_EXEC3;
} else if (!strcmp(argv[1], "exec2")) {
action = ACTION_EXEC2;
} else if (!strcmp(argv[1], "exec")) {
action = ACTION_EXEC;
} else if (!strcmp(argv[1], "runscript")) {
action = ACTION_RUNSCRIPT;
} else if (!strcmp(argv[1], "enter")) {
action = ACTION_ENTER;
} else if (!strcmp(argv[1], "status")) {
action = ACTION_STATUS;
quiet = 1;
} else if (!strcmp(argv[1], "chkpnt")) {
action = ACTION_CHKPNT;
} else if (!strcmp(argv[1], "restore")) {
action = ACTION_RESTORE;
} else if (!strcmp(argv[1], "quotaon")) {
action = ACTION_QUOTAON;
} else if (!strcmp(argv[1], "quotaoff")) {
action = ACTION_QUOTAOFF;
} else if (!strcmp(argv[1], "quotainit")) {
action = ACTION_QUOTAINIT;
} else if (!strcmp(argv[1], "--help")) {
usage(0);
} else {
init_modules(&g_action, action_nm);
action = ACTION_CUSTOM;
if (!g_action.mod_count) {
fprintf(stderr, "Bad command: %s\n", argv[1]);
ret = VZ_INVALID_PARAMETER_SYNTAX;
goto error;
}
}
if (argc < 3) {
fprintf(stderr, "CT ID missing\n");
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
if (parse_int(argv[2], &veid)) {
name = strdup(argv[2]);
veid = get_veid_by_name(name);
if (veid < 0) {
fprintf(stderr, "Bad CT ID %s\n", argv[2]);
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
}
argc -= 2; argv += 2;
/* Read global config file */
if (vps_parse_config(veid, GLOBAL_CFG, gparam, &g_action)) {
fprintf(stderr, "Global configuration file %s not found\n",
GLOBAL_CFG);
ret = VZ_NOCONFIG;
goto error;
}
init_log(gparam->log.log_file, veid, gparam->log.enable != NO,
gparam->log.level, quiet, "vzctl");
/* Set verbose level from global config if not overwriten
by --verbose
*/
if (!verbose_custom && gparam->log.verbose != NULL) {
verbose = *gparam->log.verbose;
verbose_custom = 1;
}
if (verbose < -1)
verbose = -1;
if (verbose_custom)
set_log_verbose(verbose);
if ((ret = parse_action_opt(veid, action, argc, argv, cmd_p,
action_nm)))
{
goto error;
}
if (veid == 0 && action != ACTION_SET) {
fprintf(stderr, "Only set actions are allowed for CT0\n");
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
} else if (veid < 0) {
fprintf(stderr, "Bad CT ID %d\n", veid);
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
get_vps_conf_path(veid, buf, sizeof(buf));
if (stat_file(buf)) {
if (vps_parse_config(veid, buf, vps_p, &g_action)) {
logger(-1, 0, "Error in config file %s",
buf);
ret = VZ_NOCONFIG;
goto error;
}
if (name != NULL &&
vps_p->res.name.name != NULL &&
strcmp(name, vps_p->res.name.name))
{
logger(-1, 0, "Unable to find container by name %s",
name);
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
} else if (action != ACTION_CREATE &&
action != ACTION_STATUS &&
action != ACTION_SET)
{
logger(-1, 0, "Container config file does not exist");
ret = VZ_NOVECONFIG;
goto error;
}
merge_vps_param(gparam, vps_p);
merge_global_param(cmd_p, gparam);
ret = run_action(veid, action, gparam, vps_p, cmd_p, argc-1, argv+1,
skiplock);
error:
free_modules(&g_action);
free_vps_param(gparam);
free_vps_param(vps_p);
free_vps_param(cmd_p);
free_log();
if (name != NULL) free(name);
return ret;
}
int main(int argc, char *argv[], char *envp[])
{
act_t action = -1;
int verbose = 0;
int verbose_custom = 0;
int quiet = 0;
int veid, ret, skiplock = 0;
char buf[256];
vps_param *gparam = NULL, *vps_p = NULL, *cmd_p = NULL;
const char *action_nm;
struct sigaction act;
char *name = NULL, *opt;
_proc_title = argv[0];
_proc_title_len = envp[0] - argv[0];
gparam = init_vps_param();
vps_p = init_vps_param();
cmd_p = init_vps_param();
sigemptyset(&act.sa_mask);
act.sa_handler = SIG_IGN;
act.sa_flags = 0;
sigaction(SIGPIPE, &act, NULL);
while (argc > 1) {
opt = argv[1];
if (!strcmp(opt, "--verbose")) {
verbose++;
verbose_custom = 1;
} else if (!strcmp(opt, "--quiet"))
quiet = 1;
else if (!strcmp(opt, "--version")) {
version(stdout);
exit(0);
} else if (!strcmp(opt, "--skiplock"))
skiplock = YES;
else
break;
argc--; argv++;
}
if (argc <= 1)
usage(VZ_INVALID_PARAMETER_SYNTAX);
action_nm = argv[1];
init_log(NULL, 0, 1, verbose, quiet, NULL);
if (!strcmp(argv[1], "set")) {
init_modules(&g_action, "set");
action = ACTION_SET;
} else if (!strcmp(argv[1], "create")) {
init_modules(&g_action, "create");
action = ACTION_CREATE;
} else if (!strcmp(argv[1], "start")) {
init_modules(&g_action, "set");
action = ACTION_START;
} else if (!strcmp(argv[1], "stop")) {
init_modules(&g_action, "set");
action = ACTION_STOP;
} else if (!strcmp(argv[1], "restart")) {
action = ACTION_RESTART;
} else if (!strcmp(argv[1], "destroy") || !strcmp(argv[1], "delete")) {
action = ACTION_DESTROY;
} else if (!strcmp(argv[1], "mount")) {
action = ACTION_MOUNT;
} else if (!strcmp(argv[1], "umount")) {
action = ACTION_UMOUNT;
} else if (!strcmp(argv[1], "exec3")) {
action = ACTION_EXEC3;
} else if (!strcmp(argv[1], "exec2")) {
action = ACTION_EXEC2;
} else if (!strcmp(argv[1], "exec")) {
action = ACTION_EXEC;
} else if (!strcmp(argv[1], "runscript")) {
action = ACTION_RUNSCRIPT;
} else if (!strcmp(argv[1], "enter")) {
action = ACTION_ENTER;
} else if (!strcmp(argv[1], "console")) {
action = ACTION_CONSOLE;
#ifdef HAVE_PLOOP
} else if (!strcmp(argv[1], "convert")) {
action = ACTION_CONVERT;
} else if (!strcmp(argv[1], "compact")) {
action = ACTION_COMPACT;
#endif
} else if (!strcmp(argv[1], "status")) {
action = ACTION_STATUS;
quiet = 1;
} else if (!strcmp(argv[1], "suspend") || !strcmp(argv[1], "chkpnt")) {
action = ACTION_SUSPEND;
} else if (!strcmp(argv[1], "resume") || !strcmp(argv[1], "restore")) {
action = ACTION_RESUME;
} else if (!strcmp(argv[1], "quotaon")) {
action = ACTION_QUOTAON;
} else if (!strcmp(argv[1], "quotaoff")) {
action = ACTION_QUOTAOFF;
} else if (!strcmp(argv[1], "quotainit")) {
action = ACTION_QUOTAINIT;
#ifdef HAVE_PLOOP
} else if (!strcmp(argv[1], "snapshot")) {
action = ACTION_SNAPSHOT_CREATE;
} else if (!strcmp(argv[1], "snapshot-switch")) {
action = ACTION_SNAPSHOT_SWITCH;
} else if (!strcmp(argv[1], "snapshot-delete")) {
action = ACTION_SNAPSHOT_DELETE;
} else if (!strcmp(argv[1], "snapshot-list")) {
action = ACTION_SNAPSHOT_LIST;
} else if (!strcmp(argv[1], "snapshot-mount")) {
action = ACTION_SNAPSHOT_MOUNT;
} else if (!strcmp(argv[1], "snapshot-umount")) {
action = ACTION_SNAPSHOT_UMOUNT;
#endif
} else if (!strcmp(argv[1], "--help")) {
usage(0);
} else {
init_modules(&g_action, action_nm);
action = ACTION_CUSTOM;
if (!g_action.mod_count) {
fprintf(stderr, "Bad command: %s\n", argv[1]);
ret = VZ_INVALID_PARAMETER_SYNTAX;
goto error;
}
}
if (argc < 3) {
fprintf(stderr, "CT ID missing\n");
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
if (parse_int(argv[2], &veid)) {
name = strdup(argv[2]);
veid = get_veid_by_name(name);
}
if (veid < 0 || veid > VEID_MAX) {
fprintf(stderr, "Bad CT ID %s\n", argv[2]);
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
argc -= 2; argv += 2;
/* getopt_long() prints argv[0] when reporting errors */
argv[0] = _proc_title;
/* Read global config file */
if (vps_parse_config(veid, GLOBAL_CFG, gparam, &g_action)) {
ret = VZ_NOCONFIG;
goto error;
}
init_log(gparam->log.log_file, veid, gparam->log.enable != NO,
gparam->log.level, quiet, "vzctl");
/* Set verbose level from global config if not overwriten
by --verbose
*/
if (!verbose_custom && gparam->log.verbose != NULL) {
verbose = *gparam->log.verbose;
verbose_custom = 1;
}
if (verbose < -1)
verbose = -1;
if (verbose_custom)
set_log_verbose(verbose);
if ((ret = parse_action_opt(veid, action, argc, argv, cmd_p,
action_nm)))
{
goto error;
}
if (veid == 0 && action != ACTION_SET) {
fprintf(stderr, "Only set actions are allowed for CT0\n");
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
} else if (veid < 0) {
fprintf(stderr, "Bad CT ID %d\n", veid);
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
get_vps_conf_path(veid, buf, sizeof(buf));
if (stat_file(buf) == 1) {
if (vps_parse_config(veid, buf, vps_p, &g_action)) {
ret = VZ_NOCONFIG;
goto error;
}
if (name != NULL &&
vps_p->res.name.name != NULL &&
strcmp(name, vps_p->res.name.name))
{
logger(-1, 0, "Unable to find container by name %s",
name);
ret = VZ_INVALID_PARAMETER_VALUE;
goto error;
}
} else if (action != ACTION_CREATE &&
action != ACTION_STATUS &&
action != ACTION_SET)
{
logger(-1, 0, "Container config file does not exist");
ret = VZ_NOVECONFIG;
goto error;
}
merge_vps_param(gparam, vps_p);
merge_global_param(cmd_p, gparam);
ret = run_action(veid, action, gparam, vps_p, cmd_p, argc, argv,
skiplock);
error:
free_modules(&g_action);
free_vps_param(gparam);
free_vps_param(vps_p);
free_vps_param(cmd_p);
free_log();
free(name);
return ret;
}
void UnitGroup::exe_move(int destXLoc, int destYLoc, bool forceMoveFlag)
{
run_action( destXLoc, destYLoc, UNIT_MOVE, 0, forceMoveFlag );
}
int
main(int argc, char *argv[])
{
return !run_action(NACTIONS, plugin_actions, argc, argv);
}
sysdig_table_action sinsp_cursesui::handle_input(int ch)
{
//
// Avoid parsing keys during file load
//
if((!m_inspector->is_live()) && !is_eof())
{
if(ch != KEY_BACKSPACE &&
ch != 127 &&
ch != 'q' &&
ch != KEY_F(10))
{
return STA_NONE;
}
}
if(m_mainhelp_page != NULL)
{
sysdig_table_action actn = m_mainhelp_page->handle_input(ch);
if(actn == STA_DESTROY_CHILD)
{
delete m_mainhelp_page;
m_mainhelp_page = NULL;
if(m_spy_box)
{
m_spy_box->render();
}
if(m_viz != NULL)
{
m_viz->render(true);
}
if(m_viewinfo_page)
{
m_viewinfo_page->render();
}
render();
return STA_NONE;
}
else if(actn != STA_PARENT_HANDLE)
{
return actn;
}
}
if(m_view_sidemenu != NULL)
{
ASSERT(m_action_sidemenu == NULL);
sysdig_table_action ta = m_view_sidemenu->handle_input(ch);
if(ta == STA_SWITCH_VIEW)
{
if(m_viewinfo_page)
{
delete m_viewinfo_page;
m_viewinfo_page = NULL;
}
return ta;
}
else if(ta != STA_PARENT_HANDLE)
{
return STA_NONE;
}
}
else
{
if(m_action_sidemenu != NULL)
{
sysdig_table_action ta = m_action_sidemenu->handle_input(ch);
if(ta == STA_SWITCH_VIEW)
{
sinsp_view_info* vinfo = get_selected_view();
g_logger.format("running action %d %s", m_selected_action_sidemenu_entry,
vinfo->m_name.c_str());
ASSERT(m_selected_action_sidemenu_entry < vinfo->m_actions.size());
run_action(&vinfo->m_actions[m_selected_action_sidemenu_entry]);
return ta;
}
else if(ta == STA_DESTROY_CHILD)
{
m_viz->set_x_start(0);
delete m_action_sidemenu;
m_action_sidemenu = NULL;
m_viz->set_x_start(0);
m_viz->recreate_win(m_screenh - 3);
m_viz->render(true);
m_viz->render(true);
render();
}
else if(ta != STA_PARENT_HANDLE)
{
return STA_NONE;
}
}
}
if(m_output_filtering || m_output_searching || m_search_caller_interface != NULL)
{
ASSERT(m_view_sidemenu == NULL);
ASSERT(m_action_sidemenu == NULL);
return handle_textbox_input(ch);
}
if(m_spy_box != NULL)
{
ASSERT(m_view_sidemenu == NULL);
ASSERT(m_action_sidemenu == NULL);
ASSERT(m_output_filtering == false);
ASSERT(m_output_searching == false);
sysdig_table_action actn = m_spy_box->handle_input(ch);
if(actn != STA_PARENT_HANDLE)
{
return actn;
}
}
//
// Note: the info page doesn't handle input when the sidemenu is on, because in that
// case it's just going to passively show the info for the selected view
//
if(m_viewinfo_page && m_view_sidemenu == NULL)
{
ASSERT(m_view_sidemenu == NULL);
sysdig_table_action actn = m_viewinfo_page->handle_input(ch);
if(actn == STA_DESTROY_CHILD)
{
delete m_viewinfo_page;
m_viewinfo_page = NULL;
if(m_viz != NULL)
{
m_viz->render(true);
}
render();
return STA_NONE;
}
return actn;
}
//
// Pass the event to the table viz
//
if(m_viz)
{
sysdig_table_action actn = m_viz->handle_input(ch);
if(actn != STA_PARENT_HANDLE)
{
return actn;
}
}
switch(ch)
{
case '?':
case 'h':
case KEY_F(1):
m_mainhelp_page = new curses_mainhelp_page(this);
break;
case KEY_F(10):
case 'q':
return STA_QUIT;
case 'p':
pause();
break;
case KEY_F(2):
if(m_action_sidemenu != NULL)
{
break;
}
if(m_view_sidemenu == NULL)
{
m_viz->set_x_start(VIEW_SIDEMENU_WIDTH);
m_view_sidemenu = new curses_table_sidemenu(curses_table_sidemenu::ST_VIEWS,
this, m_selected_view_sidemenu_entry, VIEW_SIDEMENU_WIDTH);
m_view_sidemenu->set_entries(&m_sidemenu_viewlist);
m_view_sidemenu->set_title("Select View");
render();
m_viewinfo_page = new curses_viewinfo_page(this,
m_selected_view,
TABLE_Y_START,
VIEW_SIDEMENU_WIDTH,
m_screenh - TABLE_Y_START - 1,
m_screenw - VIEW_SIDEMENU_WIDTH);
}
else
{
if(m_viewinfo_page)
{
delete m_viewinfo_page;
m_viewinfo_page = NULL;
}
m_viz->set_x_start(0);
delete m_view_sidemenu;
m_view_sidemenu = NULL;
m_viz->recreate_win(m_screenh - 3);
render();
}
break;
case '/':
case 6: // CTRL+F
m_search_caller_interface = NULL;
m_output_searching = true;
//m_manual_search_text = "";
m_cursor_pos = 0;
curs_set(1);
render();
break;
//case KEY_F(3):
// break;
case '\\':
case KEY_F(4):
m_search_caller_interface = NULL;
m_output_filtering = true;
m_cursor_pos = 0;
curs_set(1);
render();
break;
case KEY_F(5):
case 'e':
if(m_datatable == NULL)
{
//
// No F5 for non table displays
//
return STA_NONE;
}
else if(m_datatable->m_type == sinsp_table::TT_LIST)
{
//
// No F5 for list tables
//
return STA_NONE;
}
if(m_datatable->m_sample_data != NULL && m_datatable->m_sample_data->size() != 0)
{
m_selected_view_sidemenu_entry = 0;
m_selected_action_sidemenu_entry = 0;
return STA_SPY;
}
break;
case KEY_F(6):
case 'd':
if(m_datatable == NULL)
{
//
// No F5 for non table displays
//
return STA_NONE;
}
else if(m_datatable->m_type == sinsp_table::TT_LIST)
{
//
// No F5 for list tables
//
return STA_NONE;
}
if(m_datatable->m_sample_data != NULL && m_datatable->m_sample_data->size() != 0)
{
m_selected_view_sidemenu_entry = 0;
m_selected_action_sidemenu_entry = 0;
return STA_DIG;
}
break;
case KEY_F(7):
m_viewinfo_page = new curses_viewinfo_page(this,
m_selected_view,
0,
0,
m_screenh,
m_screenw);
break;
case KEY_F(8):
if(m_view_sidemenu != NULL)
{
break;
}
if(m_action_sidemenu == NULL)
{
m_viz->set_x_start(ACTION_SIDEMENU_WIDTH);
m_action_sidemenu = new curses_table_sidemenu(curses_table_sidemenu::ST_ACTIONS,
this, m_selected_action_sidemenu_entry, ACTION_SIDEMENU_WIDTH);
populate_action_sidemenu();
m_action_sidemenu->set_title("Select Action");
m_viz->set_x_start(ACTION_SIDEMENU_WIDTH);
m_viz->recreate_win(m_screenh - 3);
render();
m_viewinfo_page = NULL;
}
else
{
m_viz->set_x_start(0);
delete m_action_sidemenu;
m_action_sidemenu = NULL;
m_viz->set_x_start(0);
m_viz->recreate_win(m_screenh - 3);
m_viz->render(true);
m_viz->render(true);
render();
}
break;
case KEY_RESIZE:
getmaxyx(stdscr, m_screenh, m_screenw);
render();
if(m_spy_box)
{
m_spy_box->render();
m_spy_box->render();
}
if(m_viz != NULL)
{
m_viz->recreate_win(m_screenh - 3);
m_viz->render(true);
m_viz->render(true);
}
if(m_viewinfo_page)
{
m_viewinfo_page->render();
m_viewinfo_page->render();
}
render();
break;
case KEY_MOUSE:
{
MEVENT* event = NULL;
if(m_view_sidemenu != NULL)
{
event = &m_view_sidemenu->m_last_mevent;
}
else if(m_action_sidemenu != NULL)
{
event = &m_action_sidemenu->m_last_mevent;
}
else if(m_spy_box != NULL)
{
event = &m_spy_box->m_last_mevent;
}
else if(m_viz != NULL)
{
event = &m_viz->m_last_mevent;
}
if(event == NULL)
{
ASSERT(false);
break;
}
if(event->bstate & BUTTON1_CLICKED ||
event->bstate & BUTTON1_DOUBLE_CLICKED)
{
if((uint32_t)event->y == m_screenh - 1)
{
int keyc = m_mouse_to_key_list.get_key_from_coordinates(event->x, event->y);
if(keyc != -1)
{
return handle_input(keyc);
}
}
else if((uint32_t)event->y == 1 &&
(uint32_t)event->x >= m_filterstring_start_x &&
(uint32_t)event->x <= m_filterstring_end_x)
{
m_search_caller_interface = NULL;
m_is_filter_sysdig = true;
m_output_filtering = true;
m_manual_filter = m_complete_filter;
m_cursor_pos = 0;
curs_set(1);
render();
}
}
}
break;
default:
break;
}
return STA_NONE;
}
int main(int argc, char **argv) {
const char *query = NULL;
int c, bits = 0, actions_done = 0, actions = 0, action = ACTION_UNK;
char *homeplugindir = r_str_home (R2_HOMEDIR"/plugins");
char *ptr, *arch = NULL, *arch_name = NULL;
const char *op = NULL;
RCoreBinFilter filter;
RCore core;
RCoreFile *cf = NULL;
int xtr_idx = 0; // load all files if extraction is necessary.
int fd = -1;
int rawstr = 0;
r_core_init (&core);
bin = core.bin;
l = r_lib_new ("radare_plugin");
r_lib_add_handler (l, R_LIB_TYPE_BIN, "bin plugins",
&__lib_bin_cb, &__lib_bin_dt, NULL);
r_lib_add_handler (l, R_LIB_TYPE_BIN_XTR, "bin xtr plugins",
&__lib_bin_xtr_cb, &__lib_bin_xtr_dt, NULL);
/* load plugins everywhere */
r_lib_opendir (l, getenv ("LIBR_PLUGINS"));
r_lib_opendir (l, homeplugindir);
r_lib_opendir (l, LIBDIR"/radare2/"R2_VERSION);
#define is_active(x) (action&x)
#define set_action(x) actions++; action |=x
while ((c = getopt (argc, argv, "jgqAf:a:B:b:c:Ck:dMm:n:N:@:isSIHelRwO:o:rvLhxzZ")) != -1) {
switch (c) {
case 'g':
set_action (ACTION_CLASSES);
set_action (ACTION_IMPORTS);
set_action (ACTION_SYMBOLS);
set_action (ACTION_SECTIONS);
set_action (ACTION_STRINGS);
set_action (ACTION_SIZE);
set_action (ACTION_INFO);
set_action (ACTION_FIELDS);
set_action (ACTION_DWARF);
set_action (ACTION_ENTRIES);
set_action (ACTION_MAIN);
set_action (ACTION_LIBS);
set_action (ACTION_RELOCS);
set_action (ACTION_EXTRACT);
break;
case 'q': rad = R_CORE_BIN_SIMPLE; break;
case 'j': rad = R_CORE_BIN_JSON; break;
case 'A': set_action (ACTION_LISTARCHS); break;
case 'a': if (optarg) arch = optarg; break;
case 'c':
if (!optarg) {
eprintf ("Missing argument for -c");
return 1;
}
set_action (ACTION_CREATE);
create = strdup (optarg);
break;
case 'k': query = optarg; break;
case 'C': set_action (ACTION_CLASSES); break;
case 'f': if (optarg) arch_name = strdup (optarg); break;
case 'b': bits = r_num_math (NULL, optarg); break;
case 'm':
at = r_num_math (NULL, optarg);
set_action (ACTION_SRCLINE);
break;
case 'i': set_action (ACTION_IMPORTS); break;
case 's': set_action (ACTION_SYMBOLS); break;
case 'S': set_action (ACTION_SECTIONS); break;
case 'z':
if (is_active (ACTION_STRINGS)) {
rawstr = R_TRUE;
} else set_action (ACTION_STRINGS);
break;
case 'Z': set_action (ACTION_SIZE); break;
case 'I': set_action (ACTION_INFO); break;
case 'H': set_action (ACTION_FIELDS); break;
case 'd': set_action (ACTION_DWARF); break;
case 'e': set_action (ACTION_ENTRIES); break;
case 'M': set_action (ACTION_MAIN); break;
case 'l': set_action (ACTION_LIBS); break;
case 'R': set_action (ACTION_RELOCS); break;
case 'x': set_action (ACTION_EXTRACT); break;
case 'w': rw = R_TRUE; break;
case 'O':
op = optarg;
set_action (ACTION_OPERATION);
if (op && !strcmp (op, "help")) {
printf ("Operation string:\n"
" Dump symbols: d/s/1024\n"
" Dump section: d/S/.text\n"
" Resize section: r/.data/1024\n");
return 0;
}
if (optind==argc) {
eprintf ("Missing filename\n");
return 1;
}
break;
case 'o': output = optarg; break;
case 'r': rad = R_TRUE; break;
case 'v': va = R_TRUE; break;
case 'L': r_bin_list (bin); return 1;
case 'B': baddr = r_num_math (NULL, optarg); break;
case '@': at = r_num_math (NULL, optarg); break;
case 'n': name = optarg; break;
case 'N': bin->minstrlen = r_num_math (NULL, optarg); break;
//case 'V': return blob_version ("rabin2");
case 'h': return rabin_show_help (1);
default: action |= ACTION_HELP;
}
}
file = argv[optind];
if (!query)
if (action & ACTION_HELP || action == ACTION_UNK || file == NULL) {
if (va) return blob_version ("rabin2");
return rabin_show_help (0);
}
if (arch) {
ptr = strchr (arch, '_');
if (ptr) {
*ptr = '\0';
bits = r_num_math (NULL, ptr+1);
}
}
if (action & ACTION_CREATE) {
// TODO: move in a function outside
RBuffer *b;
int datalen, codelen;
ut8 *data = NULL, *code = NULL;
char *p2, *p = strchr (create, ':');
if (!p) {
eprintf ("Invalid format for -c flag. Use 'format:codehexpair:datahexpair'\n");
return 1;
}
*p++ = 0;
p2 = strchr (p, ':');
if (p2) {
// has data
*p2++ = 0;
data = malloc (strlen (p2)+1);
datalen = r_hex_str2bin (p2, data);
} else {
data = NULL;
datalen = 0;
}
code = malloc (strlen (p)+1);
if (!code) {
return 1;
}
codelen = r_hex_str2bin (p, code);
if (!arch) arch = "x86";
if (!bits) bits = 32;
if (!r_bin_use_arch (bin, arch, bits, create)) {
eprintf ("Cannot set arch\n");
return 1;
}
b = r_bin_create (bin, code, codelen, data, datalen);
if (b) {
if (r_file_dump (file, b->buf, b->length)) {
eprintf ("dumped %d bytes in '%s'\n", b->length, file);
r_file_chmod (file, "+x", 0);
} else eprintf ("error dumping into a.out\n");
r_buf_free (b);
} else eprintf ("Cannot create binary for this format '%s'.\n", create);
r_bin_free (bin);
return 0;
}
r_config_set_i (core.config, "bin.rawstr", rawstr);
cf = r_core_file_open (&core, file, R_IO_READ, 0);
fd = cf ? r_core_file_cur_fd (&core) : -1;
if (!cf || fd == -1) {
eprintf ("r_core: Cannot open file\n");
return 1;
}
if (!r_bin_load (bin, file, baddr, 0, xtr_idx, fd, rawstr)) {
if (!r_bin_load (bin, file, baddr, 0, xtr_idx, fd, rawstr)) {
eprintf ("r_bin: Cannot open file\n");
return 1;
}
}
if (query) {
if (!strcmp (query, "-")) {
__sdb_prompt (bin->cur->sdb);
} else sdb_query (bin->cur->sdb, query);
return 0;
}
// XXX: TODO move this to libr/core/bin.c
if (action & ACTION_LISTARCHS || ((arch || bits || arch_name) &&
!r_bin_select (bin, arch, bits, arch_name))) {
if (rad == R_CORE_BIN_JSON) {
int i;
printf ("[");
for (i = 0; i < bin->narch; i++) {
if (r_bin_select_idx (bin, bin->file, i)) {
RBinObject *o = r_bin_cur_object (bin);
RBinInfo *info = o ? o->info : NULL;
printf ("%s{\"arch\":\"%s\",\"bits\":%d,"
"\"offset\":%"PFMT64d",\"machine\":\"%s\"}",
i?",":"",info->arch, info->bits,
bin->cur->offset, info->machine);
}
}
printf ("]");
} else r_bin_list_archs (bin, 1);
free (arch_name);
}
if (baddr != 0LL) {
r_bin_set_baddr (bin, baddr);
bin->cur->o->baddr = baddr;
}
core.bin = bin;
filter.offset = at;
filter.name = name;
r_cons_new ()->is_interactive = R_FALSE;
#define isradjson (rad==R_CORE_BIN_JSON&&actions>0)
#define run_action(n,x,y) {\
if (action&x) {\
if (isradjson) r_cons_printf ("\"%s\":",n);\
if (!r_core_bin_info (&core, y, rad, va, &filter, 0)) {\
if (isradjson) r_cons_printf("false");\
};\
actions_done++;\
if (isradjson) r_cons_printf (actions==actions_done? "":",");\
}\
}
if (isradjson) r_cons_printf ("{");
run_action ("sections", ACTION_SECTIONS, R_CORE_BIN_ACC_SECTIONS);
run_action ("entries", ACTION_ENTRIES, R_CORE_BIN_ACC_ENTRIES);
run_action ("main", ACTION_MAIN, R_CORE_BIN_ACC_MAIN);
run_action ("imports", ACTION_IMPORTS, R_CORE_BIN_ACC_IMPORTS);
run_action ("classes", ACTION_CLASSES, R_CORE_BIN_ACC_CLASSES);
run_action ("symbols", ACTION_SYMBOLS, R_CORE_BIN_ACC_SYMBOLS);
run_action ("strings", ACTION_STRINGS, R_CORE_BIN_ACC_STRINGS);
run_action ("info", ACTION_INFO, R_CORE_BIN_ACC_INFO);
run_action ("fields", ACTION_FIELDS, R_CORE_BIN_ACC_FIELDS);
run_action ("libs", ACTION_LIBS, R_CORE_BIN_ACC_LIBS);
run_action ("relocs", ACTION_RELOCS, R_CORE_BIN_ACC_RELOCS);
run_action ("dwarf", ACTION_DWARF, R_CORE_BIN_ACC_DWARF);
run_action ("size", ACTION_SIZE, R_CORE_BIN_ACC_SIZE);
if (action&ACTION_SRCLINE)
rabin_show_srcline (at);
if (action&ACTION_EXTRACT)
rabin_extract ((arch==NULL && arch_name==NULL && bits==0));
if (op != NULL && action&ACTION_OPERATION)
rabin_do_operation (op);
if (isradjson)
printf ("}");
r_cons_flush ();
r_core_fini (&core);
return 0;
}
//----------- Begin of function UnitGroup::cluster_units_for_attack----//
//
// cluster units that are in the same direction of the target to attack
//
void UnitGroup::cluster_units_for_attack(int targetRecno, int targetLocX, int targetLocY, int targetWidth, int targetHeight)
{
Unit* unitPtr;
int locX, locY;
int right = 0;
int left = 0;
int midX = 0;
int top = 0;
int bottom = 0;
int midY = 0;
if(size() == 1)
{
unitPtr = get_unit(1);
if(unitPtr->can_attack())
unitPtr->attack(targetRecno, true);
return;
}
for(int i = 1; i<=size(); i++)
{
unitPtr = get_unit(i);
locX = unitPtr->next_x_loc();
locY = unitPtr->next_y_loc();
if(locX < targetLocX) //left
left++;
else if(locX > targetLocX+targetWidth-1) //right
right++;
else
midX++;
if(locY < targetLocY) //top
top++;
else if(locY > targetLocY+targetHeight-1) //bottom
bottom++;
else
midY++;
}
if(!left && !midX) //all at right side
{
run_action( targetLocX, targetLocY, UNIT_ATTACK, targetRecno );
return;
}
if(!right && !midX) //all at left side
{
run_action( targetLocX, targetLocY, UNIT_ATTACK, targetRecno );
return;
}
if(!top && !midY) //all at bottom side
{
run_action( targetLocX, targetLocY, UNIT_ATTACK, targetRecno);
return;
}
if(!bottom && !midY) //all at top side
{
run_action(targetLocX, targetLocY, UNIT_ATTACK, targetRecno);
return;
}
for(i=1; i<=size(); i++)
{
unitPtr = get_unit(i);
if(unitPtr->cur_action == SPRITE_ATTACK && unitPtr->cur_order.para == targetRecno)
continue;
if(unitPtr->can_attack())
unitPtr->attack(targetRecno, true);
}
}
