void handle_synchro_timeout(socket_internal_t *current_socket) { msg_t send; if (thread_getstatus(current_socket->recv_pid) == STATUS_RECEIVE_BLOCKED) { if ((current_socket->socket_values.tcp_control.no_of_retries == 0) && (timex_sub(vtimer_now(), current_socket->socket_values.tcp_control.last_packet_time).microseconds > TCP_SYN_INITIAL_TIMEOUT)) { current_socket->socket_values.tcp_control.no_of_retries++; net_msg_send(&send, current_socket->recv_pid, 0, TCP_RETRY); // printf("FIRST RETRY!\n"); } else if ((current_socket->socket_values.tcp_control.no_of_retries > 0) && (timex_sub(vtimer_now(), current_socket->socket_values.tcp_control.last_packet_time).microseconds > (current_socket->socket_values.tcp_control.no_of_retries * TCP_SYN_TIMEOUT + TCP_SYN_INITIAL_TIMEOUT))) { current_socket->socket_values.tcp_control.no_of_retries++; if (current_socket->socket_values.tcp_control.no_of_retries > TCP_MAX_SYN_RETRIES) { net_msg_send(&send, current_socket->recv_pid, 0, TCP_TIMEOUT); // printf("TCP SYN TIMEOUT!!\n"); } else { net_msg_send(&send, current_socket->recv_pid, 0, TCP_RETRY); // printf("NEXT RETRY!\n"); } } } }
void handle_synchro_timeout(socket_internal_t *current_socket) { msg_t send; if (thread_getstatus(current_socket->recv_pid) == STATUS_RECEIVE_BLOCKED) { timex_t now; vtimer_now(&now); if ((current_socket->socket_values.tcp_control.no_of_retries == 0) && (timex_uint64(timex_sub(now, current_socket->socket_values.tcp_control.last_packet_time)) > TCP_SYN_INITIAL_TIMEOUT)) { current_socket->socket_values.tcp_control.no_of_retries++; net_msg_send(&send, current_socket->recv_pid, 0, TCP_RETRY); } else if ((current_socket->socket_values.tcp_control.no_of_retries > 0) && (timex_uint64(timex_sub(now, current_socket->socket_values.tcp_control.last_packet_time)) > (current_socket->socket_values.tcp_control.no_of_retries * TCP_SYN_TIMEOUT + TCP_SYN_INITIAL_TIMEOUT))) { current_socket->socket_values.tcp_control.no_of_retries++; if (current_socket->socket_values.tcp_control.no_of_retries > TCP_MAX_SYN_RETRIES) { net_msg_send(&send, current_socket->recv_pid, 0, TCP_TIMEOUT); } else { net_msg_send(&send, current_socket->recv_pid, 0, TCP_RETRY); } } } }
void handle_established(socket_internal_t *current_socket) { msg_t send; double current_timeout = current_socket->socket_values.tcp_control.rto; if (current_timeout < SECOND) { current_timeout = SECOND; } uint8_t i; if ((current_socket->socket_values.tcp_control.send_nxt > current_socket->socket_values.tcp_control.send_una) && (thread_getstatus(current_socket->send_pid) == STATUS_RECEIVE_BLOCKED)) { for(i = 0; i < current_socket->socket_values.tcp_control.no_of_retries; i++) { current_timeout *= 2; } if (current_timeout > TCP_ACK_MAX_TIMEOUT) { net_msg_send(&send, current_socket->send_pid, 0, TCP_TIMEOUT); // printf("GOT NO ACK: TIMEOUT!\n"); } else if (timex_sub(vtimer_now(), current_socket->socket_values.tcp_control.last_packet_time).microseconds > current_timeout) { // printReasBuffers(); current_socket->socket_values.tcp_control.no_of_retries++; net_msg_send(&send, current_socket->send_pid, 0, TCP_RETRY); // printf("GOT NO ACK YET, %i. RETRY! Now: %lu Before: %lu, Diff: %lu, Cur Timeout: %f\n", current_socket->socket_values.tcp_control.no_of_retries, // vtimer_now().microseconds, current_socket->socket_values.tcp_control.last_packet_time.microseconds, // vtimer_now().microseconds - current_socket->socket_values.tcp_control.last_packet_time.microseconds, // current_timeout); } } }
void handle_established(socket_internal_t *current_socket) { msg_t send; double current_timeout = current_socket->socket_values.tcp_control.rto; if (current_timeout < SECOND) { current_timeout = SECOND; } uint8_t i; if ((current_socket->socket_values.tcp_control.send_nxt > current_socket->socket_values.tcp_control.send_una) && (thread_getstatus(current_socket->send_pid) == STATUS_RECEIVE_BLOCKED)) { for (i = 0; i < current_socket->socket_values.tcp_control.no_of_retries; i++) { current_timeout *= 2; } timex_t now; vtimer_now(&now); if (current_timeout > TCP_ACK_MAX_TIMEOUT) { net_msg_send(&send, current_socket->send_pid, 0, TCP_TIMEOUT); } else if (timex_uint64(timex_sub(now, current_socket->socket_values.tcp_control.last_packet_time)) > current_timeout) { current_socket->socket_values.tcp_control.no_of_retries++; net_msg_send(&send, current_socket->send_pid, 0, TCP_RETRY); } } }
// Receive a NET msg from the OVMS server void net_msg_in(char* msg) { int k; if (net_msg_serverok == 0) { if (memcmppgm2ram(msg, (char const rom far*)"MP-S 0 ", 7) == 0) { net_msg_server_welcome(msg+7); } return; // otherwise ignore it } // Ok, we've got an encrypted message waiting for work. // The following is a nasty hack because base64decode doesn't like incoming // messages of length divisible by 4, and is really expecting a CRLF // terminated string, so we give it one... strcatpgm2ram(msg,(char const rom far*)"\r\n"); k = base64decode(msg,net_scratchpad); RC4_crypt(&rx_crypto1, &rx_crypto2, net_scratchpad, k); if (memcmppgm2ram(net_scratchpad, (char const rom far*)"MP-0 ", 5) == 0) { msg = net_scratchpad+5; switch (*msg) { case 'A': // PING strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 a"); if (net_msg_sendpending==0) { net_msg_start(); net_msg_encode_puts(); net_msg_send(); } break; case 'Z': // PEER connection if (msg[1] != '0') { net_apps_connected = 1; if (net_msg_sendpending==0) { net_msg_start(); net_msg_stat(); net_msg_gps(); net_msg_tpms(); net_msg_firmware(); net_msg_environment(); net_msg_send(); } } else { net_apps_connected = 0; } break; } } }
//////////////////////////////////////////////////////////////////////// // net_state_ticker60() // State Model: Per-minute ticker // This function is called approximately once per minute (since state // was first entered), and gives the state a timeslice for activity. // void net_state_ticker60(void) { switch (net_state) { case NET_STATE_READY: if (net_msg_sendpending>0) { net_granular_tick -= 5; // Try again in 5 seconds... return; } if ((net_link==1)&&(net_apps_connected>0)) { net_msg_start(); net_msg_stat(); net_msg_gps(); net_msg_tpms(); net_msg_environment(); net_msg_send(); } net_state_vchar = net_state_vchar ^ 1; delay100(2); net_puts_rom(NET_CREG_CIPSTATUS); break; } }
void handle_tcp_syn_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header, socket_internal_t *tcp_socket) { msg_t m_send_tcp; if (tcp_socket->socket_values.tcp_control.state == TCP_LISTEN) { socket_internal_t *new_socket = new_tcp_queued_socket(ipv6_header, tcp_header); if (new_socket != NULL) { #ifdef TCP_HC update_tcp_hc_context(true, new_socket, tcp_header); #endif /* notify socket function destiny_socket_accept(..) that a new * connection request has arrived. No need to wait for an answer * because the server destiny_socket_accept() function isnt reading * from anything other than the queued sockets */ net_msg_send(&m_send_tcp, tcp_socket->recv_pid, 0, TCP_SYN); } else { printf("Dropped TCP SYN Message because an error occured while "\ "requesting a new queued socket!\n"); } } else { printf("Dropped TCP SYN Message because socket was not in state TCP_LISTEN!"); } }
void handle_tcp_ack_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header, socket_internal_t *tcp_socket) { msg_t m_recv_tcp, m_send_tcp; uint8_t target_pid; if (tcp_socket->socket_values.tcp_control.state == TCP_LAST_ACK) { target_pid = tcp_socket->recv_pid; close_socket(tcp_socket); msg_send(&m_send_tcp, target_pid, 0); return; } else if (tcp_socket->socket_values.tcp_control.state == TCP_CLOSING) { msg_send(&m_send_tcp, tcp_socket->recv_pid, 0); msg_send(&m_send_tcp, tcp_socket->send_pid, 0); return; } else if (get_waiting_connection_socket(tcp_socket->socket_id, ipv6_header, tcp_header) != NULL) { m_send_tcp.content.ptr = (char *)tcp_header; net_msg_send_recv(&m_send_tcp, &m_recv_tcp, tcp_socket->recv_pid, TCP_ACK); return; } else if (tcp_socket->socket_values.tcp_control.state == TCP_ESTABLISHED) { if (check_tcp_consistency(&tcp_socket->socket_values, tcp_header, 0) == PACKET_OK) { m_send_tcp.content.ptr = (char *)tcp_header; net_msg_send(&m_send_tcp, tcp_socket->send_pid, 0, TCP_ACK); return; } } printf("NO WAY OF HANDLING THIS ACK!\n"); }
void net_msg_cmd_do(void) { CHECKPOINT(0x44) delay100(2); // commands 40-49 are special AT commands, thus, disable net_msg here if ((net_msg_cmd_code < 40) || (net_msg_cmd_code > 49)) net_msg_start(); // Execute cmd: ask car module to execute first: if ((vehicle_fn_commandhandler == NULL)|| (! vehicle_fn_commandhandler(TRUE, net_msg_cmd_code,net_msg_cmd_msg))) { // Car module does not feel responsible, fall back to standard: if( !net_msg_cmd_exec() ) { // No standard as well => return "unimplemented" STP_UNIMPLEMENTED(net_scratchpad, net_msg_cmd_code); net_msg_encode_puts(); } } // terminate IPSEND by Ctrl-Z (should this be disabled for commands 40-49 as well?) net_msg_send(); #ifdef OVMS_ACCMODULE acc_handle_msg(TRUE, net_msg_cmd_code, net_msg_cmd_msg); #endif // clear command net_msg_cmd_code = 0; net_msg_cmd_msg[0] = 0; }
void handle_tcp_fin_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header, socket_internal_t *tcp_socket) { (void) ipv6_header; msg_t m_send; socket_t *current_tcp_socket = &tcp_socket->socket_values; uint8_t send_buffer[BUFFER_SIZE]; ipv6_hdr_t *temp_ipv6_header = ((ipv6_hdr_t *)(&send_buffer)); tcp_hdr_t *current_tcp_packet = ((tcp_hdr_t *)(&send_buffer[IPV6_HDR_LEN])); set_tcp_cb(¤t_tcp_socket->tcp_control, tcp_header->seq_nr + 1, current_tcp_socket->tcp_control.send_wnd, tcp_header->ack_nr + 1, tcp_header->ack_nr, tcp_header->window); #ifdef TCP_HC current_tcp_socket->tcp_control.tcp_context.hc_type = COMPRESSED_HEADER; #endif if (current_tcp_socket->tcp_control.state == TCP_FIN_WAIT_1) { current_tcp_socket->tcp_control.state = TCP_CLOSING; send_tcp(tcp_socket, current_tcp_packet, temp_ipv6_header, TCP_FIN_ACK, 0); } else { current_tcp_socket->tcp_control.state = TCP_LAST_ACK; send_tcp(tcp_socket, current_tcp_packet, temp_ipv6_header, TCP_FIN_ACK, 0); } net_msg_send(&m_send, tcp_socket->recv_pid, 0, CLOSE_CONN); }
void net_msg_alarm(void) { char *p; delay100(2); net_msg_start(); strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PAVehicle alarm is sounding!"); net_msg_encode_puts(); net_msg_send(); }
void net_msg_valettrunk(void) { char *p; delay100(2); net_msg_start(); strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PATrunk has been opened (valet mode)."); net_msg_encode_puts(); net_msg_send(); }
void net_msg_socalert(void) { char *s; delay100(2); net_msg_start(); s = stp_i(net_scratchpad, "MP-0 PAALERT!!! CRITICAL SOC LEVEL APPROACHED (", car_SOC); // 95% s = stp_rom(s, "% SOC)"); net_msg_encode_puts(); net_msg_send(); }
void net_msg_erroralert(unsigned int errorcode, unsigned long errordata) { char *s; delay100(2); net_msg_start(); s = stp_s(net_scratchpad, "MP-0 PE", car_type); s = stp_ul(s, ",", (unsigned long)errorcode); s = stp_ul(s, ",", (unsigned long)errordata); net_msg_encode_puts(); net_msg_send(); }
void handle_tcp_syn_ack_packet(ipv6_hdr_t *ipv6_header, tcp_hdr_t *tcp_header, socket_internal_t *tcp_socket) { msg_t m_send_tcp; if (tcp_socket->socket_values.tcp_control.state == SYN_SENT) { m_send_tcp.content.ptr = (char *) tcp_header; net_msg_send(&m_send_tcp, tcp_socket->recv_pid, 0, TCP_SYN_ACK); } else { printf("Socket not in state SYN_SENT, dropping SYN-ACK-packet!"); } }
void net_msg_alert(void) { char *p; delay100(2); net_msg_start(); strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PA"); switch (car_chargemode) { case 0x00: strcatpgm2ram(net_scratchpad,(char const rom far *)"Standard - "); // Charge Mode Standard break; case 0x01: strcatpgm2ram(net_scratchpad,(char const rom far *)"Storage - "); // Storage break; case 0x03: strcatpgm2ram(net_scratchpad,(char const rom far *)"Range - "); // Range break; case 0x04: strcatpgm2ram(net_scratchpad,(char const rom far *)"Performance - "); // Performance } switch (car_chargestate) { case 0x01: strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging"); // Charge State Charging break; case 0x02: strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging, Topping off"); // Topping off break; case 0x04: strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging Done"); // Done break; default: strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging Stopped"); // Stopped } strcatpgm2ram(net_scratchpad,(char const rom far *)"\rIdeal Range: "); // Ideal Range p = par_get(PARAM_MILESKM); if (*p == 'M') // Kmh or Miles sprintf(net_msg_scratchpad, (rom far char*)"%u mi", car_idealrange); // Miles else sprintf(net_msg_scratchpad, (rom far char*)"%u Km", (unsigned int) ((float) car_idealrange * 1.609)); // Kmh strcat((char*)net_scratchpad,net_msg_scratchpad); strcatpgm2ram(net_scratchpad,(char const rom far *)" SOC: "); sprintf(net_msg_scratchpad, (rom far char*)"%u%%", car_SOC); // 95% strcat(net_scratchpad,net_msg_scratchpad); net_msg_encode_puts(); net_msg_send(); }
void net_msg_reply_ussd(char *buf, unsigned char buflen) { // called from net_state_activity() // buf contains a "+CUSD:" USSD command result // parse and return as command reply: char *s, *t = NULL; // Server not ready? abort // TODO: store, resend when server is connected if ((!net_msg_serverok) || (!buf) || (!buflen)) return; // isolate USSD reply text if (t = memchr((void *) buf, '"', buflen)) { ++t; buflen -= (t - buf); buf = t; // start of USSD string while ((*t) && (*t != '"') && ((t - buf) < buflen)) { if (*t == ',') // "escape" comma for MP-0 *t = '.'; t++; } *t = 0; // end of USSD string } // format reply: s = stp_i(net_scratchpad, "MP-0 c", CMD_SendUSSD); if (t) s = stp_s(s, ",0,", buf); else s = stp_rom(s, ",1,Invalid USSD result"); // send reply: if (net_msg_sendpending > 0) { delay100(20); // HACK... should buffer & retry later... but RAM is precious s = NULL; // flag } net_msg_start(); net_msg_encode_puts(); net_msg_send(); if (!s) delay100(20); // HACK: give modem additional time if there was sendpending>0 }
void net_msg_12v_alert(void) { char *s; delay100(2); net_msg_start(); if (can_minSOCnotified & CAN_MINSOC_ALERT_12V) s = stp_l2f(net_scratchpad, "MP-0 PAALERT!!! 12V BATTERY CRITICAL (", car_12vline, 1); else s = stp_l2f(net_scratchpad, "MP-0 PA12V BATTERY OK (", car_12vline, 1); s = stp_l2f(s, "V, ref=", car_12vline_ref, 1); s = stp_rom(s, "V)"); net_msg_encode_puts(); net_msg_send(); }
void net_msg_forward_sms(char *caller, char *SMS) { //Server not ready, stop sending //TODO: store this message inside buffer, resend it when server is connected if ((net_msg_serverok == 0)||(net_msg_sendpending)>0) return; delay100(2); net_msg_start(); strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PA"); strcatpgm2ram(net_scratchpad,(char const rom far*)"SMS FROM: "); strcat(net_scratchpad, caller); strcatpgm2ram(net_scratchpad,(char const rom far*)" - MSG: "); SMS[70]=0; // Hacky limit on the max size of an SMS forwarded strcat(net_scratchpad, SMS); net_msg_encode_puts(); net_msg_send(); }
void net_msg_reply_ussd(char *buf) { // called from net_state_activity() // buf contains a "+CUSD:" USSD command result // parse and return as command reply: char *s, *t = NULL; // Server not ready? abort // TODO: store, resend when server is connected if ((!net_msg_serverok) || (!buf)) return; // isolate USSD reply text if (t = strchr(buf, '"')) { buf = ++t; // start of USSD string while ((*t) && (*t != '"')) { if (*t == ',') // replace comma *t = '.'; t++; } *t = 0; // end of USSD string } // format reply: s = stp_i(net_scratchpad, "MP-0 c", CMD_SendUSSD); if (t) s = stp_s(s, ",0,", buf); else s = stp_rom(s, ",1,Invalid USSD result"); // send reply: if (net_msg_sendpending > 0) delay100(20); // HACK... should abort, buffer & retry later... net_msg_start(); net_msg_encode_puts(); net_msg_send(); }
//////////////////////////////////////////////////////////////////////// // net_state_ticker600() // State Model: Per-10-minute ticker // This function is called approximately once per ten minutes (since // state was first entered), and gives the state a timeslice for activity. // void net_state_ticker600(void) { switch (net_state) { case NET_STATE_READY: if ((net_link==1)&&(net_apps_connected==0)) { if (net_msg_sendpending>0) { net_granular_tick -= 5; // Try again in 5 seconds... } else { net_msg_start(); net_msg_stat(); net_msg_gps(); net_msg_tpms(); net_msg_environment(); net_msg_send(); } } break; } }
//////////////////////////////////////////////////////////////////////// // net_state_activity() // State Model: Some async data has been received // This is called to indicate to the state that a complete piece of async // data has been received in net_buf (with length net_buf_pos, and mode // net_buf_mode), and the data should be completely handled before // returning. // void net_state_activity() { if (net_buf_mode == NET_BUF_SMS) { // An SMS has arrived, and net_caller has been primed if ((net_reg != 0x01)&&(net_reg != 0x05)) { // Treat this as a network registration net_watchdog=0; // Disable watchdog, as we have connectivity net_reg = 0x05; led_net(1); } net_sms_in(net_caller,net_buf,net_buf_pos); return; } else if (net_buf_mode != NET_BUF_CRLF) { // An IP data message has arrived net_msg_in(net_buf); return; } switch (net_state) { case NET_STATE_DOINIT: if ((net_buf_pos >= 2)&&(net_buf[0] == 'O')&&(net_buf[1] == 'K')) { net_state_enter(NET_STATE_COPS); } break; case NET_STATE_COPS: if ((net_buf_pos >= 2)&&(net_buf[0] == 'O')&&(net_buf[1] == 'K')) net_state_enter(NET_STATE_DONETINIT); // COPS reconnect was OK else if ((net_buf_pos >= 5)&&(net_buf[0] == 'E')&&(net_buf[1] == 'R')) net_state_enter(NET_STATE_SOFTRESET); // Reset the entire async break; case NET_STATE_DONETINIT: if ((net_buf_pos >= 2)&& (net_buf[0] == 'E')&& (net_buf[1] == 'R')&& (net_state_vchar == 5)) // ERROR response to AT+CIFSR { // This is a nasty case. The GPRS has locked up. // The only solution I can find is a hard reset of the modem led_act(0); net_state_enter(NET_STATE_HARDRESET); } else if ((net_buf_pos >= 2)&& (((net_buf[0] == 'O')&&(net_buf[1] == 'K')))|| // OK (((net_buf[0] == 'S')&&(net_buf[1] == 'H')))|| // SHUT OK (net_state_vchar == 5)) // Local IP address { net_buf_pos = 0; net_timeout_ticks = 60; net_link = 0; delay100(1); switch (++net_state_vchar) { case 1: net_puts_rom("AT+CGDCONT=1,\"IP\",\""); net_puts_ram(par_get(PARAM_GPRSAPN)); net_puts_rom("\"\r"); break; case 2: net_puts_rom("AT+CSTT=\""); net_puts_ram(par_get(PARAM_GPRSAPN)); net_puts_rom("\",\""); net_puts_ram(par_get(PARAM_GPRSUSER)); net_puts_rom("\",\""); net_puts_ram(par_get(PARAM_GPRSPASS)); net_puts_rom("\"\r"); break; case 3: net_puts_rom("AT+CIICR\r"); break; case 4: net_puts_rom("AT+CIPHEAD=1\r"); break; case 5: net_puts_rom("AT+CIFSR\r"); break; case 6: net_puts_rom("AT+CLPORT=\"TCP\",\"6867\"\r"); break; case 7: net_puts_rom("AT+CIPSTART=\"TCP\",\""); net_puts_ram(par_get(PARAM_SERVERIP)); net_puts_rom("\",\"6867\"\r"); break; case 8: net_state_enter(NET_STATE_READY); break; } } else if ((net_buf_pos>=7)&& (memcmppgm2ram(net_buf, (char const rom far*)"+CREG: 0", 8) == 0)) { // Lost network connectivity during NETINIT net_state_enter(NET_STATE_SOFTRESET); } else if (memcmppgm2ram(net_buf, (char const rom far*)"+PDP: DEACT", 11) == 0) { // PDP couldn't be activated - try again... net_state_enter(NET_STATE_SOFTRESET); } break; case NET_STATE_READY: if (memcmppgm2ram(net_buf, (char const rom far*)"+CREG", 5) == 0) { // "+CREG" Network registration if (net_buf[8]==',') net_reg = net_buf[9]&0x07; // +CREG: 1,x else net_reg = net_buf[7]&0x07; // +CREG: x if ((net_reg == 0x01)||(net_reg == 0x05)) // Registered to network? { net_watchdog=0; // Disable watchdog, as we have connectivity led_net(1); } else if (net_watchdog == 0) { net_watchdog = 120; // We need connectivity within 120 seconds led_net(0); } } else if (memcmppgm2ram(net_buf, (char const rom far*)"+CLIP", 5) == 0) { // Incoming CALL if ((net_reg != 0x01)&&(net_reg != 0x05)) { // Treat this as a network registration net_watchdog=0; // Disable watchdog, as we have connectivity net_reg = 0x05; led_net(1); } delay100(1); net_puts_rom(NET_HANGUP); net_notify_status(); } else if (memcmppgm2ram(net_buf, (char const rom far*)"CONNECT OK", 10) == 0) { if (net_link == 0) { net_msg_start(); net_msg_register(); net_msg_send(); } net_link = 1; } else if (memcmppgm2ram(net_buf, (char const rom far*)"STATE: ", 7) == 0) { // Incoming CIPSTATUS if (memcmppgm2ram(net_buf, (char const rom far*)"STATE: CONNECT OK", 17) == 0) { if (net_link == 0) { net_msg_start(); net_msg_register(); net_msg_send(); } net_link = 1; } else { net_link = 0; if ((net_reg == 0x01)||(net_reg == 0x05)) { // We have a GSM network, but CIPSTATUS is not up net_msg_disconnected(); net_state_enter(NET_STATE_DONETINIT); } } } else if (memcmppgm2ram(net_buf, (char const rom far*)"SEND OK", 7) == 0) { net_msg_sendpending = 0; } else if ( (memcmppgm2ram(net_buf, (char const rom far*)"SEND FAIL", 9) == 0)|| (memcmppgm2ram(net_buf, (char const rom far*)"CLOSED", 6) == 0)|| (memcmppgm2ram(net_buf, (char const rom far*)"+CME ERROR", 10) == 0)|| (memcmppgm2ram(net_buf, (char const rom far*)"+PDP: DEACT", 11) == 0) ) { // Various GPRS error results // Re-initialize GPRS network and TCP socket net_msg_disconnected(); net_state_enter(NET_STATE_DONETINIT); } break; } }
// Receive a NET msg from the OVMS server void net_msg_in(char* msg) { int k; char s; if (net_msg_serverok == 0) { if (memcmppgm2ram(msg, (char const rom far*)"MP-S 0 ", 7) == 0) { net_msg_server_welcome(msg+7); net_granular_tick = 3590; // Nasty hack to force a status transmission in 10 seconds } return; // otherwise ignore it } // Ok, we've got an encrypted message waiting for work. // The following is a nasty hack because base64decode doesn't like incoming // messages of length divisible by 4, and is really expecting a CRLF // terminated string, so we give it one... CHECKPOINT(0x40) if (((strlen(msg)*4)/3) >= (NET_BUF_MAX-3)) { // Quick exit to reset link if incoming message is too big net_state_enter(NET_STATE_DONETINIT); return; } strcatpgm2ram(msg,(char const rom far*)"\r\n"); k = base64decode(msg,net_scratchpad); CHECKPOINT(0x41) RC4_crypt(&rx_crypto1, &rx_crypto2, net_scratchpad, k); if (memcmppgm2ram(net_scratchpad, (char const rom far*)"MP-0 ", 5) != 0) { net_state_enter(NET_STATE_DONETINIT); return; } msg = net_scratchpad+5; if ((*msg == 'E')&&(msg[1]=='M')) { // A paranoid-mode message from the server (or, more specifically, app) // The following is a nasty hack because base64decode doesn't like incoming // messages of length divisible by 4, and is really expecting a CRLF // terminated string, so we give it one... msg += 2; // Now pointing to the code just before encrypted paranoid message strcatpgm2ram(msg,(char const rom far*)"\r\n"); k = base64decode(msg+1,net_msg_scratchpad+1); RC4_setup(&pm_crypto1, &pm_crypto2, pdigest, MD5_SIZE); for (k=0;k<1024;k++) { net_scratchpad[0] = 0; RC4_crypt(&pm_crypto1, &pm_crypto2, net_scratchpad, 1); } RC4_crypt(&pm_crypto1, &pm_crypto2, net_msg_scratchpad+1, k); net_msg_scratchpad[0] = *msg; // The code // The message is now out of paranoid mode... msg = net_msg_scratchpad; } CHECKPOINT(0x42) switch (*msg) { case 'A': // PING strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 a"); if (net_msg_sendpending==0) { net_msg_start(); net_msg_encode_puts(); net_msg_send(); } break; case 'Z': // PEER connection if (msg[1] != '0') { net_apps_connected = 1; if (net_msg_sendpending==0) { net_msg_start(); net_msgp_stat(0); net_msgp_gps(0); net_msgp_tpms(0); net_msgp_firmware(0); net_msgp_environment(0); net_msg_send(); } } else { net_apps_connected = 0; } break; case 'h': // Historical data acknowledgement #ifdef OVMS_LOGGINGMODULE logging_ack(atoi(msg+1)); #endif // #ifdef OVMS_LOGGINGMODULE break; case 'C': // COMMAND net_msg_cmd_in(msg+1); if (net_msg_sendpending==0) net_msg_cmd_do(); break; } }
void net_msg_server_welcome(char *msg) { // The server has sent a welcome (token <space> base64digest) char *d,*p,*s; int k; unsigned char hwv = 1; #ifdef OVMS_HW_V2 hwv = 2; #endif if( !msg ) return; for (d=msg;(*d != 0)&&(*d != ' ');d++) ; if (*d != ' ') return; *d++ = 0; // At this point, <msg> is token, and <x> is base64digest // (both null-terminated) // Check for token-replay attack if (strcmp(token,msg)==0) return; // Server is using our token! // Validate server token p = par_get(PARAM_SERVERPASS); hmac_md5(msg, strlen(msg), p, strlen(p), digest); base64encode(digest, MD5_SIZE, net_scratchpad); if (strcmp(d,net_scratchpad)!=0) return; // Invalid server digest // Ok, at this point, our token is ok strcpy(net_scratchpad,msg); strcat(net_scratchpad,token); hmac_md5(net_scratchpad,strlen(net_scratchpad),p,strlen(p),digest); // Setup, and prime the rx and tx cryptos RC4_setup(&rx_crypto1, &rx_crypto2, digest, MD5_SIZE); for (k=0;k<1024;k++) { net_scratchpad[0] = 0; RC4_crypt(&rx_crypto1, &rx_crypto2, net_scratchpad, 1); } RC4_setup(&tx_crypto1, &tx_crypto2, digest, MD5_SIZE); for (k=0;k<1024;k++) { net_scratchpad[0] = 0; RC4_crypt(&tx_crypto1, &tx_crypto2, net_scratchpad, 1); } net_msg_serverok = 1; p = par_get(PARAM_PARANOID); if (*p == 'P') { // Paranoid mode initialisation if (ptokenmade==0) { // We need to make the ptoken for (k=0;k<TOKEN_SIZE;k++) { ptoken[k] = cb64[rand()%64]; } ptoken[TOKEN_SIZE] = 0; } // To be truly paranoid, we must send the paranoid token to the server ;-) ptokenmade=0; // Leave it off for the MP-0 ET message strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 ET"); strcat(net_scratchpad,ptoken); net_msg_start(); net_msg_encode_puts(); net_msg_send(); ptokenmade=1; // And enable paranoid mode from now on... // And calculate the pdigest for future use p = par_get(PARAM_MODULEPASS); hmac_md5(ptoken, strlen(ptoken), p, strlen(p), pdigest); } else { ptokenmade = 0; // This disables paranoid mode } /* DEBUG / QA stats: Send crash counter and last reason: * * MP-0 H*-OVM-DebugCrash,0,2592000 * ,<firmware_version>/<vehicle_type><vehicle_version>/V<hardware_version> * ,<crashcnt>,<crashreason>,<checkpoint> */ if (debug_crashreason & 0x80) { debug_crashreason &= ~0x80; // clear checkpoint hold bit s = stp_i(net_scratchpad, "MP-0 H*-OVM-DebugCrash,0,2592000,", ovms_firmware[0]); s = stp_i(s, ".", ovms_firmware[1]); s = stp_i(s, ".", ovms_firmware[2]); s = stp_s(s, "/", par_get(PARAM_VEHICLETYPE)); if (vehicle_version) s = stp_rom(s, vehicle_version); s = stp_i(s, "/V", hwv); s = stp_i(s, ",", debug_crashcnt); s = stp_x(s, ",", debug_crashreason); s = stp_i(s, ",", debug_checkpoint); delay100(20); net_msg_start(); net_msg_encode_puts(); net_msg_send(); } #ifdef OVMS_LOGGINGMODULE logging_serverconnect(); #endif // #ifdef OVMS_LOGGINGMODULE }
void net_msg_server_welcome(char *msg) { // The server has sent a welcome (token <space> base64digest) char *d,*p; int k; for (d=msg;(*d != 0)&&(*d != ' ');d++) ; if (*d != ' ') return; *d++ = 0; // At this point, <msg> is token, and <x> is base64digest // (both null-terminated) // Check for token-replay attack if (strcmp(token,msg)==0) return; // Server is using our token! // Validate server token p = par_get(PARAM_NETPASS1); hmac_md5(msg, strlen(msg), p, strlen(p), digest); base64encode(digest, MD5_SIZE, net_scratchpad); if (strcmp(d,net_scratchpad)!=0) return; // Invalid server digest // Ok, at this point, our token is ok strcpy(net_scratchpad,msg); strcat(net_scratchpad,token); hmac_md5(net_scratchpad,strlen(net_scratchpad),p,strlen(p),digest); // Setup, and prime the rx and tx cryptos RC4_setup(&rx_crypto1, &rx_crypto2, digest, MD5_SIZE); for (k=0;k<1024;k++) { net_scratchpad[0] = 0; RC4_crypt(&rx_crypto1, &rx_crypto2, net_scratchpad, 1); } RC4_setup(&tx_crypto1, &tx_crypto2, digest, MD5_SIZE); for (k=0;k<1024;k++) { net_scratchpad[0] = 0; RC4_crypt(&tx_crypto1, &tx_crypto2, net_scratchpad, 1); } net_msg_serverok = 1; p = par_get(PARAM_PARANOID); if (*p == 'P') { // Paranoid mode initialisation if (ptokenmade==0) { // We need to make the ptoken for (k=0;k<TOKEN_SIZE;k++) { ptoken[k] = cb64[rand()%64]; } ptoken[TOKEN_SIZE] = 0; } // To be truly paranoid, we must send the paranoid token to the server ;-) ptokenmade=0; // Leave it off for the MP-0 ET message strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 ET"); strcat(net_scratchpad,ptoken); net_msg_start(); net_msg_encode_puts(); net_msg_send(); ptokenmade=1; // And enable paranoid mode from now on... // And calculate the pdigest for future use p = par_get(PARAM_REGPASS); hmac_md5(ptoken, strlen(ptoken), p, strlen(p), pdigest); } else { ptokenmade = 0; // This disables paranoid mode } }
//////////////////////////////////////////////////////////////////////// // net_state_ticker1() // State Model: Per-second ticker // This function is called approximately once per second, and gives // the state a timeslice for activity. // void net_state_ticker1(void) { char *p; switch (net_state) { case NET_STATE_START: net_state_vchar = net_state_vchar ^ 1; // Toggle LED on/off led_act(net_state_vchar); break; case NET_STATE_DOINIT: if ((net_timeout_ticks==10)&&(net_timeout_ticks==20)) net_puts_rom(NET_INIT); // Try again... break; case NET_STATE_COPS: net_state_vchar = net_state_vchar ^ 1; // Toggle LED on/off led_net(net_state_vchar); led_act(net_state_vchar^1); break; case NET_STATE_SOFTRESET: net_state_enter(NET_STATE_START); break; case NET_STATE_READY: if (net_watchdog > 0) { if (--net_watchdog == 0) { net_state_enter(NET_STATE_COPS); // Reset network connection return; } } if (net_msg_sendpending>0) { net_msg_sendpending++; if (net_msg_sendpending>60) { // Pending for more than 60 seconds.. net_state_enter(NET_STATE_DONETINIT); // Reset GPRS link return; } } if ((net_reg == 0x01)||(net_reg == 0x05)) { if ((net_msg_notify==1)&&(net_msg_serverok==1)) { net_msg_notify = 0; delay100(10); net_msg_alert(); return; } if (net_sms_notify==1) { net_sms_notify = 0; delay100(10); p = par_get(PARAM_REGPHONE); net_sms_stat(p); return; } if ((net_msg_notifyenvironment==1)&& (net_msg_serverok==1)&& (net_apps_connected>0)&& (net_msg_sendpending==0)) { net_msg_notifyenvironment = 0; delay100(10); net_msg_start(); net_msg_environment(); net_msg_send(); } } break; } }