bool PingClass::ping(IPAddress dest, byte count) { _expected_count = count; _errors = 0; _success = 0; _avg_time = 0; memset(&_options, 0, sizeof(struct ping_option)); // Repeat count (how many time send a ping message to destination) _options.count = count; // Time interval between two ping (seconds??) _options.coarse_time = 1; // Destination machine _options.ip = dest; // Callbacks _options.recv_function = reinterpret_cast<ping_recv_function>(&PingClass::_ping_recv_cb); _options.sent_function = NULL; //reinterpret_cast<ping_sent_function>(&_ping_sent_cb); // Let's go! if(ping_start(&_options)) { // Suspend till the process end esp_yield(); } return (_success > 0); }
static int do_ping(int argc, const char* const* argv) { struct ping_option *pingopts = os_zalloc(sizeof(struct ping_option)); ip_addr_t ipaddr; ipaddr.addr = ipaddr_addr(argv[1]); pingopts->ip = ipaddr.addr; pingopts->count = 3; pingopts->recv_function=ping_recv_callback; pingopts->sent_function=NULL; ping_start(pingopts); console_lock(1); return 0; }
/*JSON{ "type" : "staticmethod", "class" : "ESP8266WiFi", "name" : "ping", "generate" : "jswrap_ESP8266WiFi_ping", "params" : [ ["ipAddr","JsVar","A string or integer representation of an IP address."], ["pingCallback", "JsVar", "Optional callback function."] ] }*/ void jswrap_ESP8266WiFi_ping( JsVar *ipAddr, //!< A string or integer representation of an IP address. JsVar *pingCallback //!< Optional callback function. ) { // If the parameter is a string, get the IP address from the string // representation. if (jsvIsString(ipAddr)) { char ipString[20]; int len = jsvGetString(ipAddr, ipString, sizeof(ipString)-1); ipString[len] = '\0'; pingOpt.ip = networkParseIPAddress(ipString); if (pingOpt.ip == 0) { jsExceptionHere(JSET_ERROR, "Not a valid IP address."); return; } } else // If the parameter is an integer, treat it as an IP address. if (jsvIsInt(ipAddr)) { pingOpt.ip = jsvGetInteger(ipAddr); } else // The parameter was neither a string nor an IP address and hence we don't // know how to get the IP address of the partner to ping so throw an // exception. { jsExceptionHere(JSET_ERROR, "IP address must be string or integer."); return; } if (jsvIsUndefined(pingCallback) || jsvIsNull(pingCallback)) { if (g_jsPingCallback != NULL) { jsvUnLock(g_jsPingCallback); } g_jsPingCallback = NULL; } else if (!jsvIsFunction(pingCallback)) { jsExceptionHere(JSET_ERROR, "Callback is not a function."); return; } else { if (g_jsPingCallback != NULL) { jsvUnLock(g_jsPingCallback); } g_jsPingCallback = pingCallback; jsvLockAgainSafe(g_jsPingCallback); } // We now have an IP address to ping ... so ping. memset(&pingOpt, 0, sizeof(pingOpt)); pingOpt.count = 5; pingOpt.recv_function = pingRecvCB; ping_start(&pingOpt); }
LOCAL void ICACHE_FLASH_ATTR ping_res_cb(const char *name, ip_addr_t *ip, void *arg) { nslookup_res(name, ip, arg); if (ip) { mCurrentPinopt.ip = ip->addr; mCurrentPinopt.count = 4; mCurrentPinopt.coarse_time = 1; mCurrentPinopt.recv_function = ping_cb; mCurrentPinopt.sent_function = ping_done_cb; mSent = 0; mRecieved = 0; mLost = 0; mTotalDelay = 0; ping_start(&mCurrentPinopt); } }
LOCAL void ICACHE_FLASH_ATTR ping_nslookup_cb(const char *name, ip_addr_t *ip, void *arg) { if(dhserial_get_mode() == SM_OUTPUT_MODE) { nslookup_res(name, ip, arg); if (ip) { mCurrentPinopt.ip = ip->addr; mCurrentPinopt.count = 4; mCurrentPinopt.coarse_time = 1; mCurrentPinopt.recv_function = ping_cb; mCurrentPinopt.sent_function = ping_done_cb; mSent = 0; mRecieved = 0; mLost = 0; mTotalDelay = 0; ping_start(&mCurrentPinopt); } else { mIsCommandWorking = 0; dhserial_set_mode(SM_NORMAL_MODE, 0, 0); } } else { mIsCommandWorking = 0; } }
int net_loop(enum proto_t protocol) { int ret = -EINVAL; net_restarted = 0; net_dev_exists = 0; net_try_count = 1; debug_cond(DEBUG_INT_STATE, "--- net_loop Entry\n"); bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start"); net_init(); if (eth_is_on_demand_init() || protocol != NETCONS) { eth_halt(); eth_set_current(); ret = eth_init(); if (ret < 0) { eth_halt(); return ret; } } else { eth_init_state_only(); } restart: #ifdef CONFIG_USB_KEYBOARD net_busy_flag = 0; #endif net_set_state(NETLOOP_CONTINUE); /* * Start the ball rolling with the given start function. From * here on, this code is a state machine driven by received * packets and timer events. */ debug_cond(DEBUG_INT_STATE, "--- net_loop Init\n"); net_init_loop(); switch (net_check_prereq(protocol)) { case 1: /* network not configured */ eth_halt(); return -ENODEV; case 2: /* network device not configured */ break; case 0: net_dev_exists = 1; net_boot_file_size = 0; switch (protocol) { case TFTPGET: #ifdef CONFIG_CMD_TFTPPUT case TFTPPUT: #endif /* always use ARP to get server ethernet address */ tftp_start(protocol); break; #ifdef CONFIG_CMD_TFTPSRV case TFTPSRV: tftp_start_server(); break; #endif #if defined(CONFIG_CMD_DHCP) case DHCP: bootp_reset(); net_ip.s_addr = 0; dhcp_request(); /* Basically same as BOOTP */ break; #endif case BOOTP: bootp_reset(); net_ip.s_addr = 0; bootp_request(); break; #if defined(CONFIG_CMD_RARP) case RARP: rarp_try = 0; net_ip.s_addr = 0; rarp_request(); break; #endif #if defined(CONFIG_CMD_PING) case PING: ping_start(); break; #endif #if defined(CONFIG_CMD_NFS) case NFS: nfs_start(); break; #endif #if defined(CONFIG_CMD_CDP) case CDP: cdp_start(); break; #endif #if defined(CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD) case NETCONS: nc_start(); break; #endif #if defined(CONFIG_CMD_SNTP) case SNTP: sntp_start(); break; #endif #if defined(CONFIG_CMD_DNS) case DNS: dns_start(); break; #endif #if defined(CONFIG_CMD_LINK_LOCAL) case LINKLOCAL: link_local_start(); break; #endif default: break; } break; } #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ defined(CONFIG_STATUS_LED) && \ defined(STATUS_LED_RED) /* * Echo the inverted link state to the fault LED. */ if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) status_led_set(STATUS_LED_RED, STATUS_LED_OFF); else status_led_set(STATUS_LED_RED, STATUS_LED_ON); #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ #endif /* CONFIG_MII, ... */ #ifdef CONFIG_USB_KEYBOARD net_busy_flag = 1; #endif /* * Main packet reception loop. Loop receiving packets until * someone sets `net_state' to a state that terminates. */ for (;;) { WATCHDOG_RESET(); #ifdef CONFIG_SHOW_ACTIVITY show_activity(1); #endif if (arp_timeout_check() > 0) time_start = get_timer(0); /* * Check the ethernet for a new packet. The ethernet * receive routine will process it. * Most drivers return the most recent packet size, but not * errors that may have happened. */ eth_rx(); /* * Abort if ctrl-c was pressed. */ if (ctrlc()) { /* cancel any ARP that may not have completed */ net_arp_wait_packet_ip.s_addr = 0; net_cleanup_loop(); eth_halt(); /* Invalidate the last protocol */ eth_set_last_protocol(BOOTP); puts("\nAbort\n"); /* include a debug print as well incase the debug messages are directed to stderr */ debug_cond(DEBUG_INT_STATE, "--- net_loop Abort!\n"); ret = -EINTR; goto done; } /* * Check for a timeout, and run the timeout handler * if we have one. */ if (time_handler && ((get_timer(0) - time_start) > time_delta)) { thand_f *x; #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ defined(CONFIG_STATUS_LED) && \ defined(STATUS_LED_RED) /* * Echo the inverted link state to the fault LED. */ if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) status_led_set(STATUS_LED_RED, STATUS_LED_OFF); else status_led_set(STATUS_LED_RED, STATUS_LED_ON); #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ #endif /* CONFIG_MII, ... */ debug_cond(DEBUG_INT_STATE, "--- net_loop timeout\n"); x = time_handler; time_handler = (thand_f *)0; (*x)(); } if (net_state == NETLOOP_FAIL) ret = net_start_again(); switch (net_state) { case NETLOOP_RESTART: net_restarted = 1; goto restart; case NETLOOP_SUCCESS: net_cleanup_loop(); if (net_boot_file_size > 0) { printf("Bytes transferred = %d (%x hex)\n", net_boot_file_size, net_boot_file_size); setenv_hex("filesize", net_boot_file_size); setenv_hex("fileaddr", load_addr); } if (protocol != NETCONS) eth_halt(); else eth_halt_state_only(); eth_set_last_protocol(protocol); ret = net_boot_file_size; debug_cond(DEBUG_INT_STATE, "--- net_loop Success!\n"); goto done; case NETLOOP_FAIL: net_cleanup_loop(); /* Invalidate the last protocol */ eth_set_last_protocol(BOOTP); debug_cond(DEBUG_INT_STATE, "--- net_loop Fail!\n"); goto done; case NETLOOP_CONTINUE: continue; } } done: #ifdef CONFIG_USB_KEYBOARD net_busy_flag = 0; #endif #ifdef CONFIG_CMD_TFTPPUT /* Clear out the handlers */ net_set_udp_handler(NULL); net_set_icmp_handler(NULL); #endif return ret; }
void ping_restart() { ping_stop(); ping_start(); }
void ping_check_incoming() { if (ping_incoming_.size() != view_.backups.size() + 1) view_is_down(); else ping_start(); }
int NetLoop(enum proto_t protocol) { bd_t *bd = gd->bd; int ret = -1; NetRestarted = 0; NetDevExists = 0; NetTryCount = 1; debug_cond(DEBUG_INT_STATE, "--- NetLoop Entry\n"); bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start"); net_init(); if (eth_is_on_demand_init() || protocol != NETCONS) { eth_halt(); eth_set_current(); if (eth_init(bd) < 0) { eth_halt(); return -1; } } else eth_init_state_only(bd); restart: #ifdef CONFIG_USB_KEYBOARD net_busy_flag = 0; #endif net_set_state(NETLOOP_CONTINUE); /* * Start the ball rolling with the given start function. From * here on, this code is a state machine driven by received * packets and timer events. */ debug_cond(DEBUG_INT_STATE, "--- NetLoop Init\n"); NetInitLoop(); switch (net_check_prereq(protocol)) { case 1: /* network not configured */ eth_halt(); return -1; case 2: /* network device not configured */ break; case 0: NetDevExists = 1; NetBootFileXferSize = 0; switch (protocol) { case TFTPGET: #ifdef CONFIG_CMD_TFTPPUT case TFTPPUT: #endif /* always use ARP to get server ethernet address */ TftpStart(protocol); break; #ifdef CONFIG_CMD_TFTPSRV case TFTPSRV: TftpStartServer(); break; #endif #if defined(CONFIG_CMD_DHCP) case DHCP: BootpReset(); NetOurIP = 0; DhcpRequest(); /* Basically same as BOOTP */ break; #endif case BOOTP: BootpReset(); NetOurIP = 0; BootpRequest(); break; #if defined(CONFIG_CMD_RARP) case RARP: RarpTry = 0; NetOurIP = 0; RarpRequest(); break; #endif #if defined(CONFIG_CMD_PING) case PING: ping_start(); break; #endif #if defined(CONFIG_CMD_NFS) case NFS: NfsStart(); break; #endif #if defined(CONFIG_CMD_CDP) case CDP: CDPStart(); break; #endif #if defined (CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD) case NETCONS: NcStart(); break; #endif #if defined(CONFIG_CMD_SNTP) case SNTP: SntpStart(); break; #endif #if defined(CONFIG_CMD_DNS) case DNS: DnsStart(); break; #endif #if defined(CONFIG_CMD_LINK_LOCAL) case LINKLOCAL: link_local_start(); break; #endif default: break; } break; } #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ defined(CONFIG_STATUS_LED) && \ defined(STATUS_LED_RED) /* * Echo the inverted link state to the fault LED. */ if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) status_led_set(STATUS_LED_RED, STATUS_LED_OFF); else status_led_set(STATUS_LED_RED, STATUS_LED_ON); #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ #endif /* CONFIG_MII, ... */ #ifdef CONFIG_USB_KEYBOARD net_busy_flag = 1; #endif /* * Main packet reception loop. Loop receiving packets until * someone sets `net_state' to a state that terminates. */ for (;;) { WATCHDOG_RESET(); #ifdef CONFIG_SHOW_ACTIVITY show_activity(1); #endif /* * Check the ethernet for a new packet. The ethernet * receive routine will process it. */ eth_rx(); /* * Abort if ctrl-c was pressed. */ if (ctrlc()) { /* cancel any ARP that may not have completed */ NetArpWaitPacketIP = 0; net_cleanup_loop(); eth_halt(); /* Invalidate the last protocol */ eth_set_last_protocol(BOOTP); puts("\nAbort\n"); /* include a debug print as well incase the debug messages are directed to stderr */ debug_cond(DEBUG_INT_STATE, "--- NetLoop Abort!\n"); goto done; } ArpTimeoutCheck(); /* * Check for a timeout, and run the timeout handler * if we have one. */ if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) { thand_f *x; #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ defined(CONFIG_STATUS_LED) && \ defined(STATUS_LED_RED) /* * Echo the inverted link state to the fault LED. */ if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) { status_led_set(STATUS_LED_RED, STATUS_LED_OFF); } else { status_led_set(STATUS_LED_RED, STATUS_LED_ON); } #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ #endif /* CONFIG_MII, ... */ debug_cond(DEBUG_INT_STATE, "--- NetLoop timeout\n"); x = timeHandler; timeHandler = (thand_f *)0; (*x)(); } switch (net_state) { case NETLOOP_RESTART: NetRestarted = 1; goto restart; case NETLOOP_SUCCESS: net_cleanup_loop(); if (NetBootFileXferSize > 0) { printf("Bytes transferred = %ld (%lx hex)\n", NetBootFileXferSize, NetBootFileXferSize); setenv_hex("filesize", NetBootFileXferSize); setenv_hex("fileaddr", load_addr); } if (protocol != NETCONS) eth_halt(); else eth_halt_state_only(); eth_set_last_protocol(protocol); ret = NetBootFileXferSize; debug_cond(DEBUG_INT_STATE, "--- NetLoop Success!\n"); goto done; case NETLOOP_FAIL: net_cleanup_loop(); /* Invalidate the last protocol */ eth_set_last_protocol(BOOTP); debug_cond(DEBUG_INT_STATE, "--- NetLoop Fail!\n"); goto done; case NETLOOP_CONTINUE: continue; } } done: #ifdef CONFIG_USB_KEYBOARD net_busy_flag = 0; #endif #ifdef CONFIG_CMD_TFTPPUT /* Clear out the handlers */ net_set_udp_handler(NULL); net_set_icmp_handler(NULL); #endif return ret; }
MDB_ASYNC_ST MySQL_Connection::handler(short event) { if (mysql==NULL) { // it is the first time handler() is being called async_state_machine=ASYNC_CONNECT_START; myds->wait_until=myds->sess->thread->curtime+mysql_thread___connect_timeout_server*1000; } handler_again: proxy_debug(PROXY_DEBUG_MYSQL_PROTOCOL, 6,"async_state_machine=%d\n", async_state_machine); switch (async_state_machine) { case ASYNC_CONNECT_START: connect_start(); if (async_exit_status) { next_event(ASYNC_CONNECT_CONT); } else { NEXT_IMMEDIATE(ASYNC_CONNECT_END); } break; case ASYNC_CONNECT_CONT: if (event) { connect_cont(event); } if (async_exit_status) { if (myds->sess->thread->curtime >= myds->wait_until) { NEXT_IMMEDIATE(ASYNC_CONNECT_TIMEOUT); } next_event(ASYNC_CONNECT_CONT); } else { NEXT_IMMEDIATE(ASYNC_CONNECT_END); } break; break; case ASYNC_CONNECT_END: if (!ret_mysql) { // always increase the counter proxy_error("Failed to mysql_real_connect() on %s:%d , %d: %s\n", parent->address, parent->port, mysql_errno(mysql), mysql_error(mysql)); NEXT_IMMEDIATE(ASYNC_CONNECT_FAILED); } else { NEXT_IMMEDIATE(ASYNC_CONNECT_SUCCESSFUL); } break; case ASYNC_CONNECT_SUCCESSFUL: __sync_fetch_and_add(&MyHGM->status.server_connections_connected,1); __sync_fetch_and_add(&parent->connect_OK,1); break; case ASYNC_CONNECT_FAILED: parent->connect_error(mysql_errno(mysql)); break; case ASYNC_CONNECT_TIMEOUT: proxy_error("Connect timeout on %s:%d : %llu - %llu = %llu\n", parent->address, parent->port, myds->sess->thread->curtime , myds->wait_until, myds->sess->thread->curtime - myds->wait_until); parent->connect_error(mysql_errno(mysql)); break; case ASYNC_CHANGE_USER_START: change_user_start(); if (async_exit_status) { next_event(ASYNC_CHANGE_USER_CONT); } else { NEXT_IMMEDIATE(ASYNC_CHANGE_USER_END); } break; case ASYNC_CHANGE_USER_CONT: assert(myds->sess->status==CHANGING_USER_SERVER); change_user_cont(event); if (async_exit_status) { next_event(ASYNC_CHANGE_USER_CONT); } else { NEXT_IMMEDIATE(ASYNC_CHANGE_USER_END); } break; case ASYNC_CHANGE_USER_END: if (ret_bool) { fprintf(stderr,"Failed to mysql_change_user()"); NEXT_IMMEDIATE(ASYNC_CHANGE_USER_FAILED); } else { NEXT_IMMEDIATE(ASYNC_CHANGE_USER_SUCCESSFUL); } break; case ASYNC_CHANGE_USER_SUCCESSFUL: break; case ASYNC_CHANGE_USER_FAILED: break; case ASYNC_PING_START: ping_start(); if (async_exit_status) { next_event(ASYNC_PING_CONT); } else { NEXT_IMMEDIATE(ASYNC_PING_END); } break; case ASYNC_PING_CONT: assert(myds->sess->status==PINGING_SERVER); ping_cont(event); if (async_exit_status) { next_event(ASYNC_PING_CONT); } else { NEXT_IMMEDIATE(ASYNC_PING_END); } break; case ASYNC_PING_END: if (interr) { NEXT_IMMEDIATE(ASYNC_PING_FAILED); } else { NEXT_IMMEDIATE(ASYNC_PING_SUCCESSFUL); } break; case ASYNC_PING_SUCCESSFUL: break; case ASYNC_PING_FAILED: break; case ASYNC_QUERY_START: real_query_start(); __sync_fetch_and_add(&parent->queries_sent,1); __sync_fetch_and_add(&parent->bytes_sent,query.length); myds->sess->thread->status_variables.queries_backends_bytes_sent+=query.length; if (async_exit_status) { next_event(ASYNC_QUERY_CONT); } else { #ifdef PROXYSQL_USE_RESULT NEXT_IMMEDIATE(ASYNC_USE_RESULT_START); #else NEXT_IMMEDIATE(ASYNC_STORE_RESULT_START); #endif } break; case ASYNC_QUERY_CONT: real_query_cont(event); if (async_exit_status) { next_event(ASYNC_QUERY_CONT); } else { #ifdef PROXYSQL_USE_RESULT NEXT_IMMEDIATE(ASYNC_USE_RESULT_START); #else NEXT_IMMEDIATE(ASYNC_STORE_RESULT_START); #endif } break; case ASYNC_STORE_RESULT_START: if (mysql_errno(mysql)) { NEXT_IMMEDIATE(ASYNC_QUERY_END); } store_result_start(); if (async_exit_status) { next_event(ASYNC_STORE_RESULT_CONT); } else { NEXT_IMMEDIATE(ASYNC_QUERY_END); } break; case ASYNC_STORE_RESULT_CONT: store_result_cont(event); if (async_exit_status) { next_event(ASYNC_STORE_RESULT_CONT); } else { NEXT_IMMEDIATE(ASYNC_QUERY_END); } break; case ASYNC_USE_RESULT_START: if (mysql_errno(mysql)) { NEXT_IMMEDIATE(ASYNC_QUERY_END); } mysql_result=mysql_use_result(mysql); if (mysql_result==NULL) { NEXT_IMMEDIATE(ASYNC_QUERY_END); } else { MyRS=new MySQL_ResultSet(&myds->sess->client_myds->myprot, mysql_result, mysql); async_fetch_row_start=false; NEXT_IMMEDIATE(ASYNC_USE_RESULT_CONT); } break; case ASYNC_USE_RESULT_CONT: if (async_fetch_row_start==false) { async_exit_status=mysql_fetch_row_start(&mysql_row,mysql_result); async_fetch_row_start=true; } else { async_exit_status=mysql_fetch_row_cont(&mysql_row,mysql_result, mysql_status(event, true)); } if (async_exit_status) { next_event(ASYNC_USE_RESULT_CONT); } else { async_fetch_row_start=false; if (mysql_row) { unsigned int br=MyRS->add_row(mysql_row); __sync_fetch_and_add(&parent->bytes_recv,br); myds->sess->thread->status_variables.queries_backends_bytes_recv+=br; NEXT_IMMEDIATE(ASYNC_USE_RESULT_CONT); } else { MyRS->add_eof(); NEXT_IMMEDIATE(ASYNC_QUERY_END); } } break; case ASYNC_QUERY_END: break; case ASYNC_SET_AUTOCOMMIT_START: set_autocommit_start(); if (async_exit_status) { next_event(ASYNC_SET_AUTOCOMMIT_CONT); } else { NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_END); } break; case ASYNC_SET_AUTOCOMMIT_CONT: set_autocommit_cont(event); if (async_exit_status) { next_event(ASYNC_SET_AUTOCOMMIT_CONT); } else { NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_END); } break; case ASYNC_SET_AUTOCOMMIT_END: if (ret_bool) { NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_FAILED); } else { NEXT_IMMEDIATE(ASYNC_SET_AUTOCOMMIT_SUCCESSFUL); } break; case ASYNC_SET_AUTOCOMMIT_SUCCESSFUL: break; case ASYNC_SET_AUTOCOMMIT_FAILED: fprintf(stderr,"%s\n",mysql_error(mysql)); break; case ASYNC_SET_NAMES_START: set_names_start(); if (async_exit_status) { next_event(ASYNC_SET_NAMES_CONT); } else { NEXT_IMMEDIATE(ASYNC_SET_NAMES_END); } break; case ASYNC_SET_NAMES_CONT: set_names_cont(event); if (async_exit_status) { next_event(ASYNC_SET_NAMES_CONT); } else { NEXT_IMMEDIATE(ASYNC_SET_NAMES_END); } break; case ASYNC_SET_NAMES_END: if (interr) { NEXT_IMMEDIATE(ASYNC_SET_NAMES_FAILED); } else { NEXT_IMMEDIATE(ASYNC_SET_NAMES_SUCCESSFUL); } break; case ASYNC_SET_NAMES_SUCCESSFUL: break; case ASYNC_SET_NAMES_FAILED: fprintf(stderr,"%s\n",mysql_error(mysql)); break; case ASYNC_INITDB_START: initdb_start(); if (async_exit_status) { next_event(ASYNC_INITDB_CONT); } else { NEXT_IMMEDIATE(ASYNC_INITDB_END); } break; case ASYNC_INITDB_CONT: initdb_cont(event); if (async_exit_status) { next_event(ASYNC_INITDB_CONT); } else { NEXT_IMMEDIATE(ASYNC_INITDB_END); } break; case ASYNC_INITDB_END: if (interr) { NEXT_IMMEDIATE(ASYNC_INITDB_FAILED); } else { NEXT_IMMEDIATE(ASYNC_INITDB_SUCCESSFUL); } break; case ASYNC_INITDB_SUCCESSFUL: break; case ASYNC_INITDB_FAILED: fprintf(stderr,"%s\n",mysql_error(mysql)); break; default: assert(0); //we should never reach here break; } return async_state_machine; }
int NetLoop(enum proto_t protocol) { int ret = -1; NetRestarted = 0; NetDevExists = 0; NetTryCount = 1; debug_cond(DEBUG_INT_STATE, "--- NetLoop Entry\n"); net_init(); restart: net_set_state(NETLOOP_CONTINUE); /* * Start the ball rolling with the given start function. From * here on, this code is a state machine driven by received * packets and timer events. */ debug_cond(DEBUG_INT_STATE, "--- NetLoop Init\n"); NetInitLoop(); switch (net_check_prereq(protocol)) { case 1: case 2: return -1; case 0: NetDevExists = 1; NetBootFileXferSize = 0; switch (protocol) { case TFTPGET: #ifdef CONFIG_CMD_TFTPPUT case TFTPPUT: #endif /* always use ARP to get server ethernet address */ TftpStart(protocol); break; case PING: ping_start(); break; default: break; } break; } /* * Main packet reception loop. Loop receiving packets until * someone sets `net_state' to a state that terminates. */ for (;;) { /* * Check the ethernet for a new packet. The ethernet * receive routine will process it. */ eth_rx(); /* * Abort if q was pressed. */ if ('q' == ftuart_kbhit()) { /* cancel any ARP that may not have completed */ NetArpWaitPacketIP = 0; net_cleanup_loop(); puts("\nAbort\n"); /* include a debug print as well incase the debug messages are directed to stderr */ debug_cond(DEBUG_INT_STATE, "--- NetLoop Abort!\n"); goto done; } ArpTimeoutCheck(); /* * Check for a timeout, and run the timeout handler * if we have one. */ if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) { thand_f *x; debug_cond(DEBUG_INT_STATE, "--- NetLoop timeout\n"); x = timeHandler; timeHandler = (thand_f *)0; (*x)(); } switch (net_state) { case NETLOOP_RESTART: NetRestarted = 1; goto restart; case NETLOOP_SUCCESS: net_cleanup_loop(); if (NetBootFileXferSize > 0) { prints("Bytes transferred = %ld (%lx hex)\n", NetBootFileXferSize, NetBootFileXferSize); } ret = NetBootFileXferSize; debug_cond(DEBUG_INT_STATE, "--- NetLoop Success!\n"); goto done; case NETLOOP_FAIL: net_cleanup_loop(); debug_cond(DEBUG_INT_STATE, "--- NetLoop Fail!\n"); goto done; case NETLOOP_CONTINUE: continue; } } done: #ifdef CONFIG_CMD_TFTPPUT /* Clear out the handlers */ net_set_udp_handler(NULL); net_set_icmp_handler(NULL); #endif return ret; }