Пример #1
0
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
}
Пример #2
0
/************************************************************************
* 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);  
}
Пример #3
0
/************************************************************************
* NAME: fapp_init
*
* DESCRIPTION: FNET Application initialization.
************************************************************************/
void fapp_init(void)
{
    static fnet_uint8_t         stack_heap[FNET_CFG_HEAP_SIZE];
    struct fnet_init_params     init_params;
    struct fnet_shell_params    shell_params;

    /* Input parameters for FNET stack initialization */
    init_params.netheap_ptr = stack_heap;
    init_params.netheap_size = FNET_CFG_HEAP_SIZE;

    
    /* Add event handler on duplicated IP address */
#if FNET_CFG_IP4    
    fnet_netif_dupip_handler_init (fapp_dup_ip_handler);
#endif    
            
    /* Init FNET stack */
    if(fnet_init(&init_params) != FNET_ERR)
    {
    #if FAPP_CFG_PARAMS_READ_FLASH
        /* During bootup, the most recently stored customer configuration data will be read and used to configure the interfaces.*/
        if(fapp_params_from_flash() == FNET_OK)
        {
            fnet_printf(FAPP_PARAMS_LOAD_STR);
        }
    #endif

        if(fnet_netif_get_default() == FNET_NULL)
        {
            fnet_printf(FAPP_NET_ERR);
        }
            
    #if (FAPP_CFG_EXP_CMD && FNET_CFG_FS) || (FAPP_CFG_HTTP_CMD && FNET_CFG_HTTP)   
        fapp_fs_mount(); /* Init FS and mount FS Image. */
    #endif   
            
        /* Init main shell. */
        shell_params.shell = &fapp_shell;
        shell_params.cmd_line_buffer = fapp_cmd_line_buffer;
        shell_params.cmd_line_buffer_size = sizeof(fapp_cmd_line_buffer);
        shell_params.stream = FNET_SERIAL_STREAM_DEFAULT;
        shell_params.echo = FNET_TRUE;
            
        if((fapp_shell_desc = fnet_shell_init(&shell_params)) != FNET_ERR)
        {
            fapp_boot(fapp_shell_desc);
        }
        else
        {
            fnet_printf(FAPP_INIT_ERR, "Shell");
        }
    }
    else
    {
        fnet_printf(FAPP_INIT_ERR, "FNET");
    }

}
Пример #4
0
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 */
	}
}
Пример #5
0
/************************************************************************
* 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]);
    }
}
Пример #6
0
static void fapp_stat_cmd( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t ** argv )
{
    struct fnet_netif_statistics    statistics;
    fnet_netif_desc_t               netif = fnet_netif_get_default();  

    FNET_COMP_UNUSED_ARG(argc);
    FNET_COMP_UNUSED_ARG(argv);

    /* Print Packet statistics. */
    if(fnet_netif_get_statistics(netif, &statistics) == FNET_OK)
    {
        fnet_shell_println(desc, "\nPackets:");
        fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "TX Packets", statistics.tx_packet);
        fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "RX Packets", statistics.rx_packet);
    }

#if FNET_CFG_IP6
    {
        fnet_index_t                        i;
        fnet_netif_ip6_prefix_t             ip6_prefix;
        fnet_netif_ip6_neighbor_cache_t     ip6_neighbor_cache;
        fnet_char_t                                numaddr[FNET_IP6_ADDR_STR_SIZE];
        fnet_char_t                                mac_str[FNET_MAC_ADDR_STR_SIZE];

        /* Print content of IPv6 Prefix List. */
        fnet_shell_println(desc, "\nIPv6 Prefix List:");
        for(i=0U; fnet_netif_get_ip6_prefix(netif, i, &ip6_prefix) == FNET_TRUE; i++)
        {
            fnet_shell_println(desc,"   [%d] %s/%d\n", i, 
                                fnet_inet_ntop(AF_INET6, &ip6_prefix.prefix, numaddr, sizeof(numaddr)), ip6_prefix.prefix_length);
        }     

        /* Print content of IPv6 Neighbor Cache. */
        for(i=0U; fnet_netif_get_ip6_neighbor_cache(netif, i, &ip6_neighbor_cache) == FNET_TRUE; i++)
        {
            if(i == 0U)
            {
                fnet_shell_println(desc, "\nIPv6 Neighbor Cache:");
            }
            fnet_shell_println(desc,"   [%d] %s = %s (%s)\n", i, 
                                fnet_inet_ntop(AF_INET6, &ip6_neighbor_cache.ip_addr, numaddr, sizeof(numaddr)), 
                                fnet_mac_to_str(ip6_neighbor_cache.ll_addr, mac_str),
                                (ip6_neighbor_cache.is_router == FNET_TRUE) ? "router" : "host");
        }    
    }
#endif

}
Пример #7
0
static void fapp_unbind_cmd( fnet_shell_desc_t desc, fnet_index_t argc, fnet_char_t ** argv )
{
    fnet_netif_desc_t   netif = fnet_netif_get_default();
    fnet_ip6_addr_t     addr;
    
    FNET_COMP_UNUSED_ARG(argc);
    
    if(fnet_inet_pton(AF_INET6, argv[1], &addr, sizeof(addr)) == FNET_OK)
    {
        fnet_netif_unbind_ip6_addr(netif, &addr);
    }
    else
    {
        fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);
    }
}
Пример #8
0
/************************************************************************
* 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));
    }
}
Пример #9
0
/************************************************************************
* 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));
    }
}
Пример #10
0
/************************************************************************
* NAME: fapp_info_print
*
* DESCRIPTION: Display detailed information about the stack.
************************************************************************/
static void fapp_info_print( fnet_shell_desc_t desc )
{
    fnet_char_t                mac_str[FNET_MAC_ADDR_STR_SIZE];
    fnet_mac_addr_t     macaddr;
    fnet_netif_desc_t   netif = fnet_netif_get_default();         

    fapp_netif_info_print(desc, netif);

    /* HW address, if any */
    if(fnet_netif_get_hw_addr(netif, macaddr, sizeof(fnet_mac_addr_t)) == FNET_OK)
    {
        fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "MAC Address", fnet_mac_to_str(macaddr, mac_str));
    }    
    fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "MTU", fnet_netif_get_mtu(netif));    
    fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Link Status", fnet_netif_connected(netif) ? "connected" : "unconnected");
    fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Free Heap", fnet_free_mem_status());

#if FAPP_CFG_HTTP_CMD && FNET_CFG_HTTP
    fapp_http_info(desc);
#endif

#if FAPP_CFG_DHCP_CMD && FNET_CFG_DHCP && FNET_CFG_IP4
    fapp_dhcp_info(desc);
#endif

#if FAPP_CFG_TELNET_CMD && FNET_CFG_TELNET
    fapp_telnet_info(desc);
#endif   

#if FAPP_CFG_TFTPS_CMD && FNET_CFG_TFTP_SRV
    fapp_tftps_info(desc);
#endif 

#if FAPP_CFG_LLMNR_CMD && FNET_CFG_LLMNR
    fapp_llmnr_info(desc);
#endif 
}
Пример #11
0
/************************************************************************
* 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 fnet_size_t       bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;
    fnet_int32_t            received;
    fnet_char_t             ip_str[FNET_IP_ADDR_STR_SIZE];
    struct sockaddr         addr;
    fnet_size_t             addr_len;
    fnet_bool_t             is_first = FNET_TRUE;
    fnet_bool_t             exit_flag = FNET_FALSE;


    /* Create listen socket */
    if((fapp_bench.socket_listen = fnet_socket(family, SOCK_DGRAM, 0)) == FNET_ERR)
    {
        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(fnet_socket_bind(fapp_bench.socket_listen, &local_addr, sizeof(local_addr)) == FNET_ERR)
    {
        FNET_DEBUG("BENCH: Socket bind error.\n");
        goto ERROR_2;
    }


    /* Set socket options. */
    if(
        /* Set socket buffer size. */
        (fnet_socket_setopt(fapp_bench.socket_listen, SOL_SOCKET, SO_RCVBUF, (fnet_uint8_t *) &bufsize_option, sizeof(bufsize_option))== FNET_ERR) ||
        (fnet_socket_setopt(fapp_bench.socket_listen, SOL_SOCKET, SO_SNDBUF, (fnet_uint8_t *) &bufsize_option, sizeof(bufsize_option))== FNET_ERR)
    )
    {
        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 = 0; /* Default Interface.*/

            /* Join multicast group. */
            if(fnet_socket_setopt(fapp_bench.socket_listen, IPPROTO_IP, IP_ADD_MEMBERSHIP, (fnet_uint8_t *)&mreq, sizeof(mreq)) == FNET_ERR)
            {
                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(fnet_socket_setopt(fapp_bench.socket_listen, IPPROTO_IPV6, IPV6_JOIN_GROUP, (fnet_uint8_t *)&mreq6, sizeof(mreq6)) == FNET_ERR)
            {
                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, fnet_netif_get_default(), FNET_FALSE);
    if(multicast_address)
    {
        fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Multicast Group", fnet_inet_ntop(multicast_address->sa_family, (fnet_uint8_t*)(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 == FNET_FALSE) /* Main loop */
    {
        fnet_shell_println(desc, "Waiting.");

        fapp_bench.bytes = 0;
        fapp_bench.remote_bytes = 0;
        addr_len = sizeof(addr);
        is_first = FNET_TRUE;

        while(exit_flag == FNET_FALSE) /* Test loop. */
        {

            /* Receive data */
            received = fnet_socket_recvfrom  (fapp_bench.socket_listen, (fnet_uint8_t*)(&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, (fnet_uint8_t*)(addr.sa_data), ip_str, sizeof(ip_str)), fnet_ntohs(addr.sa_port));
                        fapp_bench.first_time = fnet_timer_ticks();
                        is_first = FNET_FALSE;
                    }
                }
                else
                {
                    if(received == FAPP_BENCH_UDP_END_BUFFER_LENGTH ) /* End of transfer. */
                    {
                        /* Send ACK containing amount of received data.*/
                        fnet_uint32_t ack_bytes = fnet_htonl(fapp_bench.bytes);

                        /* Send several times, just to be sure that it is received/not lost.*/
                        fnet_socket_sendto(fapp_bench.socket_listen, (fnet_uint8_t*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));
                        fnet_socket_sendto(fapp_bench.socket_listen, (fnet_uint8_t*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));
                        fnet_socket_sendto(fapp_bench.socket_listen, (fnet_uint8_t*)(&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 == FNET_ERR)
                {
                    fnet_shell_println(desc, "BENCH: Error (%d).", fnet_error_get());
                    break;
                }
                /* Check timeout. */
                if((is_first == FNET_FALSE) &&
                        (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:
    fnet_socket_close(fapp_bench.socket_listen);

ERROR_1:

    fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);
}
Пример #12
0
/************************************************************************
* 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;
    fnet_int32_t        received;
    fnet_char_t         ip_str[FNET_IP_ADDR_STR_SIZE];
    struct linger       linger_option = {FNET_TRUE, /*l_onoff*/
               4  /*l_linger*/
    };
    fnet_size_t         bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;
    fnet_int32_t        keepalive_option = 1;
    fnet_int32_t        keepcnt_option = FAPP_BENCH_TCP_KEEPCNT;
    fnet_int32_t        keepintvl_option = FAPP_BENCH_TCP_KEEPINTVL;
    fnet_int32_t        keepidle_option = FAPP_BENCH_TCP_KEEPIDLE;
    struct sockaddr     foreign_addr;
    fnet_size_t         addr_len;
    fnet_bool_t         exit_flag = FNET_FALSE;


    fapp_bench.socket_foreign = FNET_ERR;

    /* Create listen socket */
    if((fapp_bench.socket_listen = fnet_socket(family, SOCK_STREAM, 0)) == FNET_ERR)
    {
        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(fnet_socket_bind(fapp_bench.socket_listen, &local_addr, sizeof(local_addr)) == FNET_ERR)
    {
        FNET_DEBUG("BENCH: Socket bind error.");
        goto ERROR_2;
    }

    /* Set Socket options. */
    if( /* Setup linger option. */
        (fnet_socket_setopt (fapp_bench.socket_listen, SOL_SOCKET, SO_LINGER, (fnet_uint8_t *)&linger_option, sizeof(linger_option)) == FNET_ERR) ||
        /* Set socket buffer size. */
        (fnet_socket_setopt(fapp_bench.socket_listen, SOL_SOCKET, SO_RCVBUF, (fnet_uint8_t *) &bufsize_option, sizeof(bufsize_option))== FNET_ERR) ||
        (fnet_socket_setopt(fapp_bench.socket_listen, SOL_SOCKET, SO_SNDBUF, (fnet_uint8_t *) &bufsize_option, sizeof(bufsize_option))== FNET_ERR) ||
        /* Enable keepalive_option option. */
        (fnet_socket_setopt (fapp_bench.socket_listen, SOL_SOCKET, SO_KEEPALIVE, (fnet_uint8_t *)&keepalive_option, sizeof(keepalive_option)) == FNET_ERR) ||
        /* Keepalive probe retransmit limit. */
        (fnet_socket_setopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPCNT, (fnet_uint8_t *)&keepcnt_option, sizeof(keepcnt_option)) == FNET_ERR) ||
        /* Keepalive retransmit interval.*/
        (fnet_socket_setopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPINTVL, (fnet_uint8_t *)&keepintvl_option, sizeof(keepintvl_option)) == FNET_ERR) ||
        /* Time between keepalive probes.*/
        (fnet_socket_setopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPIDLE, (fnet_uint8_t *)&keepidle_option, sizeof(keepidle_option)) == FNET_ERR)
    )
    {
        FNET_DEBUG("BENCH: Socket setsockopt error.\n");
        goto ERROR_2;
    }

    /* Listen. */
    if(fnet_socket_listen(fapp_bench.socket_listen, 1) == FNET_ERR)
    {
        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, fnet_netif_get_default(), 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 == FNET_FALSE)
    {
        fnet_shell_println(desc, "Waiting.");

        fapp_bench.bytes = 0;
        fapp_bench.remote_bytes = 0;
        if(fapp_bench.socket_foreign != FNET_ERR)
        {
            fnet_socket_close(fapp_bench.socket_foreign);
            fapp_bench.socket_foreign = FNET_ERR;
        }

        while((fapp_bench.socket_foreign == FNET_ERR) && (exit_flag == FNET_FALSE))
        {
            /*Accept*/
            addr_len = sizeof(foreign_addr);
            fapp_bench.socket_foreign = fnet_socket_accept(fapp_bench.socket_listen, &foreign_addr, &addr_len);


            exit_flag = fnet_shell_ctrlc (desc);

            if(fapp_bench.socket_foreign != FNET_ERR)
            {

                fnet_shell_println(desc,"Receiving from %s:%d", fnet_inet_ntop(foreign_addr.sa_family, (fnet_uint8_t*)(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 = fnet_socket_recv(fapp_bench.socket_foreign, (fnet_uint8_t*)(&fapp_bench.buffer[0]), FAPP_BENCH_BUFFER_SIZE, 0);

                    if ((received == FNET_ERR) || 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]*/
                }
            }
        }
    }

    fnet_socket_close(fapp_bench.socket_foreign);

ERROR_2:
    fnet_socket_close(fapp_bench.socket_listen);

ERROR_1:

    fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);
}
Пример #13
0
/************************************************************************
* 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. */
        ||((argc == 2u) && (fnet_strcasecmp(&FAPP_DHCP_COMMAND_REBOOT[0], argv[1]) == 0))  /* [reboot] */
#endif
        ||((argc == 2u) && (fnet_strcasecmp(&FAPP_DHCP_COMMAND_AUTOIP[0], argv[1]) == 0)) /* [autoip] */
      ) 
    {

        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
        /* Check Auto-IP flag.*/
        if((argc == 2u) && (fnet_strcasecmp(&FAPP_DHCP_COMMAND_AUTOIP[0], argv[1]) == 0)) 
        {
            fapp_dhcp_autoip = FNET_TRUE;
        }
        else
        {
            fapp_dhcp_autoip = FNET_FALSE;
        }

        dhcp_params.probe_addr = FNET_TRUE; /* Enable probing of the newly received address.*/

        /* Save current IP address only if it was allocated manually/statically. */
        if(fnet_netif_get_ip4_addr_type(netif) == FNET_NETIF_IP_ADDR_TYPE_MANUAL)
        {
            fapp_dhcp_ip_old = fnet_netif_get_ip4_addr(netif); /* Save ip to restore if cancelled. */
        }
        else
        {
            fapp_dhcp_ip_old = 0;
        }

        /* Start DHCP client */
        dhcp_desc = fnet_dhcp_init(netif, &dhcp_params);
        if(dhcp_desc)
        {
            fapp_dhcp_desc = dhcp_desc;

            /* Register DHCP event handler callbacks. */
            fnet_dhcp_set_callback_updated(fapp_dhcp_desc, fapp_dhcp_callback_updated, (void *)desc);
            fnet_dhcp_set_callback_discover(fapp_dhcp_desc, fapp_dhcp_callback_discover, (void *)desc);

            fnet_shell_println(desc, FAPP_DELIMITER_STR);
            fnet_shell_println(desc, " DHCPv4 Client started.");
            fnet_shell_println(desc, FAPP_DELIMITER_STR);

            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]);
    }
}