rudpclt.c

   1 #include "rudp.h"
   2 #include "platform_adpt.h"
   3 #include <string.h>
   4 #include <stdio.h>
   5 #include <signal.h>
   6
   7 int g_quit = 0;
   8 int async = 0;
   9 void sig_handler(int sig)
  10 {
  11         if(sig == SIGINT || sig == SIGTERM)
  12         {
  13                 g_quit = 1;
  14         }
  15 }
  16
  17 int sendData(RUDPSOCKET s)
  18 {
  19         char line[3000];
  20         int i=0, rlt = 0;
  21         memset(line, '1' + i%36, 3000);
  22
  23         time_t t0, t_prev, t;
  24         unsigned long nTotal = 0, nByt = 0;
  25         t0 = t_prev = time(NULL);
  26         for(i=0; 0<50000 && !g_quit; i++)
  27         {
  28                 PA_IOVEC v[3];
  29                 PA_IoVecSetPtr(&v[0], line);
  30                 PA_IoVecSetPtr(&v[1], line);
  31                 PA_IoVecSetPtr(&v[2], line);
  32                 PA_IoVecSetLen(&v[0], 230);
  33                 PA_IoVecSetLen(&v[1], 1100);
  34                 PA_IoVecSetLen(&v[2], 100);
  35
  36                 if( (i % 100) == 0)
  37                 {
  38                         rlt = RUDPSendV(s, 0, v, 3, 0);
  39                 }
  40                 else
  41                         rlt = RUDPSendV(s, 0/*1*/, v, 3, 0);
  42                 if(rlt < 0)
  43                 {
  44                         if(rlt == ERUDP_AGAIN)
  45                         {
  46                                 //usleep(10);
  47                                 continue;
  48                         }
  49                         printf("RUDPSend error: %d\n", rlt);
  50                         break;
  51                 }
  52
  53                 int onesent = PA_IoVecGetLen(&v[0]) + PA_IoVecGetLen(&v[1]) + PA_IoVecGetLen(&v[2]);
  54                 nTotal += onesent;
  55                 nByt += onesent;
  56
  57                 time(&t);
  58                 if(t != t_prev)
  59                 {
  60                         fprintf(stderr, "rate: Avg.: %d B/s, Rt. %d B/s        \r", nTotal/(t-t0), nByt);
  61                         fflush(stderr);
  62                         t_prev = t;
  63                         nByt = 0;
  64                 }
  65         }
  66
  67         printf("***************************************\n");
  68         if(rlt > 0)
  69         {
  70                 line[0] = '\0';
  71                 RUDPSend(s, 0, line, 1, 0);
  72                 printf("all data sent.\n");
  73         }
  74         return 0;
  75 }
  76
  77 void recvData(RUDPSOCKET a)
  78 {
  79         int cnt = 0;
  80         char line[2100];
  81         int len, chno;
  82         while( !g_quit )
  83         {
  84                 struct timeval tv = { 0, 500000 };
  85                 int flag = RUDPSELECT_READABLE, rlt;
  86                 if( (rlt = RUDPSelectSock(a, -1, flag, &tv)) > 0)
  87                 {
  88                         if((len = RUDPRecv(a, &chno, line, 2000, 0)) > 0)
  89                         {
  90                                 if(chno == 0)
  91                                 {
  92                                         //fprintf(stderr, "Packet %d from chn 0\n", cnt);
  93                                 }
  94                                 cnt++;
  95                                 line[len] = '\0';
  96                                 //printf("%s\n", line);
  97                                 if(line[0] == '\0') break;
  98                         }
  99                         else if(len < 0)
 100                         {
 101                                 if(len == ERUDP_AGAIN)
 102                                 {
 103                                         //usleep(10);
 104                                         continue;
 105                                 }
 106                                 fprintf(stderr, "RUDPRecv: %d\n", len);
 107                                 exit(-1);
 108                         }
 109                 }
 110                 else if(rlt < 0)
 111                 {
 112                                 if(rlt == ERUDP_AGAIN)
 113                                 {
 114                                         //usleep(10);
 115                                         continue;
 116                                 }
 117                         printf("ERROR: RUDPSelectSock: %d\n", rlt);
 118                         exit(-1);
 119                 }
 120         }
 121         printf("receiving finished.\n");
 122 }
 123 void *threadSend(void *p)
 124 {
 125         RUDPSOCKET a = (RUDPSOCKET*)p;
 126         pthread_detach(pthread_self());
 127
 128         //recvData(a);
 129         sendData(a);
 130
 131         RUDPClose(a);
 132         sleep(5);
 133         return NULL;
 134 }
 135
 136 void* threadRecv(void *p)
 137 {
 138         RUDPSOCKET a = (RUDPSOCKET*)p;
 139         pthread_detach(pthread_self());
 140
 141         recvData(a);
 142         //sendData(a);
 143
 144         RUDPClose(a);
 145         sleep(5);
 146         return NULL;
 147 }
 148
 149
 150 //Usage: rudpclt [-a] [server] [port]
 151 //      ------- -a: asynchronous
 152 //      ------- server: default is 127.0.0.1,
 153 //      ------- port: 5001 by default
 154 #define SERVER_SEND     0x01
 155 #define SERVER_RECV     0x02
 156 int main(int argc, char *argv[])
 157 {
 158         struct sockaddr_in sai;
 159         int sa_len;
 160         int rlt, i;
 161         RUDPSOCKET s;
 162         char cmd = 3;
 163
 164
 165         PA_NetLibInit();
 166         RUDPStart();
 167
 168         s = RUDPSocket();
 169
 170         memset(&sai, 0, sizeof(sai));
 171         sai.sin_family = AF_INET;
 172         sai.sin_addr.s_addr = inet_addr("127.0.0.1");
 173         sai.sin_port = htons(5001);
 174         sa_len = sizeof(sai);
 175
 176         for(i=1; i<argc; i++)
 177         {
 178                 if(argv[i][0] == '-')
 179                 {
 180                         if(strcmp("-a", argv[i]) == 0)
 181                         {
 182                                 async = 1;
 183                         }
 184                         else if(strcmp("--recvonly", argv[i]) == 0)
 185                                 cmd &= ~SERVER_RECV;
 186                         else if(strcmp("--sendonly", argv[i]) == 0)
 187                                 cmd &= ~SERVER_SEND;
 188                         else if(strcmp("-?", argv[i]) == 0)
 189                         {
 190                                 printf("Usage: rudpclt [-a] [server] [port]\n"
 191                                         "\t-a: asynchronous\n"
 192                                         "\tserver: default is 127.0.0.1\n"
 193                                         "\tport: 5001 by default\n");
 194                                 exit(0);
 195                         }
 196
 197                 }
 198                 else if(strchr(argv[i], '.'))
 199                         sai.sin_addr.s_addr = inet_addr(argv[i]);
 200                 else
 201                         sai.sin_port = htons(atoi(argv[i]));
 202         }
 203
 204         int opt;
 205         //opt = 256; RUDPSetSockOpt(s, OPT_RUDP_RCVBUF, &opt, sizeof(int));
 206         if( (rlt = RUDPConnect(s, (struct sockaddr*)&sai, sizeof(sai))) == 0)
 207         {
 208                         opt = 256; RUDPSetSockOpt(s, OPT_RUDP_SNDBUF, &opt, sizeof(int));
 209                         if(async) RUDPSetSockOpt(s, OPT_NBLK, &async, sizeof(async));
 210                         pthread_t thd;
 211                         RUDPSend(s, 0, &cmd, 1, 0);
 212                         //sleep(5);
 213                         if(cmd & SERVER_RECV) pthread_create(&thd, NULL, threadSend, (void*)s);
 214                         recvData(s);
 215         }
 216         else if(rlt == -ERUDP_AGAIN)
 217         {
 218                 RUDPClose(s);
 219                 s = NULL;
 220         }
 221
 222         if(s) RUDPClose(s);
 223
 224         sleep(4);
 225         RUDPCleanup();
 226
 227         return 0;
 228 }