static
int breakpoint_handler(mach_port_t task, uint64_t addr, struct symbol_info *psymbol_table, size_t nsym, int stack_depth)
{
int i;
int output = 1;
int type;
const char *fname = lookup_function(addr, psymbol_table, nsym, &type);
uint64_t rax;
/* output to stderr */
if (output) {
fprintf(stderr, "[Tracer] ");
}
if (type == 2 && 0 < stack_depth) {
stack_depth--;
}
if (output) {
for(i = 0; i < stack_depth; i++) {
fprintf(stderr, " ");
}
}
if (type == 1) {
stack_depth++;
}
if (output) {
read_process_register_64(task, RAX, &rax);
if (type == 1) {
fprintf(stderr, "%s [ %s (at 0x%llx)]\n", type == 1 ? "===>" : type == 2 ? "<===" : " " , fname, addr);
} else if (type == 2) {
fprintf(stderr, "%s [ %s (at 0x%llx, rax = 0x%llx)]\n", type == 1 ? "===>" : type == 2 ? "<===" : " " , fname, addr, rax);
}
}
return stack_depth;
}
/*
* Run a single program without an object or tracker. This is used for
* providing custom sensor handlers (PROGRAM_SENSOR_DATA) and similar
* external functions.
*/
boolean ProgramManager::run_program(byte type, void *arg) {
hmtl_program_t *program = lookup_function(type);
program->program(NULL, arg, NULL);
return false;
}
char *convert_to_keystr(char *key)
{
int ret, loc;
static char keyloc[80];
ret = lookup_function(key, &loc);
*keyloc = 0;
if (ret == 1)
{
char meta_str[8];
int i, j;
int charsize = charset_size();
*meta_str = 0;
for (i = 0; i <= MAX_META; i++)
{
if (!keys[i])
continue;
for (j = 0; j < charsize; j++)
if (KEY(i, j) && KEY(i, j)->key_index == loc)
{
if (i > 0)
sprintf(meta_str, "META%d-", i);
sprintf(keyloc, "%s%s", meta_str, display_key(j));
return keyloc;
}
}
}
return keyloc;
}
/*
* Run a single program without an object or tracker. This is used for
* providing custom sensor handlers (PROGRAM_SENSOR_DATA) and similar
* external functions.
*/
boolean ProgramManager::run_program(byte type, void *arg) {
byte program = lookup_function(type);
if (program != NO_PROGRAM) {
functions[program].program(NULL, arg, NULL);
}
return false;
}
/* special interface to new_key for the default key bindings */
static void snew_key (int meta, unsigned chr, char *what)
{
int i;
int j;
if ((j = lookup_function(what, &i)) == 1)
new_key(meta, chr, i, 0, NULL);
#if 0
else
ircpanic("Something bogus passed to snew_key");
#endif
}
/*
* Process a program configuration message
*/
boolean ProgramManager::handle_msg(msg_program_t *msg) {
DEBUG4_VALUE("handle_msg: program=", msg->type);
DEBUG4_VALUELN(" output=", msg->hdr.output);
/* Find the program to be executed */
hmtl_program_t *program = lookup_function(msg->type);
if (program == NULL) {
DEBUG1_VALUELN("handle_msg: invalid type: ",
msg->type);
return false;
}
/* Setup the tracker */
if (msg->hdr.output > num_outputs) {
DEBUG1_VALUELN("handle_msg: invalid output: ",
msg->hdr.output);
return false;
}
if (outputs[msg->hdr.output] == NULL) {
DEBUG1_VALUELN("handle_msg: NULL output: ",
msg->hdr.output);
return false;
}
program_tracker_t *tracker = trackers[msg->hdr.output];
if (program->type == HMTL_PROGRAM_NONE) {
/* This is a message to clear the existing program so free the tracker */
free_tracker(msg->hdr.output);
return true;
}
if (tracker != NULL) {
DEBUG5_PRINTLN("handle_msg: reusing old tracker");
if (tracker->state) {
DEBUG5_PRINTLN("handle_msg: deleting old state");
free(tracker->state);
}
} else {
tracker = (program_tracker_t *)malloc(sizeof (program_tracker_t));
trackers[msg->hdr.output] = tracker;
}
tracker->program = program;
tracker->flags = 0x0;
tracker->program->setup(msg, tracker);
return true;
}
static int expr_resolve_ref(elcgen *gen, expression *expr)
{
if (XPATH_VAR_REF == expr->type) {
expr->target = lookup_var_ref(expr,expr->qn);
if (NULL == expr->target) {
if (strcmp(expr->qn.uri,""))
return gen_error(gen,"variable {%s}%s not found",expr->qn.uri,expr->qn.localpart);
else
return gen_error(gen,"variable %s not found",expr->qn.localpart);
}
}
else if (XPATH_FUNCTION_CALL == expr->type) {
expr->target = lookup_function(gen,expr->qn);
/* failed lookup is ok, might be to built-in function or web service */
}
return 1;
}
static void snew_key_from_str (uc *string, char *what)
{
int i;
int meta;
int old_display;
uc chr;
old_display = window_display;
window_display = 0;
if ((meta = parse_key(string, &chr)) == -1)
return;
window_display = old_display;
if (lookup_function(what, &i) == 1)
new_key(meta, chr, i, 0, NULL);
return;
}
static unsigned long spawn_erlang_epmd(ei_cnode *ec,
char *alive,
Erl_IpAddr adr,
int flags,
char *erl_or_epmd,
char *args[],
int port,
int is_erlang)
{
#if defined(VXWORKS)
FUNCPTR erlfunc;
#else /* Windows */
STARTUPINFO sinfo;
SECURITY_ATTRIBUTES sa;
PROCESS_INFORMATION pinfo;
#endif
char *cmdbuf;
int cmdlen;
char *ptr;
int i;
int num_args;
char *name_format;
struct in_addr myaddr;
struct in_addr *hisaddr = (struct in_addr *)adr;
char iaddrbuf[IP_ADDR_CHARS + 1];
int ret;
if(is_erlang){
get_addr(ei_thishostname(ec), &myaddr);
#if defined(VXWORKS)
inet_ntoa_b(myaddr, iaddrbuf);
#else /* Windows */
if((ptr = inet_ntoa(myaddr)) == NULL)
return 0;
else
strcpy(iaddrbuf,ptr);
#endif
}
if ((flags & ERL_START_REMOTE) ||
(is_erlang && (hisaddr->s_addr != myaddr.s_addr))) {
return 0;
} else {
num_args = enquote_args(args, &args);
for(cmdlen = i = 0; args[i] != NULL; ++i)
cmdlen += strlen(args[i]) + 1;
#if !defined(VXWORKS)
/* On VxWorks, we dont actually run a command,
we call start_erl() */
if(!erl_or_epmd)
#endif
erl_or_epmd = (is_erlang) ? DEF_ERL_COMMAND :
DEF_EPMD_COMMAND;
if(is_erlang){
name_format = (flags & ERL_START_LONG) ? ERL_NAME_FMT :
ERL_SNAME_FMT;
cmdlen +=
strlen(erl_or_epmd) + (*erl_or_epmd != '\0') +
strlen(name_format) + 1 + strlen(alive) +
strlen(ERL_REPLY_FMT) + 1 + strlen(iaddrbuf) +
2 * FORMATTED_INT_LEN +
1;
ptr = cmdbuf = malloc(cmdlen);
if(*erl_or_epmd != '\0')
ptr += sprintf(ptr,"%s ",erl_or_epmd);
ptr += sprintf(ptr, name_format,
alive);
ptr += sprintf(ptr, " " ERL_REPLY_FMT,
iaddrbuf, port, unique_id());
} else { /* epmd */
cmdlen += strlen(erl_or_epmd) + (*erl_or_epmd != '\0') + 1;
ptr = cmdbuf = malloc(cmdlen);
if(*erl_or_epmd != '\0')
ptr += sprintf(ptr,"%s ",erl_or_epmd);
else
*(ptr++) = '\0';
}
for(i= 0; args[i] != NULL; ++i){
*(ptr++) = ' ';
strcpy(ptr,args[i]);
ptr += strlen(args[i]);
}
free_args(args);
if (flags & ERL_START_VERBOSE) {
fprintf(stderr,"erl_call: commands are %s\n",cmdbuf);
}
/* OK, one single command line... */
#if defined(VXWORKS)
erlfunc = lookup_function((is_erlang) ? ERLANG_SYM :
EPMD_SYM);
if(erlfunc == NULL){
if (flags & ERL_START_VERBOSE) {
fprintf(stderr,"erl_call: failed to find symbol %s\n",
(is_erlang) ? ERLANG_SYM : EPMD_SYM);
}
ret = 0;
} else {
/* Just call it, it spawns itself... */
ret = (unsigned long)
(*erlfunc)((int) cmdbuf,0,0,0,0,0,0,0,0,0);
if(ret == (unsigned long) ERROR)
ret = 0;
}
#else /* Windows */
/* Hmmm, hidden or unhidden window??? */
memset(&sinfo,0,sizeof(sinfo));
sinfo.cb = sizeof(STARTUPINFO);
sinfo.dwFlags = STARTF_USESHOWWINDOW /*|
STARTF_USESTDHANDLES*/;
sinfo.wShowWindow = SW_HIDE; /* Hidden! */
sinfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
sinfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
sinfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = /*TRUE*/ FALSE;
if(!CreateProcess(
NULL,
cmdbuf,
&sa,
NULL,
/*TRUE*/ FALSE,
0 | CREATE_NEW_CONSOLE,
NULL,
NULL,
&sinfo,
&pinfo))
ret = 0;
else
ret = (unsigned long) pinfo.hProcess;
#endif
free(cmdbuf);
return ret;
}
/* NOTREACHED */
}
/*
* Process a program configuration message
*/
boolean ProgramManager::handle_msg(msg_program_t *msg) {
DEBUG4_VALUE("handle_msg: program=", msg->type);
DEBUG4_VALUELN(" output=", msg->hdr.output);
/* Find the program to be executed */
byte program = lookup_function(msg->type);
if (program == NO_PROGRAM) {
DEBUG1_VALUELN("handle_msg: invalid type: ", msg->type);
return false;
}
/* Setup the tracker */
int starting_output, stop_output;
if (msg->hdr.output == HMTL_ALL_OUTPUTS) {
/* This should be applied to all outputs that can handle the message type */
starting_output = 0;
stop_output = num_outputs;
} else if (msg->hdr.output > num_outputs) {
DEBUG1_VALUELN("handle_msg: invalid output: ",
msg->hdr.output);
return false;
} else if (outputs[msg->hdr.output] == NULL) {
DEBUG1_VALUELN("handle_msg: NULL output: ", msg->hdr.output);
return false;
} else {
/* Only apply to the specified output */
starting_output = msg->hdr.output;
stop_output = starting_output + 1;
}
for (int output = starting_output; output < stop_output; output++) {
if (outputs[output] == NULL)
continue;
if (msg->type == HMTL_PROGRAM_NONE) {
/* This is a message to clear the existing program so free the tracker */
DEBUG3_VALUELN("handle_msg: clear ", output);
free_tracker(output);
continue;
}
program_tracker_t *tracker;
if (functions[program].program == NULL) {
/*
* This is an initialization-only command, set tracker to null
*/
DEBUG4_PRINTLN("handle_msg: trackerless")
tracker = NULL;
} else {
/* If there was an active program on this output then clear the tracker */
free_tracker(output);
/* Setup a tracker for this program */
tracker = get_tracker(output);
tracker->program_index = program;
tracker->flags = 0x0;
}
if (tracker) {
// Record the output and object in the tracker
tracker->output = outputs[output];
tracker->object = objects[output];
}
/* Attempt to setup the program */
boolean success = functions[program].setup(msg, tracker, outputs[output],
objects[output], this);
if (!success) {
if (tracker) {
DEBUG4_VALUELN("handle_msg: NA on ", output);
free_tracker(output);
}
continue;
}
DEBUG4_VALUELN("handle_msg: setup on ", output);
}
return true;
}
