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