static void
command_write(char *opt)
{
char *endptr;
u_int32_t src;
u_int32_t dst;
size_t len;
dst = strtoul(opt, &endptr, 16);
if (opt == endptr)
goto out;
opt = get_next_arg(opt);
src = strtoul(opt, &endptr, 16);
if (opt == endptr)
goto out;
opt = get_next_arg(opt);
len = strtoul(opt, &endptr, 16);
if (opt == endptr)
goto out;
check_write_verify_flash(src, dst, len);
return;
out:
bad_param();
return;
}
static void
command_fill(char *opt)
{
char *endptr;
char *p;
char *limit;
int c;
p = (char *) strtoul(opt, &endptr, 16);
if (opt == endptr) {
bad_param();
return;
}
opt = get_next_arg(opt);
limit = (char *) strtoul(opt, &endptr, 16);
if (opt == endptr) {
bad_param();
return;
}
opt = get_next_arg(opt);
c = strtoul(opt, &endptr, 16);
if (opt == endptr)
c = '\0';
memset(p, c, limit - p);
}
static void prv_create_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char * end = NULL;
int result;
int64_t value;
uint8_t temp_buffer[MAX_PACKET_SIZE];
int temp_length = 0;
lwm2m_media_type_t format = LWM2M_CONTENT_TEXT;
//Get Client ID
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
//Get Uri
buffer = get_next_arg(buffer, &end);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
//Get Data to Post
buffer = get_next_arg(end, &end);
if (buffer[0] == 0) goto syntax_error;
if (!check_end_of_args(end)) goto syntax_error;
// TLV
/* Client dependent part */
if (uri.objectId == 1024)
{
result = lwm2m_PlainTextToInt64((uint8_t *)buffer, end - buffer, &value);
temp_length = lwm2m_intToTLV(LWM2M_TYPE_RESOURCE, value, (uint16_t) 1, temp_buffer, MAX_PACKET_SIZE);
format = LWM2M_CONTENT_TLV;
}
/* End Client dependent part*/
//Create
result = lwm2m_dm_create(lwm2mH, clientId, &uri, format, temp_buffer, temp_length, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
prv_print_error(result);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
static void prv_time_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char * end = NULL;
int result;
lwm2m_attributes_t attr;
int nb;
int value;
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
buffer = get_next_arg(buffer, &end);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
memset(&attr, 0, sizeof(lwm2m_attributes_t));
attr.toSet = LWM2M_ATTR_FLAG_MIN_PERIOD | LWM2M_ATTR_FLAG_MAX_PERIOD;
buffer = get_next_arg(end, &end);
if (buffer[0] == 0) goto syntax_error;
nb = sscanf(buffer, "%d", &value);
if (nb != 1) goto syntax_error;
if (value < 0) goto syntax_error;
attr.minPeriod = value;
buffer = get_next_arg(end, &end);
if (buffer[0] == 0) goto syntax_error;
nb = sscanf(buffer, "%d", &value);
if (nb != 1) goto syntax_error;
if (value < 0) goto syntax_error;
attr.maxPeriod = value;
if (!check_end_of_args(end)) goto syntax_error;
result = lwm2m_dm_write_attributes(lwm2mH, clientId, &uri, &attr, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
prv_print_error(result);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
static void
opt_subcmd_ip(char *opt)
{
bootopts.b_remote_ip.s_addr = inet_addr(opt);
opt = get_next_arg(opt);
bootopts.b_local_ip.s_addr = inet_addr(opt);
opt = get_next_arg(opt);
bootopts.b_netmask = inet_addr(opt);
opt = get_next_arg(opt);
bootopts.b_gate_ip.s_addr = inet_addr(opt);
}
static void prv_exec_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char * uriString;
int i;
int result;
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
buffer = get_next_arg(buffer);
if (buffer[0] == 0) goto syntax_error;
uriString = buffer;
buffer = get_next_arg(buffer);
i = 0;
while (uriString + i < buffer && !isspace(uriString[i]))
{
i++;
}
result = lwm2m_stringToUri(uriString, i, &uri);
if (result == 0) goto syntax_error;
if (buffer[0] == 0)
{
result = lwm2m_dm_execute(lwm2mH, clientId, &uri, NULL, 0, prv_result_callback, NULL);
}
else
{
result = lwm2m_dm_execute(lwm2mH, clientId, &uri, buffer, strlen(buffer), prv_result_callback, NULL);
}
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
static void prv_cancel_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
int result;
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
buffer = get_next_arg(buffer);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, strlen(buffer), &uri);
if (result == 0) goto syntax_error;
result = lwm2m_observe_cancel(lwm2mH, clientId, &uri, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
static void prv_cancel_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char* end = NULL;
int result;
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
buffer = get_next_arg(buffer, &end);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
if (!check_end_of_args(end)) goto syntax_error;
result = lwm2m_observe_cancel(lwm2mH, clientId, &uri, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
prv_print_error(result);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
static void prv_change(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
lwm2m_uri_t uri;
char * end = NULL;
int result;
end = get_end_of_arg(buffer);
if (end[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
buffer = get_next_arg(end, &end);
if (buffer[0] == 0)
{
fprintf(stderr, "report change!\n");
lwm2m_resource_value_changed(lwm2mH, &uri);
}
else
{
handle_value_changed(lwm2mH, &uri, buffer, end - buffer);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !\n");
}
bool quest_poison_drop_hook(char *fmt)
{
s32b mcnt = 0, i, x, y, o_idx;
object_type *o_ptr;
o_idx = get_next_arg(fmt);
o_ptr = &p_ptr->inventory[o_idx];
if (cquest.status != QUEST_STATUS_TAKEN) return FALSE;
if (p_ptr->wilderness_y != wild_locs[cquest.data[0]][0]) return FALSE;
if (p_ptr->wilderness_x != wild_locs[cquest.data[0]][1]) return FALSE;
if (p_ptr->wild_mode) return FALSE;
if (o_ptr->tval != TV_POTION2) return FALSE;
if (o_ptr->sval != SV_POTION2_CURE_WATER) return FALSE;
for (i = m_max - 1; i >= 1; i--)
{
/* Access the monster */
monster_type *m_ptr = &m_list[i];
/* Ignore "dead" monsters */
if (!m_ptr->r_idx) continue;
if (m_ptr->status <= MSTATUS_NEUTRAL) mcnt++;
}
if (mcnt < 10)
{
for (x = 1; x < cur_wid - 1; x++)
for (y = 1; y < cur_hgt - 1; y++)
{
if (!in_bounds(y, x)) continue;
if (cave[y][x].feat == FEAT_TAINTED_WATER) cave_set_feat(y, x, FEAT_SHAL_WATER);
}
cmsg_print(TERM_YELLOW, "Well done! The water seems to be clean now.");
cquest.status = QUEST_STATUS_COMPLETED;
del_hook(HOOK_DROP, quest_poison_drop_hook);
process_hooks_restart = TRUE;
return FALSE;
}
else
{
msg_print("There are too many monsters left to cure the water.");
return TRUE;
}
return FALSE;
}
static void prv_clear_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char * end = NULL;
int result;
lwm2m_attributes_t attr;
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
buffer = get_next_arg(buffer, &end);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
memset(&attr, 0, sizeof(lwm2m_attributes_t));
attr.toClear = LWM2M_ATTR_FLAG_LESS_THAN | LWM2M_ATTR_FLAG_GREATER_THAN | LWM2M_ATTR_FLAG_STEP | LWM2M_ATTR_FLAG_MIN_PERIOD | LWM2M_ATTR_FLAG_MAX_PERIOD ;
buffer = get_next_arg(end, &end);
if (!check_end_of_args(end)) goto syntax_error;
result = lwm2m_dm_write_attributes(lwm2mH, clientId, &uri, &attr, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
prv_print_error(result);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
bool quest_wolves_finish_hook(char *fmt)
{
s32b q_idx;
q_idx = get_next_arg(fmt);
if (q_idx != QUEST_WOLVES) return FALSE;
c_put_str(TERM_YELLOW, "Thank you for killing the pack of wolves!", 8, 0);
c_put_str(TERM_YELLOW, "You can use the hut as your house as a reward.", 9, 0);
/* Continue the plot */
*(quest[q_idx].plot) = QUEST_SPIDER;
return TRUE;
}
bool quest_invasion_death_hook(char *fmt)
{
s32b r_idx, m_idx;
m_idx = get_next_arg(fmt);
r_idx = m_list[m_idx].r_idx;
if (p_ptr->inside_quest != QUEST_INVASION) return FALSE;
if (r_idx == test_monster_name("Maeglin, the Traitor of Gondolin"))
{
cmsg_print(TERM_YELLOW, "You did it! Gondolin will remain hidden.");
cquest.status = QUEST_STATUS_COMPLETED;
del_hook(HOOK_MONSTER_DEATH, quest_invasion_death_hook);
process_hooks_restart = TRUE;
return (FALSE);
}
return FALSE;
}
static void
command_option(char *subcmd)
{
char *opt;
int i;
opt = get_next_arg(subcmd);
/* dispatch subcommand */
for (i = 0; opt_subcommands[i].c_name != NULL; i++) {
if (strcmp(subcmd, opt_subcommands[i].c_name) == 0) {
opt_subcommands[i].c_fn(opt);
break;
}
}
if (opt_subcommands[i].c_name == NULL) {
printf("unknown option subcommand\n");
command_help(NULL);
}
}
static void
bootmenu(void)
{
char input[LINEBUFLEN];
char *cmd;
char *opt;
int i;
for (;;) {
/* input a line */
input[0] = '\0';
printf("> ");
gets(input);
cmd = input;
/* skip leading whitespace. */
while(*cmd == ' ')
cmd++;
if(*cmd) {
/* here, some command entered */
opt = get_next_arg(cmd);
/* dispatch command */
for (i = 0; commands[i].c_name != NULL; i++) {
if (strcmp(cmd, commands[i].c_name) == 0) {
commands[i].c_fn(opt);
break;
}
}
if (commands[i].c_name == NULL) {
printf("unknown command\n");
command_help(NULL);
}
}
}
}
static void
command_dump(char *opt)
{
char *endptr;
const char *p;
const char *line_fence;
const char *limit;
p = (const char *) strtoul(opt, &endptr, 16);
if (opt == endptr) {
bad_param();
return;
}
opt = get_next_arg(opt);
limit = (const char *) strtoul(opt, &endptr, 16);
if (opt == endptr) {
limit = p + 256;
}
for (;;) {
printhexul((u_int32_t) p);
putchar(' ');
line_fence = p + 16;
while (p < line_fence) {
printhexuc(*p++);
putchar(' ');
if (p >= limit) {
putchar('\n');
return;
}
}
putchar('\n');
if (ISKEY) {
if (getchar() == '\x03')
break;
}
}
}
bool quest_invasion_ai_hook(char *fmt)
{
monster_type *m_ptr;
s32b m_idx;
m_idx = get_next_arg(fmt);
m_ptr = &m_list[m_idx];
if (p_ptr->inside_quest != QUEST_INVASION) return FALSE;
/* Ugly but thats better than a call to test_monster_name which is SLOW */
if (m_ptr->r_idx == 825)
{
/* Oups he fleed */
if ((m_ptr->fy == cquest.data[0]) && (m_ptr->fx == cquest.data[1]))
{
delete_monster_idx(m_idx);
cmsg_print(TERM_YELLOW, "Maeglin found the way to Gondolin! All hope is lost now!");
cquest.status = QUEST_STATUS_FAILED;
town_info[2].destroyed = TRUE;
return (FALSE);
}
/* Attack or flee ?*/
if (distance(m_ptr->fy, m_ptr->fx, p_ptr->py, p_ptr->px) <= 2)
{
return (FALSE);
}
else
{
process_hooks_return[0].num = cquest.data[0];
process_hooks_return[1].num = cquest.data[1];
return (TRUE);
}
}
return (FALSE);
}
bool quest_poison_quest_hook(char *fmt)
{
object_type forge, *q_ptr;
s32b q_idx;
q_idx = get_next_arg(fmt);
if (q_idx != QUEST_POISON) return FALSE;
q_ptr = &forge;
object_prep(q_ptr, lookup_kind(TV_POTION2, SV_POTION2_CURE_WATER));
q_ptr->number = 99;
object_aware(q_ptr);
object_known(q_ptr);
q_ptr->ident |= IDENT_STOREB;
q_ptr->note = quark_add("quest");
(void)inven_carry(q_ptr, FALSE);
del_hook(HOOK_INIT_QUEST, quest_poison_quest_hook);
process_hooks_restart = TRUE;
return FALSE;
}
pairing_node_t
pairing_node_init(
pairing_node_t self,
nyoci_node_t parent,
const char* name,
const char* path
) {
FILE* file = fopen(path, "r");
char* line = NULL;
size_t line_len = 0;
NYOCI_LIBRARY_VERSION_CHECK();
require(name != NULL, bail);
require(self || (self = pairing_node_alloc()), bail);
require(nyoci_node_init(
&self->node,
(void*)parent,
name
), bail);
self->node.has_link_content = 1;
// self->node.is_observable = 1;
self->interface = nyoci_get_current_instance();
smcp_pairing_mgr_init(&self->pairing_mgr, self->interface);
((nyoci_node_t)&self->node)->request_handler = (void*)&smcp_pairing_mgr_request_handler;
((nyoci_node_t)&self->node)->context = (void*)&self->pairing_mgr;
self->next_observer_refresh = nyoci_plat_cms_to_timestamp(NYOCI_OBSERVATION_KEEPALIVE_INTERVAL - MSEC_PER_SEC);
require(file != NULL, bail);
while(!feof(file) && (line=fgetln(file,&line_len))) {
char *cmd = get_next_arg(line, &line);
if (!cmd) {
continue;
} else if (strcaseequal(cmd, "Pairing")) {
char* pairing_id_str = get_next_arg(line, &line);
char* pairing_local_path_str = get_next_arg(line, &line);
char* pairing_remote_url_str = get_next_arg(line, &line);
char* pairing_enabled_str = get_next_arg(line, &line);
char* pairing_content_type_str = get_next_arg(line, &line);
if ( (pairing_id_str == NULL)
|| (pairing_local_path_str == NULL)
|| (pairing_remote_url_str == NULL)
|| (pairing_enabled_str == NULL)
|| (pairing_content_type_str == NULL)
) {
break;
}
smcp_pairing_t pairing = smcp_pairing_mgr_new_pairing(
&self->pairing_mgr,
pairing_local_path_str,
pairing_remote_url_str,
(uint8_t)atoi(pairing_id_str)
);
smcp_pairing_set_content_type(pairing, (coap_content_type_t)atoi(pairing_content_type_str));
if (atoi(pairing_enabled_str) != 0) {
smcp_pairing_set_enabled(pairing, true);
}
smcp_pairing_set_stable(pairing, true);
}
}
bail:
if (path && (path[0] != 0)) {
self->pairing_mgr.commit_stable_pairings = (void*)&pairing_node_commit_stable;
self->pairing_mgr.context = strdup(path);
}
if (file) {
fclose(file);
}
return self;
}
int main(int argc, char **argv){
#ifdef WIN32
WSADATA wsaData; // if this doesn't work
//WSAData wsaData; // then try this instead
if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) {
fprintf(stderr, "WSAStartup failed.\n");
exit(1);
}
#endif
int hand_shake_listen_port_no = 19999;
char* absolute_file_path = NULL;
char* packet_file_path = NULL;
char* colour_file_path = NULL;
char* remote_host = NULL;
for (int arg_index = 1; arg_index < argc; arg_index+=2){
if (strcmp(argv[arg_index], "-hand_shake_port") == 0){
hand_shake_listen_port_no = atoi(get_next_arg(arg_index, argv, argc));
}
if (strcmp(argv[arg_index], "-database") == 0){
absolute_file_path = get_next_arg(arg_index, argv, argc);
}
if (strcmp(argv[arg_index], "-colour_map") == 0){
colour_file_path = get_next_arg(arg_index, argv, argc);
}
if (strcmp(argv[arg_index], "-remote_host") == 0) {
remote_host = get_next_arg(arg_index, argv, argc);
}
}
if (colour_file_path == NULL) {
printf("Usage is \n "
"-colour_map "
"<Path to a file containing the population labels to receive,"
" and their associated colours>\n"
"[-hand_shake_port]"
"<optional port which the visualiser will listen to for"
" database hand shaking>\n"
"[-database]"
"<optional file path to where the database is located,"
" if needed for manual configuration>\n"
"[-remote_host] "
"<optional remote host, which will allow port triggering>\n");
return 1;
}
DatabaseMessageConnection *database_message_connection = NULL;
if (absolute_file_path == NULL) {
database_message_connection = new DatabaseMessageConnection(
hand_shake_listen_port_no);
printf("awaiting tool chain hand shake to say database is ready \n");
packet_file_path = database_message_connection->recieve_notification();
printf("received tool chain hand shake to say database is ready \n");
}
// Open the database
DatabaseReader* database = NULL;
if (!absolute_file_path){
printf("using packet based address \n");
database = new DatabaseReader(packet_file_path);
} else {
printf("using command based address \n");
database = new DatabaseReader(absolute_file_path);
}
// Get the details of the populations to be visualised
ColourReader *colour_reader = new ColourReader(colour_file_path);
std::vector<char *> *labels = colour_reader->get_labels();
// Read the database and store the results in a useful form
std::map<int, char*> *y_axis_labels = new std::map<int, char*>();
std::map<int, int> *key_to_neuronid_map = new std::map<int, int>();
std::map<int, colour> *neuron_id_to_colour_map =
new std::map<int, colour>();
std::set<int> *ports_to_listen_to = new std::set<int>();
int base_neuron_id = 0;
for (std::vector<char *>::iterator iter = labels->begin();
iter != labels->end(); iter++) {
char *label = *iter;
fprintf(stderr, "Reading %s\n", label);
// Get the port details
ip_tag_info *tag = database->get_live_output_details(label);
ports_to_listen_to->insert(tag->port);
free(tag);
// Get the key to neuron id for this population and the colour
std::map<int, int> *key_map =
database->get_key_to_neuron_id_mapping(label);
colour col = colour_reader->get_colour(label);
// Add the keys to the global maps, adding the current base neuron id
for (std::map<int, int>::iterator key_iter = key_map->begin();
key_iter != key_map->end(); key_iter++) {
int nid = key_iter->second + base_neuron_id;
(*key_to_neuronid_map)[key_iter->first] = nid;
(*neuron_id_to_colour_map)[nid] = col;
}
delete key_map;
// Put the label half-way up the population
int n_neurons = database->get_n_neurons(label);
(*y_axis_labels)[base_neuron_id + (n_neurons / 2)] = label;
// Add to the base neurons for the next population (plus a spacer)
base_neuron_id += n_neurons + 10;
}
// Get other parameters
float run_time = database->get_configuration_parameter_value(
(char *) "runtime");
float machine_time_step = database->get_configuration_parameter_value(
(char *) "machine_time_step") / 1000.0;
// Close the database
database->close_database_connection();
delete database;
// Create the visualiser
RasterPlot plotter(
argc, argv, remote_host, ports_to_listen_to, y_axis_labels,
key_to_neuronid_map, neuron_id_to_colour_map, run_time,
machine_time_step, base_neuron_id, database_message_connection);
return 0;
}
static void prv_create_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char * end = NULL;
int result;
int64_t value;
uint8_t * temp_buffer = NULL;
int temp_length = 0;
lwm2m_media_type_t format = LWM2M_CONTENT_TEXT;
//Get Client ID
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
//Get Uri
buffer = get_next_arg(buffer, &end);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
//Get Data to Post
buffer = get_next_arg(end, &end);
if (buffer[0] == 0) goto syntax_error;
if (!check_end_of_args(end)) goto syntax_error;
// TLV
/* Client dependent part */
if (uri.objectId == 1024)
{
lwm2m_data_t * dataP;
dataP = lwm2m_data_new(1);
if (dataP == NULL)
{
fprintf(stdout, "Allocation error !");
return;
}
lwm2m_data_encode_int(value, dataP);
dataP->id = 1;
format = LWM2M_CONTENT_TLV;
temp_length = lwm2m_data_serialize(NULL, 1, dataP, &format, &temp_buffer);
}
/* End Client dependent part*/
//Create
result = lwm2m_dm_create(lwm2mH, clientId, &uri, format, temp_buffer, temp_length, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
prv_print_error(result);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
int main(int argc, char **argv)
{
cfile out_cfh, ref_cfh, ver_cfh;
int out_fh;
int optr;
char *src_file = NULL;
char *trg_file = NULL;
char *patch_name = NULL;
unsigned long patch_id = 0;
signed long encode_result=0;
int err;
unsigned long sample_rate=0;
unsigned long seed_len = 0;
unsigned long hash_size = 0;
// unsigned int patch_compressor = 0;
unsigned int patch_to_stdout = 0;
#define DUMP_USAGE(exit_code) \
print_usage("differ", "src_file trg_file [patch_file|or to stdout]", help_opts, exit_code);
while((optr = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
switch(optr) {
case OVERSION:
print_version("differ"); exit(0);
case OUSAGE:
case OHELP:
DUMP_USAGE(0);
case OVERBOSE:
global_verbosity++; break;
case OSAMPLE:
sample_rate = atol(optarg);
if(sample_rate == 0 || sample_rate > MAX_SAMPLE_RATE) DUMP_USAGE(EXIT_USAGE);
break;
case OSEED:
seed_len = atol(optarg);
if(seed_len == 0 || seed_len > MAX_SEED_LEN) DUMP_USAGE(EXIT_USAGE);
break;
case OHASH:
hash_size = atol(optarg);
if(hash_size == 0 || hash_size > MAX_HASH_SIZE) DUMP_USAGE(EXIT_USAGE);
break;
case OSTDOUT:
patch_to_stdout = 1; break;
case 'f':
patch_format = optarg; break;
default:
v0printf("invalid arg- %s\n", argv[optind]);
DUMP_USAGE(EXIT_USAGE);
}
}
err = 0;
if( ((src_file = (char *)get_next_arg(argc,argv)) == NULL) ||
(err = copen(&ref_cfh, src_file, NO_COMPRESSOR, CFILE_RONLY)) != 0) {
if(src_file) {
if(err == MEM_ERROR) {
v0printf("alloc failure for src_file\n");
} else {
v0printf("Must specify an existing source file.\n");
}
exit(EXIT_USAGE);
}
DUMP_USAGE(EXIT_USAGE);
}
err = 0;
if( ((trg_file=(char *)get_next_arg(argc, argv)) == NULL) ||
(err = copen(&ver_cfh, trg_file, NO_COMPRESSOR, CFILE_RONLY)) != 0) {
if(trg_file) {
if(err == MEM_ERROR) {
v0printf("alloc failure for trg_file\n");
} else {
v0printf("Must specify an existing target file.\n");
}
exit(EXIT_USAGE);
}
DUMP_USAGE(EXIT_USAGE);
}
if(patch_to_stdout != 0) {
out_fh = 1;
} else {
if((patch_name = (char *)get_next_arg(argc, argv)) == NULL)
DUMP_USAGE(EXIT_USAGE);
if((out_fh = open(patch_name, O_WRONLY | O_TRUNC | O_CREAT, 0644))==-1) {
v0printf( "error creating patch file '%s' (open failed)\n", patch_name);
exit(1);
}
}
if (NULL!=get_next_arg(argc, argv)) {
DUMP_USAGE(EXIT_USAGE);
}
if(patch_format==NULL) {
patch_id = DEFAULT_PATCH_ID;
} else {
patch_id = check_for_format(patch_format, strlen(patch_format));
if(patch_id==0) {
v0printf( "Unknown format '%s'\n", patch_format);
exit(EXIT_FAILURE);
}
}
if(copen_dup_fd(&out_cfh, out_fh, 0, 0, NO_COMPRESSOR /* patch_compressor */, CFILE_WONLY)) {
v0printf("error allocing needed memory for output, exiting\n");
exit(EXIT_FAILURE);
}
v1printf("using patch format %lu\n", patch_id);
v1printf("using seed_len(%lu), sample_rate(%lu), hash_size(%lu)\n",
seed_len, sample_rate, hash_size);
v1printf("verbosity level(%u)\n", global_verbosity);
v1printf("initializing Command Buffer...\n");
encode_result = simple_difference(&ref_cfh, &ver_cfh, &out_cfh, patch_id, seed_len, sample_rate, hash_size);
v1printf("flushing and closing out file\n");
cclose(&out_cfh);
close(out_fh);
if(err) {
if(! patch_to_stdout) {
unlink(patch_name);
}
}
v1printf("encode_result=%ld\n", encode_result);
v1printf("exiting\n");
v1printf("closing reference file\n");
cclose(&ref_cfh);
v1printf("closing version file\n");
cclose(&ver_cfh);
close(out_fh);
check_return2(encode_result, "encoding result was nonzero")
return 0;
}
static void prv_attr_client(char * buffer,
void * user_data)
{
lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
uint16_t clientId;
lwm2m_uri_t uri;
char * end = NULL;
int result;
lwm2m_attributes_t attr;
int nb;
float value;
result = prv_read_id(buffer, &clientId);
if (result != 1) goto syntax_error;
buffer = get_next_arg(buffer, &end);
if (buffer[0] == 0) goto syntax_error;
result = lwm2m_stringToUri(buffer, end - buffer, &uri);
if (result == 0) goto syntax_error;
memset(&attr, 0, sizeof(lwm2m_attributes_t));
attr.toSet = LWM2M_ATTR_FLAG_LESS_THAN | LWM2M_ATTR_FLAG_GREATER_THAN;
buffer = get_next_arg(end, &end);
if (buffer[0] == 0) goto syntax_error;
nb = sscanf(buffer, "%f", &value);
if (nb != 1) goto syntax_error;
attr.lessThan = value;
buffer = get_next_arg(end, &end);
if (buffer[0] == 0) goto syntax_error;
nb = sscanf(buffer, "%f", &value);
if (nb != 1) goto syntax_error;
attr.greaterThan = value;
buffer = get_next_arg(end, &end);
if (buffer[0] != 0)
{
nb = sscanf(buffer, "%f", &value);
if (nb != 1) goto syntax_error;
attr.step = value;
attr.toSet |= LWM2M_ATTR_FLAG_STEP;
}
if (!check_end_of_args(end)) goto syntax_error;
result = lwm2m_dm_write_attributes(lwm2mH, clientId, &uri, &attr, prv_result_callback, NULL);
if (result == 0)
{
fprintf(stdout, "OK");
}
else
{
prv_print_error(result);
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
static void prv_bootstrap_client(char * buffer,
void * user_data)
{
internal_data_t * dataP = (internal_data_t *)user_data;
char * uri;
char * name;
char* end = NULL;
char * host;
char * port;
connection_t * newConnP = NULL;
uri = buffer;
end = get_end_of_arg(buffer);
if (end[0] != 0)
{
*end = 0;
buffer = end + 1;
name = get_next_arg(buffer, &end);
}
if (!check_end_of_args(end)) goto syntax_error;
// parse uri in the form "coaps://[host]:[port]"
if (0==strncmp(uri, "coaps://", strlen("coaps://"))) {
host = uri+strlen("coaps://");
}
else if (0==strncmp(uri, "coap://", strlen("coap://"))) {
host = uri+strlen("coap://");
}
else {
goto syntax_error;
}
port = strrchr(host, ':');
if (port == NULL) goto syntax_error;
// remove brackets
if (host[0] == '[')
{
host++;
if (*(port - 1) == ']')
{
*(port - 1) = 0;
}
else goto syntax_error;
}
// split strings
*port = 0;
port++;
fprintf(stderr, "Trying to connect to LWM2M CLient at %s:%s\r\n", host, port);
newConnP = connection_create(dataP->connList, dataP->sock, host, port);
if (newConnP == NULL) {
fprintf(stderr, "Connection creation failed.\r\n");
return;
}
dataP->connList = newConnP;
// simulate a client bootstrap request.
if (COAP_204_CHANGED == prv_bootstrap_callback(newConnP, COAP_NO_ERROR, NULL, name, user_data))
{
fprintf(stdout, "OK");
}
else
{
fprintf(stdout, "Error");
}
return;
syntax_error:
fprintf(stdout, "Syntax error !");
}
bool quest_poison_gen_hook(char *fmt)
{
int cy = 1, cx = 1, x, y, try = 10000, r_idx;
bool (*old_get_mon_num_hook)(int r_idx);
if (cquest.status != QUEST_STATUS_TAKEN) return FALSE;
if (p_ptr->wilderness_y != wild_locs[cquest.data[0]][0]) return FALSE;
if (p_ptr->wilderness_x != wild_locs[cquest.data[0]][1]) return FALSE;
if (p_ptr->wild_mode) return FALSE;
/* Find a good position */
while (try)
{
/* Get a random spot */
cy = randint(cur_hgt - 24) + 22;
cx = randint(cur_wid - 34) + 32;
/* Is it a good spot ? */
if (cave_empty_bold(cy, cx)) break;
/* One less try */
try--;
}
/* Place the baddies */
/* Backup the old hook */
old_get_mon_num_hook = get_mon_num_hook;
/* Require "okay" monsters */
get_mon_num_hook = create_molds_hook;
/* Prepare allocation table */
get_mon_num_prep();
/* Pick a monster, using the level calculation */
for (x = cx - 25; x <= cx + 25; x++)
for (y = cy - 25; y <= cy + 25; y++)
{
if (!in_bounds(y, x)) continue;
if (distance(cy, cx, y, x) > 25) continue;
if (magik(80) && ((cave[y][x].feat == FEAT_DEEP_WATER) || (cave[y][x].feat == FEAT_SHAL_WATER))) cave_set_feat(y, x, FEAT_TAINTED_WATER);
if (distance(cy, cx, y, x) > 10) continue;
if (magik(60))
{
int m_idx;
r_idx = get_mon_num(30);
m_idx = place_monster_one(y, x, r_idx, 0, FALSE, MSTATUS_ENEMY);
/* Sometimes make it up some levels */
if (magik(80) && m_idx)
{
monster_type *m_ptr = &m_list[m_idx];
if (m_ptr->level < p_ptr->lev)
{
m_ptr->exp = MONSTER_EXP(m_ptr->level + randint(p_ptr->lev - m_ptr->level));
monster_check_experience(m_idx, TRUE);
}
}
}
}
/* Reset restriction */
get_mon_num_hook = old_get_mon_num_hook;
/* Prepare allocation table */
get_mon_num_prep();
return FALSE;
}
bool quest_poison_finish_hook(char *fmt)
{
object_type forge, *q_ptr;
s32b q_idx;
q_idx = get_next_arg(fmt);
if (q_idx != QUEST_POISON) return FALSE;
c_put_str(TERM_YELLOW, "The water is clean again! Thank you so much.", 8, 0);
c_put_str(TERM_YELLOW, "The beautiful Mallorns are safe. Take this as a proof of our gratitude.", 9, 0);
q_ptr = &forge;
object_prep(q_ptr, lookup_kind(TV_DRAG_ARMOR, SV_DRAGON_BLUE));
q_ptr->found = OBJ_FOUND_REWARD;
q_ptr->number = 1;
q_ptr->name2 = EGO_ELVENKIND;
apply_magic(q_ptr, 1, FALSE, FALSE, FALSE);
object_aware(q_ptr);
object_known(q_ptr);
q_ptr->ident |= IDENT_STOREB;
(void)inven_carry(q_ptr, FALSE);
/* Continue the plot */
*(quest[q_idx].plot) = QUEST_NULL;
del_hook(HOOK_QUEST_FINISH, quest_poison_finish_hook);
process_hooks_restart = TRUE;
return TRUE;
}
/**
* Prepares the stack for a 64-bit guest and places the arguments in the correct
* register / stack locations.
*
* Arguments on 64-bit systems:
* 1st ARG: %RDI
* 2nd ARG: %RSI
* 3rd ARG: %RDX
* 4th ARG: %RCX
* 5th ARG: %R8
* 6th ARG: %R9
* 7th ARG - nth ARG: on stack from right to left
*
* @param inject The injection structure of the module that is injected.
* @param virt_stack A pointer to the virtual address of the memory area
* that was reserved for the stack of the module.
*/
void prepareStack64(struct kvm_vcpu *vcpu, struct injection *inject, u64 *virt_stack)
{
u64 phys_stack = 0;
struct x86_exception error;
struct injection_arg *arg = NULL;
unsigned int i = 0;
int ret = 0;
enum kvm_reg reg;
// Do we actually have arguments?
if (inject->args)
{
// Move all data to the stack that cannot be directly passed as an argument
// such as strings and structures.
for (i = 0; i < inject->args->argc; ++i)
{
arg = get_next_arg(inject, arg);
if (!is_immediate(arg))
{
// Copy the data to the stack
PRINT_DEBUG("Writing data of argument %d with type %d and size %d to 0x%llx\n",
i, arg->type, arg->size, *virt_stack - arg->size);
// Update address
(*virt_stack) -= arg->size;
arg->data_on_stack = (void *)(*virt_stack);
// Write
phys_stack = vcpu->arch.mmu.gva_to_gpa(vcpu, (*virt_stack), 0, &error);
ret = kvm_write_guest(vcpu->kvm, phys_stack, get_arg_data(inject, arg), arg->size);
if(ret < 0)
{
PRINT_ERROR("An error (code: %d) occurred while writing the argument %d to memory!\n",
ret, i);
return;
}
}
}
// Place arguments into the correct register / stack locations
arg = NULL;
for (i = inject->args->argc; i > 0 ; --i)
{
arg = get_prev_arg(inject, arg);
if (i >= 7)
{
// Arg goes on the stack
// ToDo: We just fix this to 8 byte here, but the size of the arg
// may actually be shorter
(*virt_stack) -= 8;
phys_stack = vcpu->arch.mmu.gva_to_gpa(vcpu, (*virt_stack), 0, &error);
if (is_immediate(arg))
{
PRINT_DEBUG("Writing argument %d with type %d and size %d to the stack 0x%llx\n",
i, arg->type, arg->size, *virt_stack);
ret = kvm_write_guest(vcpu->kvm, phys_stack, get_arg_data(inject, arg), arg->size);
}
else
{
PRINT_DEBUG("Writing pointer 0x%lx to argument %d with type %d and size %d to the stack 0x%llx\n",
(unsigned long)arg->data_on_stack, i, arg->type, arg->size, *virt_stack);
ret = kvm_write_guest(vcpu->kvm, phys_stack, &arg->data_on_stack, 8);
}
if(ret < 0)
{
PRINT_ERROR("An error (code: %d) occurred while writing the argument %d "
"to the stack!\n",
ret, i);
return;
}
}
else
{
// Arg goes into a register
switch (i)
{
case 1:
reg = VCPU_REGS_RDI;
break;
case 2:
reg = VCPU_REGS_RSI;
break;
case 3:
reg = VCPU_REGS_RDX;
break;
case 4:
reg = VCPU_REGS_RCX;
break;
case 5:
reg = VCPU_REGS_R8;
break;
case 6:
reg = VCPU_REGS_R9;
break;
default:
PRINT_ERROR("Argument is not between one and six!\n");
}
if (is_immediate(arg))
{
PRINT_DEBUG("Writing argument %d with value 0x%lx, type %d, and size %d to register %d\n",
i, (unsigned long)arg->data, arg->type, arg->size, reg);
kvm_register_write(vcpu, reg, *((unsigned long *)get_arg_data(inject, arg)));
}
else
{
PRINT_DEBUG("Writing pointer 0x%lx to argument %d with type %d and size %d to register %d\n",
(unsigned long)arg->data_on_stack, i, arg->type, arg->size, reg);
kvm_register_write(vcpu, reg, (unsigned long)arg->data_on_stack);
}
}
}
}
// Add Offset to stack so the shellcode can operate
(*virt_stack) -= STACK_AREA_SC ;
// Place the original kernel pointer on the stack
(*virt_stack) -= 8;
// Write address of the original kernel stack on the new stack
phys_stack = vcpu->arch.mmu.gva_to_gpa(vcpu, (*virt_stack), 0, &error);
ret = kvm_write_guest(vcpu->kvm, phys_stack, &_XTIER_inject.regs.rsp, 8);
kvm_register_write(vcpu, VCPU_REGS_RSP, (*virt_stack));
}
/* init_global_config_store()
Initialize the global configuration store by parsing command line arguments.
This function must only be called from the main thread.
For now there is only one configuration store implemented and it's a global store (G->config).
'G->config' depends on the global program (G->prog) store.
*/
void init_global_config_store( void )
{
int i = 0;
unsigned arf = 0;
char *debugstr = NULL;
FAIL_IF( !G ); // The global store must exist.
FAIL_IF( G->config->init_time ); // Fail if this store has already been initialized.
FAIL_IF( !G->prog->init_time ); // The program store must be initialized.
FAIL_IF( GetCurrentThreadId() != G->prog->dwMainThreadId ); // main thread only
debugstr = getenv( "GETHOOKS_DEBUG" );
if( debugstr && ( debugstr[ 0 ] == '1' ) && !debugstr[ 1 ] )
G->config->flags |= CFG_DEBUG;
G->config->polling = POLLING_DEFAULT;
G->config->verbose = VERBOSE_DEFAULT;
G->config->max_threads = MAX_THREADS_DEFAULT;
/* parse command line arguments */
i = 0;
while( arf != END )
{
if( arf != OPT ) /* attempt to get an option from the command line arguments */
arf = get_next_arg( &i, OPT );
if( arf != OPT )
continue;
/* option found */
switch( G->prog->argv[ i ][ 1 ] )
{
case '?':
case 'h':
case 'H':
{
/* show help */
print_usage_and_exit();
}
/**
desktop include option
*/
case 'd':
case 'D':
{
G->config->desklist->type = LIST_INCLUDE_DESK;
/* since this option may or may not have an associated argument,
test for both an option's argument(optarg) or the next option
*/
arf = get_next_arg( &i, OPT | OPTARG );
if( arf != OPTARG )
continue;
while( arf == OPTARG ) /* option argument found */
{
WCHAR *name = NULL;
/* make the desktop name as a wide character string */
if( !get_wstr_from_mbstr( &name, G->prog->argv[ i ] ) )
{
MSG_FATAL( "get_wstr_from_mbstr() failed." );
printf( "desktop: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
/* append to the linked list */
if( !add_list_item( G->config->desklist, 0, name ) )
{
MSG_FATAL( "add_list_item() failed." );
printf( "desktop: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
/* if add_list_item() was successful then it made a duplicate of the
wide string pointed to by name. in any case name should now be freed.
*/
free( name );
name = NULL;
/* get the option's next argument, which is optional */
arf = get_next_arg( &i, OPT | OPTARG );
}
continue;
}
/**
monitor option
*/
case 'm':
case 'M':
{
if( G->config->polling != POLLING_DEFAULT )
{
MSG_FATAL( "Option 'm': this option has already been specified." );
printf( "sec: %d\n", G->config->polling );
exit( 1 );
}
G->config->polling = POLLING_ENABLED_DEFAULT;
/* since this option may or may not have an associated argument,
test for both an option's argument(optarg) or the next option
*/
arf = get_next_arg( &i, OPT | OPTARG );
if( arf != OPTARG )
continue;
/* option argument found */
if( !str_to_int( &G->config->polling, G->prog->argv[ i ] ) )
{
MSG_FATAL( "Option 'm': the string is not an integer representation." );
printf( "sec: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
if( G->config->polling == 0 )
{
MSG_WARNING( "Option 'm': an interval of 0 uses too much CPU time." );
printf( "sec: %s\n", G->prog->argv[ i ] );
}
if( G->config->polling > 86400 ) // number of seconds in a day
{
MSG_WARNING( "Option 'm': more seconds than in a day (86400)." );
printf( "sec: %s\n", G->prog->argv[ i ] );
}
if( G->config->polling < POLLING_MIN )
{
MSG_FATAL( "Option 'm': less seconds than the minimum allowed." );
printf( "sec: %s\n", G->prog->argv[ i ] );
printf( "POLLING_MIN: %d\n", POLLING_MIN );
exit( 1 );
}
else if( G->config->polling > POLLING_MAX )
{
MSG_FATAL( "Option 'm': more seconds than the maximum allowed." );
printf( "sec: %s\n", G->prog->argv[ i ] );
printf( "POLLING_MAX: %d\n", POLLING_MAX );
exit( 1 );
}
continue;
}
/**
hook include/exclude options
i: include list for hooks
x: exclude list for hooks
*/
case 'i':
case 'I':
{
if( G->config->hooklist->type == LIST_EXCLUDE_HOOK )
{
MSG_FATAL( "Options 'i' and 'x' are mutually exclusive." );
exit( 1 );
}
G->config->hooklist->type = LIST_INCLUDE_HOOK;
}
/* pass through to the exclude code.
the exclude code can handle either type of list, include or exclude.
*/
case 'x':
case 'X':
{
if( G->config->hooklist->type != LIST_INCLUDE_HOOK )
{
G->config->hooklist->type = LIST_EXCLUDE_HOOK;
}
else if( ( G->prog->argv[ i ][ 1 ] == 'x' ) || ( G->prog->argv[ i ][ 1 ] == 'X' ) )
{
MSG_FATAL( "Options 'i' and 'x' are mutually exclusive." );
exit( 1 );
}
/* the 'i' or 'x' option requires at least one associated argument (optarg).
if an optarg is not found get_next_arg() will exit(1)
*/
arf = get_next_arg( &i, OPTARG );
while( arf == OPTARG ) /* option argument found */
{
__int64 id = 0;
WCHAR *name = NULL;
/* if the string is not an integer then it's a hook name not an id */
if( !str_to_int64( &id, G->prog->argv[ i ] ) )
{
id = 0;
/* make the hook name as a wide character string */
if( !get_wstr_from_mbstr( &name, G->prog->argv[ i ] ) )
{
MSG_FATAL( "get_wstr_from_mbstr() failed." );
printf( "hook: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
_wcsupr( name ); /* convert hook name to uppercase */
}
/* append to the linked list */
if( !add_list_item( G->config->hooklist, id, name ) )
{
MSG_FATAL( "add_list_item() failed." );
printf( "hook: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
/* if add_list_item() was successful then it made a duplicate of the
wide string pointed to by name. in any case name should now be freed.
*/
free( name );
name = NULL;
/* get the option's next argument, which is optional */
arf = get_next_arg( &i, OPT | OPTARG );
}
continue;
}
/**
program include/exclude options
p: include list for programs
r: exclude list for programs
*/
case 'p':
case 'P':
{
if( G->config->proglist->type == LIST_EXCLUDE_PROG )
{
MSG_FATAL( "Options 'p' and 'r' are mutually exclusive." );
exit( 1 );
}
G->config->proglist->type = LIST_INCLUDE_PROG;
}
/* pass through to the exclude code.
the exclude code can handle either type of list, include or exclude.
*/
case 'r':
case 'R':
{
if( G->config->proglist->type != LIST_INCLUDE_PROG )
{
G->config->proglist->type = LIST_EXCLUDE_PROG;
}
else if( ( G->prog->argv[ i ][ 1 ] == 'r' ) || ( G->prog->argv[ i ][ 1 ] == 'R' ) )
{
MSG_FATAL( "Options 'p' and 'r' are mutually exclusive." );
exit( 1 );
}
/* the 'p' or 'r' option requires at least one associated argument (optarg).
if an optarg is not found get_next_arg() will exit(1)
*/
arf = get_next_arg( &i, OPTARG );
while( arf == OPTARG ) /* option argument found */
{
__int64 id = 0;
WCHAR *name = NULL;
const char *p = G->prog->argv[ i ];
/* a colon is used as the escape character.
if the first character is a colon then a program name
is specified, not a PID/TID. this is only necessary
in cases where a program name can be mistaken by
the parser for an option or a PID/TID.
*/
if( *p == ':' )
++p;
/* if the first character is a colon, or the string is not an integer,
or it is and the integer is negative, then assume program name
*/
if( ( p != G->prog->argv[ i ] )
|| ( str_to_int64( &id, G->prog->argv[ i ] ) != NUM_POS )
)
{
/* make the program name as a wide character string */
if( !get_wstr_from_mbstr( &name, p ) )
{
MSG_FATAL( "get_wstr_from_mbstr() failed." );
printf( "prog: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
//_wcslwr( name ); /* convert program name to lowercase */
/* program name and id are mutually exclusive.
elsewhere in the code if a list item's name != NULL
then its id is ignored.
*/
}
/* else the id is valid and name remains NULL*/
/* append to the linked list */
if( !add_list_item( G->config->proglist, id, name ) )
{
MSG_FATAL( "add_list_item() failed." );
printf( "prog: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
/* if add_list_item() was successful then it made a duplicate of the
wide string pointed to by name. in any case name should now be freed.
*/
free( name );
name = NULL;
/* get the option's next argument, which is optional */
arf = get_next_arg( &i, OPT | OPTARG );
}
continue;
}
/**
verbosity option
*/
case 'v':
case 'V':
{
if( G->config->verbose != VERBOSE_DEFAULT )
{
MSG_FATAL( "Option 'v': this option has already been specified." );
printf( "verbosity level: %d\n", G->config->verbose );
exit( 1 );
}
G->config->verbose = VERBOSE_ENABLED_DEFAULT;
/* since this option may or may not have an associated argument,
test for both an option's argument(optarg) or the next option
*/
arf = get_next_arg( &i, OPT | OPTARG );
if( arf != OPTARG )
continue;
/* option argument found */
if( !str_to_int( &G->config->verbose, G->prog->argv[ i ] ) )
{
MSG_FATAL( "Option 'v': the string is not an integer representation." );
printf( "num: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
if( G->config->verbose < VERBOSE_MIN )
{
MSG_FATAL( "Option 'v': less verbosity than the minimum allowed." );
printf( "num: %s\n", G->prog->argv[ i ] );
printf( "VERBOSE_MIN: %d\n", VERBOSE_MIN );
exit( 1 );
}
else if( G->config->verbose > VERBOSE_MAX )
{
MSG_FATAL( "Option 'v': more verbosity than the maximum allowed." );
printf( "num: %s\n", G->prog->argv[ i ] );
printf( "VERBOSE_MAX: %d\n", VERBOSE_MAX );
exit( 1 );
}
continue;
}
/**
threads option (advanced)
*/
case 't':
case 'T':
{
if( G->config->max_threads != MAX_THREADS_DEFAULT )
{
MSG_FATAL( "Option 't': this option has already been specified." );
printf( "max threads: %u\n", G->config->max_threads );
exit( 1 );
}
/* this option must have an associated argument (optarg).
if an optarg is not found get_next_arg() will exit(1)
*/
arf = get_next_arg( &i, OPTARG );
/* option argument found */
/* if the string is not a positive integer representation > 0 */
if( ( str_to_uint( &G->config->max_threads, G->prog->argv[ i ] ) != NUM_POS )
|| ( G->config->max_threads <= 0 )
)
{
MSG_FATAL( "Option 't': maximum number of threads invalid." );
printf( "num: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
continue;
}
/**
test mode include option (advanced)
*/
case 'z':
case 'Z':
{
unsigned __int64 id = 0;
WCHAR *name = NULL;
G->config->testlist->type = LIST_INCLUDE_TEST;
/* the 'z' option requires one associated argument (optarg), and a second which is
optional.
*/
arf = get_next_arg( &i, OPT | OPTARG );
if( arf != OPTARG )
{
print_testmode_usage();
exit( 1 );
}
/* make the test name as a wide character string */
if( !get_wstr_from_mbstr( &name, G->prog->argv[ i ] ) )
{
MSG_FATAL( "get_wstr_from_mbstr() failed." );
printf( "name: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
arf = get_next_arg( &i, OPT | OPTARG ); // get the second optarg, which is optional
/* at least one option argument (optarg) was found */
/* if a second optarg was found it's the id. the value of id will be UI64_MAX if
the conversion fails or there's no second optarg.
*/
if( arf == OPTARG )
str_to_uint64( &id, G->prog->argv[ i ] );
else
id = UI64_MAX;
/* append to the linked list */
if( !add_list_item( G->config->testlist, (__int64)id, name ) )
{
MSG_FATAL( "add_list_item() failed." );
printf( "test id: 0x%I64X\n", id );
printf( "test name: %ls\n", name );
exit( 1 );
}
/* if add_list_item() was successful then it made a duplicate of the
wide string pointed to by name. in any case name should now be freed.
*/
free( name );
name = NULL;
continue;
}
/**
option to ignore internal hooks (advanced)
*/
case 'e':
case 'E':
{
G->config->flags |= CFG_IGNORE_INTERNAL_HOOKS;
arf = get_next_arg( &i, OPT );
continue;
}
/**
option to ignore known hooks (advanced)
*/
case 'u':
case 'U':
{
G->config->flags |= CFG_IGNORE_KNOWN_HOOKS;
arf = get_next_arg( &i, OPT );
continue;
}
/**
option to ignore targeted hooks (advanced)
*/
case 'g':
case 'G':
{
G->config->flags |= CFG_IGNORE_TARGETED_HOOKS;
arf = get_next_arg( &i, OPT );
continue;
}
/**
option to ignore failed NtQuerySystemInformation() calls (advanced)
*/
case 'f':
case 'F':
{
G->config->flags |= CFG_IGNORE_FAILED_QUERIES;
arf = get_next_arg( &i, OPT );
continue;
}
/**
option to ignore hook lock count changes (advanced)
*/
case 'c':
case 'C':
{
G->config->flags |= CFG_IGNORE_LOCK_COUNTS;
arf = get_next_arg( &i, OPT );
continue;
}
/**
option to go completely passive (advanced)
*/
case 'y':
case 'Y':
{
G->config->flags |= CFG_COMPLETELY_PASSIVE;
arf = get_next_arg( &i, OPT );
continue;
}
default:
{
MSG_FATAL( "Unknown option." );
printf( "OPT: %s\n", G->prog->argv[ i ] );
exit( 1 );
}
}
}
if( ( G->config->proglist->type == LIST_INCLUDE_PROG )
|| ( G->config->proglist->type == LIST_EXCLUDE_PROG )
)
GetSystemTimeAsFileTime( (FILETIME *)&G->config->proglist->init_time );
if( ( G->config->hooklist->type == LIST_INCLUDE_HOOK )
|| ( G->config->hooklist->type == LIST_EXCLUDE_HOOK )
)
GetSystemTimeAsFileTime( (FILETIME *)&G->config->hooklist->init_time );
if( ( G->config->desklist->type == LIST_INCLUDE_DESK ) )
GetSystemTimeAsFileTime( (FILETIME *)&G->config->desklist->init_time );
if( ( G->config->testlist->type == LIST_INCLUDE_TEST ) )
GetSystemTimeAsFileTime( (FILETIME *)&G->config->testlist->init_time );
/* G->config has been initialized */
GetSystemTimeAsFileTime( (FILETIME *)&G->config->init_time );
return;
}
