/*
* Take a line of input and process it, return TRUE if profanity is to
* continue, FALSE otherwise
*/
gboolean
process_input(char *inp)
{
log_debug("Input received: %s", inp);
gboolean result = FALSE;
g_strstrip(inp);
// add line to history if something typed
if (strlen(inp) > 0) {
cmd_history_append(inp);
}
// just carry on if no input
if (strlen(inp) == 0) {
result = TRUE;
// handle command if input starts with a '/'
} else if (inp[0] == '/') {
char *inp_cpy = strdup(inp);
char *command = strtok(inp_cpy, " ");
result = cmd_execute(command, inp);
free(inp_cpy);
// call a default handler if input didn't start with '/'
} else {
result = cmd_execute_default(inp);
}
ui_input_clear();
roster_reset_search_attempts();
return result;
}
void serverlist_connect() {
static char cmd[100];
int i;
for (i = 1; i < cmd_argc(); i++) {
char *string = cmd_argv(i);
int id = atoi(string);
if (string[0] && id >= 0 && id < server_count) {
sprintf(cmd, "connect %s %d", serverlist[id].address, serverlist[id].port);
cmd_execute(cmd_client(), cmd);
} else {
ui_output(cmd_client(), "Invalid id: %d.\n", id);
}
}
}
void
sock_recv_and_exec(int sock)
{
char msg[64];
if(sock_recv_msg(sock, msg, sizeof(msg)) == -1)
return;
if(!strcmp(msg, VITUNES_RUNNING))
return;
if(!kb_execute_by_name(msg))
cmd_execute(msg);
}
/*
* The common entry for processing command.
*/
static void
cmd_received(cmd_t *cmd, boolean_t *quit, struct timespec *timeout)
{
boolean_t badcmd, execute;
int cmd_id = CMD_ID(cmd);
execute = B_TRUE;
*quit = B_FALSE;
switch (cmd_id) {
case CMD_QUIT_ID:
*quit = B_TRUE;
return;
case CMD_RESIZE_ID:
/*
* The screen resize signal would trigger this
* command. Destroy existing screen and curses
* resources and then re-init the curses resources.
*/
win_fix_fini();
page_win_destroy();
reg_curses_fini();
if (reg_curses_init(B_FALSE)) {
win_fix_init();
} else {
execute = B_FALSE;
}
timeout_set(timeout, DISP_DEFAULT_INTVAL);
break;
case CMD_REFRESH_ID:
/*
* User hit the hotkey 'R' to refresh current window.
*/
timeout_set(timeout, DISP_DEFAULT_INTVAL);
break;
}
if (execute) {
cmd_execute(cmd, &badcmd);
}
}
int main(int argc, char** argv)
{
char command[MAXLEN];
char **arguments;
while(1)
{
printf("5550558721 Supanat Potiwarakorn > ");
if (fgets(command, MAXLEN, stdin) == '\n');
if (tokenize(command, DELIMITERS, &arguments) < 0) {
fprintf(stderr, "Failed to parse command");
exit(1);
}
if (strcasecmp(arguments[0], "exit") == 0) exit(EXIT_SUCCESS); // exiting command
cmd_execute(arguments); // create a new child process for execution
}
}
int io_handle_enter(int x, int y) {
char* line = NULL;
line = rl_copy_text(0, rl_end);
rl_set_prompt("");
rl_replace_line("", 1);
rl_redisplay();
cmd_execute(line);
if (strcmp(line, "") != 0) {
add_history(line);
}
free(line);
rl_set_prompt(prompt);
rl_redisplay();
/* force readline to think that the current line was "eaten" and executed */
rl_done = 1;
return 0;
}
void launcher (char *commbuff, FlowSource_t *FlowSource, char *process, int expire) {
FlowSource_t *fs;
struct sigaction act;
char *args[MAXARGS];
int pid, stat;
srecord_t *InfoRecord;
InfoRecord = (srecord_t *)commbuff;
syslog(LOG_INFO, "Launcher: Startup. auto-expire %s", expire ? "enabled" : "off" );
done = launch = child_exit = 0;
// process may be NULL, if we only expire data files
if ( process ) {
char *cmd = NULL;
srecord_t TestRecord;
// check for valid command expansion
strncpy(TestRecord.fname, "test", FNAME_SIZE-1);
TestRecord.fname[FNAME_SIZE-1] = 0;
strncpy(TestRecord.tstring, "200407110845", 15);
TestRecord.tstring[15] = 0;
TestRecord.tstamp = 1;
fs = FlowSource;
while ( fs ) {
cmd = cmd_expand(&TestRecord, fs->Ident, fs->datadir, process);
if ( cmd == NULL ) {
syslog(LOG_ERR, "Launcher: ident: %s, Unable to expand command: '%s'", fs->Ident, process);
exit(255);
}
fs = fs->next;
}
}
/* Signal handling */
memset((void *)&act,0,sizeof(struct sigaction));
act.sa_handler = SignalHandler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGCHLD, &act, NULL); // child process terminated
sigaction(SIGTERM, &act, NULL); // we are done
sigaction(SIGINT, &act, NULL); // we are done
sigaction(SIGHUP, &act, NULL); // run command
while ( !done ) {
// sleep until we get signaled
syslog(LOG_DEBUG, "Launcher: Sleeping");
select(0, NULL, NULL, NULL, NULL);
syslog(LOG_DEBUG, "Launcher: Wakeup");
if ( launch ) { // SIGHUP
launch = 0;
if ( process ) {
char *cmd = NULL;
fs = FlowSource;
while ( fs ) {
// Expand % placeholders
cmd = cmd_expand(InfoRecord, fs->Ident, fs->datadir, process);
if ( cmd == NULL ) {
syslog(LOG_ERR, "Launcher: ident: %s, Unable to expand command: '%s'", fs->Ident, process);
continue;
}
// printf("Launcher: run command: '%s'\n", cmd);
syslog(LOG_DEBUG, "Launcher: ident: %s run command: '%s'", fs->Ident, cmd);
// prepare args array
cmd_parse(cmd, args);
if ( args[0] )
cmd_execute(args);
// do not flood the system with new processes
sleep(1);
// else cmd_parse already reported the error
free(cmd);
fs = fs->next;
}
}
fs = FlowSource;
while ( fs ) {
if ( expire )
do_expire(fs->datadir);
fs = fs->next;
}
}
if ( child_exit ) {
syslog(LOG_INFO, "laucher child exit %d childs.", child_exit);
while ( (pid = waitpid (-1, &stat, WNOHANG)) > 0 ) {
if ( WIFEXITED(stat) ) {
syslog(LOG_DEBUG, "launcher child %i exit status: %i", pid, WEXITSTATUS(stat));
}
if ( WIFSIGNALED(stat) ) {
syslog(LOG_WARNING, "laucher child %i died due to signal %i", pid, WTERMSIG(stat));
}
child_exit--;
}
syslog(LOG_INFO, "laucher waiting childs done. %d childs", child_exit);
child_exit = 0;
}
if ( done ) {
syslog(LOG_INFO, "Launcher: Terminating.");
}
}
waitpid (-1, &stat, 0);
// we are done
syslog(LOG_INFO, "Launcher: exit.");
} // End of launcher
static int main_cmd(int argc, char *argv[])
{
if (argc < 1) {
return help();
}
char *cmd = *argv++; argc--;
if (contains(cmd, "key")) {
if (argc < 2) {
return help();
}
uint32_t lockkey = strtoul(argv[0], NULL, 0);
hdhomerun_device_tuner_lockkey_use_value(hd, lockkey);
cmd = argv[1];
argv+=2; argc-=2;
}
if (contains(cmd, "get")) {
if (argc < 1) {
return help();
}
return cmd_get(argv[0]);
}
if (contains(cmd, "set")) {
if (argc < 2) {
return help();
}
return cmd_set(argv[0], argv[1]);
}
if (contains(cmd, "scan")) {
if (argc < 1) {
return help();
}
if (argc < 2) {
return cmd_scan(argv[0], NULL);
} else {
return cmd_scan(argv[0], argv[1]);
}
}
if (contains(cmd, "save")) {
if (argc < 2) {
return help();
}
return cmd_save(argv[0], argv[1]);
}
if (contains(cmd, "upgrade")) {
if (argc < 1) {
return help();
}
return cmd_upgrade(argv[0]);
}
if (contains(cmd, "execute")) {
return cmd_execute();
}
return help();
}
/** @brief Main loop.
*/
int main(void)
{
#ifdef INIT_CODE
do{ INIT_CODE }while(0);
#endif
/* interruptions not used, moving interrupt vector not needed
IVCR = (1<<IVCE);
IVCR = (1<<IVSEL);
*/
#ifdef ENABLE_UART
// UART init (all values have been already computed)
UBRRxH = UART_UBRR_VAL>>8;
UBRRxL = UART_UBRR_VAL;
UCSRxA = UART_U2X_VAL;
UCSRxB = (1<<RXENx) | (1<<TXENx);
UCSRxC = UART_NBITS_VAL | UART_PARITY_VAL | UART_STOP_BIT_VAL;
#endif
#ifdef ENABLE_I2C_SLAVE
// I2C init
TWAR = I2C_ADDR << 1;
TWCR = (1<<TWIE)|(1<<TWEN)|(1<<TWINT)|(1<<TWEA);
#endif
#ifdef ENABLE_UART
SEND_MESSAGE("boot ENTER");
#endif
// timeout before booting
uint8_t i = (BOOT_TIMEOUT)*F_CPU/(65536*4*1000);
for(;;) {
// detect activity from client
// set the proto_* method if needed
// from UART
#ifdef ENABLE_UART
if( (UCSRxA & (1<<RXCx)) ) {
// UART is the default for proto_*
break;
}
#endif
// from I2C
#ifdef ENABLE_I2C_SLAVE
if( (TWCR & (1<<TWINT)) ) {
#ifdef ENABLE_UART
proto_send = i2cs_send;
proto_recv = i2cs_recv;
#endif
break;
}
#endif
if( i == 0 ) {
boot(); // timeout
}
i--;
_delay_loop_2(0); // 65536*4 cycles
}
for(;;) {
const uint8_t c = recv_u8();
if( c == 0x00 ) {
continue; // null command: ignore
} else if( c == 0xff ) {
// failure command
reply_failure();
}
else if( c == 'i' ) cmd_infos();
else if( c == 'm' ) cmd_mirror();
#ifndef DISABLE_EXECUTE
else if( c == 'x' ) cmd_execute();
#endif
#ifndef DISABLE_PROG_PAGE
else if( c == 'p' ) cmd_prog_page();
#endif
#ifndef DISABLE_MEM_CRC
else if( c == 'c' ) cmd_mem_crc();
#endif
#ifndef DISABLE_FUSE_READ
else if( c == 'f' ) cmd_fuse_read();
#endif
#ifndef DISABLE_COPY_PAGES
else if( c == 'y' ) cmd_copy_pages();
#endif
#ifdef ENABLE_I2C_MASTER
else if( c == '<' ) cmd_i2c_recv();
else if( c == '>' ) cmd_i2c_send();
#endif
else {
reply_error(STATUS_UNKNOWN_COMMAND);
}
}
return 1;
}
/* ARGSUSED */
static void *
disp_handler(void *arg)
{
disp_flag_t flag;
int status = 0;
cmd_t cmd;
boolean_t quit, pagelist_inited = B_FALSE;
struct timespec timeout;
uint64_t start_ms;
int64_t diff_ms;
/*
* Wait cons thread to complete initialization.
*/
if (!consthr_init_wait()) {
debug_print(NULL, 2, "Timeout for waiting cons thread to "
"complete initialization\n");
/*
* The cons thread should exit with error or startup failed,
* disp thread stops running.
*/
goto L_EXIT;
}
/*
* NumaTOP contains multiple windows. It uses double linked list
* to link all of windows.
*/
page_list_init();
pagelist_inited = B_TRUE;
timeout_set(&timeout, 0);
start_ms = current_ms();
for (;;) {
status = 0;
(void) pthread_mutex_lock(&s_disp_ctl.mutex);
flag = s_disp_ctl.flag;
while (flag == DISP_FLAG_NONE) {
status = pthread_cond_timedwait(&s_disp_ctl.cond,
&s_disp_ctl.mutex, &timeout);
flag = s_disp_ctl.flag;
if (status == ETIMEDOUT) {
break;
}
}
if (flag == DISP_FLAG_CMD) {
(void) memcpy(&cmd, &s_disp_ctl.cmd, sizeof (cmd));
}
s_disp_ctl.flag = DISP_FLAG_NONE;
(void) pthread_mutex_unlock(&s_disp_ctl.mutex);
diff_ms = current_ms() - start_ms;
if (g_run_secs <= diff_ms / MS_SEC) {
g_run_secs = TIME_NSEC_MAX;
debug_print(NULL, 2,
"disp: it's time to exit\n");
continue;
}
if ((status == ETIMEDOUT) && (flag == DISP_FLAG_NONE)) {
if (page_current_get() == NULL) {
timeout_set(&timeout, DISP_DEFAULT_INTVAL);
continue;
}
/*
* Force a 'refresh' operation.
*/
CMD_ID_SET(&cmd, CMD_REFRESH_ID);
cmd_execute(&cmd, NULL);
timeout_set(&timeout, DISP_DEFAULT_INTVAL);
continue;
}
switch (flag) {
case DISP_FLAG_QUIT:
debug_print(NULL, 2,
"disp: received DISP_FLAG_QUIT\n");
goto L_EXIT;
case DISP_FLAG_CMD:
cmd_received(&cmd, &quit, &timeout);
if (quit) {
debug_print(NULL, 2,
"disp thread received CMD_QUIT_ID\n");
goto L_EXIT;
}
break;
case DISP_FLAG_PROFILING_DATA_READY:
case DISP_FLAG_CALLCHAIN_DATA_READY:
case DISP_FLAG_LL_DATA_READY:
case DISP_FLAG_PQOS_CMT_READY:
/*
* Show the page.
*/
(void) page_next_execute(B_FALSE);
timeout_set(&timeout, DISP_DEFAULT_INTVAL);
break;
case DISP_FLAG_PROFILING_DATA_FAIL:
case DISP_FLAG_CALLCHAIN_DATA_FAIL:
case DISP_FLAG_LL_DATA_FAIL:
case DISP_FLAG_PQOS_CMT_FAIL:
/*
* Received the notification that the perf counting
* was failed.
*/
debug_print(NULL, 2,
"disp: profiling/callchain/LL data failed.\n");
disp_go_home();
break;
case DISP_FLAG_SCROLLUP:
/*
* User hits the "UP" key.
*/
key_scroll(SCROLL_UP);
if (status == ETIMEDOUT) {
timeout_set(&timeout, DISP_DEFAULT_INTVAL);
}
break;
case DISP_FLAG_SCROLLDOWN:
/*
* User hits the "DOWN" key.
*/
key_scroll(SCROLL_DOWN);
if (status == ETIMEDOUT) {
timeout_set(&timeout, DISP_DEFAULT_INTVAL);
}
break;
case DISP_FLAG_SCROLLENTER:
/*
* User selects a scroll item and hit the "ENTER".
*/
scroll_enter();
if (status == ETIMEDOUT) {
timeout_set(&timeout, DISP_DEFAULT_INTVAL);
}
break;
default:
break;
}
}
L_EXIT:
if (pagelist_inited) {
page_list_fini();
}
/*
* Let the perf thread exit first.
*/
perf_fini();
debug_print(NULL, 2, "disp thread is exiting\n");
return (NULL);
}
int process_dcload_udp(ether_header_t *ether, ip_header_t *ip, udp_header_t *udp)
{
ip_udp_pseudo_header_t *pseudo;
unsigned short i;
command_t *command;
if (tool_ip && (tool_port != ntohs(udp->src) || tool_ip != ntohl(ip->src)))
return -1;
pseudo = (ip_udp_pseudo_header_t *)pkt_buf;
pseudo->src_ip = ip->src;
pseudo->dest_ip = ip->dest;
pseudo->zero = 0;
pseudo->protocol = ip->protocol;
pseudo->udp_length = udp->length;
pseudo->src_port = udp->src;
pseudo->dest_port = udp->dest;
pseudo->length = udp->length;
pseudo->checksum = 0;
memset(pseudo->data, 0, ntohs(udp->length) - 8 + (ntohs(udp->length)%2));
memcpy(pseudo->data, udp->data, ntohs(udp->length) - 8);
/* checksum == 0 means no checksum */
if (udp->checksum != 0)
i = checksum((unsigned short *)pseudo, (sizeof(ip_udp_pseudo_header_t) + ntohs(udp->length) - 9 + 1)/2);
else
i = 0;
/* checksum == 0xffff means checksum was really 0 */
if (udp->checksum == 0xffff)
udp->checksum = 0;
if (i != udp->checksum) {
/* scif_puts("UDP CHECKSUM BAD\n"); */
return -1;
}
if (!tool_ip) {
printf("Set dc-tool IP to 0x%x, port %d\n", ntohl(ip->src), ntohs(udp->src));
tool_ip = ntohl(ip->src);
tool_port = ntohs(udp->src);
memcpy(tool_mac, ether->src, 6);
} else {
/* if (tool_ip != ntohs(ip->src)) */
/* return -1; */
}
make_ether(ether->src, ether->dest, (ether_header_t *)pkt_buf);
command = (command_t *)udp->data;
/* printf("Received command '%c%c%c%c'\n", */
/* command->id[0], */
/* command->id[1], */
/* command->id[2], */
/* command->id[3]); */
if (!memcmp(command->id, CMD_EXECUTE, 4)) {
cmd_execute(ether, ip, udp, command);
} else
if (!memcmp(command->id, CMD_REBOOT, 4)) {
cmd_reboot(ip, udp, command);
} else
if (!memcmp(command->id, CMD_LOADBIN, 4)) {
cmd_loadbin(ip, udp, command);
} else
if (!memcmp(command->id, CMD_PARTBIN, 4)) {
cmd_partbin(ip, udp, command);
} else
if (!memcmp(command->id, CMD_DONEBIN, 4)) {
cmd_donebin(ip, udp, command);
} else
if (!memcmp(command->id, CMD_SENDBINQ, 4)) {
cmd_sendbinq(ip, udp, command);
} else
if (!memcmp(command->id, CMD_SENDBIN, 4)) {
cmd_sendbin(ip, udp, command);
} else
if (!memcmp(command->id, CMD_VERSION, 4)) {
cmd_version(ip, udp, command);
} else
if (!memcmp(command->id, CMD_RETVAL, 4)) {
cmd_retval(ip, udp, command);
} else {
tool_ip = 0;
return -1;
}
return 0;
}
