static void
tftp_test(struct bootp *bp)
{
int res;
int server1_id = 0;
int server2_id = 0;
int server3_id = 0;
extern struct tftpd_fileops dummy_fileops;
server1_id = tftpd_start(0, &dummy_fileops);
if (server1_id > 0) {
diag_printf("TFTP server created - id: %x\n", server1_id);
} else {
diag_printf("Couldn't create first server!\n");
}
#ifdef CYGSEM_NET_TFTPD_MULTITHREADED
server2_id = tftpd_start(0, &dummy_fileops);
if (server2_id > 0) {
diag_printf("Second TFTP server created - id: %x\n", server2_id);
} else {
diag_printf("Couldn't create a second server!\n");
}
#if CYGNUM_NET_TFTPD_MULTITHREADED_PORTS > 1
server3_id = tftpd_start(1025, &dummy_fileops);
if (server3_id > 0) {
diag_printf("Third TFTP server created - id: %x\n", server3_id);
} else {
diag_printf("Couldn't create a third server!\n");
}
#endif //CYGNUM_NET_TFTPD_MULTITHREADED_PORTS > 1
#else //CYGSEM_NET_TFTPD_MULTITHREADED
server2_id = tftpd_start(1025, &dummy_fileops);
if (server2_id > 0) {
diag_printf("Second TFTP server created - id: %x\n", server2_id);
} else {
diag_printf("Couldn't create a second server!\n");
}
#endif //!CYGSEM_NET_TFTPD_MULTITHREADED
// Only let the server run for 5 minutes
cyg_thread_delay(2*100); // let the tftpd start up first
TNR_ON();
cyg_thread_delay(5*60*100);
TNR_OFF();
if (server1_id > 0) {
res = tftpd_stop(server1_id);
diag_printf("TFTP server - id: %x stopped - res: %d\n", server1_id, res);
}
if (server2_id > 0) {
res = tftpd_stop(server2_id);
diag_printf("TFTP server - id: %x stopped - res: %d\n", server2_id, res);
}
if (server3_id > 0) {
res = tftpd_stop(server2_id);
diag_printf("TFTP server - id: %x stopped - res: %d\n", server2_id, res);
}
}
void
pexit(char *s)
{
TNR_OFF();
perror(s);
cyg_test_exit();
}
void
net_test(cyg_addrword_t param)
{
extern void cyg_net_snmp_init(void);
CYG_TEST_INIT();
CYG_TEST_INFO("Start multiple SNMP server test");
init_all_network_interfaces();
autohost_init();
cyg_net_snmp_init();
TNR_INIT();
// Now command the host to do ping to us...
#ifdef CYGHWR_NET_DRIVER_ETH0
if (eth0_up) {
do_snmp_tests(ð0_bootp_data, 3, TESTTIME);
}
#endif
#ifdef CYGHWR_NET_DRIVER_ETH1
if (eth1_up) {
do_snmp_tests(ð1_bootp_data, 3, TESTTIME);
}
#endif
// Let the server run for 5 minutes
cyg_thread_delay(2*100); // let the stuff start up first
TNR_ON();
cyg_thread_delay(TESTTIME*100); // FIXME - assume cS clock.
// Additional delay 'cos host may be slower than us - and it has to
// complete a transfer anyway:
cyg_thread_delay( 30 *100); // FIXME - assume cS clock.
TNR_OFF();
autohost_end( 3 * (0
#ifdef CYGHWR_NET_DRIVER_ETH0
+ eth0_up
#endif
#ifdef CYGHWR_NET_DRIVER_ETH1
+ eth1_up
#endif
) ); // check for N pass messages from hosts
TNR_PRINT_ACTIVITY();
CYG_TEST_EXIT("Done");
}
static void
tftp_test(struct bootp *bp)
{
int server_id, res;
extern struct tftpd_fileops dummy_fileops;
server_id = tftpd_start(0, &dummy_fileops);
if (server_id > 0) {
diag_printf("TFTP server created - id: %x\n", server_id);
// Only let the server run for 5 minutes
cyg_thread_delay(2*100); // let the tftpd start up first
TNR_ON();
cyg_thread_delay(5*60*100);
TNR_OFF();
res = tftpd_stop(server_id);
diag_printf("TFTP server stopped - res: %d\n", res);
} else {
diag_printf("Couldn't create a server!\n");
}
}
static void
echo_test(void * p)
{
int s_source, s_sink, e_source, e_sink;
struct sockaddr_in e_source_addr, e_sink_addr, local;
int one = 1;
fd_set in_fds;
int i, num, len;
struct test_params params,nparams;
struct test_status status,nstatus;
s_source = socket(AF_INET, SOCK_STREAM, 0);
if (s_source < 0) {
pexit("stream socket");
}
if (setsockopt(s_source, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
pexit("setsockopt /source/ SO_REUSEADDR");
}
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
// local.sin_len = sizeof(local);
local.sin_port = ntohs(SOURCE_PORT);
local.sin_addr.s_addr = INADDR_ANY;
if(bind(s_source, (struct sockaddr *) &local, sizeof(local)) < 0) {
pexit("bind /source/ error");
}
listen(s_source, SOMAXCONN);
s_sink = socket(AF_INET, SOCK_STREAM, 0);
if (s_sink < 0) {
pexit("stream socket");
}
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
// local.sin_len = sizeof(local);
local.sin_port = ntohs(SINK_PORT);
local.sin_addr.s_addr = INADDR_ANY;
if(bind(s_sink, (struct sockaddr *) &local, sizeof(local)) < 0) {
pexit("bind /sink/ error");
}
if (setsockopt(s_sink, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
pexit("setsockopt /sink/ SO_REUSEADDR");
}
listen(s_sink, SOMAXCONN);
e_source = 0; e_sink = 0;
while (true) {
// Wait for a connection on either of the ports
FD_ZERO(&in_fds);
FD_SET(s_source, &in_fds);
FD_SET(s_sink, &in_fds);
num = select(max(s_sink,s_source)+1, &in_fds, 0, 0, 0);
if (FD_ISSET(s_source, &in_fds)) {
len = sizeof(e_source_addr);
if ((e_source = accept(s_source, (struct sockaddr *)&e_source_addr, &len)) < 0) {
pexit("accept /source/");
}
diag_printf("SOURCE connection from %s:%d\n",
inet_ntoa(e_source_addr.sin_addr), ntohs(e_source_addr.sin_port));
}
if (FD_ISSET(s_sink, &in_fds)) {
len = sizeof(e_sink_addr);
if ((e_sink = accept(s_sink, (struct sockaddr *)&e_sink_addr, &len)) < 0) {
pexit("accept /sink/");
}
diag_printf("SINK connection from %s:%d\n",
inet_ntoa(e_sink_addr.sin_addr), ntohs(e_sink_addr.sin_port));
}
// Continue with test once a connection is established in both directions
if ((e_source != 0) && (e_sink != 0)) {
break;
}
}
// Wait for "source" to tell us the testing paramters
if (do_read(e_source, &nparams, sizeof(nparams)) != sizeof(nparams)) {
pexit("Can't read initialization parameters");
}
params.nbufs = ntohl(nparams.nbufs);
params.bufsize = ntohl(nparams.bufsize);
params.load = ntohl(nparams.load);
diag_printf("Using %d buffers of %d bytes each, %d%% background load\n",
params.nbufs, params.bufsize, params.load);
// Tell the sink what the parameters are
if (do_write(e_sink, &nparams, sizeof(nparams)) != sizeof(nparams)) {
pexit("Can't write initialization parameters");
}
status.ok = 1;
nstatus.ok = htonl(status.ok);
// Tell the "source" to start - we're all connected and ready to go!
if (do_write(e_source, &nstatus, sizeof(nstatus)) != sizeof(nstatus)) {
pexit("Can't send ACK to 'source' host");
}
TNR_ON();
// Echo the data from the source to the sink hosts
for (i = 0; i < params.nbufs; i++) {
if ((len = do_read(e_source, data_buf, params.bufsize)) != params.bufsize) {
TNR_OFF();
diag_printf("Can't read buf #%d: ", i+1);
if (len < 0) {
perror("I/O error");
} else {
diag_printf("short read - only %d bytes\n", len);
}
TNR_ON();
}
if ((len = do_write(e_sink, data_buf, params.bufsize)) != params.bufsize) {
TNR_OFF();
diag_printf("Can't write buf #%d: ", i+1);
if (len < 0) {
perror("I/O error");
} else {
diag_printf("short write - only %d bytes\n", len);
}
TNR_ON();
}
}
TNR_OFF();
// Wait for the data to drain and the "sink" to tell us all is OK.
if (do_read(e_sink, &status, sizeof(status)) != sizeof(status)) {
pexit("Can't receive ACK from 'sink' host");
}
}
static void
echo_test(cyg_addrword_t p)
{
int s_source, s_sink, e_source, e_sink;
struct sockaddr_in e_source_addr, e_sink_addr, local;
int one = 1;
fd_set in_fds;
int i, num, len;
struct test_params params,nparams;
struct test_status status,nstatus;
cyg_tick_count_t starttime, stoptime;
s_source = socket(AF_INET, SOCK_STREAM, 0);
if (s_source < 0) {
pexit("stream socket");
}
if (setsockopt(s_source, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
pexit("setsockopt /source/ SO_REUSEADDR");
}
if (setsockopt(s_source, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) {
pexit("setsockopt /source/ SO_REUSEPORT");
}
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_len = sizeof(local);
local.sin_port = ntohs(SOURCE_PORT);
local.sin_addr.s_addr = INADDR_ANY;
if(bind(s_source, (struct sockaddr *) &local, sizeof(local)) < 0) {
pexit("bind /source/ error");
}
listen(s_source, SOMAXCONN);
s_sink = socket(AF_INET, SOCK_STREAM, 0);
if (s_sink < 0) {
pexit("stream socket");
}
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_len = sizeof(local);
local.sin_port = ntohs(SINK_PORT);
local.sin_addr.s_addr = INADDR_ANY;
if(bind(s_sink, (struct sockaddr *) &local, sizeof(local)) < 0) {
pexit("bind /sink/ error");
}
if (setsockopt(s_sink, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
pexit("setsockopt /sink/ SO_REUSEADDR");
}
if (setsockopt(s_sink, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) {
pexit("setsockopt /sink/ SO_REUSEPORT");
}
listen(s_sink, SOMAXCONN);
e_source = 0; e_sink = 0;
while (true) {
// Wait for a connection on either of the ports
FD_ZERO(&in_fds);
FD_SET(s_source, &in_fds);
FD_SET(s_sink, &in_fds);
num = select(max(s_sink,s_source)+1, &in_fds, 0, 0, 0);
if (FD_ISSET(s_source, &in_fds)) {
len = sizeof(e_source_addr);
if ((e_source = accept(s_source, (struct sockaddr *)&e_source_addr, &len)) < 0) {
pexit("accept /source/");
}
diag_printf("SOURCE connection from %s:%d\n",
inet_ntoa(e_source_addr.sin_addr), ntohs(e_source_addr.sin_port));
}
if (FD_ISSET(s_sink, &in_fds)) {
len = sizeof(e_sink_addr);
if ((e_sink = accept(s_sink, (struct sockaddr *)&e_sink_addr, &len)) < 0) {
pexit("accept /sink/");
}
diag_printf("SINK connection from %s:%d\n",
inet_ntoa(e_sink_addr.sin_addr), ntohs(e_sink_addr.sin_port));
}
// Continue with test once a connection is established in both directions
if ((e_source != 0) && (e_sink != 0)) {
break;
}
}
// Wait for "source" to tell us the testing paramters
if (do_read(e_source, &nparams, sizeof(nparams)) != sizeof(nparams)) {
pexit("Can't read initialization parameters");
}
params.nbufs = ntohl(nparams.nbufs);
params.bufsize = ntohl(nparams.bufsize);
params.load = ntohl(nparams.load);
diag_printf("Using %d buffers of %d bytes each, %d%% background load\n",
params.nbufs, params.bufsize, params.load);
// Tell the sink what the parameters are
if (do_write(e_sink, &nparams, sizeof(nparams)) != sizeof(nparams)) {
pexit("Can't write initialization parameters");
}
status.ok = 1;
nstatus.ok = htonl(status.ok);
// Tell the "source" to start - we're all connected and ready to go!
if (do_write(e_source, &nstatus, sizeof(nstatus)) != sizeof(nstatus)) {
pexit("Can't send ACK to 'source' host");
}
idle_thread_count = 0;
cyg_semaphore_post(&idle_thread_sem); // Start idle thread
starttime = cyg_current_time();
start_load(params.load);
TNR_ON();
// Echo the data from the source to the sink hosts
for (i = 0; i < params.nbufs; i++) {
if ((len = do_read(e_source, data_buf, params.bufsize)) != params.bufsize) {
TNR_OFF();
diag_printf("Can't read buf #%d: ", i+1);
if (len < 0) {
perror("I/O error");
} else {
diag_printf("short read - only %d bytes\n", len);
}
TNR_ON();
}
if ((len = do_write(e_sink, data_buf, params.bufsize)) != params.bufsize) {
TNR_OFF();
diag_printf("Can't write buf #%d: ", i+1);
if (len < 0) {
perror("I/O error");
} else {
diag_printf("short write - only %d bytes\n", len);
}
TNR_ON();
}
}
TNR_OFF();
// Wait for the data to drain and the "sink" to tell us all is OK.
if (do_read(e_sink, &status, sizeof(status)) != sizeof(status)) {
pexit("Can't receive ACK from 'sink' host");
}
start_load(0);
cyg_semaphore_wait(&idle_thread_sem); // Stop idle thread
stoptime = cyg_current_time();
stoptime -= starttime; // time taken in cS
// expected idle loops in that time period for an idle system:
starttime = no_load_idle_count_1_second * stoptime / 100;
diag_printf( "%d ticks elapsed, %d kloops predicted for an idle system\n",
(int)stoptime, (int)(starttime/1000) );
diag_printf( "actual kloops %d, CPU was %d%% idle during transfer\n",
(int)(idle_thread_count/1000),
(int)(idle_thread_count * 100 / starttime) );
// Now examine how close that loading actually was:
start_load(params.load); // Start up a given load
idle_thread_count = 0;
cyg_semaphore_post(&idle_thread_sem); // Start idle thread
cyg_thread_delay(1*100); // Pause for one second
cyg_semaphore_wait(&idle_thread_sem); // Stop idle thread
start_load(0); // Shut down background load
i = 100 - ((idle_thread_count * 100) / no_load_idle_count_1_second );
diag_printf("Final load[%d] = %d => %d%%\n", load_thread_level,
(int)idle_thread_count, i);
//#ifdef CYGDBG_USE_ASSERTS
#ifdef CYGDBG_NET_TIMING_STATS
{
extern void show_net_times(void);
show_net_times();
}
#endif
//#endif
}
