tool/mbed/mbed-sdk/libraries/tests/net/echo/udp_link_layer/main.cpp

   1 #include "mbed.h"
   2 #include "rtos.h"
   3 #include "EthernetInterface.h"
   4 #include <list>
   5 #include <string>
   6
   7 /**
   8 * How to use:
   9 * make.py -m LPC1768 -t ARM -d E:\ -n NET_14
  10 * udp_link_layer_auto.py -p COM20 -d E:\ -t 10
  11 */
  12
  13 // Evil globals
  14 namespace {
  15     // IP and port used to store HOST address info
  16     char host_address[32] = {0};
  17     volatile int host_port = 0;
  18
  19     const int ECHO_SERVER_PORT = 7;
  20     const int BUFFER_SIZE = 64;
  21
  22     // Forwarding packet queue
  23     std::list<std::string> datagram_queue;
  24
  25     // Statistics (mbed)
  26     volatile int received_packets = 0;
  27     volatile int forwarded_packets = 0;
  28     volatile int max_queue_len = 0;
  29
  30     Mutex cli_serv_mutex;
  31     // cli_serv_mutex.lock(); // LOCK
  32     // cli_serv_mutex.unlock(); // LOCK
  33 }
  34
  35 void udp_server_task(void const *argument)
  36 {
  37     DigitalOut indicator(LED1);
  38     UDPSocket server;
  39
  40     server.bind(ECHO_SERVER_PORT);
  41     // printf("[udp_server_task] Start\r\n");
  42
  43     Endpoint client;
  44     char buffer[BUFFER_SIZE] = { 0 };
  45     while (true) {
  46         //printf("[udp_server_task] Wait for packet...\r\n");
  47         int n = server.receiveFrom(client, buffer, sizeof(buffer));
  48         if (n > 0) {
  49             //printf("[udp_server_task] Received packet from: %s\r\n", client.get_address());
  50             const int buffer_string_end_index = n >= BUFFER_SIZE ? BUFFER_SIZE - 1 : n;
  51             buffer[buffer_string_end_index] = '\0';
  52             //printf("[udp_server_task] Server received: %s\r\n", buffer);
  53             if (host_port == 0) {
  54                 strcpy(host_address, client.get_address());
  55                 host_port = ECHO_SERVER_PORT + 1;
  56                 //printf("[udp_server_task] Set host address and port: %s:%d\r\n", host_address, host_port);
  57             }
  58             // Dispatch data to client for sending to test HOST
  59             cli_serv_mutex.lock(); // LOCK
  60             // Push to datagram queue
  61             datagram_queue.push_front(std::string(buffer));
  62             max_queue_len = datagram_queue.size() > max_queue_len ? datagram_queue.size() : max_queue_len;
  63             received_packets++;
  64             cli_serv_mutex.unlock(); // LOCK
  65             indicator = !indicator;
  66         }
  67     }
  68 }
  69
  70 void udp_client_task(void const *argument)
  71 {
  72     while (host_port == 0) {
  73         // Waiting for HOST port notification
  74     }
  75
  76     DigitalOut indicator(LED2);
  77     UDPSocket socket;
  78     socket.init();
  79
  80     Endpoint echo_server;
  81     echo_server.set_address(host_address, host_port);
  82     //printf("[udp_client_task] Start: %s:%d\r\n", host_address, host_port);
  83
  84     while (1) {
  85         std::string datagram;
  86         bool sent_datagram = false;
  87         cli_serv_mutex.lock(); // LOCK
  88         if (datagram_queue.size() > 0) {
  89             // POP from datagram queue
  90             datagram = datagram_queue.back();
  91             datagram_queue.pop_back();
  92             sent_datagram = true;
  93         }
  94         cli_serv_mutex.unlock(); // LOCK
  95         if (sent_datagram) {
  96             //printf("[udp_client_task] Forwarded datagram: %s\r\n", datagram.c_str());
  97             socket.sendTo(echo_server, (char *)datagram.c_str(), datagram.length());
  98             forwarded_packets++;
  99             indicator = !indicator;
 100         }
 101     }
 102 }
 103
 104 int main(void)
 105 {
 106     EthernetInterface eth;
 107
 108     eth.init(); //Use DHCP
 109     eth.connect();
 110     printf("MBED: Server IP Address is %s:%d\r\n", eth.getIPAddress(), ECHO_SERVER_PORT);
 111
 112     Thread UdpServerTask(udp_server_task, NULL, osPriorityNormal, DEFAULT_STACK_SIZE * 2.25);
 113     Thread UdpClientTask(udp_client_task, NULL, osPriorityNormal, DEFAULT_STACK_SIZE * 2.25);
 114
 115     // Control TCP server to get MBED statistics
 116     {
 117         char buffer[BUFFER_SIZE] = {0};
 118         const int TELNET_SERVER_PORT = 23;
 119         const int BUFFER_SIZE = 256;
 120         TCPSocketServer server;
 121         server.bind(TELNET_SERVER_PORT);
 122         server.listen();
 123
 124         while (true) {
 125             printf("MBED: Wait for new connection...\r\n");
 126             TCPSocketConnection client;
 127             server.accept(client);
 128             client.set_blocking(false, 1500); // Timeout after (1.5)s
 129             printf("MBED: Connection from: %s\r\n", client.get_address());
 130
 131             while (true) {
 132                 int n = client.receive(buffer, sizeof(buffer));
 133                 //if (n <= 0) break;
 134                 if (n > 0) {
 135                     // printf("Recv %d chars\r\n", n);
 136                     const int buffer_string_end_index = n >= BUFFER_SIZE ? BUFFER_SIZE - 1 : n;
 137                     buffer[buffer_string_end_index] = '\0';
 138                     // client.send_all(buffer, strlen(buffer));
 139                     if (strncmp(buffer, "stat", 4) == 0) {
 140                         sprintf(buffer, "received_packets %d\nforwarded_packets %d\nmax_queue_len %d",
 141                                 received_packets, forwarded_packets, max_queue_len);
 142                         client.send_all(buffer, strlen(buffer));
 143                         // printf("%s", buffer);
 144                     }
 145                 }
 146                 //if (n <= 0) break;
 147             }
 148             client.close();
 149         }
 150     }
 151 }