static void sieve_tool_get_user_data
(const char **username_r, const char **homedir_r)
{
uid_t process_euid = geteuid();
struct passwd *pw;
const char *user = NULL, *home = NULL;
user = getenv("USER");
home = getenv("HOME");
if ( user == NULL || *user == '\0' ||
home == NULL || *home == '\0' ) {
if ((pw = getpwuid(process_euid)) != NULL) {
user = pw->pw_name;
home = pw->pw_dir;
}
}
if ( username_r != NULL ) {
if ( user == NULL || *user == '\0' ) {
i_fatal("couldn't lookup our username (uid=%s)",
dec2str(process_euid));
}
*username_r = t_strdup(user);
}
if ( homedir_r != NULL )
*homedir_r = t_strdup(home);
}
void MTD_FLASHMEM MultipartFormDataProcessor::handle_DecodingHeaders(char c) {
static char const EOH[4] = {0x0D, 0x0A, 0x0D, 0x0A};
if (c == EOH[substate]) {
++substate;
if (substate == 2) {
// useful if this is not an EOH to separate headers
headers->append(0x0D, 1);
} else if (substate == 4) {
// end of headers
headers->append(0, 1); // add string terminating zero
// look for "name" parameter
CharChunksIterator keyBegin;
extractParameter(FSTR(" name="), headers->getIterator(), &keyBegin, &nameBegin, &nameEnd);
// look for "filename" parameter
CharChunksIterator filenameBegin, filenameEnd;
if (extractParameter(FSTR(" filename="), headers->getIterator(), &keyBegin, &filenameBegin, &filenameEnd)) {
//// this is a file
// add "filename" to form fields
filenameBegin = getFilename(filenameBegin,
filenameEnd); // some browsers send a full path instead of a simple file name (IE)
formfields->add(keyBegin + 1, keyBegin + 9, filenameBegin, filenameEnd);
// extract Content-Type parameter
CharChunksIterator contentTypeBegin, contentTypeEnd;
if (extractParameter(FSTR("Content-Type:"), filenameEnd, &keyBegin, &contentTypeBegin, &contentTypeEnd)) {
// add "Content-Type" to form fields
formfields->add(keyBegin, keyBegin + 12, contentTypeBegin, contentTypeEnd);
// create file
file.create(APtr<char>(t_strdup(filenameBegin, filenameEnd)).get(),
APtr<char>(t_strdup(contentTypeBegin, contentTypeEnd)).get());
state = GettingFile;
} else {
// missing content-type, cannot get as file!
state = GettingValue;
}
} else {
//// this is a normal field
valueStorage = chunksFactory.add();
state = GettingValue;
}
substate = 0;
}
} else {
// add to headers buffer
headers->append(c, HEADERS_CHUNK_SIZE);
substate = 0;
}
}
int hash_format_init(const char *format_string, struct hash_format **format_r,
const char **error_r)
{
struct hash_format *format;
pool_t pool;
int ret;
pool = pool_alloconly_create("hash format", 1024);
format = p_new(pool, struct hash_format, 1);
format->pool = pool;
format->str = p_strdup(pool, format_string);
format->pos = &format->list;
T_BEGIN {
ret = hash_format_string_analyze(format, format_string,
error_r);
if (ret < 0)
*error_r = p_strdup(format->pool, *error_r);
} T_END;
if (ret < 0) {
*error_r = t_strdup(*error_r);
pool_unref(&pool);
return -1;
}
*format_r = format;
return 0;
}
ARRAY_TYPE(imap_arg_list) *
test_parse_imap_args(pool_t pool, const char *line, unsigned int linelen,
const char **error_r)
{
struct imap_parser *imap_parser;
struct istream *input;
const struct imap_arg *args;
ARRAY_TYPE(imap_arg_list) *dup_args;
enum imap_parser_error fatal;
int ret;
input = i_stream_create_from_data(line, linelen);
imap_parser = imap_parser_create(input, NULL, (size_t)-1);
ret = imap_parser_finish_line(imap_parser, 0,
IMAP_PARSE_FLAG_LITERAL8 |
IMAP_PARSE_FLAG_LITERAL_TYPE |
IMAP_PARSE_FLAG_ATOM_ALLCHARS |
IMAP_PARSE_FLAG_MULTILINE_STR, &args);
if (ret < 0) {
dup_args = NULL;
if (ret == -2)
*error_r = "Missing data";
else {
*error_r = t_strdup(imap_parser_get_error(imap_parser,
&fatal));
}
} else {
dup_args = test_parse_imap_args_dup(pool, args);
}
imap_parser_unref(&imap_parser);
i_stream_unref(&input);
return dup_args;
}
// should be called only after setStatus, addHeader and addContent
void MTD_FLASHMEM HTTPResponse::flush()
{
// status line
m_httpHandler->getSocket()->writeFmt(FSTR("HTTP/1.1 %s\r\n"), m_status);
// HTTPResponse headers
addHeader(FSTR("Connection"), FSTR("close"));
// user headers
for (uint32_t i = 0; i != m_headers.getItemsCount(); ++i)
{
Fields::Item* item = m_headers[i];
m_httpHandler->getSocket()->writeFmt(FSTR("%s: %s\r\n"), APtr<char>(t_strdup(item->key)).get(), APtr<char>(t_strdup(item->value)).get());
}
// content length header
m_httpHandler->getSocket()->writeFmt(FSTR("%s: %d\r\n\r\n"), STR_Content_Length, m_content.getItemsCount());
// actual content
if (m_content.getItemsCount() > 0)
{
CharChunksIterator iter = m_content.getIterator();
CharChunkBase* chunk = iter.getCurrentChunk();
while (chunk)
{
m_httpHandler->getSocket()->write((uint8_t const*)chunk->data, chunk->getItems());
chunk = iter.moveToNextChunk();
}
m_content.clear();
}
}
static int settings_add_include(const char *path, struct input_stack **inputp,
bool ignore_errors, const char **error_r)
{
struct input_stack *tmp, *new_input;
int fd;
for (tmp = *inputp; tmp != NULL; tmp = tmp->prev) {
if (strcmp(tmp->path, path) == 0)
break;
}
if (tmp != NULL) {
*error_r = t_strdup_printf("Recursive include file: %s", path);
return -1;
}
if ((fd = open(path, O_RDONLY)) == -1) {
if (ignore_errors)
return 0;
*error_r = t_strdup_printf("Couldn't open include file %s: %m",
path);
return -1;
}
new_input = t_new(struct input_stack, 1);
new_input->prev = *inputp;
new_input->path = t_strdup(path);
new_input->input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
i_stream_set_return_partial_line(new_input->input, TRUE);
*inputp = new_input;
return 0;
}
static int
driver_mysql_transaction_commit_s(struct sql_transaction_context *_ctx,
const char **error_r)
{
struct mysql_transaction_context *ctx =
(struct mysql_transaction_context *)_ctx;
struct mysql_db *db = (struct mysql_db *)_ctx->db;
int ret = 1;
*error_r = NULL;
if (_ctx->head != NULL) {
ret = driver_mysql_try_commit_s(ctx);
*error_r = t_strdup(ctx->error);
if (ret == 0) {
i_info("%s: Disconnected from database, "
"retrying commit", db->dbname);
if (sql_connect(_ctx->db) >= 0) {
ctx->failed = FALSE;
ret = driver_mysql_try_commit_s(ctx);
}
}
}
sql_transaction_rollback(&_ctx);
return ret <= 0 ? -1 : 0;
}
FMT(const T_CHAR * p_spec,TAGFUNC _f,TAGFREEFUNC _ff,void * _fp)
{
found=0;
org_spec=spec=t_strdup(p_spec);
f=_f;
ff=_ff;
fp=_fp;
}
int mail_search_build(struct mail_search_register *reg,
struct mail_search_parser *parser, const char **charset,
struct mail_search_args **args_r, const char **error_r)
{
struct mail_search_build_context ctx;
struct mail_search_args *args;
struct mail_search_arg *root;
const char *str;
int ret;
*args_r = NULL;
*error_r = NULL;
args = mail_search_build_init();
memset(&ctx, 0, sizeof(ctx));
ctx.pool = args->pool;
ctx.reg = reg;
ctx.parser = parser;
ctx.charset = p_strdup(ctx.pool, *charset);
ret = mail_search_build_list(&ctx, &root);
if (!ctx.charset_checked && ret == 0) {
/* make sure we give an error message if charset is invalid */
ret = mail_search_build_get_utf8(&ctx, "", &str);
}
if (ret < 0) {
*error_r = ctx._error != NULL ? t_strdup(ctx._error) :
t_strdup(mail_search_parser_get_error(parser));
if (ctx.unknown_charset)
*charset = NULL;
pool_unref(&args->pool);
return -1;
}
if (root->type == SEARCH_SUB && !root->match_not) {
/* simple SUB root */
args->args = root->value.subargs;
} else {
args->args = root;
}
*args_r = args;
return 0;
}
int cmd_authenticate(struct imap_client *imap_client, bool *parsed_r)
{
/* NOTE: This command's input is handled specially because the
SASL-IR can be large. */
struct client *client = &imap_client->common;
const unsigned char *data;
size_t i, size;
int ret;
*parsed_r = FALSE;
/* <auth mechanism name> [<initial SASL response>] */
if (!imap_client->auth_mech_name_parsed) {
data = i_stream_get_data(client->input, &size);
for (i = 0; i < size; i++) {
if (data[i] == ' ' ||
data[i] == '\r' || data[i] == '\n')
break;
}
if (i == size)
return 0;
if (i == 0) {
/* empty mechanism name */
imap_client->skip_line = TRUE;
return -1;
}
i_free(client->auth_mech_name);
client->auth_mech_name = i_strndup(data, i);
imap_client->auth_mech_name_parsed = TRUE;
if (data[i] == ' ')
i++;
i_stream_skip(client->input, i);
}
/* get SASL-IR, if any */
if ((ret = client_auth_read_line(client)) <= 0)
return ret;
*parsed_r = TRUE;
imap_client->auth_mech_name_parsed = FALSE;
return imap_client_auth_begin(imap_client,
t_strdup(client->auth_mech_name),
t_strdup(str_c(client->auth_response)));
}
static void
passdb_imap_verify_plain(struct auth_request *auth_request,
const char *password,
verify_plain_callback_t *callback)
{
struct passdb_module *_module = auth_request->passdb->passdb;
struct imap_passdb_module *module =
(struct imap_passdb_module *)_module;
struct imap_auth_request *request;
struct imapc_client_settings set;
const struct var_expand_table *table;
string_t *str;
set = module->set;
set.debug = auth_request->set->debug;
set.dns_client_socket_path =
t_strconcat(auth_request->set->base_dir, "/",
DNS_CLIENT_SOCKET_NAME, NULL);
set.password = password;
set.max_idle_time = IMAPC_DEFAULT_MAX_IDLE_TIME;
if (module->set_have_vars) {
str = t_str_new(128);
table = auth_request_get_var_expand_table(auth_request, NULL);
var_expand(str, set.username, table);
set.username = t_strdup(str_c(str));
str_truncate(str, 0);
var_expand(str, set.host, table);
set.host = t_strdup(str_c(str));
}
auth_request_log_debug(auth_request, AUTH_SUBSYS_DB,
"lookup host=%s port=%d", set.host, set.port);
request = p_new(auth_request->pool, struct imap_auth_request, 1);
request->client = imapc_client_init(&set);
request->auth_request = auth_request;
request->verify_callback = callback;
auth_request_ref(auth_request);
imapc_client_login(request->client, passdb_imap_login_callback,
request);
}
static const char *
client_get_log_str(struct client *client, const char *msg)
{
static const struct var_expand_table static_tab[3] = {
{ 's', NULL, NULL },
{ '$', NULL, NULL },
{ '\0', NULL, NULL }
};
static const struct var_expand_func_table func_table[] = {
{ "passdb", client_var_expand_func_passdb },
{ NULL, NULL }
};
const struct var_expand_table *var_expand_table;
struct var_expand_table *tab;
char *const *e;
string_t *str, *str2;
unsigned int pos;
var_expand_table = get_var_expand_table(client);
tab = t_malloc(sizeof(static_tab));
memcpy(tab, static_tab, sizeof(static_tab));
str = t_str_new(256);
str2 = t_str_new(128);
for (e = client->set->log_format_elements_split; *e != NULL; e++) {
pos = str_len(str);
var_expand_with_funcs(str, *e, var_expand_table,
func_table, client);
if (have_username_key(*e)) {
/* username is added even if it's empty */
} else {
str_truncate(str2, 0);
var_expand(str2, *e, login_var_expand_empty_tab);
if (strcmp(str_c(str)+pos, str_c(str2)) == 0) {
/* empty %variables, don't add */
str_truncate(str, pos);
continue;
}
}
if (str_len(str) > 0)
str_append(str, ", ");
}
if (str_len(str) > 0)
str_truncate(str, str_len(str)-2);
tab[0].value = t_strdup(str_c(str));
tab[1].value = msg;
str_truncate(str, 0);
var_expand(str, client->set->login_log_format, tab);
return str_c(str);
}
static void
dsync_fix_mailbox_name(struct mail_namespace *ns, string_t *vname,
char alt_char)
{
const char *old_vname;
char *p, list_sep = mailbox_list_get_hierarchy_sep(ns->list);
guid_128_t guid;
/* replace control chars */
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if ((unsigned char)*p < ' ')
*p = alt_char;
}
/* make it valid UTF8 */
if (!uni_utf8_str_is_valid(str_c(vname))) {
old_vname = t_strdup(str_c(vname));
str_truncate(vname, 0);
if (uni_utf8_get_valid_data((const void *)old_vname,
strlen(old_vname), vname))
i_unreached();
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
/* 1) change any real separators to alt separators (this wouldn't
be necessary with listescape, but don't bother detecting it) */
if (list_sep != mail_namespace_get_sep(ns)) {
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if (*p == list_sep)
*p = alt_char;
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
}
/* 2) '/' characters aren't valid without listescape */
if (mail_namespace_get_sep(ns) != '/' && list_sep != '/') {
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if (*p == '/')
*p = alt_char;
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
}
/* 3) probably some reserved name (e.g. dbox-Mails) */
str_insert(vname, ns->prefix_len, "_");
if (dsync_is_valid_name(ns, str_c(vname)))
return;
/* 4) name is too long? just give up and generate a unique name */
guid_128_generate(guid);
str_truncate(vname, 0);
str_append(vname, ns->prefix);
str_append(vname, guid_128_to_string(guid));
i_assert(dsync_is_valid_name(ns, str_c(vname)));
}
void MTD_FLASHMEM HTTPResponse::flushHeaders(uint32_t contentLength) {
if (!m_headersFlushed) {
// status line
m_httpHandler->getSocket()->writeFmt(FSTR("HTTP/1.1 %s\r\n"), m_status);
// HTTPResponse headers
addHeader(FSTR("Connection"), FSTR("close"));
// user headers
for (uint32_t i = 0; i != m_headers.getItemsCount(); ++i) {
Fields::Item *item = m_headers[i];
m_httpHandler->getSocket()->writeFmt(FSTR("%s: %s\r\n"), APtr<char>(t_strdup(item->key)).get(),
APtr<char>(t_strdup(item->value)).get());
}
// content length header
m_httpHandler->getSocket()->writeFmt(FSTR("%s: %d\r\n\r\n"), STR_Content_Length, contentLength);
m_headersFlushed = true;
}
}
static void
ldap_lookup_finish(struct auth_request *auth_request,
struct passdb_ldap_request *ldap_request,
LDAPMessage *res)
{
enum passdb_result passdb_result;
const char *password = NULL, *scheme;
int ret;
if (res == NULL) {
passdb_result = PASSDB_RESULT_INTERNAL_FAILURE;
} else if (ldap_request->entries == 0) {
passdb_result = PASSDB_RESULT_USER_UNKNOWN;
auth_request_log_info(auth_request, "ldap",
"unknown user");
} else if (ldap_request->entries > 1) {
auth_request_log_error(auth_request, "ldap",
"pass_filter matched multiple objects, aborting");
passdb_result = PASSDB_RESULT_INTERNAL_FAILURE;
} else if (auth_request->passdb_password == NULL &&
!auth_fields_exists(auth_request->extra_fields, "nopassword")) {
auth_request_log_info(auth_request, "ldap",
"No password returned (and no nopassword)");
passdb_result = PASSDB_RESULT_PASSWORD_MISMATCH;
} else {
/* passdb_password may change on the way,
so we'll need to strdup. */
password = t_strdup(auth_request->passdb_password);
passdb_result = PASSDB_RESULT_OK;
}
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,
ldap_request->callback.lookup_credentials,
auth_request);
} else {
if (password != NULL) {
ret = auth_request_password_verify(auth_request,
auth_request->mech_password,
password, scheme, "ldap");
passdb_result = ret > 0 ? PASSDB_RESULT_OK :
PASSDB_RESULT_PASSWORD_MISMATCH;
}
ldap_request->callback.verify_plain(passdb_result,
auth_request);
}
}
static struct istream *mail_raw_create_stream
(struct mail_user *ruser, int fd, time_t *mtime_r, const char **sender)
{
struct istream *input, *input2, *input_list[2];
const unsigned char *data;
size_t i, size;
int ret, tz;
char *env_sender = NULL;
*mtime_r = (time_t)-1;
fd_set_nonblock(fd, FALSE);
input = i_stream_create_fd(fd, 4096, FALSE);
input->blocking = TRUE;
/* If input begins with a From-line, drop it */
ret = i_stream_read_data(input, &data, &size, 5);
if (ret > 0 && size >= 5 && memcmp(data, "From ", 5) == 0) {
/* skip until the first LF */
i_stream_skip(input, 5);
while ( i_stream_read_data(input, &data, &size, 0) > 0 ) {
for (i = 0; i < size; i++) {
if (data[i] == '\n')
break;
}
if (i != size) {
(void)mbox_from_parse(data, i, mtime_r, &tz, &env_sender);
i_stream_skip(input, i + 1);
break;
}
i_stream_skip(input, size);
}
}
if (env_sender != NULL && sender != NULL) {
*sender = t_strdup(env_sender);
}
i_free(env_sender);
if (input->v_offset == 0) {
input2 = input;
i_stream_ref(input2);
} else {
input2 = i_stream_create_limit(input, (uoff_t)-1);
}
i_stream_unref(&input);
input_list[0] = input2; input_list[1] = NULL;
input = i_stream_create_seekable(input_list, MAIL_MAX_MEMORY_BUFFER,
seekable_fd_callback, (void*)ruser);
i_stream_unref(&input2);
return input;
}
static int
service_auth_userdb_lookup(struct mail_storage_service_ctx *ctx,
const struct mail_storage_service_input *input,
pool_t pool, const char **user,
const char *const **fields_r,
const char **error_r)
{
struct auth_user_info info;
const char *new_username;
int ret;
memset(&info, 0, sizeof(info));
info.service = input->service != NULL ? input->service :
ctx->service->name;
info.local_ip = input->local_ip;
info.remote_ip = input->remote_ip;
info.local_port = input->local_port;
info.remote_port = input->remote_port;
info.debug = input->debug;
ret = auth_master_user_lookup(ctx->conn, *user, &info, pool,
&new_username, fields_r);
if (ret > 0) {
if (strcmp(*user, new_username) != 0) {
if (ctx->debug)
i_debug("changed username to %s", new_username);
*user = t_strdup(new_username);
}
*user = new_username;
} else if (ret == 0)
*error_r = "Unknown user";
else if (**fields_r != NULL) {
*error_r = t_strdup(**fields_r);
ret = -2;
} else {
*error_r = MAIL_ERRSTR_CRITICAL_MSG;
}
return ret;
}
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);
}
}
int message_search_msg(struct message_search_context *ctx,
struct istream *input, struct message_part *parts,
const char **error_r)
{
char *error;
int ret;
T_BEGIN {
ret = message_search_msg_real(ctx, input, parts, error_r);
error = i_strdup(*error_r);
} T_END;
*error_r = t_strdup(error);
i_free(error);
return ret;
}
int mail_search_build(struct mail_search_register *reg,
struct mail_search_parser *parser, const char *charset,
struct mail_search_args **args_r, const char **error_r)
{
struct mail_search_build_context ctx;
struct mail_search_args *args;
struct mail_search_arg *root;
*args_r = NULL;
*error_r = NULL;
args = mail_search_build_init();
args->charset = p_strdup(args->pool, charset);
memset(&ctx, 0, sizeof(ctx));
ctx.pool = args->pool;
ctx.reg = reg;
ctx.parser = parser;
if (mail_search_build_list(&ctx, &root) < 0) {
*error_r = ctx._error != NULL ? t_strdup(ctx._error) :
t_strdup(mail_search_parser_get_error(parser));
pool_unref(&args->pool);
return -1;
}
if (root->type == SEARCH_SUB && !root->not) {
/* simple SUB root */
args->args = root->value.subargs;
} else {
args->args = root;
}
*args_r = args;
return 0;
}
int http_client_request_send(struct http_client_request *req,
bool pipelined, const char **error_r)
{
char *errstr = NULL;
int ret;
T_BEGIN {
ret = http_client_request_send_real(req, pipelined, error_r);
if (ret < 0)
errstr = i_strdup(*error_r);
} T_END;
*error_r = t_strdup(errstr);
i_free(errstr);
return ret;
}
static int maildir_file_do_try(struct maildir_mailbox *mbox, uint32_t uid,
maildir_file_do_func *callback, void *context)
{
const char *path, *fname;
enum maildir_uidlist_rec_flag flags;
bool have_flags;
int ret;
ret = maildir_sync_lookup(mbox, uid, &flags, &fname);
if (ret <= 0)
return ret == 0 ? -2 : -1;
if ((flags & MAILDIR_UIDLIST_REC_FLAG_NONSYNCED) != 0) {
/* let's see if we can guess the filename based on index */
fname = maildir_filename_guess(mbox, uid, fname,
&flags, &have_flags);
}
/* make a copy, just in case callback refreshes uidlist and
the pointer becomes invalid. */
fname = t_strdup(fname);
ret = 0;
if ((flags & MAILDIR_UIDLIST_REC_FLAG_NEW_DIR) != 0) {
/* probably in new/ dir */
path = t_strconcat(mailbox_get_path(&mbox->box),
"/new/", fname, NULL);
ret = callback(mbox, path, context);
}
if (ret == 0) {
path = t_strconcat(mailbox_get_path(&mbox->box), "/cur/",
fname, NULL);
ret = callback(mbox, path, context);
}
if (ret > 0 && (flags & MAILDIR_UIDLIST_REC_FLAG_NONSYNCED) != 0) {
/* file was found. make sure we remember its latest name. */
maildir_uidlist_update_fname(mbox->uidlist, fname);
} else if (ret == 0 &&
(flags & MAILDIR_UIDLIST_REC_FLAG_NONSYNCED) == 0) {
/* file wasn't found. mark this message nonsynced, so we can
retry the lookup by guessing the flags */
maildir_uidlist_add_flags(mbox->uidlist, fname,
MAILDIR_UIDLIST_REC_FLAG_NONSYNCED);
}
return ret;
}
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;
const char *password = NULL, *scheme = NULL;
enum passdb_result passdb_result;
int ret;
if (array_count(&module->conn->set.passdb_fields) == 0 &&
array_count(&module->conn->set.parsed_passdb_objects) == 0) {
auth_request_log_error(auth_request, AUTH_SUBSYS_DB,
"No passdb_objects or passdb_fields specified");
passdb_result = PASSDB_RESULT_INTERNAL_FAILURE;
} else {
passdb_result = passdb_dict_lookup_key(auth_request, module);
}
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, AUTH_SUBSYS_DB);
passdb_result = ret > 0 ? PASSDB_RESULT_OK :
PASSDB_RESULT_PASSWORD_MISMATCH;
}
dict_request->callback.verify_plain(passdb_result,
auth_request);
}
}
static int tst_test_multiscript_operation_execute
(const struct sieve_runtime_env *renv, sieve_size_t *address)
{
struct sieve_stringlist *scripts_list;
string_t *script_name;
ARRAY_TYPE (const_string) scriptfiles;
bool result = TRUE;
int ret;
/*
* Read operands
*/
if ( (ret=sieve_opr_stringlist_read(renv, address, "scripts", &scripts_list))
<= 0 )
return ret;
/*
* Perform operation
*/
sieve_runtime_trace(renv, SIEVE_TRLVL_TESTS,
"testsuite: test_multiscript test");
sieve_runtime_trace_descend(renv);
t_array_init(&scriptfiles, 16);
script_name = NULL;
while ( result &&
(ret=sieve_stringlist_next_item(scripts_list, &script_name)) > 0 ) {
const char *script = t_strdup(str_c(script_name));
array_append(&scriptfiles, &script, 1);
}
result = result && (ret >= 0) &&
testsuite_script_multiscript(renv, &scriptfiles);
/* Set result */
sieve_interpreter_set_test_result(renv->interp, result);
return SIEVE_EXEC_OK;
}
static const char *
client_get_log_str(struct client *client, const char *msg)
{
static struct var_expand_table static_tab[3] = {
{ 's', NULL, NULL },
{ '$', NULL, NULL },
{ '\0', NULL, NULL }
};
const struct var_expand_table *var_expand_table;
struct var_expand_table *tab;
const char *p;
char *const *e;
string_t *str;
var_expand_table = get_var_expand_table(client);
tab = t_malloc(sizeof(static_tab));
memcpy(tab, static_tab, sizeof(static_tab));
str = t_str_new(256);
for (e = client->set->log_format_elements_split; *e != NULL; e++) {
for (p = *e; *p != '\0'; p++) {
if (*p != '%' || p[1] == '\0')
continue;
p++;
if (have_key(var_expand_table, p)) {
if (str_len(str) > 0)
str_append(str, ", ");
var_expand(str, *e, var_expand_table);
break;
}
}
}
tab[0].value = t_strdup(str_c(str));
tab[1].value = msg;
str_truncate(str, 0);
var_expand(str, client->set->login_log_format, tab);
return str_c(str);
}
int main(void)
{
printf("\n===== START TEST =====\n");
t_bzero();
t_strcat();
t_isalnum();
t_isascii();
t_isprint();
t_tolower();
t_toupper();
t_puts();
t_strlen();
t_memset();
t_memcpy();
t_strdup();
t_cat();
t_bonus();
printf("\n===== END OF TEST =====\n");
return (0);
}
int ssl_iostream_check_cert_validity(struct ssl_iostream *ssl_io,
const char *host, const char **error_r)
{
if (!ssl_iostream_has_valid_client_cert(ssl_io)) {
if (!ssl_iostream_has_broken_client_cert(ssl_io))
*error_r = "SSL certificate not received";
else {
*error_r = t_strdup(ssl_iostream_get_last_error(ssl_io));
if (*error_r == NULL)
*error_r = "Received invalid SSL certificate";
}
return -1;
} else if (ssl_iostream_cert_match_name(ssl_io, host) < 0) {
*error_r = t_strdup_printf(
"SSL certificate doesn't match expected host name %s",
host);
return -1;
}
return 0;
}
/* return AD realm if it exists */
const char *get_ad_realm ( struct auth_request *auth_request )
{
const char *out_realm = NULL;
SCDynamicStoreRef store = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("dovecot.digest.auth"), NULL, NULL);
if ( store ) {
CFDictionaryRef dict = SCDynamicStoreCopyValue(store, CFSTR("com.apple.opendirectoryd.ActiveDirectory"));
if (dict) {
CFStringRef domain = CFDictionaryGetValue(dict, CFSTR("DomainNameFlat"));
if (domain) {
const char *ad_realm = CFStringGetCStringPtr(domain, kCFStringEncodingUTF8);
if (ad_realm) {
auth_request_log_info(auth_request, "digest-md5", "ad realm: %s", ad_realm);
out_realm = t_strdup(ad_realm);
}
}
CFRelease(dict);
}
CFRelease(store);
}
return( out_realm );
}
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;
}
int mail_user_init(struct mail_user *user, const char **error_r)
{
const struct mail_storage_settings *mail_set;
const char *home, *key, *value;
bool need_home_dir;
need_home_dir = user->_home == NULL &&
settings_vars_have_key(user->set_info, user->set,
'h', "home", &key, &value);
if (need_home_dir && mail_user_get_home(user, &home) <= 0) {
user->error = p_strdup_printf(user->pool,
"userdb didn't return a home directory, "
"but %s used it (%%h): %s", key, value);
}
/* expand settings after we can expand %h */
settings_var_expand_with_funcs(user->set_info, user->set,
user->pool, mail_user_var_expand_table(user),
mail_user_var_expand_func_table, user);
user->settings_expanded = TRUE;
mail_user_expand_plugins_envs(user);
/* autocreated users for shared mailboxes need to be fully initialized
if they don't exist, since they're going to be used anyway */
if (user->error == NULL || user->nonexistent) {
mail_set = mail_user_set_get_storage_set(user);
user->mail_debug = mail_set->mail_debug;
user->initialized = TRUE;
hook_mail_user_created(user);
}
if (user->error != NULL) {
*error_r = t_strdup(user->error);
return -1;
}
return 0;
}
