CVSing the test suite.
[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 */