void goto_dialog::address_entered()
{
bool status;
QString input = offset_input->text().remove(QRegExp("[^0-9A-Fa-f]"));
int address = input.toInt(&status, 16);
if(input.isEmpty()){
return;
}
if(relative->isChecked()){
address = active_editor->get_buffer()->pc_to_snes(active_editor->get_relative_position(address));
}
if(validate_address(address)){
emit triggered(address);
}
}
/* Increase refcount */
seg_t mm_realloc(seg_t base)
{
register struct malloc_hole *m;
#ifdef CONFIG_SWAP
base = validate_address(base);
#endif
m = find_hole(&memmap, base);
m->refcount++;
return m->page_base;
}
static gboolean
validate_configuration (GVariant *configuration,
GError **error)
{
GVariantDict *dict = NULL;
GVariant *value = NULL;
dict = g_variant_dict_new (configuration);
if (g_variant_dict_contains (dict, "address"))
{
value = g_variant_dict_lookup_value (dict, "address",
G_VARIANT_TYPE_STRING);
if (value == NULL)
{
g_variant_dict_unref (dict);
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'address' entry must be a string"));
return FALSE;
}
if (!validate_address ("address", g_variant_get_string (value, NULL),
TRUE, error))
{
g_variant_dict_unref (dict);
return FALSE;
}
}
else
{
g_variant_dict_unref (dict);
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'address' entry is required"));
return FALSE;
}
if (g_variant_dict_contains (dict, "router"))
{
value = g_variant_dict_lookup_value (dict, "router",
G_VARIANT_TYPE_STRING);
if (value == NULL)
{
g_variant_dict_unref (dict);
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'router' entry must be a string"));
return FALSE;
}
if (!validate_address ("router", g_variant_get_string (value, NULL),
FALSE, error))
{
g_variant_dict_unref (dict);
return FALSE;
}
}
if (g_variant_dict_contains (dict, "nameservers"))
{
value = g_variant_dict_lookup_value (dict, "nameservers",
G_VARIANT_TYPE_STRING_ARRAY);
if (value == NULL)
{
g_variant_dict_unref (dict);
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'nameservers' entry must be a string array"));
return FALSE;
}
gsize len;
gs_strfreev gchar **nameservers = g_variant_dup_strv (value, &len);
for (gsize i = 0; i < len; i++)
{
if (!validate_address ("nameservers", nameservers[i],
FALSE, error))
{
g_variant_dict_unref (dict);
return FALSE;
}
}
}
if (g_variant_dict_contains (dict, "domain"))
{
value = g_variant_dict_lookup_value (dict, "domain",
G_VARIANT_TYPE_STRING);
if (value == NULL)
{
g_variant_dict_unref (dict);
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'domain' entry must be a string"));
return FALSE;
}
if (!validate_domainname ("domain", g_variant_get_string (value, NULL),
error))
{
g_variant_dict_unref (dict);
return FALSE;
}
}
if (g_variant_dict_contains (dict, "searches"))
{
value = g_variant_dict_lookup_value (dict, "searches",
G_VARIANT_TYPE_STRING_ARRAY);
if (value == NULL)
{
g_variant_dict_unref (dict);
*error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'searches' entry must be a string array"));
return FALSE;
}
gsize len;
gs_strfreev gchar **searches = g_variant_dup_strv (value, &len);
for (gsize i = 0; i < len; i++)
{
if (!validate_domainname ("searches", searches[i], error))
{
g_variant_dict_unref (dict);
return FALSE;
}
}
}
g_variant_dict_unref (dict);
return TRUE;
}
void sg_xmlcfg::load_netents(const bpt::iptree& pt)
{
gpenv& env_mgr = gpenv::instance();
try {
BOOST_FOREACH(const bpt::iptree::value_type& v, pt.get_child("servicegalaxy.networks")) {
if (v.first != "network")
continue;
const bpt::iptree& v_pt = v.second;
sg_netent_t item;
memset(&item, '\0', sizeof(sg_netent_t));
string hostid = v_pt.get<string>("hostid");
if (hostid.length() > MAX_IDENT)
throw sg_exception(__FILE__, __LINE__, SGEINVAL, 0, (_("ERROR: networks.network.hostid is too long.")).str(SGLOCALE));
strcpy(item.lmid, hostid.c_str());
string gwsaddr;
env_mgr.expand_var(gwsaddr, get_value(v_pt, "gwsaddr", string("")));
if (gwsaddr.length() > MAX_STRING)
throw sg_exception(__FILE__, __LINE__, SGEINVAL, 0, (_("ERROR: networks.network.gwsaddr is too long.")).str(SGLOCALE));
validate_address("networks.network.gwsaddr", gwsaddr);
strcpy(item.naddr, gwsaddr.c_str());
string agtaddr;
env_mgr.expand_var(agtaddr, get_value(v_pt, "agtaddr", string("")));
if (agtaddr.length() > MAX_STRING)
throw sg_exception(__FILE__, __LINE__, SGEINVAL, 0, (_("ERROR: networks.network.agtaddr is too long.")).str(SGLOCALE));
validate_address("networks.network.agtaddr", agtaddr);
strcpy(item.nlsaddr, agtaddr.c_str());
string netname = get_value(v_pt, "netname", string(""));
if (netname.empty())
netname = NM_DEFAULTNET;
if (netname.length() > MAX_IDENT)
throw sg_exception(__FILE__, __LINE__, SGEINVAL, 0, (_("ERROR: networks.network.netname is too long.")).str(SGLOCALE));
strcpy(item.netgroup, netname.c_str());
string tcpkeepalive = get_value(v_pt, "tcpkeepalive", string("Y"));
if (strcasecmp(tcpkeepalive.c_str(), "Y") == 0)
item.tcpkeepalive = true;
else if (strcasecmp(tcpkeepalive.c_str(), "N") == 0)
item.tcpkeepalive = false;
else
throw sg_exception(__FILE__, __LINE__, SGEINVAL, 0, (_("ERROR: networks.network.tcpkeepalive value invalid.")).str(SGLOCALE));
string nodelay = get_value(v_pt, "nodelay", string("N"));
if (strcasecmp(nodelay.c_str(), "Y") == 0)
item.nodelay = true;
else if (strcasecmp(nodelay.c_str(), "N") == 0)
item.nodelay = false;
else
throw sg_exception(__FILE__, __LINE__, SGEINVAL, 0, (_("ERROR: networks.network.nodelay value invalid.")).str(SGLOCALE));
BOOST_FOREACH(const sg_netent_t& netent, netents) {
if (hostid == netent.lmid && netname == netent.netgroup)
throw sg_exception(__FILE__, __LINE__, SGEINVAL, 0, (_("ERROR: networks.network.netgroup must be unique on same node.")).str(SGLOCALE));
}
netents.push_back(item);
}
} catch (bpt::ptree_bad_data& ex) {
throw sg_exception(__FILE__, __LINE__, SGESYSTEM, 0, (_("ERROR: Parse section networks failure, {1} ({2})") % ex.what() % ex.data<string>()).str(SGLOCALE));
} catch (bpt::ptree_error& ex) {
throw sg_exception(__FILE__, __LINE__, SGESYSTEM, 0, (_("ERROR: Parse section networks failure, {1}") % ex.what()).str(SGLOCALE));
}
}
int main(int argc, char *argv[]) {
int read_pipe[2];
int write_pipe[2];
if (argc != 3) {
printf("error: missing argument(s)\n");
exit(1);
}
char *filename = argv[1];
// make pipe to communicate
if (pipe(read_pipe) < 0 || pipe(write_pipe) < 0) {
printf("Pipe failed!\n");
exit(1);
}
int pid = fork();
if (pid == -1) {
/* Here pid is -1, the fork failed */
/* Some possible reasons are that you're */
/* out of process slots or virtual memory */
perror("The fork failed!\n");
exit(2);
}
if (pid == 0) {
/********** Memory **********/
// close parent's pipes
close(read_pipe[0]);
close(write_pipe[1]);
// initialize memory from file
int memory[MEMORY_SIZE];
int initialize_error = initialize(memory, filename);
write(MEMORY_WRITE, &initialize_error, sizeof(int));
if (initialize_error == 1) _exit(0);
// read from parent
while (1) {
int address = -1;
int command = -2;
if (read(MEMORY_READ, &command, sizeof(int)) >= 0) {
if (command == CRASH_COMMAND) {
// crash signal from the parent process
_exit(1);
} else if (command == READ_COMMAND) {
// returns the value at address
read(MEMORY_READ, &address, sizeof(int));
write(MEMORY_WRITE, &memory[address], sizeof(int));
} else if (command == WRITE_COMMAND) {
// writes a value to address
int data = -1;
read(MEMORY_READ, &address, sizeof(int));
read(MEMORY_READ, &data, sizeof(int));
memory[address] = data;
}
}
} // END while
_exit(0);
}
/********** CPU **********/
// close child's pipes
close(write_pipe[0]);
close(read_pipe[1]);
// check whether child process fails to initialize
int initialize_error = -1;
while (initialize_error == -1) {
read(CPU_READ, &initialize_error, sizeof(int));
if (initialize_error == 1) {
printf("error: input file does not exist!\n");
waitpid(-1, NULL, 0);
exit(1);
}
}
int TIMEOUT = -1;
int timer = 0;
int is_timer_interrupt = false;
int interrupted = false;
// initialize CPU's variables
int program_counter = 0;
int stack_pointer = SYSTEM_CODE_START;
int instruction_register = 0;
int accumulator = 0;
int x = 0;
int y = 0;
int mode = USER_MODE;
sscanf(argv[2], "%d", &TIMEOUT);
if (TIMEOUT < 5) {
printf("timeout too short!\n");
goto ERROR_EXIT;
}
int address = -1;
int flag = -2;
while (1) {
/* Fetch new instruction */
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
if (!interrupted) timer ++;
// read the returned data/instruction from memory
// then execute
if (read(CPU_READ, &instruction_register, sizeof(int)) >= 0) {
switch (instruction_register) {
case 1:
/* Loads the value into AC */
// fetch the value from the memory
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
// reads the value to the AC
read(CPU_READ, &accumulator, sizeof(int));
if (!interrupted) timer++;
break;
case 2:
/* Loads the value in address into AC */
address = -1;
// fetch the address from memory
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
// check validity of the address
flag = validate_address(mode, address);
if (flag != 0) {
if (flag == 1) {
// address does not exist!
printf("error: address does not exist!\n");
} else if (flag == 2) {
// invalid write operation!
printf("error: permission denied! Cannot access system code in user mode\n");
}
goto ERROR_EXIT;
}
// read the value at address to the AC
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
read(CPU_READ, &accumulator, sizeof(int));
if (!interrupted) timer++;
break;
case 3:
/* Loads the value from the address found in the address into the AC */
address = -1;
// fetch the address from the memory
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
// check validity of the address
flag = validate_address(mode, address);
if (flag != 0) {
if (flag == 1) {
// address does not exist!
printf("error: address does not exist!\n");
} else if (flag == 2) {
// invalid write operation!
printf("error: permission denied! Cannot access system code in user mode\n");
}
goto ERROR_EXIT;
}
// read the address at address
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
// check validity of the address
flag = validate_address(mode, address);
if (flag != 0) {
if (flag == 1) {
// address does not exist!
printf("error: address does not exist!\n");
} else if (flag == 2) {
// invalid write operation!
printf("error: permission denied! Cannot access system code in user mode\n");
}
goto ERROR_EXIT;
}
// read the value at adress to the AC
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
read(CPU_READ, &accumulator, sizeof(int));
if (!interrupted) timer++;
break;
case 4: case 5:
/* Loads the value at address (address + X) or (address + Y) into the AC */
address = -1;
// read the address
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
// read the value at (address + X) or (address + Y) into the AC
if (instruction_register == 4) {
address += x;
} else if (instruction_register == 5) {
address += y;
}
// check validity of the address
flag = validate_address(mode, address);
if (flag != 0) {
if (flag == 1) {
// address does not exist!
printf("error: address does not exist!\n");
} else if (flag == 2) {
// invalid write operation!
printf("error: permission denied! Cannot access system code in user mode\n");
}
goto ERROR_EXIT;
}
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
read(CPU_READ, &accumulator, sizeof(int));
if (!interrupted) timer++;
break;
case 6:
/* Loads from (stack_pointer + X) into the AC */
address = stack_pointer + x;
// check validity of the address
flag = validate_address(mode, address);
if (flag != 0) {
if (flag == 1) {
// address does not exist!
printf("error: address does not exist!\n");
} else if (flag == 2) {
// invalid write operation!
printf("error: permission denied! Cannot access system code in user mode\n");
}
goto ERROR_EXIT;
}
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
read(CPU_READ, &accumulator, sizeof(int));
if (!interrupted) timer++;
break;
case 7:
/* Stores the value in AC to the address */
address = -1;
// fetch the address from memory
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
// check validity of the address
flag = validate_address(mode, address);
if (flag != 0) {
if (flag == 1) {
// address does not exist!
printf("error: address does not exist!\n");
} else if (flag == 2) {
// invalid write operation!
printf("error: permission denied! Cannot access system code in user mode\n");
}
goto ERROR_EXIT;
}
// writes the AC to the address
write(CPU_WRITE, &WRITE_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
write(CPU_WRITE, &accumulator, sizeof(int));
break;
case 8:
// gets a random integer from 1 to 100 into the AC
srand(time(NULL));
accumulator = rand() % 99 + 1;
break;
case 9: ;
/* Writes AC as an int or char into the screen */
// fetch port number from the memory
int port = -1;
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &port, sizeof(int));
if (!interrupted) timer++;
if (port == 1) {
// writes as an integer
printf("%d", accumulator);
} else if (port == 2) {
// writes as a character
write(1, &accumulator, sizeof(int));
} else {
printf("error: print to invalid port!\n");
goto ERROR_EXIT;
}
break;
case 10:
// add the value from X to AC
accumulator += x;
break;
case 11:
// add the value from Y to AC
accumulator += y;
break;
case 12:
// subtract the value from X from AC
accumulator -= x;
break;
case 13:
// subtract the value from Y from AC
accumulator -= y;
break;
case 14:
// copy the value from AC to X
x = accumulator;
break;
case 15:
// copy the value from X to AC
accumulator = x;
break;
case 16:
// copy the value from AC to Y
y = accumulator;
break;
case 17:
// copy the value from Y to AC
accumulator = y;
break;
case 18:
// copy the value from AC to SP
stack_pointer = accumulator;
break;
case 19:
// copy the value from SP to AC
accumulator = stack_pointer;
break;
case 20:
/* Jumps to the address */
// fetch the address
address = -1;
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
// jump
JUMP:
// check validity of the address
flag = validate_address(mode, address);
if (flag != 0) {
if (flag == 1) {
// address does not exist!
printf("error: address does not exist!\n");
} else if (flag == 2) {
// invalid write operation!
printf("error: permission denied! Cannot access system code in user mode\n");
}
goto ERROR_EXIT;
}
program_counter = address; // jump
break;
case 21: case 22:
/* case 21: Jumps to the address only if the value in the AC is zero
case 22: Jumps if the value in the AC is not zero */
// fetch the address from memory
address = -1;
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
if (instruction_register == 21) {
if (accumulator == 0) {
goto JUMP;
}
} else if (instruction_register == 22) {
if (accumulator != 0) {
goto JUMP;
}
}
break;
case 23:
/* Push return address (i.e. program counter) onto stack, jump to the address */
// read address
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter++;
read(CPU_READ, &address, sizeof(int));
if (!interrupted) timer++;
// push return address to user's stack
stack_pointer --;
write(CPU_WRITE, &WRITE_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
goto JUMP;
break;
case 24:
/* Pop return address from the stack, jump to the address */
if (stack_pointer == SYSTEM_CODE_START || stack_pointer == MEMORY_SIZE) {
// nothing to pop
printf("error: invalid stack-popping operation!\n");
goto ERROR_EXIT;
}
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
read(CPU_READ, &address, sizeof(int));
stack_pointer++;
if (!interrupted) timer++;
goto JUMP;
break;
case 25:
// Increment the value in X
x ++;
break;
case 26:
// Increment the value in Y
x --;
break;
case 27:
// Push AC onto stack
stack_pointer --;
write(CPU_WRITE, &WRITE_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
write(CPU_WRITE, &accumulator, sizeof(int));
break;
case 28:
// Pop from stack into AC
if (stack_pointer == SYSTEM_CODE_START || stack_pointer == MEMORY_SIZE) {
// nothing to pop
printf("error: invalid stack-popping operation!\n");
goto ERROR_EXIT;
}
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
read(CPU_READ, &accumulator, sizeof(int));
stack_pointer ++;
if (!interrupted) timer++;
break;
case 29:
/* System call: interrupt */
// Set system mode, switch stack, push stack pointer and program counter
// Set new stack pointer and program counter
if (!interrupted) {
interrupted = true;
mode = SYSTEM_MODE;
// push stack pointer to system stack
address = MEMORY_SIZE - 1;
write(CPU_WRITE, &WRITE_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
stack_pointer = MEMORY_SIZE - 1; // switch stack
// push program counter
stack_pointer --;
write(CPU_WRITE, &WRITE_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter = INT_INTERRUPT_START;
}
break;
case 30:
/* Restores registers, set user mode */
if (mode == USER_MODE) {
// invalid instruction
printf("error: call instruction 30 in user mode!\n");
goto ERROR_EXIT;
}
/* SYSTEM MODE */
// pop program counter
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
read(CPU_READ, &program_counter, sizeof(int));
stack_pointer ++;
// pop user's stack pointer
write(CPU_WRITE, &READ_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
read(CPU_READ, &stack_pointer, sizeof(int));
// get out of the interrupt handler
interrupted = false;
is_timer_interrupt = false;
mode = USER_MODE;
break;
case 50:
// end of program
goto NORMAL_EXIT;
default:
/* Invalid instruction */
printf("error: invalid instruction at %d\n", (--program_counter));
goto ERROR_EXIT;
}
}
if (timer >= TIMEOUT) {
// cause interrupt
timer = 0;
interrupted = true;
is_timer_interrupt = true;
mode = SYSTEM_MODE;
// push stack pointer to system stack
address = MEMORY_SIZE - 1;
write(CPU_WRITE, &WRITE_COMMAND, sizeof(int));
write(CPU_WRITE, &address, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
stack_pointer = MEMORY_SIZE - 1; // switch stack
// push program counter
stack_pointer --;
write(CPU_WRITE, &WRITE_COMMAND, sizeof(int));
write(CPU_WRITE, &stack_pointer, sizeof(int));
write(CPU_WRITE, &program_counter, sizeof(int));
program_counter = TIMER_INTERRUPT_START;
}
} // END while
NORMAL_EXIT:
// wait for child process to end
write(CPU_WRITE, &CRASH_COMMAND, sizeof(int));
waitpid(-1, NULL, 0);
return 0;
ERROR_EXIT:
write(CPU_WRITE, &CRASH_COMMAND, sizeof(int));
waitpid(-1, NULL, 0);
exit(1);
}
int main(int argc, char **argv) {
char c, *id = NULL, *spoof_addr = NULL;
opterr = 0;
while ((c = getopt(argc, argv, "hVi:m:")) != -1) {
switch(c) {
case 'h':
help_message();
return 0;
case 'V':
printf("%s\n", version);
return 0;
case 'i':
if (validate_interface(optarg)) {
id = calloc(1, strlen(optarg)+1);
strcpy(id, optarg);
}
else {
fprintf(stderr, "Invalid interface specified after -i.\n");
return 1;
}
break;
case 'm':
if (validate_address(optarg)) {
spoof_addr = calloc(1, strlen(optarg)+1);
strcpy(spoof_addr, optarg);
}
else {
fprintf(stderr, "Invalid address specified after -m.\n");
return 1;
}
break;
case '?':
if (optopt == 'i' || optopt == 'm') {
fprintf(stderr, "Option -%c requires an argument.\n", optopt);
return 1;
}
else if (isprint(optopt)) {
fprintf(stderr, "Unknown option -%c.\n", optopt);
return 1;
}
else {
fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
return 1;
}
default:
abort(); /* if we get here, bad things have happened */
}
}
if (geteuid() != 0) {
fprintf(stderr, "This tools needs to be run as root.\n");
return 1;
}
if (!id) {
fprintf(stderr, "No interface supplied.\n");
return 1;
}
if (!spoof_addr) {
spoof_addr = generate_mac();
spoof_addr[ADDR_BYTES-1] = '\0';
}
spoof_interface_mac(id, spoof_addr);
sleep(2);
bounce_interface(id);
sleep(1);
return 0;
}
gboolean
mm_mbm_parse_e2ipcfg_response (const gchar *response,
MMBearerIpConfig **out_ip4_config,
MMBearerIpConfig **out_ip6_config,
GError **error)
{
MMBearerIpConfig **ip_config = NULL;
gboolean got_address = FALSE, got_gw = FALSE, got_dns = FALSE;
GRegex *r;
GMatchInfo *match_info = NULL;
GError *match_error = NULL;
gchar *dns[3] = { 0 };
guint dns_idx = 0;
int family = AF_INET;
MMBearerIpMethod method = MM_BEARER_IP_METHOD_STATIC;
g_return_val_if_fail (out_ip4_config, FALSE);
g_return_val_if_fail (out_ip6_config, FALSE);
if (!response || !g_str_has_prefix (response, E2IPCFG_TAG)) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Missing " E2IPCFG_TAG " prefix");
return FALSE;
}
response = mm_strip_tag (response, "*E2IPCFG: ");
if (strchr (response, ':')) {
family = AF_INET6;
ip_config = out_ip6_config;
method = MM_BEARER_IP_METHOD_DHCP;
} else if (strchr (response, '.')) {
family = AF_INET;
ip_config = out_ip4_config;
method = MM_BEARER_IP_METHOD_STATIC;
} else {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Failed to detect " E2IPCFG_TAG " address family");
return FALSE;
}
/* *E2IPCFG: (1,<IP>)(2,<gateway>)(3,<DNS>)(3,<DNS>)
*
* *E2IPCFG: (1,"46.157.32.246")(2,"46.157.32.243")(3,"193.213.112.4")(3,"130.67.15.198")
* *E2IPCFG: (1,"fe80:0000:0000:0000:0000:0000:e537:1801")(3,"2001:4600:0004:0fff:0000:0000:0000:0054")(3,"2001:4600:0004:1fff:0000:0000:0000:0054")
* *E2IPCFG: (1,"fe80:0000:0000:0000:0000:0027:b7fe:9401")(3,"fd00:976a:0000:0000:0000:0000:0000:0009")
*/
r = g_regex_new ("\\((\\d),\"([0-9a-fA-F.:]+)\"\\)", 0, 0, NULL);
g_assert (r != NULL);
if (!g_regex_match_full (r, response, -1, 0, 0, &match_info, &match_error)) {
if (match_error) {
g_propagate_error (error, match_error);
g_prefix_error (error, "Could not parse " E2IPCFG_TAG " results: ");
} else {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't match " E2IPCFG_TAG " reply");
}
goto done;
}
*ip_config = mm_bearer_ip_config_new ();
mm_bearer_ip_config_set_method (*ip_config, method);
while (g_match_info_matches (match_info)) {
char *id = g_match_info_fetch (match_info, 1);
char *str = g_match_info_fetch (match_info, 2);
switch (atoi (id)) {
case 1:
if (validate_address (family, str)) {
mm_bearer_ip_config_set_address (*ip_config, str);
mm_bearer_ip_config_set_prefix (*ip_config, (family == AF_INET6) ? 64 : 28);
got_address = TRUE;
}
break;
case 2:
if ((family == AF_INET) && validate_address (family, str)) {
mm_bearer_ip_config_set_gateway (*ip_config, str);
got_gw = TRUE;
}
break;
case 3:
if (validate_address (family, str)) {
dns[dns_idx++] = g_strdup (str);
got_dns = TRUE;
}
break;
default:
break;
}
g_free (id);
g_free (str);
g_match_info_next (match_info, NULL);
}
if (got_dns) {
mm_bearer_ip_config_set_dns (*ip_config, (const gchar **) dns);
g_free (dns[0]);
g_free (dns[1]);
}
if (!got_address || (family == AF_INET && !got_gw)) {
g_object_unref (*ip_config);
*ip_config = NULL;
g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Got incomplete IP configuration from " E2IPCFG_TAG);
}
done:
if (match_info)
g_match_info_free (match_info);
g_regex_unref (r);
return !!*ip_config;
}
