diff options
| author | Philip Hazel <ph10@hermes.cam.ac.uk> | 2006-02-06 16:22:56 +0000 |
|---|---|---|
| committer | Philip Hazel <ph10@hermes.cam.ac.uk> | 2006-02-06 16:22:56 +0000 |
| commit | c55a77db55ebf46a399f136eeb3a928b1e862772 (patch) | |
| tree | c732f478642b0066b751b1034e195a200b43f5c2 | |
| parent | 151b83f867487080e8f0e5cd6179e857dc6b3ccb (diff) | |
CVSing the test suite.
| -rw-r--r-- | test/dnszones-src/db.ip4.10 | 19 | ||||
| -rw-r--r-- | test/dnszones-src/db.ip4.127 | 10 | ||||
| -rw-r--r-- | test/dnszones-src/db.ip4.V4NET | 60 | ||||
| -rw-r--r-- | test/dnszones-src/db.ip6.0 | 11 | ||||
| -rw-r--r-- | test/dnszones-src/db.ip6.V6NET | 12 | ||||
| -rw-r--r-- | test/dnszones-src/db.test.ex | 360 | ||||
| -rw-r--r-- | test/dnszones-src/qualify.test.ex | 5 | ||||
| -rw-r--r-- | test/src/cf.c | 715 | ||||
| -rw-r--r-- | test/src/checkaccess.c | 41 | ||||
| -rw-r--r-- | test/src/client.c | 898 | ||||
| -rw-r--r-- | test/src/fakens.c | 588 | ||||
| -rw-r--r-- | test/src/fd.c | 104 | ||||
| -rw-r--r-- | test/src/iefbr14.c | 11 | ||||
| -rw-r--r-- | test/src/loaded.c | 42 | ||||
| -rw-r--r-- | test/src/mtpscript.c | 169 | ||||
| -rw-r--r-- | test/src/server.c | 612 | ||||
| -rw-r--r-- | test/src/showids.c | 26 |
17 files changed, 3683 insertions, 0 deletions
diff --git a/test/dnszones-src/db.ip4.10 b/test/dnszones-src/db.ip4.10 new file mode 100644 index 000000000..cac14fc07 --- /dev/null +++ b/test/dnszones-src/db.ip4.10 @@ -0,0 +1,19 @@ +; $Cambridge: exim/test/dnszones-src/db.ip4.10,v 1.1 2006/02/06 16:22:56 ph10 Exp $ + +; This is a testing reverse zone file for use when testing DNS handling in +; Exim. This is a fake zone of no real use - hence no SOA record. The zone name +; is 10.in-addr.arpa. This file is passed through the substitution mechanism +; before being used by the fakens auxiliary program, though in fact there is +; nothing to substitute. + +; This zone exists to handle reverse lookups for the host with a huge number of +; IP addresses that get manufactured by the fake_gethostbyname() function in +; Exim. They are hard-wired to use the 10.250.0.0/16 network. Apart from that +; one use, the test suite shouldn't be using that network, so everything else +; is passed on to res_search(). The next line triggers this action. + +PASS ON NOT FOUND + +*.250 PTR manyhome.test.ex. + +; End diff --git a/test/dnszones-src/db.ip4.127 b/test/dnszones-src/db.ip4.127 new file mode 100644 index 000000000..150107415 --- /dev/null +++ b/test/dnszones-src/db.ip4.127 @@ -0,0 +1,10 @@ +; $Cambridge: exim/test/dnszones-src/db.ip4.127,v 1.1 2006/02/06 16:22:56 ph10 Exp $ + +; This is a testing reverse zone file for use when testing DNS handling in +; Exim. This is a fake zone of no real use - hence no SOA record. The zone name +; is 127.in-addr.arpa. This file is passed through the substitution mechanism +; before being used by the fakens auxiliary program. + +1.0.0.127.in-addr.arpa. PTR localhost. + +; End diff --git a/test/dnszones-src/db.ip4.V4NET b/test/dnszones-src/db.ip4.V4NET new file mode 100644 index 000000000..b7419f561 --- /dev/null +++ b/test/dnszones-src/db.ip4.V4NET @@ -0,0 +1,60 @@ +; $Cambridge: exim/test/dnszones-src/db.ip4.V4NET,v 1.1 2006/02/06 16:22:56 ph10 Exp $ + +; This is a testing reverse zone file for use when testing DNS handling in +; Exim. This is a fake zone of no real use - hence no SOA record. The zone name +; is determined by the V4NET substitution. This file is passed through the +; substitution mechanism before being used by the fakens auxiliary program. + +1.0.0 PTR ten-1.test.ex. +2.0.0 PTR ten-2.test.ex. +3.0.0 PTR ten-3-alias.test.ex. +3.0.0 PTR ten-3.test.ex. +4.0.0 PTR ten-4.test.ex. +5.0.0 PTR ten-5-6.test.ex. +6.0.0 PTR ten-5-6.test.ex. + +; V4NET.0.0.97 is deliberately not reverse registered + +98.0.0 PTR noforward.test.ex. +99.0.0 PTR ten-99.TEST.EX. + +; V4NET.11.12.13 (black-1) is deliberately not reverse registered + +14.12.11 PTR black-2.test.ex. + +10.10.10 PTR myhost.test.ex. + +5.4.12 PTR other1.test.ex. +1.3.12 PTR other2.test.ex. +2.3.12 PTR other2.test.ex. + +1.0.99 PTR other99.test.ex. + +; The first of these deliberately points back to a different name +; with a different address - that of the second one. + +99.99.99 PTR badB.test.ex. +98.99.99 PTR badB.test.ex. + +; This host has multiple names with several components, for +; testing negative wildcard matching + +97.99.99 PTR x.gov.uk.test.ex. +97.99.99 PTR x.co.uk.test.ex. + +; This points to a name that will give `try again' when looked +; up from within the test harness. + +96.99.99 PTR x.test.again.dns. + +; This IP number points back to a legitimate host, but also to a name that +; isn't forward registered + +90.99.99 PTR oneback.test.ex. +90.99.99 PTR host1.masq.test.ex. + +; This is a duff registration for testing + +255.255.255 PTR . + +; End diff --git a/test/dnszones-src/db.ip6.0 b/test/dnszones-src/db.ip6.0 new file mode 100644 index 000000000..b626611fa --- /dev/null +++ b/test/dnszones-src/db.ip6.0 @@ -0,0 +1,11 @@ +; $Cambridge: exim/test/dnszones-src/db.ip6.0,v 1.1 2006/02/06 16:22:56 ph10 Exp $ + +; This is a testing reverse zone file for use when testing DNS handling in +; Exim. This is a fake zone of no real use - hence no SOA record. The zone name +; is 0.0.0.0.ip6.arpa. This file is passed through the substitution mechanism +; before being used by the fakens auxiliary program, though in fact there is +; nothing to substitute. + +1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0 PTR localhost. + +; End diff --git a/test/dnszones-src/db.ip6.V6NET b/test/dnszones-src/db.ip6.V6NET new file mode 100644 index 000000000..0db200ea7 --- /dev/null +++ b/test/dnszones-src/db.ip6.V6NET @@ -0,0 +1,12 @@ +; $Cambridge: exim/test/dnszones-src/db.ip6.V6NET,v 1.1 2006/02/06 16:22:56 ph10 Exp $ + +; This is a testing reverse zone file for use when testing DNS handling in +; Exim. This is a fake zone of no real use - hence no SOA record. The zone +; name is determined by the V6NET substitution. This file is passed through +; the substitution mechanism before being used by the fakens auxiliary program, +; though in fact there is nothing to substitute. + +2.6.0.a.6.8.e.f.f.f.0.2.0.0.a.0.1.0.0.0.2.1.0.0.0.0.0.0 PTR testptr-arpa.ipv6.test.ex. +d.0.0.0.c.b.a.0.8.0.0.0.7.0.0.0.6.0.0.0.5.0.0.0.4.3.2.1 PTR test3.ipv6.test.ex. + +; End diff --git a/test/dnszones-src/db.test.ex b/test/dnszones-src/db.test.ex new file mode 100644 index 000000000..2e2865eb4 --- /dev/null +++ b/test/dnszones-src/db.test.ex @@ -0,0 +1,360 @@ +; $Cambridge: exim/test/dnszones-src/db.test.ex,v 1.1 2006/02/06 16:22:56 ph10 Exp $ + +; This is a testing zone file for use when testing DNS handling in Exim. This +; is a fake zone of no real use - hence no SOA record. The zone name is +; test.ex. This file is passed through the substitution mechanism before being +; used by the fakens auxiliary program. This inserts the actual IP addresses +; of the local host into the zone. + +; NOTE (1): apart from ::1, IPv6 addresses must always have 8 components. Do +; not abbreviate them by using the :: feature. Leading zeros in components may, +; however, be omitted. + +; NOTE (2): the fakens program is very simple and assumes that the buffer into +; which is puts the response is always going to be big enough. In other words, +; the expectation is for just a few RRs for each query. + +; NOTE (3): the top-level networks for testing addresses are parameterized by +; the use of V4NET and V6NET. These networks should be such that no real +; host ever uses them. + +test.ex. NS exim.test.ex. + +test.ex. TXT "A TXT record for test.ex." + +cname CNAME test.ex. + +ptr PTR data.for.ptr.test.ex. + +; Standard localhost handling + +localhost A 127.0.0.1 +localhost AAAA ::1 + +; This name exists only if qualified; it is never automatically qualified + +dontqualify A V4NET.255.255.254 + +; A host with upper case letters in its canonical name + +UpperCase A 127.0.0.1 + +; A host with UTF-8 characters in its name + +mx.π A V4NET.255.255.255 + +; A non-standard name for localhost + +thishost A 127.0.0.1 + +; Another host with both A and AAAA records + +46 A V4NET.0.0.4 + AAAA V6NET:ffff:836f:0a00:000a:0800:200a:c031 + +; And another + +46b A V4NET.0.0.5 + AAAA V6NET:ffff:836f:0a00:000a:0800:200a:c033 + +; A working IPv4 address and a non-working IPv6 address, with different +; names so they can have different MX values + +46c AAAA V6NET:ffff:836f:0a00:000a:0800:200a:c033 +46d A HOSTIPV4 + +; A host with just a non-local IPv6 address + +v6 AAAA V6NET:ffff:836f:0a00:000a:0800:200a:c032 + +; Alias A and CNAME records for the local host, under the name "eximtesthost" + +eximtesthost A HOSTIPV4 +alias-eximtesthost CNAME eximtesthost.test.ex. + +; A bad CNAME + +badcname CNAME rhubarb.test.ex. + +; Test a name containing an underscore + +a_b A 99.99.99.99 + +; The reverse registration for this name is an empty string + +empty A V4NET.255.255.255 + +; Some IPv6 stuff + +eximtesthost.ipv6 AAAA HOSTIPV6 +test2.ipv6 AAAA V6NET:2101:12:1:a00:20ff:fe86:a062 +test3.ipv6 AAAA V6NET:1234:5:6:7:8:abc:0d + +; A case of forward and backward pointers disagreeing + +badA A V4NET.99.99.99 +badB A V4NET.99.99.98 + +; A host with multiple names in different (sub) domains +; These are intended to be within test.ex - absence of final dots is deliberate + +x.gov.uk A V4NET.99.99.97 +x.co.uk A V4NET.99.99.97 + +; A host, the reverse lookup of whose IP address gives this name plus another +; that does not forward resolve to the same address + +oneback A V4NET.99.99.90 +host1.masq A V4NET.90.90.90 + +; Fake hosts are registered in the V4NET.0.0.0 subnet. In the past, the +; 10.0.0.0/8 network was used; hence the names of the hosts. + +ten-1 A V4NET.0.0.1 +ten-2 A V4NET.0.0.2 +ten-3 A V4NET.0.0.3 +ten-3-alias A V4NET.0.0.3 +ten-3xtra A V4NET.0.0.3 +ten-4 A V4NET.0.0.4 +ten-5 A V4NET.0.0.5 +ten-6 A V4NET.0.0.6 +ten-5-6 A V4NET.0.0.5 + A V4NET.0.0.6 + +ten-99 A V4NET.0.0.99 + +black-1 A V4NET.11.12.13 +black-2 A V4NET.11.12.14 + +myhost A V4NET.10.10.10 +myhost2 A V4NET.10.10.10 + +other1 A V4NET.12.4.5 +other2 A V4NET.12.3.1 + A V4NET.12.3.2 + +other99 A V4NET.99.0.1 + +testsub.sub A V4NET.99.0.3 + +; This one's real name really is recurse.test.ex.test.ex. It is done like +; this for testing host widening, without getting tangled up in qualify issues. + +recurse.test.ex A V4NET.99.0.2 + +; -------- Testing RBL records ------- + +; V4NET.11.12.13 is deliberately not reverse-registered + +13.12.11.V4NET.rbl A 127.0.0.2 + TXT "This is a test blacklisting message" +14.12.11.V4NET.rbl A 127.0.0.2 + TXT "This is a test blacklisting message" +15.12.11.V4NET.rbl A 127.0.0.2 + TXT "This is a very long blacklisting message, continuing for ages and ages and certainly being longer than 128 characters which was a previous limit on the length that Exim was prepared to handle." + +14.12.11.V4NET.rbl2 A 127.0.0.2 + TXT "This is a test blacklisting2 message" +16.12.11.V4NET.rbl2 A 127.0.0.2 + TXT "This is a test blacklisting2 message" + +14.12.11.V4NET.rbl3 A 127.0.0.2 + TXT "This is a test blacklisting3 message" +15.12.11.V4NET.rbl3 A 127.0.0.3 + TXT "This is a very long blacklisting message, continuing for ages and ages and certainly being longer than 128 characters which was a previous limit on the length that Exim was prepared to handle." + +20.12.11.V4NET.rbl4 A 127.0.0.6 +21.12.11.V4NET.rbl4 A 127.0.0.7 + +1.13.13.V4NET.rbl CNAME non-exist.test.ex. +2.13.13.V4NET.rbl A 127.0.0.1 + A 127.0.0.2 + +; -------- Testing MX records -------- + +mxcased MX 5 ten-99.TEST.EX. + +; Points to a host with both A and AAAA + +mx46 MX 46 46.test.ex. + +; Points to two hosts with both kinds of address, equal precedence + +mx4646 MX 46 46.test.ex. + MX 46 46b.test.ex. + +; Ditto, with a third IPv6 host + +mx46466 MX 46 46.test.ex. + MX 46 46b.test.ex. + MX 46 v6.test.ex. + +; Points to a host with a working IPv4 and a non-working IPv6 record + +mx46cd MX 10 46c.test.ex. + MX 11 46d.test.ex. + +; Two equal precedence pointing to a v4 and a v6 host + +mx246 MX 10 v6.test.ex. + MX 10 ten-1.test.ex. + +; Lowest-numbered points to local host + +mxt1 MX 5 eximtesthost.test.ex. + +; Points only to non-existent hosts + +mxt2 MX 5 not-exist.test.ex. + +; Points to some non-existent hosts; +; Lowest numbered existing points to local host + +mxt3 MX 5 not-exist.test.ex. + MX 6 eximtesthost.test.ex. + +; Points to some non-existent hosts; +; Lowest numbered existing points to non-local host + +mxt3r MX 5 not-exist.test.ex. + MX 6 exim.org. + +; Points to an alias + +mxt4 MX 5 alias-eximtesthost.test.ex. + +; Various combinations of precedence and local host + +mxt5 MX 5 eximtesthost.test.ex. + MX 5 ten-1.test.ex. + +mxt6 MX 5 ten-1.test.ex. + MX 6 eximtesthost.test.ex. + MX 6 ten-2.test.ex. + +mxt7 MX 5 ten-2.test.ex. + MX 6 ten-3.test.ex. + MX 7 eximtesthost.test.ex. + MX 8 ten-1.test.ex. + +mxt8 MX 5 ten-2.test.ex. + MX 6 ten-3.test.ex. + MX 7 eximtesthost.test.ex. + MX 7 ten-4.test.ex. + MX 8 ten-1.test.ex. + +; Same host appearing twice; make some variants in different orders to +; simulate a real nameserver and its round robinning + +mxt9 MX 5 ten-1.test.ex. + MX 6 ten-2.test.ex. + MX 7 ten-3.test.ex. + MX 8 ten-1.test.ex. + +mxt9a MX 6 ten-2.test.ex. + MX 7 ten-3.test.ex. + MX 8 ten-1.test.ex. + MX 5 ten-1.test.ex. + +mxt9b MX 7 ten-3.test.ex. + MX 8 ten-1.test.ex. + MX 5 ten-1.test.ex. + MX 6 ten-2.test.ex. + +; MX pointing to IP address + +mxt10 MX 5 V4NET.0.0.1. + +; Several MXs pointing to local host + +mxt11 MX 5 localhost.test.ex. + MX 6 localhost.test.ex. + +mxt11a MX 5 localhost.test.ex. + MX 6 ten-1.test.ex. + +mxt12 MX 5 local1.test.ex. + MX 6 local2.test.ex. + +local1 A 127.0.0.2 +local2 A 127.0.0.2 + +; Some more + +mxt13 MX 4 other1.test.ex. + MX 5 other2.test.ex. + +; Different hosts with same IP addresses in the list + +mxt14 MX 4 ten-5-6.test.ex. + MX 5 ten-5.test.ex. + MX 6 ten-6.test.ex. + +; Large number of IP addresses at one MX value, and then some +; at another, to check that hosts_max_try tries the MX different +; values if it can. + +mxt99 MX 1 ten-1.test.ex. + MX 1 ten-2.test.ex. + MX 1 ten-3.test.ex. + MX 1 ten-4.test.ex. + MX 1 ten-5.test.ex. + MX 1 ten-6.test.ex. + MX 3 black-1.test.ex. + MX 3 black-2.test.ex. + +; Special case test for @mx_any (to doublecheck a reported Exim 3 bug isn't +; in Exim 4). The MX points to two names, each with multiple addresses. The +; very last address is the local host. When Exim is testing, it will sort +; these addresses into ascending order. + +mxt98 MX 1 98-1.test.ex. + MX 2 98-2.test.ex. + +98-1 A V4NET.1.2.3 + A V4NET.4.5.6 + +98-2 A V4NET.7.8.9 + A HOSTIPV4 + +; IP addresses with the same MX value + +mxt97 MX 1 ten-1.test.ex. + MX 1 ten-2.test.ex. + MX 1 ten-3.test.ex. + MX 1 ten-4.test.ex. + +; MX pointing to a single-component name that exists if qualified, but not +; if not. We use the special name dontqualify to stop the fake resolver +; qualifying it. + +mxt1c MX 1 dontqualify. + +; MX with UTF-8 characters in its name + +π MX 0 mx.π.test.ex. + +; -------- Testing SRV records -------- + +_smtp._tcp.srv01 SRV 0 0 25 ten-1.test.ex. + +_smtp._tcp.srv02 SRV 1 3 99 ten-1.test.ex. + SRV 1 1 99 ten-2.test.ex. + SRV 3 0 66 ten-3.test.ex. + +_smtp._tcp.nosmtp SRV 0 0 0 . + +_smtp2._tcp.srv03 SRV 0 0 88 ten-4.test.ex. + +_smtp._tcp.srv27 SRV 0 0 PORT_S localhost + + +; -------- With some for CSA testing plus their A records ------- + +_client._smtp.csa1 SRV 1 2 0 csa1.test.ex. +_client._smtp.csa2 SRV 1 1 0 csa2.test.ex. + +csa1 A V4NET.9.8.7 +csa2 A V4NET.9.8.8 + +; End diff --git a/test/dnszones-src/qualify.test.ex b/test/dnszones-src/qualify.test.ex new file mode 100644 index 000000000..e8c9f9358 --- /dev/null +++ b/test/dnszones-src/qualify.test.ex @@ -0,0 +1,5 @@ +$Cambridge: exim/test/dnszones-src/qualify.test.ex,v 1.1 2006/02/06 16:22:56 ph10 Exp $ + +The contents of this file are not used. Its name is used as a way of specifying +the domain that is to be used to qualify unqualified domain names when given to +the fake DNS resolver. diff --git a/test/src/cf.c b/test/src/cf.c new file mode 100644 index 000000000..4dc3dc00f --- /dev/null +++ b/test/src/cf.c @@ -0,0 +1,715 @@ +/* $Cambridge: exim/test/src/cf.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/************************************************ +* PH-Compare * +************************************************/ + +/* A program to compare two files line by line. + +History: + +It was originally written in C, but the C under +Panos is still a shambles (1986). Translated therefore +to BCPL -- this explains some of the odd style. + +Modified to run on Archimedes, August 1987. +Modified to run under MSDOS, March 1989. +Modified to run under CINTERP interpreter, July 1989. +Modified to run under Unix, October 1989. + +Translated back into C, March 1990! */ + +/* Copyright (c) 1986, 1987, 1989, 1990, 1994, 2001 by Philip Hazel */ + +/* Previously modified: October 1994*/ +/* Last modified: September 2001 - a long-lived bug fixed! */ + + +#include <stdio.h> +#include <errno.h> + +#ifdef __STDC__ +#include <string.h> +#include <stdlib.h> +#endif + +/* ----- parameters ----- */ + +#define version 8 +#define defaultstore 100000 /* default recovery buffer size */ +#define minstore 500 /* minimum recovery buffer size */ + +/* ----- misc defines ----- */ + +#define FALSE 0 +#define TRUE 1 + +#ifdef __STDC__ +#define pvoid void +#else +#define pvoid +#endif + +#define EqString(s, t) (strcmp(s, t) == 0) + +/* ----- line structure ----- */ + +typedef struct line { + struct line *next; + int number; + char text[999999]; +} line; + + +/* ----- global variables ----- */ + +FILE *f_one; /* files */ +FILE *f_two; +FILE *f_out; + +int lines_one = 0; /* line counts */ +int lines_two = 0; +int return_code = 0; +int eof_one = FALSE; /* eof flags */ +int eof_two = FALSE; +int exact = FALSE; /* TRUE => no strip spaces */ +int echo = TRUE; /* TRUE => show mismatched lines */ +int sync_count = 3; /* resync count */ +int storesize = defaultstore; /* size of each buffer */ + +char *name_one = NULL; /* file names */ +char *name_two = NULL; +char *to_name = NULL; + +char *bufbase_one; /* start buffer */ +char *bufbase_two; +char *bufnext_one; /* next free byte */ +char *bufnext_two; +char *buftop_one; /* end buffer */ +char *buftop_two; + +line *rootline_one; /* mis-match point */ +line *rootline_two; +line *lastline_one; /* last in store */ +line *lastline_two; +line *pline_one; /* working line */ +line *pline_two; + + +/************************************************* +* Help Information * +*************************************************/ + +void givehelp(pvoid) +{ +printf("PH's CMP v%d\n", version); +printf("Keywords:\n"); +printf(" <file> ) files to compare\n"); +printf(" <file> ) no keywords used\n"); +printf("-to <file> output destination\n"); +printf("-exact include trailing spaces & match tabs\n"); +printf("-noecho don't echo differences (just give line numbers)\n"); +printf("-s, -sync <n> set re-sync count, default 3\n"); +printf("-buffer <n> buffer size (for each file) default 100000\n"); +printf("-id give program version id\n"); +printf("-h, -help give this help\n"); +printf("\nExamples:\n"); +printf("cmp old.f77 new.f77\n"); +printf("cmp first second -noecho -sync 1\n"); +printf("cmp large1 large2 -buffer 200000 -noecho -to diffs\n"); +} + + + +/************************************************ +* Errors -- all serious * +************************************************/ + +void moan(code, text) +int code; +char *text; +{ +fprintf(stderr, "\n** "); +switch (code) + { + case 1: + fprintf(stderr, "Unable to open file \"%s\"", text); + if (errno) + { + fprintf(stderr, " - "); + perror(NULL); + } + else fprintf(stderr, "\n"); + break; + + case 2: + fprintf(stderr, "Buffer overflow for file \"%s\"\n", text); + break; + + case 3: + fprintf(stderr, "Two file names must be given\n"); + break; + + default: + fprintf(stderr, "Unknown error %d\n", code); + break; + } + +fprintf(stderr, "** CMP abandoned\n"); +exit(99); +} + + + +/************************************************* +* Write line identification * +*************************************************/ + +void write_id(n1, n2, c, name, p1, p2) +int n1, n2, c; +char *name, *p1, *p2; +{ +if (n2 < 0) n2 = -n2; +n2 -= 1; +fprintf(f_out, "%cine", c); +if (n1 == n2) fprintf(f_out, " %d of \"%s\"%s", n1, name, p1); + else fprintf(f_out, "s %d-%d of \"%s\"%s", n1, n2, name, p2); +} + + +/************************************************* +* Write sequence of lines * +*************************************************/ + +void write_lines(s, t) +line *s, *t; +{ +while (s != t) + { + char *p = s->text; + while (*p != '\n') fputc(*p++, f_out); + fputc('\n', f_out); + s = s->next; + } +} + + + +/************************************************* +* Write separator rule * +*************************************************/ + +void rule(s, l) +int s, l; +{ +while (l-- > 0) fprintf(f_out, "%c", s); +fprintf(f_out, "\n"); +} + + + +/************************************************* +* Write message on re-sync or eof * +*************************************************/ + +void write_message(tline_one, tline_two) +line *tline_one, *tline_two; +{ +int s1 = rootline_one->number; +int t1 = tline_one->number; +int s2 = rootline_two->number; +int t2 = tline_two->number; +if (echo) rule('=', 15); + +if (s1 == t1) + { + write_id(s2, t2, 'L', name_two, " occurs ", " occur "); + if (s1 < 0) fprintf(f_out, "at the end"); + else fprintf(f_out, "before line %d", s1); + fprintf(f_out, " of \"%s\".\n", name_one); + if (echo) + { + rule('-', 10); + write_lines(rootline_two, tline_two); + } + } + +else if (s2 == t2) + { + write_id(s1, t1, 'L', name_one, " occurs ", " occur "); + if (s2 < 0) fprintf(f_out, "at the end"); + else fprintf(f_out, "before line %d", s2); + fprintf(f_out, " of \"%s\".\n", name_two); + if (echo) + { + rule('-', 10); + write_lines(rootline_one, tline_one); + } + } + +else if (t1 < 0 && t2 < 0) + { + fprintf(f_out, "From line %d of \"%s\" and line %d of \"%s\" ", + rootline_one->number, name_one, rootline_two->number, name_two); + fprintf(f_out, "the files are different.\n"); + if (echo) + { + rule('-', 10); + if (-t1-s1 < 21) write_lines(rootline_one, tline_one); + else fprintf(f_out, "... <more than 20 lines> ...\n"); + rule('-', 10); + if (-t2-s2 < 21) write_lines(rootline_two, tline_two); + else fprintf(f_out, "... <more than 20 lines> ...\n"); + } + } + +else + { + write_id(s1, t1, 'L', name_one, " does ", " do "); + fprintf(f_out, "not match "); + write_id(s2, t2, 'l', name_two, ".\n", ".\n"); + if (echo) + { + rule('-', 10); + write_lines(rootline_one, tline_one); + rule('-', 10); + write_lines(rootline_two, tline_two); + } + } +} + + + + +/************************************************* +* Advance to next line in store * +*************************************************/ + +/* A separate procedure exists for each file, for +simplicity and efficiency. */ + +int nextline_one(pvoid) +{ +if (pline_one == NULL || pline_one->next == NULL) return FALSE; +pline_one = pline_one->next; +return TRUE; +} + +int nextline_two(pvoid) +{ +if (pline_two == NULL || pline_two->next == NULL) return FALSE; +pline_two = pline_two->next; +return TRUE; +} + + +/************************************************* +* Read a line into store * +*************************************************/ + +/* A separate procedure exists for each file, for +simplicity and efficiency. */ + +void readline_one(pvoid) +{ +int count = 0; +int c = fgetc(f_one); +line *nextline = (line *)bufnext_one; + +bufnext_one = nextline->text; +if (bufnext_one >= buftop_one) moan(2, name_one); + +nextline->next = NULL; + +lines_one ++; +if (c == EOF) + { + eof_one = TRUE; + nextline->number = -lines_one; + } +else + { + nextline->number = lines_one; + for (;;) + { + if (c == EOF) c = '\n'; + if (c == '\n') + { + if (!exact) + while (bufnext_one > nextline->text) + { if (bufnext_one[-1] == ' ') bufnext_one--; else break; } + *(bufnext_one++) = '\n'; + if (bufnext_one >= buftop_one) moan(2, name_one); + break; + } + if (c == '\t' && !exact) + do { *(bufnext_one++) = ' '; count++; } while ((count & 7) != 0); + else { *(bufnext_one++) = c; count++; } + if (bufnext_one >= buftop_one) moan(2, name_one); + c = fgetc(f_one); + } + } + +if (lastline_one != NULL) lastline_one->next = nextline; +lastline_one = nextline; +pline_one = nextline; + +bufnext_one = (char *) (((int)bufnext_one+3) & (-4)); +} + + + +void readline_two(pvoid) +{ +int count = 0; +int c = fgetc(f_two); +line *nextline = (line *)bufnext_two; + +bufnext_two = nextline->text; +if (bufnext_two >= buftop_two) moan(2, name_two); + +nextline->next = NULL; + +lines_two ++; +if (c == EOF) + { + eof_two = TRUE; + nextline->number = -lines_two; + } +else + { + nextline->number = lines_two; + for (;;) + { + if (c == EOF) c = '\n'; + if (c == '\n') + { + if (!exact) + while (bufnext_two > nextline->text) + { if (bufnext_two[-1] == ' ') bufnext_two--; else break; } + *(bufnext_two++) = '\n'; + if (bufnext_two >= buftop_two) moan(2, name_two); + break; + } + if (c == '\t' && !exact) + do { *(bufnext_two++) = ' '; count++; } while ((count & 7) != 0); + else { *(bufnext_two++) = c; count++; } + if (bufnext_two >= buftop_two) moan(2, name_two); + c = fgetc(f_two); + } + } + +if (lastline_two != NULL) lastline_two->next = nextline; +lastline_two = nextline; +pline_two = nextline; + +bufnext_two = (char *) (((int)bufnext_two+3) & (-4)); +} + + + +/************************************************** +* Compare two lines * +**************************************************/ + +int compare_lines(a, b) +line *a, *b; +{ +int n1 = a->number; +int n2 = b->number; +char *s = a->text; +char *t = b->text; + +if (n1 < 0 && n2 < 0) return TRUE; +if (n1 < 0 || n2 < 0) return FALSE; + +while (*s == *t) + { + if (*s == '\n') return TRUE; + s++; t++; + } + +return FALSE; +} + + +/************************************************* +* Re-synchronizing code * +*************************************************/ + +int resync(pvoid) +{ +int i; +int matched = TRUE; +line *tline_one = pline_one; +line *tline_two = pline_two; + +if (eof_one || eof_two) matched = FALSE; else + { + for (i = 1; i < sync_count; i++) + { + if (!nextline_one()) readline_one(); + if (!nextline_two()) readline_two(); + if (!compare_lines(pline_one, pline_two)) { matched = FALSE; break; } + if (eof_one || eof_two) { matched = FALSE; break; } + } + } + +if (matched) write_message(tline_one, tline_two); else + { + pline_one = tline_one; + pline_two = tline_two; + } + +return matched; +} + + + +/************************************************* +* Main compare code * +*************************************************/ + +void compare(pvoid) +{ +int matched = TRUE; + +/* Big main loop - exit by return or unmatched at eof */ + +while (matched) + { + /* First minor loop, while in step */ + + while (matched && !eof_one && !eof_two) + { + /* Advance or read next lines */ + + if (!nextline_one()) + { + bufnext_one = bufbase_one; + lastline_one = NULL; + readline_one(); + } + + if (!nextline_two()) + { + bufnext_two = bufbase_two; + lastline_two = NULL; + readline_two(); + } + + /* Compare and check for end of file */ + + matched = compare_lines(pline_one, pline_two); + + } /* End first minor loop */ + + if (matched) return; /* successful end of file */ + + /* There has been a mis-match */ + + return_code++; + rootline_one = pline_one; /* Fail point */ + rootline_two = pline_two; + + /* Second minor loop, trying to regain sync */ + + while (!eof_one || !eof_two) + { + /* Advance one and scan all of two */ + + if (!eof_one) + { + line *zline = pline_two; + if (!nextline_one()) readline_one(); + pline_two = rootline_two; + for (;;) + { + if (compare_lines(pline_one, pline_two)) + { + matched = resync(); + if (matched) break; + } + if (pline_two == zline) break; + pline_two = pline_two->next; + } + if (matched) break; + } + + /* Advance two and scan all of one */ + + if (!eof_two) + { + line *zline = pline_one; + if (!nextline_two()) readline_two(); + pline_one = rootline_one; + for (;;) + { + if (compare_lines(pline_one, pline_two)) + { + matched = resync(); + if (matched) break; + } + if (pline_one == zline) break; + pline_one = pline_one->next; + } + if (matched) break; + } + + } /* End second minor loop */ + + } /* End of major loop */ + +write_message(lastline_one, lastline_two); +} + + + + +/************************************************* +* Entry Point * +*************************************************/ + +int main(argc, argv) +int argc; +char **argv; +{ +int argp = 1; +int arg_id = FALSE; +int arg_help = FALSE; + +f_out = stdout; + +/* Scan argument strings */ + +while (argp < argc) + { + char *arg = argv[argp]; + char **lv_name = (name_one == NULL)? &name_one:&name_two; /* default for positional */ + int *lv_value = NULL; + int value = TRUE; + + if (arg[0] == '-') + { /* keyed argument */ + if (EqString(arg,"-help") || EqString(arg, "-h")) + { arg_help = TRUE; value = FALSE; } + else if (EqString(arg, "-id")) + { arg_id = TRUE; value = FALSE; } + else if (EqString(arg, "-exact")) + { exact = TRUE; value = FALSE; } + else if (EqString(arg, "-noecho")) + { echo = FALSE; value = FALSE; } + else if (EqString(arg, "-to")) lv_name = &to_name; + else if (EqString(arg, "-sync") || EqString(arg, "-s")) + lv_value = &sync_count; + else if (EqString(arg, "-buffer")) lv_value = &storesize; + else { printf("Unknown keyword %s\n", arg); exit(99); } + + if (++argp >= argc && value) + { printf("Value for keyword %s missing\n", arg); exit(99); } + } + + /* Deal with keys that take values */ + + if (value) + { + if (lv_value == &sync_count || lv_value == &storesize) + { + int ch; + int i = 0; + char *argval = argv[argp++]; + *lv_value = 0; + while ((ch = argval[i++]) != 0) + { + if ('0' <= ch && ch <= '9') *lv_value = 10*(*lv_value) + ch - '0'; else + { + printf("Number expected after \"%s\" but \"%s\" read\n", + arg, argval); + exit(99); + } + } + } + + else if (*lv_name != NULL) + { + printf("Keyword expected but \"%s\" read", arg); + printf(" - use \"cmp -h\" for help\n"); + exit(99); + } + else *lv_name = argv[argp++]; + } + } + +/* Deal with help and id */ + +if (arg_id && !arg_help) + { + printf("PH's CMP v%d\n", version); + exit(0); + } + +if (arg_help) + { + givehelp(); + exit(0); + } + +/* Deal with file names */ + +if (name_one == NULL || name_two == NULL) moan(3, ""); + +if (to_name != NULL) + { + f_out = fopen(to_name, "w"); + if (f_out == NULL) moan(1, to_name); + } + +/* Further general initialization */ + +if (storesize < minstore) storesize = defaultstore; +f_one = fopen(name_one, "r"); +if (f_one == NULL) moan(1, name_one); +f_two = fopen(name_two, "r"); +if (f_two == NULL) moan(1, name_two); + +bufbase_one = (char *)malloc(storesize); +buftop_one = bufbase_one + storesize; +bufbase_two = (char *)malloc(storesize); +buftop_two = bufbase_two + storesize; + +/* Do the job */ + +compare(); + +/* Final messages */ + +if (return_code == 0) + fprintf(f_out, "\"%s\" and \"%s\" are identical.\n", name_one, name_two); +else + { + if (echo) rule('=', 15); + fprintf(f_out, "%d difference", return_code); + if (return_code != 1) fprintf(f_out, "s"); + fprintf(f_out, " found.\n"); + + lines_one -= 1; + fprintf(f_out, "\"%s\" contains %d line", name_one, lines_one); + if (lines_one != 1) fprintf(f_out, "s"); + + lines_two -= 1; + fprintf(f_out, "; \"%s\" contains %d line", name_two, lines_two); + if (lines_two != 1) fprintf(f_out, "s"); + fprintf(f_out, ".\n"); + } + +free(bufbase_one); +free(bufbase_two); + +fclose(f_one); +fclose(f_two); +if (f_out != stdout) fclose(f_out); + +return return_code; +} + +/* End of PH-Compare. */ diff --git a/test/src/checkaccess.c b/test/src/checkaccess.c new file mode 100644 index 000000000..926daa0fe --- /dev/null +++ b/test/src/checkaccess.c @@ -0,0 +1,41 @@ +/* $Cambridge: exim/test/src/checkaccess.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/* This is a baby program that is run as root from the runtest script. It is +passed the Exim uid and gid as arguments, and the name of a file in the +test-suite directory. It gives up all supplementary groups, changes to the +given uid/gid, and then tries to read the file. The yield is 0 if that is +successful, and non-zero otherwise (use different values to aid debugging). See +comments in the exim.c source file about the use of setgroups() for getting rid +of extraneous groups. */ + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <pwd.h> +#include <grp.h> + +#include <stdio.h> + + +int main(int argc, char **argv) +{ +int fd; +gid_t group_list[10]; +struct passwd *pw = getpwnam(argv[2]); +struct group *gr = getgrnam(argv[3]); + +if (pw == NULL) return 1; +if (gr == NULL) return 2; +if (setgroups(0, NULL) != 0 && setgroups(1, group_list) != 0) return 4; +if (setgid(gr->gr_gid) != 0) return 5; +if (setuid(pw->pw_uid) != 0) return 6; + +fd = open(argv[1], O_RDONLY); +if (fd < 0) return 7; + +close(fd); +return 0; +} + +/* End */ diff --git a/test/src/client.c b/test/src/client.c new file mode 100644 index 000000000..0a2159472 --- /dev/null +++ b/test/src/client.c @@ -0,0 +1,898 @@ +/* $Cambridge: exim/test/src/client.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/* A little hacked up program that makes a TCP/IP call and reads a script to +drive it, for testing Exim server code running as a daemon. It's got a bit +messy with the addition of support for either OpenSSL or GnuTLS. The code for +those was hacked out of Exim itself. */ + +/* ANSI C standard includes */ + +#include <ctype.h> +#include <signal.h> +#include <stdarg.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +/* Unix includes */ + +#include <errno.h> +#include <dirent.h> +#include <sys/types.h> + +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> + +#include <netdb.h> +#include <arpa/inet.h> +#include <sys/time.h> +#include <sys/resource.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <utime.h> + +#ifdef AF_INET6 +#define HAVE_IPV6 1 +#endif + +#ifndef S_ADDR_TYPE +#define S_ADDR_TYPE u_long +#endif + +typedef unsigned char uschar; + +#define CS (char *) +#define US (unsigned char *) + +#define FALSE 0 +#define TRUE 1 + + + +static int sigalrm_seen = 0; + + +/* TLS support can be optionally included, either for OpenSSL or GnuTLS. The +latter needs a whole pile of tables. */ + +#ifdef HAVE_OPENSSL +#define HAVE_TLS +#include <openssl/crypto.h> +#include <openssl/x509.h> +#include <openssl/pem.h> +#include <openssl/ssl.h> +#include <openssl/err.h> +#include <openssl/rand.h> +#endif + + +#ifdef HAVE_GNUTLS +#define HAVE_TLS +#include <gnutls/gnutls.h> +#include <gnutls/x509.h> + +#define DH_BITS 768 +#define RSA_BITS 512 + +/* Local static variables for GNUTLS */ + +static gnutls_rsa_params rsa_params = NULL; +static gnutls_dh_params dh_params = NULL; + +static gnutls_certificate_credentials_t x509_cred = NULL; +static gnutls_session tls_session = NULL; + +static int ssl_session_timeout = 200; + +/* Priorities for TLS algorithms to use. */ + +static const int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 }; + +static const int kx_priority[16] = { + GNUTLS_KX_RSA, + GNUTLS_KX_DHE_DSS, + GNUTLS_KX_DHE_RSA, + GNUTLS_KX_RSA_EXPORT, + 0 }; + +static int default_cipher_priority[16] = { + GNUTLS_CIPHER_AES_256_CBC, + GNUTLS_CIPHER_AES_128_CBC, + GNUTLS_CIPHER_3DES_CBC, + GNUTLS_CIPHER_ARCFOUR_128, + 0 }; + +static const int mac_priority[16] = { + GNUTLS_MAC_SHA, + GNUTLS_MAC_MD5, + 0 }; + +static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 }; +static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 }; + +#endif + + + + +/************************************************* +* SIGALRM handler - crash out * +*************************************************/ + +static void +sigalrm_handler_crash(int sig) +{ +sig = sig; /* Keep picky compilers happy */ +printf("\nClient timed out\n"); +exit(99); +} + + +/************************************************* +* SIGALRM handler - set flag * +*************************************************/ + +static void +sigalrm_handler_flag(int sig) +{ +sig = sig; /* Keep picky compilers happy */ +sigalrm_seen = 1; +} + + + +/****************************************************************************/ +/****************************************************************************/ + +#ifdef HAVE_OPENSSL +/************************************************* +* Start an OpenSSL TLS session * +*************************************************/ + +int tls_start(int sock, SSL **ssl, SSL_CTX *ctx) +{ +int rc; +static const char *sid_ctx = "exim"; + +RAND_load_file("client.c", -1); /* Not *very* random! */ + +*ssl = SSL_new (ctx); +SSL_set_session_id_context(*ssl, sid_ctx, strlen(sid_ctx)); +SSL_set_fd (*ssl, sock); +SSL_set_connect_state(*ssl); + +signal(SIGALRM, sigalrm_handler_flag); +sigalrm_seen = 0; +alarm(5); +rc = SSL_connect (*ssl); +alarm(0); + +if (sigalrm_seen) + { + printf("SSL_connect timed out\n"); + return 0; + } + +if (rc <= 0) + { + ERR_print_errors_fp(stdout); + return 0; + } + +printf("SSL connection using %s\n", SSL_get_cipher (*ssl)); +return 1; +} + + +/************************************************* +* SSL Information callback * +*************************************************/ + +static void +info_callback(SSL *s, int where, int ret) +{ +where = where; +ret = ret; +printf("SSL info: %s\n", SSL_state_string_long(s)); +} +#endif + + +/****************************************************************************/ +/****************************************************************************/ + + +#ifdef HAVE_GNUTLS +/************************************************* +* Handle GnuTLS error * +*************************************************/ + +/* Called from lots of places when errors occur before actually starting to do +the TLS handshake, that is, while the session is still in clear. + +Argument: + prefix prefix text + err a GnuTLS error number, or 0 if local error + +Returns: doesn't - it dies +*/ + +static void +gnutls_error(uschar *prefix, int err) +{ +fprintf(stderr, "GnuTLS connection error:%s", prefix); +if (err != 0) fprintf(stderr, " %s", gnutls_strerror(err)); +fprintf(stderr, "\n"); +exit(1); +} + + + +/************************************************* +* Setup up RSA and DH parameters * +*************************************************/ + +/* For the test suite, the parameters should always be available in the spool +directory. */ + +static void +init_rsa_dh(void) +{ +int fd; +int ret; +gnutls_datum m; +uschar filename[200]; +struct stat statbuf; + +/* Initialize the data structures for holding the parameters */ + +ret = gnutls_rsa_params_init(&rsa_params); +if (ret < 0) gnutls_error(US"init rsa_params", ret); + +ret = gnutls_dh_params_init(&dh_params); +if (ret < 0) gnutls_error(US"init dh_params", ret); + +/* Open the cache file for reading and if successful, read it and set up the +parameters. If we can't set up the RSA parameters, assume that we are dealing +with an old-style cache file that is in another format, and fall through to +compute new values. However, if we correctly get RSA parameters, a failure to +set up D-H parameters is treated as an error. */ + +fd = open("aux-fixed/gnutls-params", O_RDONLY, 0); +if (fd < 0) + { + fprintf(stderr, "Failed to open spool/gnutls-params: %s\n", strerror(errno)); + exit(1); + } + +if (fstat(fd, &statbuf) < 0) + { + (void)close(fd); + return gnutls_error(US"TLS cache stat failed", 0); + } + +m.size = statbuf.st_size; +m.data = malloc(m.size); +if (m.data == NULL) + return gnutls_error(US"memory allocation failed", 0); +if (read(fd, m.data, m.size) != m.size) + return gnutls_error(US"TLS cache read failed", 0); +(void)close(fd); + +ret = gnutls_rsa_params_import_pkcs1(rsa_params, &m, GNUTLS_X509_FMT_PEM); +if (ret < 0) return gnutls_error(US"RSA params import", ret); +ret = gnutls_dh_params_import_pkcs3(dh_params, &m, GNUTLS_X509_FMT_PEM); +if (ret < 0) return gnutls_error(US"DH params import", ret); +free(m.data); +} + + + + +/************************************************* +* Initialize for GnuTLS * +*************************************************/ + +/* +Arguments: + certificate certificate file + privatekey private key file +*/ + +static void +tls_init(uschar *certificate, uschar *privatekey) +{ +int rc; + +rc = gnutls_global_init(); +if (rc < 0) gnutls_error(US"gnutls_global_init", rc); + +/* Read RSA and D-H parameters from the cache file. */ + +init_rsa_dh(); + +/* Create the credentials structure */ + +rc = gnutls_certificate_allocate_credentials(&x509_cred); +if (rc < 0) gnutls_error(US"certificate_allocate_credentials", rc); + +/* Set the certificate and private keys */ + +if (certificate != NULL) + { + rc = gnutls_certificate_set_x509_key_file(x509_cred, CS certificate, + CS privatekey, GNUTLS_X509_FMT_PEM); + if (rc < 0) gnutls_error("gnutls_certificate", rc); + } + +/* Associate the parameters with the x509 credentials structure. */ + +gnutls_certificate_set_dh_params(x509_cred, dh_params); +gnutls_certificate_set_rsa_export_params(x509_cred, rsa_params); +} + + + +/************************************************* +* Initialize a single GNUTLS session * +*************************************************/ + +static gnutls_session +tls_session_init(void) +{ +gnutls_session session; + +gnutls_init(&session, GNUTLS_CLIENT); + +gnutls_cipher_set_priority(session, default_cipher_priority); +gnutls_compression_set_priority(session, comp_priority); +gnutls_kx_set_priority(session, kx_priority); +gnutls_protocol_set_priority(session, protocol_priority); +gnutls_mac_set_priority(session, mac_priority); + +gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred); + +gnutls_dh_set_prime_bits(session, DH_BITS); +gnutls_db_set_cache_expiration(session, ssl_session_timeout); + +return session; +} +#endif + + +/****************************************************************************/ +/****************************************************************************/ + + + + +/************************************************* +* Main Program * +*************************************************/ + +/* Usage: client + <IP address> + <port> + [<outgoing interface>] + [<cert file>] + [<key file>] +*/ + +int main(int argc, char **argv) +{ +struct sockaddr *s_ptr; +struct sockaddr_in s_in4; +char *interface = NULL; +char *address = NULL; +char *certfile = NULL; +char *keyfile = NULL; +int argi = 1; +int host_af, port, s_len, rc, sock, save_errno; +int timeout = 1; +int tls_active = 0; +int sent_starttls = 0; +int tls_on_connect = 0; + +#if HAVE_IPV6 +struct sockaddr_in6 s_in6; +#endif + +#ifdef HAVE_OPENSSL +SSL_CTX* ctx; +SSL* ssl; +#endif + +unsigned char outbuffer[10240]; +unsigned char inbuffer[10240]; +unsigned char *inptr = inbuffer; + +*inptr = 0; /* Buffer empty */ + +/* Options */ + +while (argc >= argi + 1 && argv[argi][0] == '-') + { + if (strcmp(argv[argi], "-tls-on-connect") == 0) + { + tls_on_connect = 1; + argi++; + } + else if (argv[argi][1] == 't' && isdigit(argv[argi][2])) + { + timeout = atoi(argv[argi]+1); + argi++; + } + else + { + printf("Unrecognized option %s\n", argv[argi]); + exit(1); + } + } + +/* Mandatory 1st arg is IP address */ + +if (argc < argi+1) + { + printf("No IP address given\n"); + exit(1); + } + +address = argv[argi++]; +host_af = (strchr(address, ':') != NULL)? AF_INET6 : AF_INET; + +/* Mandatory 2nd arg is port */ + +if (argc < argi+1) + { + printf("No port number given\n"); + exit(1); + } + +port = atoi(argv[argi++]); + +/* Optional next arg is interface */ + +if (argc > argi && + (isdigit((unsigned char)argv[argi][0]) || argv[argi][0] == ':')) + interface = argv[argi++]; + +/* Any more arguments are the name of a certificate file and key file */ + +if (argc > argi) certfile = argv[argi++]; +if (argc > argi) keyfile = argv[argi++]; + + +#if HAVE_IPV6 +/* For an IPv6 address, use an IPv6 sockaddr structure. */ + +if (host_af == AF_INET6) + { + s_ptr = (struct sockaddr *)&s_in6; + s_len = sizeof(s_in6); + } +else +#endif + +/* For an IPv4 address, use an IPv4 sockaddr structure, +even on an IPv6 system. */ + + { + s_ptr = (struct sockaddr *)&s_in4; + s_len = sizeof(s_in4); + } + +printf("Connecting to %s port %d ... ", address, port); + +sock = socket(host_af, SOCK_STREAM, 0); +if (sock < 0) + { + printf("socket creation failed: %s\n", strerror(errno)); + exit(1); + } + +/* Bind to a specific interface if requested. On an IPv6 system, this has +to be of the same family as the address we are calling. On an IPv4 system the +test is redundant, but it keeps the code tidier. */ + +if (interface != NULL) + { + int interface_af = (strchr(interface, ':') != NULL)? AF_INET6 : AF_INET; + + if (interface_af == host_af) + { + #if HAVE_IPV6 + + /* Set up for IPv6 binding */ + + if (host_af == AF_INET6) + { + memset(&s_in6, 0, sizeof(s_in6)); + s_in6.sin6_family = AF_INET6; + s_in6.sin6_port = 0; + if (inet_pton(AF_INET6, interface, &s_in6.sin6_addr) != 1) + { + printf("Unable to parse \"%s\"", interface); + exit(1); + } + } + else + #endif + + /* Set up for IPv4 binding */ + + { + memset(&s_in4, 0, sizeof(s_in4)); + s_in4.sin_family = AF_INET; + s_in4.sin_port = 0; + s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(interface); + } + + /* Bind */ + + if (bind(sock, s_ptr, s_len) < 0) + { + printf("Unable to bind outgoing SMTP call to %s: %s", + interface, strerror(errno)); + exit(1); + } + } + } + +/* Set up a remote IPv6 address */ + +#if HAVE_IPV6 +if (host_af == AF_INET6) + { + memset(&s_in6, 0, sizeof(s_in6)); + s_in6.sin6_family = AF_INET6; + s_in6.sin6_port = htons(port); + if (inet_pton(host_af, address, &s_in6.sin6_addr) != 1) + { + printf("Unable to parse \"%s\"", address); + exit(1); + } + } +else +#endif + +/* Set up a remote IPv4 address */ + + { + memset(&s_in4, 0, sizeof(s_in4)); + s_in4.sin_family = AF_INET; + s_in4.sin_port = htons(port); + s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(address); + } + +/* SIGALRM handler crashes out */ + +signal(SIGALRM, sigalrm_handler_crash); +alarm(timeout); +rc = connect(sock, s_ptr, s_len); +save_errno = errno; +alarm(0); + +/* A failure whose error code is "Interrupted system call" is in fact +an externally applied timeout if the signal handler has been run. */ + +if (rc < 0) + { + close(sock); + printf("failed: %s\n", strerror(save_errno)); + exit(1); + } + +printf("connected\n"); + + +/* --------------- Set up for OpenSSL --------------- */ + +#ifdef HAVE_OPENSSL +SSL_library_init(); +SSL_load_error_strings(); + +ctx = SSL_CTX_new(SSLv23_method()); +if (ctx == NULL) + { + printf ("SSL_CTX_new failed\n"); + exit(1); + } + +if (certfile != NULL) + { + if (!SSL_CTX_use_certificate_file(ctx, certfile, SSL_FILETYPE_PEM)) + { + printf("SSL_CTX_use_certificate_file failed\n"); + exit(1); + } + printf("Certificate file = %s\n", certfile); + } + +if (keyfile != NULL) + { + if (!SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM)) + { + printf("SSL_CTX_use_PrivateKey_file failed\n"); + exit(1); + } + printf("Key file = %s\n", keyfile); + } + +SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_BOTH); +SSL_CTX_set_timeout(ctx, 200); +SSL_CTX_set_info_callback(ctx, (void (*)())info_callback); +#endif + + +/* --------------- Set up for GnuTLS --------------- */ + +#ifdef HAVE_GNUTLS +if (certfile != NULL) printf("Certificate file = %s\n", certfile); +if (keyfile != NULL) printf("Key file = %s\n", keyfile); +tls_init(certfile, keyfile); +tls_session = tls_session_init(); +gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr)sock); + +/* When the server asks for a certificate and the client does not have one, +there is a SIGPIPE error in the gnutls_handshake() function for some reason +that is not understood. As luck would have it, this has never hit Exim itself +because it ignores SIGPIPE errors. Doing the same here allows it all to work as +one wants. */ + +signal(SIGPIPE, SIG_IGN); +#endif + +/* ---------------------------------------------- */ + + +/* Start TLS session if configured to do so without STARTTLS */ + +#ifdef HAVE_TLS +if (tls_on_connect) + { + printf("Attempting to start TLS\n"); + + #ifdef HAVE_OPENSSL + tls_active = tls_start(sock, &ssl, ctx); + #endif + + #ifdef HAVE_GNUTLS + sigalrm_seen = FALSE; + alarm(timeout); + tls_active = gnutls_handshake(tls_session) >= 0; + alarm(0); + #endif + + if (!tls_active) + printf("Failed to start TLS\n"); + else + printf("Succeeded in starting TLS\n"); + } +#endif + +while (fgets(outbuffer, sizeof(outbuffer), stdin) != NULL) + { + int n = (int)strlen(outbuffer); + while (n > 0 && isspace(outbuffer[n-1])) n--; + outbuffer[n] = 0; + + /* Expect incoming */ + + if (strncmp(outbuffer, "??? ", 4) == 0) + { + unsigned char *lineptr; + printf("%s\n", outbuffer); + + if (*inptr == 0) /* Refill input buffer */ + { + if (tls_active) + { + #ifdef HAVE_OPENSSL + rc = SSL_read (ssl, inbuffer, sizeof(inbuffer) - 1); + #endif + #ifdef HAVE_GNUTLS + rc = gnutls_record_recv(tls_session, CS inbuffer, sizeof(inbuffer) - 1); + #endif + } + else + { + alarm(timeout); + rc = read(sock, inbuffer, sizeof(inbuffer)); + alarm(0); + } + + if (rc < 0) + { + printf("Read error %s\n", strerror(errno)); + exit(1) ; + } + else if (rc == 0) + { + printf("Unexpected EOF read\n"); + close(sock); + exit(1); + } + else + { + inbuffer[rc] = 0; + inptr = inbuffer; + } + } + + lineptr = inptr; + while (*inptr != 0 && *inptr != '\r' && *inptr != '\n') inptr++; + if (*inptr != 0) + { + *inptr++ = 0; + if (*inptr == '\n') inptr++; + } + + printf("<<< %s\n", lineptr); + if (strncmp(lineptr, outbuffer + 4, (int)strlen(outbuffer) - 4) != 0) + { + printf("\n******** Input mismatch ********\n"); + exit(1); + } + + #ifdef HAVE_TLS + if (sent_starttls) + { + if (lineptr[0] == '2') + { + printf("Attempting to start TLS\n"); + fflush(stdout); + + #ifdef HAVE_OPENSSL + tls_active = tls_start(sock, &ssl, ctx); + #endif + + #ifdef HAVE_GNUTLS + sigalrm_seen = FALSE; + alarm(timeout); + tls_active = gnutls_handshake(tls_session) >= 0; + alarm(0); + #endif + + if (!tls_active) + { + printf("Failed to start TLS\n"); + fflush(stdout); + } + else + printf("Succeeded in starting TLS\n"); + } + else printf("Abandoning TLS start attempt\n"); + } + sent_starttls = 0; + #endif + } + + /* Wait for a bit before proceeding */ + + else if (strncmp(outbuffer, "+++ ", 4) == 0) + { + printf("%s\n", outbuffer); + sleep(atoi(outbuffer + 4)); + } + + /* Send outgoing, but barf if unconsumed incoming */ + + else + { + unsigned char *escape; + + if (*inptr != 0) + { + printf("Unconsumed input: %s", inptr); + printf(" About to send: %s\n", outbuffer); + exit(1); + } + + #ifdef HAVE_TLS + + /* Shutdown TLS */ + + if (strcmp(outbuffer, "stoptls") == 0 || + strcmp(outbuffer, "STOPTLS") == 0) + { + if (!tls_active) + { + printf("STOPTLS read when TLS not active\n"); + exit(1); + } + printf("Shutting down TLS encryption\n"); + + #ifdef HAVE_OPENSSL + SSL_shutdown(ssl); + SSL_free(ssl); + #endif + + #ifdef HAVE_GNUTLS + gnutls_bye(tls_session, GNUTLS_SHUT_WR); + gnutls_deinit(tls_session); + tls_session = NULL; + gnutls_global_deinit(); + #endif + + tls_active = 0; + continue; + } + + /* Remember that we sent STARTTLS */ + + sent_starttls = (strcmp(outbuffer, "starttls") == 0 || + strcmp(outbuffer, "STARTTLS") == 0); + + /* Fudge: if the command is "starttls_wait", we send the starttls bit, + but we haven't set the flag, so that there is no negotiation. This is for + testing the server's timeout. */ + + if (strcmp(outbuffer, "starttls_wait") == 0) + { + outbuffer[8] = 0; + n = 8; + } + #endif + + printf(">>> %s\n", outbuffer); + strcpy(outbuffer + n, "\r\n"); + + /* Turn "\n" and "\r" into the relevant characters. This is a hack. */ + + while ((escape = strstr(outbuffer, "\\r")) != NULL) + { + *escape = '\r'; + memmove(escape + 1, escape + 2, (n + 2) - (escape - outbuffer) - 2); + n--; + } + + while ((escape = strstr(outbuffer, "\\n")) != NULL) + { + *escape = '\n'; + memmove(escape + 1, escape + 2, (n + 2) - (escape - outbuffer) - 2); + n--; + } + + /* OK, do it */ + + alarm(timeout); + if (tls_active) + { + #ifdef HAVE_OPENSSL + rc = SSL_write (ssl, outbuffer, n + 2); + #endif + #ifdef HAVE_GNUTLS + rc = gnutls_record_send(tls_session, CS outbuffer, n + 2); + if (rc < 0) + { + printf("GnuTLS write error: %s\n", gnutls_strerror(rc)); + exit(1); + } + #endif + } + else + { + rc = write(sock, outbuffer, n + 2); + } + alarm(0); + + if (rc < 0) + { + printf("Write error: %s\n", strerror(errno)); + exit(1); + } + } + } + +printf("End of script\n"); +close(sock); + +exit(0); +} + +/* End of client.c */ diff --git a/test/src/fakens.c b/test/src/fakens.c new file mode 100644 index 000000000..9ab7b7e2d --- /dev/null +++ b/test/src/fakens.c @@ -0,0 +1,588 @@ +/* $Cambridge: exim/test/src/fakens.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/************************************************* +* fakens - A Fake Nameserver Program * +*************************************************/ + +/* This program exists to support the testing of DNS handling code in Exim. It +avoids the need to install special zones in a real nameserver. When Exim is +running in its (new) test harness, DNS lookups are first passed to this program +instead of to the real resolver. (With a few exceptions - see the discussion in +the test suite's README file.) The program is also passed the name of the Exim +spool directory; it expects to find its "zone files" in ../dnszones relative to +that directory. Note that there is little checking in this program. The fake +zone files are assumed to be syntactically valid. + +The zones that are handled are found by scanning the dnszones directory. A file +whose name is of the form db.ip4.x is a zone file for .x.in-addr.arpa; a file +whose name is of the form db.ip6.x is a zone file for .x.ip6.arpa; a file of +the form db.anything.else is a zone file for .anything.else. A file of the form +qualify.x.y specifies the domain that is used to qualify single-component +names, except for the name "dontqualify". + +The arguments to the program are: + + the name of the Exim spool directory + the domain name that is being sought + the DNS record type that is being sought + +The output from the program is written to stdout. It is supposed to be in +exactly the same format as a traditional namserver response (see RFC 1035) so +that Exim can process it as normal. At present, no compression is used. +Error messages are written to stderr. + +The return codes from the program are zero for success, and otherwise the +values that are set in h_errno after a failing call to the normal resolver: + + 1 HOST_NOT_FOUND host not found (authoritative) + 2 TRY_AGAIN server failure + 3 NO_RECOVERY non-recoverable error + 4 NO_DATA valid name, no data of requested type + +In a real nameserver, TRY_AGAIN is also used for a non-authoritative not found, +but it is not used for that here. There is also one extra return code: + + 5 PASS_ON requests Exim to call res_search() + +This is used for zones that fakens does not recognize. It is also used if a +line in the zone file contains exactly this: + + PASS ON NOT FOUND + +and the domain is not found. It converts the the result to PASS_ON instead of +HOST_NOT_FOUND. */ + +#include <ctype.h> +#include <stdarg.h> +#include <stdio.h> +#include <string.h> +#include <netdb.h> +#include <errno.h> +#include <arpa/nameser.h> +#include <sys/types.h> +#include <dirent.h> + +#define FALSE 0 +#define TRUE 1 +#define PASS_ON 5 + +typedef int BOOL; +typedef unsigned char uschar; + +#define CS (char *) +#define CCS (const char *) +#define US (unsigned char *) + +#define Ustrcat(s,t) strcat(CS(s),CCS(t)) +#define Ustrchr(s,n) US strchr(CCS(s),n) +#define Ustrcmp(s,t) strcmp(CCS(s),CCS(t)) +#define Ustrcpy(s,t) strcpy(CS(s),CCS(t)) +#define Ustrlen(s) (int)strlen(CCS(s)) +#define Ustrncmp(s,t,n) strncmp(CCS(s),CCS(t),n) +#define Ustrncpy(s,t,n) strncpy(CS(s),CCS(t),n) + + +typedef struct adomainstr { + struct adomainstr *next; + uschar name[1]; +} adomainstr; + +typedef struct zoneitem { + uschar *zone; + uschar *zonefile; +} zoneitem; + +typedef struct tlist { + uschar *name; + int value; +} tlist; + +/* On some (older?) operating systems, the standard ns_t_xxx definitions are +not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is +not defined, assume we are in this state. A really old system might not even +know about AAAA and SRV at all. */ + +#ifndef ns_t_a +#define ns_t_a T_A +#define ns_t_ns T_NS +#define ns_t_cname T_CNAME +#define ns_t_soa T_SOA +#define ns_t_ptr T_PTR +#define ns_t_mx T_MX +#define ns_t_txt T_TXT +#define ns_t_aaaa T_AAAA +#define ns_t_srv T_SRV +#ifndef T_AAAA +#define T_AAAA 28 +#endif +#ifndef T_SRV +#define T_SRV 33 +#endif +#endif + +static tlist type_list[] = { + { US"A", ns_t_a }, + { US"NS", ns_t_ns }, + { US"CNAME", ns_t_cname }, +/* { US"SOA", ns_t_soa }, Not currently in use */ + { US"PTR", ns_t_ptr }, + { US"MX", ns_t_mx }, + { US"TXT", ns_t_txt }, + { US"AAAA", ns_t_aaaa }, + { US"SRV", ns_t_srv }, + { NULL, 0 } +}; + + + +/************************************************* +* Get memory and sprintf into it * +*************************************************/ + +/* This is used when building a table of zones and their files. + +Arguments: + format a format string + ... arguments + +Returns: pointer to formatted string +*/ + +static uschar * +fcopystring(uschar *format, ...) +{ +uschar *yield; +char buffer[256]; +va_list ap; +va_start(ap, format); +vsprintf(buffer, format, ap); +va_end(ap); +yield = (uschar *)malloc(Ustrlen(buffer) + 1); +Ustrcpy(yield, buffer); +return yield; +} + + +/************************************************* +* Pack name into memory * +*************************************************/ + +/* This function packs a domain name into memory according to DNS rules. At +present, it doesn't do any compression. + +Arguments: + name the name + pk where to put it + +Returns: the updated value of pk +*/ + +static uschar * +packname(uschar *name, uschar *pk) +{ +while (*name != 0) + { + uschar *p = name; + while (*p != 0 && *p != '.') p++; + *pk++ = (p - name); + memmove(pk, name, p - name); + pk += p - name; + name = (*p == 0)? p : p + 1; + } +*pk++ = 0; +return pk; +} + + + +/************************************************* +* Scan file for RRs * +*************************************************/ + +/* This function scans an open "zone file" for appropriate records, and adds +any that are found to the output buffer. + +Arguments: + f the input FILE + zone the current zone name + domain the domain we are looking for + qtype the type of RR we want + qtypelen the length of qtype + pkptr points to the output buffer pointer; this is updated + countptr points to the record count; this is updated + adomainptr points to where to hang additional domains + +Returns: 0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or + PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen +*/ + +static int +find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype, + int qtypelen, uschar **pkptr, int *countptr, adomainstr **adomainptr) +{ +int yield = HOST_NOT_FOUND; +int zonelen = Ustrlen(zone); +int domainlen = Ustrlen(domain); +BOOL pass_on_not_found = FALSE; +tlist *typeptr; +uschar *pk = *pkptr; +uschar buffer[256]; +uschar rrdomain[256]; + +/* Decode the required type */ + +for (typeptr = type_list; typeptr->name != NULL; typeptr++) + { if (Ustrcmp(typeptr->name, qtype) == 0) break; } +if (typeptr->name == NULL) + { + fprintf(stderr, "fakens: unknown record type %s\n", qtype); + return NO_RECOVERY; + } + +rrdomain[0] = 0; /* No previous domain */ +(void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */ + +/* Scan for RRs */ + +while (fgets(CS buffer, sizeof(buffer), f) != NULL) + { + uschar *rdlptr; + uschar *p, *ep, *pp; + BOOL found_cname = FALSE; + int i, plen, value; + int tvalue = typeptr->value; + int qtlen = qtypelen; + + p = buffer; + while (isspace(*p)) p++; + if (*p == 0 || *p == ';') continue; + + if (Ustrncmp(p, "PASS ON NOT FOUND", 17) == 0) + { + pass_on_not_found = TRUE; + continue; + } + + ep = buffer + Ustrlen(buffer); + while (isspace(ep[-1])) ep--; + *ep = 0; + + p = buffer; + if (!isspace(*p)) + { + uschar *pp = rrdomain; + while (!isspace(*p)) *pp++ = tolower(*p++); + if (pp[-1] != '.') Ustrcpy(pp, zone); else pp[-1] = 0; + } + + /* Compare domain names; first check for a wildcard */ + + if (rrdomain[0] == '*') + { + int restlen = Ustrlen(rrdomain) - 1; + if (domainlen > restlen && + Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue; + } + + /* Not a wildcard RR */ + + else if (Ustrcmp(domain, rrdomain) != 0) continue; + + /* The domain matches */ + + if (yield == HOST_NOT_FOUND) yield = NO_DATA; + + /* Compare RR types; a CNAME record is always returned */ + + while (isspace(*p)) p++; + + if (Ustrncmp(p, "CNAME", 5) == 0) + { + tvalue = ns_t_cname; + qtlen = 5; + found_cname = TRUE; + } + else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue; + + /* Found a relevant record */ + + yield = 0; + *countptr = *countptr + 1; + + p += qtlen; + while (isspace(*p)) p++; + + pk = packname(domain, pk); /* Not rrdomain because of wildcard */ + *pk++ = (tvalue >> 8) & 255; + *pk++ = (tvalue) & 255; + *pk++ = 0; + *pk++ = 1; /* class = IN */ + + pk += 4; /* TTL field; don't care */ + + rdlptr = pk; /* remember rdlength field */ + pk += 2; + + /* The rest of the data depends on the type */ + + switch (tvalue) + { + case ns_t_soa: /* Not currently used */ + break; + + case ns_t_a: + for (i = 0; i < 4; i++) + { + value = 0; + while (isdigit(*p)) value = value*10 + *p++ - '0'; + *pk++ = value; + p++; + } + break; + + /* The only occurrence of a double colon is for ::1 */ + case ns_t_aaaa: + if (Ustrcmp(p, "::1") == 0) + { + memset(pk, 0, 15); + pk += 15; + *pk++ = 1; + } + else for (i = 0; i < 8; i++) + { + value = 0; + while (isxdigit(*p)) + { + value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7'); + p++; + } + *pk++ = (value >> 8) & 255; + *pk++ = value & 255; + p++; + } + break; + + case ns_t_mx: + value = 0; + while (isdigit(*p)) value = value*10 + *p++ - '0'; + while (isspace(*p)) p++; + *pk++ = (value >> 8) & 255; + *pk++ = value & 255; + goto PACKNAME; + + case ns_t_txt: + pp = pk++; + if (*p == '"') p++; /* Should always be the case */ + while (*p != 0 && *p != '"') *pk++ = *p++; + *pp = pk - pp - 1; + break; + + case ns_t_srv: + for (i = 0; i < 3; i++) + { + value = 0; + while (isdigit(*p)) value = value*10 + *p++ - '0'; + while (isspace(*p)) p++; + *pk++ = (value >> 8) & 255; + *pk++ = value & 255; + } + + /* Fall through */ + + case ns_t_cname: + case ns_t_ns: + case ns_t_ptr: + PACKNAME: + if (ep[-1] != '.') sprintf(ep, "%s.", zone); + pk = packname(p, pk); + plen = Ustrlen(p); + if (adomainptr != NULL && plen > zonelen + 2 && + Ustrncmp(p + plen - zonelen - 1, zone, zonelen) == 0) + { + adomainstr *adomain = (adomainstr *)malloc(sizeof(adomainstr) + plen); + *adomainptr = adomain; + adomainptr = &(adomain->next); + adomain->next = NULL; + Ustrncpy(adomain->name, p, plen - 1); + adomain->name[plen-1] = 0; + } + break; + } + + /* Fill in the length, and we are done with this RR */ + + rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255; + rdlptr[1] = (pk -rdlptr - 2) & 255; + + /* If we have just yielded a CNAME, we must change the domain name to the + new domain, and re-start the scan from the beginning. */ + + if (found_cname) + { + domain = fcopystring("%s", p); + domainlen = Ustrlen(domain); + domain[domainlen - 1] = 0; /* Removed trailing dot */ + rrdomain[0] = 0; /* No previous domain */ + (void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */ + } + } + +*pkptr = pk; +return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield; +} + + + +/************************************************* +* Entry point and main program * +*************************************************/ + +int +main(int argc, char **argv) +{ +FILE *f; +DIR *d; +int dirlen, domlen, qtypelen; +int yield, count; +int i; +int zonecount = 0; +tlist *typeptr; +struct dirent *de; +adomainstr *adomain = NULL; +zoneitem zones[32]; +uschar *qualify = NULL; +uschar *p, *zone; +uschar *zonefile = NULL; +uschar domain[256]; +uschar buffer[256]; +uschar qtype[12]; +uschar packet[512]; +uschar *pk = packet; + +if (argc != 4) + { + fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1); + return NO_RECOVERY; + } + +/* Find the zones */ + +(void)sprintf(buffer, "%s/../dnszones", argv[1]); + +d = opendir(CCS buffer); +if (d == NULL) + { + fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer, + strerror(errno)); + return NO_RECOVERY; + } + +while ((de = readdir(d)) != NULL) + { + uschar *name = de->d_name; + if (Ustrncmp(name, "qualify.", 8) == 0) + { + qualify = fcopystring("%s", name + 7); + continue; + } + if (Ustrncmp(name, "db.", 3) != 0) continue; + if (Ustrncmp(name + 3, "ip4.", 4) == 0) + zones[zonecount].zone = fcopystring("%s.in-addr.arpa", name + 6); + else if (Ustrncmp(name + 3, "ip6.", 4) == 0) + zones[zonecount].zone = fcopystring("%s.ip6.arpa", name + 6); + else + zones[zonecount].zone = fcopystring("%s", name + 2); + zones[zonecount++].zonefile = fcopystring("%s", name); + } +(void)closedir(d); + +/* Get the RR type and upper case it, and check that we recognize it. */ + +Ustrncpy(qtype, argv[3], sizeof(qtype)); +qtypelen = Ustrlen(qtype); +for (p = qtype; *p != 0; p++) *p = toupper(*p); + +/* Find the domain, lower case it, check that it is in a zone that we handle, +and set up the zone file name. The zone names in the table all start with a +dot. */ + +domlen = Ustrlen(argv[2]); +if (argv[2][domlen-1] == '.') domlen--; +Ustrncpy(domain, argv[2], domlen); +domain[domlen] = 0; +for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]); + +if (Ustrchr(domain, '.') == NULL && qualify != NULL && + Ustrcmp(domain, "dontqualify") != 0) + { + Ustrcat(domain, qualify); + domlen += Ustrlen(qualify); + } + +for (i = 0; i < zonecount; i++) + { + int zlen; + zone = zones[i].zone; + zlen = Ustrlen(zone); + if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen && + Ustrcmp(domain + domlen - zlen, zone) == 0)) + { + zonefile = zones[i].zonefile; + break; + } + } + +if (zonefile == NULL) + { + fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain); + return PASS_ON; + } + +(void)sprintf(buffer, "%s/../dnszones/%s", argv[1], zonefile); + +/* Initialize the start of the response packet. We don't have to fake up +everything, because we know that Exim will look only at the answer and +additional section parts. */ + +memset(packet, 0, 12); +pk += 12; + +/* Open the zone file. */ + +f = fopen(buffer, "r"); +if (f == NULL) + { + fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno)); + return NO_RECOVERY; + } + +/* Find the records we want, and add them to the result. */ + +count = 0; +yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &adomain); +if (yield == NO_RECOVERY) goto END_OFF; + +packet[6] = (count >> 8) & 255; +packet[7] = count & 255; + +/* Search for additional records and add them to the result. */ + +count = 0; +for (; adomain != NULL; adomain = adomain->next) + { + (void)find_records(f, zone, adomain->name, US"AAAA", 4, &pk, &count, NULL); + (void)find_records(f, zone, adomain->name, US"A", 1, &pk, &count, NULL); + } + +packet[10] = (count >> 8) & 255; +packet[11] = count & 255; + +/* Close the zone file, write the result, and return. */ + +END_OFF: +(void)fclose(f); +(void)fwrite(packet, 1, pk - packet, stdout); +return yield; +} + +/* End of fakens.c */ diff --git a/test/src/fd.c b/test/src/fd.c new file mode 100644 index 000000000..4616f6fd1 --- /dev/null +++ b/test/src/fd.c @@ -0,0 +1,104 @@ +/* $Cambridge: exim/test/src/fd.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/* A program to check on open file descriptors. There are some weird options +for running it in Exim testing. If -q is given, make output suitable for +queryprogram. If -f is given, copy the input as for a transport filter. If -s +is given, add extra output from stat(). */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <fcntl.h> +#include <limits.h> +#include <errno.h> +#include <sys/stat.h> +#include <unistd.h> + + +/* The way of finding out the maximum file descriptor various between OS. +Most have sysconf(), but a few don't. */ + +#ifdef _SC_OPEN_MAX + #define mac_maxfd (sysconf(_SC_OPEN_MAX) - 1) +#elif defined OPEN_MAX + #define mac_maxfd (OPEN_MAX - 1) +#elif defined NOFILE + #define mac_maxfd (NOFILE - 1) +#else + #define mac_maxfd 255; /* just in case */ +#endif + + +int main(int argc, char **argv) +{ +int fd; +int qpgm = 0; +int filter = 0; +int use_stat = 0; +struct stat statbuf; +char buffer[8192]; +char *p = buffer; + +while (argc > 1) + { + char *arg = argv[--argc]; + if (strcmp(arg, "-q") == 0) qpgm = 1; + if (strcmp(arg, "-f") == 0) filter = 1; + if (strcmp(arg, "-s") == 0) use_stat = 1; + } + +if (filter) + { + int len; + while ((len = read(0, buffer, sizeof(buffer))) > 0) + write(1, buffer, len); + } + +p += sprintf(p, "max fd = %d\n", (int)mac_maxfd); + +for (fd = 0; fd <= mac_maxfd; fd++) + { + int options = fcntl(fd, F_GETFD); + if (options >= 0) + { + int status = fcntl(fd, F_GETFL); + p += sprintf(p, "%3d opt=%d status=%X ", fd, options, status); + switch(status & 3) + { + case 0: p += sprintf(p, "RDONLY"); + break; + case 1: p += sprintf(p, "WRONLY"); + break; + case 2: p += sprintf(p, "RDWR"); + break; + } + if (isatty(fd)) p += sprintf(p, " TTY"); + if ((status & 8) != 0) p += sprintf(p, " APPEND"); + + if (use_stat && fstat(fd, &statbuf) >= 0) + { + p += sprintf(p, " mode=%o uid=%d size=%d", (int)statbuf.st_mode, + (int)statbuf.st_uid, (int)statbuf.st_size); + } + + p += sprintf(p, "\n"); + } + else if (errno != EBADF) + { + p += sprintf(p, "%3d errno=%d %s\n", fd, errno, strerror(errno)); + } + } + +if (qpgm) + { + for (p = buffer; *p != 0; p++) + if (*p == '\n') *p = ' '; + printf("ACCEPT DATA=\"%s\"\n", buffer); + } +else printf("%s", buffer); + +exit(0); +} + +/* End */ diff --git a/test/src/iefbr14.c b/test/src/iefbr14.c new file mode 100644 index 000000000..959c370be --- /dev/null +++ b/test/src/iefbr14.c @@ -0,0 +1,11 @@ +/* $Cambridge: exim/test/src/iefbr14.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/* This is a program that does nothing, and returns zero. It is exactly the +same as the Unix "true" utility. Why do we need it? Well, not all systems have +"true" in the same place, and sometimes it's a shell built-in. Given that we +have little utilities anyway, it's just easier to do this. As for its name, +those with IBM mainframe memories will know where that comes from. */ + +int main(void) { return 0; } + +/* End */ diff --git a/test/src/loaded.c b/test/src/loaded.c new file mode 100644 index 000000000..252738427 --- /dev/null +++ b/test/src/loaded.c @@ -0,0 +1,42 @@ +/* $Cambridge: exim/test/src/loaded.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/* This is a test function for dynamic loading in Exim expansions. It uses the +number of arguments to control the result. */ + +/* These lines are taken from local_scan.h in the Exim source: */ + +/* ========================================================================== */ +/* Return codes from the support functions lss_match_xxx(). These are also the +codes that dynamically-loaded ${dlfunc functions must return. */ + +#define OK 0 /* Successful match */ +#define DEFER 1 /* Defer - some problem */ +#define FAIL 2 /* Matching failed */ +#define ERROR 3 /* Internal or config error */ + +/* Extra return code for ${dlfunc functions */ + +#define FAIL_FORCED 4 /* "Forced" failure */ +/* ========================================================================== */ + + +int dltest(unsigned char **yield, int argc, unsigned char *argv[]) +{ +switch (argc) + { + case 0: + return ERROR; + + case 1: + *yield = argv[0]; + return OK; + + case 2: + *yield = (unsigned char *)"yield FAIL_FORCED"; + return FAIL_FORCED; + + default: + *yield = (unsigned char *)"yield FAIL"; + return FAIL; + } +} diff --git a/test/src/mtpscript.c b/test/src/mtpscript.c new file mode 100644 index 000000000..6a0b28160 --- /dev/null +++ b/test/src/mtpscript.c @@ -0,0 +1,169 @@ +/* $Cambridge: exim/test/src/mtpscript.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/* A little hacked up program that allows a script to play the part of a remote +SMTP/LMTP server on stdin/stdout for testing purposes. Hacked from the more +complicated version that does it over a socket. */ + + +/* ANSI C standard includes */ + +#include <ctype.h> +#include <signal.h> +#include <stdarg.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +/* Unix includes */ + +#include <errno.h> +#include <unistd.h> + + +static FILE *log; + + +/************************************************* +* SIGALRM handler - crash out * +*************************************************/ + +static void +sigalrm_handler(int sig) +{ +sig = sig; /* Keep picky compilers happy */ +fprintf(log, "Server timed out\n"); +exit(99); +} + + + +/************************************************* +* Main Program * +*************************************************/ + +int main(int argc, char **argv) +{ +char *logfile; +char *logmode = "w"; +FILE *script; +unsigned char sbuffer[1024]; +unsigned char ibuffer[1024]; + +if (argc < 3) + { + fprintf(stdout, "500 Script and log file required\n"); + exit(1); + } + +/* Get the script and log open */ + +script = fopen(argv[1], "r"); +if (script == NULL) + { + fprintf(stdout, "500 Failed to open script %s: %s\r\n", argv[1], + strerror(errno)); + exit(1); + } + +logfile = argv[2]; +if (logfile[0] == '+') + { + logfile++; + logmode = "a"; + } + +log = fopen(logfile, logmode); +if (log == NULL) + { + fprintf(stdout, "500 Failed to open log %s: %s\r\n", logfile, + strerror(errno)); + exit(1); + } + +/* SIGALRM handler crashes out */ + +signal(SIGALRM, sigalrm_handler); + +/* Read the script, and do what it says. */ + +while (fgets(sbuffer, sizeof(sbuffer), script) != NULL) + { + int n = (int)strlen(sbuffer); + while (n > 0 && isspace(sbuffer[n-1])) n--; + sbuffer[n] = 0; + + /* If the script line starts with a digit, it is a response line which + we are to send. */ + + if (isdigit(sbuffer[0])) + { + fprintf(log, "%s\n", sbuffer); + fflush(log); + fprintf(stdout, "%s\r\n", sbuffer); + fflush(stdout); + } + + /* If the script line starts with "*sleep" we just sleep for a while + before continuing. Do not write this to the log, as it may not get + written at the right place in a log that's being shared. */ + + else if (strncmp(sbuffer, "*sleep ", 7) == 0) + { + sleep(atoi(sbuffer+7)); + } + + /* Otherwise the script line is the start of an input line we are expecting + from the client, or "*eof" indicating we expect the client to close the + connection. Read command line or data lines; the latter are indicated + by the expected line being just ".". */ + + else + { + int data = strcmp(sbuffer, ".") == 0; + + fprintf(log, "%s\n", sbuffer); + fflush(log); + + /* Loop for multiple data lines */ + + for (;;) + { + int n; + alarm(5); + if (fgets(ibuffer, sizeof(ibuffer), stdin) == NULL) + { + fprintf(log, "%sxpected EOF read from client\n", + (strncmp(sbuffer, "*eof", 4) == 0)? "E" : "Une"); + goto END_OFF; + } + alarm(0); + n = (int)strlen(ibuffer); + while (n > 0 && isspace(ibuffer[n-1])) n--; + ibuffer[n] = 0; + fprintf(log, "<<< %s\n", ibuffer); + if (!data || strcmp(ibuffer, ".") == 0) break; + } + + /* Check received what was expected */ + + if (strncmp(sbuffer, ibuffer, (int)strlen(sbuffer)) != 0) + { + fprintf(log, "Comparison failed - bailing out\n"); + goto END_OFF; + } + } + } + +/* This could appear in the wrong place in a shared log, so forgo it. */ +/* fprintf(log, "End of script\n"); */ + +END_OFF: +fclose(script); +fclose(log); + +exit(0); +} + +/* End of mtpscript.c */ diff --git a/test/src/server.c b/test/src/server.c new file mode 100644 index 000000000..f35d80ba2 --- /dev/null +++ b/test/src/server.c @@ -0,0 +1,612 @@ +/* $Cambridge: exim/test/src/server.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +/* A little hacked up program that listens on a given port and allows a script +to play the part of a remote MTA for testing purposes. This scripted version is +hacked from my original interactive version. A further hack allows it to listen +on a Unix domain socket as an alternative to a TCP/IP port. + +In an IPv6 world, listening happens on both an IPv6 and an IPv4 socket, always +on all interfaces, unless the option -noipv6 is given. */ + +/* ANSI C standard includes */ + +#include <ctype.h> +#include <signal.h> +#include <stdarg.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +/* Unix includes */ + +#include <errno.h> +#include <dirent.h> +#include <sys/types.h> + +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> + +#ifdef HAVE_NETINET_IP_VAR_H +#include <netinet/ip_var.h> +#endif + +#include <netdb.h> +#include <arpa/inet.h> +#include <sys/time.h> +#include <sys/resource.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <utime.h> + +#ifdef AF_INET6 +#define HAVE_IPV6 1 +#endif + +#ifndef S_ADDR_TYPE +#define S_ADDR_TYPE u_long +#endif + + +typedef struct line { + struct line *next; + char line[1]; +} line; + + +/************************************************* +* SIGALRM handler - crash out * +*************************************************/ + +static void +sigalrm_handler(int sig) +{ +sig = sig; /* Keep picky compilers happy */ +printf("\nServer timed out\n"); +exit(99); +} + + +/************************************************* +* Get textual IP address * +*************************************************/ + +/* This function is copied from Exim */ + +char * +host_ntoa(const void *arg, char *buffer) +{ +char *yield; + +/* The new world. It is annoying that we have to fish out the address from +different places in the block, depending on what kind of address it is. It +is also a pain that inet_ntop() returns a const char *, whereas the IPv4 +function inet_ntoa() returns just char *, and some picky compilers insist +on warning if one assigns a const char * to a char *. Hence the casts. */ + +#if HAVE_IPV6 +char addr_buffer[46]; +int family = ((struct sockaddr *)arg)->sa_family; +if (family == AF_INET6) + { + struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg; + yield = (char *)inet_ntop(family, &(sk->sin6_addr), addr_buffer, + sizeof(addr_buffer)); + } +else + { + struct sockaddr_in *sk = (struct sockaddr_in *)arg; + yield = (char *)inet_ntop(family, &(sk->sin_addr), addr_buffer, + sizeof(addr_buffer)); + } + +/* If the result is a mapped IPv4 address, show it in V4 format. */ + +if (strncmp(yield, "::ffff:", 7) == 0) yield += 7; + +#else /* HAVE_IPV6 */ + +/* The old world */ + +yield = inet_ntoa(((struct sockaddr_in *)arg)->sin_addr); +#endif + +strcpy(buffer, yield); +return buffer; +} + + +/************************************************* +* Main Program * +*************************************************/ + +#define v6n 0 /* IPv6 socket number */ +#define v4n 1 /* IPv4 socket number */ +#define udn 2 /* Unix domain socket number */ +#define skn 2 /* Potential number of sockets */ + +int main(int argc, char **argv) +{ +int i; +int port = 0; +int listen_socket[3] = { -1, -1, -1 }; +int accept_socket; +int dup_accept_socket; +int connection_count = 1; +int count; +int on = 1; +int timeout = 5; +int use_ipv4 = 1; +int use_ipv6 = 1; +int debug = 0; +int na = 1; +line *script = NULL; +line *last = NULL; +line *s; +FILE *in, *out; + +char *sockname = NULL; +unsigned char buffer[10240]; + +struct sockaddr_un sockun; /* don't use "sun" */ +struct sockaddr_un sockun_accepted; +int sockun_len = sizeof(sockun_accepted); + +#if HAVE_IPV6 +struct sockaddr_in6 sin6; +struct sockaddr_in6 accepted; +struct in6_addr anyaddr6 = IN6ADDR_ANY_INIT ; +#else +struct sockaddr_in accepted; +#endif + +/* Always need an IPv4 structure */ + +struct sockaddr_in sin4; + +int len = sizeof(accepted); + + +/* Sort out the arguments */ + +while (na < argc && argv[na][0] == '-') + { + if (strcmp(argv[na], "-d") == 0) debug = 1; + else if (strcmp(argv[na], "-t") == 0) timeout = atoi(argv[++na]); + else if (strcmp(argv[na], "-noipv4") == 0) use_ipv4 = 0; + else if (strcmp(argv[na], "-noipv6") == 0) use_ipv6 = 0; + else + { + printf("server: unknown option %s\n", argv[na]); + exit(1); + } + na++; + } + +if (!use_ipv4 && !use_ipv6) + { + printf("server: -noipv4 and -noipv6 cannot both be given\n"); + exit(1); + } + +if (na >= argc) + { + printf("server: no port number or socket name given\n"); + exit(1); + } + +if (argv[na][0] == '/') + { + sockname = argv[na]; + unlink(sockname); /* in case left lying around */ + } +else port = atoi(argv[na]); +na++; + +if (na < argc) connection_count = atoi(argv[na]); + + +/* Create sockets */ + +if (port == 0) /* Unix domain */ + { + if (debug) printf("Creating Unix domain socket\n"); + listen_socket[udn] = socket(PF_UNIX, SOCK_STREAM, 0); + if (listen_socket[udn] < 0) + { + printf("Unix domain socket creation failed: %s\n", strerror(errno)); + exit(1); + } + } +else + { + #if HAVE_IPV6 + if (use_ipv6) + { + if (debug) printf("Creating IPv6 socket\n"); + listen_socket[v6n] = socket(AF_INET6, SOCK_STREAM, 0); + if (listen_socket[v6n] < 0) + { + printf("IPv6 socket creation failed: %s\n", strerror(errno)); + exit(1); + } + + /* If this is an IPv6 wildcard socket, set IPV6_V6ONLY if that option is + available. */ + + #ifdef IPV6_V6ONLY + if (setsockopt(listen_socket[v6n], IPPROTO_IPV6, IPV6_V6ONLY, (char *)(&on), + sizeof(on)) < 0) + printf("Setting IPV6_V6ONLY on IPv6 wildcard " + "socket failed (%s): carrying on without it\n", strerror(errno)); + #endif /* IPV6_V6ONLY */ + } + #endif /* HAVE_IPV6 */ + + /* Create an IPv4 socket if required */ + + if (use_ipv4) + { + if (debug) printf("Creating IPv4 socket\n"); + listen_socket[v4n] = socket(AF_INET, SOCK_STREAM, 0); + if (listen_socket[v4n] < 0) + { + printf("IPv4 socket creation failed: %s\n", strerror(errno)); + exit(1); + } + } + } + + +/* Set SO_REUSEADDR on the IP sockets so that the program can be restarted +while a connection is being handled - this can happen as old connections lie +around for a bit while crashed processes are tidied away. Without this, a +connection will prevent reuse of the smtp port for listening. */ + +for (i = v6n; i <= v4n; i++) + { + if (listen_socket[i] >= 0 && + setsockopt(listen_socket[i], SOL_SOCKET, SO_REUSEADDR, (char *)(&on), + sizeof(on)) < 0) + { + printf("setting SO_REUSEADDR on socket failed: %s\n", strerror(errno)); + exit(1); + } + } + + +/* Now bind the sockets to the required port or path. If a path, ensure +anyone can write to it. */ + +if (port == 0) + { + struct stat statbuf; + sockun.sun_family = AF_UNIX; + if (debug) printf("Binding Unix domain socket\n"); + sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1), sockname); + if (bind(listen_socket[udn], (struct sockaddr *)&sockun, sizeof(sockun)) < 0) + { + printf("Unix domain socket bind() failed: %s\n", strerror(errno)); + exit(1); + } + (void)stat(sockname, &statbuf); + if (debug) printf("Setting Unix domain socket mode: %0x\n", + statbuf.st_mode | 0777); + if (chmod(sockname, statbuf.st_mode | 0777) < 0) + { + printf("Unix domain socket chmod() failed: %s\n", strerror(errno)); + exit(1); + } + } + +else + { + for (i = 0; i < skn; i++) + { + if (listen_socket[i] < 0) continue; + + /* For an IPv6 listen, use an IPv6 socket */ + + #if HAVE_IPV6 + if (i == v6n) + { + memset(&sin6, 0, sizeof(sin6)); + sin6.sin6_family = AF_INET6; + sin6.sin6_port = htons(port); + sin6.sin6_addr = anyaddr6; + if (bind(listen_socket[i], (struct sockaddr *)&sin6, sizeof(sin6)) < 0) + { + printf("IPv6 socket bind() failed: %s\n", strerror(errno)); + exit(1); + } + } + else + #endif + + /* For an IPv4 bind, use an IPv4 socket, even in an IPv6 world. If an IPv4 + bind fails EADDRINUSE after IPv6 success, carry on, because it means the + IPv6 socket will handle IPv4 connections. */ + + { + memset(&sin4, 0, sizeof(sin4)); + sin4.sin_family = AF_INET; + sin4.sin_addr.s_addr = (S_ADDR_TYPE)INADDR_ANY; + sin4.sin_port = htons(port); + if (bind(listen_socket[i], (struct sockaddr *)&sin4, sizeof(sin4)) < 0) + { + if (listen_socket[v6n] < 0 || errno != EADDRINUSE) + { + printf("IPv4 socket bind() failed: %s\n", strerror(errno)); + exit(1); + } + else + { + close(listen_socket[i]); + listen_socket[i] = -1; + } + } + } + } + } + + +/* Start listening. If IPv4 fails EADDRINUSE after IPv6 succeeds, ignore the +error because it means that the IPv6 socket will handle IPv4 connections. Don't +output anything, because it will mess up the test output, which will be +different for systems that do this and those that don't. */ + +for (i = 0; i <= skn; i++) + { + if (listen_socket[i] >= 0 && listen(listen_socket[i], 5) < 0) + { + if (i != v4n || listen_socket[v6n] < 0 || errno != EADDRINUSE) + { + printf("listen() failed: %s\n", strerror(errno)); + exit(1); + } + } + } + + +/* This program handles only a fixed number of connections, in sequence. Before +waiting for the first connection, read the standard input, which contains the +script of things to do. A line containing "++++" is treated as end of file. +This is so that the Perl driving script doesn't have to close the pipe - +because that would cause it to wait for this process, which it doesn't yet want +to do. The driving script adds the "++++" automatically - it doesn't actually +appear in the test script. */ + +while (fgets(buffer, sizeof(buffer), stdin) != NULL) + { + line *next; + int n = (int)strlen(buffer); + while (n > 0 && isspace(buffer[n-1])) n--; + buffer[n] = 0; + if (strcmp(buffer, "++++") == 0) break; + next = malloc(sizeof(line) + n); + next->next = NULL; + strcpy(next->line, buffer); + if (last == NULL) script = last = next; + else last->next = next; + last = next; + } + +fclose(stdin); + +/* SIGALRM handler crashes out */ + +signal(SIGALRM, sigalrm_handler); + +/* s points to the current place in the script */ + +s = script; + +for (count = 0; count < connection_count; count++) + { + alarm(timeout); + if (port <= 0) + { + printf("Listening on %s ... ", sockname); + fflush(stdout); + accept_socket = accept(listen_socket[udn], + (struct sockaddr *)&sockun_accepted, &sockun_len); + } + + else + { + int lcount; + int max_socket = 0; + fd_set select_listen; + + printf("Listening on port %d ... ", port); + fflush(stdout); + + FD_ZERO(&select_listen); + for (i = 0; i < skn; i++) + { + if (listen_socket[i] >= 0) FD_SET(listen_socket[i], &select_listen); + if (listen_socket[i] > max_socket) max_socket = listen_socket[i]; + } + + lcount = select(max_socket + 1, &select_listen, NULL, NULL, NULL); + if (lcount < 0) + { + printf("Select failed\n"); + fflush(stdout); + continue; + } + + accept_socket = -1; + for (i = 0; i < skn; i++) + { + if (listen_socket[i] > 0 && FD_ISSET(listen_socket[i], &select_listen)) + { + accept_socket = accept(listen_socket[i], + (struct sockaddr *)&accepted, &len); + FD_CLR(listen_socket[i], &select_listen); + break; + } + } + } + alarm(0); + + if (accept_socket < 0) + { + printf("accept() failed: %s\n", strerror(errno)); + exit(1); + } + + out = fdopen(accept_socket, "w"); + + dup_accept_socket = dup(accept_socket); + + if (port > 0) + printf("\nConnection request from [%s]\n", host_ntoa(&accepted, buffer)); + else + { + printf("\nConnection request\n"); + + /* Linux supports a feature for acquiring the peer's credentials, but it + appears to be Linux-specific. This code is untested and unused, just + saved here for reference. */ + + /**********-------------------- + struct ucred cr; + int cl=sizeof(cr); + + if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &cl)==0) { + printf("Peer's pid=%d, uid=%d, gid=%d\n", + cr.pid, cr.uid, cr.gid); + --------------*****************/ + } + + if (dup_accept_socket < 0) + { + printf("Couldn't dup socket descriptor\n"); + printf("421 Connection refused: %s\n", strerror(errno)); + fprintf(out, "421 Connection refused: %s\r\n", strerror(errno)); + fclose(out); + exit(2); + } + + in = fdopen(dup_accept_socket, "r"); + + /* Loop for handling the conversation(s). For use in SMTP sessions, there are + default rules for determining input and output lines: the latter start with + digits. This means that the input looks like SMTP dialog. However, this + doesn't work for other tests (e.g. ident tests) so we have explicit '<' and + '>' flags for input and output as well as the defaults. */ + + for (; s != NULL; s = s->next) + { + char *ss = s->line; + + /* Output lines either start with '>' or a digit. In the '>' case we can + fudge the sending of \r\n as required. Default is \r\n, ">>" send nothing, + ">CR>" sends \r only, and ">LF>" sends \n only. We can also force a + connection closedown by ">*eof". */ + + if (ss[0] == '>') + { + char *end = "\r\n"; + printf("%s\n", ss++); + + if (strncmp(ss, "*eof", 4) == 0) + { + s = s->next; + goto END_OFF; + } + + if (*ss == '>') + { end = ""; ss++; } + else if (strncmp(ss, "CR>", 3) == 0) + { end = "\r"; ss += 3; } + else if (strncmp(ss, "LF>", 3) == 0) + { end = "\n"; ss += 3; } + + fprintf(out, "%s%s", ss, end); + } + + else if (isdigit((unsigned char)ss[0])) + { + printf("%s\n", ss); + fprintf(out, "%s\r\n", ss); + } + + /* If the script line starts with "*sleep" we just sleep for a while + before continuing. */ + + else if (strncmp(ss, "*sleep ", 7) == 0) + { + int sleepfor = atoi(ss+7); + printf("%s\n", ss); + fflush(out); + sleep(sleepfor); + } + + /* Otherwise the script line is the start of an input line we are expecting + from the client, or "*eof" indicating we expect the client to close the + connection. Read command line or data lines; the latter are indicated + by the expected line being just ".". If the line starts with '<', that + doesn't form part of the expected input. (This allows for incoming data + starting with a digit.) */ + + else + { + int offset; + int data = strcmp(ss, ".") == 0; + + if (ss[0] == '<') + { + buffer[0] = '<'; + offset = 1; + } + else offset = 0; + + fflush(out); + + for (;;) + { + int n; + alarm(timeout); + if (fgets(buffer+offset, sizeof(buffer)-offset, in) == NULL) + { + printf("%sxpected EOF read from client\n", + (strncmp(ss, "*eof", 4) == 0)? "E" : "Une"); + s = s->next; + goto END_OFF; + } + alarm(0); + n = (int)strlen(buffer); + while (n > 0 && isspace(buffer[n-1])) n--; + buffer[n] = 0; + printf("%s\n", buffer); + if (!data || strcmp(buffer, ".") == 0) break; + } + + if (strncmp(ss, buffer, (int)strlen(ss)) != 0) + { + printf("Comparison failed - bailing out\n"); + printf("Expected: %s\n", ss); + break; + } + } + } + + END_OFF: + fclose(in); + fclose(out); + } + +if (s == NULL) printf("End of script\n"); + +if (sockname != NULL) unlink(sockname); +exit(0); +} + +/* End of server.c */ diff --git a/test/src/showids.c b/test/src/showids.c new file mode 100644 index 000000000..fd4eb2057 --- /dev/null +++ b/test/src/showids.c @@ -0,0 +1,26 @@ +/* $Cambridge: exim/test/src/showids.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */ + +#include <stdio.h> +#include <unistd.h> +#include <sys/types.h> + +int main(void) +{ +int count, i; +gid_t grouplist[100]; + +printf("uid=%d gid=%d euid=%d egid=%d\n", + getuid(), getgid(), geteuid(), getegid()); + +/* Can no longer use this because on different systems, the supplemental +groups will be different. */ + +#ifdef NEVER +printf("supplemental groups: "); +count = getgroups(100, grouplist); +for (i = 0; i < count; i++) printf("%d ", grouplist[i]); +printf("\n"); +#endif + +return 0; +} |