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