[exim.git] / src / src / drtables.c

/* $Cambridge: exim/src/src/drtables.c,v 1.11 2009/11/16 19:50:36 nm4 Exp $ */

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Copyright (c) University of Cambridge 1995 - 2009 */
/* See the file NOTICE for conditions of use and distribution. */


#include "exim.h"

#include <string.h>

/* This module contains tables that define the lookup methods and drivers
that are actually included in the binary. Its contents are controlled by
various macros in config.h that ultimately come from Local/Makefile. They are
all described in src/EDITME. */


lookup_info **lookup_list;
int lookup_list_count = 0;

static int lookup_list_init_done = 0;

/* Table of information about all possible authentication mechamisms. All
entries are always present if any mechanism is declared, but the functions are
set to NULL for those that are not compiled into the binary. */

#ifdef AUTH_CRAM_MD5
#include "auths/cram_md5.h"
#endif

#ifdef AUTH_CYRUS_SASL
#include "auths/cyrus_sasl.h"
#endif

#ifdef AUTH_DOVECOT
#include "auths/dovecot.h"
#endif

#ifdef AUTH_PLAINTEXT
#include "auths/plaintext.h"
#endif

#ifdef AUTH_SPA
#include "auths/spa.h"
#endif

auth_info auths_available[] = {

/* Checking by an expansion condition on plain text */

#ifdef AUTH_CRAM_MD5
  {
  US"cram_md5",                              /* lookup name */
  auth_cram_md5_options,
  &auth_cram_md5_options_count,
  &auth_cram_md5_option_defaults,
  sizeof(auth_cram_md5_options_block),
  auth_cram_md5_init,                        /* init function */
  auth_cram_md5_server,                      /* server function */
  auth_cram_md5_client                       /* client function */
  },
#endif

#ifdef AUTH_CYRUS_SASL
  {
  US"cyrus_sasl",           /* lookup name */
  auth_cyrus_sasl_options,
  &auth_cyrus_sasl_options_count,
  &auth_cyrus_sasl_option_defaults,
  sizeof(auth_cyrus_sasl_options_block),
  auth_cyrus_sasl_init,                      /* init function */
  auth_cyrus_sasl_server,                    /* server function */
  NULL                                       /* client function */
  },
#endif

#ifdef AUTH_DOVECOT
  {
  US"dovecot",                                /* lookup name */
  auth_dovecot_options,
  &auth_dovecot_options_count,
  &auth_dovecot_option_defaults,
  sizeof(auth_dovecot_options_block),
  auth_dovecot_init,                          /* init function */
  auth_dovecot_server,                        /* server function */
  NULL                                        /* client function */
  },
#endif

#ifdef AUTH_PLAINTEXT
  {
  US"plaintext",                             /* lookup name */
  auth_plaintext_options,
  &auth_plaintext_options_count,
  &auth_plaintext_option_defaults,
  sizeof(auth_plaintext_options_block),
  auth_plaintext_init,                       /* init function */
  auth_plaintext_server,                     /* server function */
  auth_plaintext_client                      /* client function */
  },
#endif

#ifdef AUTH_SPA
  {
  US"spa",                                   /* lookup name */
  auth_spa_options,
  &auth_spa_options_count,
  &auth_spa_option_defaults,
  sizeof(auth_spa_options_block),
  auth_spa_init,                             /* init function */
  auth_spa_server,                           /* server function */
  auth_spa_client                            /* client function */
  },
#endif

{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL  }
};


/* Tables of information about which routers and transports are included in the
exim binary. */

/* Pull in the necessary header files */

#include "routers/rf_functions.h"

#ifdef ROUTER_ACCEPT
#include "routers/accept.h"
#endif

#ifdef ROUTER_DNSLOOKUP
#include "routers/dnslookup.h"
#endif

#ifdef ROUTER_MANUALROUTE
#include "routers/manualroute.h"
#endif

#ifdef ROUTER_IPLITERAL
#include "routers/ipliteral.h"
#endif

#ifdef ROUTER_IPLOOKUP
#include "routers/iplookup.h"
#endif

#ifdef ROUTER_QUERYPROGRAM
#include "routers/queryprogram.h"
#endif

#ifdef ROUTER_REDIRECT
#include "routers/redirect.h"
#endif

#ifdef TRANSPORT_APPENDFILE
#include "transports/appendfile.h"
#endif

#ifdef TRANSPORT_AUTOREPLY
#include "transports/autoreply.h"
#endif

#ifdef TRANSPORT_LMTP
#include "transports/lmtp.h"
#endif

#ifdef TRANSPORT_PIPE
#include "transports/pipe.h"
#endif

#ifdef TRANSPORT_SMTP
#include "transports/smtp.h"
#endif


/* Now set up the structures, terminated by an entry with a null name. */

router_info routers_available[] = {
#ifdef ROUTER_ACCEPT
  {
  US"accept",
  accept_router_options,
  &accept_router_options_count,
  &accept_router_option_defaults,
  sizeof(accept_router_options_block),
  accept_router_init,
  accept_router_entry,
  NULL,     /* no tidyup entry */
  ri_yestransport
  },
#endif
#ifdef ROUTER_DNSLOOKUP
  {
  US"dnslookup",
  dnslookup_router_options,
  &dnslookup_router_options_count,
  &dnslookup_router_option_defaults,
  sizeof(dnslookup_router_options_block),
  dnslookup_router_init,
  dnslookup_router_entry,
  NULL,     /* no tidyup entry */
  ri_yestransport
  },
#endif
#ifdef ROUTER_IPLITERAL
  {
  US"ipliteral",
  ipliteral_router_options,
  &ipliteral_router_options_count,
  &ipliteral_router_option_defaults,
  sizeof(ipliteral_router_options_block),
  ipliteral_router_init,
  ipliteral_router_entry,
  NULL,     /* no tidyup entry */
  ri_yestransport
  },
#endif
#ifdef ROUTER_IPLOOKUP
  {
  US"iplookup",
  iplookup_router_options,
  &iplookup_router_options_count,
  &iplookup_router_option_defaults,
  sizeof(iplookup_router_options_block),
  iplookup_router_init,
  iplookup_router_entry,
  NULL,     /* no tidyup entry */
  ri_notransport
  },
#endif
#ifdef ROUTER_MANUALROUTE
  {
  US"manualroute",
  manualroute_router_options,
  &manualroute_router_options_count,
  &manualroute_router_option_defaults,
  sizeof(manualroute_router_options_block),
  manualroute_router_init,
  manualroute_router_entry,
  NULL,     /* no tidyup entry */
  0
  },
#endif
#ifdef ROUTER_QUERYPROGRAM
  {
  US"queryprogram",
  queryprogram_router_options,
  &queryprogram_router_options_count,
  &queryprogram_router_option_defaults,
  sizeof(queryprogram_router_options_block),
  queryprogram_router_init,
  queryprogram_router_entry,
  NULL,     /* no tidyup entry */
  0
  },
#endif
#ifdef ROUTER_REDIRECT
  {
  US"redirect",
  redirect_router_options,
  &redirect_router_options_count,
  &redirect_router_option_defaults,
  sizeof(redirect_router_options_block),
  redirect_router_init,
  redirect_router_entry,
  NULL,     /* no tidyup entry */
  ri_notransport
  },
#endif
{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL, 0 }
};


transport_info transports_available[] = {
#ifdef TRANSPORT_APPENDFILE
  {
  US"appendfile",                              /* driver name */
  appendfile_transport_options,                /* local options table */
  &appendfile_transport_options_count,         /* number of entries */
  &appendfile_transport_option_defaults,       /* private options defaults */
  sizeof(appendfile_transport_options_block),  /* size of private block */
  appendfile_transport_init,                   /* init entry point */
  appendfile_transport_entry,                  /* main entry point */
  NULL,                                        /* no tidyup entry */
  NULL,                                        /* no closedown entry */
  TRUE,                                        /* local flag */
  },
#endif
#ifdef TRANSPORT_AUTOREPLY
  {
  US"autoreply",                               /* driver name */
  autoreply_transport_options,                 /* local options table */
  &autoreply_transport_options_count,          /* number of entries */
  &autoreply_transport_option_defaults,        /* private options defaults */
  sizeof(autoreply_transport_options_block),   /* size of private block */
  autoreply_transport_init,                    /* init entry point */
  autoreply_transport_entry,                   /* main entry point */
  NULL,                                        /* no tidyup entry */
  NULL,                                        /* no closedown entry */
  TRUE                                         /* local flag */
  },
#endif
#ifdef TRANSPORT_LMTP
  {
  US"lmtp",                                    /* driver name */
  lmtp_transport_options,                      /* local options table */
  &lmtp_transport_options_count,               /* number of entries */
  &lmtp_transport_option_defaults,             /* private options defaults */
  sizeof(lmtp_transport_options_block),        /* size of private block */
  lmtp_transport_init,                         /* init entry point */
  lmtp_transport_entry,                        /* main entry point */
  NULL,                                        /* no tidyup entry */
  NULL,                                        /* no closedown entry */
  TRUE                                         /* local flag */
  },
#endif
#ifdef TRANSPORT_PIPE
  {
  US"pipe",                                    /* driver name */
  pipe_transport_options,                      /* local options table */
  &pipe_transport_options_count,               /* number of entries */
  &pipe_transport_option_defaults,             /* private options defaults */
  sizeof(pipe_transport_options_block),        /* size of private block */
  pipe_transport_init,                         /* init entry point */
  pipe_transport_entry,                        /* main entry point */
  NULL,                                        /* no tidyup entry */
  NULL,                                        /* no closedown entry */
  TRUE                                         /* local flag */
  },
#endif
#ifdef TRANSPORT_SMTP
  {
  US"smtp",                                    /* driver name */
  smtp_transport_options,                      /* local options table */
  &smtp_transport_options_count,               /* number of entries */
  &smtp_transport_option_defaults,             /* private options defaults */
  sizeof(smtp_transport_options_block),        /* size of private block */
  smtp_transport_init,                         /* init entry point */
  smtp_transport_entry,                        /* main entry point */
  NULL,                                        /* no tidyup entry */
  smtp_transport_closedown,                    /* close down passed channel */
  FALSE                                        /* local flag */
  },
#endif
{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, FALSE }
};

struct lookupmodulestr
{
  void *dl;
  struct lookup_module_info *info;
  struct lookupmodulestr *next;
};

static struct lookupmodulestr *lookupmodules = NULL;

static void addlookupmodule(void *dl, struct lookup_module_info *info)
{
  struct lookupmodulestr *p = store_malloc(sizeof(struct lookupmodulestr));
  p->dl = dl;
  p->info = info;
  p->next = lookupmodules;
  lookupmodules = p;
  lookup_list_count += info->lookupcount;
}

/* only valid after lookup_list and lookup_list_count are assigned */
static void add_lookup_to_list(lookup_info *info)
{
  /* need to add the lookup to lookup_list, sorted */
  int pos = 0;

  /* strategy is to go through the list until we find
   * either an empty spot or a name that is higher.
   * this can't fail because we have enough space. */
  while (lookup_list[pos]
      && (Ustrcmp(lookup_list[pos]->name, info->name) <= 0)) {
    pos++;
  }
  if (lookup_list[pos]) {
    /* need to insert it, so move all the other items up
     * (last slot is still empty, of course) */
    memmove(&lookup_list[pos+1],
            &lookup_list[pos],
            sizeof(lookup_info **) * (lookup_list_count-pos-1));
  }
  lookup_list[pos] = info;
}

void init_lookup_list(void)
{
  DIR *dd;
  struct dirent *ent;
  const pcre *regex_islookupmod = regex_must_compile(US"\\.so$", FALSE, TRUE);
  int countmodules = 0;
  int moduleerrors = 0;
  struct lookupmodulestr *p;

  if (lookup_list_init_done)
    return;
  lookup_list_init_done = 1;

#if defined(LOOKUP_CDB) && LOOKUP_CDB!=2
extern lookup_module_info cdb_lookup_module_info;
  addlookupmodule(NULL, &cdb_lookup_module_info);
#endif

#if defined(LOOKUP_DBM) && LOOKUP_DBM!=2
extern lookup_module_info dbmdb_lookup_module_info;
  addlookupmodule(NULL, &dbmdb_lookup_module_info);
#endif

#if defined(LOOKUP_DNSDB) && LOOKUP_DNSDB!=2
extern lookup_module_info dnsdb_lookup_module_info;
  addlookupmodule(NULL, &dnsdb_lookup_module_info);
#endif

#if defined(LOOKUP_DSEARCH) && LOOKUP_DSEARCH!=2
extern lookup_module_info dsearch_lookup_module_info;
  addlookupmodule(NULL, &dsearch_lookup_module_info);
#endif

#if defined(LOOKUP_IBASE) && LOOKUP_IBASE!=2
extern lookup_module_info ibase_lookup_module_info;
  addlookupmodule(NULL, &ibase_lookup_module_info);
#endif

#ifdef LOOKUP_LDAP
extern lookup_module_info ldap_lookup_module_info;
  addlookupmodule(NULL, &ldap_lookup_module_info);
#endif

#if defined(LOOKUP_LSEARCH) && LOOKUP_LSEARCH!=2
extern lookup_module_info lsearch_lookup_module_info;
  addlookupmodule(NULL, &lsearch_lookup_module_info);
#endif

#if defined(LOOKUP_MYSQL) && LOOKUP_MYSQL!=2
extern lookup_module_info mysql_lookup_module_info;
  addlookupmodule(NULL, &mysql_lookup_module_info);
#endif

#if defined(LOOKUP_NIS) && LOOKUP_NIS!=2
extern lookup_module_info nis_lookup_module_info;
  addlookupmodule(NULL, &nis_lookup_module_info);
#endif

#if defined(LOOKUP_NISPLUS) && LOOKUP_NISPLUS!=2
extern lookup_module_info nisplus_lookup_module_info;
  addlookupmodule(NULL, &nisplus_lookup_module_info);
#endif

#if defined(LOOKUP_ORACLE) && LOOKUP_ORACLE!=2
extern lookup_module_info oracle_lookup_module_info;
  addlookupmodule(NULL, &oracle_lookup_module_info);
#endif

#if defined(LOOKUP_PASSWD) && LOOKUP_PASSWD!=2
extern lookup_module_info passwd_lookup_module_info;
  addlookupmodule(NULL, &passwd_lookup_module_info);
#endif

#if defined(LOOKUP_PGSQL) && LOOKUP_PGSQL!=2
extern lookup_module_info pgsql_lookup_module_info;
  addlookupmodule(NULL, &pgsql_lookup_module_info);
#endif

#ifdef EXPERIMENTAL_SPF
extern lookup_module_info spf_lookup_module_info;
  addlookupmodule(NULL, &spf_lookup_module_info);
#endif

#if defined(LOOKUP_SQLITE) && LOOKUP_SQLITE!=2
extern lookup_module_info sqlite_lookup_module_info;
  addlookupmodule(NULL, &sqlite_lookup_module_info);
#endif

#if defined(LOOKUP_TESTDB) && LOOKUP_TESTDB!=2
extern lookup_module_info testdb_lookup_module_info;
  addlookupmodule(NULL, &testdb_lookup_module_info);
#endif

#if defined(LOOKUP_WHOSON) && LOOKUP_WHOSON!=2
extern lookup_module_info whoson_lookup_module_info;
  addlookupmodule(NULL, &whoson_lookup_module_info);
#endif

#ifdef LOOKUP_MODULE_DIR
  dd = opendir(LOOKUP_MODULE_DIR);
  if (dd == NULL) {
    DEBUG(D_lookup) debug_printf("Couldn't open %s: not loading lookup modules\n", LOOKUP_MODULE_DIR);
    log_write(0, LOG_MAIN, "Couldn't open %s: not loading lookup modules\n", LOOKUP_MODULE_DIR);
  }
  else {
    DEBUG(D_lookup) debug_printf("Loading lookup modules from %s\n", LOOKUP_MODULE_DIR);
    while ((ent = readdir(dd)) != NULL) {
      char *name = ent->d_name;
      int len = (int)strlen(name);
      if (pcre_exec(regex_islookupmod, NULL, name, len, 0, PCRE_EOPT, NULL, 0) >= 0) {
        int pathnamelen = len + (int)strlen(LOOKUP_MODULE_DIR) + 2;
        void *dl;
        struct lookup_module_info *info;
        char *errormsg;

        /* SRH: am I being paranoid here or what? */
        if (pathnamelen > big_buffer_size) {
          fprintf(stderr, "Loading lookup modules: %s/%s: name too long\n", LOOKUP_MODULE_DIR, name);
          log_write(0, LOG_MAIN|LOG_PANIC, "%s/%s: name too long\n", LOOKUP_MODULE_DIR, name);
          continue;
        }

        /* SRH: snprintf here? */
        sprintf(CS big_buffer, "%s/%s", LOOKUP_MODULE_DIR, name);

        dl = dlopen(CS big_buffer, RTLD_NOW);// TJ was LAZY
        if (dl == NULL) {
          fprintf(stderr, "Error loading %s: %s\n", name, dlerror());
          moduleerrors++;
          log_write(0, LOG_MAIN|LOG_PANIC, "Error loading lookup module %s: %s\n", name, dlerror());
          continue;
        }

        /* FreeBSD nsdispatch() can trigger dlerror() errors about
         * _nss_cache_cycle_prevention_function; we need to clear the dlerror()
         * state before calling dlsym(), so that any error afterwards only
         * comes from dlsym().
         */
        errormsg = dlerror();

        info = (struct lookup_module_info*) dlsym(dl, "_lookup_module_info");
        if ((errormsg = dlerror()) != NULL) {
          fprintf(stderr, "%s does not appear to be a lookup module (%s)\n", name, errormsg);
          dlclose(dl);
          moduleerrors++;
          log_write(0, LOG_MAIN|LOG_PANIC, "%s does not appear to be a lookup module (%s)\n", name, errormsg);
          continue;
        }
        if (info->magic != LOOKUP_MODULE_INFO_MAGIC) {
          fprintf(stderr, "Lookup module %s is not compatible with this version of Exim\n", name);
          dlclose(dl);
          moduleerrors++;
          log_write(0, LOG_MAIN|LOG_PANIC, "Lookup module %s is not compatible with this version of Exim\n", name);
          continue;
        }

        addlookupmodule(dl, info);
        DEBUG(D_lookup) debug_printf("Loaded \"%s\" (%d lookup types)\n", name, info->lookupcount);
        countmodules++;
      }
    }
    closedir(dd);
  }

  DEBUG(D_lookup) debug_printf("Loaded %d lookup modules\n", countmodules);
#endif

  store_free((void*)regex_islookupmod);

  DEBUG(D_lookup) debug_printf("Total %d lookups\n", lookup_list_count);

  lookup_list = store_malloc(sizeof(lookup_info *) * lookup_list_count);
  memset(lookup_list, 0, sizeof(lookup_info *) * lookup_list_count);

  /* now add all lookups to the real list */
  p = lookupmodules;
  while (p) {
    int j;
    struct lookupmodulestr *pnext;

    for (j = 0; j < p->info->lookupcount; j++)
      add_lookup_to_list(p->info->lookups[j]);

    pnext = p->next;
    store_free(p);
    p = pnext;
  }
  /* just to be sure */
  lookupmodules = NULL;
}

/* End of drtables.c */
Commit	Line	Data
0a49a7a4	1	/* $Cambridge: exim/src/src/drtables.c,v 1.11 2009/11/16 19:50:36 nm4 Exp $ */
059ec3d9 PH	2
	3	/*************************************************
	4	* Exim - an Internet mail transport agent *
	5	*************************************************/
	6
0a49a7a4	7	/* Copyright (c) University of Cambridge 1995 - 2009 */
059ec3d9 PH	8	/* See the file NOTICE for conditions of use and distribution. */
	9
	10
	11	#include "exim.h"
	12
e6d225ae	13	#include <string.h>
059ec3d9 PH	14
	15	/* This module contains tables that define the lookup methods and drivers
	16	that are actually included in the binary. Its contents are controlled by
	17	various macros in config.h that ultimately come from Local/Makefile. They are
	18	all described in src/EDITME. */
	19
	20
e6d225ae DW	21	lookup_info **lookup_list;
e6d225ae DW	22	int lookup_list_count = 0;
059ec3d9	23
6545de78 PP	24	static int lookup_list_init_done = 0;
6545de78 PP	25
059ec3d9 PH	26	/* Table of information about all possible authentication mechamisms. All
	27	entries are always present if any mechanism is declared, but the functions are
	28	set to NULL for those that are not compiled into the binary. */
	29
	30	#ifdef AUTH_CRAM_MD5
	31	#include "auths/cram_md5.h"
	32	#endif
	33
	34	#ifdef AUTH_CYRUS_SASL
	35	#include "auths/cyrus_sasl.h"
	36	#endif
	37
14aa5a05 PH	38	#ifdef AUTH_DOVECOT
	39	#include "auths/dovecot.h"
	40	#endif
	41
059ec3d9 PH	42	#ifdef AUTH_PLAINTEXT
	43	#include "auths/plaintext.h"
	44	#endif
	45
	46	#ifdef AUTH_SPA
	47	#include "auths/spa.h"
	48	#endif
	49
	50	auth_info auths_available[] = {
	51
	52	/* Checking by an expansion condition on plain text */
	53
	54	#ifdef AUTH_CRAM_MD5
	55	{
	56	US"cram_md5", /* lookup name */
	57	auth_cram_md5_options,
	58	&auth_cram_md5_options_count,
	59	&auth_cram_md5_option_defaults,
	60	sizeof(auth_cram_md5_options_block),
	61	auth_cram_md5_init, /* init function */
	62	auth_cram_md5_server, /* server function */
	63	auth_cram_md5_client /* client function */
	64	},
	65	#endif
	66
	67	#ifdef AUTH_CYRUS_SASL
	68	{
384152a6	69	US"cyrus_sasl", /* lookup name */
059ec3d9 PH	70	auth_cyrus_sasl_options,
	71	&auth_cyrus_sasl_options_count,
	72	&auth_cyrus_sasl_option_defaults,
	73	sizeof(auth_cyrus_sasl_options_block),
	74	auth_cyrus_sasl_init, /* init function */
	75	auth_cyrus_sasl_server, /* server function */
	76	NULL /* client function */
	77	},
	78	#endif
	79
14aa5a05 PH	80	#ifdef AUTH_DOVECOT
	81	{
	82	US"dovecot", /* lookup name */
	83	auth_dovecot_options,
	84	&auth_dovecot_options_count,
	85	&auth_dovecot_option_defaults,
	86	sizeof(auth_dovecot_options_block),
	87	auth_dovecot_init, /* init function */
	88	auth_dovecot_server, /* server function */
	89	NULL /* client function */
	90	},
	91	#endif
	92
059ec3d9 PH	93	#ifdef AUTH_PLAINTEXT
	94	{
	95	US"plaintext", /* lookup name */
	96	auth_plaintext_options,
	97	&auth_plaintext_options_count,
	98	&auth_plaintext_option_defaults,
	99	sizeof(auth_plaintext_options_block),
	100	auth_plaintext_init, /* init function */
	101	auth_plaintext_server, /* server function */
	102	auth_plaintext_client /* client function */
	103	},
	104	#endif
	105
	106	#ifdef AUTH_SPA
	107	{
	108	US"spa", /* lookup name */
	109	auth_spa_options,
	110	&auth_spa_options_count,
	111	&auth_spa_option_defaults,
	112	sizeof(auth_spa_options_block),
	113	auth_spa_init, /* init function */
	114	auth_spa_server, /* server function */
	115	auth_spa_client /* client function */
	116	},
	117	#endif
	118
	119	{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL }
	120	};
	121
	122
	123	/* Tables of information about which routers and transports are included in the
	124	exim binary. */
	125
	126	/* Pull in the necessary header files */
	127
	128	#include "routers/rf_functions.h"
	129
	130	#ifdef ROUTER_ACCEPT
	131	#include "routers/accept.h"
	132	#endif
	133
	134	#ifdef ROUTER_DNSLOOKUP
	135	#include "routers/dnslookup.h"
	136	#endif
	137
	138	#ifdef ROUTER_MANUALROUTE
	139	#include "routers/manualroute.h"
	140	#endif
	141
	142	#ifdef ROUTER_IPLITERAL
	143	#include "routers/ipliteral.h"
	144	#endif
	145
	146	#ifdef ROUTER_IPLOOKUP
	147	#include "routers/iplookup.h"
	148	#endif
	149
	150	#ifdef ROUTER_QUERYPROGRAM
	151	#include "routers/queryprogram.h"
	152	#endif
	153
	154	#ifdef ROUTER_REDIRECT
	155	#include "routers/redirect.h"
	156	#endif
157
158	#ifdef TRANSPORT_APPENDFILE
159	#include "transports/appendfile.h"
160	#endif
161
162	#ifdef TRANSPORT_AUTOREPLY
163	#include "transports/autoreply.h"
164	#endif
165
166	#ifdef TRANSPORT_LMTP
167	#include "transports/lmtp.h"
168	#endif
169
170	#ifdef TRANSPORT_PIPE
171	#include "transports/pipe.h"
172	#endif
173
174	#ifdef TRANSPORT_SMTP
175	#include "transports/smtp.h"
176	#endif
177
178
179	/* Now set up the structures, terminated by an entry with a null name. */
180
181	router_info routers_available[] = {
182	#ifdef ROUTER_ACCEPT
183	{
184	US"accept",
185	accept_router_options,
186	&accept_router_options_count,
187	&accept_router_option_defaults,
188	sizeof(accept_router_options_block),
189	accept_router_init,
190	accept_router_entry,
191	NULL, /* no tidyup entry */
192	ri_yestransport
193	},
194	#endif
195	#ifdef ROUTER_DNSLOOKUP
196	{
197	US"dnslookup",
198	dnslookup_router_options,
199	&dnslookup_router_options_count,
200	&dnslookup_router_option_defaults,
201	sizeof(dnslookup_router_options_block),
202	dnslookup_router_init,
203	dnslookup_router_entry,
204	NULL, /* no tidyup entry */
205	ri_yestransport
206	},
207	#endif
208	#ifdef ROUTER_IPLITERAL
209	{
210	US"ipliteral",
211	ipliteral_router_options,
212	&ipliteral_router_options_count,
213	&ipliteral_router_option_defaults,
214	sizeof(ipliteral_router_options_block),
215	ipliteral_router_init,
216	ipliteral_router_entry,
217	NULL, /* no tidyup entry */
218	ri_yestransport
219	},
220	#endif
221	#ifdef ROUTER_IPLOOKUP
222	{
223	US"iplookup",
224	iplookup_router_options,
225	&iplookup_router_options_count,
226	&iplookup_router_option_defaults,
227	sizeof(iplookup_router_options_block),
228	iplookup_router_init,
229	iplookup_router_entry,
230	NULL, /* no tidyup entry */
231	ri_notransport
232	},
233	#endif
234	#ifdef ROUTER_MANUALROUTE
235	{
236	US"manualroute",
237	manualroute_router_options,
238	&manualroute_router_options_count,
239	&manualroute_router_option_defaults,
240	sizeof(manualroute_router_options_block),
241	manualroute_router_init,
242	manualroute_router_entry,
243	NULL, /* no tidyup entry */
244	0
245	},
246	#endif
247	#ifdef ROUTER_QUERYPROGRAM
248	{
249	US"queryprogram",
250	queryprogram_router_options,
251	&queryprogram_router_options_count,
252	&queryprogram_router_option_defaults,
253	sizeof(queryprogram_router_options_block),
254	queryprogram_router_init,
255	queryprogram_router_entry,
256	NULL, /* no tidyup entry */
257	0
258	},
259	#endif
260	#ifdef ROUTER_REDIRECT
261	{
262	US"redirect",
263	redirect_router_options,
264	&redirect_router_options_count,
265	&redirect_router_option_defaults,
266	sizeof(redirect_router_options_block),
267	redirect_router_init,
268	redirect_router_entry,
269	NULL, /* no tidyup entry */
270	ri_notransport
271	},
272	#endif
273	{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL, 0 }
274	};
275
276
277
278	transport_info transports_available[] = {
279	#ifdef TRANSPORT_APPENDFILE
280	{
281	US"appendfile", /* driver name */
282	appendfile_transport_options, /* local options table */
283	&appendfile_transport_options_count, /* number of entries */
284	&appendfile_transport_option_defaults, /* private options defaults */
285	sizeof(appendfile_transport_options_block), /* size of private block */
286	appendfile_transport_init, /* init entry point */
287	appendfile_transport_entry, /* main entry point */
288	NULL, /* no tidyup entry */
289	NULL, /* no closedown entry */
290	TRUE, /* local flag */
291	},
292	#endif
293	#ifdef TRANSPORT_AUTOREPLY
294	{
295	US"autoreply", /* driver name */
296	autoreply_transport_options, /* local options table */
297	&autoreply_transport_options_count, /* number of entries */
298	&autoreply_transport_option_defaults, /* private options defaults */
299	sizeof(autoreply_transport_options_block), /* size of private block */
300	autoreply_transport_init, /* init entry point */
301	autoreply_transport_entry, /* main entry point */
302	NULL, /* no tidyup entry */
303	NULL, /* no closedown entry */
304	TRUE /* local flag */
305	},
306	#endif
307	#ifdef TRANSPORT_LMTP
308	{
309	US"lmtp", /* driver name */
310	lmtp_transport_options, /* local options table */
311	&lmtp_transport_options_count, /* number of entries */
312	&lmtp_transport_option_defaults, /* private options defaults */
313	sizeof(lmtp_transport_options_block), /* size of private block */
314	lmtp_transport_init, /* init entry point */
315	lmtp_transport_entry, /* main entry point */
316	NULL, /* no tidyup entry */
317	NULL, /* no closedown entry */
318	TRUE /* local flag */
319	},
320	#endif
321	#ifdef TRANSPORT_PIPE
322	{
323	US"pipe", /* driver name */
324	pipe_transport_options, /* local options table */
325	&pipe_transport_options_count, /* number of entries */
326	&pipe_transport_option_defaults, /* private options defaults */
327	sizeof(pipe_transport_options_block), /* size of private block */
328	pipe_transport_init, /* init entry point */
329	pipe_transport_entry, /* main entry point */
330	NULL, /* no tidyup entry */
331	NULL, /* no closedown entry */
332	TRUE /* local flag */
333	},
334	#endif
335	#ifdef TRANSPORT_SMTP
336	{
337	US"smtp", /* driver name */
338	smtp_transport_options, /* local options table */
339	&smtp_transport_options_count, /* number of entries */
340	&smtp_transport_option_defaults, /* private options defaults */
341	sizeof(smtp_transport_options_block), /* size of private block */
342	smtp_transport_init, /* init entry point */
343	smtp_transport_entry, /* main entry point */
344	NULL, /* no tidyup entry */
345	smtp_transport_closedown, /* close down passed channel */
346	FALSE /* local flag */
347	},
348	#endif
349	{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, FALSE }
350	};
351
e6d225ae DW	352	struct lookupmodulestr
	353	{
	354	void *dl;
	355	struct lookup_module_info *info;
	356	struct lookupmodulestr *next;
	357	};
	358
	359	static struct lookupmodulestr *lookupmodules = NULL;
	360
	361	static void addlookupmodule(void dl, struct lookup_module_info info)
	362	{
	363	struct lookupmodulestr *p = store_malloc(sizeof(struct lookupmodulestr));
	364	p->dl = dl;
	365	p->info = info;
	366	p->next = lookupmodules;
	367	lookupmodules = p;
	368	lookup_list_count += info->lookupcount;
	369	}
	370
	371	/* only valid after lookup_list and lookup_list_count are assigned */
	372	static void add_lookup_to_list(lookup_info *info)
	373	{
	374	/* need to add the lookup to lookup_list, sorted */
	375	int pos = 0;
	376
	377	/* strategy is to go through the list until we find
	378	* either an empty spot or a name that is higher.
	379	* this can't fail because we have enough space. */
	380	while (lookup_list[pos]
	381	&& (Ustrcmp(lookup_list[pos]->name, info->name) <= 0)) {
	382	pos++;
	383	}
	384	if (lookup_list[pos]) {
	385	/* need to insert it, so move all the other items up
	386	* (last slot is still empty, of course) */
	387	memmove(&lookup_list[pos+1],
	388	&lookup_list[pos],
	389	sizeof(lookup_info *) (lookup_list_count-pos-1));
	390	}
	391	lookup_list[pos] = info;
	392	}
	393
	394	void init_lookup_list(void)
	395	{
	396	DIR *dd;
	397	struct dirent *ent;
	398	const pcre *regex_islookupmod = regex_must_compile(US"\\.so$", FALSE, TRUE);
	399	int countmodules = 0;
	400	int moduleerrors = 0;
	401	struct lookupmodulestr *p;
	402
6545de78 PP	403	if (lookup_list_init_done)
	404	return;
	405	lookup_list_init_done = 1;
	406
e6d225ae DW	407	#if defined(LOOKUP_CDB) && LOOKUP_CDB!=2
	408	extern lookup_module_info cdb_lookup_module_info;
	409	addlookupmodule(NULL, &cdb_lookup_module_info);
	410	#endif
	411
	412	#if defined(LOOKUP_DBM) && LOOKUP_DBM!=2
	413	extern lookup_module_info dbmdb_lookup_module_info;
	414	addlookupmodule(NULL, &dbmdb_lookup_module_info);
	415	#endif
	416
	417	#if defined(LOOKUP_DNSDB) && LOOKUP_DNSDB!=2
	418	extern lookup_module_info dnsdb_lookup_module_info;
	419	addlookupmodule(NULL, &dnsdb_lookup_module_info);
	420	#endif
	421
	422	#if defined(LOOKUP_DSEARCH) && LOOKUP_DSEARCH!=2
	423	extern lookup_module_info dsearch_lookup_module_info;
	424	addlookupmodule(NULL, &dsearch_lookup_module_info);
	425	#endif
	426
	427	#if defined(LOOKUP_IBASE) && LOOKUP_IBASE!=2
	428	extern lookup_module_info ibase_lookup_module_info;
	429	addlookupmodule(NULL, &ibase_lookup_module_info);
	430	#endif
	431
	432	#ifdef LOOKUP_LDAP
	433	extern lookup_module_info ldap_lookup_module_info;
	434	addlookupmodule(NULL, &ldap_lookup_module_info);
	435	#endif
	436
	437	#if defined(LOOKUP_LSEARCH) && LOOKUP_LSEARCH!=2
	438	extern lookup_module_info lsearch_lookup_module_info;
	439	addlookupmodule(NULL, &lsearch_lookup_module_info);
	440	#endif
	441
	442	#if defined(LOOKUP_MYSQL) && LOOKUP_MYSQL!=2
	443	extern lookup_module_info mysql_lookup_module_info;
	444	addlookupmodule(NULL, &mysql_lookup_module_info);
	445	#endif
	446
	447	#if defined(LOOKUP_NIS) && LOOKUP_NIS!=2
	448	extern lookup_module_info nis_lookup_module_info;
	449	addlookupmodule(NULL, &nis_lookup_module_info);
	450	#endif
	451
	452	#if defined(LOOKUP_NISPLUS) && LOOKUP_NISPLUS!=2
	453	extern lookup_module_info nisplus_lookup_module_info;
	454	addlookupmodule(NULL, &nisplus_lookup_module_info);
	455	#endif
	456
	457	#if defined(LOOKUP_ORACLE) && LOOKUP_ORACLE!=2
	458	extern lookup_module_info oracle_lookup_module_info;
	459	addlookupmodule(NULL, &oracle_lookup_module_info);
	460	#endif
	461
	462	#if defined(LOOKUP_PASSWD) && LOOKUP_PASSWD!=2
	463	extern lookup_module_info passwd_lookup_module_info;
	464	addlookupmodule(NULL, &passwd_lookup_module_info);
	465	#endif
	466
	467	#if defined(LOOKUP_PGSQL) && LOOKUP_PGSQL!=2
	468	extern lookup_module_info pgsql_lookup_module_info;
	469	addlookupmodule(NULL, &pgsql_lookup_module_info);
	470	#endif
471
472	#ifdef EXPERIMENTAL_SPF
473	extern lookup_module_info spf_lookup_module_info;
474	addlookupmodule(NULL, &spf_lookup_module_info);
475	#endif
476
477	#if defined(LOOKUP_SQLITE) && LOOKUP_SQLITE!=2
478	extern lookup_module_info sqlite_lookup_module_info;
479	addlookupmodule(NULL, &sqlite_lookup_module_info);
480	#endif
481
482	#if defined(LOOKUP_TESTDB) && LOOKUP_TESTDB!=2
483	extern lookup_module_info testdb_lookup_module_info;
484	addlookupmodule(NULL, &testdb_lookup_module_info);
485	#endif
486
487	#if defined(LOOKUP_WHOSON) && LOOKUP_WHOSON!=2
488	extern lookup_module_info whoson_lookup_module_info;
489	addlookupmodule(NULL, &whoson_lookup_module_info);
490	#endif
491
492	#ifdef LOOKUP_MODULE_DIR
493	dd = opendir(LOOKUP_MODULE_DIR);
494	if (dd == NULL) {
1594a79a	495	DEBUG(D_lookup) debug_printf("Couldn't open %s: not loading lookup modules\n", LOOKUP_MODULE_DIR);
e6d225ae DW	496	log_write(0, LOG_MAIN, "Couldn't open %s: not loading lookup modules\n", LOOKUP_MODULE_DIR);
	497	}
	498	else {
1594a79a	499	DEBUG(D_lookup) debug_printf("Loading lookup modules from %s\n", LOOKUP_MODULE_DIR);
e6d225ae DW	500	while ((ent = readdir(dd)) != NULL) {
	501	char *name = ent->d_name;
	502	int len = (int)strlen(name);
	503	if (pcre_exec(regex_islookupmod, NULL, name, len, 0, PCRE_EOPT, NULL, 0) >= 0) {
	504	int pathnamelen = len + (int)strlen(LOOKUP_MODULE_DIR) + 2;
	505	void *dl;
	506	struct lookup_module_info *info;
	507	char *errormsg;
	508
	509	/* SRH: am I being paranoid here or what? */
	510	if (pathnamelen > big_buffer_size) {
	511	fprintf(stderr, "Loading lookup modules: %s/%s: name too long\n", LOOKUP_MODULE_DIR, name);
	512	log_write(0, LOG_MAIN\|LOG_PANIC, "%s/%s: name too long\n", LOOKUP_MODULE_DIR, name);
	513	continue;
	514	}
	515
	516	/* SRH: snprintf here? */
	517	sprintf(CS big_buffer, "%s/%s", LOOKUP_MODULE_DIR, name);
	518
	519	dl = dlopen(CS big_buffer, RTLD_NOW);// TJ was LAZY
	520	if (dl == NULL) {
	521	fprintf(stderr, "Error loading %s: %s\n", name, dlerror());
	522	moduleerrors++;
	523	log_write(0, LOG_MAIN\|LOG_PANIC, "Error loading lookup module %s: %s\n", name, dlerror());
	524	continue;
	525	}
	526
56e0c4ce PP	527	/* FreeBSD nsdispatch() can trigger dlerror() errors about
	528	* _nss_cache_cycle_prevention_function; we need to clear the dlerror()
	529	* state before calling dlsym(), so that any error afterwards only
	530	* comes from dlsym().
	531	*/
	532	errormsg = dlerror();
	533
e6d225ae DW	534	info = (struct lookup_module_info*) dlsym(dl, "_lookup_module_info");
	535	if ((errormsg = dlerror()) != NULL) {
	536	fprintf(stderr, "%s does not appear to be a lookup module (%s)\n", name, errormsg);
	537	dlclose(dl);
	538	moduleerrors++;
	539	log_write(0, LOG_MAIN\|LOG_PANIC, "%s does not appear to be a lookup module (%s)\n", name, errormsg);
	540	continue;
	541	}
	542	if (info->magic != LOOKUP_MODULE_INFO_MAGIC) {
	543	fprintf(stderr, "Lookup module %s is not compatible with this version of Exim\n", name);
	544	dlclose(dl);
	545	moduleerrors++;
	546	log_write(0, LOG_MAIN\|LOG_PANIC, "Lookup module %s is not compatible with this version of Exim\n", name);
	547	continue;
	548	}
	549
	550	addlookupmodule(dl, info);
1594a79a	551	DEBUG(D_lookup) debug_printf("Loaded \"%s\" (%d lookup types)\n", name, info->lookupcount);
e6d225ae DW	552	countmodules++;
	553	}
	554	}
	555	closedir(dd);
	556	}
	557
1594a79a	558	DEBUG(D_lookup) debug_printf("Loaded %d lookup modules\n", countmodules);
e6d225ae DW	559	#endif
	560
	561	store_free((void*)regex_islookupmod);
	562
1594a79a	563	DEBUG(D_lookup) debug_printf("Total %d lookups\n", lookup_list_count);
e6d225ae DW	564
	565	lookup_list = store_malloc(sizeof(lookup_info ) lookup_list_count);
	566	memset(lookup_list, 0, sizeof(lookup_info ) lookup_list_count);
	567
	568	/* now add all lookups to the real list */
	569	p = lookupmodules;
	570	while (p) {
	571	int j;
	572	struct lookupmodulestr *pnext;
	573
	574	for (j = 0; j < p->info->lookupcount; j++)
	575	add_lookup_to_list(p->info->lookups[j]);
	576
	577	pnext = p->next;
	578	store_free(p);
	579	p = pnext;
	580	}
	581	/* just to be sure */
	582	lookupmodules = NULL;
	583	}
	584
059ec3d9	585	/* End of drtables.c */