test/src/server.c

   1 /* A little hacked up program that listens on a given port and allows a script
   2 to play the part of a remote MTA for testing purposes. This scripted version is
   3 hacked from my original interactive version. A further hack allows it to listen
   4 on a Unix domain socket as an alternative to a TCP/IP port.
   5
   6 In an IPv6 world, listening happens on both an IPv6 and an IPv4 socket, always
   7 on all interfaces, unless the option -noipv6 is given. */
   8
   9 /* ANSI C standard includes */
  10
  11 #include <ctype.h>
  12 #include <signal.h>
  13 #include <stdarg.h>
  14 #include <stddef.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <time.h>
  19
  20 /* Unix includes */
  21
  22 #include <errno.h>
  23 #include <dirent.h>
  24 #include <sys/types.h>
  25
  26 #include <netinet/in_systm.h>
  27 #include <netinet/in.h>
  28 #include <netinet/ip.h>
  29
  30 #ifdef HAVE_NETINET_IP_VAR_H
  31 #include <netinet/ip_var.h>
  32 #endif
  33
  34 #include <netdb.h>
  35 #include <arpa/inet.h>
  36 #include <sys/time.h>
  37 #include <sys/resource.h>
  38 #include <sys/socket.h>
  39 #include <sys/un.h>
  40 #include <sys/stat.h>
  41 #include <fcntl.h>
  42 #include <unistd.h>
  43 #include <utime.h>
  44
  45 #ifdef AF_INET6
  46 #define HAVE_IPV6 1
  47 #endif
  48
  49 #ifndef S_ADDR_TYPE
  50 #define S_ADDR_TYPE u_long
  51 #endif
  52
  53
  54 typedef struct line {
  55   struct line *next;
  56   char line[1];
  57 } line;
  58
  59
  60 /*************************************************
  61 *            SIGALRM handler - crash out         *
  62 *************************************************/
  63
  64 static void
  65 sigalrm_handler(int sig)
  66 {
  67 sig = sig;    /* Keep picky compilers happy */
  68 printf("\nServer timed out\n");
  69 exit(99);
  70 }
  71
  72
  73 /*************************************************
  74 *          Get textual IP address                *
  75 *************************************************/
  76
  77 /* This function is copied from Exim */
  78
  79 char *
  80 host_ntoa(const void *arg, char *buffer)
  81 {
  82 char *yield;
  83
  84 /* The new world. It is annoying that we have to fish out the address from
  85 different places in the block, depending on what kind of address it is. It
  86 is also a pain that inet_ntop() returns a const char *, whereas the IPv4
  87 function inet_ntoa() returns just char *, and some picky compilers insist
  88 on warning if one assigns a const char * to a char *. Hence the casts. */
  89
  90 #if HAVE_IPV6
  91 char addr_buffer[46];
  92 int family = ((struct sockaddr *)arg)->sa_family;
  93 if (family == AF_INET6)
  94   {
  95   struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
  96   yield = (char *)inet_ntop(family, &(sk->sin6_addr), addr_buffer,
  97     sizeof(addr_buffer));
  98   }
  99 else
 100   {
 101   struct sockaddr_in *sk = (struct sockaddr_in *)arg;
 102   yield = (char *)inet_ntop(family, &(sk->sin_addr), addr_buffer,
 103     sizeof(addr_buffer));
 104   }
 105
 106 /* If the result is a mapped IPv4 address, show it in V4 format. */
 107
 108 if (strncmp(yield, "::ffff:", 7) == 0) yield += 7;
 109
 110 #else /* HAVE_IPV6 */
 111
 112 /* The old world */
 113
 114 yield = inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
 115 #endif
 116
 117 strcpy(buffer, yield);
 118 return buffer;
 119 }
 120
 121
 122 /*************************************************
 123 *                 Main Program                   *
 124 *************************************************/
 125
 126 #define v6n 0    /* IPv6 socket number */
 127 #define v4n 1    /* IPv4 socket number */
 128 #define udn 2    /* Unix domain socket number */
 129 #define skn 2    /* Potential number of sockets */
 130
 131 int main(int argc, char **argv)
 132 {
 133 int i;
 134 int port = 0;
 135 int listen_socket[3] = { -1, -1, -1 };
 136 int accept_socket;
 137 int dup_accept_socket;
 138 int connection_count = 1;
 139 int count;
 140 int on = 1;
 141 int timeout = 5;
 142 int use_ipv4 = 1;
 143 int use_ipv6 = 1;
 144 int debug = 0;
 145 int na = 1;
 146 line *script = NULL;
 147 line *last = NULL;
 148 line *s;
 149 FILE *in, *out;
 150
 151 char *sockname = NULL;
 152 unsigned char buffer[10240];
 153
 154 struct sockaddr_un sockun;            /* don't use "sun" */
 155 struct sockaddr_un sockun_accepted;
 156 int sockun_len = sizeof(sockun_accepted);
 157
 158 #if HAVE_IPV6
 159 struct sockaddr_in6 sin6;
 160 struct sockaddr_in6 accepted;
 161 struct in6_addr anyaddr6 =  IN6ADDR_ANY_INIT ;
 162 #else
 163 struct sockaddr_in accepted;
 164 #endif
 165
 166 /* Always need an IPv4 structure */
 167
 168 struct sockaddr_in sin4;
 169
 170 int len = sizeof(accepted);
 171
 172
 173 /* Sort out the arguments */
 174
 175 while (na < argc && argv[na][0] == '-')
 176   {
 177   if (strcmp(argv[na], "-d") == 0) debug = 1;
 178   else if (strcmp(argv[na], "-t") == 0) timeout = atoi(argv[++na]);
 179   else if (strcmp(argv[na], "-noipv4") == 0) use_ipv4 = 0;
 180   else if (strcmp(argv[na], "-noipv6") == 0) use_ipv6 = 0;
 181   else
 182     {
 183     printf("server: unknown option %s\n", argv[na]);
 184     exit(1);
 185     }
 186   na++;
 187   }
 188
 189 if (!use_ipv4 && !use_ipv6)
 190   {
 191   printf("server: -noipv4 and -noipv6 cannot both be given\n");
 192   exit(1);
 193   }
 194
 195 if (na >= argc)
 196   {
 197   printf("server: no port number or socket name given\n");
 198   exit(1);
 199   }
 200
 201 if (argv[na][0] == '/')
 202   {
 203   sockname = argv[na];
 204   unlink(sockname);       /* in case left lying around */
 205   }
 206 else port = atoi(argv[na]);
 207 na++;
 208
 209 if (na < argc) connection_count = atoi(argv[na]);
 210
 211
 212 /* Create sockets */
 213
 214 if (port == 0)  /* Unix domain */
 215   {
 216   if (debug) printf("Creating Unix domain socket\n");
 217   listen_socket[udn] = socket(PF_UNIX, SOCK_STREAM, 0);
 218   if (listen_socket[udn] < 0)
 219     {
 220     printf("Unix domain socket creation failed: %s\n", strerror(errno));
 221     exit(1);
 222     }
 223   }
 224 else
 225   {
 226   #if HAVE_IPV6
 227   if (use_ipv6)
 228     {
 229     if (debug) printf("Creating IPv6 socket\n");
 230     listen_socket[v6n] = socket(AF_INET6, SOCK_STREAM, 0);
 231     if (listen_socket[v6n] < 0)
 232       {
 233       printf("IPv6 socket creation failed: %s\n", strerror(errno));
 234       exit(1);
 235       }
 236
 237     /* If this is an IPv6 wildcard socket, set IPV6_V6ONLY if that option is
 238     available. */
 239
 240     #ifdef IPV6_V6ONLY
 241     if (setsockopt(listen_socket[v6n], IPPROTO_IPV6, IPV6_V6ONLY, (char *)(&on),
 242           sizeof(on)) < 0)
 243       printf("Setting IPV6_V6ONLY on IPv6 wildcard "
 244         "socket failed (%s): carrying on without it\n", strerror(errno));
 245     #endif  /* IPV6_V6ONLY */
 246     }
 247   #endif  /* HAVE_IPV6 */
 248
 249   /* Create an IPv4 socket if required */
 250
 251   if (use_ipv4)
 252     {
 253     if (debug) printf("Creating IPv4 socket\n");
 254     listen_socket[v4n] = socket(AF_INET, SOCK_STREAM, 0);
 255     if (listen_socket[v4n] < 0)
 256       {
 257       printf("IPv4 socket creation failed: %s\n", strerror(errno));
 258       exit(1);
 259       }
 260     }
 261   }
 262
 263
 264 /* Set SO_REUSEADDR on the IP sockets so that the program can be restarted
 265 while a connection is being handled - this can happen as old connections lie
 266 around for a bit while crashed processes are tidied away.  Without this, a
 267 connection will prevent reuse of the smtp port for listening. */
 268
 269 for (i = v6n; i <= v4n; i++)
 270   {
 271   if (listen_socket[i] >= 0 &&
 272       setsockopt(listen_socket[i], SOL_SOCKET, SO_REUSEADDR, (char *)(&on),
 273         sizeof(on)) < 0)
 274     {
 275     printf("setting SO_REUSEADDR on socket failed: %s\n", strerror(errno));
 276     exit(1);
 277     }
 278   }
 279
 280
 281 /* Now bind the sockets to the required port or path. If a path, ensure
 282 anyone can write to it. */
 283
 284 if (port == 0)
 285   {
 286   struct stat statbuf;
 287   sockun.sun_family = AF_UNIX;
 288   if (debug) printf("Binding Unix domain socket\n");
 289   sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1), sockname);
 290   if (bind(listen_socket[udn], (struct sockaddr *)&sockun, sizeof(sockun)) < 0)
 291     {
 292     printf("Unix domain socket bind() failed: %s\n", strerror(errno));
 293     exit(1);
 294     }
 295   (void)stat(sockname, &statbuf);
 296   if (debug) printf("Setting Unix domain socket mode: %0x\n",
 297     statbuf.st_mode | 0777);
 298   if (chmod(sockname, statbuf.st_mode | 0777) < 0)
 299     {
 300     printf("Unix domain socket chmod() failed: %s\n", strerror(errno));
 301     exit(1);
 302     }
 303   }
 304
 305 else
 306   {
 307   for (i = 0; i < skn; i++)
 308     {
 309     if (listen_socket[i] < 0) continue;
 310
 311     /* For an IPv6 listen, use an IPv6 socket */
 312
 313     #if HAVE_IPV6
 314     if (i == v6n)
 315       {
 316       memset(&sin6, 0, sizeof(sin6));
 317       sin6.sin6_family = AF_INET6;
 318       sin6.sin6_port = htons(port);
 319       sin6.sin6_addr = anyaddr6;
 320       if (bind(listen_socket[i], (struct sockaddr *)&sin6, sizeof(sin6)) < 0)
 321         {
 322         printf("IPv6 socket bind() failed: %s\n", strerror(errno));
 323         exit(1);
 324         }
 325       }
 326     else
 327     #endif
 328
 329     /* For an IPv4 bind, use an IPv4 socket, even in an IPv6 world. If an IPv4
 330     bind fails EADDRINUSE after IPv6 success, carry on, because it means the
 331     IPv6 socket will handle IPv4 connections. */
 332
 333       {
 334       memset(&sin4, 0, sizeof(sin4));
 335       sin4.sin_family = AF_INET;
 336       sin4.sin_addr.s_addr = (S_ADDR_TYPE)INADDR_ANY;
 337       sin4.sin_port = htons(port);
 338       if (bind(listen_socket[i], (struct sockaddr *)&sin4, sizeof(sin4)) < 0)
 339         {
 340         if (listen_socket[v6n] < 0 || errno != EADDRINUSE)
 341           {
 342           printf("IPv4 socket bind() failed: %s\n", strerror(errno));
 343           exit(1);
 344           }
 345         else
 346           {
 347           close(listen_socket[i]);
 348           listen_socket[i] = -1;
 349           }
 350         }
 351       }
 352     }
 353   }
 354
 355
 356 /* Start listening. If IPv4 fails EADDRINUSE after IPv6 succeeds, ignore the
 357 error because it means that the IPv6 socket will handle IPv4 connections. Don't
 358 output anything, because it will mess up the test output, which will be
 359 different for systems that do this and those that don't. */
 360
 361 for (i = 0; i <= skn; i++)
 362   {
 363   if (listen_socket[i] >= 0 && listen(listen_socket[i], 5) < 0)
 364     {
 365     if (i != v4n || listen_socket[v6n] < 0 || errno != EADDRINUSE)
 366       {
 367       printf("listen() failed: %s\n", strerror(errno));
 368       exit(1);
 369       }
 370     }
 371   }
 372
 373
 374 /* This program handles only a fixed number of connections, in sequence. Before
 375 waiting for the first connection, read the standard input, which contains the
 376 script of things to do. A line containing "++++" is treated as end of file.
 377 This is so that the Perl driving script doesn't have to close the pipe -
 378 because that would cause it to wait for this process, which it doesn't yet want
 379 to do. The driving script adds the "++++" automatically - it doesn't actually
 380 appear in the test script. */
 381
 382 while (fgets(buffer, sizeof(buffer), stdin) != NULL)
 383   {
 384   line *next;
 385   int n = (int)strlen(buffer);
 386   while (n > 0 && isspace(buffer[n-1])) n--;
 387   buffer[n] = 0;
 388   if (strcmp(buffer, "++++") == 0) break;
 389   next = malloc(sizeof(line) + n);
 390   next->next = NULL;
 391   strcpy(next->line, buffer);
 392   if (last == NULL) script = last = next;
 393     else last->next = next;
 394   last = next;
 395   }
 396
 397 fclose(stdin);
 398
 399 /* SIGALRM handler crashes out */
 400
 401 signal(SIGALRM, sigalrm_handler);
 402
 403 /* s points to the current place in the script */
 404
 405 s = script;
 406
 407 for (count = 0; count < connection_count; count++)
 408   {
 409   alarm(timeout);
 410   if (port <= 0)
 411     {
 412     printf("Listening on %s ... ", sockname);
 413     fflush(stdout);
 414     accept_socket = accept(listen_socket[udn],
 415       (struct sockaddr *)&sockun_accepted, &sockun_len);
 416     }
 417
 418   else
 419     {
 420     int lcount;
 421     int max_socket = 0;
 422     fd_set select_listen;
 423
 424     printf("Listening on port %d ... ", port);
 425     fflush(stdout);
 426
 427     FD_ZERO(&select_listen);
 428     for (i = 0; i < skn; i++)
 429       {
 430       if (listen_socket[i] >= 0) FD_SET(listen_socket[i], &select_listen);
 431       if (listen_socket[i] > max_socket) max_socket = listen_socket[i];
 432       }
 433
 434     lcount = select(max_socket + 1, &select_listen, NULL, NULL, NULL);
 435     if (lcount < 0)
 436       {
 437       printf("Select failed\n");
 438       fflush(stdout);
 439       continue;
 440       }
 441
 442     accept_socket = -1;
 443     for (i = 0; i < skn; i++)
 444       {
 445       if (listen_socket[i] > 0 && FD_ISSET(listen_socket[i], &select_listen))
 446         {
 447         accept_socket = accept(listen_socket[i],
 448           (struct sockaddr *)&accepted, &len);
 449         FD_CLR(listen_socket[i], &select_listen);
 450         break;
 451         }
 452       }
 453     }
 454   alarm(0);
 455
 456   if (accept_socket < 0)
 457     {
 458     printf("accept() failed: %s\n", strerror(errno));
 459     exit(1);
 460     }
 461
 462   out = fdopen(accept_socket, "w");
 463
 464   dup_accept_socket = dup(accept_socket);
 465
 466   if (port > 0)
 467     printf("\nConnection request from [%s]\n", host_ntoa(&accepted, buffer));
 468   else
 469     {
 470     printf("\nConnection request\n");
 471
 472     /* Linux supports a feature for acquiring the peer's credentials, but it
 473     appears to be Linux-specific. This code is untested and unused, just
 474     saved here for reference. */
 475
 476     /**********--------------------
 477     struct ucred cr;
 478     int cl=sizeof(cr);
 479
 480     if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &cl)==0) {
 481       printf("Peer's pid=%d, uid=%d, gid=%d\n",
 482               cr.pid, cr.uid, cr.gid);
 483     --------------*****************/
 484     }
 485
 486   if (dup_accept_socket < 0)
 487     {
 488     printf("Couldn't dup socket descriptor\n");
 489     printf("421 Connection refused: %s\n", strerror(errno));
 490     fprintf(out, "421 Connection refused: %s\r\n", strerror(errno));
 491     fclose(out);
 492     exit(2);
 493     }
 494
 495   in = fdopen(dup_accept_socket, "r");
 496
 497   /* Loop for handling the conversation(s). For use in SMTP sessions, there are
 498   default rules for determining input and output lines: the latter start with
 499   digits. This means that the input looks like SMTP dialog. However, this
 500   doesn't work for other tests (e.g. ident tests) so we have explicit '<' and
 501   '>' flags for input and output as well as the defaults. */
 502
 503   for (; s != NULL; s = s->next)
 504     {
 505     char *ss = s->line;
 506
 507     /* Output lines either start with '>' or a digit. In the '>' case we can
 508     fudge the sending of \r\n as required. Default is \r\n, ">>" send nothing,
 509     ">CR>" sends \r only, and ">LF>" sends \n only. We can also force a
 510     connection closedown by ">*eof". */
 511
 512     if (ss[0] == '>')
 513       {
 514       char *end = "\r\n";
 515       printf("%s\n", ss++);
 516
 517       if (strncmp(ss, "*eof", 4) == 0)
 518         {
 519         s = s->next;
 520         goto END_OFF;
 521         }
 522
 523       if (*ss == '>')
 524         { end = ""; ss++; }
 525       else if (strncmp(ss, "CR>", 3) == 0)
 526         { end = "\r"; ss += 3; }
 527       else if (strncmp(ss, "LF>", 3) == 0)
 528         { end = "\n"; ss += 3; }
 529
 530       fprintf(out, "%s%s", ss, end);
 531       }
 532
 533     else if (isdigit((unsigned char)ss[0]))
 534       {
 535       printf("%s\n", ss);
 536       fprintf(out, "%s\r\n", ss);
 537       }
 538
 539     /* If the script line starts with "*sleep" we just sleep for a while
 540     before continuing. */
 541
 542     else if (strncmp(ss, "*sleep ", 7) == 0)
 543       {
 544       int sleepfor = atoi(ss+7);
 545       printf("%s\n", ss);
 546       fflush(out);
 547       sleep(sleepfor);
 548       }
 549
 550     /* Otherwise the script line is the start of an input line we are expecting
 551     from the client, or "*eof" indicating we expect the client to close the
 552     connection. Read command line or data lines; the latter are indicated
 553     by the expected line being just ".". If the line starts with '<', that
 554     doesn't form part of the expected input. (This allows for incoming data
 555     starting with a digit.) */
 556
 557     else
 558       {
 559       int offset;
 560       int data = strcmp(ss, ".") == 0;
 561
 562       if (ss[0] == '<')
 563         {
 564         buffer[0] = '<';
 565         offset = 1;
 566         }
 567       else offset = 0;
 568
 569       fflush(out);
 570
 571       for (;;)
 572         {
 573         int n;
 574         alarm(timeout);
 575         if (fgets(buffer+offset, sizeof(buffer)-offset, in) == NULL)
 576           {
 577           printf("%sxpected EOF read from client\n",
 578             (strncmp(ss, "*eof", 4) == 0)? "E" : "Une");
 579           s = s->next;
 580           goto END_OFF;
 581           }
 582         alarm(0);
 583         n = (int)strlen(buffer);
 584         while (n > 0 && isspace(buffer[n-1])) n--;
 585         buffer[n] = 0;
 586         printf("%s\n", buffer);
 587         if (!data || strcmp(buffer, ".") == 0) break;
 588         }
 589
 590       if (strncmp(ss, buffer, (int)strlen(ss)) != 0)
 591         {
 592         printf("Comparison failed - bailing out\n");
 593         printf("Expected: %s\n", ss);
 594         break;
 595         }
 596       }
 597     }
 598
 599   END_OFF:
 600   fclose(in);
 601   fclose(out);
 602   }
 603
 604 if (s == NULL) printf("End of script\n");
 605
 606 if (sockname != NULL) unlink(sockname);
 607 exit(0);
 608 }
 609
 610 /* End of server.c */