bool t_binary_abspath(const char **binpath)
{
const char *path_env, *const *paths;
string_t *path;
if (**binpath == '/') {
/* already have absolute path */
return TRUE;
} else if (strchr(*binpath, '/') != NULL) {
/* relative to current directory */
*binpath = t_abspath(*binpath);
return TRUE;
} else if ((path_env = getenv("PATH")) != NULL) {
/* we have to find our executable from path */
path = t_str_new(256);
paths = t_strsplit(path_env, ":");
for (; *paths != NULL; paths++) {
str_append(path, *paths);
str_append_c(path, '/');
str_append(path, *binpath);
if (access(str_c(path), X_OK) == 0) {
*binpath = str_c(path);
return TRUE;
}
str_truncate(path, 0);
}
}
return FALSE;
}
static void main_init(void)
{
struct master_service_connection conn;
if (IS_STANDALONE()) {
memset(&conn, 0, sizeof(conn));
(void)client_create(STDIN_FILENO, STDOUT_FILENO, &conn);
}
dns_client_socket_path = t_abspath(DNS_CLIENT_SOCKET_PATH);
}
static struct mail_raw *mail_raw_create
(struct mail_user *ruser, struct istream *input,
const char *mailfile, const char *sender, time_t mtime)
{
struct mail_raw *mailr;
struct mailbox_header_lookup_ctx *headers_ctx;
const char *envelope_sender;
int ret;
if ( mailfile != NULL && *mailfile != '/' )
mailfile = t_abspath(mailfile);
mailr = i_new(struct mail_raw, 1);
envelope_sender = sender != NULL ? sender : DEFAULT_ENVELOPE_SENDER;
if ( mailfile == NULL ) {
ret = raw_mailbox_alloc_stream(ruser, input, mtime,
envelope_sender, &mailr->box);
} else {
ret = raw_mailbox_alloc_path(ruser, mailfile, (time_t)-1,
envelope_sender, &mailr->box);
}
if ( ret < 0 ) {
if ( mailfile == NULL ) {
i_fatal("Can't open delivery mail as raw: %s",
mailbox_get_last_error(mailr->box, NULL));
} else {
i_fatal("Can't open delivery mail as raw (file=%s): %s",
mailfile, mailbox_get_last_error(mailr->box, NULL));
}
}
mailr->trans = mailbox_transaction_begin(mailr->box, 0);
headers_ctx = mailbox_header_lookup_init(mailr->box, wanted_headers);
mailr->mail = mail_alloc(mailr->trans, 0, headers_ctx);
mailbox_header_lookup_unref(&headers_ctx);
mail_set_seq(mailr->mail, 1);
return mailr;
}
int main(int argc, char *argv[])
{
static const struct setting_parser_info *set_roots[] = {
&pop3_setting_parser_info,
NULL
};
struct master_login_settings login_set;
enum master_service_flags service_flags = 0;
enum mail_storage_service_flags storage_service_flags = 0;
const char *username = NULL;
int c;
memset(&login_set, 0, sizeof(login_set));
login_set.postlogin_timeout_secs = MASTER_POSTLOGIN_TIMEOUT_DEFAULT;
if (IS_STANDALONE() && getuid() == 0 &&
net_getpeername(1, NULL, NULL) == 0) {
printf("-ERR [SYS/PERM] pop3 binary must not be started from "
"inetd, use pop3-login instead.\n");
return 1;
}
if (IS_STANDALONE()) {
service_flags |= MASTER_SERVICE_FLAG_STANDALONE |
MASTER_SERVICE_FLAG_STD_CLIENT;
} else {
service_flags |= MASTER_SERVICE_FLAG_KEEP_CONFIG_OPEN;
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_DISALLOW_ROOT;
}
master_service = master_service_init("pop3", service_flags,
&argc, &argv, "t:u:");
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 't':
if (str_to_uint(optarg, &login_set.postlogin_timeout_secs) < 0 ||
login_set.postlogin_timeout_secs == 0)
i_fatal("Invalid -t parameter: %s", optarg);
break;
case 'u':
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP;
username = optarg;
break;
default:
return FATAL_DEFAULT;
}
}
login_set.auth_socket_path = t_abspath("auth-master");
if (argv[optind] != NULL)
login_set.postlogin_socket_path = t_abspath(argv[optind]);
login_set.callback = login_client_connected;
login_set.failure_callback = login_client_failed;
master_service_init_finish(master_service);
master_service_set_die_callback(master_service, pop3_die);
storage_service =
mail_storage_service_init(master_service,
set_roots, storage_service_flags);
/* fake that we're running, so we know if client was destroyed
while handling its initial input */
io_loop_set_running(current_ioloop);
if (IS_STANDALONE()) {
T_BEGIN {
main_stdio_run(username);
} T_END;
} else {
int main(int argc, char **argv)
{
struct sieve_instance *svinst;
const char *scriptfile, *dumpfile, *tracefile;
struct sieve_trace_config tr_config;
struct sieve_binary *sbin;
const char *sieve_dir;
bool log_stdout = FALSE;
int ret, c;
sieve_tool = sieve_tool_init
("testsuite", &argc, &argv, "d:t:T:EDP:", TRUE);
/* Parse arguments */
scriptfile = dumpfile = tracefile = NULL;
memset(&tr_config, 0, sizeof(tr_config));
tr_config.level = SIEVE_TRLVL_ACTIONS;
while ((c = sieve_tool_getopt(sieve_tool)) > 0) {
switch (c) {
case 'd':
/* destination address */
dumpfile = optarg;
break;
case 't':
/* trace file */
tracefile = optarg;
break;
case 'T':
sieve_tool_parse_trace_option(&tr_config, optarg);
break;
case 'E':
log_stdout = TRUE;
break;
default:
print_help();
i_fatal_status(EX_USAGE,
"Unknown argument: %c", c);
break;
}
}
if ( optind < argc ) {
scriptfile = t_strdup(argv[optind++]);
} else {
print_help();
i_fatal_status(EX_USAGE, "Missing <scriptfile> argument");
}
if (optind != argc) {
print_help();
i_fatal_status(EX_USAGE, "Unknown argument: %s", argv[optind]);
}
/* Initialize mail user */
sieve_tool_set_homedir(sieve_tool, t_abspath(""));
/* Initialize settings environment */
testsuite_settings_init();
/* Currently needed for include (FIXME) */
sieve_dir = strrchr(scriptfile, '/');
if ( sieve_dir == NULL )
sieve_dir= "./";
else {
sieve_dir = t_strdup_until(scriptfile, sieve_dir+1);
}
testsuite_setting_set
("sieve_dir", t_strconcat(sieve_dir, "included", NULL));
testsuite_setting_set
("sieve_global_dir", t_strconcat(sieve_dir, "included-global", NULL));
/* Finish testsuite initialization */
svinst = sieve_tool_init_finish(sieve_tool, FALSE);
testsuite_init(svinst, log_stdout);
printf("Test case: %s:\n\n", scriptfile);
/* Compile sieve script */
if ( (sbin = sieve_compile
(svinst, scriptfile, NULL, testsuite_log_main_ehandler, NULL)) != NULL ) {
struct ostream *tracestream = NULL;
struct sieve_script_env scriptenv;
/* Dump script */
sieve_tool_dump_binary_to(sbin, dumpfile, FALSE);
if ( tracefile != NULL )
tracestream = sieve_tool_open_output_stream(tracefile);
testsuite_mailstore_init();
testsuite_message_init();
memset(&scriptenv, 0, sizeof(scriptenv));
scriptenv.user = sieve_tool_get_mail_user(sieve_tool);
scriptenv.default_mailbox = "INBOX";
scriptenv.hostname = "testsuite.example.com";
scriptenv.postmaster_address = "*****@*****.**";
scriptenv.username = sieve_tool_get_username(sieve_tool);
scriptenv.smtp_open = testsuite_smtp_open;
scriptenv.smtp_close = testsuite_smtp_close;
scriptenv.trace_stream = tracestream;
scriptenv.trace_config = tr_config;
testsuite_scriptenv = &scriptenv;
testsuite_result_init();
/* Run the test */
ret = testsuite_run
(sbin, &testsuite_msgdata, &scriptenv, testsuite_log_main_ehandler);
switch ( ret ) {
case SIEVE_EXEC_OK:
break;
case SIEVE_EXEC_FAILURE:
case SIEVE_EXEC_KEEP_FAILED:
testsuite_testcase_fail("test script execution aborted due to error");
break;
case SIEVE_EXEC_BIN_CORRUPT:
testsuite_testcase_fail("compiled test script binary is corrupt");
break;
default:
testsuite_testcase_fail("unknown execution exit code");
}
sieve_close(&sbin);
/* De-initialize message environment */
testsuite_message_deinit();
testsuite_mailstore_deinit();
testsuite_result_deinit();
if ( tracestream != NULL )
o_stream_unref(&tracestream);
} else {
testsuite_testcase_fail("failed to compile testcase script");
}
/* De-initialize testsuite */
testsuite_deinit();
testsuite_settings_deinit();
sieve_tool_deinit(&sieve_tool);
if ( !testsuite_testcase_result() )
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
