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