//-----------------------------------------------------------------------------
int flash_erase_all ( void )
{
unsigned int ra;
ra=0;
sdata[ra++]='P';
sdata[ra++]=' ';
sdata[ra++]='0';
sdata[ra++]=' ';
sdata[ra++]='7';
sdata[ra++]=0x0D;
sdata[ra++]=0x0A;
ser_senddata(sdata,ra);
if(get_return_code()) return(1);
ra=0;
sdata[ra++]='E';
sdata[ra++]=' ';
sdata[ra++]='0';
sdata[ra++]=' ';
sdata[ra++]='7';
sdata[ra++]=0x0D;
sdata[ra++]=0x0A;
ser_senddata(sdata,ra);
if(get_return_code()) return(1);
return(0);
}
//-----------------------------------------------------------------------------
int read_data_word ( unsigned int addr, unsigned int *data )
{
unsigned int ra,rb,rc,rd;
sprintf((char *)sdata,"R %u 4\r",addr);
ra=strlen((char *)sdata);
ser_senddata(sdata,ra);
if(get_return_code()) return(1);
ra=wait_for_packet();
if(ra<3) return(1);
for(rb=0;rb<ra;rb++) printf("0x%02X ",rdata[rb]); printf("\n");
rb=uudecode(udata,&rdata[1],ra-2);
rc=0;
rd=0;
for(ra=0;ra<rb;ra++)
{
rd<<=8;
rd|=udata[ra];
rc+=udata[ra];
printf("0x%02X %u\n",udata[ra],rc);
}
if(get_checksum(&ra)) return(1);
if(ra!=rc) return(1);
ser_senddata(okpatt,sizeof(okpatt));
*data=rd;
return(0);
}
CAMLprim value stub_sent_data(value ssl, value transferred)
{
CAMLparam2(ssl,transferred);
int rc;
rc=matrixSslSentData(ssl_t_val(ssl), Int_val(transferred));
if(rc<0) {
caml_failwith("Sent data");
}
CAMLreturn(get_return_code(rc,NULL,0));
}
CAMLprim value stub_processed_data(value ssl)
{
CAMLparam1(ssl);
unsigned char *buf=NULL;
unsigned int len;
int rc;
rc=matrixSslProcessedData(ssl_t_val(ssl), &buf, &len);
if(rc<0) {
caml_failwith("Processed Data");
}
CAMLreturn(get_return_code(rc,buf,len));
}
//-----------------------------------------------------------------------------
int write_data_word ( unsigned int addr, unsigned int data )
{
unsigned int ra,rb,rc,rd;
ra=0;
rd=data;
//sdata[ra++]=(rd>>24)&0xFF; rd<<=8;
//sdata[ra++]=(rd>>24)&0xFF; rd<<=8;
//sdata[ra++]=(rd>>24)&0xFF; rd<<=8;
//sdata[ra++]=(rd>>24)&0xFF; rd<<=8;
sdata[ra++]=rd&0xFF; rd>>=8;
sdata[ra++]=rd&0xFF; rd>>=8;
sdata[ra++]=rd&0xFF; rd>>=8;
sdata[ra++]=rd&0xFF; rd>>=8;
rd=0; for(rb=0;rb<ra;rb++) rd+=sdata[rb];
rb=uuencode(udata,sdata,ra);
udata[rb++]=0x0D;
udata[rb++]=0x0A;
sprintf((char *)sdata,"W %u 4\r\n",addr);
ra=strlen((char *)sdata);
ser_senddata(sdata,ra);
if(get_return_code()) return(1);
ser_senddata(udata,rb);
sprintf((char *)sdata,"%u\r\n",rd);
ra=strlen((char *)sdata);
ser_senddata(sdata,ra);
ra=wait_for_packet();
rb=0;
if(ra!=4) rb++;
if(rdata[1]!='O') rb++;
if(rdata[2]!='K') rb++;
if(rb)
{
for(rc=0;rc<ra;rc++) printf("[0x%02X]",rdata[rc]); printf("\n");
printf("%s\n",rdata);
return(1);
}
return(0);
}
CAMLprim value stub_received_data(value ssl, value str)
{
CAMLparam2(ssl,str);
CAMLlocal1(ret);
int str_len = caml_string_length(str);
unsigned char *buf=NULL;
unsigned int len, to_cpy;
int rc;
len=matrixSslGetReadbuf(ssl_t_val(ssl), &buf);
to_cpy = (len<str_len) ? len : str_len;
memcpy(buf,String_val(str),len);
rc=matrixSslReceivedData(ssl_t_val(ssl), to_cpy, &buf, &len);
if(rc<0) {
caml_failwith("Received Data");
}
CAMLreturn(get_return_code(rc,buf,len));
}
static int parse_client_line(const int client_socket, char *msg)
{
char *token;
/* On récupère le premier mot, s'il est vide, on retourne direct */
if (!(token = strtok(msg, " ")))
return MSG_OK;
/*****************************************************************************
* CMD_QUIT
****************************************************************************/
if (!strcmp(CMD_QUIT, token))
{
send_ok(client_socket, DETAIL_RET_QUIT);
return MSG_QUIT;
}
/*****************************************************************************
* CMD_CREATE_PROCESS
****************************************************************************/
else if (!strcmp(CMD_CREATE_PROCESS, token))
{
char *args[MAX_ARGS];
char **pc = args;
/* On récup le nom du prog */
if (!(token = strtok(NULL, " ")))
{
send_failure(client_socket, DETAIL_RET_CREATE_PROCESS_SYNTAX);
return MSG_ERR;
}
/* strtok renvoie un buffer static, on le copie */
/* *pc = args[0] = nom du programme */
if (!(*pc++ = strdup(token)))
{
perror("strdup");
return MSG_ERR;
}
/* La suite devient optionelle, c'est les arguments */
while ((token = strtok(NULL, " ")))
{
if ((*pc++ = strdup(token)) == NULL)
{
perror("strdup");
return MSG_ERR;
}
}
*pc = NULL; /* Fin des arguments */
/* On crée le processus */
pid_t proc = create_process(args[0], args);
/* Le processus n'a pas pu être créé */
if (proc == -1) {
send_failure(client_socket, DETAIL_RET_CREATE_PROCESS_ERROR);
return MSG_ERR;
}
send_ok(client_socket, itoa(proc));
return MSG_OK;
}
/*****************************************************************************
* CMD_DESTROY_PROCESS
****************************************************************************/
else if (!strcmp(CMD_DESTROY_PROCESS, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_DESTROY_PROCESS_SYNTAX);
return MSG_ERR;
}
pid_t process_to_kill = atoi(token);
if (!process_exists(process_to_kill))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
destroy_process(process_to_kill);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_SEND_INPUT
****************************************************************************/
else if (!strcmp(CMD_SEND_INPUT, token))
{
char buffer[MESSAGE_BUFFER_SIZE];
buffer[0] = '\0';
/* On récup le PID */
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_SEND_INPUT_SYNTAX);
return MSG_ERR;
}
/* Il existe ? */
pid_t send_to_process = atoi(token);
if (!process_exists(send_to_process))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
/* Il est déjà terminé ? */
if (get_return_code(send_to_process) != PROCESS_NOT_TERMINATED)
{
send_failure(client_socket, DETAIL_RET_PROCESS_TERMINATED);
return MSG_ERR;
}
/* Son stdin est ouvert ? */
if (!input_open(send_to_process))
{
send_failure(client_socket, DETAIL_RET_INPUT_CLOSE);
return MSG_ERR;
}
/* On récup' le message à envoyer */
/* TODO: Prendre la chaîne telle qu'elle, sans splitter puis merger avec un espace */
while ((token = strtok(NULL, " ")))
{
strcat(buffer, token);
strcat(buffer, " ");
}
/* Si le message est vide, erreur ! */
if (strlen(buffer) == 0)
{
send_failure(client_socket, DETAIL_RET_SEND_INPUT_SYNTAX);
return MSG_ERR;
}
/* Sinon on envoie ! */
send_input(send_to_process, buffer);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_CLOSE_INPUT
****************************************************************************/
else if (!strcmp(CMD_CLOSE_INPUT, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_CLOSE_INPUT_SYNTAX);
return MSG_ERR;
}
pid_t process_to_close_input = atoi(token);
if (!process_exists(process_to_close_input))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
close_input(process_to_close_input);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_OUTPUT
****************************************************************************/
else if (!strcmp(CMD_GET_OUTPUT, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_OUTPUT_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_output = atoi(token);
if (!process_exists(process_to_get_output))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
get_output(client_socket, process_to_get_output);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_ERROR
****************************************************************************/
else if (!strcmp(CMD_GET_ERROR, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_ERROR_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_error = atoi(token);
if (!process_exists(process_to_get_error))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
get_error(client_socket, process_to_get_error);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_RETURN_CODE
****************************************************************************/
else if (!strcmp(CMD_GET_RETURN_CODE, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_RETURN_CODE_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_ret = atoi(token);
if (!process_exists(process_to_get_ret))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
int ret = get_return_code(process_to_get_ret);
if (ret == PROCESS_NOT_TERMINATED)
{
send_failure(client_socket, DETAIL_RET_GET_RETURN_CODE_ERROR);
return MSG_ERR;
}
send_ok(client_socket, itoa(ret));
return MSG_OK;
}
/*****************************************************************************
* CMD_LIST_PROCESS
****************************************************************************/
else if (!strcmp(CMD_LIST_PROCESS, token))
{
list_process(client_socket);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_HELP
****************************************************************************/
else if (!strcmp(CMD_GET_HELP, token))
{
send_basic(client_socket, help, strlen(help));
return MSG_OK;
}
/*****************************************************************************
* COMMANDE INCONNUE
****************************************************************************/
else
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_COMMAND);
return MSG_UNKNOWN_COMMAND;
}
}
//-----------------------------------------------------------------------------
int do_nxp_stuff ( void )
{
unsigned int ra,rb;
unsigned int ramadd;
if(nxp_isp_synchronize()) return(1);
//ra=0;
//sdata[ra++]='J';
//sdata[ra++]=0x0D;
//sdata[ra++]=0x0A;
//ser_senddata(sdata,ra);
//watch_for();
//ra=0;
//sdata[ra++]='K';
//sdata[ra++]=0x0D;
//sdata[ra++]=0x0A;
//ser_senddata(sdata,ra);
//watch_for();
//ra=0;
//sdata[ra++]='N';
//sdata[ra++]=0x0D;
//sdata[ra++]=0x0A;
//ser_senddata(sdata,ra);
//watch_for();
//Turn off echo
ser_senddata(echo_off,sizeof(echo_off));
if(sync_wait_for(echo_off_ok,sizeof(echo_off_ok))) return(1);
printf("echo off\n");
//----
//the ra-1 is so that everything from the chip is 0x0A...stuff...0x0D
//----
//Unlock
ra=0;
sdata[ra++]='U';
sdata[ra++]=' ';
sdata[ra++]='2';
sdata[ra++]='3';
sdata[ra++]='1';
sdata[ra++]='3';
sdata[ra++]='0';
sdata[ra++]=0x0D;
sdata[ra++]=0x0A;
ser_senddata(sdata,ra);
if(get_return_code()) return(1);
printf("unlocked\n");
ramadd=0x10000800;
for(rb=0x000;rb<0x800;rb+=64,ramadd+=64)
{
printf("write 0x%08X\n",ramadd);
sprintf((char *)sdata,"W %u 64\r\n",ramadd);
ra=strlen((char *)sdata);
ser_senddata(sdata,ra);
if(get_return_code()) return(1);
ser_senddata(&fdata[rb],64);
}
printf("go\n");
ramadd=0x10000800;
sprintf((char *)sdata,"G %u T\r\n",ramadd);
ra=strlen((char *)sdata);
ser_senddata(sdata,ra);
watch_for();
return(0);
}
int main(int argc, char *argv[])
{
if (argc < 1) {
dprintf(STDERR_FILENO, "wrun called without argument\n");
terminate_nocore();
}
shift(&argc, &argv);
if (argc > 1 && !strcmp(argv[0], "--tool_name")) {
shift(&argc, &argv);
tool_name = shift(&argc, &argv);
}
fill_std_fd_info_identity(STDIN_FILENO);
fill_std_fd_info_identity(STDOUT_FILENO);
fill_std_fd_info_identity(STDERR_FILENO);
bool force_redirects = false;
bool silent_breakaway = false;
int port;
bool terminate = !get_outbash_infos(&port, &force_redirects);
struct string outbash_command = string_create("");
if (argc && !strcmp(argv[0], ":")) {
shift(&argc, &argv);
string_append(&outbash_command, "cd:~\n");
} else {
char* cwd = agetcwd();
if (is_absolute_drive_fs_path(cwd)) {
char* cwd_win32 = convert_drive_fs_path_to_win32(cwd);
string_append(&outbash_command, "cd:");
string_append(&outbash_command, cwd_win32);
string_append(&outbash_command, "\n");
free(cwd_win32);
}
free(cwd);
}
while (argc && !strncmp(argv[0], "--", 2)) {
if (!strcmp(argv[0], "--")) {
shift(&argc, &argv);
break;
}
if (!strcmp(argv[0], "--env")) {
shift(&argc, &argv);
while (argc && strncmp(argv[0], "--", 2) != 0
&& *argv[0] != '\0' && strchr(argv[0] + 1, '=')) {
string_append(&outbash_command, "env:");
string_append(&outbash_command, argv[0]);
string_append(&outbash_command, "\n");
shift(&argc, &argv);
}
} else if (!strcmp(argv[0], "--force-redirects")) {
force_redirects = true;
shift(&argc, &argv);
} else if (!strcmp(argv[0], "--silent-breakaway")) {
silent_breakaway = true;
shift(&argc, &argv);
} else if (!strcmp(argv[0], "--help")) {
print_help();
exit(1);
} else {
dprintf(STDERR_FILENO, "%s: unknown command line option: %s\n", tool_name, argv[0]);
dprintf(STDERR_FILENO, "type %s --help for more information.\n", tool_name);
terminate_nocore();
}
}
if (terminate)
terminate_nocore();
check_argc(argc);
decide_will_redirect(STDIN_FILENO, force_redirects);
decide_will_redirect(STDOUT_FILENO, force_redirects);
decide_will_redirect(STDERR_FILENO, force_redirects);
int sock_ctrl = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock_ctrl < 0) {
dprintf(STDERR_FILENO, "%s: socket() failed: %s\n", tool_name, my_strerror(errno));
terminate_nocore();
}
#define STDIN_NEEDS_SOCKET_REDIRECT 1
#define STDOUT_NEEDS_SOCKET_REDIRECT 2
#define STDERR_NEEDS_SOCKET_REDIRECT 4
#define STDERR_SOCKREDIR_TO_STDOUT 8
int redirects = (needs_socket_redirect(STDIN_FILENO) ? STDIN_NEEDS_SOCKET_REDIRECT : 0)
| (needs_socket_redirect(STDOUT_FILENO) ? STDOUT_NEEDS_SOCKET_REDIRECT : 0);
if (needs_socket_redirect(STDERR_FILENO)) {
if ((redirects & STDOUT_NEEDS_SOCKET_REDIRECT) && are_stdfd_to_same_thing(STDOUT_FILENO, STDERR_FILENO))
redirects |= STDERR_SOCKREDIR_TO_STDOUT;
else
redirects |= STDERR_NEEDS_SOCKET_REDIRECT;
}
struct listening_socket lsock_in = NO_LISTENING_SOCKET;
struct listening_socket lsock_out = NO_LISTENING_SOCKET;
struct listening_socket lsock_err = NO_LISTENING_SOCKET;
if (redirects & STDIN_NEEDS_SOCKET_REDIRECT) lsock_in = socket_listen_one_loopback();
if (redirects & STDOUT_NEEDS_SOCKET_REDIRECT) lsock_out = socket_listen_one_loopback();
if (redirects & STDERR_NEEDS_SOCKET_REDIRECT) lsock_err = socket_listen_one_loopback();
ask_redirect(&outbash_command, "stdin:", STDIN_FILENO, lsock_in.port);
ask_redirect(&outbash_command, "stdout:", STDOUT_FILENO, lsock_out.port);
ask_redirect(&outbash_command, "stderr:", STDERR_FILENO,
(redirects & STDERR_NEEDS_SOCKET_REDIRECT) ? lsock_err.port : lsock_out.port);
if (silent_breakaway)
string_append(&outbash_command, "silent_breakaway:1\n");
char* win32_module;
if (is_absolute_drive_fs_path(argv[0])) {
win32_module = convert_drive_fs_path_to_win32(argv[0]);
string_append(&outbash_command, "module:");
string_append(&outbash_command, win32_module);
string_append(&outbash_command, "\n");
} else {
win32_module = convert_slash_to_backslash(argv[0]);
}
const bool module_need_quotes = (NULL != strpbrk(win32_module, " \t"));
string_append(&outbash_command, "run:");
if (module_need_quotes)
string_append(&outbash_command, "\"");
string_append(&outbash_command, win32_module);
if (module_need_quotes)
string_append(&outbash_command, "\"");
free(win32_module);
for (int i = 1; i < argc; i++) {
string_append(&outbash_command, " ");
string_append(&outbash_command, argv[i]);
}
string_append(&outbash_command, "\n\n");
//dprintf(STDOUT_FILENO, "%s", outbash_command.str);
//return EXIT_FAILURE;
signal(SIGPIPE, SIG_IGN);
sigset_t signal_set, orig_mask;
//////////////////////////// unblock SIGUSR1
sigemptyset(&signal_set);
sigaddset(&signal_set, SIGUSR1);
pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL);
//////////////////////////// block SIGTSTP
sigemptyset(&signal_set);
sigaddset(&signal_set, SIGTSTP);
pthread_sigmask(SIG_BLOCK, &signal_set, &orig_mask);
//////////////////////////// install custom SIGTSTP handler if signal was not ignored
struct sigaction sa;
sigaction(SIGTSTP, NULL, &sa);
const bool ignore_sigtstp = (sa.sa_handler == SIG_IGN);
if (!ignore_sigtstp) {
sa.sa_handler = tstop_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGTSTP, &sa, NULL);
}
//////////////////////////// install custom SIGUSR1 handler to wake-up blocked IO forwarding threads
// NOTE: the handler itself do nothing, but any blocked syscall will return with EINTR error
sa.sa_handler = noop_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, NULL);
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
serv_addr.sin_port = htons(port);
if (connect(sock_ctrl, (const struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
// NOTE: I'm not sure that WSL does what Linux does concerning
// http://www.madore.org/~david/computers/connect-intr.html
// for now we do not expect to recover after an interruption here.
dprintf(STDERR_FILENO, "%s: connect() failed: %s\n", tool_name, my_strerror(errno));
terminate_nocore();
}
if (send_all(sock_ctrl, outbash_command.str, outbash_command.length, 0) < 0) {
dprintf(STDERR_FILENO, "%s: send_all() failed: %s\n", tool_name, my_strerror(errno));
terminate_nocore();
}
string_destroy(&outbash_command);
static struct forward_state fs[3];
fs_init_accept_as_needed(&fs[STDIN_FILENO], &lsock_in, redirects & STDIN_NEEDS_SOCKET_REDIRECT, STDIN_FILENO, "stdin");
fs_init_accept_as_needed(&fs[STDOUT_FILENO], &lsock_out, redirects & STDOUT_NEEDS_SOCKET_REDIRECT, STDOUT_FILENO, "stdout");
fs_init_accept_as_needed(&fs[STDERR_FILENO], &lsock_err, redirects & STDERR_NEEDS_SOCKET_REDIRECT, STDERR_FILENO, "stderr");
char *line = ctrl_readln(sock_ctrl, NULL);
if (!line || strcmp(line, "connected")) {
dprintf(STDERR_FILENO, "%s: did not receive connection validation from outbash.exe\n", tool_name);
terminate_nocore();
}
close_listener(&lsock_in);
close_listener(&lsock_out);
close_listener(&lsock_err);
enum state_e state = RUNNING;
int program_return_code = 255;
pthread_t forward_threads[3];
bool active_threads[3] = {0};
for (int i = 0; i < 3; i++) {
if ((!fs[i].dead_in) || (!fs[i].dead_out)) {
int err = pthread_create(&forward_threads[i], NULL, forward_one_stream, &fs[i]);
if (err != 0) {
dprintf(STDERR_FILENO, "%s: pthread_create() failed: %s\n", tool_name, my_strerror(err));
terminate_nocore();
}
active_threads[i] = true;
}
}
int nfds = sock_ctrl + 1;
while (state != TERMINATED) {
fd_set rfds;
FD_ZERO(&rfds);
if (sock_ctrl < 0 || sock_ctrl >= FD_SETSIZE) {
dprintf(STDERR_FILENO, "%s: sock_ctrl=%d out of range\n", tool_name, sock_ctrl);
abort();
}
FD_SET(sock_ctrl, &rfds);
int pselect_res = pselect(nfds, &rfds, NULL, NULL, NULL, &orig_mask); // tstop_handler can run here
int pselect_errno = errno;
if (tstop_req && state == RUNNING) {
int r = send_all(sock_ctrl, "suspend\n", strlen("suspend\n"), 0);
if (r < 0 && err_is_connection_broken(errno)) {
// We will never be able to ask outbash to suspend the
// Windows process, the expected reason is that it actually
// has already terminated and we don't know yet about that,
// so stop the suspend forwarding mechanism and suspend
// ourselves immediately.
shutdown(sock_ctrl, SHUT_WR); // also we can't send anything anymore // XXX to comment for WSL bug workaround? proba low here...
signal(SIGTSTP, SIG_DFL);
state = DYING;
raise(SIGTSTP);
pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
} else if (r < 0) { // other errors
dprintf(STDERR_FILENO, "%s: send_all(\"suspend\\n\") failed: %s\n", tool_name, my_strerror(errno));
abort();
} else { // OK
// It's up to outbash now, just wait for its "suspend_ok"
// answer after it has suspended the Windows process.
state = SUSPEND_PENDING;
}
}
if (pselect_res < 0 && pselect_errno == EINTR) {
// "On error, -1 is returned, and errno is set appropriately;
// the sets and timeout become undefined, so do not rely on
// their contents after an error."
continue;
}
if (pselect_res < 0) {
dprintf(STDERR_FILENO, "%s: pselect() failed: %s\n", tool_name, my_strerror(pselect_errno));
abort();
}
if (FD_ISSET(sock_ctrl, &rfds)) {
while (1) {
int nonblock_marker;
line = ctrl_readln(sock_ctrl, &nonblock_marker);
if (!line && nonblock_marker) break;
if (line && !strcmp(line, "suspend_ok")) {
if (state == SUSPEND_PENDING) {
signal(SIGTSTP, SIG_DFL);
raise(SIGTSTP);
sigset_t previous_mask;
pthread_sigmask(SIG_SETMASK, &orig_mask, &previous_mask);
// >>> Process will Stop here, until SIGCONT <<<
pthread_sigmask(SIG_SETMASK, &previous_mask, NULL);
tstop_req = 0;
int r = send_all(sock_ctrl, "resume\n", strlen("resume\n"), 0);
if (r < 0 && err_is_connection_broken(errno)) {
// killed when suspended (if this is possible?)
// or maybe just before an attempt?
shutdown(sock_ctrl, SHUT_WR); // XXX to comment for WSL bug workaround? proba low here...
state = DYING;
pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
} else if (r < 0) {
dprintf(STDERR_FILENO, "%s: send_all(\"resume\\n\") failed: %s\n", tool_name, my_strerror(errno));
abort();
} else {
state = RUNNING;
sa.sa_handler = tstop_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGTSTP, &sa, NULL);
}
} else {
dprintf(STDERR_FILENO, "%s: spurious \"suspend_ok\" received\n", tool_name);
}
} else { // not "suspend_ok" => for now only other cases are exit conditions
program_return_code = get_return_code(line);
shutdown(sock_ctrl, SHUT_RDWR);
signal(SIGTSTP, ignore_sigtstp ? SIG_IGN : SIG_DFL);
if ((tstop_req && state == RUNNING) || state == SUSPEND_PENDING) {
// We expect to stop soon, but not without flushing the OS TCP
// buffers and our owns, and other WSL processes in a pipe might
// already be suspended, so we better honor suspend requests ASAP.
raise(SIGTSTP);
}
pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
tstop_req = 0;
state = TERMINATED;
break;
}
}
}
}
// XXX: this is not ideal if the Win32 side managed to maintain the
// redirection socket beyond the lifetime of the launched process,
// however things seem to already be not reliable for Windows reasons
// in this case
if (active_threads[0]) {
__sync_fetch_and_add(&fs[0].ask_terminate, 1);
useconds_t usec_sleep = 1000;
while (!__sync_fetch_and_add(&fs[0].finished, 0)) {
pthread_kill(forward_threads[0], SIGUSR1);
usleep(usec_sleep);
usec_sleep *= 2;
if (usec_sleep > 60000000)
usec_sleep = 60000000;
}
}
for (int i = 0; i < 3; i++)
if (active_threads[i])
pthread_join(forward_threads[i], NULL);
return program_return_code;
}
//-----------------------------------------------------------------------------
int do_lpc_stuff ( int erase_all )
{
unsigned int ra,rb,rc;
unsigned int ramadd;
unsigned int romadd;
unsigned int romsec;
if(lpc_isp_synchronize()) return(1);
//ra=0;
//sdata[ra++]='J';
//sdata[ra++]=0x0D;
//ser_senddata(sdata,ra);
//watch_for();
//ra=0;
//sdata[ra++]='K';
//sdata[ra++]=0x0D;
//ser_senddata(sdata,ra);
//watch_for();
//Turn off echo
ra=0;
sdata[ra++]='A';
sdata[ra++]=' ';
sdata[ra++]='0';
sdata[ra++]=0x0D;
sdata[ra++]=0x0A;
ser_senddata(sdata,ra);
if(sync_wait_for(sdata,ra-1)) return(1);
//----
//the ra-1 is so that everything from the chip is 0x0A...stuff...0x0D
//----
if(get_return_code()) return(1);
//Unlock
ra=0;
sdata[ra++]='U';
sdata[ra++]=' ';
sdata[ra++]='2';
sdata[ra++]='3';
sdata[ra++]='1';
sdata[ra++]='3';
sdata[ra++]='0';
sdata[ra++]=0x0D;
ser_senddata(sdata,ra);
if(get_return_code()) return(1);
////write program to ram and run from ram
//rb=0x40000200;
//for(ra=0;ra<bin_length;ra++)
//{
//if(write_data_word(rb,bin_data[ra])) return(1);
//rb+=4;
//}
//sprintf((char *)sdata,"G %u A\r",0x40000200);
//ra=strlen((char *)sdata);
//ser_senddata(sdata,ra);
////if(get_return_code()) return(1);
if(erase_all)
{
printf("Erase All\n");
if(flash_erase_all())
{
printf("flash_erase_all() failed\n");
return(1);
}
}
//write program to flash
printf("Programming 0x%04X bytes to flash\n",fdatalen<<2);
//patch vector table, first 0x20 bytes worth of words need to add to zero
fdata[0x14>>2]=0x0;
rc=0; for(ra=0;ra<0x20;ra+=4) rc+=fdata[ra>>2];
rc=-rc;
fdata[0x14>>2]=rc;
printf("0x%08X\n",fdata[0]);
romadd=0x00000000;
//ramadd=0x40000200;
for(ra=0;ra<fdatalen;ra+=64)
{
romsec=romadd>>12; //armmite uses 4KB sectors
if((romadd&0xFFF)==0) //armmite uses 4KB sectors
{
printf("\nErasing 0x%04X\n",romadd);
sprintf((char *)sdata,"P %u %u\r",romsec,romsec);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
sprintf((char *)sdata,"E %u %u\r",romsec,romsec);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
ramadd=0x40000200;
}
printf("\nProgramming 0x%04X\n",romadd);
rc=ramadd;
for(rb=0;rb<64;rb++) //256 bytes per copy
{
if(write_data_word(rc,fdata[ra+rb])) return(1);
rc+=4;
}
sprintf((char *)sdata,"P %u %u\r",romsec,romsec);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
sprintf((char *)sdata,"C %u %u 256\r",romadd,ramadd);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
romadd+=256;
ramadd+=256;
}
printf("\n====\n");
while(1)
{
rb=ser_copystring(rdata);
for(ra=0;ra<rb;ra++)
{
printf("0x%02X ",rdata[ra]);
if((rdata[ra]>=0x20)&&(rdata[ra]<127)) printf("[%c]",rdata[ra]);
printf("\n");
}
ser_dump(rb);
}
return(0);
}
//-----------------------------------------------------------------------------
int do_nxp_stuff ( void )
{
unsigned int ra,rc;
unsigned int ramadd;
unsigned int romadd;
unsigned int romsec;
if(nxp_isp_synchronize()) return(1);
//ra=0;
//sdata[ra++]='J';
//sdata[ra++]=0x0D;
//sdata[ra++]=0x0A;
//ser_senddata(sdata,ra);
//watch_for();
//ra=0;
//sdata[ra++]='K';
//sdata[ra++]=0x0D;
//sdata[ra++]=0x0A;
//ser_senddata(sdata,ra);
//watch_for();
//ra=0;
//sdata[ra++]='N';
//sdata[ra++]=0x0D;
//sdata[ra++]=0x0A;
//ser_senddata(sdata,ra);
//watch_for();
//Turn off echo
ser_senddata(echo_off,sizeof(echo_off));
if(sync_wait_for(echo_off_ok,sizeof(echo_off_ok))) return(1);
printf("echo off\n");
//----
//the ra-1 is so that everything from the chip is 0x0A...stuff...0x0D
//----
//Unlock
ra=0;
sdata[ra++]='U';
sdata[ra++]=' ';
sdata[ra++]='2';
sdata[ra++]='3';
sdata[ra++]='1';
sdata[ra++]='3';
sdata[ra++]='0';
sdata[ra++]=0x0D;
sdata[ra++]=0x0A;
ser_senddata(sdata,ra);
//if(sync_wait_for(cmd_success,sizeof(cmd_success))) return(1);
if(get_return_code()) return(1);
printf("unlocked\n");
//write program to flash
printf("Programming 0x%04X bytes to flash\n",fdatalen<<2);
//patch vector table, first 0x20 bytes worth of words need to add to zero
fdata[0x14>>2]=0x0;
rc=0; for(ra=0;ra<0x20;ra+=4) rc+=fdata[ra>>2];
rc=-rc;
fdata[0x14>>2]=rc;
printf("0x%08X\n",fdata[0]);
//The size of a sector is 1 KB and the size of a page is 64 Byte.
//One sector contains 16 pages.
romadd=0x00000000;
for(ra=0;ra<fdatalen;ra+=256)
{
//romsec=romadd>>12; //nxp1334 uses 4KB sectors
//if((romadd&0xFFF)==0) //nxp13134 uses 4KB sectors
romsec=romadd>>10; //nxp82x uses 1KB sectors
if((romadd&0x3FF)==0) //nxp82x uses 1KB sectors
{
printf("\nErasing 0x%04X\n",romadd);
sprintf((char *)sdata,"P %u %u\r",romsec,romsec);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
sprintf((char *)sdata,"E %u %u\r",romsec,romsec);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
ramadd=0x10000800;
}
printf("\nProgramming 0x%04X\n",romadd);
sprintf((char *)sdata,"W %u 256\r\n",ramadd);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
ser_senddata(&fdata[ra],256);
sprintf((char *)sdata,"P %u %u\r",romsec,romsec);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
sprintf((char *)sdata,"C %u %u 256\r",romadd,ramadd);
ser_senddata(sdata,strlen((char *)sdata));
if(get_return_code()) return(1);
romadd+=256;
ramadd+=256;
}
return(0);
}
