/************************************************************************
* NAME: fnet_fs_release
*
* DESCRIPTION: This function releases FNET FS interface.
*************************************************************************/
void fnet_fs_release( void )
{
fnet_fs_unmount("");
fnet_fs_root_unregister();
/* Clear the rest. */
fnet_memset_zero( fnet_fs_mount_list, sizeof(struct fnet_fs_mount_point)*FNET_CFG_FS_MOUNT_MAX);
fnet_memset_zero( fnet_fs_desc_list, sizeof(struct fnet_fs_desc)*FNET_CFG_FS_DESC_MAX);
fnet_fs_list = 0;
}
/************************************************************************
* NAME: fnet_fs_unmount
*
* DESCRIPTION: Unmounts a FS.
*************************************************************************/
fnet_return_t fnet_fs_unmount( const fnet_char_t *mount_name )
{
fnet_return_t result = FNET_ERR;
struct fnet_fs_mount_point *mount_point;
struct fnet_fs *fs;
if(mount_name)
{
fnet_os_mutex_lock();
mount_point = fnet_fs_find_mount(&mount_name);
if(mount_point)
{
fs = mount_point->fs;
if(fs && (fs->operations) && (fs->operations->unmount) )
{
fs->operations->unmount(mount_point->arg);
}
fnet_memset_zero( mount_point, sizeof(struct fnet_fs_mount_point) );
result = FNET_OK;
}
fnet_os_mutex_unlock();
}
return result;
}
/************************************************************************
* NAME: fnet_arp_init
*
* DESCRIPTION: ARP module initialization.
*************************************************************************/
fnet_return_t fnet_arp_init(fnet_netif_t *netif, fnet_arp_if_t *arpif)
{
fnet_index_t i;
fnet_return_t result = FNET_ERR;
if(netif && arpif)
{
netif->arp_if_ptr = arpif;
for (i = 0U; i < FNET_CFG_ARP_TABLE_SIZE; i++)
{
fnet_memset_zero(&(arpif->arp_table[i]), sizeof(fnet_arp_entry_t));
}
#if FNET_CFG_ARP_EXPIRE_TIMEOUT
arpif->arp_tmr = fnet_timer_new((FNET_ARP_TIMER_PERIOD / FNET_TIMER_PERIOD_MS), fnet_arp_timer, (fnet_uint32_t)arpif);
#endif
if (arpif->arp_tmr)
{
/* Install event Handler. */
arpif->arp_event = fnet_event_init(fnet_arp_ip4_addr_conflict, (fnet_uint32_t)netif);
if (arpif->arp_event != FNET_ERR)
{
result = FNET_OK;
}
}
}
return result;
}
/************************************************************************
* NAME: fapp_http_cgi_stdata_handle
*
* DESCRIPTION:
*************************************************************************/
static int fapp_http_cgi_stdata_handle(char * query, long *cookie)
{
unsigned long time, t_hour, t_min, t_sec;
struct fnet_netif_statistics statistics;
FNET_COMP_UNUSED_ARG(query);
/* Get Time. */
time = fnet_timer_ticks();
t_hour = time/FNET_TIMER_TICK_IN_HOUR;
t_min = (time%FNET_TIMER_TICK_IN_HOUR)/FNET_TIMER_TICK_IN_MIN;
t_sec = (time%FNET_TIMER_TICK_IN_MIN)/FNET_TIMER_TICK_IN_SEC;
/* Get statistics. */
fnet_memset_zero( &statistics, sizeof(struct fnet_netif_statistics) );
fnet_netif_get_statistics(fapp_default_netif, &statistics);
/* Write to the temprorary buffer. */
fnet_snprintf(fapp_http_cgi_buffer, sizeof(fapp_http_cgi_buffer), "({\"time\":\"%02d:%02d:%02d\",\"tx\":%d,\"rx\":%d})",
t_hour, t_min, t_sec, statistics.tx_packet, statistics.rx_packet);
*cookie = (long)fapp_http_cgi_buffer; /* Save fapp_http_cgi_buffer as cookie.*/
return FNET_OK;
}
void fnet_raw_input_ip4( fnet_netif_t *netif, fnet_ip4_addr_t src_ip, fnet_ip4_addr_t dest_ip,
fnet_netbuf_t *nb, fnet_netbuf_t *ip4_nb)
{
struct sockaddr src_addr;
struct sockaddr dest_addr;
fnet_ip_header_t *hdr = ip4_nb->data_ptr;
fnet_memset_zero(&src_addr, sizeof(struct sockaddr));
src_addr.sa_family = AF_INET;
((struct sockaddr_in*)(&src_addr))->sin_addr.s_addr = src_ip;
fnet_memset_zero(&dest_addr, sizeof(struct sockaddr));
dest_addr.sa_family = AF_INET;
((struct sockaddr_in*)(&dest_addr))->sin_addr.s_addr = dest_ip;
fnet_raw_input(netif, &src_addr, &dest_addr, nb, hdr->protocol);
}
void fnet_raw_input_ip6(fnet_netif_t *netif, fnet_ip6_addr_t *src_ip, fnet_ip6_addr_t *dest_ip, fnet_netbuf_t *nb, fnet_netbuf_t *ip6_nb)
{
struct sockaddr src_addr;
struct sockaddr dest_addr;
fnet_ip6_header_t *hdr = ip6_nb->data_ptr;
fnet_memset_zero(&src_addr, sizeof(struct sockaddr));
src_addr.sa_family = AF_INET6;
FNET_IP6_ADDR_COPY(src_ip, &((struct sockaddr_in6 *)(&src_addr))->sin6_addr.s6_addr);
((struct sockaddr_in6 *)(&src_addr))->sin6_scope_id = netif->scope_id;
fnet_memset_zero(&dest_addr, sizeof(struct sockaddr));
dest_addr.sa_family = AF_INET6;
FNET_IP6_ADDR_COPY(dest_ip, &((struct sockaddr_in6 *)(&dest_addr))->sin6_addr.s6_addr);
((struct sockaddr_in6 *)(&dest_addr))->sin6_scope_id = netif->scope_id;
fnet_raw_input(netif, &src_addr, &dest_addr, nb, hdr->next_header);
}
/************************************************************************
* NAME: fnet_malloc
*
* DESCRIPTION: Allocates memory in heap for TCP/IP
*
*************************************************************************/
void *fnet_malloc_zero( unsigned nbytes )
{
void *result;
result = fnet_malloc(nbytes);
if(result)
{
fnet_memset_zero(result, nbytes);
}
return result;
}
/************************************************************************
* NAME: fnet_malloc
*
* DESCRIPTION: Allocates memory in heap for TCP/IP
*
*************************************************************************/
void *fnet_malloc_zero( fnet_size_t nbytes )
{
void *result;
result = fnet_malloc(nbytes);
if(result)
{
fnet_memset_zero(result, nbytes);
}
return result;
}
/************************************************************************
* DESCRIPTION: Close DIR stream.
*************************************************************************/
fnet_return_t fnet_fs_fclose( fnet_fs_file_t file)
{
fnet_return_t result = FNET_ERR;
struct fnet_fs_desc *filep = (struct fnet_fs_desc *)file;
if(filep)
{
fnet_memset_zero( filep, sizeof(struct fnet_fs_desc) ); /* clear file structure */
result = FNET_OK;
}
return result;
}
/************************************************************************
* DESCRIPTION: Close DIR stream.
*************************************************************************/
fnet_return_t fnet_fs_closedir( fnet_fs_dir_t dir)
{
fnet_return_t result = FNET_ERR;
struct fnet_fs_desc *dirp = (struct fnet_fs_desc *)dir;
if(dirp)
{
fnet_memset_zero( dirp, sizeof(struct fnet_fs_desc) ); /* clear dir structure */
result = FNET_OK;
}
return result;
}
/************************************************************************
* 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]);
}
}
int wait_dhcp(int tries) {
fnet_netif_desc_t netif;
struct fnet_dhcp_params dhcp_params;
struct callback_params_t callback_params;
/* Get Default netif */
netif = fnet_netif_get_default();
if (!netif) {
return -1;
}
/* Clear params struct */
fnet_memset_zero(&dhcp_params, sizeof(struct fnet_dhcp_params));
/* Turn on link-local support */
dhcp_params.retries_until_link_local = tries;
/* Initialise DHCP client */
if(fnet_dhcp_init(netif, &dhcp_params) == FNET_ERR) {
return -1;
}
/* Setup param for callbacks */
callback_params.max_tries = tries + 1; /* Add one so we get link local before timeout */
callback_params.cur_try = 1;
callback_params.state = WAITING;
/* Print message */
fnet_printf("\nDHCP: Waiting for server \n");
/* Register call backs */
fnet_dhcp_handler_updated_set(handler_updated, &callback_params);
fnet_dhcp_handler_discover_set(handler_discover, &callback_params);
/* Poll background services until address found or n_tries exceeded */
while (callback_params.state == WAITING) {
fnet_poll_services();
}
/* Now evaluate response */
if (callback_params.state == SUCCESS) {
fnet_printf("DHCP: Success! \n");
return 0; /* Success */
}
else {
fnet_printf("DHCP: Failed! Using link local address \n");
/* Keep DHCP server running in background */
return -1; /* Failure */
}
}
/************************************************************************
* 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: fnet_fs_closedir
*
* DESCRIPTION: Close DIR stream.
*************************************************************************/
int fnet_fs_closedir( FNET_FS_DIR dir)
{
int result = FNET_ERR;
struct fnet_fs_desc *dirp = (struct fnet_fs_desc *)dir;
if(dirp)
{
fnet_os_mutex_lock();
fnet_memset_zero( dirp, sizeof(struct fnet_fs_desc) ); /* clear dir structure */
fnet_os_mutex_unlock();
result = FNET_OK;
}
return result;
}
/************************************************************************
* NAME: fnet_fs_closedir
*
* DESCRIPTION: Close DIR stream.
*************************************************************************/
int fnet_fs_fclose( FNET_FS_FILE file)
{
int result = FNET_ERR;
struct fnet_fs_desc *filep = (struct fnet_fs_desc *)file;
if(filep)
{
fnet_os_mutex_lock();
fnet_memset_zero( filep, sizeof(struct fnet_fs_desc) ); /* clear file structure */
fnet_os_mutex_unlock();
result = FNET_OK;
}
return result;
}
static void fnet_arp_timer(fnet_uint32_t cookie)
{
fnet_arp_if_t *arpif = (fnet_arp_if_t *)cookie;
fnet_index_t i;
for (i = 0U; i < FNET_CFG_ARP_TABLE_SIZE; i++)
{
if ((arpif->arp_table[i].prot_addr) && (((fnet_timer_ticks() - arpif->arp_table[i].cr_time)) > (fnet_time_t)((FNET_CFG_ARP_EXPIRE_TIMEOUT * 1000U) / FNET_TIMER_PERIOD_MS)))
{
if (arpif->arp_table[i].hold)
{
fnet_netbuf_free_chain(arpif->arp_table[i].hold);
}
fnet_memset_zero(&(arpif->arp_table[i]), sizeof(fnet_arp_entry_t));
}
}
}
/************************************************************************
* NAME: fnet_arp_timer
*
* DESCRIPTION: ARP timer.
*************************************************************************/
static void fnet_arp_timer( void *cookie )
{
fnet_arp_if_t *arpif = (fnet_arp_if_t *)cookie;
int i;
for (i = 0; i < FNET_ARP_TABLE_SIZE; i++)
{
if((arpif->arp_table[i].prot_addr)
&& ((fnet_timer_ticks() - arpif->arp_table[i].cr_time))
> (unsigned long)(FNET_ARP_TIMEOUT / FNET_TIMER_PERIOD_MS))
{
if(arpif->arp_table[i].hold)
fnet_netbuf_free_chain(arpif->arp_table[i].hold);
fnet_memset_zero(&(arpif->arp_table[i]), sizeof(fnet_arp_entry_t));
}
}
}
/************************************************************************
* NAME: fnet_udp_rcv
*
* DESCRIPTION :UDP receive function.
*************************************************************************/
static fnet_int32_t fnet_udp_rcv(fnet_socket_if_t *sk, fnet_uint8_t *buf, fnet_size_t len, fnet_flag_t flags, struct sockaddr *addr)
{
fnet_error_t error = FNET_ERR_OK;
fnet_int32_t length;
struct sockaddr foreign_addr;
fnet_memset_zero ((void *)&foreign_addr, sizeof(foreign_addr));
#if FNET_CFG_TCP_URGENT
if(flags & MSG_OOB)
{
error = FNET_ERR_OPNOTSUPP; /* Operation not supported.*/
goto ERROR;
}
#endif /* FNET_CFG_TCP_URGENT */
if((length = fnet_socket_buffer_read_address(&(sk->receive_buffer), buf,
len, &foreign_addr, ((flags & MSG_PEEK)== 0u)?FNET_TRUE:FNET_FALSE)) == FNET_ERR)
{
/* The message was too large to fit into the specified buffer and was truncated.*/
error = FNET_ERR_MSGSIZE;
goto ERROR;
}
if(sk->options.local_error == FNET_ERR_OK)
{
if(addr)
{
fnet_socket_addr_copy(&foreign_addr, addr);
}
return (length);
}
else /* We get UDP or ICMP error.*/
{
error = sk->options.local_error;
}
ERROR:
fnet_socket_set_error(sk, error);
return (FNET_ERR);
}
/************************************************************************
* NAME: fnet_fs_opendir
*
* DESCRIPTION: Open DIR stream.
*************************************************************************/
fnet_fs_dir_t fnet_fs_opendir( const fnet_char_t *dirname)
{
fnet_fs_dir_t result = 0;
fnet_index_t i;
struct fnet_fs_desc *dir = 0;
struct fnet_fs_mount_point *mount_point;
if(dirname)
{
fnet_os_mutex_lock();
for(i=0U; i < FNET_CFG_FS_DESC_MAX; i++) /* Free descriptor? */
{
if(fnet_fs_desc_list[i].id == 0u)
{
dir = &fnet_fs_desc_list[i]; /* found free DIR descriptor */
break;
}
}
if(dir) /* Found free descriptor. */
{
mount_point = fnet_fs_find_mount(&dirname);
if(mount_point && (mount_point->fs) && (mount_point->fs->dir_operations)
&& (mount_point->fs->dir_operations->opendir))
{
dir->mount = mount_point;
if(mount_point->fs->dir_operations->opendir(dir, dirname) == FNET_OK)
{
result = dir;
}
else
{
fnet_memset_zero( dir, sizeof(struct fnet_fs_desc) ); /* clear dir structure */
}
}
}
fnet_os_mutex_unlock();
}
return result;
}
/************************************************************************
* NAME: fnet_arp_init
*
* DESCRIPTION: ARP module initialization.
*************************************************************************/
int fnet_arp_init( fnet_netif_t *netif )
{
fnet_arp_if_t *arpif = &(((fnet_eth_if_t *)(netif->if_ptr))->arp_if);
int i;
int result= FNET_ERR;
for (i = 0; i < FNET_ARP_TABLE_SIZE; i++)
fnet_memset_zero(&(arpif->arp_table[i]), sizeof(fnet_arp_entry_t));
arpif->arp_tmr = fnet_timer_new((FNET_ARP_TIMER_PERIOD / FNET_TIMER_PERIOD_MS),
fnet_arp_timer, arpif);
if(arpif->arp_tmr)
{
/* Install event Handler. */
arpif->arp_event = fnet_event_init(fnet_arp_ip_duplicated, netif);
if(arpif->arp_event != FNET_ERR)
result = FNET_OK;
}
return result;
}
/************************************************************************
* NAME: fapp_llmnr_cmd
*
* DESCRIPTION: Run LLMNR server.
*************************************************************************/
void fapp_llmnr_cmd( fnet_shell_desc_t desc, int argc, char ** argv )
{
struct fnet_llmnr_params params;
fnet_llmnr_desc_t llmnr_desc;
if(argc == 1) /* By default is "init".*/
{
/* Init parameters.*/
fnet_memset_zero(¶ms, sizeof(params));
params.netif_desc = fapp_default_netif;
params.host_name = fapp_params_host_name;
/* Start LLMNR server */
llmnr_desc = fnet_llmnr_init(¶ms);
if(llmnr_desc != FNET_ERR)
{
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fnet_shell_println(desc, " LLMNR server started.");
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Host Name", params.host_name );
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fapp_llmnr_desc = llmnr_desc;
}
else
{
fnet_shell_println(desc, FAPP_INIT_ERR, "LLMNR");
}
}
else if(argc == 2 && fnet_strcasecmp(&FAPP_COMMAND_RELEASE[0], argv[1]) == 0) /* [release] */
{
fapp_llmnr_release();
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);
}
}
/************************************************************************
* NAME: fapp_bench_tcp_rx
*
* DESCRIPTION: Start Benchmark TCP server.
************************************************************************/
static void fapp_bench_tcp_rx (fnet_shell_desc_t desc, fnet_address_family_t family)
{
struct sockaddr local_addr;
int received;
char ip_str[FNET_IP_ADDR_STR_SIZE];
struct linger linger_option ={1, /*l_onoff*/
4 /*l_linger*/};
unsigned long bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;
int keepalive_option = 1;
int keepcnt_option = FAPP_BENCH_TCP_KEEPCNT;
int keepintvl_option = FAPP_BENCH_TCP_KEEPINTVL;
int keepidle_option = FAPP_BENCH_TCP_KEEPIDLE;
struct sockaddr foreign_addr;
unsigned int addr_len;
int exit_flag = 0;
fapp_bench.socket_foreign = SOCKET_INVALID;
/* Create listen socket */
if((fapp_bench.socket_listen = socket(family, SOCK_STREAM, 0)) == SOCKET_INVALID)
{
FNET_DEBUG("BENCH: Socket creation error.");
goto ERROR_1;
}
/* Bind socket.*/
fnet_memset_zero(&local_addr, sizeof(local_addr));
local_addr.sa_port = FAPP_BENCH_PORT;
local_addr.sa_family = family;
if(bind(fapp_bench.socket_listen, &local_addr, sizeof(local_addr)) == SOCKET_ERROR)
{
FNET_DEBUG("BENCH: Socket bind error.");
goto ERROR_2;
}
/* Set Socket options. */
if( /* Setup linger option. */
(setsockopt (fapp_bench.socket_listen, SOL_SOCKET, SO_LINGER, (char *)&linger_option, sizeof(linger_option)) == SOCKET_ERROR) ||
/* Set socket buffer size. */
(setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_RCVBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||
(setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_SNDBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||
/* Enable keepalive_option option. */
(setsockopt (fapp_bench.socket_listen, SOL_SOCKET, SO_KEEPALIVE, (char *)&keepalive_option, sizeof(keepalive_option)) == SOCKET_ERROR) ||
/* Keepalive probe retransmit limit. */
(setsockopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPCNT, (char *)&keepcnt_option, sizeof(keepcnt_option)) == SOCKET_ERROR) ||
/* Keepalive retransmit interval.*/
(setsockopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPINTVL, (char *)&keepintvl_option, sizeof(keepintvl_option)) == SOCKET_ERROR) ||
/* Time between keepalive probes.*/
(setsockopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPIDLE, (char *)&keepidle_option, sizeof(keepidle_option)) == SOCKET_ERROR)
)
{
FNET_DEBUG("BENCH: Socket setsockopt error.\n");
goto ERROR_2;
}
/* Listen. */
if(listen(fapp_bench.socket_listen, 1) == SOCKET_ERROR)
{
FNET_DEBUG("BENCH: Socket listen error.\n");
goto ERROR_2;
}
/* ------ Start test.----------- */
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fnet_shell_println(desc, " TCP RX Test");
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fapp_netif_addr_print(desc, family, fapp_default_netif, FNET_FALSE);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Local Port", FNET_NTOHS(FAPP_BENCH_PORT));
fnet_shell_println(desc, FAPP_TOCANCEL_STR);
fnet_shell_println(desc, FAPP_DELIMITER_STR);
while(exit_flag == 0)
{
fnet_shell_println(desc, "Waiting.");
fapp_bench.bytes = 0;
fapp_bench.remote_bytes = 0;
if(fapp_bench.socket_foreign != SOCKET_INVALID)
{
closesocket(fapp_bench.socket_foreign);
fapp_bench.socket_foreign = SOCKET_INVALID;
}
while((fapp_bench.socket_foreign == SOCKET_INVALID) && (exit_flag == 0))
{
/*Accept*/
addr_len = sizeof(foreign_addr);
fapp_bench.socket_foreign = accept(fapp_bench.socket_listen, &foreign_addr, &addr_len);
exit_flag = fnet_shell_ctrlc (desc);
if(fapp_bench.socket_foreign != SOCKET_INVALID)
{
fnet_shell_println(desc,"Receiving from %s:%d", fnet_inet_ntop(foreign_addr.sa_family, (char*)(foreign_addr.sa_data), ip_str, sizeof(ip_str)), fnet_ntohs(foreign_addr.sa_port));
fapp_bench.first_time = fnet_timer_ticks();
while(1) /* Receiving data.*/
{
received = recv(fapp_bench.socket_foreign, (char*)(&fapp_bench.buffer[0]), FAPP_BENCH_BUFFER_SIZE, 0);
if ((received == SOCKET_ERROR) || exit_flag)
{
fapp_bench.last_time = fnet_timer_ticks();
/* Print benchmark results.*/
fapp_bench_print_results (desc);
break;
}
else
{
fapp_bench.bytes += received;
}
exit_flag = fnet_shell_ctrlc (desc); /* Check [Ctrl+c]*/
}
}
}
}
closesocket(fapp_bench.socket_foreign);
ERROR_2:
closesocket(fapp_bench.socket_listen);
ERROR_1:
fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);
}
/************************************************************************
* NAME: fapp_ping_cmd
*
* DESCRIPTION: Ping command.
************************************************************************/
void fapp_ping_cmd( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t ** argv )
{
struct fnet_ping_params ping_params;
fnet_index_t i;
fnet_char_t *p;
fnet_uint32_t value;
fnet_char_t ip_str[FNET_IP_ADDR_STR_SIZE];
fnet_memset_zero(&ping_params, sizeof(ping_params));
ping_params.cookie = (fnet_uint32_t)desc;
ping_params.handler = fapp_ping_handler;
ping_params.packet_size = FAPP_PING_DEFAULT_SIZE;
ping_params.timeout = FAPP_PING_DEFAULT_TIMEOUT;
ping_params.pattern = FAPP_PING_DEFAULT_PATTERN;
ping_params.ttl = FAPP_PING_DEFAULT_HOP_LIMIT;
ping_params.packet_count = FAPP_PING_DEFAULT_NUMBER;
/* Last parameter must be ip address.*/
i = (argc-1u);
if(fnet_inet_ptos(argv[i], &ping_params.target_addr) == FNET_ERR)
{
goto ERROR_PARAMETER;
}
else
{
/* TBD Optimise parameters parsing.*/
if(argc > 2u) /* There are additional parameters */
{
/* [-c <count>][-i <seconds>]\n\t[-p <pattern>][-s <size>][-h <hoplimit/ttl>] */
for(i=1u; i<(fnet_index_t)(argc-1u); i++)
{
if (!fnet_strcmp(argv[i], "-c"))
{
i++;
value = fnet_strtoul(argv[i], &p, 10u);
if ((value == 0U) && (p == argv[i]))
{
goto ERROR_PARAMETER;
}
else
{
ping_params.packet_count = value;
}
}
else if (!fnet_strcmp(argv[i], "-i"))
{
i++;
value = fnet_strtoul(argv[i], &p, 10u);
if ((value == 0U) && (p == argv[i]))
{
goto ERROR_PARAMETER;
}
else
{
ping_params.timeout = value*1000U;
}
}
else if (!fnet_strcmp(argv[i], "-p"))
{
i++;
value = fnet_strtoul(argv[i], &p, 10u);
if ((value == 0U) && (p == argv[i]))
{
goto ERROR_PARAMETER;
}
else
{
ping_params.pattern = (fnet_uint8_t)value;
}
}
else if (!fnet_strcmp(argv[i], "-s"))
{
i++;
value = fnet_strtoul(argv[i], &p, 10u);
if ((value == 0U) && (p == argv[i]))
{
goto ERROR_PARAMETER;
}
else
{
ping_params.packet_size = (fnet_size_t)value;
}
}
else if (!fnet_strcmp(argv[i], "-h"))
{
i++;
value = fnet_strtoul(argv[i], &p, 10u);
if ((value == 0U) && (p == argv[i]))
{
goto ERROR_PARAMETER;
}
else
{
ping_params.ttl = (fnet_uint8_t)value;
}
}
else if (!fnet_strcmp(argv[i], "-n"))
{
/* Just ignore the -n parameter.*/
}
else if (!fnet_strcmp(argv[i], "-I"))
{
i++;
/* Just ignore the -I parameter and its value.*/
}
else /* Wrong parameter.*/
{
goto ERROR_PARAMETER;
}
}
}
if(fnet_ping_request(&ping_params) == FNET_OK)
{
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fnet_shell_println(desc, " PING" );
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Remote IP addr", fnet_inet_ntop(ping_params.target_addr.sa_family, ping_params.target_addr.sa_data, ip_str, sizeof(ip_str)));
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Message Size", ping_params.packet_size>FNET_CFG_PING_PACKET_MAX?FNET_CFG_PING_PACKET_MAX:ping_params.packet_size);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Num. of messages", ping_params.packet_count);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Pattern", ping_params.pattern);
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Hoplimit (TTL)", ping_params.ttl);
fnet_shell_println(desc, FAPP_TOCANCEL_STR);
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fnet_shell_block(desc, fapp_ping_on_ctrlc); /* Block shell. */
}
else
{
fnet_shell_println(desc, FAPP_INIT_ERR, "PING");
}
}
return;
ERROR_PARAMETER:
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[i]);
return;
}
/************************************************************************
* NAME: fnet_malloc
*
* DESCRIPTION: Allocates memory in the memory pool.
*
*************************************************************************/
#if FNET_MEMPOOL_MALLOC_BEST_CHOICE /* Choose the best. */
void *fnet_mempool_malloc(fnet_mempool_desc_t mpool, unsigned nbytes )
{
struct fnet_mempool * mempool = (struct fnet_mempool *)mpool;
fnet_mempool_unit_header_t *p, *prevp;
fnet_mempool_unit_header_t *best_p =0;
fnet_mempool_unit_header_t *best_p_prev =0;
unsigned nunits;
void * res;
fnet_isr_lock();
nunits = ((nbytes + mempool->unit_size - 1) / mempool->unit_size) + 1;
prevp = mempool->free_ptr;
best_p_prev = prevp;
/* Find the best one. */
for(p = prevp->ptr; ; prevp = p, p = p->ptr)
{
if( (p->size >= nunits) && ( (best_p==0) || ((best_p)&&(best_p->size > p->size)) ) )
{
best_p_prev = prevp;
best_p = p;
}
if(p == mempool->free_ptr)
break; /* End of list is reached. */
}
if(best_p)
{
if(best_p->size == nunits)
{
best_p_prev->ptr = best_p->ptr;
}
else
{
best_p->size -= nunits; /* Put to the top. */
best_p = (fnet_mempool_unit_header_t *)((unsigned long)best_p + best_p->size*mempool->unit_size);
best_p->size = nunits;
}
mempool->free_ptr = best_p_prev;
res = (void *)((unsigned long)best_p + mempool->unit_size);
#if 0 /* Clear mem.*/
fnet_memset_zero( res, (nunits-1)* mempool->unit_size );
#endif
}
else
{
/* Break here to detect allocation errors */
res = 0;
}
#if FNET_DEBUG_MEMPOOL_CHECK
if(res)
{
int i;
for(i=DEBUG_last_free_addr_num; i<DEBUG_ALLOCATED_ADDR_MAX; i++)
{
if(DEBUG_allocated_addr[i].address == 0)
{
/* Save allocated address */
DEBUG_allocated_addr[i].address = res;
DEBUG_allocated_addr[i].size = nunits;
break;
}
}
if( i==DEBUG_ALLOCATED_ADDR_MAX)
fnet_println ("Addr_table_overload!!!");
}
#endif
fnet_isr_unlock();
return res;
}
/************************************************************************
* NAME: fnet_fs_fopen
*
* DESCRIPTION: Opens the specified file relative to.
*************************************************************************/
fnet_fs_file_t fnet_fs_fopen_re(const fnet_char_t *filename, const fnet_char_t *mode, fnet_fs_dir_t dir )
{
fnet_uint8_t mode_in = 0U;
fnet_fs_file_t result = 0;
fnet_index_t i;
struct fnet_fs_desc *file = 0;
struct fnet_fs_mount_point *mount_point;
struct fnet_fs_desc *cur_dir = (struct fnet_fs_desc *) dir;
if(filename && mode)
{
/* Parse the file mode. */
switch(*mode)
{
case 'r':
mode_in = FNET_FS_MODE_READ|FNET_FS_MODE_OPEN_EXISTING;
break;
case 'w':
mode_in = FNET_FS_MODE_WRITE|FNET_FS_MODE_OPEN_ALWAYS|FNET_FS_MODE_OPEN_TRUNC;
break;
case 'a':
mode_in = FNET_FS_MODE_WRITE|FNET_FS_MODE_OPEN_ALWAYS|FNET_FS_MODE_END;
break;
default:
break;
}
if(mode_in) /* Is mode correct? */
{
mode++;
if(*mode == 'b') /* Text and binary is the same for us. */
{
mode++;
}
if(*mode == '+')
{
mode_in |= FNET_FS_MODE_READ|FNET_FS_MODE_WRITE;
}
fnet_os_mutex_lock();
for(i=0u; i < FNET_CFG_FS_DESC_MAX; i++) /* Free descriptor? */
{
if(fnet_fs_desc_list[i].id == 0u)
{
file = &fnet_fs_desc_list[i]; /* found free DIR descriptor */
break;
}
}
if(file) /* Found free descriptor. */
{
if(cur_dir)
{
mount_point = cur_dir->mount;
}
else
{
mount_point = fnet_fs_find_mount(&filename);
}
if(mount_point && (mount_point->fs)
&& (mount_point->fs->file_operations)
&& (mount_point->fs->file_operations->fopen))
{
file->mount = mount_point;
if(mount_point->fs->file_operations->fopen(file, filename, mode_in, cur_dir) == FNET_OK)
{
result = file;
}
else
{
fnet_memset_zero( file, sizeof(struct fnet_fs_desc) ); /* clear file structure */
}
}
}
fnet_os_mutex_unlock();
}
}
return result;
}
/************************************************************************
* NAME: fnet_eth_init
*
* DESCRIPTION: Do initialization for an Ethernet-type interface.
*************************************************************************/
fnet_return_t fnet_eth_init( fnet_netif_t *netif)
{
fnet_return_t result = FNET_ERR;
fnet_eth_if_t *eth_if = (fnet_eth_if_t *)(netif->if_ptr);
if(eth_if)
{
#if !FNET_CFG_CPU_ETH_MIB
/* Clear Ethernet statistics. */
fnet_memset_zero(ð_if->statistics, sizeof(struct fnet_netif_statistics));
#endif
#if FNET_CFG_IP4
result = fnet_arp_init(netif, ð_if->arp_if); /* Init ARP for this interface.*/
#else
result = FNET_OK;
#endif /* FNET_CFG_IP4 */
if(result == FNET_OK)
{
#if FNET_CFG_IP6
#if FNET_CFG_IP6_PMTU_DISCOVERY
fnet_netif_pmtu_init(netif);
#endif
/* Init Neighbor Discovery.*/
if( ( result = fnet_nd6_init (netif, ð_if->nd6_if) ) == FNET_OK)
{
/* RFC4861 6.3.3: The host joins the all-nodes multicast address on all
* multicastcapable interfaces.
*/
fnet_ip6_multicast_join(netif, &fnet_ip6_addr_linklocal_allnodes);
/* To speed the autoconfiguration process, a host may generate its linklocal
* address (and verify its uniqueness) in parallel with waiting
* for a Router Advertisement. Because a router may delay responding to
* a Router Solicitation for a few seconds, the total time needed to
* complete autoconfiguration can be significantly longer if the two
* steps are done serially.
*/
/* Link-Local Address Generation/Auto configuration.
* It comprises of '1111111010' as the first ten bits followed by 54 zeroes
* and a 64 bit interface identifier.
* For all autoconfiguration types, a link-local address is always configured.
*/
fnet_netif_bind_ip6_addr_prv( netif, &fnet_ip6_addr_any, FNET_NETIF_IP_ADDR_TYPE_AUTOCONFIGURABLE,
FNET_NETIF_IP6_ADDR_LIFETIME_INFINITE /*in seconds*/, FNET_ND6_PREFIX_LENGTH_DEFAULT /* bits */ );
/* RFC4862: The next phase of autoconfiguration involves obtaining a Router
* Advertisement or determining that no routers are present. If routers
* are present, they will send Router Advertisements that specify what
* sort of autoconfiguration a host can do.
* To obtain an advertisement quickly, a host sends one or more Router
* Solicitations to the all-routers multicast group.
*/
fnet_nd6_rd_start(netif);
}
#endif /* FNET_CFG_IP6 */
/* Set connection flag. */
eth_if->connection_flag = fnet_netif_is_connected(netif);
eth_if->eth_timer = fnet_timer_new((FNET_ETH_TIMER_PERIOD / FNET_TIMER_PERIOD_MS), fnet_eth_timer, (fnet_uint32_t)netif);
fnet_eth_number++;
}
}
return result;
}
/************************************************************************
* NAME: fnet_dns_state_machine
*
* DESCRIPTION: DNS-client state machine.
************************************************************************/
static void fnet_dns_state_machine( void *fnet_dns_if_p )
{
int sent_size;
int received;
unsigned int i;
fnet_dns_header_t *header;
fnet_dns_rr_header_t *rr_header;
fnet_dns_if_t *dns_if = (fnet_dns_if_t *)fnet_dns_if_p;
switch(dns_if->state)
{
/*---- TX --------------------------------------------*/
case FNET_DNS_STATE_TX:
FNET_DEBUG_DNS("Sending query...");
sent_size = send(dns_if->socket_cln, dns_if->message, dns_if->message_size, 0U);
if (sent_size != (int)dns_if->message_size)
{
dns_if->state = FNET_DNS_STATE_RELEASE; /* ERROR */
}
else
{
dns_if->last_time = fnet_timer_ticks();
dns_if->state = FNET_DNS_STATE_RX;
}
break;
/*---- RX -----------------------------------------------*/
case FNET_DNS_STATE_RX:
/* Receive data */
received = recv(dns_if->socket_cln, dns_if->message, sizeof(dns_if->message), 0U);
if(received > 0 )
{
header = (fnet_dns_header_t *)fnet_dns_if.message;
if((header->id == dns_if->id) && /* Check the ID.*/
((header->flags & FNET_DNS_HEADER_FLAGS_QR)==FNET_DNS_HEADER_FLAGS_QR)) /* Is response.*/
{
for (i=(sizeof(fnet_dns_header_t)-1U); i < (unsigned int)received; i++)
{
/* [RFC1035 4.1.4.] In order to reduce the size of messages, the domain system utilizes a
* compression scheme which eliminates the repetition of domain names in a
* message. In this scheme, an entire domain name or a list of labels at
* the end of a domain name is replaced with a pointer to a prior occurance
* of the same name.
* The pointer takes the form of a two octet sequence:
* +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
* | 1 1| OFFSET |
* +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
*/
/* => Check for 0xC0. */
if ((unsigned char)dns_if->message[i] == FNET_DNS_NAME_COMPRESSED_MASK) /* look for the beginnig of the response (Question Name == 192 (label compression))*/
{
rr_header = (fnet_dns_rr_header_t *)&dns_if->message[i];
/* Check Question Type, Class and Resource Data Length. */
if ( (rr_header->type == dns_if->dns_type) &&
(rr_header->rr_class == FNET_HTONS(FNET_DNS_HEADER_CLASS_IN)))
{
/* Resolved.*/
if(rr_header->type == FNET_HTONS(FNET_DNS_TYPE_A))
{
dns_if->resolved_ip4_addr[dns_if->addr_number].ip4_addr = *((fnet_ip4_addr_t*)(&rr_header->rdata));
dns_if->resolved_ip4_addr[dns_if->addr_number].ttl = rr_header->ttl;
}
else /* AF_INET6 */
{
FNET_IP6_ADDR_COPY( (fnet_ip6_addr_t*)(&rr_header->rdata), &dns_if->resolved_ip6_addr[dns_if->addr_number].ip6_addr );
dns_if->resolved_ip6_addr[dns_if->addr_number].ttl = rr_header->ttl;
}
dns_if->addr_number++;
}
i+=(unsigned int)(sizeof(fnet_dns_rr_header_t)+fnet_ntohs(rr_header->rdlength)-4U-1U);
}
}
}
/* else = wrong message.*/
dns_if->state = FNET_DNS_STATE_RELEASE;
}
else if(received == SOCKET_ERROR) /* Check error.*/
{
dns_if->state = FNET_DNS_STATE_RELEASE; /* ERROR */
}
else /* No data. Check timeout */
if(fnet_timer_get_interval(dns_if->last_time, fnet_timer_ticks()) > ((FNET_CFG_DNS_RETRANSMISSION_TIMEOUT*1000U)/FNET_TIMER_PERIOD_MS))
{
dns_if->iteration++;
if(dns_if->iteration > FNET_CFG_DNS_RETRANSMISSION_MAX)
{
dns_if->state = FNET_DNS_STATE_RELEASE; /* ERROR */
}
else
{
dns_if->state = FNET_DNS_STATE_TX;
}
}
else
{}
break;
/*---- RELEASE -------------------------------------------------*/
case FNET_DNS_STATE_RELEASE:
{
struct fnet_dns_resolved_addr *addr_list = FNET_NULL;
fnet_dns_release();
/* Fill fnet_dns_resolved_addr */
if(dns_if->addr_number > 0)
{
if(dns_if->addr_family == AF_INET)
{
for(i=0; i<dns_if->addr_number; i++)
{
fnet_memset_zero(&dns_if->resolved_ip4_addr_sock[i].resolved_addr, sizeof(dns_if->resolved_ip4_addr_sock[i].resolved_addr));
dns_if->resolved_ip4_addr_sock[i].resolved_addr.sa_family = AF_INET;
((struct sockaddr_in*)(&dns_if->resolved_ip4_addr_sock[i].resolved_addr))->sin_addr.s_addr = dns_if->resolved_ip4_addr[i].ip4_addr;
dns_if->resolved_ip4_addr_sock[i].resolved_addr_ttl = dns_if->resolved_ip4_addr[i].ttl;
}
addr_list = dns_if->resolved_ip4_addr_sock;
}
else if(dns_if->addr_family == AF_INET6)
{
for(i=0; i<dns_if->addr_number; i++)
{
fnet_memset_zero(&dns_if->resolved_ip6_addr_sock[i].resolved_addr, sizeof(dns_if->resolved_ip4_addr_sock[i].resolved_addr));
dns_if->resolved_ip6_addr_sock[i].resolved_addr.sa_family = AF_INET6;
FNET_IP6_ADDR_COPY(&dns_if->resolved_ip6_addr[i].ip6_addr, &((struct sockaddr_in6*)(&dns_if->resolved_ip6_addr_sock[i].resolved_addr))->sin6_addr.s6_addr);
dns_if->resolved_ip6_addr_sock[i].resolved_addr_ttl = dns_if->resolved_ip6_addr[i].ttl;
}
addr_list = dns_if->resolved_ip6_addr_sock;
}
else
{}
}
dns_if->handler(addr_list, dns_if->addr_number, dns_if->handler_cookie); /* User Callback.*/
}
break;
default:
break;
}
}
/************************************************************************
* NAME: fapp_bench_udp_rx
*
* DESCRIPTION: Start Benchmark UDP server.
************************************************************************/
static void fapp_bench_udp_rx (fnet_shell_desc_t desc, fnet_address_family_t family, struct sockaddr *multicast_address /* optional, set to 0*/)
{
struct sockaddr local_addr;
const unsigned long bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;
int received;
char ip_str[FNET_IP_ADDR_STR_SIZE];
struct sockaddr addr;
unsigned int addr_len;
int is_first = 1;
int exit_flag = 0;
/* Create listen socket */
if((fapp_bench.socket_listen = socket(family, SOCK_DGRAM, 0)) == SOCKET_INVALID)
{
FNET_DEBUG("BENCH: Socket creation error.\n");
goto ERROR_1;
}
/*Bind.*/
fnet_memset_zero(&local_addr, sizeof(local_addr));
local_addr.sa_port = FAPP_BENCH_PORT;
local_addr.sa_family = family;
if(bind(fapp_bench.socket_listen, &local_addr, sizeof(local_addr)) == SOCKET_ERROR)
{
FNET_DEBUG("BENCH: Socket bind error.\n");
goto ERROR_2;
}
/* Set socket options. */
if(
/* Set socket buffer size. */
(setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_RCVBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||
(setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_SNDBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR)
)
{
FNET_DEBUG("BENCH: Socket setsockopt error.\n");
goto ERROR_2;
}
/* Join multicast group, if set. */
if(multicast_address)
{
#if FNET_CFG_IP4
if(multicast_address->sa_family == AF_INET)
{
struct ip_mreq mreq; /* Multicast group information.*/
mreq.imr_multiaddr.s_addr = ((struct sockaddr_in*)multicast_address)->sin_addr.s_addr;
mreq.imr_interface.s_addr = FNET_HTONL(INADDR_ANY); /* Default Interface.*/
/* Join multicast group. */
if(setsockopt(fapp_bench.socket_listen, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq)) == SOCKET_ERROR)
{
FNET_DEBUG("BENCH: Joining to multicast group is failed.\n");
goto ERROR_2;
}
}
#endif
#if FNET_CFG_IP6
if(multicast_address->sa_family == AF_INET6)
{
struct ipv6_mreq mreq6; /* Multicast group information.*/
FNET_IP6_ADDR_COPY(&((struct sockaddr_in6*)multicast_address)->sin6_addr.s6_addr, &mreq6.ipv6imr_multiaddr.s6_addr);
mreq6.ipv6imr_interface = ((struct sockaddr_in6*)multicast_address)->sin6_scope_id;
/* Join multicast group. */
if(setsockopt(fapp_bench.socket_listen, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *)&mreq6, sizeof(mreq6)) == SOCKET_ERROR)
{
FNET_DEBUG("BENCH: Joining to multicast group is failed.\n");
goto ERROR_2;
}
}
#endif
}
/* ------ Start test.----------- */
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fnet_shell_println(desc, " UDP RX Test" );
fnet_shell_println(desc, FAPP_DELIMITER_STR);
fapp_netif_addr_print(desc, family, fapp_default_netif, FNET_FALSE);
if(multicast_address)
{
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Multicast Group", fnet_inet_ntop(multicast_address->sa_family, (char*)(multicast_address->sa_data), ip_str, sizeof(ip_str)) );
}
fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Local Port", FNET_NTOHS(FAPP_BENCH_PORT));
fnet_shell_println(desc, FAPP_TOCANCEL_STR);
fnet_shell_println(desc, FAPP_DELIMITER_STR);
while(exit_flag == 0) /* Main loop */
{
fnet_shell_println(desc, "Waiting.");
fapp_bench.bytes = 0;
fapp_bench.remote_bytes = 0;
addr_len = sizeof(addr);
is_first = 1;
while(exit_flag == 0) /* Test loop. */
{
/* Receive data */
received = recvfrom (fapp_bench.socket_listen, (char*)(&fapp_bench.buffer[0]), FAPP_BENCH_BUFFER_SIZE, 0,
&addr, &addr_len );
if(received >= FAPP_BENCH_UDP_END_BUFFER_LENGTH)
{
/* Reset timeout. */
fapp_bench.last_time = fnet_timer_ticks();
if(is_first)
{
if( received > FAPP_BENCH_UDP_END_BUFFER_LENGTH )
{
fnet_shell_println(desc,"Receiving from %s:%d", fnet_inet_ntop(addr.sa_family, (char*)(addr.sa_data), ip_str, sizeof(ip_str)), fnet_ntohs(addr.sa_port));
fapp_bench.first_time = fnet_timer_ticks();
is_first = 0;
}
}
else
{
if(received == FAPP_BENCH_UDP_END_BUFFER_LENGTH ) /* End of transfer. */
{
/* Send ACK containing amount of received data.*/
unsigned long ack_bytes = fnet_htonl(fapp_bench.bytes);
/* Send several times, just to be sure that it is received/not lost.*/
sendto(fapp_bench.socket_listen, (char*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));
sendto(fapp_bench.socket_listen, (char*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));
sendto(fapp_bench.socket_listen, (char*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));
/* Print benchmark results.*/
fapp_bench_print_results (desc);
break;
}
else
fapp_bench.bytes += received;
}
}
else
{
/* Check error. Check timeout */
if(received == SOCKET_ERROR)
{
fnet_shell_println(desc, "BENCH: Error (%d).", fnet_error_get());
break;
}
/* Check timeout. */
if((is_first == 0) &&
(fnet_timer_get_interval(fapp_bench.last_time, fnet_timer_ticks()) > (FAPP_UDP_TIMEOUT_MS/FNET_TIMER_PERIOD_MS)))
{
fnet_shell_println(desc, "BENCH: Exit on timeout.");
fapp_bench_print_results (desc);
break;
}
}
exit_flag = fnet_shell_ctrlc (desc);
}
}
ERROR_2:
closesocket(fapp_bench.socket_listen);
ERROR_1:
fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);
}
/************************************************************************
* NAME: fapp_benchtx_cmd
*
* DESCRIPTION: Start TX Benchmark.
************************************************************************/
void fapp_benchtx_cmd( fnet_shell_desc_t desc, int argc, char ** argv )
{
struct fapp_bench_tx_params bench_params;
fnet_memset_zero(&bench_params.foreign_addr, sizeof(bench_params.foreign_addr));
if(fnet_inet_ptos(argv[1], &bench_params.foreign_addr) == FNET_OK)
{
bench_params.desc = desc;
bench_params.foreign_addr.sa_port = FAPP_BENCH_PORT;
bench_params.packet_size = FAPP_BENCH_TX_PACKET_SIZE_DEFAULT;
bench_params.packet_number = FAPP_BENCH_TX_PACKET_NUMBER_DEFAULT;
bench_params.iteration_number = FAPP_BENCH_TX_ITERATION_NUMBER_DEFAULT;
if(argc > 3)
{
char *p = 0;
/* Packet size.*/
bench_params.packet_size = (int)fnet_strtoul(argv[3], &p, 0);
if ((bench_params.packet_size == 0) || (bench_params.packet_size > FAPP_BENCH_PACKET_SIZE_MAX))
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[3]); /* Print error mesage. */
return;
}
/* Number of packets.*/
if(argc > 4)
{
bench_params.packet_number = (int)fnet_strtoul(argv[4], &p, 0);
if (bench_params.packet_number == 0)
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[4]); /* Print error mesage. */
return;
}
/* Number of iterations.*/
if(argc > 5)
{
bench_params.iteration_number = (int)fnet_strtoul(argv[5], &p, 0);
if ((bench_params.iteration_number < 1) || (bench_params.iteration_number > FAPP_BENCH_TX_ITERATION_NUMBER_MAX) )
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[5]); /* Print error mesage. */
return;
}
}
}
}
/* TCP */
if((argc == 2)||(argc >= 3 && fnet_strcasecmp("tcp", argv[2]) == 0))
{
fapp_bench_tcp_tx (&bench_params);
}
/* UDP */
else if(argc >= 3 && fnet_strcasecmp("udp", argv[2]) == 0)
{
fapp_bench_udp_tx (&bench_params);
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[2]);
}
}
else
{
fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]); /* Wrong Benchmark Server IP address. */
return;
}
}
/************************************************************************
* NAME: fnet_dns_init
*
* DESCRIPTION: Initializes DNS client service and starts the host
* name resolving.
************************************************************************/
int fnet_dns_init( struct fnet_dns_params *params )
{
const unsigned long bufsize_option = FNET_DNS_MESSAGE_SIZE;
unsigned int total_length;
unsigned long host_name_length;
struct sockaddr remote_addr;
fnet_dns_header_t *header;
/* Check input parameters. */
if((params == 0)
|| (params->dns_server_addr.sa_family == AF_UNSPEC)
|| fnet_socket_addr_is_unspecified(¶ms->dns_server_addr)
|| (params->handler == 0)
/* Check length of host_name.*/
|| ((host_name_length = fnet_strlen(params->host_name)) == 0U) || (host_name_length >= FNET_DNS_MAME_SIZE))
{
FNET_DEBUG_DNS(FNET_DNS_ERR_PARAMS);
goto ERROR;
}
/* Check if DNS service is free.*/
if(fnet_dns_if.state != FNET_DNS_STATE_DISABLED)
{
FNET_DEBUG_DNS(FNET_DNS_ERR_IS_INITIALIZED);
goto ERROR;
}
/* Save input parmeters.*/
fnet_dns_if.handler = params->handler;
fnet_dns_if.handler_cookie = params->cookie;
fnet_dns_if.addr_family = params->addr_family;
fnet_dns_if.addr_number = 0;
if(params->addr_family == AF_INET)
{
fnet_dns_if.dns_type = FNET_HTONS(FNET_DNS_TYPE_A);
}
else
if(params->addr_family == AF_INET6)
{
fnet_dns_if.dns_type = FNET_HTONS(FNET_DNS_TYPE_AAAA);
}
else
{
FNET_DEBUG_DNS(FNET_DNS_ERR_PARAMS);
goto ERROR;
}
fnet_dns_if.iteration = 0U; /* Reset iteration counter.*/
fnet_dns_if.id++; /* Change query ID.*/
/* Create socket */
if((fnet_dns_if.socket_cln = socket(params->dns_server_addr.sa_family, SOCK_DGRAM, 0)) == SOCKET_INVALID)
{
FNET_DEBUG_DNS(FNET_DNS_ERR_SOCKET_CREATION);
goto ERROR;
}
/* Set socket options */
setsockopt(fnet_dns_if.socket_cln, SOL_SOCKET, SO_RCVBUF, (const char *)&bufsize_option, sizeof(bufsize_option));
setsockopt(fnet_dns_if.socket_cln, SOL_SOCKET, SO_SNDBUF, (const char *)&bufsize_option, sizeof(bufsize_option));
/* Bind/connect to the server.*/
FNET_DEBUG_DNS("Connecting to DNS Server.");
fnet_memset_zero(&remote_addr, sizeof(remote_addr));
remote_addr = params->dns_server_addr;
if(remote_addr.sa_port == 0U)
{
remote_addr.sa_port = FNET_CFG_DNS_PORT;
}
if(connect(fnet_dns_if.socket_cln, &remote_addr, sizeof(remote_addr))== FNET_ERR)
{
FNET_DEBUG_DNS(FNET_DNS_ERR_SOCKET_CONNECT);
goto ERROR_1;
}
/* ==== Build message. ==== */
fnet_memset_zero(fnet_dns_if.message, sizeof(fnet_dns_if.message)); /* Clear buffer.*/
/* Set header fields:
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ID |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|QR| Opcode |AA|TC|RD|RA| Z | RCODE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QDCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ANCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| NSCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ARCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
*/
header = (fnet_dns_header_t *)fnet_dns_if.message;
header->id = fnet_dns_if.id; /* Set ID. */
header->flags = FNET_HTONS(FNET_DNS_HEADER_FLAGS_RD); /* Recursion Desired.*/
header->qdcount = FNET_HTONS(1U); /* One Question. */
/* No Answer (ANCOUNT).*/ /* No Authority (NSCOUNT). */ /* No Additional (ARCOUNT). */
total_length = sizeof(fnet_dns_header_t);
total_length += fnet_dns_add_question( &fnet_dns_if.message[total_length], fnet_dns_if.dns_type, params->host_name);
fnet_dns_if.message_size = (unsigned long)(total_length);
/* Register DNS service. */
fnet_dns_if.service_descriptor = fnet_poll_service_register(fnet_dns_state_machine, (void *) &fnet_dns_if);
if(fnet_dns_if.service_descriptor == (fnet_poll_desc_t)FNET_ERR)
{
FNET_DEBUG_DNS(FNET_DNS_ERR_SERVICE);
goto ERROR_1;
}
fnet_dns_if.state = FNET_DNS_STATE_TX; /* => Send request. */
return FNET_OK;
ERROR_1:
closesocket(fnet_dns_if.socket_cln);
ERROR:
return FNET_ERR;
}
