drivers/char/mxhwenp/test/metaserver.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <time.h>
   4 #ifndef WIN32
   5 #include <sys/times.h>
   6 #endif
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <stdarg.h>
  10 #include "netp.h"
  11
  12 enum
  13 {
  14         TCPSERVER,
  15         TCPCLIENT
  16 };
  17
  18 unsigned int
  19 lookup_ip(char *host)
  20 {
  21         struct hostent *he;
  22         unsigned int ip;
  23
  24         ip = inet_addr(host);
  25         if (ip==INADDR_NONE)
  26         {
  27                 he=gethostbyname(host);
  28                 if (!he)
  29                         return 0;
  30                 memcpy(&ip, he->h_addr_list[0],he->h_length);
  31         }
  32         return ip;
  33 }
  34
  35 int
  36 bind_interface(int fd, unsigned int ip, int port)
  37 {
  38         struct sockaddr_in sin;
  39
  40         memset(&sin,0,sizeof(sin));
  41         sin.sin_family = AF_INET;
  42         sin.sin_addr.s_addr=ip;
  43         sin.sin_port = htons((unsigned short) port);
  44         if (bind(fd, (struct sockaddr *) &sin,sizeof(sin)) < 0)
  45                 return -1;
  46         else
  47                 return 0;
  48 }
  49
  50 int
  51 set_nonblocking(int fd)
  52 {
  53 #ifdef WIN32
  54         long val=1;
  55         if (ioctlsocket (fd, FIONBIO, &val) != 0)
  56 #else
  57         if (fcntl (fd, F_SETFL, O_NONBLOCK) != 0)
  58 #endif
  59                 return -1;
  60         else
  61                 return 0;
  62 }
  63
  64 int
  65 tcp_socket(char *host, int port, int type)
  66 {
  67         struct  sockaddr_in sin;
  68         int             sock;
  69
  70         memset(&sin,0,sizeof(sin));
  71         sin.sin_family = AF_INET;
  72         sin.sin_port = htons((unsigned short)port);
  73         sin.sin_addr.s_addr = host? lookup_ip(host):htonl(INADDR_ANY);
  74
  75         sock = socket(AF_INET, SOCK_STREAM, 0);
  76         if (sock > 0)
  77         {
  78         if (type==TCPSERVER)
  79                 bind(sock, (struct sockaddr*) &sin,sizeof(sin));
  80         else
  81                 connect(sock, (struct sockaddr*) &sin,sizeof(sin));
  82         }
  83         return sock;
  84 }
  85
  86 ssize_t
  87 readn(int fd, void *vptr, size_t n)
  88 {
  89         size_t nleft=n;
  90         ssize_t nread;
  91         char *p = vptr;
  92
  93         while(nleft > 0)
  94         {
  95                 if ((nread = read(fd, p, nleft)) < 0)
  96                 {
  97                         if (errno==EINTR)
  98                                 nread=0;
  99                         else
 100                         return -1;
 101                 } else if (nread==0)
 102                         break;
 103                 nleft -= nread;
 104                 p += nread;
 105         }
 106         return n-nleft;
 107 }
 108
 109 ssize_t
 110 writen(int fd, void *vptr, size_t n)
 111 {
 112         size_t nleft=n;
 113         ssize_t nread;
 114         char *p = vptr;
 115
 116         while(nleft > 0)
 117         {
 118                 if ((nread = write(fd, p, nleft)) < 0)
 119                 {
 120                         if (errno==EINTR)
 121                                 nread=0;
 122                         else
 123                         return -1;
 124                 } else if (nread==0)
 125                         break;
 126                 nleft -= nread;
 127                 p += nread;
 128         }
 129         return n;
 130 }
 131
 132 unsigned char Buf[2048];
 133
 134 void
 135 send_cmd (int fd, unsigned int cmd, const char *fmt, ...)
 136 {
 137     va_list ap;
 138     size_t  l;
 139     u_short s;
 140
 141     va_start (ap, fmt);
 142     vsnprintf (Buf + 4, sizeof (Buf) - 4, fmt, ap);
 143     va_end (ap);
 144
 145         l = strlen (Buf + 4);
 146         s = (u_short) l;
 147
 148         memcpy(Buf, &s, 2);
 149         s = (short) cmd;
 150         memcpy(Buf+2, &s, 2);
 151
 152     writen (fd, Buf, 4 + l);
 153     *(Buf+4+l)=0;
 154 printf("SEND:[%d,%d] %s\n",cmd, l, Buf+4);
 155 }
 156
 157 #define HANDLER(f) void f (int fd, unsigned int cmd, char *pkt, unsigned int len)
 158
 159 typedef struct
 160 {
 161     unsigned int cmd;
 162     HANDLER ((*handler));
 163 } HNDLR;
 164
 165 static int
 166 split_line(char **av, char *pkt, int max)
 167 {
 168         int n=0;
 169
 170         while(*pkt && n < max)
 171         {
 172                 while(*pkt==' ') pkt++;
 173                 av[n++] = pkt++;
 174                 while(*pkt==' ') pkt++;
 175         }
 176         return n;
 177 }
 178
 179 /* <name> <runs> <len1> [<len2> ....] */
 180 HANDLER(meta_cipher_process)
 181 {
 182         char *av[32];
 183         int i,ac, numPkts;
 184         double swT, hwT;
 185
 186         ac = split_line(av, pkt, 32);
 187         if (ac < 3)
 188                 return;
 189
 190         numPkts = atoi(av[1]);
 191         for (i=2; i < ac; i++)
 192         {
 193                 if (test_meta_cipher_process(av[0], numPkts, atoi(av[i]), &swT, &hwT))
 194                         continue;
 195                 send_cmd(fd, cmd, "%s %.2f %.2f", av[1], swT, hwT);
 196         }
 197 }
 198
 199 HNDLR hndls[] =
 200 {
 201         {0, NULL},
 202         {1, meta_cipher_process},
 203 };
 204
 205 int HNDLR_SIZE = sizeof(hndls)/sizeof(hndls[0]);
 206
 207 static void
 208 server_dispatch(int fd)
 209 {
 210         int n;
 211         u_short cmd, len;
 212
 213         while(1)
 214         {
 215                 n = readn(fd, Buf, 4);
 216                 if (n<=0)
 217                         return;
 218                 memcpy(&len, Buf, 2);
 219                 memcpy(&cmd, Buf+2, 2);
 220                 if (cmd==0)
 221                         break;
 222                 n = readn(fd, Buf, len);
 223                 if (n!=len)
 224                         return;
 225                 *(Buf+len)=0;;
 226 printf("RECV:[%d,%d] %s\n",cmd, len, Buf);
 227
 228                 for (n=0; n < HNDLR_SIZE; n++)
 229                 if (hndls[n].cmd == cmd)
 230                 {
 231                         hndls[n].handler(fd, cmd, Buf, len);
 232                         break;
 233                 }
 234         }
 235 }
 236
 237 int
 238 meta_main()
 239 {
 240         struct  sockaddr_in caddr;
 241         socklen_t len;
 242         int             fd, sock;
 243
 244 #if defined(WIN32)
 245     WSADATA wsa;
 246
 247     WSAStartup (MAKEWORD (1, 1), &wsa);
 248 #endif /* !WIN32 */
 249         sock = tcp_socket(NULL,SERVER_PORT,TCPSERVER);
 250         listen(sock, 5);
 251 printf("listen at port %d\n",SERVER_PORT);
 252         for (;;)
 253         {
 254                 len = sizeof(caddr);
 255                 fd  = accept(sock,(struct sockaddr*) &caddr,&len);
 256                 if (fd > 0)
 257                 {
 258         printf("accept a client at fd %d\n",fd);
 259                         server_dispatch(fd);
 260                         close(fd);
 261                 }
 262         }
 263         close(sock);
 264 #if defined(WIN32) && !defined(__CYGWIN__)
 265     WSACleanup ();
 266 #endif
 267         return 0;
 268 }
 269
 270
 271