/* 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;
}
}
