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