void cmd_buf_handler() { gchar **cmd_strv; gint strv_len, i; do { cmd_strv = g_strsplit(control_service_data.cmd_buf->str, "\n", CMD_BUF_PIECES); strv_len = g_strv_length(cmd_strv); if (strv_len == 0) { g_strfreev(cmd_strv); return; } for (i = 0; i < strv_len - 1; i++) { if (strlen(cmd_strv[i]) > 0) { g_print("Cmd was : \"%s\"\n", cmd_strv[i]); cmd_handler(cmd_strv[i]); } } g_string_free(control_service_data.cmd_buf, TRUE); control_service_data.cmd_buf = g_string_new_len(cmd_strv[strv_len - 1], strlen(cmd_strv[strv_len -1])); g_strfreev(cmd_strv); } while (strv_len == CMD_BUF_PIECES); }
void cmd_poll() { while (HAL_OK == UART_WaitOnFlagUntilTimeout(&huart1, UART_FLAG_RXNE, RESET, 0)) { cmd_handler(); } }
void cmdPoll() { while (Serial.available()) { cmd_handler(); } }
/* * Function: main * Description: main function calls functions for intialization and * command verification, excution and finalization */ int main(int argc, char *argv[]) { int ret = 0; WIMAX_API_RET wmxStatus; parsed_cmd out_cmd; //checking user priviledge //Disabled permission checking so non-root can run it // if (geteuid() != (uid_t) 0) { // fprintf(stderr, // "ERROR: You do not possess sufficient privileges to perform this action.\n"); // return 1; // } // validate user command if (validate_cmd(argc, argv, &out_cmd) != 0) { wimaxcu_main_help(); return 1; } // If user requested to diplay the help if (out_cmd.cmd == CMD_HELP) { wimaxcu_main_help(); return 0; } memset(&gbl_device_id, 0, sizeof(WIMAX_API_DEVICE_ID)); // Request for READ_WRITE Permissions // TODO: Kalyan Can we request for permissions based on the command? // For example for status Read permission is sufficient. gbl_device_id.privilege = WIMAX_API_PRIVILEGE_READ_WRITE; //Signal to handle Ctrl+C signal(SIGINT, wimaxcu_stop_signal_handler); signal(SIGTERM, wimaxcu_stop_signal_handler); // Initialize the SDK (CommonAPI) wmxStatus = wimaxcu_initialize(&gbl_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { printf("ERROR: Make sure WiMAX Network Service is running.\n"); return 1; } // Kalyan 5.0.09 merge // This delay will allow the Initialize to init everything in its threads // sleep(1); // Execute the command ret = cmd_handler(&gbl_device_id, &out_cmd); // Finalize the SDK wimaxcu_finalize(&gbl_device_id); return ret; }
void ums_run_once() { uint8_t nextByte; // disabled until complete enable string is received while (umsEnabled < UMS_ENABLE_LEN && pf_receive_byte(&nextByte) != 0) { if (nextByte == UMS_ENABLE[umsEnabled]) { ++umsEnabled; if (umsEnabled == UMS_ENABLE_LEN) { ums_send_accept(); } } else { umsEnabled = 0; } } // not disabled, normal operation if (umsEnabled == UMS_ENABLE_LEN) { // if the stepper queue is full, then we don't process any more commands while (!st_full()) { uint8_t *rx = cmd_receive(); if (rx != NULL) { cmd_handler(rx); commandCounter++; } else { break; } } } // send a status when limit switches change or ~1e6 stepper delay ticks have elapsed if (umsLimits != previousLimits || umsRunTime > nextStatusTime || (umsStatus & UMS_SEND_STATUS_NOW) != 0) { previousLimits = umsLimits; nextStatusTime += UMS_STATUS_INTERVAL; ums_send_status(); umsStatus &= ~UMS_SEND_STATUS_NOW; } }
void udp_rx2_handler(void *arg, struct udp_pcb *upcb, struct pbuf *p, struct ip_addr *addr, u16_t port) { int i; uint8_t* prx_udp_msg = (uint8_t*)&rx_udp_msg[SNTP]; struct pbuf *pbuffer = p; if(p->tot_len <= rx_udp_msg_size) { while(1) { for(i = 0; i < pbuffer->len; i++) { prx_udp_msg[i] = *(((uint8_t*)pbuffer->payload)+i); } if(pbuffer->next == NULL) break; else pbuffer = pbuffer->next; } cmd_handler(SNTP); } pbuf_free(p); }
int main() { print_header(); while (1) { printf("(aprime) "); char cmd[20]; fgets(cmd, sizeof(cmd), stdin); bool integer = true; for (i=0; i < strlen(cmd)-1; i++) { if (!isdigit(cmd[i])) { integer = false; break; } } if (integer == true) { int input; sscanf(cmd, "%d", &input); assess_primality(input); } else { cmd_handler(cmd); } } }
void ieee_mainloop(void) { int16_t cmd = 0; set_error(ERROR_DOSVERSION); ieee_data.bus_state = BUS_IDLE; ieee_data.device_state = DEVICE_IDLE; for(;;) { switch(ieee_data.bus_state) { case BUS_SLEEP: /* BUS_SLEEP */ set_atn_irq(0); ieee_bus_idle(); set_error(ERROR_OK); set_busy_led(0); uart_puts_P(PSTR("ieee.c/sleep ")); set_dirty_led(1); /* Wait until the sleep key is used again */ while (!key_pressed(KEY_SLEEP)) system_sleep(); reset_key(KEY_SLEEP); set_atn_irq(1); update_leds(); ieee_data.bus_state = BUS_IDLE; break; case BUS_IDLE: /* BUS_IDLE */ ieee_bus_idle(); while(IEEE_ATN) { ; /* wait for ATN */ if (key_pressed(KEY_NEXT | KEY_PREV | KEY_HOME)) { change_disk(); } else if (key_pressed(KEY_SLEEP)) { reset_key(KEY_SLEEP); ieee_data.bus_state = BUS_SLEEP; break; } else if (display_found && key_pressed(KEY_DISPLAY)) { display_service(); reset_key(KEY_DISPLAY); } system_sleep(); } if (ieee_data.bus_state != BUS_SLEEP) ieee_data.bus_state = BUS_FOUNDATN; break; case BUS_FOUNDATN: /* BUS_FOUNDATN */ ieee_data.bus_state = BUS_ATNPROCESS; cmd = ieee_getc(); break; case BUS_ATNPROCESS: /* BUS_ATNPROCESS */ if(cmd < 0) { uart_putc('c'); ieee_data.bus_state = BUS_IDLE; break; } else cmd &= 0xFF; uart_puts_p("ATN "); uart_puthex(cmd); uart_putcrlf(); if (cmd == 0x3f) { /* UNLISTEN */ if(ieee_data.device_state == DEVICE_LISTEN) { ieee_data.device_state = DEVICE_IDLE; uart_puts_p("UNLISTEN\r\n"); } ieee_data.bus_state = BUS_IDLE; break; } else if (cmd == 0x5f) { /* UNTALK */ if(ieee_data.device_state == DEVICE_TALK) { ieee_data.device_state = DEVICE_IDLE; uart_puts_p("UNTALK\r\n"); } ieee_data.bus_state = BUS_IDLE; break; } else if (cmd == (0x40 + device_address)) { /* TALK */ uart_puts_p("TALK "); uart_puthex(device_address); uart_putcrlf(); ieee_data.device_state = DEVICE_TALK; /* disk drives never talk immediatly after TALK, so stay idle and wait for a secondary address given by 0x60-0x6f DATA */ ieee_data.bus_state = BUS_IDLE; break; } else if (cmd == (0x20 + device_address)) { /* LISTEN */ ieee_data.device_state = DEVICE_LISTEN; uart_puts_p("LISTEN "); uart_puthex(device_address); uart_putcrlf(); ieee_data.bus_state = BUS_IDLE; break; } else if ((cmd & 0xf0) == 0x60) { /* DATA */ /* 8250LP sends data while ATN is still active, so wait for bus controller to release ATN or we will misinterpret data as a command */ while(!IEEE_ATN); if(ieee_data.device_state == DEVICE_LISTEN) { cmd = ieee_listen_handler(cmd); cmd_handler(); break; } else if (ieee_data.device_state == DEVICE_TALK) { ieee_data.secondary_address = cmd & 0x0f; uart_puts_p("DATA T "); uart_puthex(ieee_data.secondary_address); uart_putcrlf(); if(ieee_talk_handler() == TIMEOUT_ABORT) { ieee_data.device_state = DEVICE_IDLE; } ieee_data.bus_state = BUS_IDLE; break; } else { ieee_data.bus_state = BUS_IDLE; break; } } else if (ieee_data.device_state == DEVICE_IDLE) { ieee_data.bus_state = BUS_IDLE; break; /* ----- if we reach this, we're LISTENer or TALKer ----- */ } else if ((cmd & 0xf0) == 0xe0) { /* CLOSE */ ieee_data.secondary_address = cmd & 0x0f; uart_puts_p("CLOSE "); uart_puthex(ieee_data.secondary_address); uart_putcrlf(); /* Close all buffers if sec. 15 is closed */ if(ieee_data.secondary_address == 15) { free_multiple_buffers(FMB_USER_CLEAN); } else { /* Close a single buffer */ buffer_t *buf; buf = find_buffer (ieee_data.secondary_address); if (buf != NULL) { buf->cleanup(buf); free_buffer(buf); } } ieee_data.bus_state = BUS_IDLE; break; } else if ((cmd & 0xf0) == 0xf0) { /* OPEN */ cmd = ieee_listen_handler(cmd); cmd_handler(); break; } else { /* Command for other device or unknown command */ ieee_data.bus_state = BUS_IDLE; } break; } /* switch */ } /* for() */ }
uint8_t cmd_interpret(uint8_t * cmd, uint8_t * result) { return cmd_handler(cmd[0],cmd+1,result); }
int run_shell() { char *command; char *commandtmp; char *cmd_token; char *arg_token; int cmd_arr_length = sizeof(cmd_arr) / sizeof(char *); /* gets length of command array */ int prompt = '$'; int i; int invalid_cmd; int bytes_read; int nbytes = BYTE_LIM; set_env_vars(); printf("Welcome to failshell!\n"); /* allocates appropriate mem to command, limiting user's command and setting up temporary container string to split */ command = (char *) malloc(nbytes); commandtmp = (char *) malloc(sizeof(command)); if (commandtmp == NULL) return OOM; /* if no space left to allocate (highly unlikely...) */ /* the main loop that powers the shell */ while (run_signal != EOF) { invalid_cmd = TRUE; printf("%s %s %c ", user, pwd, prompt); /* get command string from user and place into address pointed at by *command */ bytes_read = getline(&command, (size_t *) &nbytes, stdin); if (bytes_read == EOF) /* bytes_read will only = EOF if some IO error or interrupt (including Ctrl+D) */ return EOF; strcpy(commandtmp, command); cmd_token = (char *) malloc(sizeof(command)); arg_token = (char *) malloc(sizeof(command)); /* split entered command into tokens for command argument and second argument i.e., $0 and $1 */ cmd_token = strtok(commandtmp, DELIMITER); arg_token = strtok(NULL, DELIMITER); /* had problems with '\n' value being put into strings, which messed up comparisons later; this takes them out if they exist */ if (arg_token == NULL) trim_line_break(cmd_token); /* if no argument */ else trim_line_break(arg_token); /* compares entered command with all valid commands, allowing handler to execute command if valid */ for (i = 0; i < cmd_arr_length; i++) { if (strcmp(cmd_token, cmd_arr[i]) == 0) { invalid_cmd = FALSE; cmd_handler(i, arg_token); } } /* don't print error message if user entered valid command or if they didn't enter anything */ if (invalid_cmd && strlen(cmd_token) > 1) printf("Command \"%s\" is invalid. Type \"%s\" for assistance.\n", cmd_token, cmd_arr[4]); } return 0; }