static void
solr_add_ns_query_http(string_t *str, struct solr_fts_backend *backend,
struct mail_namespace *ns)
{
string_t *tmp;
tmp = t_str_new(64);
solr_add_ns_query(tmp, backend, ns, FALSE);
http_url_escape_param(str, str_c(tmp));
}
static void test_str_append(void)
{
string_t *str = t_str_new(32);
string_t *str2 = t_str_new(32);
test_begin("str_append_*()");
str_append(str, "foo");
str_append_c(str, '|');
str_append_c(str, '\0');
test_assert(str->used == 5 && memcmp(str_data(str), "foo|\0", 5) == 0);
str_append(str2, "sec");
str_append_c(str2, '\0');
str_append(str2, "ond");
str_append_str(str, str2);
test_assert(str->used == 5+7 && memcmp(str_data(str), "foo|\0sec\0ond", 5+7) == 0);
test_end();
}
int rfc822_parse_content_param(struct rfc822_parser_context *ctx,
const char **key_r, const char **value_r)
{
string_t *tmp;
size_t value_pos;
int ret;
/* .. := *(";" parameter)
parameter := attribute "=" value
attribute := token
value := token / quoted-string
*/
*key_r = NULL;
*value_r = NULL;
if (ctx->data == ctx->end)
return 0;
if (*ctx->data != ';')
return -1;
ctx->data++;
if (rfc822_skip_lwsp(ctx) <= 0)
return -1;
tmp = t_str_new(64);
if (rfc822_parse_mime_token(ctx, tmp) <= 0)
return -1;
str_append_c(tmp, '\0');
value_pos = str_len(tmp);
if (*ctx->data != '=')
return -1;
ctx->data++;
if ((ret = rfc822_skip_lwsp(ctx)) <= 0) {
/* broken / no value */
} else if (*ctx->data == '"') {
ret = rfc822_parse_quoted_string(ctx, tmp);
} else if (ctx->data != ctx->end && *ctx->data == '=') {
/* workaround for broken input:
name==?utf-8?b?...?= */
while (ctx->data != ctx->end && *ctx->data != ';' &&
*ctx->data != ' ' && *ctx->data != '\t' &&
*ctx->data != '\r' && *ctx->data != '\n') {
str_append_c(tmp, *ctx->data);
ctx->data++;
}
} else {
ret = rfc822_parse_mime_token(ctx, tmp);
}
*key_r = str_c(tmp);
*value_r = *key_r + value_pos;
return ret < 0 ? -1 : 1;
}
static void test_json_append_escaped_data(void)
{
static const unsigned char test_input[] =
"\b\f\r\n\t\"\\\000\001\002-\xC3\xA4";
string_t *str = t_str_new(32);
test_begin("json_append_escaped()");
json_append_escaped_data(str, test_input, sizeof(test_input)-1);
test_assert(strcmp(str_c(str), "\\b\\f\\r\\n\\t\\\"\\\\\\u0000\\u0001\\u0002-\xC3\xA4") == 0);
test_end();
}
void test_str_sanitize(void)
{
static struct str_sanitize_test tests[] = {
{ NULL, 2, NULL },
{ "", 2, NULL },
{ "a", 2, NULL },
{ "ab", 2, NULL },
{ "abc", 2, "..." },
{ "abcd", 3, "..." },
{ "abcde", 4, "a..." },
{ "\xD1\x81", 1, "..." },
{ "\xD1\x81", 2, "\xD1\x81" },
{ "\xD1\x81", 3, NULL },
{ "\xC3\xA4\xC3\xA4zyxa", 1, "..." },
{ "\xC3\xA4\xC3\xA4zyxa", 2, "..." },
{ "\xC3\xA4\xC3\xA4zyxa", 3, "..." },
{ "\xC3\xA4\xC3\xA4zyxa", 4, "..." },
{ "\xC3\xA4\xC3\xA4zyxa", 5, "\xC3\xA4..." },
{ "\xC3\xA4\xC3\xA4zyxa", 6, "\xC3\xA4..." },
{ "\xC3\xA4\xC3\xA4zyxa", 7, "\xC3\xA4\xC3\xA4..." },
{ "\xC3\xA4\xC3\xA4zyxa", 8, "\xC3\xA4\xC3\xA4zyxa" },
{ "\001x\x1fy\x81", 10, "?x?y?" }
};
const char *str;
string_t *str2;
unsigned int i;
test_begin("str_sanitize");
for (i = 0; i < N_ELEMENTS(tests); i++) {
str = str_sanitize(tests[i].str, tests[i].max_len);
if (tests[i].sanitized != NULL)
test_assert_idx(null_strcmp(str, tests[i].sanitized) == 0, i);
else
test_assert_idx(str == tests[i].str, i);
}
test_end();
test_begin("str_sanitize_append");
str2 = t_str_new(128);
for (i = 0; i < N_ELEMENTS(tests); i++) {
if (tests[i].str == NULL)
continue;
str_truncate(str2, 0);
str_append(str2, "1234567890");
str_sanitize_append(str2, tests[i].str, tests[i].max_len);
test_assert_idx(strncmp(str_c(str2), "1234567890", 10) == 0, i);
if (tests[i].sanitized != NULL)
test_assert_idx(strcmp(str_c(str2)+10, tests[i].sanitized) == 0, i);
else
test_assert_idx(strcmp(str_c(str2)+10, tests[i].str) == 0, i);
}
test_end();
}
const char *
checkpassword_get_cmd(struct auth_request *request, const char *args,
const char *checkpassword_reply_path)
{
string_t *str;
str = t_str_new(256);
var_expand(str, args,
auth_request_get_var_expand_table(request, NULL));
return t_strconcat(str_c(str), " ", checkpassword_reply_path, NULL);
}
void stats_connection_disconnect(struct stats_connection *conn,
struct mail_user *user)
{
struct stats_user *suser = STATS_USER_CONTEXT(user);
string_t *str = t_str_new(128);
str_append(str, "DISCONNECT\t");
str_append(str, guid_128_to_string(suser->session_guid));
str_append_c(str, '\n');
stats_connection_send(conn, str);
}
int http_parse_quoted_string(struct http_parser *parser, const char **str_r)
{
string_t *str;
/* quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
qdtext = HTAB / SP / "!" / %x23-5B ; '#'-'['
/ %x5D-7E ; ']'-'~'
/ obs-text
quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
obs-text = %x80-FF
*/
/* DQUOTE */
if (parser->cur >= parser->end || parser->cur[0] != '"')
return 0;
parser->cur++;
/* *( qdtext / quoted-pair ) */
str = t_str_new(256);
for (;;) {
const unsigned char *first;
/* *qdtext */
first = parser->cur;
while (parser->cur < parser->end && http_char_is_qdtext(*parser->cur))
parser->cur++;
if (parser->cur >= parser->end)
return -1;
str_append_data(str, first, parser->cur - first);
/* DQUOTE */
if (*parser->cur == '"') {
parser->cur++;
break;
/* "\" */
} else if (*parser->cur == '\\') {
parser->cur++;
if (parser->cur >= parser->end || !http_char_is_text(*parser->cur))
return -1;
str_append_c(str, *parser->cur);
parser->cur++;
/* ERROR */
} else {
return -1;
}
}
*str_r = str_c(str);
return 1;
}
static void passwd_file_lookup(struct auth_request *auth_request,
userdb_callback_t *callback)
{
struct userdb_module *_module = auth_request->userdb->userdb;
struct passwd_file_userdb_module *module =
(struct passwd_file_userdb_module *)_module;
struct passwd_user *pu;
const struct var_expand_table *table;
string_t *str;
const char *key, *value;
char **p;
pu = db_passwd_file_lookup(module->pwf, auth_request,
module->username_format);
if (pu == NULL || pu->uid == 0) {
callback(USERDB_RESULT_USER_UNKNOWN, auth_request);
return;
}
auth_request_init_userdb_reply(auth_request);
if (pu->uid != (uid_t)-1) {
auth_request_set_userdb_field(auth_request, "uid",
dec2str(pu->uid));
}
if (pu->gid != (gid_t)-1) {
auth_request_set_userdb_field(auth_request, "gid",
dec2str(pu->gid));
}
if (pu->home != NULL)
auth_request_set_userdb_field(auth_request, "home", pu->home);
if (pu->extra_fields != NULL) {
str = t_str_new(512);
table = auth_request_get_var_expand_table(auth_request, NULL);
for (p = pu->extra_fields; *p != NULL; p++) {
if (strncmp(*p, "userdb_", 7) != 0)
continue;
key = *p + 7;
value = strchr(key, '=');
if (value != NULL) {
key = t_strdup_until(key, value);
str_truncate(str, 0);
var_expand(str, value + 1, table);
value = str_c(str);
}
auth_request_set_userdb_field(auth_request, key, value);
}
}
callback(USERDB_RESULT_OK, auth_request);
}
static int
replication_fifo_notify(struct mail_user *user,
enum replication_priority priority)
{
string_t *str;
ssize_t ret;
if (fifo_failed)
return -1;
if (fifo_fd == -1) {
fifo_fd = open(fifo_path, O_WRONLY | O_NONBLOCK);
if (fifo_fd == -1) {
i_error("open(%s) failed: %m", fifo_path);
fifo_failed = TRUE;
return -1;
}
}
/* <username> \t <priority> */
str = t_str_new(256);
str_append_tabescaped(str, user->username);
str_append_c(str, '\t');
switch (priority) {
case REPLICATION_PRIORITY_NONE:
case REPLICATION_PRIORITY_SYNC:
i_unreached();
case REPLICATION_PRIORITY_LOW:
str_append(str, "low");
break;
case REPLICATION_PRIORITY_HIGH:
str_append(str, "high");
break;
}
str_append_c(str, '\n');
ret = write(fifo_fd, str_data(str), str_len(str));
i_assert(ret != 0);
if (ret != (ssize_t)str_len(str)) {
if (ret > 0)
i_error("write(%s) wrote partial data", fifo_path);
else if (errno == EAGAIN) {
/* busy, try again later */
return 0;
} else if (errno != EPIPE) {
i_error("write(%s) failed: %m", fifo_path);
} else {
/* server was probably restarted, don't bother logging
this. */
}
if (close(fifo_fd) < 0)
i_error("close(%s) failed: %m", fifo_path);
fifo_fd = -1;
return -1;
}
return 1;
}
static void test_str_c(void)
{
string_t *str;
unsigned int i, j;
test_begin("str_c()");
str = t_str_new(0);
T_BEGIN {
(void)str_c(str);
} T_END;
for (i = 0; i < 32; i++) T_BEGIN {
str = t_str_new(15);
for (j = 0; j < i; j++)
str_append_c(str, 'x');
T_BEGIN {
(void)str_c(str);
} T_END;
} T_END;
test_end();
}
void userdb_blocking_lookup(struct auth_request *request)
{
string_t *str;
str = t_str_new(128);
str_printfa(str, "USER\t%u\t", request->userdb->userdb->id);
auth_request_export(request, str);
auth_request_ref(request);
auth_worker_call(request->pool, request->user,
str_c(str), user_callback, request);
}
static int fetch_and_copy(struct client *client,
struct mailbox_transaction_context *t,
struct mail_search_args *search_args,
const char **src_uidset_r,
unsigned int *copy_count_r)
{
struct mail_search_context *search_ctx;
struct mailbox_transaction_context *src_trans;
struct mail_save_context *save_ctx;
struct mail *mail;
unsigned int copy_count = 0;
struct msgset_generator_context srcset_ctx;
string_t *src_uidset;
int ret;
src_uidset = t_str_new(256);
msgset_generator_init(&srcset_ctx, src_uidset);
src_trans = mailbox_transaction_begin(client->mailbox, 0);
search_ctx = mailbox_search_init(src_trans, search_args, NULL);
mail = mail_alloc(src_trans, 0, NULL);
ret = 1;
while (mailbox_search_next(search_ctx, mail) && ret > 0) {
if (mail->expunged) {
ret = 0;
break;
}
if ((++copy_count % COPY_CHECK_INTERVAL) == 0)
client_send_sendalive_if_needed(client);
save_ctx = mailbox_save_alloc(t);
mailbox_save_copy_flags(save_ctx, mail);
if (mailbox_copy(&save_ctx, mail) < 0)
ret = mail->expunged ? 0 : -1;
msgset_generator_next(&srcset_ctx, mail->uid);
}
mail_free(&mail);
msgset_generator_finish(&srcset_ctx);
if (mailbox_search_deinit(&search_ctx) < 0)
ret = -1;
if (mailbox_transaction_commit(&src_trans) < 0)
ret = -1;
*src_uidset_r = str_c(src_uidset);
*copy_count_r = copy_count;
return ret;
}
struct db_passwd_file *
db_passwd_file_init(const char *path, bool userdb, bool debug)
{
struct db_passwd_file *db;
const char *p;
bool percents = FALSE;
db = db_passwd_file_find(path);
if (db != NULL) {
db->refcount++;
if (userdb)
db_passwd_file_set_userdb(db);
return db;
}
db = i_new(struct db_passwd_file, 1);
db->refcount = 1;
if (userdb)
db_passwd_file_set_userdb(db);
db->debug = debug;
for (p = path; *p != '\0'; p++) {
if (*p == '%' && p[1] != '\0') {
if (var_get_key(++p) == '%')
percents = TRUE;
else
db->vars = TRUE;
}
}
if (percents && !db->vars) {
/* just extra escaped % chars. remove them. */
struct var_expand_table empty_table[1];
string_t *dest;
empty_table[0].key = '\0';
dest = t_str_new(256);
var_expand(dest, path, empty_table);
path = str_c(dest);
}
db->path = i_strdup(path);
if (db->vars) {
hash_table_create(&db->files, default_pool, 0,
str_hash, strcmp);
} else {
db->default_file = passwd_file_new(db, path);
}
db->next = passwd_files;
passwd_files = db;
return db;
}
bool mod_lower_modify(string_t *in, string_t **result)
{
char *content;
*result = t_str_new(str_len(in));
str_append_str(*result, in);
content = str_c_modifiable(*result);
(void)str_lcase(content);
return TRUE;
}
static void get_plain_auth(struct client *client, string_t *dest)
{
string_t *str;
str = t_str_new(128);
str_append(str, client->proxy_user);
str_append_c(str, '\0');
str_append(str, client->proxy_master_user);
str_append_c(str, '\0');
str_append(str, client->proxy_password);
base64_encode(str_data(str), str_len(str), dest);
}
void rfc2822_header_utf8_printf
(string_t *header, const char *name, const char *fmt, ...)
{
string_t *body = t_str_new(256);
va_list args;
va_start(args, fmt);
message_header_encode(t_strdup_vprintf(fmt, args), body);
va_end(args);
rfc2822_header_write(header, name, str_c(body));
}
const char *mbox_from_create(const char *sender, time_t timestamp)
{
string_t *str;
struct tm *tm;
int year;
str = t_str_new(256);
str_append(str, "From ");
str_append(str, sender);
str_append(str, " ");
/* we could use simply asctime(), but i18n etc. may break it.
Example: "Thu Nov 29 22:33:52 2001" */
tm = localtime(×tamp);
/* week day */
str_append(str, weekdays[tm->tm_wday]);
str_append_c(str, ' ');
/* month */
str_append(str, months[tm->tm_mon]);
str_append_c(str, ' ');
/* day */
str_append_c(str, (tm->tm_mday / 10) + '0');
str_append_c(str, (tm->tm_mday % 10) + '0');
str_append_c(str, ' ');
/* hour */
str_append_c(str, (tm->tm_hour / 10) + '0');
str_append_c(str, (tm->tm_hour % 10) + '0');
str_append_c(str, ':');
/* minute */
str_append_c(str, (tm->tm_min / 10) + '0');
str_append_c(str, (tm->tm_min % 10) + '0');
str_append_c(str, ':');
/* second */
str_append_c(str, (tm->tm_sec / 10) + '0');
str_append_c(str, (tm->tm_sec % 10) + '0');
str_append_c(str, ' ');
/* year */
year = tm->tm_year + 1900;
str_append_c(str, (year / 1000) + '0');
str_append_c(str, ((year / 100) % 10) + '0');
str_append_c(str, ((year / 10) % 10) + '0');
str_append_c(str, (year % 10) + '0');
str_append_c(str, '\n');
return str_c(str);
}
bool mod_lowerfirst_modify(string_t *in, string_t **result)
{
char *content;
*result = t_str_new(str_len(in));
str_append_str(*result, in);
content = str_c_modifiable(*result);
content[0] = i_tolower(content[0]);
return TRUE;
}
static void imap_hibernate_write_cmd(struct client *client, string_t *cmd,
const buffer_t *state, int fd_notify)
{
struct stat peer_st;
str_append_tabescaped(cmd, client->user->username);
str_append_c(cmd, '\t');
str_append_tabescaped(cmd, client->user->set->mail_log_prefix);
str_printfa(cmd, "\tidle_notify_interval=%u",
client->set->imap_idle_notify_interval);
if (fstat(client->fd_in, &peer_st) == 0) {
str_printfa(cmd, "\tpeer_dev_major=%lu\tpeer_dev_minor=%lu\tpeer_ino=%llu",
(unsigned long)major(peer_st.st_dev),
(unsigned long)minor(peer_st.st_dev),
(unsigned long long)peer_st.st_ino);
}
if (client->session_id != NULL) {
str_append(cmd, "\tsession=");
str_append_tabescaped(cmd, client->session_id);
}
if (client->user->local_ip != NULL)
str_printfa(cmd, "\tlip=%s", net_ip2addr(client->user->local_ip));
if (client->user->remote_ip != NULL)
str_printfa(cmd, "\trip=%s", net_ip2addr(client->user->remote_ip));
if (client->userdb_fields != NULL) {
string_t *userdb_fields = t_str_new(256);
unsigned int i;
for (i = 0; client->userdb_fields[i] != NULL; i++) {
if (i > 0)
str_append_c(userdb_fields, '\t');
str_append_tabescaped(userdb_fields, client->userdb_fields[i]);
}
str_append(cmd, "\tuserdb_fields=");
str_append_tabescaped(cmd, str_c(userdb_fields));
}
if (client->user->uid != (uid_t)-1)
str_printfa(cmd, "\tuid=%s", dec2str(client->user->uid));
if (client->user->gid != (gid_t)-1)
str_printfa(cmd, "\tgid=%s", dec2str(client->user->gid));
str_append(cmd, "\tstats=");
str_append_tabescaped(cmd, client_stats(client));
if (client->command_queue != NULL &&
strcasecmp(client->command_queue->name, "IDLE") == 0)
str_append(cmd, "\tidle-cmd");
if (fd_notify != -1)
str_append(cmd, "\tnotify_fd");
str_append(cmd, "\tstate=");
base64_encode(state->data, state->used, cmd);
str_append_c(cmd, '\n');
}
static void test_fts_icu_utf16_to_utf8(void)
{
string_t *dest = t_str_new(64);
const UChar src[] = { 0xbd, 'b', 'c' };
unsigned int i;
test_begin("fts_icu_utf16_to_utf8");
for (i = N_ELEMENTS(src); i > 0; i--) {
fts_icu_utf16_to_utf8(dest, src, i);
test_assert(dest->used == i+1);
}
test_end();
}
struct config_export_context *
config_export_init(const char *const *modules, enum config_dump_scope scope,
enum config_dump_flags flags,
config_request_callback_t *callback, void *context)
{
struct config_export_context *ctx;
pool_t pool;
pool = pool_alloconly_create(MEMPOOL_GROWING"config export", 1024*64);
ctx = p_new(pool, struct config_export_context, 1);
ctx->pool = pool;
ctx->modules = modules == NULL ? NULL : p_strarray_dup(pool, modules);
ctx->flags = flags;
ctx->callback = callback;
ctx->context = context;
ctx->scope = scope;
ctx->value = t_str_new(256);
ctx->prefix = t_str_new(64);
hash_table_create(&ctx->keys, ctx->pool, 0, str_hash, strcmp);
return ctx;
}
static void test_base32_random(void)
{
string_t *str, *dest;
char buf[10];
unsigned int i, j, max;
str = t_str_new(256);
dest = t_str_new(256);
test_begin("padded base32 encode/decode with random input");
for (i = 0; i < 1000; i++) {
max = rand() % sizeof(buf);
for (j = 0; j < max; j++)
buf[j] = rand();
str_truncate(str, 0);
str_truncate(dest, 0);
base32_encode(TRUE, buf, max, str);
test_assert(base32_decode(str_data(str), str_len(str), NULL, dest) >= 0);
test_assert(str_len(dest) == max &&
memcmp(buf, str_data(dest), max) == 0);
}
test_end();
test_begin("padded base32hex encode/decode with random input");
for (i = 0; i < 1000; i++) {
max = rand() % sizeof(buf);
for (j = 0; j < max; j++)
buf[j] = rand();
str_truncate(str, 0);
str_truncate(dest, 0);
base32hex_encode(TRUE, buf, max, str);
test_assert(base32hex_decode(str_data(str), str_len(str), NULL, dest) >= 0);
test_assert(str_len(dest) == max &&
memcmp(buf, str_data(dest), max) == 0);
}
test_end();
}
static const char *mech_get_plugin_name(const char *name)
{
string_t *str = t_str_new(32);
str_append(str, "mech_");
for (; *name != '\0'; name++) {
if (*name == '-')
str_append_c(str, '_');
else
str_append_c(str, i_tolower(*name));
}
return str_c(str);
}
static void passdb_dict_lookup_pass(struct passdb_dict_request *dict_request)
{
struct auth_request *auth_request = dict_request->auth_request;
struct passdb_module *_module = auth_request->passdb->passdb;
struct dict_passdb_module *module =
(struct dict_passdb_module *)_module;
string_t *key;
const char *password = NULL, *scheme = NULL;
enum passdb_result passdb_result;
int ret;
key = t_str_new(512);
str_append(key, DICT_PATH_SHARED);
var_expand(key, module->conn->set.password_key,
auth_request_get_var_expand_table(auth_request, NULL));
if (*module->conn->set.password_key == '\0') {
auth_request_log_error(auth_request, "dict",
"password_key not specified");
passdb_result = PASSDB_RESULT_INTERNAL_FAILURE;
} else {
passdb_result = passdb_dict_lookup_key(auth_request, module,
str_c(key));
}
if (passdb_result == PASSDB_RESULT_OK) {
/* passdb_password may change on the way,
so we'll need to strdup. */
password = t_strdup(auth_request->passdb_password);
scheme = password_get_scheme(&password);
/* auth_request_set_field() sets scheme */
i_assert(password == NULL || scheme != NULL);
}
if (auth_request->credentials_scheme != NULL) {
passdb_handle_credentials(passdb_result, password, scheme,
dict_request->callback.lookup_credentials,
auth_request);
} else {
if (password != NULL) {
ret = auth_request_password_verify(auth_request,
auth_request->mech_password,
password, scheme, "dict");
passdb_result = ret > 0 ? PASSDB_RESULT_OK :
PASSDB_RESULT_PASSWORD_MISMATCH;
}
dict_request->callback.verify_plain(passdb_result,
auth_request);
}
}
static int
unlink_old_files_real(const char *dir, const char *prefix, time_t min_time)
{
DIR *dirp;
struct dirent *d;
struct stat st;
string_t *path;
unsigned int prefix_len, dir_len;
dirp = opendir(dir);
if (dirp == NULL) {
if (errno != ENOENT)
i_error("opendir(%s) failed: %m", dir);
return -1;
}
/* update atime immediately, so if this scanning is done based on
atime it won't be done by multiple processes if the scan is slow */
if (utime(dir, NULL) < 0 && errno != ENOENT)
i_error("utime(%s) failed: %m", dir);
path = t_str_new(256);
str_printfa(path, "%s/", dir);
dir_len = str_len(path);
prefix_len = strlen(prefix);
while ((d = readdir(dirp)) != NULL) {
if (d->d_name[0] == '.' &&
(d->d_name[1] == '\0' ||
(d->d_name[1] == '.' && d->d_name[2] == '\0'))) {
/* skip . and .. */
continue;
}
if (strncmp(d->d_name, prefix, prefix_len) != 0)
continue;
str_truncate(path, dir_len);
str_append(path, d->d_name);
if (stat(str_c(path), &st) < 0) {
if (errno != ENOENT)
i_error("stat(%s) failed: %m", str_c(path));
} else if (!S_ISDIR(st.st_mode) && st.st_ctime < min_time) {
if (unlink(str_c(path)) < 0 && errno != ENOENT)
i_error("unlink(%s) failed: %m", str_c(path));
}
}
if (closedir(dirp) < 0)
i_error("closedir(%s) failed: %m", dir);
return 0;
}
static int mcht_count_match
(struct sieve_match_context *mctx, struct sieve_stringlist *value_list,
struct sieve_stringlist *key_list)
{
const struct sieve_runtime_env *renv = mctx->runenv;
bool trace = sieve_runtime_trace_active(renv, SIEVE_TRLVL_MATCHING);
int count;
string_t *key_item;
int match, ret;
if ( (count=sieve_stringlist_get_length(value_list)) < 0 ) {
mctx->exec_status = value_list->exec_status;
return -1;
}
sieve_stringlist_reset(key_list);
string_t *value = t_str_new(20);
str_printfa(value, "%d", count);
if ( trace ) {
sieve_runtime_trace(renv, 0,
"matching count value `%s'", str_sanitize(str_c(value), 80));
}
sieve_runtime_trace_descend(renv);
/* Match to all key values */
key_item = NULL;
match = 0;
while ( match == 0 &&
(ret=sieve_stringlist_next_item(key_list, &key_item)) > 0 )
{
match = mcht_value_match_key
(mctx, str_c(value), str_len(value), str_c(key_item), str_len(key_item));
if ( trace ) {
sieve_runtime_trace(renv, 0,
"with key `%s' => %d", str_sanitize(str_c(key_item), 80), ret);
}
}
sieve_runtime_trace_ascend(renv);
if ( ret < 0 ) {
mctx->exec_status = key_list->exec_status;
match = -1;
}
return match;
}
const char *acl_rights_export(const struct acl_rights *rights)
{
string_t *str = t_str_new(128);
if (rights->rights != NULL)
str_append(str, t_strarray_join(rights->rights, " "));
if (rights->neg_rights != NULL) {
if (str_len(str) > 0)
str_append_c(str, ' ');
str_append_c(str, '-');
str_append(str, t_strarray_join(rights->neg_rights, " -"));
}
return str_c(str);
}
void passdb_blocking_verify_plain(struct auth_request *request)
{
string_t *str;
str = t_str_new(128);
str_printfa(str, "PASSV\t%u\t", request->passdb->passdb->id);
str_append_tabescaped(str, request->mech_password);
str_append_c(str, '\t');
auth_request_export(request, str);
auth_request_ref(request);
auth_worker_call(request->pool, request->user, str_c(str),
verify_plain_callback, request);
}
void passdb_blocking_lookup_credentials(struct auth_request *request)
{
string_t *str;
str = t_str_new(128);
str_printfa(str, "PASSL\t%u\t", request->passdb->passdb->id);
str_append_tabescaped(str, request->credentials_scheme);
str_append_c(str, '\t');
auth_request_export(request, str);
auth_request_ref(request);
auth_worker_call(request->pool, request->user, str_c(str),
lookup_credentials_callback, request);
}