diff -x EDITME -x os.h-Linux -Nur exim-4.69/OS/Makefile-Base exim-4.69.new/OS/Makefile-Base --- exim-4.69/OS/Makefile-Base 2008-02-14 15:02:56.000000000 +0100 +++ exim-4.69.new/OS/Makefile-Base 2008-02-14 14:56:37.000000000 +0100 @@ -304,7 +304,7 @@ # updated each time. We don't bother with that for the auxiliaries. OBJ_EXIM = acl.o child.o crypt16.o daemon.o dbfn.o debug.o deliver.o \ - directory.o dns.o drtables.o enq.o exim.o expand.o filter.o \ + directory.o dns.o drtables.o dynamic.o enq.o exim.o expand.o filter.o \ filtertest.o globals.o \ header.o host.o ip.o log.o lss.o match.o moan.o \ os.o parse.o queue.o \ @@ -541,6 +541,7 @@ deliver.o: $(HDRS) deliver.c directory.o: $(HDRS) directory.c dns.o: $(HDRS) dns.c +dynamic.o: $(HDRS) dynamic.c enq.o: $(HDRS) enq.c exim.o: $(HDRS) exim.c expand.o: $(HDRS) expand.c diff -x EDITME -x os.h-Linux -Nur exim-4.69/scripts/MakeLinks exim-4.69.new/scripts/MakeLinks --- exim-4.69/scripts/MakeLinks 2007-09-28 14:21:57.000000000 +0200 +++ exim-4.69.new/scripts/MakeLinks 2008-02-14 14:55:39.000000000 +0100 @@ -217,6 +217,7 @@ ln -s ../src/dns.c dns.c ln -s ../src/drtables.c drtables.c ln -s ../src/dummies.c dummies.c +ln -s ../src/dynamic.c dynamic.c ln -s ../src/enq.c enq.c ln -s ../src/exim.c exim.c ln -s ../src/exim_dbmbuild.c exim_dbmbuild.c diff -x EDITME -x os.h-Linux -Nur exim-4.69/src/dynamic.c exim-4.69.new/src/dynamic.c --- exim-4.69/src/dynamic.c 1970-01-01 01:00:00.000000000 +0100 +++ exim-4.69.new/src/dynamic.c 2008-02-14 17:12:08.000000000 +0100 @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2008 Robert Millan + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + */ + +#ifdef DYNAMIC_LOADER + +#include +#include +#include + +#include "exim.h" + +static struct { void *handle; char filename[]; } dltable[] = +{ +#ifdef EXPERIMENTAL_SPF + { NULL, "libspf2.so.2" }, +#endif +}; + +enum dltable_members +{ +#ifdef EXPERIMENTAL_SPF + LIBSPF, +#endif +}; + +static void * +load_so (char *so) +{ + void *ret; + + ret = dlopen (so, RTLD_GLOBAL|RTLD_LAZY); + if (! ret) + { + fprintf (stderr, "%s\n", dlerror ()); + exit (1); + } + + return ret; +} + +static void * +load_sym (int id, char *sym) +{ + void *ret; + char *err; + + if (! dltable[id].handle) + dltable[id].handle = load_so (dltable[id].filename); + + dlerror (); /* Clear old error conditions. */ + ret = dlsym (dltable[id].handle, sym); + err = dlerror (); + if (err) + { + fprintf (stderr, "%s\n", err); + exit (1); + } + + return ret; +} + + + +#ifdef EXPERIMENTAL_SPF + +static SPF_request_t *(*fn_SPF_request_new_ptr) (SPF_server_t *) = NULL; +SPF_request_t * +SPF_request_new (SPF_server_t *spf_server) +{ + if (! fn_SPF_request_new_ptr) + fn_SPF_request_new_ptr = load_sym (LIBSPF, "SPF_request_new"); + return (*fn_SPF_request_new_ptr) (spf_server); +} + +int (*fn_SPF_request_set_env_from_ptr) (SPF_request_t *, const char *) = NULL; +int +SPF_request_set_env_from (SPF_request_t *sr, const char *from) +{ + if (! fn_SPF_request_set_env_from_ptr) + fn_SPF_request_set_env_from_ptr = load_sym (LIBSPF, "SPF_request_set_env_from"); + return (*fn_SPF_request_set_env_from_ptr) (sr, from); +} + +SPF_errcode_t (*fn_SPF_request_query_mailfrom_ptr) (SPF_request_t *, SPF_response_t **) = NULL; +SPF_errcode_t +SPF_request_query_mailfrom (SPF_request_t *spf_request, SPF_response_t **spf_responsep) +{ + if (! fn_SPF_request_query_mailfrom_ptr) + fn_SPF_request_query_mailfrom_ptr = load_sym (LIBSPF, "SPF_request_query_mailfrom"); + return (*fn_SPF_request_query_mailfrom_ptr) (spf_request, spf_responsep); +} + +SPF_errcode_t (*fn_SPF_request_set_ipv4_str_ptr) (SPF_request_t *, const char *) = NULL; +SPF_errcode_t +SPF_request_set_ipv4_str (SPF_request_t *sr, const char *astr) +{ + if (! fn_SPF_request_set_ipv4_str_ptr) + fn_SPF_request_set_ipv4_str_ptr = load_sym (LIBSPF, "SPF_request_set_ipv4_str"); + return (*fn_SPF_request_set_ipv4_str_ptr) (sr, astr); +} + +SPF_errcode_t (*fn_SPF_request_set_helo_dom_ptr) (SPF_request_t *, const char *) = NULL; +SPF_errcode_t +SPF_request_set_helo_dom (SPF_request_t *sr, const char *dom) +{ + if (! fn_SPF_request_set_helo_dom_ptr) + fn_SPF_request_set_helo_dom_ptr = load_sym (LIBSPF, "SPF_request_set_helo_dom"); + return (*fn_SPF_request_set_helo_dom_ptr) (sr, dom); +} + +void (*fn_SPF_request_free_ptr) (SPF_request_t *) = NULL; +void +SPF_request_free (SPF_request_t *sr) +{ + if (! fn_SPF_request_free_ptr) + fn_SPF_request_free_ptr = load_sym (LIBSPF, "SPF_request_free"); + return (*fn_SPF_request_free_ptr) (sr); +} + +const char *(*fn_SPF_response_get_header_comment_ptr) (SPF_response_t *) = NULL; +const char * +SPF_response_get_header_comment (SPF_response_t *rp) +{ + if (! fn_SPF_response_get_header_comment_ptr) + fn_SPF_response_get_header_comment_ptr = load_sym (LIBSPF, "SPF_response_get_header_comment"); + return (*fn_SPF_response_get_header_comment_ptr) (rp); +} + +const char *(*fn_SPF_response_get_smtp_comment_ptr) (SPF_response_t *) = NULL; +const char * +SPF_response_get_smtp_comment (SPF_response_t *rp) +{ + if (! fn_SPF_response_get_smtp_comment_ptr) + fn_SPF_response_get_smtp_comment_ptr = load_sym (LIBSPF, "SPF_response_get_smtp_comment"); + return (*fn_SPF_response_get_smtp_comment_ptr) (rp); +} + +const char *(*fn_SPF_response_get_received_spf_ptr) (SPF_response_t *) = NULL; +const char * +SPF_response_get_received_spf (SPF_response_t *rp) +{ + if (! fn_SPF_response_get_received_spf_ptr) + fn_SPF_response_get_received_spf_ptr = load_sym (LIBSPF, "SPF_response_get_received_spf"); + return (*fn_SPF_response_get_received_spf_ptr) (rp); +} + +SPF_result_t (*fn_SPF_response_result_ptr) (SPF_response_t *) = NULL; +SPF_result_t +SPF_response_result (SPF_response_t *rp) +{ + if (! fn_SPF_response_result_ptr) + fn_SPF_response_result_ptr = load_sym (LIBSPF, "SPF_response_result"); + return (*fn_SPF_response_result_ptr) (rp); +} + +void (*fn_SPF_response_free_ptr) (SPF_response_t *) = NULL; +void +SPF_response_free (SPF_response_t *rp) +{ + if (! fn_SPF_response_free_ptr) + fn_SPF_response_free_ptr = load_sym (LIBSPF, "SPF_response_free"); + return (*fn_SPF_response_free_ptr) (rp); +} + +const char *(*fn_SPF_strresult_ptr) (SPF_result_t) = NULL; +const char * +SPF_strresult (SPF_result_t result) +{ + if (! fn_SPF_strresult_ptr) + fn_SPF_strresult_ptr = load_sym (LIBSPF, "SPF_strresult"); + return (*fn_SPF_strresult_ptr) (result); +} + + +SPF_server_t *(*fn_SPF_server_new_ptr) (SPF_server_dnstype_t, int) = NULL; +SPF_server_t * +SPF_server_new (SPF_server_dnstype_t dnstype, int debug) +{ + if (! fn_SPF_server_new_ptr) + fn_SPF_server_new_ptr = load_sym (LIBSPF, "SPF_server_new"); + return (*fn_SPF_server_new_ptr) (dnstype, debug); +} + +SPF_errcode_t (*fn_SPF_server_set_rec_dom_ptr) (SPF_server_t *, const char *) = NULL; +SPF_errcode_t +SPF_server_set_rec_dom (SPF_server_t *sp, const char *dom) +{ + if (! fn_SPF_server_set_rec_dom_ptr) + fn_SPF_server_set_rec_dom_ptr = load_sym (LIBSPF, "SPF_server_set_rec_dom"); + return (*fn_SPF_server_set_rec_dom_ptr) (sp, dom); +} + +void (*fn_SPF_server_free_ptr) (SPF_server_t *) = NULL; +void +SPF_server_free (SPF_server_t *sp) +{ + if (! fn_SPF_server_free_ptr) + fn_SPF_server_free_ptr = load_sym (LIBSPF, "SPF_server_free"); + return (*fn_SPF_server_free_ptr) (sp); +} + +#endif /* EXPERIMENTAL_SPF */ + +#endif /* DYNAMIC_LOADER */