/************************************************************************
* NAME: fapp_benchrx_cmd
*
* DESCRIPTION: Start RX Benchmark server.
************************************************************************/
void fapp_benchrx_cmd( fnet_shell_desc_t desc, int argc, char ** argv )
{
fnet_address_family_t family;
family = AF_SUPPORTED;
/* TCP */
if((argc == 1)||(argc == 2 && fnet_strcasecmp("tcp", argv[1]) == 0))
{
fapp_bench_tcp_rx(desc, family);
}
/* UDP */
else if(((argc == 2) || (argc == 3)) && fnet_strcasecmp("udp", argv[1]) == 0)
{
fnet_ip4_addr_t multicast_address = 0;
if(argc == 3) /* Multicast group address.*/
{
if((fnet_inet_aton(argv[2], (struct in_addr *) &multicast_address) == FNET_ERR) || !FNET_IP4_ADDR_IS_MULTICAST(multicast_address))
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[2]);
return;
}
}
fapp_bench_udp_rx(desc, family, multicast_address);
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);
}
}
/************************************************************************
* NAME: fapp_netif_info_print
*
* DESCRIPTION: Print detailed address information about default
* network interface.
************************************************************************/
void fapp_netif_info_print( fnet_shell_desc_t desc, fnet_netif_desc_t netif)
{
fnet_char_t name[FNET_NETIF_NAMELEN];
fnet_netif_get_name(netif, name, sizeof(name));
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Interface", name);
fapp_netif_addr_print(desc, AF_SUPPORTED, netif, FNET_TRUE);
#if FNET_CFG_IP4
{
fnet_ip4_addr_t ip_addr;
fnet_char_t ip_str[FNET_IP4_ADDR_STR_SIZE];
ip_addr = fnet_netif_get_ip4_subnet_mask(netif);
fnet_inet_ntoa(*(struct in_addr *)( &ip_addr), ip_str);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "IPv4 Subnet mask", ip_str);
ip_addr = fnet_netif_get_ip4_gateway(netif);
fnet_inet_ntoa(*(struct in_addr *)( &ip_addr), ip_str);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "IPv4 Gateway", ip_str);
#if FNET_CFG_DNS
ip_addr = fnet_netif_get_ip4_dns(netif);
fnet_inet_ntoa(*(struct in_addr *)( &ip_addr), ip_str);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "IPv4 DNS", ip_str);
#endif
}
#endif /* FNET_CFG_IP4 */
}
/************************************************************************
* NAME: fapp_fs_dir_cmd
*
* DESCRIPTION: Displays a list of files and subdirectories in a directory.
*************************************************************************/
static void fapp_fs_dir_cmd( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t **argv )
{
struct fnet_fs_dirent ep;
FNET_FS_DIR dir;
FNET_COMP_UNUSED_ARG(argc);
FNET_COMP_UNUSED_ARG(argv);
/* Open dir */
dir = fnet_fs_opendir(fapp_fs_current_path);
if (dir)
{
/* Print the dir content. */
while ((fnet_fs_readdir (dir, &ep))==FNET_OK)
{
fnet_shell_println(desc, FAPP_FS_DIR_STR, (ep.d_type == DT_DIR)?"<DIR>":"<FILE>", ep.d_size, ep.d_name);
}
/* Close dir */
fnet_fs_closedir(dir);
}
else
{
fnet_shell_println(desc, FAPP_FS_DIR_ERR);
}
}
/************************************************************************
* NAME: fapp_mem_erase_all
*
* DESCRIPTION:
************************************************************************/
void fapp_mem_erase_all(fnet_shell_desc_t desc)
{
fnet_uint32_t addr;
const struct fapp_mem_region *region = fapp_mem_regions;
fnet_uint32_t log_start_addr;
fnet_size_t log_erase_size;
fnet_size_t log_skip_size;
/* Check all regions if it has erase function. */
while(region->description)
{
if((region->erase) && (region->erase_size))
{
addr = region->address;
log_start_addr = addr;
log_erase_size = 0u;
log_skip_size = 0u;
while(addr < (region->address+region->size))
{
if(fapp_mem_erase((void *)addr, region->erase_size) == FNET_OK)
{
if(log_skip_size)
{
fnet_shell_println(desc, FAPP_MEM_ERASE_SKIPPED, log_start_addr, log_start_addr+log_skip_size-1u);
log_skip_size = 0u;
log_start_addr = addr;
}
log_erase_size += region->erase_size;
}
else
{
if(log_erase_size)
{
fnet_shell_println(desc, FAPP_MEM_ERASE_ERASED, log_start_addr, log_start_addr+log_erase_size-1u);
log_erase_size = 0u;
log_start_addr = addr;
}
log_skip_size += region->erase_size;
}
addr+=region->erase_size;
}
if(log_erase_size)
{
fnet_shell_println(desc, FAPP_MEM_ERASE_ERASED, log_start_addr, log_start_addr+log_erase_size-1u);
}
else
{
fnet_shell_println(desc, FAPP_MEM_ERASE_SKIPPED, log_start_addr, log_start_addr+log_skip_size-1u);
}
}
region++;
}
}
/************************************************************************
* NAME: fapp_netif_addr_print
*
* DESCRIPTION: Print Interface IP addresses.
************************************************************************/
void fapp_netif_addr_print(fnet_shell_desc_t desc, fnet_address_family_t family, fnet_netif_desc_t netif, fnet_bool_t print_type)
{
fnet_char_t ip_str[FNET_IP_ADDR_STR_SIZE]={0};
#if FNET_CFG_IP4
if((family & AF_INET)==AF_INET)
{
fnet_ip4_addr_t local_ip;
local_ip = fnet_netif_get_ip4_addr(netif);
fnet_shell_printf(desc, FAPP_SHELL_INFO_FORMAT_S, "IPv4 Address", fnet_inet_ntoa(*(struct in_addr *)(&local_ip), ip_str) );
if(print_type)
{
fnet_shell_println(desc," <%s>", fnet_netif_get_ip4_addr_automatic(netif) ? "automatic" : "manual");
}
else
{
fnet_shell_println(desc, "");
}
}
#endif /* FNET_CFG_IP4 */
#if FNET_CFG_IP6
if((family & AF_INET6)==AF_INET6)
{
fnet_bool_t result;
fnet_index_t n;
fnet_netif_ip6_addr_info_t addr_info;
/* Print all assigned IPv6 addreses.*/
n=0u;
for(;;)
{
result = fnet_netif_get_ip6_addr (netif, n, &addr_info);
if(result == FNET_TRUE)
{
fnet_inet_ntop(AF_INET6, (fnet_uint8_t*)(&addr_info.address), ip_str, sizeof(ip_str));
fnet_shell_printf(desc, FAPP_SHELL_INFO_FORMAT_S, "IPv6 Address", ip_str);
if(print_type)
{
fnet_shell_println(desc," <%s> ScopeID:%d", (addr_info.type == FNET_NETIF_IP6_ADDR_TYPE_AUTOCONFIGURABLE) ? "autoconfigurable" : "manual", fnet_netif_get_scope_id(netif));
}
else
{
fnet_shell_println(desc,"");
}
}
else
{
break;
}
n++;
}
}
#endif /* FNET_CFG_IP6 */
}
/************************************************************************
* NAME: fapp_boot
*
* DESCRIPTION:
************************************************************************/
static void fapp_boot(fnet_shell_desc_t desc)
{
/* Bootloader. */
#if FAPP_CFG_BOOTLOADER
/* The bootloader wait some time for a key over a serial connection.*/
/* The wait time is given by the boot_delay parameter.*/
fnet_time_t delay;
const struct boot_mode *mode;
mode = fapp_boot_mode_by_index (fapp_params_boot_config.mode);
if(mode->handler)
{
delay = fapp_params_boot_config.delay;
fnet_shell_printf(desc, FAPP_BOOT_STR, mode->name, delay);
while(delay > 0u)
{
delay--;
if( fnet_shell_getchar(desc) != FNET_ERR)
{
break;
}
fnet_timer_delay(FNET_TIMER_TICK_IN_SEC); /* 1 sec. delay. */
fnet_shell_printf(desc, "\b\b\b\b %3d", delay);
}
fnet_shell_println(desc, "");
if(delay == 0u)
{
/* Auto-start*/
mode->handler(desc);
}
}
else
#endif
{
/* Default startup script. */
#if FAPP_CFG_STARTUP_SCRIPT_ENABLED
fnet_shell_println(desc, "Startup script: %s", FAPP_CFG_STARTUP_SCRIPT);
fnet_shell_script(desc, FAPP_CFG_STARTUP_SCRIPT );
#endif
}
FNET_COMP_UNUSED_ARG(desc);
}
/************************************************************************
* NAME: fapp_fs_init
*
* DESCRIPTION: File Explorer initialization function.
************************************************************************/
static void fapp_fs_init( fnet_shell_desc_t desc )
{
/* Format exp shell prompt */
fnet_snprintf( FAPP_FS_PROMPT_STR, sizeof(FAPP_FS_PROMPT_STR), "%s%s%s",
&FAPP_FS_PROMPT_STR_HEADER[0],
&fapp_fs_current_path[0],
&FAPP_FS_PROMPT_STR_TRAILER[0]);
fnet_shell_println(desc, "\n%s", FAPP_DELIMITER_STR);
fnet_shell_println(desc, " File Explorer started.");
fnet_shell_println(desc, " Enter 'help' for command list.");
fnet_shell_println(desc, "%s\n", FAPP_DELIMITER_STR);
}
/************************************************************************
* NAME: fapp_http_cmd
*
* DESCRIPTION: Run HTTP server.
*************************************************************************/
void fapp_http_cmd( fnet_shell_desc_t desc, int argc, char ** argv )
{
struct fnet_http_params params;
fnet_http_desc_t http_desc;
FNET_COMP_UNUSED_ARG(desc);
if(argc == 1) /* By default is "init".*/
{
fnet_memset_zero(¶ms, sizeof(struct fnet_http_params));
params.root_path = FAPP_HTTP_MOUNT_NAME; /* Root directory path */
params.index_path = FAPP_HTTP_INDEX_FILE; /* Index file path, relative to the root_path */
#if FNET_CFG_HTTP_SSI
params.ssi_table = fapp_ssi_table;
#endif
#if FNET_CFG_HTTP_CGI
params.cgi_table = fapp_cgi_table;
#endif
#if FNET_CFG_HTTP_AUTHENTICATION_BASIC
params.auth_table = fapp_auth_table;
#endif
#if FNET_CFG_HTTP_POST
params.post_table = fapp_post_table;
#endif
/* Enable HTTP server */
http_desc = fnet_http_init(¶ms);
if(http_desc != FNET_ERR)
{
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fnet_shell_println(desc, " HTTP server started.");
fapp_netif_addr_print(desc, AF_SUPPORTED, fapp_default_netif, FNET_FALSE);
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fapp_http_desc = http_desc;
}
else
{
fnet_shell_println(desc, FAPP_INIT_ERR, "HTTP");
}
}
else if(argc == 2 && fnet_strcasecmp(&FAPP_COMMAND_RELEASE[0], argv[1]) == 0) /* [release] */
{
fapp_http_release();
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);
}
}
/************************************************************************
* NAME: fapp_dhcp_cmd
*
* DESCRIPTION: Enable DHCP client.
************************************************************************/
void fapp_dhcp_cmd( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t ** argv )
{
struct fnet_dhcp_params dhcp_params;
fnet_dhcp_desc_t dhcp_desc;
fnet_netif_desc_t netif = fnet_netif_get_default();
if(argc == 1u /* By default is "init".*/
#if 0 /* DHCP reboot feature not used too much. */
|| fnet_strcasecmp(&FAPP_DHCP_COMMAND_REBOOT[0], argv[1]) == 0
#endif
) /* [reboot] */
{
fnet_memset_zero(&dhcp_params, sizeof(struct fnet_dhcp_params));
fapp_dhcp_discover_counter = FAPP_CFG_DHCP_CMD_DISCOVER_MAX; /* reset counter.*/
#if 0 /* DHCP reboot feature not used too much. */
if(fnet_strcasecmp(&FAPP_DHCP_COMMAND_REBOOT[0], argv[1]) == 0) /* [reboot] */
dhcp_params.requested_ip_address.s_addr = fnet_netif_get_ip4_addr(netif);
#endif
fapp_dhcp_ip_old = fnet_netif_get_ip4_addr(netif); /* Save ip to restore if cancelled. */
/* Enable DHCP client */
dhcp_desc = fnet_dhcp_init(netif, &dhcp_params);
if(dhcp_desc != FNET_ERR)
{
fapp_dhcp_desc = dhcp_desc;
/* Register DHCP event handlers. */
fnet_dhcp_handler_updated_set(fapp_dhcp_desc, fapp_dhcp_handler_updated, (void *)desc);
fnet_dhcp_handler_discover_set(fapp_dhcp_desc, fapp_dhcp_handler_discover, (void *)desc);
fnet_shell_println(desc, FAPP_TOCANCEL_STR);
fnet_shell_block(desc, fapp_dhcp_on_ctrlc); /* Block shell. */
}
else
{
fnet_shell_println(desc, FAPP_INIT_ERR, "DHCP");
}
}
else if((argc == 2u) && (fnet_strcasecmp(&FAPP_COMMAND_RELEASE[0], argv[1]) == 0)) /* [release] */
{
fapp_dhcp_release();
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);
}
}
static void fapp_save_cmd ( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t ** argv )
{
(void)argc;
(void)argv;
if(fapp_params_to_flash() == FNET_OK)
{
fnet_shell_println(desc, FAPP_SAVE_STR);
}
else
{
fnet_shell_script_release(desc); /* Critical error. Clear script. */
fnet_shell_println(desc, FAPP_SAVE_FAILED_STR);
}
}
void fapp_debug_cmd( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t ** argv )
{
FNET_COMP_UNUSED_ARG(desc);
FNET_COMP_UNUSED_ARG(argc);
FNET_COMP_UNUSED_ARG(argv);
/* Put here you debugging information.*/
#if 0
fnet_fec_debug_mii_print_regs(fnet_netif_get_default());
#endif
#if 0
{
fnet_index_t i = 0;
fnet_ip6_addr_t addr_dns;
fnet_uint8_t ip_str[FNET_IP_ADDR_STR_SIZE]={0};
while(fnet_netif_get_ip6_dns(fnet_netif_get_default(), i, &addr_dns ) == FNET_TRUE)
{
fnet_inet_ntop(AF_INET6, (fnet_uint8_t*)(&addr_dns), ip_str, sizeof(ip_str));
fnet_shell_println(desc, "DNS[%d]=%s", i, ip_str);
i++;
}
}
#endif
#if 0 /* Test ctacrypt library.*/
extern void ctaocrypt_test(void);
ctaocrypt_test();
#endif
}
/************************************************************************
* NAME: fapp_show
*
* DESCRIPTION: Shows all system settings.
************************************************************************/
void fapp_get_cmd( fnet_shell_desc_t desc, int argc, char ** argv )
{
int index;
if(argc == 1) /* Print all prameters. */
{
for (index = 0; index < FAPP_SET_CMD_NUM; ++index)
{
fnet_shell_printf(desc, FAPP_GET_OPT_FORMAT, fapp_setget_cmd_table[index].option);
fapp_setget_cmd_table[index].get(desc);
}
}
else /* Print one parameter. */
{
for (index = 0; index < FAPP_SET_CMD_NUM; index++)
{
if(fnet_strcasecmp(fapp_setget_cmd_table[index].option, argv[1]) == 0)
{
fnet_shell_printf(desc, FAPP_GET_OPT_FORMAT, fapp_setget_cmd_table[index].option);
fapp_setget_cmd_table[index].get(desc);
return;
}
}
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);
}
}
/************************************************************************
* NAME: fapp_dhcp_on_ctrlc
*
* DESCRIPTION:
************************************************************************/
static void fapp_dhcp_on_ctrlc(fnet_shell_desc_t desc)
{
/* Release DHCP. */
fapp_dhcp_release();
/* Restore old ip address, as DHCP set it to zero. */
fnet_netif_set_ip4_addr( fnet_netif_get_default(), fapp_dhcp_ip_old );
fnet_shell_println( desc, FAPP_CANCELLED_STR);
}
static void fapp_get_ip(fnet_shell_desc_t desc, fnet_ip4_addr_t (*get_address)( fnet_netif_desc_t netif_desc ))
{
char ip_str[FNET_IP4_ADDR_STR_SIZE];
struct in_addr addr;
addr.s_addr = get_address(fapp_default_netif);
fnet_inet_ntoa(addr, ip_str);
fnet_shell_println(desc, FAPP_GET_SOPT_FORMAT, ip_str);
}
void fapp_mem_cmd ( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t **argv )
{
const struct fapp_mem_region *mem = fapp_mem_regions;
const struct fapp_mem_region_reserved *region_reserved = fapp_mem_regions_reserved;
FNET_COMP_UNUSED_ARG(desc);
FNET_COMP_UNUSED_ARG(argc);
FNET_COMP_UNUSED_ARG(argv);
/* Print memory types. */
fnet_shell_println(desc, FAPP_MEM_HEADER, "Memory type");
fnet_shell_println(desc, FAPP_MEM_DELIMITER);
while(mem->description)
{
fnet_shell_println(desc, MEM_STR, mem->description, mem->address,
mem->address + mem->size - 1u);
mem++;
}
/* Print protected/reserved memory regions.*/
fnet_shell_println(desc, FAPP_MEM_HEADER, "Reserved");
fnet_shell_println(desc, FAPP_MEM_DELIMITER);
while(region_reserved->description)
{
fnet_shell_println(desc, MEM_STR, region_reserved->description, region_reserved->address,
region_reserved->address + region_reserved->size - 1u);
region_reserved++;
}
fnet_shell_println(desc, "");
}
/************************************************************************
* NAME: fapp_dhcp_info
*
* DESCRIPTION:
*************************************************************************/
void fapp_dhcp_info(fnet_shell_desc_t desc)
{
fnet_char_t ip_str[FNET_IP4_ADDR_STR_SIZE];
fnet_bool_t dhcp_is_enabled = fnet_dhcp_is_enabled(fapp_dhcp_desc);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "DHCP Client", fapp_enabled_str[dhcp_is_enabled]);
if(dhcp_is_enabled && (fnet_netif_get_ip4_addr_type(fnet_netif_get_default()) == FNET_NETIF_IP_ADDR_TYPE_DHCP))
{
struct fnet_dhcp_options options;
fnet_dhcp_get_options(fapp_dhcp_desc, &options);
fnet_inet_ntoa(*(struct in_addr *)( &options.dhcp_server), ip_str);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "DHCP Server", ip_str);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Lease Time", fnet_ntohl(options.lease_time));
}
}
static void fapp_set_cmd_mac(fnet_shell_desc_t desc, char *value)
{
fnet_mac_addr_t macaddr;
if((fnet_str_to_mac(value, macaddr) != FNET_OK) ||
(fnet_netif_set_hw_addr(fapp_default_netif, macaddr, sizeof(fnet_mac_addr_t)) != FNET_OK))
{
fnet_shell_println(desc, FAPP_PARAM_ERR, value);
}
}
static void fapp_set_cmd_image_type(fnet_shell_desc_t desc, char *value )
{
struct image_type *type = fapp_tftp_image_type_by_name (value);
if(type == 0)
fnet_shell_println(desc, FAPP_PARAM_ERR, value);
else
fapp_params_tftp_config.file_type = type->index;
}
static void fapp_set_cmd_boot(fnet_shell_desc_t desc, char *value )
{
const struct boot_mode *mode = fapp_boot_mode_by_name (value);
if(mode == 0)
fnet_shell_println(desc, FAPP_PARAM_ERR, value);
else
fapp_params_boot_config.mode = mode->index;
}
static void fapp_get_cmd_mac(fnet_shell_desc_t desc)
{
char mac_str[FNET_MAC_ADDR_STR_SIZE];
fnet_mac_addr_t macaddr;
fnet_netif_get_hw_addr(fapp_default_netif, macaddr, sizeof(fnet_mac_addr_t));
fnet_mac_to_str(macaddr, mac_str);
fnet_shell_println(desc, FAPP_GET_SOPT_FORMAT, mac_str);
}
/************************************************************************
* NAME: fapp_dhcp_info
*
* DESCRIPTION:
*************************************************************************/
void fapp_dhcp_info(fnet_shell_desc_t desc)
{
fnet_char_t ip_str[FNET_IP4_ADDR_STR_SIZE];
fnet_bool_t dhcp_enabled = fnet_dhcp_enabled(fapp_dhcp_desc);
fnet_bool_t address_automatic = fnet_netif_get_ip4_addr_automatic(fnet_netif_get_default());
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "DHCP Client", dhcp_enabled ? FAPP_SHELL_INFO_ENABLED : FAPP_SHELL_INFO_DISABLED);
if(dhcp_enabled && address_automatic)
{
struct fnet_dhcp_options options;
fnet_dhcp_get_options(fapp_dhcp_desc, &options);
fnet_inet_ntoa(*(struct in_addr *)( &options.dhcp_server), ip_str);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "DHCP Server", ip_str);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Lease Time", fnet_ntohl(options.lease_time));
}
}
static void fapp_set_cmd_bootdelay(fnet_shell_desc_t desc, char *value )
{
unsigned long delay;
char *p = 0;
delay = fnet_strtoul(value,&p,0);
if ((delay == 0) && (p == value))
fnet_shell_println(desc, FAPP_PARAM_ERR, value); /* Print error mesage. */
else
fapp_params_boot_config.delay = delay;
}
static void fapp_set_cmd_tftp(fnet_shell_desc_t desc, char *value )
{
struct sockaddr s_addr;
if(fnet_inet_ptos(value, &s_addr) == FNET_ERR)
{
fnet_shell_println(desc, FAPP_PARAM_ERR, value); /* Print error. */
}
fapp_params_tftp_config.server_addr = s_addr;
}
static void fapp_set_cmd_raw(fnet_shell_desc_t desc, char *value )
{
unsigned long address;
char *p = 0;
address = fnet_strtoul(value,&p,16);
if ((address == 0) && (p == value))
fnet_shell_println(desc, FAPP_PARAM_ERR, value); /* Print error mesage. */
else
fapp_params_tftp_config.file_raw_address = address;
}
/************************************************************************
* NAME: fapp_dhcp_handler_updated
*
* DESCRIPTION: Event handler on new IP from DHCP client.
************************************************************************/
static void fapp_dhcp_handler_updated(fnet_dhcp_desc_t dhcp_desc, fnet_netif_desc_t netif, void *shl_desc )
{
fnet_shell_desc_t desc = (fnet_shell_desc_t) shl_desc;
fapp_dhcp_discover_counter = -1; /* Infinite for future. */
/* Optionally, unregister DHCP event handlers, just to do not
* disturb a user. */
fnet_dhcp_handler_updated_set(dhcp_desc, 0, 0);
fnet_dhcp_handler_discover_set(dhcp_desc, 0, 0);
fnet_shell_unblock((fnet_shell_desc_t)shl_desc); /* Unblock the shell. */
/* Print updated parameters info. */
fnet_shell_println( desc, "\n%s", FAPP_DELIMITER_STR);
fnet_shell_println( desc, FAPP_DHCP_NEWIP_STR);
fnet_shell_println( desc, FAPP_DELIMITER_STR);
fapp_netif_info_print( desc, netif );
}
static void fapp_set_ip(fnet_shell_desc_t desc, char *value, void (*set_ip)( fnet_netif_desc_t netif_desc, fnet_ip4_addr_t ipaddr ) )
{
fnet_ip4_addr_t addr;
if(fnet_inet_aton(value, (struct in_addr *) &addr) == FNET_OK)
{
set_ip(fapp_default_netif, addr);
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, value);
};
}
/************************************************************************
* NAME: fapp_dhcp_handler_discover
*
* DESCRIPTION: Event handler on new IP from DHCP client.
************************************************************************/
static void fapp_dhcp_handler_discover( fnet_netif_desc_t netif,void *shl_desc )
{
fnet_shell_desc_t desc = (fnet_shell_desc_t) shl_desc;
FNET_COMP_UNUSED_ARG(netif);
if(fapp_dhcp_discover_counter-- == 0)
{
fnet_shell_unblock((fnet_shell_desc_t)shl_desc);
fapp_dhcp_on_ctrlc((fnet_shell_desc_t)shl_desc); /* Cancel DHCP.*/
}
else
fnet_shell_println(desc, FAPP_DHCP_DISCOVER_STR);
}
/************************************************************************
* NAME: fapp_bench_print_results
*
* DESCRIPTION: Print Benchmark results.
************************************************************************/
static void fapp_bench_print_results (fnet_shell_desc_t desc)
{
/* Print benchmark results.*/
unsigned long interval = fnet_timer_get_interval(fapp_bench.first_time, fapp_bench.last_time);
fnet_shell_println(desc, "Results:");
if(fapp_bench.remote_bytes == 0)
{
fnet_shell_println(desc, "\t%d bytes in %d.%d seconds = %d Kbits/sec\n", fapp_bench.bytes,
((interval*FNET_TIMER_PERIOD_MS)/1000),
((interval*FNET_TIMER_PERIOD_MS)%1000)/100,
(interval == 0) ? -1 : (int)((fapp_bench.bytes*8/**(1000*//FNET_TIMER_PERIOD_MS/*)*/)/interval)/*/1000*/);
}
else /* UDP TX only */
{
fnet_shell_println(desc, "\t%d [%d] bytes in %d.%d seconds = %d [%d] Kbits/sec\n", fapp_bench.bytes, fapp_bench.remote_bytes,
((interval*FNET_TIMER_PERIOD_MS)/1000),
((interval*FNET_TIMER_PERIOD_MS)%1000)/100,
(interval == 0) ? -1 : (int)((fapp_bench.bytes*8/**(1000*//FNET_TIMER_PERIOD_MS/*)*/)/interval)/*/1000*/,
(interval == 0) ? -1 : (int)((fapp_bench.remote_bytes*8/**(1000*//FNET_TIMER_PERIOD_MS/*)*/)/interval)/*/1000*/);
}
}
/************************************************************************
* NAME: fapp_ping_handler
*
* DESCRIPTION:
************************************************************************/
static void fapp_ping_handler (fnet_error_t result, fnet_size_t packet_count, struct sockaddr *target_addr, fnet_uint32_t cookie)
{
fnet_char_t ip_str[FNET_IP_ADDR_STR_SIZE];
fnet_shell_desc_t desc = (fnet_shell_desc_t)cookie;
if(result == FNET_ERR_OK)
{
fnet_shell_println(desc, FAPP_PING_STR_REPLY, fnet_inet_ntop(target_addr->sa_family, target_addr->sa_data, ip_str, sizeof(ip_str)));
}
else if(result == FNET_ERR_TIMEDOUT)
{
fnet_shell_println(desc, FAPP_PING_STR_TIMEOUT);
}
else
{
fnet_shell_println(desc, "Error = %d", result);
}
if(packet_count == 0U)
{
fnet_shell_unblock(desc); /* Unblock the shell. */
}
}
/************************************************************************
* NAME: fapp_benchrx_cmd
*
* DESCRIPTION: Start RX Benchmark server.
************************************************************************/
void fapp_benchrx_cmd( fnet_shell_desc_t desc, int argc, char ** argv )
{
fnet_address_family_t family;
family = AF_SUPPORTED;
/* TCP */
if((argc == 1)||(argc == 2 && fnet_strcasecmp("tcp", argv[1]) == 0))
{
fapp_bench_tcp_rx(desc, family);
}
/* UDP */
else if(((argc == 2) || (argc == 3)) && fnet_strcasecmp("udp", argv[1]) == 0)
{
struct sockaddr multicast_address;
struct sockaddr *multicast_address_p = FNET_NULL;
if(argc == 3) /* Multicast group address.*/
{
if((fnet_inet_ptos(argv[2], &multicast_address) == FNET_ERR) /* Convert from string to address.*/
|| !fnet_socket_addr_is_multicast(&multicast_address) /* Check if address is multicast.*/
|| ((family & multicast_address.sa_family)==0) ) /* Check supported family.*/
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[2]);
return;
}
multicast_address_p = &multicast_address;
}
fapp_bench_udp_rx(desc, family, multicast_address_p);
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);
}
}
