void sieve_tool_parse_trace_option
(struct sieve_trace_config *tr_config, const char *tr_option)
{
if ( strncmp(tr_option, "level=", 6) == 0 ) {
const char *lvl = &tr_option[6];
if ( strcmp(lvl, "none") == 0 ) {
tr_config->level = SIEVE_TRLVL_NONE;
} else if ( strcmp(lvl, "actions") == 0 ) {
tr_config->level = SIEVE_TRLVL_ACTIONS;
} else if ( strcmp(lvl, "commands") == 0 ) {
tr_config->level = SIEVE_TRLVL_COMMANDS;
} else if ( strcmp(lvl, "tests") == 0 ) {
tr_config->level = SIEVE_TRLVL_TESTS;
} else if ( strcmp(lvl, "matching") == 0 ) {
tr_config->level = SIEVE_TRLVL_MATCHING;
} else {
i_fatal_status(EX_USAGE, "Unknown -tlevel= trace level: %s", lvl);
}
} else if ( strcmp(tr_option, "debug") == 0 ) {
tr_config->flags |= SIEVE_TRFLG_DEBUG;
} else if ( strcmp(tr_option, "addresses") == 0 ) {
tr_config->flags |= SIEVE_TRFLG_ADDRESSES;
} else {
i_fatal_status(EX_USAGE, "Unknown -t trace option value: %s", tr_option);
}
}
void doveadm_sieve_cmd_scriptnames_check(const char *const args[])
{
unsigned int i;
for (i = 0; args[i] != NULL; i++) {
if (!uni_utf8_str_is_valid(args[i])) {
i_fatal_status(EX_DATAERR,
"Sieve script name not valid UTF-8: %s", args[i]);
}
if ( !sieve_script_name_is_valid(args[i]) ) {
i_fatal_status(EX_DATAERR,
"Sieve script name not valid: %s", args[i]);
}
}
}
void expunge_search_args_check(struct mail_search_args *args, const char *cmd)
{
if (!expunge_search_args_is_mailbox_ok(args->args)) {
i_fatal_status(EX_USAGE,
"%s: To avoid accidents, search query "
"must contain MAILBOX in all search branches", cmd);
}
if (!expunge_search_args_is_msgset_ok(args->args)) {
i_fatal_status(EX_USAGE,
"%s: To avoid accidents, each branch in search query "
"must contain something else besides MAILBOX "
"(e.g. just add \"all\" if you want everything)", cmd);
}
mail_search_args_simplify(args);
}
static void *pool_system_malloc(pool_t pool ATTR_UNUSED, size_t size)
{
void *mem;
#ifdef DEBUG
int old_errno = errno;
#endif
if (unlikely(size == 0 || size > SSIZE_T_MAX))
i_panic("Trying to allocate %"PRIuSIZE_T" bytes", size);
#ifndef USE_GC
mem = calloc(size, 1);
#else
mem = GC_malloc(size);
#endif
if (unlikely(mem == NULL)) {
i_fatal_status(FATAL_OUTOFMEM, "pool_system_malloc(%"PRIuSIZE_T
"): Out of memory", size);
}
#ifdef DEBUG
/* we rely on errno not changing. it shouldn't. */
i_assert(errno == old_errno);
#endif
return mem;
}
struct ostream *o_stream_create_lzma(struct ostream *output, int level)
{
struct lzma_ostream *zstream;
lzma_ret ret;
i_assert(level >= 1 && level <= 9);
zstream = i_new(struct lzma_ostream, 1);
zstream->ostream.sendv = o_stream_lzma_sendv;
zstream->ostream.flush = o_stream_lzma_flush;
zstream->ostream.iostream.close = o_stream_lzma_close;
ret = lzma_easy_encoder(&zstream->strm, level, LZMA_CHECK_CRC64);
switch (ret) {
case LZMA_OK:
break;
case LZMA_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "lzma: Out of memory");
case LZMA_OPTIONS_ERROR:
i_fatal("lzma: Invalid level");
default:
i_fatal("lzma_easy_encoder() failed with %d", ret);
}
zstream->strm.next_out = zstream->outbuf;
zstream->strm.avail_out = sizeof(zstream->outbuf);
return o_stream_create(&zstream->ostream, output,
o_stream_get_fd(output));
}
static void director_connect(struct director_context *ctx)
{
#define DIRECTOR_HANDSHAKE "VERSION\tdirector-doveadm\t1\t0\n"
const char *line;
int fd;
fd = doveadm_connect(ctx->socket_path);
net_set_nonblock(fd, FALSE);
ctx->input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
director_send(ctx, DIRECTOR_HANDSHAKE);
alarm(5);
line = i_stream_read_next_line(ctx->input);
alarm(0);
if (line == NULL) {
if (ctx->input->stream_errno != 0)
i_fatal("read(%s) failed: %m", ctx->socket_path);
else if (ctx->input->eof)
i_fatal("%s disconnected", ctx->socket_path);
else {
i_fatal("read(%s) timed out (is director configured?)",
ctx->socket_path);
}
}
if (!version_string_verify(line, "director-doveadm", 1)) {
i_fatal_status(EX_PROTOCOL,
"%s not a compatible director-doveadm socket",
ctx->socket_path);
}
}
struct ostream *o_stream_create_bz2(struct ostream *output, int level)
{
struct bzlib_ostream *zstream;
int ret;
i_assert(level >= 1 && level <= 9);
zstream = i_new(struct bzlib_ostream, 1);
zstream->ostream.sendv = o_stream_bzlib_sendv;
zstream->ostream.flush = o_stream_bzlib_flush;
zstream->ostream.iostream.close = o_stream_bzlib_close;
ret = BZ2_bzCompressInit(&zstream->zs, level, 0, 0);
switch (ret) {
case BZ_OK:
break;
case BZ_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM,
"bzlib: Out of memory");
case BZ_CONFIG_ERROR:
i_fatal("Wrong bzlib library version (broken compilation)");
case BZ_PARAM_ERROR:
i_fatal("bzlib: Invalid parameters");
default:
i_fatal("BZ2_bzCompressInit() failed with %d", ret);
}
zstream->zs.next_out = zstream->outbuf;
zstream->zs.avail_out = sizeof(zstream->outbuf);
return o_stream_create(&zstream->ostream, output,
o_stream_get_fd(output));
}
static void status_parse_fields(struct status_cmd_context *ctx,
const char *const *fields)
{
if (*fields == NULL)
i_fatal_status(EX_USAGE, "No status fields");
for (; *fields != NULL; fields++) {
const char *field = *fields;
if (strcmp(field, "all") == 0) {
if (ctx->total_sum) {
ctx->status_items |= TOTAL_STATUS_ITEMS;
ctx->metadata_items |= TOTAL_METADATA_ITEMS;
} else {
ctx->status_items |= ALL_STATUS_ITEMS;
ctx->metadata_items |= ALL_METADATA_ITEMS;
}
} else if (strcmp(field, "messages") == 0)
ctx->status_items |= STATUS_MESSAGES;
else if (strcmp(field, "recent") == 0)
ctx->status_items |= STATUS_RECENT;
else if (strcmp(field, "uidnext") == 0)
ctx->status_items |= STATUS_UIDNEXT;
else if (strcmp(field, "uidvalidity") == 0)
ctx->status_items |= STATUS_UIDVALIDITY;
else if (strcmp(field, "unseen") == 0)
ctx->status_items |= STATUS_UNSEEN;
else if (strcmp(field, "highestmodseq") == 0)
ctx->status_items |= STATUS_HIGHESTMODSEQ;
else if (strcmp(field, "vsize") == 0)
ctx->metadata_items |= MAILBOX_METADATA_VIRTUAL_SIZE;
else if (strcmp(field, "guid") == 0)
ctx->metadata_items |= MAILBOX_METADATA_GUID;
else {
i_fatal_status(EX_USAGE,
"Unknown status field: %s", field);
}
if (ctx->total_sum &&
((ctx->status_items & ~TOTAL_STATUS_ITEMS) != 0 ||
(ctx->metadata_items & ~TOTAL_METADATA_ITEMS) != 0)) {
i_fatal_status(EX_USAGE,
"Status field %s can't be used with -t", field);
}
}
}
static int o_stream_lzma_send_flush(struct lzma_ostream *zstream)
{
lzma_stream *zs = &zstream->strm;
unsigned int len;
bool done = FALSE;
int ret;
if (zs->avail_in != 0) {
i_assert(zstream->ostream.ostream.last_failed_errno != 0);
zstream->ostream.ostream.stream_errno =
zstream->ostream.ostream.last_failed_errno;
return -1;
}
if (zstream->flushed)
return 0;
if ((ret = o_stream_flush_parent_if_needed(&zstream->ostream)) <= 0)
return ret;
if ((ret = o_stream_zlib_send_outbuf(zstream)) <= 0)
return ret;
i_assert(zstream->outbuf_used == 0);
do {
ret = lzma_code(zs, LZMA_FINISH);
switch (ret) {
case LZMA_OK:
break;
case LZMA_STREAM_END:
done = TRUE;
break;
case LZMA_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM,
"lzma.write(%s): Out of memory",
o_stream_get_name(&zstream->ostream.ostream));
default:
i_panic("lzma.write(%s) flush failed with unexpected code %d",
o_stream_get_name(&zstream->ostream.ostream), ret);
}
if (zs->avail_out == 0 || done) {
len = sizeof(zstream->outbuf) - zs->avail_out;
zs->next_out = zstream->outbuf;
zs->avail_out = sizeof(zstream->outbuf);
zstream->outbuf_used = len;
if ((ret = o_stream_zlib_send_outbuf(zstream)) <= 0)
return ret;
}
} while (!done);
zstream->flushed = TRUE;
return 0;
}
static void i_stream_lzma_init(struct lzma_istream *zstream)
{
lzma_ret ret;
ret = lzma_stream_decoder(&zstream->strm, LZMA_MEMORY_LIMIT,
LZMA_CONCATENATED);
switch (ret) {
case LZMA_OK:
break;
case LZMA_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "lzma: Out of memory");
default:
i_fatal("lzma_stream_decoder() failed with ret=%d", ret);
}
}
static ssize_t
o_stream_lzma_send_chunk(struct lzma_ostream *zstream,
const void *data, size_t size)
{
lzma_stream *zs = &zstream->strm;
int ret;
i_assert(zstream->outbuf_used == 0);
zs->next_in = (void *)data;
zs->avail_in = size;
while (zs->avail_in > 0) {
if (zs->avail_out == 0) {
/* previous block was compressed. send it and start
compression for a new block. */
zs->next_out = zstream->outbuf;
zs->avail_out = sizeof(zstream->outbuf);
zstream->outbuf_used = sizeof(zstream->outbuf);
if ((ret = o_stream_zlib_send_outbuf(zstream)) < 0)
return -1;
if (ret == 0) {
/* parent stream's buffer full */
break;
}
}
ret = lzma_code(zs, LZMA_RUN);
switch (ret) {
case LZMA_OK:
break;
case LZMA_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM,
"lzma.write(%s): Out of memory",
o_stream_get_name(&zstream->ostream.ostream));
default:
i_panic("lzma.write(%s) failed with unexpected code %d",
o_stream_get_name(&zstream->ostream.ostream), ret);
}
}
size -= zs->avail_in;
zstream->flushed = FALSE;
return size;
}
static void *pool_system_malloc(pool_t pool ATTR_UNUSED, size_t size)
{
void *mem;
if (unlikely(size == 0 || size > SSIZE_T_MAX))
i_panic("Trying to allocate %"PRIuSIZE_T" bytes", size);
#ifndef USE_GC
mem = calloc(size, 1);
#else
mem = GC_malloc(size);
#endif
if (unlikely(mem == NULL)) {
i_fatal_status(FATAL_OUTOFMEM, "pool_system_malloc(%"PRIuSIZE_T
"): Out of memory", size);
}
return mem;
}
static void i_stream_bzlib_init(struct bzlib_istream *zstream)
{
int ret;
ret = BZ2_bzDecompressInit(&zstream->zs, 0, 0);
switch (ret) {
case BZ_OK:
break;
case BZ_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "bzlib: Out of memory");
case BZ_CONFIG_ERROR:
i_fatal("Wrong bzlib library version (broken compilation)");
case BZ_PARAM_ERROR:
i_fatal("bzlib: Invalid parameters");
default:
i_fatal("BZ2_bzDecompressInit() failed with %d", ret);
}
}
unsigned int t_push(void)
{
struct stack_frame_block *frame_block;
frame_pos++;
if (frame_pos == BLOCK_FRAME_COUNT) {
/* frame block full */
if (data_stack_frame == 0) {
/* kludgy, but allow this before initialization */
frame_pos = 0;
data_stack_init();
return t_push();
}
frame_pos = 0;
if (unused_frame_blocks == NULL) {
/* allocate new block */
#ifndef USE_GC
frame_block = calloc(sizeof(*frame_block), 1);
#else
frame_block = GC_malloc(sizeof(*frame_block));
#endif
if (frame_block == NULL) {
i_fatal_status(FATAL_OUTOFMEM,
"t_push(): Out of memory");
}
} else {
/* use existing unused frame_block */
frame_block = unused_frame_blocks;
unused_frame_blocks = unused_frame_blocks->prev;
}
frame_block->prev = current_frame_block;
current_frame_block = frame_block;
}
data_stack_last_buffer_reset(FALSE);
/* mark our current position */
current_frame_block->block[frame_pos] = current_block;
current_frame_block->block_space_used[frame_pos] = current_block->left;
current_frame_block->last_alloc_size[frame_pos] = 0;
return data_stack_frame++;
}
int solr_connection_init(const char *url, bool debug,
struct solr_connection **conn_r, const char **error_r)
{
struct http_client_settings http_set;
struct solr_connection *conn;
struct http_url *http_url;
const char *error;
if (http_url_parse(url, NULL, 0, pool_datastack_create(),
&http_url, &error) < 0) {
*error_r = t_strdup_printf(
"fts_solr: Failed to parse HTTP url: %s", error);
return -1;
}
conn = i_new(struct solr_connection, 1);
conn->http_host = i_strdup(http_url->host.name);
conn->http_port = http_url->port;
conn->http_base_url = i_strconcat(http_url->path, http_url->enc_query, NULL);
conn->http_ssl = http_url->have_ssl;
conn->debug = debug;
if (solr_http_client == NULL) {
memset(&http_set, 0, sizeof(http_set));
http_set.max_idle_time_msecs = 5*1000;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
http_set.max_redirects = 1;
http_set.max_attempts = 3;
http_set.debug = debug;
http_set.connect_timeout_msecs = 5*1000;
http_set.request_timeout_msecs = 60*1000;
solr_http_client = http_client_init(&http_set);
}
conn->xml_parser = XML_ParserCreate("UTF-8");
if (conn->xml_parser == NULL) {
i_fatal_status(FATAL_OUTOFMEM,
"fts_solr: Failed to allocate XML parser");
}
*conn_r = conn;
return 0;
}
const char *openssl_iostream_error(void)
{
unsigned long err;
char *buf;
size_t err_size = 256;
err = ERR_get_error();
if (err == 0) {
if (errno != 0)
return strerror(errno);
return "Unknown error";
}
if (ERR_GET_REASON(err) == ERR_R_MALLOC_FAILURE)
i_fatal_status(FATAL_OUTOFMEM, "OpenSSL malloc() failed");
buf = t_malloc(err_size);
buf[err_size-1] = '\0';
ERR_error_string_n(err, buf, err_size-1);
return buf;
}
static void i_stream_zlib_init(struct zlib_istream *zstream)
{
int ret;
ret = inflateInit2(&zstream->zs, -15);
switch (ret) {
case Z_OK:
break;
case Z_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "zlib: Out of memory");
case Z_VERSION_ERROR:
i_fatal("Wrong zlib library version (broken compilation)");
case Z_STREAM_ERROR:
i_fatal("zlib: Invalid parameters");
default:
i_fatal("inflateInit() failed with %d", ret);
}
zstream->header_read = !zstream->gz;
zstream->trailer_read = !zstream->gz;
}
static struct ostream *
o_stream_create_zlib(struct ostream *output, int level, bool gz)
{
const int strategy = Z_DEFAULT_STRATEGY;
struct zlib_ostream *zstream;
int ret;
i_assert(level >= 1 && level <= 9);
zstream = i_new(struct zlib_ostream, 1);
zstream->ostream.sendv = o_stream_zlib_sendv;
zstream->ostream.cork = o_stream_zlib_cork;
zstream->ostream.flush = o_stream_zlib_flush;
zstream->ostream.iostream.close = o_stream_zlib_close;
zstream->output = output;
zstream->crc = 0;
zstream->gz = gz;
if (!gz)
zstream->header_sent = TRUE;
o_stream_ref(output);
o_stream_zlib_init_gz_header(zstream, level, strategy);
ret = deflateInit2(&zstream->zs, level, Z_DEFLATED, -15, 8, strategy);
switch (ret) {
case Z_OK:
break;
case Z_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "deflateInit(): Out of memory");
case Z_VERSION_ERROR:
i_fatal("Wrong zlib library version (broken compilation)");
case Z_STREAM_ERROR:
i_fatal("Invalid compression level %d", level);
default:
i_fatal("deflateInit() failed with %d", ret);
}
zstream->zs.next_out = zstream->outbuf;
zstream->zs.avail_out = sizeof(zstream->outbuf);
return o_stream_create(&zstream->ostream);
}
int sieve_tool_getopt(struct sieve_tool *tool)
{
int c;
while ( (c = master_getopt(master_service)) > 0 ) {
switch ( c ) {
case 'x':
/* extensions */
if ( tool->sieve_extensions != NULL ) {
i_fatal_status(EX_USAGE,
"duplicate -x option specified, but only one allowed.");
}
tool->sieve_extensions = i_strdup(optarg);
break;
case 'u':
if ( tool->username == NULL )
tool->username = i_strdup(optarg);
break;
case 'P':
/* Plugin */
{
const char *plugin;
plugin = t_strdup(optarg);
array_append(&tool->sieve_plugins, &plugin, 1);
}
break;
case 'D':
tool->debug = TRUE;
break;
default:
return c;
}
}
return c;
}
static void
cmd_mailbox_metadata_parse_key(const char *arg,
enum mail_attribute_type *type_r,
const char **key_r)
{
arg = t_str_lcase(arg);
if (strncmp(arg, "/private/", 9) == 0) {
*type_r = MAIL_ATTRIBUTE_TYPE_PRIVATE;
*key_r = arg + 9;
} else if (strncmp(arg, "/shared/", 8) == 0) {
*type_r = MAIL_ATTRIBUTE_TYPE_SHARED;
*key_r = arg + 8;
} else if (strcmp(arg, "/private") == 0) {
*type_r = MAIL_ATTRIBUTE_TYPE_PRIVATE;
*key_r = "";
} else if (strcmp(arg, "/shared") == 0) {
*type_r = MAIL_ATTRIBUTE_TYPE_SHARED;
*key_r = "";
} else {
i_fatal_status(EX_USAGE, "Invalid metadata key '%s': "
"Must begin with /private or /shared", arg);
}
}
static int
fts_filter_stemmer_snowball_filter(struct fts_filter *filter,
const char **token, const char **error_r)
{
struct fts_filter_stemmer_snowball *sp =
(struct fts_filter_stemmer_snowball *) filter;
const sb_symbol *base;
if (sp->stemmer == NULL) {
if (fts_filter_stemmer_snowball_create_stemmer(sp, error_r) < 0)
return -1;
}
base = sb_stemmer_stem(sp->stemmer, (const unsigned char *)*token, strlen(*token));
if (base == NULL) {
/* the only reason why this could fail is because of
out of memory. */
i_fatal_status(FATAL_OUTOFMEM,
"sb_stemmer_stem(len=%"PRIuSIZE_T") failed: "
"Out of memory", strlen(*token));
}
*token = t_strndup(base, sb_stemmer_length(sp->stemmer));
return 1;
}
static ssize_t i_stream_bzlib_read(struct istream_private *stream)
{
struct bzlib_istream *zstream = (struct bzlib_istream *)stream;
const unsigned char *data;
uoff_t high_offset;
size_t size;
int ret;
high_offset = stream->istream.v_offset + (stream->pos - stream->skip);
if (zstream->eof_offset == high_offset) {
i_assert(zstream->high_pos == 0 ||
zstream->high_pos == stream->pos);
stream->istream.eof = TRUE;
return -1;
}
if (stream->pos < zstream->high_pos) {
/* we're here because we seeked back within the read buffer. */
ret = zstream->high_pos - stream->pos;
stream->pos = zstream->high_pos;
zstream->high_pos = 0;
if (zstream->eof_offset != (uoff_t)-1) {
high_offset = stream->istream.v_offset +
(stream->pos - stream->skip);
i_assert(zstream->eof_offset == high_offset);
stream->istream.eof = TRUE;
}
return ret;
}
zstream->high_pos = 0;
if (stream->pos + CHUNK_SIZE > stream->buffer_size) {
/* try to keep at least CHUNK_SIZE available */
if (!zstream->marked && stream->skip > 0) {
/* don't try to keep anything cached if we don't
have a seek mark. */
i_stream_compress(stream);
}
if (stream->max_buffer_size == 0 ||
stream->buffer_size < stream->max_buffer_size)
i_stream_grow_buffer(stream, CHUNK_SIZE);
if (stream->pos == stream->buffer_size) {
if (stream->skip > 0) {
/* lose our buffer cache */
i_stream_compress(stream);
}
if (stream->pos == stream->buffer_size)
return -2; /* buffer full */
}
}
if (zstream->zs.avail_in == 0) {
/* need to read more data. try to read a full CHUNK_SIZE */
i_stream_skip(stream->parent, zstream->prev_size);
if (i_stream_read_data(stream->parent, &data, &size,
CHUNK_SIZE-1) == -1 && size == 0) {
if (stream->parent->stream_errno != 0) {
stream->istream.stream_errno =
stream->parent->stream_errno;
} else {
i_assert(stream->parent->eof);
if (zstream->log_errors) {
bzlib_read_error(zstream,
"unexpected EOF");
}
stream->istream.stream_errno = EINVAL;
}
return -1;
}
zstream->prev_size = size;
if (size == 0) {
/* no more input */
i_assert(!stream->istream.blocking);
return 0;
}
zstream->zs.next_in = (char *)data;
zstream->zs.avail_in = size;
}
size = stream->buffer_size - stream->pos;
zstream->zs.next_out = (char *)stream->w_buffer + stream->pos;
zstream->zs.avail_out = size;
ret = BZ2_bzDecompress(&zstream->zs);
size -= zstream->zs.avail_out;
stream->pos += size;
switch (ret) {
case BZ_OK:
break;
case BZ_PARAM_ERROR:
i_unreached();
case BZ_DATA_ERROR:
if (zstream->log_errors)
bzlib_read_error(zstream, "corrupted data");
stream->istream.stream_errno = EINVAL;
return -1;
case BZ_DATA_ERROR_MAGIC:
if (zstream->log_errors) {
bzlib_read_error(zstream,
"wrong magic in header (not bz2 file?)");
}
stream->istream.stream_errno = EINVAL;
return -1;
case BZ_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "bzlib.read(%s): Out of memory",
i_stream_get_name(&stream->istream));
case BZ_STREAM_END:
zstream->eof_offset = stream->istream.v_offset +
(stream->pos - stream->skip);
if (size == 0) {
stream->istream.eof = TRUE;
return -1;
}
break;
default:
i_fatal("BZ2_bzDecompress() failed with %d", ret);
}
if (size == 0) {
/* read more input */
return i_stream_bzlib_read(stream);
}
return size;
}
void execv_const(const char *path, const char *const argv[])
{
(void)execv(path, argv_drop_const(argv));
i_fatal_status(errno == ENOMEM ? FATAL_OUTOFMEM : FATAL_EXEC,
"execv(%s) failed: %m", path);
}
void execvp_const(const char *file, const char *const argv[])
{
(void)execvp(file, argv_drop_const(argv));
i_fatal_status(errno == ENOMEM ? FATAL_OUTOFMEM : FATAL_EXEC,
"execvp(%s) failed: %m", file);
}
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;
}
int main(int argc, char *argv[])
{
static const struct setting_parser_info *set_roots[] = {
&imap_urlauth_worker_setting_parser_info,
NULL
};
enum master_service_flags service_flags = 0;
enum mail_storage_service_flags storage_service_flags =
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP |
MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT;
ARRAY_TYPE (const_string) access_apps;
const char *access_user = NULL;
int c;
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("imap-urlauth-worker", service_flags,
&argc, &argv, "a:");
t_array_init(&access_apps, 4);
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 'a': {
const char *app = t_strdup(optarg);
array_append(&access_apps, &app, 1);
break;
}
default:
return FATAL_DEFAULT;
}
}
if ( optind < argc ) {
access_user = argv[optind++];
}
if (optind != argc) {
i_fatal_status(EX_USAGE, "Unknown argument: %s", argv[optind]);
}
master_service_init_log(master_service,
t_strdup_printf("imap-urlauth[%s]: ", my_pid));
master_service_init_finish(master_service);
master_service_set_die_callback(master_service, imap_urlauth_worker_die);
random_init();
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 {
if (array_count(&access_apps) > 0) {
(void)array_append_space(&access_apps);
main_stdio_run(access_user, array_idx(&access_apps,0));
} else {
main_stdio_run(access_user, NULL);
}
} T_END;
} else {
static ssize_t i_stream_zlib_read(struct istream_private *stream)
{
struct zlib_istream *zstream = (struct zlib_istream *)stream;
const unsigned char *data;
uoff_t high_offset;
size_t size, out_size;
int ret;
high_offset = stream->istream.v_offset + (stream->pos - stream->skip);
if (zstream->eof_offset == high_offset) {
i_assert(zstream->high_pos == 0 ||
zstream->high_pos == stream->pos);
if (!zstream->trailer_read) {
do {
ret = i_stream_zlib_read_trailer(zstream);
} while (ret == 0 && stream->istream.blocking);
if (ret <= 0)
return ret;
}
if (!zstream->gz || i_stream_is_eof(stream->parent)) {
stream->istream.eof = TRUE;
return -1;
}
/* gzip file with concatenated content */
zstream->eof_offset = (uoff_t)-1;
zstream->stream_size = (uoff_t)-1;
zstream->header_read = FALSE;
zstream->trailer_read = FALSE;
zstream->crc32 = 0;
(void)inflateEnd(&zstream->zs);
i_stream_zlib_init(zstream);
}
if (!zstream->header_read) {
do {
ret = i_stream_zlib_read_header(stream);
} while (ret == 0 && stream->istream.blocking);
if (ret <= 0)
return ret;
zstream->header_read = TRUE;
}
if (stream->pos < zstream->high_pos) {
/* we're here because we seeked back within the read buffer. */
ret = zstream->high_pos - stream->pos;
stream->pos = zstream->high_pos;
zstream->high_pos = 0;
if (zstream->trailer_read) {
high_offset = stream->istream.v_offset +
(stream->pos - stream->skip);
i_assert(zstream->eof_offset == high_offset);
stream->istream.eof = TRUE;
}
return ret;
}
zstream->high_pos = 0;
if (stream->pos + CHUNK_SIZE > stream->buffer_size) {
/* try to keep at least CHUNK_SIZE available */
if (!zstream->marked && stream->skip > 0) {
/* don't try to keep anything cached if we don't
have a seek mark. */
i_stream_compress(stream);
}
if (stream->buffer_size < i_stream_get_max_buffer_size(&stream->istream))
i_stream_grow_buffer(stream, CHUNK_SIZE);
if (stream->pos == stream->buffer_size) {
if (stream->skip > 0) {
/* lose our buffer cache */
i_stream_compress(stream);
}
if (stream->pos == stream->buffer_size)
return -2; /* buffer full */
}
}
if (i_stream_read_more(stream->parent, &data, &size) < 0) {
if (stream->parent->stream_errno != 0) {
stream->istream.stream_errno =
stream->parent->stream_errno;
} else {
i_assert(stream->parent->eof);
zlib_read_error(zstream, "unexpected EOF");
stream->istream.stream_errno = EPIPE;
}
return -1;
}
if (size == 0) {
/* no more input */
i_assert(!stream->istream.blocking);
return 0;
}
zstream->zs.next_in = (void *)data;
zstream->zs.avail_in = size;
out_size = stream->buffer_size - stream->pos;
zstream->zs.next_out = stream->w_buffer + stream->pos;
zstream->zs.avail_out = out_size;
ret = inflate(&zstream->zs, Z_SYNC_FLUSH);
out_size -= zstream->zs.avail_out;
zstream->crc32 = crc32_data_more(zstream->crc32,
stream->w_buffer + stream->pos,
out_size);
stream->pos += out_size;
i_stream_skip(stream->parent, size - zstream->zs.avail_in);
switch (ret) {
case Z_OK:
break;
case Z_NEED_DICT:
zlib_read_error(zstream, "can't read file without dict");
stream->istream.stream_errno = EINVAL;
return -1;
case Z_DATA_ERROR:
zlib_read_error(zstream, "corrupted data");
stream->istream.stream_errno = EINVAL;
return -1;
case Z_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "zlib.read(%s): Out of memory",
i_stream_get_name(&stream->istream));
case Z_STREAM_END:
zstream->eof_offset = stream->istream.v_offset +
(stream->pos - stream->skip);
zstream->stream_size = zstream->eof_offset;
zstream->zs.avail_in = 0;
if (!zstream->trailer_read) {
/* try to read and verify the trailer, we might not
be called again. */
if (i_stream_zlib_read_trailer(zstream) < 0)
return -1;
}
break;
default:
i_fatal("inflate() failed with %d", ret);
}
if (out_size == 0) {
/* read more input */
return i_stream_zlib_read(stream);
}
return out_size;
}
static ssize_t i_stream_lzma_read(struct istream_private *stream)
{
struct lzma_istream *zstream = (struct lzma_istream *)stream;
const unsigned char *data;
uoff_t high_offset;
size_t size, out_size;
lzma_ret ret;
high_offset = stream->istream.v_offset + (stream->pos - stream->skip);
if (zstream->eof_offset == high_offset) {
i_assert(zstream->high_pos == 0 ||
zstream->high_pos == stream->pos);
stream->istream.eof = TRUE;
return -1;
}
if (stream->pos < zstream->high_pos) {
/* we're here because we seeked back within the read buffer. */
ret = zstream->high_pos - stream->pos;
stream->pos = zstream->high_pos;
zstream->high_pos = 0;
if (zstream->eof_offset != (uoff_t)-1) {
high_offset = stream->istream.v_offset +
(stream->pos - stream->skip);
i_assert(zstream->eof_offset == high_offset);
stream->istream.eof = TRUE;
}
return ret;
}
zstream->high_pos = 0;
if (stream->pos + CHUNK_SIZE > stream->buffer_size) {
/* try to keep at least CHUNK_SIZE available */
if (!zstream->marked && stream->skip > 0) {
/* don't try to keep anything cached if we don't
have a seek mark. */
i_stream_compress(stream);
}
if (stream->buffer_size < i_stream_get_max_buffer_size(&stream->istream))
i_stream_grow_buffer(stream, CHUNK_SIZE);
if (stream->pos == stream->buffer_size) {
if (stream->skip > 0) {
/* lose our buffer cache */
i_stream_compress(stream);
}
if (stream->pos == stream->buffer_size)
return -2; /* buffer full */
}
}
if (i_stream_read_more(stream->parent, &data, &size) < 0) {
if (stream->parent->stream_errno != 0) {
stream->istream.stream_errno =
stream->parent->stream_errno;
} else {
i_assert(stream->parent->eof);
lzma_stream_end(zstream);
stream->istream.eof = TRUE;
}
return -1;
}
if (size == 0) {
/* no more input */
i_assert(!stream->istream.blocking);
return 0;
}
zstream->strm.next_in = data;
zstream->strm.avail_in = size;
out_size = stream->buffer_size - stream->pos;
zstream->strm.next_out = stream->w_buffer + stream->pos;
zstream->strm.avail_out = out_size;
ret = lzma_code(&zstream->strm, LZMA_RUN);
out_size -= zstream->strm.avail_out;
stream->pos += out_size;
i_stream_skip(stream->parent, size - zstream->strm.avail_in);
switch (ret) {
case LZMA_OK:
break;
case LZMA_DATA_ERROR:
case LZMA_BUF_ERROR:
lzma_read_error(zstream, "corrupted data");
stream->istream.stream_errno = EINVAL;
return -1;
case LZMA_FORMAT_ERROR:
lzma_read_error(zstream, "wrong magic in header (not xz file?)");
stream->istream.stream_errno = EINVAL;
return -1;
case LZMA_OPTIONS_ERROR:
lzma_read_error(zstream, "Unsupported xz options");
stream->istream.stream_errno = EINVAL;
return -1;
case LZMA_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "lzma.read(%s): Out of memory",
i_stream_get_name(&stream->istream));
case LZMA_STREAM_END:
lzma_stream_end(zstream);
if (out_size == 0) {
stream->istream.eof = TRUE;
return -1;
}
break;
default:
lzma_read_error(zstream, t_strdup_printf(
"lzma_code() failed with %d", ret));
stream->istream.stream_errno = EINVAL;
return -1;
}
if (out_size == 0) {
/* read more input */
return i_stream_lzma_read(stream);
}
return out_size;
}
static int
pam_userpass_conv(int num_msg, pam_const struct pam_message **msg,
struct pam_response **resp_r, void *appdata_ptr)
{
/* @UNSAFE */
struct pam_conv_context *ctx = appdata_ptr;
struct passdb_module *_passdb = ctx->request->passdb->passdb;
struct pam_passdb_module *passdb = (struct pam_passdb_module *)_passdb;
struct pam_response *resp;
char *string;
int i;
*resp_r = NULL;
resp = calloc(num_msg, sizeof(struct pam_response));
if (resp == NULL)
i_fatal_status(FATAL_OUTOFMEM, "Out of memory");
for (i = 0; i < num_msg; i++) {
auth_request_log_debug(ctx->request, "pam",
"#%d/%d style=%d msg=%s", i+1, num_msg,
msg[i]->msg_style,
msg[i]->msg != NULL ? msg[i]->msg : "");
switch (msg[i]->msg_style) {
case PAM_PROMPT_ECHO_ON:
/* Assume we're asking for user. We might not ever
get here because PAM already knows the user. */
string = strdup(ctx->request->user);
if (string == NULL)
i_fatal_status(FATAL_OUTOFMEM, "Out of memory");
break;
case PAM_PROMPT_ECHO_OFF:
/* Assume we're asking for password */
if (passdb->failure_show_msg)
ctx->failure_msg = t_strdup(msg[i]->msg);
string = strdup(ctx->pass);
if (string == NULL)
i_fatal_status(FATAL_OUTOFMEM, "Out of memory");
break;
case PAM_ERROR_MSG:
case PAM_TEXT_INFO:
string = NULL;
break;
default:
while (--i >= 0) {
if (resp[i].resp != NULL) {
safe_memset(resp[i].resp, 0,
strlen(resp[i].resp));
free(resp[i].resp);
}
}
free(resp);
return PAM_CONV_ERR;
}
resp[i].resp_retcode = PAM_SUCCESS;
resp[i].resp = string;
}
*resp_r = resp;
return PAM_SUCCESS;
}