/* Pickup on activity and process it. Processing may mean a number of things: * - to try an accept() on a server socket (ignoring it upon EAGAIN) * - to trigger a thread that is hoping writing after EAGAIN * - to read a message and further process it */ void process_activity (int sox, int soxidx, struct soxinfo *soxi, short int revents) { if (revents & POLLOUT) { //TODO// signal waiting thread that it may continue tlog (TLOG_UNIXSOCK, LOG_CRIT, "Eekk!! Could send a packet?!? Unregistering client"); unregister_client_socket_byindex (soxidx); close (sox); } if (revents & POLLIN) { if (soxi->flags & SOF_SERVER) { struct sockaddr sa; socklen_t salen = sizeof (sa); int newsox = accept (sox, &sa, &salen); if (newsox != -1) { tlog (TLOG_UNIXSOCK, LOG_NOTICE, "Received incoming connection. Registering it"); register_client_socket (newsox); } } if (soxi->flags & SOF_CLIENT) { struct command *cmd = allocate_command_for_clientfd (sox); if (receive_command (sox, cmd)) { process_command (cmd); } else { tlog (TLOG_UNIXSOCK, LOG_ERR, "Failed to receive command request"); } } } }
/** * @brief CDC_Receive_FS * Data received over USB OUT endpoint are sent over CDC interface * through this function. * * @note * This function will block any OUT packet reception on USB endpoint * untill exiting this function. If you exit this function before transfer * is complete on CDC interface (ie. using DMA controller) it will result * in receiving more data while previous ones are still not sent. * * @param Buf: Buffer of data to be received * @param Len: Number of data received (in bytes) * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]); USBD_CDC_ReceivePacket(&hUsbDeviceFS); receive_command(Buf); return (USBD_OK); /* USER CODE END 6 */ }
int main(int argc, char** argv) { // open clients <-> gateway message queue mqd_t mq = open_msg_queue(MQ_NAME); if (mq == (mqd_t)-1) exit(EXIT_FAILURE); // open gateway <-> servers message queues create_server_mqs(); Command cmd; int ret = receive_command(mq, &cmd); if (ret == -1) exit(EXIT_FAILURE); Command *command = &cmd; int server_id = command->crypt[0]; while(strcmp(command->name, "exit") != 0) { server_id = command->crypt[0] - 1; // if there are no more actions to take if (server_id == -2) unlock_client(command->name); else { // forward command to server send_command(server_mqs[server_id], command); } ret = receive_command(mq, command); if (ret == -1) exit(EXIT_FAILURE); } // send the exit command to the servers int i; for (i = 0; i < NUM_SERVERS; i++) send_command(server_mqs[i], command); close_server_mqs(); mq_close(mq); return 0; }
int init_world(t_client *cl, t_graph *fx) { char *cmd; cmd = receive_command(cl->sock); if (strcmp(cmd, "BIENVENUE") == 0) return (receive_start_conf(cl, fx)); else { printf("Error: \033[31mNot receive %s\n", NAME); return (-1); } return (0); }
void state_default() { char buf[MAXLEN]; int ret; if(previous_state != STATE_DEFAULT) { previous_state = STATE_DEFAULT; } FD_ZERO(&readfds); FD_SET(client_socket, &readfds); ret = select(client_socket+1, &readfds, NULL, NULL, NULL); if(ret < 0) { PRINT_ERROR("Error in select()\n") state = STATE_SHUTDOWN; return; } if(FD_ISSET(client_socket, &readfds)) { ret = receive_command(client_socket, (char *) &buf); if(ret == 0) { if (state_changed(buf, state)) { strcpy(buf, "< ok >"); send(client_socket, buf, strlen(buf), 0); return; } else { PRINT_ERROR("unknown command '%s'\n", buf); strcpy(buf, "< error unknown command >"); send(client_socket, buf, strlen(buf), 0); } } else { state = STATE_SHUTDOWN; return; } } else { ret = read(client_socket, &buf, 0); if(ret==-1) { state = STATE_SHUTDOWN; return; } } }
/* trap handler: main entry point */ int __trap_to_gdb(struct cpu_user_regs *regs, unsigned long cookie) { int rc = 0; unsigned long flags; if ( gdb_ctx->serhnd < 0 ) { printk("Debugging connection not set up.\n"); return -EBUSY; } /* We rely on our caller to ensure we're only on one processor * at a time... We should probably panic here, but given that * we're a debugger we should probably be a little tolerant of * things going wrong. */ /* We don't want to use a spin lock here, because we're doing two distinct things: 1 -- we don't want to run on more than one processor at a time, and 2 -- we want to do something sensible if we re-enter ourselves. Spin locks are good for 1, but useless for 2. */ if ( !atomic_dec_and_test(&gdb_ctx->running) ) { printk("WARNING WARNING WARNING: Avoiding recursive gdb.\n"); atomic_inc(&gdb_ctx->running); return -EBUSY; } if ( !gdb_ctx->connected ) { printk("GDB connection activated.\n"); gdb_arch_print_state(regs); gdb_ctx->connected = 1; } gdb_smp_pause(); local_irq_save(flags); watchdog_disable(); console_start_sync(); /* Shouldn't really do this, but otherwise we stop for no obvious reason, which is Bad */ printk("Waiting for GDB to attach...\n"); gdb_arch_enter(regs); gdb_ctx->signum = gdb_arch_signal_num(regs, cookie); /* If gdb is already attached, tell it we've stopped again. */ if ( gdb_ctx->currently_attached ) { gdb_start_packet(gdb_ctx); gdb_cmd_signum(gdb_ctx); } do { if ( receive_command(gdb_ctx) < 0 ) { dbg_printk("Error in GDB session...\n"); rc = -EIO; break; } } while ( process_command(regs, gdb_ctx) == 0 ); gdb_smp_resume(); gdb_arch_exit(regs); console_end_sync(); watchdog_enable(); atomic_inc(&gdb_ctx->running); local_irq_restore(flags); return rc; }
void state_isotp() { int i, items, ret; char rxmsg[MAXLEN]; /* can to inet */ char buf[MAXLEN]; /* inet commands to can */ unsigned char isobuf[ISOTPLEN+1]; /* binary buffer for isotp socket */ unsigned char tmp; if(previous_state == STATE_ISOTP) { state_isotp_init(); previous_state = STATE_ISOTP; } FD_ZERO(&readfds); FD_SET(si, &readfds); FD_SET(client_socket, &readfds); /* * Check if there are more elements in the element buffer before calling select() and * blocking for new packets. */ if(more_elements) { FD_CLR(si, &readfds); } else { ret = select((si > client_socket)?si+1:client_socket+1, &readfds, NULL, NULL, NULL); if(ret < 0) { PRINT_ERROR("Error in select()\n") change_state(STATE_SHUTDOWN); return; } } if (FD_ISSET(si, &readfds)) { struct timeval tv = {0}; items = read(si, isobuf, ISOTPLEN); /* read timestamp data */ if(ioctl(si, SIOCGSTAMP, &tv) < 0) { PRINT_ERROR("Could not receive timestamp\n"); } if (items > 0 && items <= ISOTPLEN) { int startlen; sprintf(rxmsg, "< pdu %ld.%06ld ", tv.tv_sec, tv.tv_usec); startlen = strlen(rxmsg); for (i=0; i < items; i++) sprintf(rxmsg + startlen + 2*i, "%02X", isobuf[i]); sprintf(rxmsg + strlen(rxmsg), " >"); send(client_socket, rxmsg, strlen(rxmsg), 0); } } if (FD_ISSET(client_socket, &readfds)) { ret = receive_command(client_socket, buf); if(ret != 0) { change_state(STATE_SHUTDOWN); return; } if ( (ret = state_changed(buf, state)) ) { if(ret == CONTROL_SWITCH_STATE) state_isotp_deinit(); strcpy(buf, "< ok >"); send(client_socket, buf, strlen(buf), 0); return; } #if 0 if(!strcmp("< echo >", buf)) { send(client_socket, buf, strlen(buf), 0); return; } if(!strncmp("< sendpdu ", buf, 10)) { items = element_length(buf, 2); if (items & 1) { PRINT_ERROR("odd number of ASCII Hex values\n"); return; } items /= 2; if (items > ISOTPLEN) { PRINT_ERROR("PDU too long\n"); return; } for (i = 0; i < items; i++) { tmp = asc2nibble(buf[(2*i) + 10]); if (tmp > 0x0F) return; isobuf[i] = (tmp << 4); tmp = asc2nibble(buf[(2*i) + 11]); if (tmp > 0x0F) return; isobuf[i] |= tmp; } ret = write(si, isobuf, items); if(ret != items) { PRINT_ERROR("Error in write()\n") change_state(STATE_SHUTDOWN); return; } } else { PRINT_ERROR("unknown command '%s'.\n", buf) strcpy(buf, "< error unknown command >"); send(client_socket, buf, strlen(buf), 0); } #else ret = decode_command(buf); switch(ret) { case COMMAND_ECHO: send(client_socket, buf, strlen(buf), 0); break; case COMMAND_SENDPDU: items = element_length(buf, 2); if (items & 1) { PRINT_ERROR("odd number of ASCII Hex values\n"); return; } items /= 2; if (items > ISOTPLEN) { PRINT_ERROR("PDU too long\n"); return; } for (i = 0; i < items; i++) { tmp = asc2nibble(buf[(2*i) + 10]); if (tmp > 0x0F) return; isobuf[i] = (tmp << 4); tmp = asc2nibble(buf[(2*i) + 11]); if (tmp > 0x0F) return; isobuf[i] |= tmp; } ret = write(si, isobuf, items); if(ret != items) { PRINT_ERROR("Error in write()\n") change_state(STATE_SHUTDOWN); return; } break; /* COMMAND_SENDPDU */ case COMMAND_UNKNOWN: default: PRINT_ERROR("unknown command '%s'.\n", buf) strcpy(buf, "< error unknown command >"); send(client_socket, buf, strlen(buf), 0); break; /* COMMAND_UNKNOWN */ } #endif } }
void state_isotp_init() { int items, ret; struct sockaddr_can addr; struct ifreq ifr; static struct can_isotp_options opts; static struct can_isotp_fc_options fcopts; char buf[MAXLEN]; /* inet commands to can */ while(previous_state != STATE_ISOTP) { ret = receive_command(client_socket, buf); if(ret != 0) { change_state(STATE_SHUTDOWN); return; } strncpy(ifr.ifr_name, bus_name, IFNAMSIZ); if ( (ret = state_changed(buf, state)) ) { /* ensure proper handling in other states */ if(ret == CONTROL_SWITCH_STATE) previous_state = STATE_ISOTP; strcpy(buf, "< ok >"); send(client_socket, buf, strlen(buf), 0); return; } #if 0 if(!strcmp("< echo >", buf)) { send(client_socket, buf, strlen(buf), 0); continue; } memset(&opts, 0, sizeof(opts)); memset(&fcopts, 0, sizeof(fcopts)); memset(&addr, 0, sizeof(addr)); /* get configuration to open the socket */ if(!strncmp("< isotpconf ", buf, 12)) { items = sscanf(buf, "< %*s %x %x %x " "%hhu %hhx %hhu " "%hhx %hhx %hhx %hhx >", &addr.can_addr.tp.tx_id, &addr.can_addr.tp.rx_id, &opts.flags, &fcopts.bs, &fcopts.stmin, &fcopts.wftmax, &opts.txpad_content, &opts.rxpad_content, &opts.ext_address, &opts.rx_ext_address); /* < isotpconf XXXXXXXX ... > check for extended identifier */ if(element_length(buf, 2) == 8) addr.can_addr.tp.tx_id |= CAN_EFF_FLAG; if(element_length(buf, 3) == 8) addr.can_addr.tp.rx_id |= CAN_EFF_FLAG; if (((opts.flags & CAN_ISOTP_RX_EXT_ADDR) && items < 10) || ((opts.flags & CAN_ISOTP_EXTEND_ADDR) && items < 9) || ((opts.flags & CAN_ISOTP_RX_PADDING) && items < 8) || ((opts.flags & CAN_ISOTP_TX_PADDING) && items < 7) || (items < 5)) { PRINT_ERROR("Syntax error in isotpconf command\n"); /* try it once more */ continue; } /* open ISOTP socket */ if ((si = socket(PF_CAN, SOCK_DGRAM, CAN_ISOTP)) < 0) { PRINT_ERROR("Error while opening ISOTP socket %s\n", strerror(errno)); /* ensure proper handling in other states */ previous_state = STATE_ISOTP; state_isotp_deinit(); change_state(STATE_SHUTDOWN); return; } strcpy(ifr.ifr_name, bus_name); if(ioctl(si, SIOCGIFINDEX, &ifr) < 0) { PRINT_ERROR("Error while searching for bus %s\n", strerror(errno)); /* ensure proper handling in other states */ previous_state = STATE_ISOTP; state_isotp_deinit(); change_state(STATE_SHUTDOWN); return; } addr.can_family = PF_CAN; addr.can_ifindex = ifr.ifr_ifindex; /* only change the built-in defaults when required */ if (opts.flags) setsockopt(si, SOL_CAN_ISOTP, CAN_ISOTP_OPTS, &opts, sizeof(opts)); setsockopt(si, SOL_CAN_ISOTP, CAN_ISOTP_RECV_FC, &fcopts, sizeof(fcopts)); PRINT_VERBOSE("binding ISOTP socket...\n") if (bind(si, (struct sockaddr *)&addr, sizeof(addr)) < 0) { PRINT_ERROR("Error while binding ISOTP socket %s\n", strerror(errno)); /* ensure proper handling in other states */ previous_state = STATE_ISOTP; state_isotp_deinit(); change_state(STATE_SHUTDOWN); return; } /* ok we made it and have a proper isotp socket open */ previous_state = STATE_ISOTP; } #else ret = decode_command(buf); switch(ret) { case COMMAND_ECHO: send(client_socket, buf, strlen(buf), 0); continue; break; case COMMAND_ISOTPCONF: memset(&opts, 0, sizeof(opts)); memset(&fcopts, 0, sizeof(fcopts)); memset(&addr, 0, sizeof(addr)); /* get configuration to open the socket */ items = sscanf(buf, "< %*s %x %x %x " "%hhu %hhx %hhu " "%hhx %hhx %hhx %hhx >", &addr.can_addr.tp.tx_id, &addr.can_addr.tp.rx_id, &opts.flags, &fcopts.bs, &fcopts.stmin, &fcopts.wftmax, &opts.txpad_content, &opts.rxpad_content, &opts.ext_address, &opts.rx_ext_address); /* < isotpconf XXXXXXXX ... > check for extended identifier */ if(element_length(buf, 2) == 8) addr.can_addr.tp.tx_id |= CAN_EFF_FLAG; if(element_length(buf, 3) == 8) addr.can_addr.tp.rx_id |= CAN_EFF_FLAG; if (((opts.flags & CAN_ISOTP_RX_EXT_ADDR) && items < 10) || ((opts.flags & CAN_ISOTP_EXTEND_ADDR) && items < 9) || ((opts.flags & CAN_ISOTP_RX_PADDING) && items < 8) || ((opts.flags & CAN_ISOTP_TX_PADDING) && items < 7) || (items < 5)) { PRINT_ERROR("Syntax error in isotpconf command\n"); /* try it once more */ continue; } /* open ISOTP socket */ if ((si = socket(PF_CAN, SOCK_DGRAM, CAN_ISOTP)) < 0) { PRINT_ERROR("Error while opening ISOTP socket %s\n", strerror(errno)); /* ensure proper handling in other states */ previous_state = STATE_ISOTP; state_isotp_deinit(); change_state(STATE_SHUTDOWN); return; } strcpy(ifr.ifr_name, bus_name); if(ioctl(si, SIOCGIFINDEX, &ifr) < 0) { PRINT_ERROR("Error while searching for bus %s\n", strerror(errno)); /* ensure proper handling in other states */ previous_state = STATE_ISOTP; state_isotp_deinit(); change_state(STATE_SHUTDOWN); return; } addr.can_family = PF_CAN; addr.can_ifindex = ifr.ifr_ifindex; /* only change the built-in defaults when required */ if (opts.flags) setsockopt(si, SOL_CAN_ISOTP, CAN_ISOTP_OPTS, &opts, sizeof(opts)); setsockopt(si, SOL_CAN_ISOTP, CAN_ISOTP_RECV_FC, &fcopts, sizeof(fcopts)); PRINT_VERBOSE("binding ISOTP socket...\n") if (bind(si, (struct sockaddr *)&addr, sizeof(addr)) < 0) { PRINT_ERROR("Error while binding ISOTP socket %s\n", strerror(errno)); /* ensure proper handling in other states */ previous_state = STATE_ISOTP; state_isotp_deinit(); change_state(STATE_SHUTDOWN); return; } /* ok we made it and have a proper isotp socket open */ previous_state = STATE_ISOTP; break; case COMMAND_UNKNOWN: default: break; } /* switch */ #endif } /* while */
int main(int argc, char **argv) { int i, found; struct sockaddr_in clientaddr; socklen_t sin_size = sizeof(clientaddr); struct sigaction signalaction, sigint_action; sigset_t sigset; char buf[MAXLEN]; int c; char* busses_string; #ifdef HAVE_LIBCONFIG config_t config; #endif /* set default config settings */ port = PORT; description = malloc(sizeof(BEACON_DESCRIPTION)); strcpy(description, BEACON_DESCRIPTION); interface_string = malloc(strlen("eth0")+ 1); strcpy(interface_string, "eth0"); busses_string = malloc(strlen("vcan0")+ 1); strcpy(busses_string, "vcan0"); #ifdef HAVE_LIBCONFIG /* Read config file before parsing commandline arguments */ config_init(&config); if(CONFIG_TRUE == config_read_file(&config, "/etc/socketcand.conf")) { config_lookup_int(&config, "port", (long int*) &port); config_lookup_string(&config, "description", (const char**) &description); config_lookup_string(&config, "busses", (const char**) &busses_string); config_lookup_string(&config, "listen", (const char**) &interface_string); } #endif /* Parse commandline arguments */ while (1) { /* getopt_long stores the option index here. */ int option_index = 0; static struct option long_options[] = { {"verbose", no_argument, 0, 'v'}, {"interfaces", required_argument, 0, 'i'}, {"port", required_argument, 0, 'p'}, {"listen", required_argument, 0, 'l'}, {"daemon", no_argument, 0, 'd'}, {"version", no_argument, 0, 'z'}, {"no-beacon", no_argument, 0, 'n'}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "vhni:p:l:d", long_options, &option_index); if (c == -1) break; switch (c) { case 0: /* If this option set a flag, do nothing else now. */ if (long_options[option_index].flag != 0) break; break; case 'v': puts ("Verbose output activated\n"); verbose_flag = 1; break; case 'p': port = atoi(optarg); break; case 'i': busses_string = realloc(busses_string,strlen(optarg)); strcpy(busses_string, optarg); break; case 'l': interface_string = realloc(interface_string, strlen(optarg)); strcpy(interface_string, optarg); break; case 'h': print_usage(); return 0; case 'd': daemon_flag=1; break; case 'z': printf("socketcand version '%s'\n", PACKAGE_VERSION); return 0; case 'n': disable_beacon=1; break; case '?': print_usage(); return 0; default: print_usage(); return -1; } } /* parse busses */ for(i=0;;i++) { if(busses_string[i] == '\0') break; if(busses_string[i] == ',') interface_count++; } interface_count++; interface_names = malloc(sizeof(char *) * interface_count); interface_names[0] = strtok(busses_string, ","); for(i=1;i<interface_count;i++) { interface_names[i] = strtok(NULL, ","); } /* if daemon mode was activated the syslog must be opened */ if(daemon_flag) { openlog("socketcand", 0, LOG_DAEMON); } sigemptyset(&sigset); signalaction.sa_handler = &childdied; signalaction.sa_mask = sigset; signalaction.sa_flags = 0; sigaction(SIGCHLD, &signalaction, NULL); /* signal for dying child */ sigint_action.sa_handler = &sigint; sigint_action.sa_mask = sigset; sigint_action.sa_flags = 0; sigaction(SIGINT, &sigint_action, NULL); if((sl = socket(PF_INET, SOCK_STREAM, 0)) < 0) { perror("inetsocket"); exit(1); } #ifdef DEBUG if(verbose_flag) printf("setting SO_REUSEADDR\n"); i = 1; if(setsockopt(sl, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) <0) { perror("setting SO_REUSEADDR failed"); } #endif determine_adress(); if(!disable_beacon) { PRINT_VERBOSE("creating broadcast thread...\n") i = pthread_create(&beacon_thread, NULL, &beacon_loop, NULL); if(i) PRINT_ERROR("could not create broadcast thread.\n"); } else { PRINT_VERBOSE("Discovery beacon disabled\n"); } PRINT_VERBOSE("binding socket to %s:%d\n", inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port)) if(bind(sl,(struct sockaddr*)&saddr, sizeof(saddr)) < 0) { perror("bind"); exit(-1); } if (listen(sl,3) != 0) { perror("listen"); exit(1); } while (1) { client_socket = accept(sl,(struct sockaddr *)&clientaddr, &sin_size); if (client_socket > 0 ){ int flag; flag = 1; setsockopt(client_socket, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(flag)); if (fork()) close(client_socket); else break; } else { if (errno != EINTR) { /* * If the cause for the error was NOT the * signal from a dying child => give an error */ perror("accept"); exit(1); } } } PRINT_VERBOSE("client connected\n") #ifdef DEBUG PRINT_VERBOSE("setting SO_REUSEADDR\n") i = 1; if(setsockopt(client_socket, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) <0) { perror("setting SO_REUSEADDR failed"); } #endif /* main loop with state machine */ while(1) { switch(state) { case STATE_NO_BUS: if(previous_state != STATE_NO_BUS) { strcpy(buf, "< hi >"); send(client_socket, buf, strlen(buf), 0); previous_state = STATE_NO_BUS; } /* client has to start with a command */ i = receive_command(client_socket, (char *) &buf); if(i != 0) { PRINT_ERROR("Connection terminated while waiting for command.\n"); state = STATE_SHUTDOWN; break; } if(!strncmp("< open ", buf, 7)) { sscanf(buf, "< open %s>", bus_name); /* check if access to this bus is allowed */ found = 0; for(i=0;i<interface_count;i++) { if(!strcmp(interface_names[i], bus_name)) found = 1; } if(found) { strcpy(buf, "< ok >"); send(client_socket, buf, strlen(buf), 0); state = STATE_BCM; break; } else { PRINT_INFO("client tried to access unauthorized bus.\n"); strcpy(buf, "< error could not open bus >"); send(client_socket, buf, strlen(buf), 0); state = STATE_SHUTDOWN; } } else { PRINT_ERROR("unknown command '%s'.\n", buf) strcpy(buf, "< error unknown command >"); send(client_socket, buf, strlen(buf), 0); } break; case STATE_BCM: state_bcm(); break; case STATE_RAW: state_raw(); break; case STATE_CONTROL: state_control(); break; case STATE_SHUTDOWN: PRINT_VERBOSE("Closing client connection.\n"); close(client_socket); return 0; } } return 0; }
void main(void){ //------------------------------------------------------------------------------ // Main Program // This is the main routine for the program. Execution of code starts here. // The operating system is Back Ground Fore Ground. // //------------------------------------------------------------------------------ init_ports(); Init_Clocks(); Init_Conditions(); init_timers(); five_msec_delay(QUARTER_SECOND); Init_LCD(); setup_sw_debounce(); init_adc(); P1OUT |= IR_LED; init_serial_uart(); WDTCTL = WDTPW + WDTHOLD; setup_pwm(); set_motor_speed(R_FORWARD, PWM_RES); set_motor_speed(L_FORWARD, PWM_RES); unsigned int time_sequence = START_VAL; // counter for switch loop unsigned int previous_count = START_VAL; // automatic variable for // comparing timer_count unsigned int display_count = START_VAL; is_follow_running = FALSE; //------------------------------------------------------------------------------ // Begining of the "While" Operating System //------------------------------------------------------------------------------ while(ALWAYS) { // Can the Operating system run if(get_timer_count() > display_count + QUARTER_SECOND) { display_count = get_timer_count(); Display_Process(); time_sequence = START_VAL; } update_switches(); // Check for switch state change update_menu(); if(is_follow_running) run_follow(); if(uca0_is_message_received()) { BufferString message = uca0_read_buffer(TRUE); receive_command(message.head + message.offset); } if(uca1_is_message_received()) { update_menu(); BufferString message = uca1_read_buffer(TRUE); uca0_transmit_message(message.head, message.offset); if(find(WIFI_COMMAND_SYMBOL, message)) { receive_command(message.head + message.offset); } if(find(LOST_WIFI_COMMAND_SYMBOL, message)) { receive_command(CONNECT_NCSU); } } if(time_sequence > SECOND_AND_A_QUARTER) time_sequence = START_VAL; unsigned int current_timer_count = get_timer_count(); if(current_timer_count > previous_count) { previous_count = current_timer_count % UINT_16_MAX; time_sequence++; } } //------------------------------------------------------------------------------ }
int main(int argc, char** argv) { if (argc < 2) { fprintf(stderr, "Too few arguments given to server.\n./server N\n"); exit(EXIT_FAILURE); } int server_id = atoi(argv[1]); pdecryptf_t decrypt = choose_decryption(server_id); char mq_name[13]; sprintf(mq_name, "/mq_server_%d", server_id); mqd_t mq = open_msg_queue(mq_name); Command cmd; int ret = receive_command(mq, &cmd); if (ret == -1) exit(EXIT_FAILURE); Command *command = &cmd; mqd_t ret_mq; while(strcmp(command->name, "exit") != 0) { //open shared memory char* shm_name = command->name; int shm_size = command->dim; int shm_fd; void* mem = open_shared_memory(shm_name, shm_size, &shm_fd); if (mem == NULL) { exit(EXIT_FAILURE); } // get size of the message from the first // integer in the shared memory int dim_message; memcpy(&dim_message, mem, sizeof(int)); // decrypt message void* out = malloc(1000); int decrypt_size = decrypt(mem+sizeof(int), dim_message, out); // copy result back in shared memory memcpy(mem, &decrypt_size, sizeof(int)); memcpy(mem + sizeof(int), out, decrypt_size); // Close shared memory close_shared_memory(mem, shm_size, shm_fd, shm_name); // Send message back to gateway with self removed int i; for (i = 1; i < 17; i++) command->crypt[i-1] = command->crypt[i]; ret_mq = open_msg_queue(MQ_GATEWAY); ret = send_command(ret_mq, command); if (ret == -1) exit(EXIT_FAILURE); mq_close(ret_mq); // Get another message from the mq ret = receive_command(mq, command); if (ret == -1) exit(EXIT_FAILURE); } mq_close(mq); mq_close(ret_mq); return 0; }
void receive_command(char* command) { BufferString temp_command; temp_command.head = command; temp_command.offset = START_ZERO; if(compare(command, COMMAND_AKNOWLEDGE)) { uca0_transmit_message(AKNOWLEDGE_MESSAGE, NO_OFFSET); } else if(compare(command, SLOW_BAUD)) { uca1_set_current_baud(BAUD_115200); uca0_transmit_message(SLOW_BAUD_MESSAGE, NO_OFFSET); uca1_transmit_message(SLOW_BAUD_COMMAND, NO_OFFSET); five_msec_delay(SECOND + SECOND); uca1_transmit_message(SAVE_COMMAND, NO_OFFSET); five_msec_delay(SECOND); uca1_set_current_baud(BAUD_9600); uca1_transmit_message(RESET_COMMAND, NO_OFFSET); PJOUT &= ~IOT_RESET; five_msec_delay(QUARTER_SECOND); PJOUT |= IOT_RESET; uca0_transmit_message(RESET_MESSAGE, NO_OFFSET); five_msec_delay(QUARTER_SECOND); uca1_transmit_message(G_MAC_COMMAND, NO_OFFSET); } else if(compare(command, FAST_BAUD)) { uca1_set_current_baud(BAUD_9600); uca0_transmit_message(FAST_BAUD_MESSAGE, NO_OFFSET); uca1_transmit_message(FAST_BAUD_COMMAND, NO_OFFSET); five_msec_delay(SECOND + SECOND); uca1_transmit_message(SAVE_COMMAND, NO_OFFSET); five_msec_delay(SECOND); uca1_set_current_baud(BAUD_115200); uca1_transmit_message(RESET_COMMAND, NO_OFFSET); PJOUT &= ~IOT_RESET; five_msec_delay(QUARTER_SECOND); PJOUT |= IOT_RESET; uca0_transmit_message(RESET_MESSAGE, NO_OFFSET); } else if(compare(command, CONNECT_NCSU)) { uca0_transmit_message(CONNECT_NCSU_MESSAGE, NO_OFFSET); uca1_transmit_message(SET_SSID_NCSU_COMMAND, NO_OFFSET); uca1_transmit_message(GET_SSID_NCSU_COMMAND, NO_OFFSET); five_msec_delay(QUARTER_SECOND); uca1_transmit_message(SET_HOST_NAME_COMMAND, NO_OFFSET); uca1_transmit_message(GET_HOST_NAME_COMMAND, NO_OFFSET); five_msec_delay(QUARTER_SECOND); uca1_transmit_message(SET_PRIVACY_MODE_COMMAND, NO_OFFSET); uca1_transmit_message(GET_PRIVACY_MODE_COMMAND, NO_OFFSET); five_msec_delay(QUARTER_SECOND); uca1_transmit_message(SET_NETWORK_MODE_COMMAND, NO_OFFSET); uca1_transmit_message(GET_NETWORK_MODE_COMMAND, NO_OFFSET); uca1_transmit_message(SAVE_COMMAND, NO_OFFSET); uca1_transmit_message(GET_NETWORK_MODE_COMMAND, NO_OFFSET); uca1_transmit_message(SAVE_COMMAND, NO_OFFSET); five_msec_delay(QUARTER_SECOND); uca1_transmit_message(RESET_COMMAND, NO_OFFSET); PJOUT &= ~IOT_RESET; five_msec_delay(QUARTER_SECOND); PJOUT |= IOT_RESET; uca0_transmit_message(RESET_MESSAGE, NO_OFFSET); } else if(compare(command, GET_WIFI_STATUS)) { uca1_transmit_message(GET_WIFI_STATUS_COMMAND, NO_OFFSET); } else if(compare(command, GET_WIFI_IP)) { uca1_transmit_message(GET_WIFI_IP_COMMAND, NO_OFFSET); } // Forward Command else if(find(CAR_FORWARD, temp_command)) { display_1 = CLEAR_LINE; display_2 = command; display_3 = CLEAR_LINE; display_4 = CLEAR_LINE; set_motor_speed(R_FORWARD, (int) (MAX_SPEED * 0.87f)); set_motor_speed(L_FORWARD, MAX_SPEED); lcd_BIG_mid(); five_msec_delay(QUARTER_SECOND); Display_Process(); uca0_transmit_message("SUCCESS", NO_OFFSET); turn_on_motor(R_FORWARD); turn_on_motor(L_FORWARD); if(CH_TO_DIG(command[COMMAND_TIME_POS]) <= 9) five_msec_delay(SECOND * CH_TO_DIG(command[COMMAND_TIME_POS]) / COMMAND_TURN_RATIO); turn_off_motor(R_FORWARD); turn_off_motor(L_FORWARD); lcd_4line(); if(command[COMMAND_LENGTH] == COMMAND_CHAR_SYMBOL) receive_command(command + COMMAND_LENGTH); } // Backward Command else if(find(CAR_BACKWARD, temp_command)) { display_1 = CLEAR_LINE; display_2 = command; display_3 = CLEAR_LINE; display_4 = CLEAR_LINE; lcd_BIG_mid(); five_msec_delay(QUARTER_SECOND); Display_Process(); uca0_transmit_message("SUCCESS", NO_OFFSET); turn_on_motor(R_REVERSE); turn_on_motor(L_REVERSE); five_msec_delay(SECOND * CH_TO_DIG(command[COMMAND_TIME_POS])); turn_off_motor(R_REVERSE); turn_off_motor(L_REVERSE); lcd_4line(); if(command[COMMAND_LENGTH] == COMMAND_CHAR_SYMBOL) receive_command(command + COMMAND_LENGTH); } // Right Command else if(find(CAR_RIGHT, temp_command)) { display_1 = CLEAR_LINE; display_2 = command; display_3 = CLEAR_LINE; display_4 = CLEAR_LINE; lcd_BIG_mid(); five_msec_delay(QUARTER_SECOND); Display_Process(); uca0_transmit_message("SUCCESS", NO_OFFSET); turn_on_motor(R_REVERSE); turn_on_motor(L_FORWARD); if(CH_TO_DIG(command[COMMAND_TIME_POS]) <= 9) five_msec_delay(SECOND * CH_TO_DIG(command[COMMAND_TIME_POS]) / COMMAND_TURN_RATIO); turn_off_motor(R_REVERSE); turn_off_motor(L_FORWARD); lcd_4line(); if(command[COMMAND_LENGTH] == COMMAND_CHAR_SYMBOL) receive_command(command + COMMAND_LENGTH); } // Left Command else if(find(CAR_LEFT, temp_command)) { display_1 = CLEAR_LINE; display_2 = command; display_3 = CLEAR_LINE; display_4 = CLEAR_LINE; lcd_BIG_mid(); five_msec_delay(QUARTER_SECOND); Display_Process(); uca0_transmit_message("SUCCESS", NO_OFFSET); turn_on_motor(R_FORWARD); turn_on_motor(L_REVERSE); if(CH_TO_DIG(command[COMMAND_TIME_POS]) <= 9) five_msec_delay(SECOND * CH_TO_DIG(command[COMMAND_TIME_POS]) / COMMAND_TURN_RATIO); turn_off_motor(R_FORWARD); turn_off_motor(L_REVERSE); lcd_4line(); if(command[COMMAND_LENGTH] == COMMAND_CHAR_SYMBOL) receive_command(command + COMMAND_LENGTH); } else if(find(CAR_LINE_FOLLOW, temp_command)) { is_follow_running = is_follow_running ? FALSE : TRUE; } }