int run_test_process(ContextAttachCallBack * done, void * data) {
#if defined(WIN32)
char fnm[FILE_PATH_SIZE];
char cmd[FILE_PATH_SIZE];
int res = 0;
STARTUPINFO si;
PROCESS_INFORMATION prs;
ContextAttachArgs * args;
memset(&si, 0, sizeof(si));
memset(&prs, 0, sizeof(prs));
memset(fnm, 0, sizeof(fnm));
if (GetModuleFileName(NULL, fnm, sizeof(fnm)) == 0) {
set_win32_errno(GetLastError());
return -1;
}
si.cb = sizeof(si);
strcpy(cmd, "agent.exe -t");
if (CreateProcess(fnm, cmd, NULL, NULL,
FALSE, CREATE_SUSPENDED | CREATE_DEFAULT_ERROR_MODE | CREATE_NO_WINDOW,
NULL, NULL, &si, &prs) == 0) {
set_win32_errno(GetLastError());
return -1;
}
args = (ContextAttachArgs *)loc_alloc(sizeof(ContextAttachArgs));
args->done = done;
args->data = data;
args->thread = prs.hThread;
args->process = prs.hProcess;
res = context_attach(prs.dwProcessId, done_context_attach, args, 0);
if (res != 0) loc_free(args);
return res;
#elif defined(_WRS_KERNEL)
int tid = taskCreate("tTcf", 100, 0, 0x4000, (FUNCPTR)test_proc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
if (tid == 0) return -1;
taskStop(tid);
taskActivate(tid);
assert(taskIsStopped(tid));
return context_attach(tid, done, data, 0);
#else
/* Create child process to debug */
int pid = fork();
if (pid < 0) return -1;
if (pid == 0) {
int fd;
if (context_attach_self() < 0) exit(1);
fd = sysconf(_SC_OPEN_MAX);
while (fd-- > 2) close(fd);
if (tkill(getpid(), SIGSTOP) < 0) exit(1);
test_proc();
exit(0);
}
return context_attach(pid, done, data, CONTEXT_ATTACH_SELF);
#endif
}
static void command_attach(char * token, Channel * c) {
int err = 0;
char id[256];
pid_t pid, parent;
json_read_string(&c->inp, id, sizeof(id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
pid = id2pid(id, &parent);
if (parent != 0) {
err = ERR_INV_CONTEXT;
}
else if (context_find_from_pid(pid) != NULL) {
err = ERR_ALREADY_ATTACHED;
}
else {
AttachDoneArgs * data = loc_alloc_zero(sizeof *data);
data->c = c;
strcpy(data->token, token);
if (context_attach(pid, attach_done, data, 0) == 0) {
stream_lock(c);
return;
}
err = errno;
loc_free(data);
}
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, err);
write_stream(&c->out, MARKER_EOM);
}
object_t
get_local(context_t context, int uplevel, int offset)
{
object_t cur = context->env;
while (uplevel > 0)
{
if (cur->environment.parent == OBJECT_NULL) return NULL;
else cur = cur->environment.parent;
-- uplevel;
}
if (offset >= cur->environment.length) return NULL;
object_t result = SLOT_GET(cur->environment.slot_entry[offset]);
if (IS_OBJECT(result))
context_attach(context, result);
return result;
}
static void command_start(char * token, Channel * c) {
int pid = 0;
int err = 0;
char dir[FILE_PATH_SIZE];
char exe[FILE_PATH_SIZE];
char ** args = NULL;
char ** envp = NULL;
int args_len = 0;
int envp_len = 0;
int attach = 0;
int selfattach = 0;
int pending = 0;
ChildProcess * prs = NULL;
Trap trap;
if (set_trap(&trap)) {
json_read_string(&c->inp, dir, sizeof(dir));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
json_read_string(&c->inp, exe, sizeof(exe));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
args = json_read_alloc_string_array(&c->inp, &args_len);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
envp = json_read_alloc_string_array(&c->inp, &envp_len);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
attach = json_read_boolean(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
if (dir[0] != 0 && chdir(dir) < 0) err = errno;
if (err == 0 && start_process(c, envp, dir, exe, args, attach, &pid, &selfattach, &prs) < 0) err = errno;
if (prs != NULL) {
write_process_input(prs);
prs->out_struct = read_process_output(prs, prs->out, prs->out_id, sizeof(prs->out_id));
if (prs->out != prs->err) prs->err_struct = read_process_output(prs, prs->err, prs->err_id, sizeof(prs->err_id));
strncpy(prs->name, exe, sizeof(prs->name) - 1);
}
if (!err) {
if (attach) {
AttachDoneArgs * data = loc_alloc_zero(sizeof *data);
data->c = c;
strcpy(data->token, token);
pending = context_attach(pid, start_done, data, selfattach) == 0;
if (pending) {
stream_lock(c);
}
else {
err = errno;
loc_free(data);
}
}
else {
add_waitpid_process(pid);
}
}
if (!pending) {
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, err);
if (err || pid == 0) {
write_stringz(&c->out, "null");
}
else {
write_context(&c->out, pid);
write_stream(&c->out, 0);
}
write_stream(&c->out, MARKER_EOM);
}
clear_trap(&trap);
}
loc_free(args);
loc_free(envp);
if (trap.error) exception(trap.error);
}
