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 #include <netinet/tcp.h>
  30
  31 #ifdef HAVE_NETINET_IP_VAR_H
  32 # include <netinet/ip_var.h>
  33 #endif
  34
  35 #include <netdb.h>
  36 #include <arpa/inet.h>
  37 #include <sys/time.h>
  38 #include <sys/resource.h>
  39 #include <sys/socket.h>
  40 #include <sys/un.h>
  41 #include <sys/stat.h>
  42 #include <fcntl.h>
  43 #include <unistd.h>
  44 #include <utime.h>
  45
  46 #ifdef AF_INET6
  47 # define HAVE_IPV6 1
  48 #endif
  49
  50 #ifndef S_ADDR_TYPE
  51 # define S_ADDR_TYPE u_long
  52 #endif
  53
  54 #ifndef CS
  55 # define CS (char *)
  56 # define CCS (const char *)
  57 #endif
  58
  59
  60 typedef struct line {
  61   struct line *next;
  62   unsigned len;
  63   char line[1];
  64 } line;
  65
  66 typedef unsigned BOOL;
  67 #define FALSE 0
  68 #define TRUE  1
  69
  70
  71 /*************************************************
  72 *            SIGALRM handler - crash out         *
  73 *************************************************/
  74 int tmo_noerror = 0;
  75
  76 static void
  77 sigalrm_handler(int sig)
  78 {
  79 sig = sig;    /* Keep picky compilers happy */
  80 printf("\nServer timed out\n");
  81 exit(tmo_noerror ? 0 : 99);
  82 }
  83
  84
  85 /*************************************************
  86 *          Get textual IP address                *
  87 *************************************************/
  88
  89 /* This function is copied from Exim */
  90
  91 char *
  92 host_ntoa(const void *arg, char *buffer)
  93 {
  94 char *yield;
  95
  96 /* The new world. It is annoying that we have to fish out the address from
  97 different places in the block, depending on what kind of address it is. It
  98 is also a pain that inet_ntop() returns a const char *, whereas the IPv4
  99 function inet_ntoa() returns just char *, and some picky compilers insist
 100 on warning if one assigns a const char * to a char *. Hence the casts. */
 101
 102 #if HAVE_IPV6
 103 char addr_buffer[46];
 104 int family = ((struct sockaddr *)arg)->sa_family;
 105 if (family == AF_INET6)
 106   {
 107   struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
 108   yield = (char *)inet_ntop(family, &(sk->sin6_addr), addr_buffer,
 109     sizeof(addr_buffer));
 110   }
 111 else
 112   {
 113   struct sockaddr_in *sk = (struct sockaddr_in *)arg;
 114   yield = (char *)inet_ntop(family, &(sk->sin_addr), addr_buffer,
 115     sizeof(addr_buffer));
 116   }
 117
 118 /* If the result is a mapped IPv4 address, show it in V4 format. */
 119
 120 if (strncmp(yield, "::ffff:", 7) == 0) yield += 7;
 121
 122 #else /* HAVE_IPV6 */
 123
 124 /* The old world */
 125
 126 yield = inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
 127 #endif
 128
 129 strcpy(buffer, yield);
 130 return buffer;
 131 }
 132
 133
 134
 135 static void
 136 printit(char * s, int n)
 137 {
 138 while(n--)
 139   {
 140   unsigned char c = *s++;
 141   if (c == '\\')
 142     printf("\\\\");
 143   else if (c >= ' ' && c <= '~')        /* assumes ascii */
 144     putchar(c);
 145   else
 146     printf("\\x%02x", c);
 147   }
 148 putchar('\n');
 149 }
 150
 151
 152
 153 /*************************************************
 154 *                 Main Program                   *
 155 *************************************************/
 156
 157 #define v6n 0    /* IPv6 socket number */
 158 #define v4n 1    /* IPv4 socket number */
 159 #define udn 2    /* Unix domain socket number */
 160 #define skn 2    /* Potential number of sockets */
 161
 162 int
 163 main(int argc, char **argv)
 164 {
 165 int i;
 166 int port = 0;
 167 int listen_socket[3] = { -1, -1, -1 };
 168 int accept_socket;
 169 int dup_accept_socket;
 170 int connection_count = 1;
 171 int count;
 172 int on = 1;
 173 int timeout = 5;
 174 int initial_pause = 0, tfo = 0;
 175 int use_ipv4 = 1;
 176 int use_ipv6 = 1;
 177 int debug = 0;
 178 int na = 1;
 179 line *script = NULL;
 180 line *last = NULL;
 181 line *s;
 182 FILE *in, *out;
 183 int linebuf = 1;
 184 char *pidfile = NULL;
 185
 186 char *sockname = NULL;
 187 unsigned char buffer[10240];
 188
 189 struct sockaddr_un sockun;            /* don't use "sun" */
 190 struct sockaddr_un sockun_accepted;
 191 int sockun_len = sizeof(sockun_accepted);
 192
 193 #if HAVE_IPV6
 194 struct sockaddr_in6 sin6;
 195 struct sockaddr_in6 accepted;
 196 struct in6_addr anyaddr6 =  IN6ADDR_ANY_INIT ;
 197 #else
 198 struct sockaddr_in accepted;
 199 #endif
 200
 201 /* Always need an IPv4 structure */
 202
 203 struct sockaddr_in sin4;
 204
 205 int len = sizeof(accepted);
 206
 207
 208 /* Sort out the arguments */
 209 if (argc > 1 && (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-h")))
 210   {
 211   printf("Usage: %s [options] port|socket [connection count]\n", argv[0]);
 212   puts("Options"
 213        "\n\t-d       debug"
 214        "\n\t-i n     n seconds initial delay"
 215        "\n\t-noipv4  disable ipv4"
 216        "\n\t-noipv6  disable ipv6"
 217        "\n\t-oP file write PID to file"
 218        "\n\t-t n     n seconds timeout"
 219        "\n\t-tfo     enable TCP Fast Open"
 220   );
 221   exit(0);
 222   }
 223
 224 while (na < argc && argv[na][0] == '-')
 225   {
 226   if (strcmp(argv[na], "-d") == 0) debug = 1;
 227   else if (strcmp(argv[na], "-tfo") == 0) tfo = 1;
 228   else if (strcmp(argv[na], "-t") == 0)
 229     {
 230     if (tmo_noerror = ((timeout = atoi(argv[++na])) < 0)) timeout = -timeout;
 231     }
 232   else if (strcmp(argv[na], "-i") == 0) initial_pause = atoi(argv[++na]);
 233   else if (strcmp(argv[na], "-noipv4") == 0) use_ipv4 = 0;
 234   else if (strcmp(argv[na], "-noipv6") == 0) use_ipv6 = 0;
 235   else if (strcmp(argv[na], "-oP") == 0) pidfile = argv[++na];
 236   else
 237     {
 238     printf("server: unknown option %s, try -h or --help\n", argv[na]);
 239     exit(1);
 240     }
 241   na++;
 242   }
 243
 244 if (!use_ipv4 && !use_ipv6)
 245   {
 246   printf("server: -noipv4 and -noipv6 cannot both be given\n");
 247   exit(1);
 248   }
 249
 250 if (na >= argc)
 251   {
 252   printf("server: no port number or socket name given\n");
 253   exit(1);
 254   }
 255
 256 if (argv[na][0] == '/')
 257   {
 258   sockname = argv[na];
 259   unlink(sockname);       /* in case left lying around */
 260   }
 261 else port = atoi(argv[na]);
 262 na++;
 263
 264 if (na < argc) connection_count = atoi(argv[na]);
 265
 266
 267 /* Initial pause (before creating listen sockets */
 268 if (initial_pause > 0)
 269   {
 270   if (debug)
 271     printf("%ld: Inital pause of %d seconds\n", (long)time(NULL), initial_pause);
 272   else
 273     printf("Inital pause of %d seconds\n", initial_pause);
 274   while (initial_pause > 0)
 275     initial_pause = sleep(initial_pause);
 276   }
 277
 278 /* Create sockets */
 279
 280 if (port == 0)  /* Unix domain */
 281   {
 282   if (debug) printf("%l: Creating Unix domain socket\n", (long) time(NULL));
 283   listen_socket[udn] = socket(PF_UNIX, SOCK_STREAM, 0);
 284   if (listen_socket[udn] < 0)
 285     {
 286     printf("Unix domain socket creation failed: %s\n", strerror(errno));
 287     exit(1);
 288     }
 289   }
 290 else
 291   {
 292   #if HAVE_IPV6
 293   if (use_ipv6)
 294     {
 295     if (debug) printf("Creating IPv6 socket\n");
 296     listen_socket[v6n] = socket(AF_INET6, SOCK_STREAM, 0);
 297     if (listen_socket[v6n] < 0)
 298       {
 299       printf("IPv6 socket creation failed: %s\n", strerror(errno));
 300       exit(1);
 301       }
 302 #if defined(TCP_FASTOPEN) && !defined(__APPLE__)
 303     if (tfo)
 304       {
 305       int backlog = 5;
 306       if (setsockopt(listen_socket[v6n], IPPROTO_TCP, TCP_FASTOPEN,
 307                     &backlog, sizeof(backlog)))
 308         if (debug) printf("setsockopt TCP_FASTOPEN: %s\n", strerror(errno));
 309       }
 310 #endif
 311     /* If this is an IPv6 wildcard socket, set IPV6_V6ONLY if that option is
 312     available. */
 313
 314     #ifdef IPV6_V6ONLY
 315     if (setsockopt(listen_socket[v6n], IPPROTO_IPV6, IPV6_V6ONLY, (char *)(&on),
 316           sizeof(on)) < 0)
 317       printf("Setting IPV6_V6ONLY on IPv6 wildcard "
 318         "socket failed (%s): carrying on without it\n", strerror(errno));
 319     #endif  /* IPV6_V6ONLY */
 320     }
 321   #endif  /* HAVE_IPV6 */
 322
 323   /* Create an IPv4 socket if required */
 324
 325   if (use_ipv4)
 326     {
 327     if (debug) printf("Creating IPv4 socket\n");
 328     listen_socket[v4n] = socket(AF_INET, SOCK_STREAM, 0);
 329     if (listen_socket[v4n] < 0)
 330       {
 331       printf("IPv4 socket creation failed: %s\n", strerror(errno));
 332       exit(1);
 333       }
 334 #if defined(TCP_FASTOPEN) && !defined(__APPLE__)
 335     if (tfo)
 336       {
 337       int backlog = 5;
 338       if (setsockopt(listen_socket[v4n], IPPROTO_TCP, TCP_FASTOPEN,
 339                     &backlog, sizeof(backlog)))
 340         if (debug) printf("setsockopt TCP_FASTOPEN: %s\n", strerror(errno));
 341       }
 342 #endif
 343     }
 344   }
 345
 346
 347 /* Set SO_REUSEADDR on the IP sockets so that the program can be restarted
 348 while a connection is being handled - this can happen as old connections lie
 349 around for a bit while crashed processes are tidied away.  Without this, a
 350 connection will prevent reuse of the smtp port for listening. */
 351
 352 for (i = v6n; i <= v4n; i++)
 353   {
 354   if (listen_socket[i] >= 0 &&
 355       setsockopt(listen_socket[i], SOL_SOCKET, SO_REUSEADDR, (char *)(&on),
 356         sizeof(on)) < 0)
 357     {
 358     printf("setting SO_REUSEADDR on socket failed: %s\n", strerror(errno));
 359     exit(1);
 360     }
 361   }
 362
 363
 364 /* Now bind the sockets to the required port or path. If a path, ensure
 365 anyone can write to it. */
 366
 367 if (port == 0)
 368   {
 369   struct stat statbuf;
 370   sockun.sun_family = AF_UNIX;
 371   if (debug) printf("Binding Unix domain socket\n");
 372   sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1), sockname);
 373   if (bind(listen_socket[udn], (struct sockaddr *)&sockun, sizeof(sockun)) < 0)
 374     {
 375     printf("Unix domain socket bind() failed: %s\n", strerror(errno));
 376     exit(1);
 377     }
 378   (void)stat(sockname, &statbuf);
 379   if (debug) printf("Setting Unix domain socket mode: %0x\n",
 380     statbuf.st_mode | 0777);
 381   if (chmod(sockname, statbuf.st_mode | 0777) < 0)
 382     {
 383     printf("Unix domain socket chmod() failed: %s\n", strerror(errno));
 384     exit(1);
 385     }
 386   }
 387
 388 else
 389   {
 390   for (i = 0; i < skn; i++)
 391     {
 392     if (listen_socket[i] < 0) continue;
 393
 394     /* For an IPv6 listen, use an IPv6 socket */
 395
 396     #if HAVE_IPV6
 397     if (i == v6n)
 398       {
 399       memset(&sin6, 0, sizeof(sin6));
 400       sin6.sin6_family = AF_INET6;
 401       sin6.sin6_port = htons(port);
 402       sin6.sin6_addr = anyaddr6;
 403       if (bind(listen_socket[i], (struct sockaddr *)&sin6, sizeof(sin6)) < 0)
 404         {
 405         printf("IPv6 socket bind(port %d) failed: %s\n", port, strerror(errno));
 406         exit(1);
 407         }
 408       }
 409     else
 410     #endif
 411
 412     /* For an IPv4 bind, use an IPv4 socket, even in an IPv6 world. If an IPv4
 413     bind fails EADDRINUSE after IPv6 success, carry on, because it means the
 414     IPv6 socket will handle IPv4 connections. */
 415
 416       {
 417       memset(&sin4, 0, sizeof(sin4));
 418       sin4.sin_family = AF_INET;
 419       sin4.sin_addr.s_addr = (S_ADDR_TYPE)INADDR_ANY;
 420       sin4.sin_port = htons(port);
 421       if (bind(listen_socket[i], (struct sockaddr *)&sin4, sizeof(sin4)) < 0)
 422         if (listen_socket[v6n] < 0 || errno != EADDRINUSE)
 423           {
 424           printf("IPv4 socket bind(port %d) failed: %s\n", port, strerror(errno));
 425           exit(1);
 426           }
 427         else
 428           {
 429           close(listen_socket[i]);
 430           listen_socket[i] = -1;
 431           }
 432       }
 433     }
 434   }
 435
 436
 437 /* Start listening. If IPv4 fails EADDRINUSE after IPv6 succeeds, ignore the
 438 error because it means that the IPv6 socket will handle IPv4 connections. Don't
 439 output anything, because it will mess up the test output, which will be
 440 different for systems that do this and those that don't. */
 441
 442 for (i = 0; i <= skn; i++) if (listen_socket[i] >= 0)
 443   {
 444   if (listen(listen_socket[i], 5) < 0)
 445     if (i != v4n || listen_socket[v6n] < 0 || errno != EADDRINUSE)
 446       {
 447       printf("listen() failed: %s\n", strerror(errno));
 448       exit(1);
 449       }
 450
 451 #if defined(TCP_FASTOPEN) && defined(__APPLE__)
 452   if (  tfo
 453      && setsockopt(listen_socket[v4n], IPPROTO_TCP, TCP_FASTOPEN, &on, sizeof(on))
 454      && debug)
 455       printf("setsockopt TCP_FASTOPEN: %s\n", strerror(errno));
 456 #endif
 457   }
 458
 459
 460 if (pidfile)
 461   {
 462   FILE * p;
 463   if (!(p = fopen(pidfile, "w")))
 464     {
 465     fprintf(stderr, "pidfile create failed: %s\n", strerror(errno));
 466     exit(1);
 467     }
 468   fprintf(p, "%ld\n", (long)getpid());
 469   fclose(p);
 470   }
 471
 472 /* This program handles only a fixed number of connections, in sequence. Before
 473 waiting for the first connection, read the standard input, which contains the
 474 script of things to do. A line containing "++++" is treated as end of file.
 475 This is so that the Perl driving script doesn't have to close the pipe -
 476 because that would cause it to wait for this process, which it doesn't yet want
 477 to do. The driving script adds the "++++" automatically - it doesn't actually
 478 appear in the test script. Within lines we interpret \xNN and \\ groups */
 479
 480 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
 481   {
 482   line *next;
 483   char * d;
 484   int n = (int)strlen(CS buffer);
 485
 486   if (n > 1 && buffer[0] == '>' && buffer[1] == '>')
 487     linebuf = 0;
 488   while (n > 0 && isspace(buffer[n-1])) n--;
 489   buffer[n] = 0;
 490   if (strcmp(CS buffer, "++++") == 0) break;
 491   next = malloc(sizeof(line) + n);
 492   next->next = NULL;
 493   d = next->line;
 494     {
 495     char * s = CS buffer;
 496     do
 497       {
 498       char ch;
 499       char cl = *s;
 500       if (cl == '\\' && (cl = *++s) == 'x')
 501         {
 502         if ((ch = *++s - '0') > 9 && (ch -= 'A'-'9'-1) > 15) ch -= 'a'-'A';
 503         if ((cl = *++s - '0') > 9 && (cl -= 'A'-'9'-1) > 15) cl -= 'a'-'A';
 504         cl |= ch << 4;
 505         }
 506       *d++ = cl;
 507       }
 508     while (*s++);
 509     }
 510   next->len = d - next->line - 1;
 511   if (last == NULL) script = last = next;
 512     else last->next = next;
 513   last = next;
 514   }
 515
 516 fclose(stdin);
 517
 518 /* SIGALRM handler crashes out */
 519
 520 signal(SIGALRM, sigalrm_handler);
 521
 522 /* s points to the current place in the script */
 523
 524 s = script;
 525
 526 for (count = 0; count < connection_count; count++)
 527   {
 528   struct {
 529     int left;
 530     BOOL in_use;
 531   } content_length = { 0, FALSE };
 532
 533   alarm(timeout);
 534   if (port <= 0)
 535     {
 536     printf("Listening on %s ... ", sockname);
 537     fflush(stdout);
 538     accept_socket = accept(listen_socket[udn],
 539       (struct sockaddr *)&sockun_accepted, &sockun_len);
 540     }
 541
 542   else
 543     {
 544     int lcount;
 545     int max_socket = 0;
 546     fd_set select_listen;
 547
 548     printf("Listening on port %d ... ", port);
 549     fflush(stdout);
 550
 551     FD_ZERO(&select_listen);
 552     for (i = 0; i < skn; i++)
 553       {
 554       if (listen_socket[i] >= 0) FD_SET(listen_socket[i], &select_listen);
 555       if (listen_socket[i] > max_socket) max_socket = listen_socket[i];
 556       }
 557
 558     if ((lcount = select(max_socket + 1, &select_listen, NULL, NULL, NULL)) < 0)
 559       {
 560       printf("Select failed\n");
 561       fflush(stdout);
 562       continue;
 563       }
 564
 565     accept_socket = -1;
 566     for (i = 0; i < skn; i++)
 567       if (listen_socket[i] > 0 && FD_ISSET(listen_socket[i], &select_listen))
 568         {
 569         accept_socket = accept(listen_socket[i],
 570           (struct sockaddr *)&accepted, &len);
 571         FD_CLR(listen_socket[i], &select_listen);
 572         break;
 573         }
 574     }
 575   alarm(0);
 576
 577   if (accept_socket < 0)
 578     {
 579     printf("accept() failed: %s\n", strerror(errno));
 580     exit(1);
 581     }
 582
 583   out = fdopen(accept_socket, "w");
 584
 585   dup_accept_socket = dup(accept_socket);
 586
 587   if (port > 0)
 588     printf("\nConnection request from [%s]\n", host_ntoa(&accepted, CS buffer));
 589   else
 590     {
 591     printf("\nConnection request\n");
 592
 593     /* Linux supports a feature for acquiring the peer's credentials, but it
 594     appears to be Linux-specific. This code is untested and unused, just
 595     saved here for reference. */
 596
 597     /**********--------------------
 598     struct ucred cr;
 599     int cl=sizeof(cr);
 600
 601     if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &cl)==0) {
 602       printf("Peer's pid=%d, uid=%d, gid=%d\n",
 603               cr.pid, cr.uid, cr.gid);
 604     --------------*****************/
 605     }
 606   fflush(stdout);
 607
 608   if (dup_accept_socket < 0)
 609     {
 610     printf("Couldn't dup socket descriptor\n");
 611     printf("421 Connection refused: %s\n", strerror(errno));
 612     fprintf(out, "421 Connection refused: %s\r\n", strerror(errno));
 613     fclose(out);
 614     exit(2);
 615     }
 616
 617   in = fdopen(dup_accept_socket, "r");
 618
 619   /* Loop for handling the conversation(s). For use in SMTP sessions, there are
 620   default rules for determining input and output lines: the latter start with
 621   digits. This means that the input looks like SMTP dialog. However, this
 622   doesn't work for other tests (e.g. ident tests) so we have explicit '<' and
 623   '>' flags for input and output as well as the defaults. */
 624
 625   for (; s; s = s->next)
 626     {
 627     char *ss = s->line;
 628
 629     /* Output lines either start with '>' or a digit. In the '>' case we can
 630     fudge the sending of \r\n as required. Default is \r\n, ">>" send nothing,
 631     ">CR>" sends \r only, and ">LF>" sends \n only. We can also force a
 632     connection closedown by ">*eof". */
 633
 634     if (ss[0] == '>')
 635       {
 636       char *end = "\r\n";
 637       unsigned len = s->len;
 638       printit(ss++, len--);
 639
 640       if (strncmp(ss, "*eof", 4) == 0)
 641         {
 642         s = s->next;
 643         goto END_OFF;
 644         }
 645
 646       if (*ss == '>')
 647         { end = ""; ss++; len--; }
 648       else if (strncmp(ss, "CR>", 3) == 0)
 649         { end = "\r"; ss += 3; len -= 3; }
 650       else if (strncmp(ss, "LF>", 3) == 0)
 651         { end = "\n"; ss += 3; len -= 3; }
 652
 653       fwrite(ss, 1, len, out);
 654       if (*end) fprintf(out, end);
 655       }
 656
 657     else if (isdigit((unsigned char)ss[0]))
 658       {
 659       printf("%s\n", ss);
 660       fprintf(out, "%s\r\n", ss);
 661       }
 662
 663     /* If the script line starts with "*sleep" we just sleep for a while
 664     before continuing. */
 665
 666     else if (strncmp(ss, "*sleep ", 7) == 0)
 667       {
 668       int sleepfor = atoi(ss+7);
 669       printf("%s\n", ss);
 670       fflush(out);
 671       sleep(sleepfor);
 672       }
 673
 674     /* If the script line starts with "*data " we expect a numeric argument,
 675     and we expect to read (and discard) that many data bytes from the input. */
 676
 677     else if (strncmp(ss, "*data ", 6) == 0)
 678       {
 679       int dlen = atoi(ss+6);
 680       int n;
 681
 682       alarm(timeout);
 683
 684       if (!linebuf)
 685         while (dlen > 0)
 686           {
 687           n = dlen < sizeof(buffer) ? dlen : sizeof(buffer);
 688           if ((n = read(dup_accept_socket, CS buffer, n)) == 0)
 689             {
 690             printf("Unexpected EOF read from client\n");
 691             s = s->next;
 692             goto END_OFF;
 693             }
 694           dlen -= n;
 695           }
 696       else
 697         while (dlen-- > 0)
 698           if (fgetc(in) == EOF)
 699             {
 700             printf("Unexpected EOF read from client\n");
 701             s = s->next;
 702             goto END_OFF;
 703             }
 704       }
 705
 706     /* Otherwise the script line is the start of an input line we are expecting
 707     from the client, or "*eof" indicating we expect the client to close the
 708     connection. Read command line or data lines; the latter are indicated
 709     by the expected line being just ".". If the line starts with '<', that
 710     doesn't form part of the expected input. (This allows for incoming data
 711     starting with a digit.) If the line starts with '<<' we operate in
 712     unbuffered rather than line mode and assume that a single read gets the
 713     entire message. */
 714
 715     else
 716       {
 717       int offset;
 718       int data = strcmp(ss, ".") == 0;
 719
 720       if (ss[0] != '<')
 721         offset = 0;
 722       else
 723         {
 724         buffer[0] = '<';
 725         if (ss[1] != '<')
 726           offset = 1;
 727         else
 728           {
 729           buffer[1] = '<';
 730           offset = 2;
 731           }
 732         }
 733
 734       fflush(out);
 735
 736       if (!linebuf)
 737         {
 738         int n;
 739         char c;
 740
 741         alarm(timeout);
 742         n = read(dup_accept_socket, CS buffer+offset, s->len - offset);
 743         if (content_length.in_use) content_length.left -= n;
 744         if (n == 0)
 745           {
 746           printf("%sxpected EOF read from client\n",
 747             (strncmp(ss, "*eof", 4) == 0)? "E" : "Une");
 748           s = s->next;
 749           goto END_OFF;
 750           }
 751         if (offset != 2)
 752           while (read(dup_accept_socket, &c, 1) == 1 && c != '\n') ;
 753         alarm(0);
 754         n += offset;
 755
 756         printit(CS buffer, n);
 757
 758         if (data) do
 759           {
 760           n = (read(dup_accept_socket, &c, 1) == 1 && c == '.');
 761           if (content_length.in_use) content_length.left--;
 762           while (c != '\n' && read(dup_accept_socket, &c, 1) == 1)
 763             if (content_length.in_use) content_length.left--;
 764           } while (!n);
 765         else if (memcmp(ss, buffer, n) != 0)
 766           {
 767           printf("Comparison failed - bailing out\nExpected: ");
 768           printit(ss, n);
 769           break;
 770           }
 771         }
 772       else
 773         {
 774         for (;;)
 775           {
 776           int n;
 777           alarm(timeout);
 778           if (fgets(CS buffer+offset, sizeof(buffer)-offset, in) == NULL)
 779             {
 780             printf("%sxpected EOF read from client\n",
 781               (strncmp(ss, "*eof", 4) == 0)? "E" : "Une");
 782             s = s->next;
 783             goto END_OFF;
 784             }
 785           alarm(0);
 786           n = strlen(CS buffer);
 787           if (content_length.in_use) content_length.left -= (n - offset);
 788           while (n > 0 && isspace(buffer[n-1])) n--;
 789           buffer[n] = 0;
 790           printf("%s\n", buffer);
 791           if (!data || strcmp(CS buffer, ".") == 0) break;
 792           }
 793
 794         if (strncmp(ss, CS buffer, (int)strlen(ss)) != 0)
 795           {
 796           printf("Comparison failed - bailing out\n");
 797           printf("Expected: %s\n", ss);
 798           break;
 799           }
 800         }
 801
 802         if (sscanf(CCS buffer, "<Content-length: %d", &content_length.left))
 803           content_length.in_use = TRUE;
 804         if (content_length.in_use && content_length.left <= 0)
 805           shutdown(dup_accept_socket, SHUT_RD);
 806       }
 807     }
 808
 809   END_OFF:
 810   fclose(in);
 811   fclose(out);
 812   }
 813
 814 if (s == NULL) printf("End of script\n");
 815
 816 if (sockname) unlink(sockname);
 817 exit(0);
 818 }
 819
 820 /* End of server.c */