自学教程：C++ t_strdup函数代码示例

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 intdriver_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 voidpassdb_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 voiddsync_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 voidldap_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 intservice_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;}