Subversion Repositories xenie

/***************************************************************************

 *

 * (C) Copyright 2017 DFC Design, s.r.o., Brno, Czech Republic

 * Author: Marek Kvas (m.kvas@dspfpga.com)

 *

 ***************************************************************************

 *

 * This file is part of Xenia Ethernet Example project.

 *

 * Xenia Ethernet Example project is free software: you can

 * redistribute it and/or modify it under the terms of

 * the GNU Lesser General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * Xenia Ethernet Example project is distributed in the hope that

 * it will be useful, but WITHOUT ANY WARRANTY; without even

 * the implied warranty of MERCHANTABILITY or FITNESS FOR A

 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License

 * for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with Xenia Ethernet Example project.  If not,

 * see <http://www.gnu.org/licenses/>.

 *

 ***************************************************************************

 *

 * !!!!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!!!!!!!

 * This console application demonstrates functionality of Xenie Ethernet

 * Example design. The application generates high bandwidth network traffic

 * which - if accidentally routed to corporate/public network segment - can

 * saturate network infrastructure and effectively prevent network from

 * correct function. Some devices may even start to behave unpredictably

 * than. It is highly recommended to use this example on dedicated private

 * network segments only. If you are not sure about network infrastructure,

 * consult situation with your network administrator.

 * !!!!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!!!!!!!

 *

 * As the first step, presence of any Xenie with correct running design

 * is verified using Network info discovery packet. This packet is

 * broadcasted to all interfaces. When Xenie receives it, it responds with

 * unicast response containing its MAC, IPv4 address and netmask. Because

 * Xenie example design doesn't have ARP, static ARP record is created

 * in order to enable unicast communication.

 *

 * !!! Static ARP record may - if not well understood and managed -

 * cause weird behaviour of the network. Static ARP record is not

 * permanent, so it disappears after system reboot, or ARP table reset.

 *

 * If Xenie is found on the network, number of transmitter / receiver

 * thread pairs is created. The number of this pairs is given by

 * SESSIONS_COUNT macro.

 *

 * Each transmitter thread sends UDP test traffic as fast as possible to

 * Xenie address. Xenie captures this packets, inserts some statistical

 * data into each datagram and sends them back.

 * This "looped back" datagrams are captured by the corresonding receiver

 * thread. It checks the statistics inserted by Xenie and determines whether

 * any datagrams were lost. The lost count and some other information is

 * stored in the context of each receiver.

 *

 * The main thread periodically reads the statistics from all the receiver

 * threads, sums them up (if applicable) and prints info to the console.

 *

 * Integrity of the received frames is protected by 32 bit CRC at the

 * Ethernet layer so it is not necessary to check for datagram payload

 * correctness. Corrupted packets are simply discarded by NIC.

 *

 * Timestamps from Xenie are used to measure bandwidth. Calculated number

 * should match number given by Windows task manager. Be careful about

 * interpretation of graphs shown by the task manager as it sums up TX and

 * RX traffic. So if 50 % of bandwidth is really used, graphs show 100 %

 * already.

 *

 * In order to generate maximum traffic, maximum frame size is used.

 * MTU macro can be modified to limit packet size. By default 9000

 * bytes is used - it is standard maximum value for jumbo frames.

 * When this macro is set to value higher than real MTU used by

 * machine running this application, datagrams are fragmented at the IP

 * layer. As Xenie cannot handle fragmented IP packets, the test wont

 * work as expected - high but not 100 % packet loss is

 * most likely result. If host machine has MTU high enough, but

 * there is any network switch on the path to Xenie that doesn't

 * support set MTU, the traffic will most likely be lost completely.

 * !!! Check your NIC settings for the MTU before you run this application.

 *

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <winsock2.h>

#include <WS2tcpip.h>

#include <IPHlpApi.h>

#include <stdint.h>

/* Windows Socket library */

#pragma comment(lib,"ws2_32.lib")

/*

 * Ports of services provided by xenie eth example design.

 * They are hardcoded in HDL.

 */

#define XENIE_TEST_PORT                                         0xdfc1

#define XENIE_NET_INFO_DICOVERY_PORT            0xdfcc

/* Magic number hardcoded in HDL for our traffic identification */

#define TEST_PACKET_MAGIC       0xDFCDFC01

/* Namber of TX/RX thread pairs to be created */

#define SESSIONS_COUNT          60

/*

 * MTU must be set to value equal or less than MTU set on NIC.

 * 9000 is maximum for most of standard NICs.

 *

 * If set too high, Windows stack will fragment datagrams on IP

 * leyer. Xenie test design doesn't support fragmented packets -

 * communication will be corrupted.

 */

/* MTU of the NIC or path */

#define MTU 9000 

/* Real length of Ethernet frame (pramble and FCS excluded)*/

#define MAX_ETH_FRAME_SIZE ((MTU) + 14) 

/* Max lenght of UDP payload to fulfill MTU */

#define MAX_PKT_UDP_DATA ((MAX_ETH_FRAME_SIZE) - (14 + 20 + 8)) 

/* Lenght of balast after out test protocol header to create maximum packet */

#define MAX_PKT_DATA_LENGTH ((MAX_PKT_UDP_DATA) - 32) 

/* Structure defining packet carrying Xenie's network settings */

#pragma pack(push)

struct xenie_net_info_pkt_s {

        uint64_t tstmp;

        unsigned char mac_addr[6];

        unsigned char pad[2];

        IN_ADDR ip_addr;

        IN_ADDR net_mask;

};

#pragma pack(pop)

/*

 * Send xenie discovery packet.

 * Zero is returned on success and xenie argument is

 * filled with received data.

 */

int find_xenie(struct xenie_net_info_pkt_s *xenie)

{

        int i;

        int res, ret = -1;

        SOCKET s;

        SOCKADDR_IN xenie_net_info_dicovery;

        DWORD optval;

        s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

        if (s == INVALID_SOCKET)

                return -1;

        /* Enable broadcasts */

        optval = 100;

        res = setsockopt(s, SOL_SOCKET, SO_BROADCAST,

                        (char *)&optval, sizeof(optval));

        if (res)

                goto err;

        /* Set Timeout for response */

        optval = 100;

        res = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO,

                        (char *)&optval, sizeof(optval));

        if (res)

                goto err;

        /* Send dicovery packet */

        xenie_net_info_dicovery.sin_addr.s_addr = INADDR_BROADCAST;

        xenie_net_info_dicovery.sin_port = ntohs(XENIE_NET_INFO_DICOVERY_PORT);

        xenie_net_info_dicovery.sin_family = AF_INET;

        res = sendto(s," ", 1, 0, (SOCKADDR*)&xenie_net_info_dicovery,

                                sizeof(xenie_net_info_dicovery));

        if(res != 1) {

                printf("err %d\n", WSAGetLastError());

                goto err;

        }

        /* Receive response */

        res = recv(s, (char*)xenie, sizeof(*xenie), 0);

        if(res != sizeof(*xenie))

                goto err;

        /* Change byteorder for IP addresses */

        xenie->ip_addr.s_addr = ntohl(xenie->ip_addr.s_addr);

        xenie->net_mask.s_addr = ntohl(xenie->net_mask.s_addr);

        /* swap bytes for mac address */

        for(i = 0; i < 3; i++) {

                unsigned char tmp;

                tmp = xenie->mac_addr[i];

                xenie->mac_addr[i] = xenie->mac_addr[5-i];

                xenie->mac_addr[5-i] = tmp;

        }

        ret = 0;

err:

        closesocket(s);

        return ret;

}

/*

 * Beacause xenie with demo udp_ip stack doesn't suppor ARP.

 * it is necessary to create static ARP record if unicast

 * communication is needed.

 */

int create_arp_record(struct xenie_net_info_pkt_s *xenie)

{

        unsigned int i;

        int res;

        int ret = 0;

        MIB_IPNETROW arp_entry;

        PMIB_IPNETTABLE ip_net_table;

        unsigned long arpTableLength = 0;

        /*

         * Get current ARP table to find whether adderess

         * is already assigned or not

         */

        res = GetIpNetTable(NULL, &arpTableLength, 1);

        if (res != ERROR_INSUFFICIENT_BUFFER)

                return -1;

        ip_net_table = (PMIB_IPNETTABLE)malloc(arpTableLength);

        if (ip_net_table == NULL)

                return -1;

        res = GetIpNetTable(ip_net_table, &arpTableLength, 1);

        if (res) {

                ret = -1;

                goto end;

        }

        /* We have to create new record */

        arp_entry.dwPhysAddrLen = 6;

        memcpy(&arp_entry.bPhysAddr, xenie->mac_addr, arp_entry.dwPhysAddrLen);

        res = GetBestInterface(xenie->ip_addr.s_addr, &arp_entry.dwIndex);

        if(res){

                ret = -1;

                goto end;

        }

        arp_entry.dwAddr = xenie->ip_addr.s_addr;

        arp_entry.Type = MIB_IPNET_TYPE_STATIC;

        /*

         * First Search ARP table for our address whether

         * there is any similar record

         */

        for (i = 0; i < ip_net_table->dwNumEntries; i++) {

                if (ip_net_table->table[i].dwAddr == xenie->ip_addr.s_addr) {

                        if ((strncmp((char*)ip_net_table->table[i].bPhysAddr,

                                                                         (char*)xenie->mac_addr, 6) != 0) ||

                           (ip_net_table->table[i].Type != MIB_IPNET_TYPE_STATIC) ||

                           (ip_net_table->table[i].dwIndex != arp_entry.dwIndex)) {

                                res = DeleteIpNetEntry(&ip_net_table->table[i]);

                        } else {

                                /* Record already exists so let it be */

                                goto end;

                        }

                }

        }

        res = CreateIpNetEntry(&arp_entry);

        if(res) {

                ret = -1;

                goto end;

        }

end:

        free(ip_net_table);

        return ret;

}

/* Structure definind packets used for testing */

struct test_counters {

        uint32_t loopback_pkt_cnt;

        uint32_t test_pkt_cnt;

        uint32_t unknown_port_pkt_cnt;

        uint32_t test_pkt_accepted_cnt;

};

#pragma pack(push)

struct testPkt {

        uint32_t magic;

        uint32_t seqNo;

        uint64_t tstmp;

        struct test_counters cnts;

        char data[MAX_PKT_DATA_LENGTH];

};

#pragma pack(pop)

/* Structure used to managed threads */

struct threadManagement {

        HANDLE threadHandle;

        DWORD threadID;

        HANDLE exitEvent;

};

/* Collection of statistics counters*/

struct rcv_stats {

        uint32_t received_pkts;

        uint32_t received_test_pkts;

        uint32_t lost_pkts;

        uint32_t seqNo_restarts;

        uint64_t max_pkt_period;

};

/* Context for received thread */

struct rcvThreadData {

        struct threadManagement tmng;

        SOCKET *s;

        HANDLE   accessMutex;

        uint32_t last_seqNo;

        uint64_t last_timestamp;

        uint32_t first_test_pkt_accepted_cnt;

        struct rcv_stats stats;

        struct test_counters cnts;

        unsigned int ring_low_watermark;

};

/* Context for send thread */

struct sendThreadData {

        struct threadManagement tmng;

        HANDLE   accessMutex;

        SOCKET  *s;

        uint32_t sent_pkts;

};

/* Structure keeping references to correspondind send/receive threads */

struct sendRcvSession {

        struct rcvThreadData rcv;

        struct sendThreadData snd;

        SOCKET s;

};

/* Body od send threads */

DWORD WINAPI sendThread_func (LPVOID param) {

        int res;

        int i;

        struct sendThreadData *ctx = (struct sendThreadData*)param;

        struct testPkt pkt;

        ctx->sent_pkts = 0;

        pkt.magic = TEST_PACKET_MAGIC;

        /* Fill body of packet with random data */

        srand( (unsigned)time( NULL ) );

        for(i = 0; i < MAX_PKT_DATA_LENGTH; i++) {

                pkt.data[i] = rand();

        }

        while(WaitForSingleObject(ctx->tmng.exitEvent,0) == WAIT_TIMEOUT) {

                WaitForSingleObject(ctx->accessMutex, INFINITE);

                pkt.seqNo = ctx->sent_pkts;

                res = send(*ctx->s, (char *)&pkt, MAX_PKT_UDP_DATA, 0);

                if (res < 0) {

                        printf("ERROR: Send failed with error %d\n", WSAGetLastError());

                } else {

                        ctx->sent_pkts++;

                }

                ReleaseMutex(ctx->accessMutex);

        }

}

/* Budy of receive thread */

DWORD WINAPI rcvThread_func(LPVOID param)

{

        int res;

        struct rcvThreadData *ctx = (struct rcvThreadData*)param;

        struct testPkt pkt;

        /* Loop until asked to exit */

        while(WaitForSingleObject(ctx->tmng.exitEvent,0) == WAIT_TIMEOUT) {

                res = recv(*ctx->s, (char*)&pkt, sizeof(pkt), 0);

                if (res > 0) {

                        /* packet received */

                        ctx->stats.received_pkts++;

                        //pkt = (struct pkt*)cur_recv_req->pkt_addr;

                        /* Check it is ours test packet */

                        if((pkt.magic == TEST_PACKET_MAGIC) && (res == MAX_PKT_UDP_DATA)) {

                                WaitForSingleObject(ctx->accessMutex, INFINITE);

                                /* Careful about the first packet */

                                if (ctx->stats.received_test_pkts) {

                                        if(pkt.seqNo < (ctx->last_seqNo+1)) {

                                                ctx->stats.seqNo_restarts++;

                                        } else {

                                                ctx->stats.lost_pkts += pkt.seqNo - ctx->last_seqNo -1;

                                        }

                                } else {

                                        ctx->first_test_pkt_accepted_cnt =

                                                pkt.cnts.test_pkt_accepted_cnt;

                                }

                                ctx->stats.received_test_pkts++;

                                ctx->last_seqNo = pkt.seqNo;

                                ctx->cnts = pkt.cnts;

                                ctx->last_timestamp = pkt.tstmp;

                                ReleaseMutex(ctx->accessMutex);

                        } else {

                                /* This packet doesnt belong to our test */

                                printf("ERROR: Captured packet with wrong magic number or length\n");

                        }

                } else if (res == WSAETIMEDOUT) {

                        // recv timed out - nothing happened

                        continue;

                } else {

                        // error occured

                        printf("ERROR: recv returned error number %d\n",

                                WSAGetLastError());

                }

        }

        return 0;

}

/* Convenience function creating send/receive thread */

int startThread(LPTHREAD_START_ROUTINE lpStartAddress,

                                struct threadManagement *tmng)

{

        tmng->exitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

        if (tmng->exitEvent == NULL)

                return -1;

        tmng->threadHandle = CreateThread(NULL, 0, lpStartAddress,

                        tmng, 0, &tmng->threadID);

        if (tmng->threadHandle == NULL) {

                CloseHandle(tmng->threadHandle);

                return -1;

        }

        return 0;

}

/* Convenience function creating send/receive thread pair */

int create_session(struct sendRcvSession *session,

                                        struct xenie_net_info_pkt_s *xenie)

{

        int res;

        SOCKADDR_IN xenie_addr;

        DWORD optval;

        /* Create socket common for both send and receive */

        session->s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

        if (session->s == INVALID_SOCKET)

                return -1;

        /* Set Timeout for response */

        optval = 100;

        res = setsockopt(session->s, SOL_SOCKET, SO_RCVTIMEO,

                (char *)&optval, sizeof(optval));

        if (res) {

                printf("ERROR: Cannot set timeout on socket\n");

                goto clean_skt;

        }

        /* Set receive buffer for response */

        optval = 32*1024*1024;

        res = setsockopt(session->s, SOL_SOCKET, SO_RCVBUF,

                (char *)&optval, sizeof(optval));

        if (res) {

                printf("ERROR: Cannot set timeout on socket\n");

                goto clean_skt;

        }

        /* Connect to test socket */

        xenie_addr.sin_addr.s_addr = xenie->ip_addr.s_addr;

        xenie_addr.sin_port = ntohs(XENIE_TEST_PORT);

        xenie_addr.sin_family = AF_INET;

        res = connect(session->s, (SOCKADDR*)&xenie_addr, sizeof(xenie_addr));

        if (res < 0) {

                printf("ERROR: Cannot send data to selected socket.\n");

                goto clean_skt;

        }

        session->rcv.accessMutex = CreateMutex(NULL, 0, NULL);

        session->snd.accessMutex = CreateMutex(NULL, 0, NULL);

        if ((session->rcv.accessMutex == NULL) ||

                (session->rcv.accessMutex == NULL)) {

                goto clean_mutex;

        }

        session->rcv.s = &session->s;

        session->snd.s = &session->s;

        /* Create thread for receiving */

        if(startThread(rcvThread_func, &session->rcv.tmng)) {

                printf("ERROR: Cannot start receive thread.\n");

                goto clean_mutex;

        }

        /* Create thread for sending */

        if(startThread(sendThread_func, &session->snd.tmng)) {

                printf("ERROR: Cannot start send thread.\n");

                goto clean_rcvThread;

        }

        return 0;

clean_rcvThread:

        SetEvent(session->rcv.tmng.exitEvent);

        /* wait for thread to really end */

        WaitForSingleObject(session->rcv.tmng.threadHandle, INFINITE);

clean_mutex:

        CloseHandle(session->rcv.accessMutex);

        CloseHandle(session->snd.accessMutex);

clean_skt:

        closesocket(session->s);

        return -1;

}

int main (int argc, char *argv[])

{

        WSADATA wsaData;

        int res;

        int i;

        struct xenie_net_info_pkt_s xenie;

        struct rcvThreadData rcvThreadCtx;

        struct sendThreadData sendThreadCtx;

        struct sendRcvSession sessions[SESSIONS_COUNT];

        uint64_t last_timestamp = 0;

        uint32_t last_test_pkt_accepted_cnt =0;

        /* Windows sockets library init */

        res = WSAStartup(MAKEWORD(2, 2), &wsaData);

    if (res != NO_ERROR) {

                printf("ERROR: Cannot initialize Windows Sockets library. Error: %d\n",

                        WSAGetLastError());

        return 1;

    }

        res = find_xenie(&xenie);

        if (res) {

                printf("ERROR: No xenie board has been found.\n");

                return 1;

        }

        printf("Xenie board found:\n");

        printf("MAC:       %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",

                xenie.mac_addr[5],xenie.mac_addr[4], xenie.mac_addr[3],

                xenie.mac_addr[2], xenie.mac_addr[1], xenie.mac_addr[0]);

        printf("IP:        %s\n", inet_ntoa(xenie.ip_addr));

        printf("Net mask:  %s\n\n", inet_ntoa(xenie.net_mask));

        if (create_arp_record(&xenie)) {

                printf("ERROR: Cannot create static ARP record for Xenie borad\n");

                return 1;

        }

        /* Clean memory with session contexts */

        memset(sessions, 0, sizeof(sessions));

        /* Start all sessions */

        for (i = 0; i < SESSIONS_COUNT; i++) {

                printf(" Creating session %d ... ", i);

                if (create_session(&sessions[i], &xenie)) {

                        printf("failed.\n");

                        return -1;

                } else {

                        printf("Ok.\n");

                }

        }

        /* Main thread prints statistics once a second */

        while (1) {

                struct rcv_stats stats;

                struct test_counters cnts;

                uint32_t sent_pkts, received_pkts, lost_pkts;

                uint32_t test_pkt_cnt, test_pkt_accepted_cnt;

                uint32_t loopback_pkt_cnt, unknown_port_pkt_cnt;

                uint32_t pkt_cnt_per_unit;

                uint64_t tstmp, unit;

                double bandwidth;

                /* Collect statistics */

                sent_pkts = 0;

                received_pkts = 0;

                lost_pkts = 0;

                test_pkt_cnt = 0;

                test_pkt_accepted_cnt = 0;

                loopback_pkt_cnt = 0;

                unknown_port_pkt_cnt = 0;

                for (i = 0; i < SESSIONS_COUNT; i++) {

                        WaitForSingleObject(sessions[i].rcv.accessMutex, INFINITE);

                        stats = sessions[i].rcv.stats;

                        cnts = sessions[i].rcv.cnts;

                        tstmp = sessions[i].rcv.last_timestamp;

                        ReleaseMutex(sessions[i].rcv.accessMutex);

                        WaitForSingleObject(sessions[i].snd.accessMutex, INFINITE);

                        sent_pkts += sessions[i].snd.sent_pkts;

                        ReleaseMutex(sessions[i].snd.accessMutex);

                        received_pkts += stats.received_pkts;

                        lost_pkts += stats.lost_pkts;

                }

                /* These are common for all sessions and don't sum them up*/

                test_pkt_cnt = cnts.test_pkt_cnt;

                test_pkt_accepted_cnt = cnts.test_pkt_accepted_cnt;

                loopback_pkt_cnt = cnts.loopback_pkt_cnt;

                unknown_port_pkt_cnt = cnts.unknown_port_pkt_cnt;

                pkt_cnt_per_unit = test_pkt_accepted_cnt - last_test_pkt_accepted_cnt;

                last_test_pkt_accepted_cnt = test_pkt_accepted_cnt;

                unit = tstmp - last_timestamp;

                last_timestamp = tstmp;

                bandwidth = (double)pkt_cnt_per_unit *

                        MAX_ETH_FRAME_SIZE/((double)unit/156250000);

                printf("----------\n");

                printf("Bandwidth %.3f MB/s (%.1f %%)\n",

                        bandwidth/1024/1024, 100*8*bandwidth/10000000000);

                printf("Sent pkts %-9u, received %-9u, lost %-5u (%-5d)\n",

                        sent_pkts, received_pkts, lost_pkts, test_pkt_accepted_cnt -

                        sessions[0].rcv.first_test_pkt_accepted_cnt - sent_pkts);

                printf("test_pkt_cnt %-9u, test_accepted_pkt_cnt, "

                           "%-9u loopback %-9u unknown_pkt_cnt %-9u\n",

                        test_pkt_cnt, test_pkt_accepted_cnt,

                        loopback_pkt_cnt, unknown_port_pkt_cnt);

                Sleep(1000);

        }

        return 0;

}