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