const char *username)
{
const char *data = node->data;
- unsigned int username_len;
+ size_t username_len;
/* The cache nodes begin with "P"/"U", passdb/userdb ID, optional
"+" master user, "\t" and then usually followed by the username.
const char *name, const char *value,
const char *default_scheme)
{
- unsigned int name_len = strlen(name);
+ size_t name_len = strlen(name);
i_assert(*name != '\0');
i_assert(value != NULL);
void auth_request_set_userdb_field(struct auth_request *request,
const char *name, const char *value)
{
- unsigned int name_len = strlen(name);
+ size_t name_len = strlen(name);
uid_t uid;
gid_t gid;
struct timeout *to_abort, *to_penalty;
unsigned int policy_penalty;
unsigned int last_penalty;
- unsigned int initial_response_len;
+ size_t initial_response_len;
const unsigned char *initial_response;
union {
struct io *io_out, *io_in;
string_t *input_buf;
- unsigned int output_pos, output_len;
+ size_t output_pos, output_len;
int exit_status;
bool exited:1;
void (*request_callback)())
{
struct chkpw_auth_request *chkpw_auth_request;
- unsigned int output_len;
+ size_t output_len;
int fd_in[2], fd_out[2];
pid_t pid;
output_len += strlen(auth_password);
if (output_len > CHECKPASSWORD_MAX_REQUEST_LEN) {
auth_request_log_info(request, AUTH_SUBSYS_DB,
- "Username+password combination too long (%u bytes)",
+ "Username+password combination too long (%"PRIuSIZE_T" bytes)",
output_len);
callback(request, DB_CHECKPASSWORD_STATUS_FAILURE,
NULL, request_callback);
struct hash_iterate_context *iter;
char *name;
struct db_ldap_value *value;
- unsigned int orig_len, unused_count = 0;
+ unsigned int unused_count = 0;
+ size_t orig_len;
orig_len = str_len(ctx->debug);
if (orig_len == 0) {
return new;
}
-static bool data_has_nuls(const void *data, unsigned int len)
+static bool data_has_nuls(const void *data, size_t len)
{
const unsigned char *c = data;
- unsigned int i;
+ size_t i;
/* apparently all names end with NUL? */
if (len > 0 && c[len-1] == '\0')
gss_buffer_desc outbuf;
const char *login_user, *error;
unsigned char *name;
- unsigned int name_len;
+ size_t name_len;
major_status = gss_unwrap(&minor_status, request->gss_ctx,
&inbuf, &outbuf, NULL, NULL);
(struct scram_auth_request *)auth_request;
const char *error = NULL;
const char *server_final_message;
- int len;
+ size_t len;
if (request->client_first_message_bare == NULL) {
/* Received client-first-message */
{
const struct password_scheme *scheme;
const char *encoding = NULL;
- unsigned int scheme_len;
+ size_t scheme_len;
*encoding_r = PW_ENCODING_NONE;
const struct password_scheme *s;
enum password_encoding encoding;
buffer_t *buf;
- unsigned int len;
+ size_t len;
bool guessed_encoding;
*error_r = NULL;
const unsigned char *raw_password, size_t size,
const char **error_r)
{
- unsigned int i, plaintext_len, trunc_len = 0;
+ size_t i, plaintext_len, trunc_len = 0;
/* format: <length>-<password> */
for (i = 0; i < size; i++) {
userdb_callback_t *userdb_callback;
const char *key_prefix;
- unsigned int key_prefix_len;
+ size_t key_prefix_len;
struct dict_iterate_context *iter;
};
struct config_filter filter;
/* root=NULL-terminated list of parsers */
struct config_module_parser *parsers;
- unsigned int pathlen;
+ size_t pathlen;
const char *open_path;
unsigned int open_linenum;
struct input_stack *cur_input;
string_t *str;
- unsigned int pathlen;
+ size_t pathlen;
unsigned int section_counter;
const char *error;
const char **key_r, const char **value_r)
{
const char *key;
- unsigned int len;
+ size_t len;
char *p;
*key_r = NULL;
}
case SET_ENUM: {
const char *const *val = value;
- unsigned int len = strlen(*val);
+ size_t len = strlen(*val);
if (dump_default)
str_append(str, *val);
const struct setting_define *def;
const void *value, *default_value, *change_value;
void *const *children, *const *change_children = NULL;
- unsigned int i, count, count2, prefix_len;
+ unsigned int i, count, count2;
+ size_t prefix_len;
const char *str;
char *key;
bool dump, dump_default = FALSE;
static bool value_need_quote(const char *value)
{
- unsigned int len = strlen(value);
+ size_t len = strlen(value);
if (len == 0)
return FALSE;
struct prefix_stack prefix;
const char *const *strings, *const *args, *p, *str, *const *prefixes;
const char *key, *key2, *value;
- unsigned int i, j, count, len, prefix_count, skip_len;
- unsigned int setting_name_filter_len, prefix_idx = UINT_MAX;
+ unsigned int i, j, count, prefix_count;
+ unsigned int prefix_idx = UINT_MAX;
+ size_t len, skip_len, setting_name_filter_len;
bool unique_key;
int ret = 0;
{
static struct config_dump_human_context *ctx;
const char *const *str;
- unsigned int len;
+ size_t len;
bool dump_section = FALSE;
ctx = config_dump_human_init(NULL, scope, FALSE);
void *context)
{
char **setting_name_filters = context;
- unsigned int i, filter_len;
+ unsigned int i;
+ size_t filter_len;
if (setting_name_filters == NULL) {
printf("%s=%s\n", key, value);
struct hostname_format fmt;
const char *p;
unsigned char hash[GUID_128_HOST_HASH_SIZE];
- unsigned int len, n, limit;
+ unsigned int n, limit;
HASH_TABLE(void *, void *) hosts;
void *key, *value;
string_t *host;
fmt.suffix = p;
} else {
/* detect host1[suffix] vs host01[suffix] */
- len = strlen(my_hostname);
+ size_t len = strlen(my_hostname);
while (len > 0 && !i_isdigit(my_hostname[len-1]))
len--;
fmt.suffix = my_hostname + len;
const char *key, const char *value)
{
const char *p;
- unsigned int len;
+ size_t len;
if (strcmp(key, "base_dir") == 0) {
len = strlen(value);
{
const struct socket_set *set = &ctx->old->socket_set;
const char *path, *prefix;
- unsigned int len;
+ size_t len;
bool master_suffix;
if (set->path == NULL) {
void director_connection_send(struct director_connection *conn,
const char *data)
{
- unsigned int len = strlen(data);
+ size_t len = strlen(data);
off_t ret;
if (conn->output->closed || !conn->connected)
t_strdup_printf("\"error\":\"%s: user doesn't exist\"",
lookup_name));
} else if (show_field != NULL) {
- unsigned int show_field_len = strlen(show_field);
+ size_t show_field_len = strlen(show_field);
string_t *json_field = t_str_new(show_field_len+1);
json_append_escaped(json_field, show_field);
o_stream_nsend_str(doveadm_print_ostream, t_strdup_printf("\"%s\":", str_c(json_field)));
"%s: user %s doesn't exist\n", lookup_name,
input->username);
} else if (show_field != NULL) {
- unsigned int show_field_len = strlen(show_field);
+ size_t show_field_len = strlen(show_field);
for (; *fields != NULL; fields++) {
if (strncmp(*fields, show_field, show_field_len) == 0 &&
{
int argc = *_argc;
const char *const *argv = *_argv;
- unsigned int len;
+ size_t len;
if (argc < 2)
return FALSE;
const char *const *argv[])
{
const struct doveadm_cmd *cmd;
- unsigned int cmd_name_len;
+ size_t cmd_name_len;
i_assert(*argc > 0);
unsigned int async_count)
{
struct fs_file *file;
- unsigned int path_len;
+ size_t path_len;
path_len = strlen(path);
if (path_len > 0 && path[path_len-1] != '/')
struct stat st;
char *key;
string_t *full_path;
- unsigned int dir_len;
+ size_t dir_len;
dir = opendir(path);
if (dir == NULL) {
static bool log_type_find(const char *str, enum log_type *type_r)
{
- unsigned int i, len = strlen(str);
+ unsigned int i;
+ size_t len = strlen(str);
for (i = 0; i < LAST_LOG_TYPE; i++) {
if (strncasecmp(str, failure_log_type_prefixes[i], len) == 0 &&
static const char *t_cmd_log_error_trim(const char *orig)
{
- unsigned int pos;
+ size_t pos;
/* Trim whitespace from suffix and remove ':' if it exists */
for (pos = strlen(orig); pos > 0; pos--) {
array_foreach(&ctx->mailboxes, namep) {
const char *name = *namep;
- unsigned int len;
+ size_t len;
bool directory = FALSE;
ns = mail_namespace_find(user->namespaces, name);
const char *cmdname, int *argc,
const char *const **argv)
{
- unsigned int len;
+ size_t len;
if (*argc < 2)
return FALSE;
const char *const **argv)
{
const struct doveadm_mail_cmd *cmd;
- unsigned int cmd_name_len;
+ size_t cmd_name_len;
const char *const *orig_argv;
int orig_argc;
bool doveadm_mail_has_subcommands(const char *cmd_name)
{
const struct doveadm_mail_cmd *cmd;
- unsigned int len = strlen(cmd_name);
+ size_t len = strlen(cmd_name);
array_foreach(&doveadm_mail_cmds, cmd) {
if (strncmp(cmd->name, cmd_name, len) == 0 &&
const char *key;
const char *title;
enum doveadm_print_header_flags flags;
- unsigned int min_length, max_length, length;
+ size_t min_length, max_length, length;
};
struct doveadm_print_table_context {
{
struct doveadm_print_table_header *headers;
const char *value, *const *values;
- unsigned int i, line, len, hdr_count, value_count, line_count;
- unsigned int max_length, orig_length, diff;
+ unsigned int i, line, hdr_count, value_count, line_count;
+ size_t len, max_length, orig_length, diff;
ctx->lengths_set = TRUE;
struct dirent *d;
struct stat st, first_st;
string_t *path;
- unsigned int dir_len;
+ size_t dir_len;
int ret;
if (argc < 3)
struct dirent *d;
struct stat st;
string_t *str;
- unsigned int dir_len, hash_len;
+ size_t dir_len, hash_len;
if (argc < 3 || strlen(argv[2]) < 4)
help(&doveadm_cmd_sis_find);
DIR *dir;
struct dirent *d;
const char *plugin_name;
- unsigned int name_len = strlen(name);
+ size_t name_len = strlen(name);
bool found = FALSE;
/* first check that it's not actually loaded */
const char *cmd, *args, *p, *short_name, *sub_name;
const char *prev_name = "", *prev_sub_name = "";
const char **lines;
- unsigned int i, count, prefix_len = strlen(prefix);
+ unsigned int i, count;
+ size_t prefix_len = strlen(prefix);
/* split lines */
lines = (void *)p_strsplit(pool_datastack_create(), str, "\n");
{
const struct doveadm_cmd_ver2 *cmd2;
const struct doveadm_cmd *cmd;
- unsigned int len = strlen(cmd_name);
+ size_t len = strlen(cmd_name);
array_foreach(&doveadm_cmds, cmd) {
if (strncmp(cmd->name, cmd_name, len) == 0 &&
const char *const *name_parts)
{
const char *part, *prefix = ns->prefix;
- unsigned int part_len;
+ size_t part_len;
char ns_sep = mail_namespace_get_sep(ns);
if ((ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0 &&
struct dsync_mailbox_node *node)
{
const char *full_name;
- unsigned int prefix_len = node->ns == NULL ? 0 : node->ns->prefix_len;
+ size_t prefix_len = node->ns == NULL ? 0 : node->ns->prefix_len;
if (strcmp(node->name, "INBOX") == 0 && node->parent == &tree->root)
return TRUE;
const char *old_name, *new_name, *p;
char name[TEMP_MAX_NAME_LEN+1];
buffer_t buf;
- unsigned int prefix_len, max_prefix_len, counter = 1;
+ size_t prefix_len, max_prefix_len;
+ unsigned int counter = 1;
i_assert(!sync_node_is_namespace_prefix(tree, node));
static void suffix_inc(string_t *str)
{
char *data;
- unsigned int i;
+ size_t i;
data = str_c_modifiable(str) + str_len(str)-1;
for (i = str_len(str); i > 0; i--, data--) {
{
const char *p, *new_suffix;
string_t *str = t_str_new(256);
- unsigned int max_prefix_len;
+ size_t max_prefix_len;
/* The name is currently <oldname>-<temp>. Both sides need to
use equivalent names, so we'll replace the <temp> if possible
return iter;
}
-static unsigned int node_get_full_name_length(struct dsync_mailbox_node *node)
+static size_t node_get_full_name_length(struct dsync_mailbox_node *node)
{
if (node->parent->parent == NULL)
return strlen(node->name);
const char **full_name_r,
struct dsync_mailbox_node **node_r)
{
- unsigned int len;
+ size_t len;
if (iter->cur->first_child != NULL)
iter->cur = iter->cur->first_child;
const struct dsync_mailbox_node *src,
string_t *path)
{
- unsigned int prefix_len = str_len(path);
+ size_t prefix_len = str_len(path);
struct dsync_mailbox_node *node;
if (prefix_len > 0) {
mailbox_flags2str(struct cmd_list_context *ctx, string_t *str,
const char *special_use, enum mailbox_info_flags flags)
{
- unsigned int orig_len = str_len(str);
+ size_t orig_len = str_len(str);
if ((flags & MAILBOX_NONEXISTENT) != 0 && !ctx->used_listext) {
flags |= MAILBOX_NOSELECT;
struct imap_notify_namespace *notify_ns;
struct imap_notify_mailboxes *notify_boxes;
const char *const *names;
- unsigned int i, count, cur_len, name_len = strlen(name);
+ unsigned int i, count;
+ size_t cur_len, name_len = strlen(name);
char ns_sep = mail_namespace_get_sep(ns);
if ((ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0 &&
struct mail_namespace *old_ns, *new_ns;
struct mailbox *old_box, *new_box;
const char *oldname, *newname;
- unsigned int oldlen;
+ size_t oldlen;
/* <old name> <new name> */
if (!client_read_string_args(cmd, 2, &oldname, &newname))
static bool str_ends_with_char(const char *str, char c)
{
- unsigned int len = strlen(str);
+ size_t len = strlen(str);
return len > 0 && str[len-1] == c;
}
bool imap_mailbox_flags2str(string_t *str, enum mailbox_info_flags flags)
{
- unsigned int orig_len = str_len(str);
+ size_t orig_len = str_len(str);
if ((flags & MAILBOX_SUBSCRIBED) != 0)
str_append(str, "\\Subscribed ");
{
struct mailbox *box;
const char *const *namep;
- unsigned int name_len;
+ size_t name_len;
char ns_sep;
bool ret;
{
const struct mailbox_status *status = &result->status;
string_t *str;
- unsigned int prefix_len;
+ size_t prefix_len;
str = t_str_new(128);
str_append(str, "* STATUS ");
const char *tag;
const unsigned char *input;
- unsigned int input_size;
+ size_t input_size;
bool send_untagged_capability;
};
static void
-client_parse_input(const unsigned char *data, unsigned int len,
+client_parse_input(const unsigned char *data, size_t len,
struct client_input *input_r)
{
- unsigned int taglen;
+ size_t taglen;
i_assert(len > 0);
static bool ipc_socket_is_client(const char *name)
{
- unsigned int len;
+ size_t len;
if (strcmp(name, "ipc") == 0)
return TRUE;
const struct compression_handler *
compression_lookup_handler_from_ext(const char *path)
{
- unsigned int i, len, path_len = strlen(path);
+ unsigned int i;
+ size_t len, path_len = strlen(path);
for (i = 0; compression_handlers[i].name != NULL; i++) {
if (compression_handlers[i].ext == NULL)
static int o_stream_bzlib_send_flush(struct bzlib_ostream *zstream)
{
bz_stream *zs = &zstream->zs;
- unsigned int len;
+ size_t len;
bool done = FALSE;
int ret;
static int o_stream_lzma_send_flush(struct lzma_ostream *zstream)
{
lzma_stream *zs = &zstream->strm;
- unsigned int len;
+ size_t len;
bool done = FALSE;
int ret;
o_stream_zlib_send_flush(struct zlib_ostream *zstream, bool final)
{
z_stream *zs = &zstream->zs;
- unsigned int len;
+ size_t len;
bool done = FALSE;
int ret, flush;
DBC *cursor;
char *path;
- unsigned int path_len;
+ size_t path_len;
DBT pkey, pdata;
struct file_dict_iterate_path {
const char *path;
- unsigned int len;
+ size_t len;
};
struct file_dict_iterate_context {
char *key, *value, *old_value;
char *orig_key, *orig_value;
const struct dict_transaction_memory_change *change;
- unsigned int new_len;
+ size_t new_len;
long long diff;
array_foreach(&ctx->changes, change) {
buffer_t *cmd;
struct {
const unsigned char *value;
- unsigned int value_len;
+ size_t value_len;
enum memcached_response status;
bool reply_received;
} reply;
struct memcached_dict *dict = (struct memcached_dict *)_dict;
struct ioloop *prev_ioloop = current_ioloop;
struct timeout *to;
- unsigned int key_len;
+ size_t key_len;
if (strncmp(key, DICT_PATH_SHARED, strlen(DICT_PATH_SHARED)) == 0)
key += strlen(DICT_PATH_SHARED);
key_len = strlen(key);
if (key_len > 0xffff) {
*error_r = t_strdup_printf(
- "memcached: Key is too long (%u bytes): %s", key_len, key);
+ "memcached: Key is too long (%"PRIuSIZE_T" bytes): %s", key_len, key);
return -1;
}
struct setting_parser_ctx *ctx)
{
struct dict_sql_map_field *field;
- unsigned int value_len;
+ size_t value_len;
switch (ctx->type) {
case SECTION_ROOT:
struct sql_result *result;
string_t *key;
const struct dict_sql_map *map;
- unsigned int key_prefix_len, pattern_prefix_len, next_map_idx;
- unsigned int path_idx, sql_fields_start_idx;
+ size_t key_prefix_len, pattern_prefix_len;
+ unsigned int path_idx, sql_fields_start_idx, next_map_idx;
bool synchronous_result;
bool iter_query_sent;
const char *error;
static bool
dict_sql_map_match(const struct dict_sql_map *map, const char *path,
- ARRAY_TYPE(const_string) *values, unsigned int *pat_len_r,
- unsigned int *path_len_r, bool partial_ok, bool recurse)
+ ARRAY_TYPE(const_string) *values, size_t *pat_len_r,
+ size_t *path_len_r, bool partial_ok, bool recurse)
{
const char *path_start = path;
const char *pat, *field, *p;
- unsigned int len;
+ size_t len;
array_clear(values);
pat = map->pattern;
ARRAY_TYPE(const_string) *values)
{
const struct dict_sql_map *maps;
- unsigned int i, count, len;
+ unsigned int i, count;
+ size_t len;
t_array_init(values, dict->set->max_field_count);
maps = array_get(&dict->set->maps, &count);
{
struct sql_dict *dict = (struct sql_dict *)ctx->ctx.dict;
const struct dict_sql_map *maps;
- unsigned int i, count, pat_len, path_len;
+ unsigned int i, count;
+ size_t pat_len, path_len;
bool recurse = (ctx->flags & DICT_ITERATE_FLAG_RECURSE) != 0;
t_array_init(values, dict->set->max_field_count);
break;
}
case FS_DICT_VALUE_ENCODING_BASE64: {
- const unsigned int base64_size =
+ const size_t base64_size =
MAX_BASE64_ENCODED_SIZE(file->write_buffer->used);
string_t *base64 = t_str_new(base64_size);
base64_encode(file->write_buffer->data,
struct posix_fs {
struct fs fs;
char *temp_file_prefix, *root_path, *path_prefix;
- unsigned int temp_file_prefix_len;
+ size_t temp_file_prefix_len;
enum fs_posix_lock_method lock_method;
mode_t mode;
bool mode_auto;
struct test_fs_iter *iter = (struct test_fs_iter *)_iter;
struct test_fs *fs = (struct test_fs *)_iter->fs;
const char *const *files, *p;
- unsigned int count, len, prev_dir_len = strlen(iter->prev_dir);
+ unsigned int count;
+ size_t len, prev_dir_len = strlen(iter->prev_dir);
files = array_get(&fs->iter_files, &count);
for (; iter->idx < count; iter->idx++) {
#include "fts-common.h"
#include "fts-filter-private.h"
-static unichar_t get_ending_utf8_char(const char *str, unsigned int *end_pos)
+static unichar_t get_ending_utf8_char(const char *str, size_t *end_pos)
{
unichar_t c;
const char **token,
const char **error_r ATTR_UNUSED)
{
- unsigned int len = strlen(*token);
+ size_t len = strlen(*token);
unichar_t c;
if (len > 1 && ((*token)[len-1] == 's' || (*token)[len-1] == 'S')) {
void fts_icu_utf8_to_utf16(buffer_t *dest_utf16, const char *src_utf8)
{
UErrorCode err = U_ZERO_ERROR;
- unsigned int src_bytes = strlen(src_utf8);
+ size_t src_bytes = strlen(src_utf8);
int32_t utf16_len;
UChar *dest_data, *retp = NULL;
int32_t avail_uchars = 0;
/* we're searching and we want to find only the full
user@domain (not "user" and "domain"). we'll do this by
not feeding the last user@domain to parent tokenizer. */
- unsigned int parent_prefix_len =
+ size_t parent_prefix_len =
str_len(tok->parent_data) - str_len(tok->last_word);
i_assert(str_len(tok->parent_data) >= str_len(tok->last_word) &&
strcmp(str_c(tok->parent_data) + parent_prefix_len,
{
const unsigned char *input = (const unsigned char *)_input;
const char *token, *error;
- unsigned int i, outi, max, char_len, input_len = strlen(_input);
+ unsigned int i, outi, max, char_len;
+ size_t input_len = strlen(_input);
/* test all input at once */
outi = first_outi;
{
const unsigned char *data, *p;
size_t size, line_len, line_start_pos;
- unsigned int key_len = strlen(key);
+ size_t key_len = strlen(key);
i_assert(req->state == HTTP_REQUEST_STATE_NEW ||
/* allow calling for retries */
struct imapc_connection *conn = context;
const unsigned char *sasl_output;
unsigned int sasl_output_len;
- unsigned int input_len;
+ size_t input_len;
buffer_t *buf;
const char *error;
struct imapc_command *const *cmds, *cmd;
struct imapc_command_reply reply;
const unsigned char *p, *data;
- unsigned int count, seek_pos, start_pos, end_pos, size;
+ unsigned int count, size;
+ size_t seek_pos, start_pos, end_pos;
int ret;
if (imapc_connection_is_throttled(conn))
void imapc_command_send(struct imapc_command *cmd, const char *cmd_str)
{
- unsigned int len = strlen(cmd_str);
+ size_t len = strlen(cmd_str);
cmd->data = str_new(cmd->pool, 6 + len + 2);
str_printfa(cmd->data, "%u %s\r\n", cmd->tag, cmd_str);
{
struct imap_match_glob *glob;
struct imap_match_pattern *match_patterns;
- unsigned int i, len, pos, patterns_count, patterns_data_len = 0;
+ unsigned int i, patterns_count;
+ size_t len, pos, patterns_data_len = 0;
patterns_count = str_array_length(patterns);
match_patterns = p_new(pool, struct imap_match_pattern,
static bool imap_parser_is_next_text(struct imap_parser *parser)
{
const struct imap_arg *arg;
- unsigned int len;
+ size_t len;
if (parser->cur_list != &parser->root_list)
return FALSE;
static void
imap_append_literal(string_t *dest, const char *src, unsigned int pos)
{
- unsigned int full_len = pos + strlen(src+pos);
+ size_t full_len = pos + strlen(src+pos);
- str_printfa(dest, "{%u}\r\n", full_len);
+ str_printfa(dest, "{%"PRIuSIZE_T"}\r\n", full_len);
buffer_append(dest, src, full_len);
}
void imap_append_nstring(string_t *dest, const char *src)
{
- unsigned int i, escape_count = 0;
+ unsigned int escape_count = 0;
+ size_t i;
if (src == NULL) {
str_append(dest, "NIL");
};
static void
-mbase64_encode(string_t *dest, const unsigned char *in, unsigned int len)
+mbase64_encode(string_t *dest, const unsigned char *in, size_t len)
{
str_append_c(dest, '&');
while (len >= 3) {
static bool lmtp_client_send_xclient(struct lmtp_client *client)
{
string_t *str;
- unsigned int empty_len;
+ size_t empty_len;
if (client->xclient_args == NULL) {
/* not supported */
unsigned int base64_block_pos;
buffer_t *hdr_buf;
- unsigned int cte_header_len;
+ size_t cte_header_len;
bool content_type_seen:1;
};
char *charset_trans_charset;
struct charset_translation *charset_trans;
char translation_buf[CHARSET_MAX_PENDING_BUF_SIZE];
- unsigned int translation_size;
+ size_t translation_size;
struct qp_decoder *qp;
buffer_t *encoding_buf;
const unsigned char **data, size_t *size)
{
unsigned char trans_buf[CHARSET_MAX_PENDING_BUF_SIZE+1];
- unsigned int data_wanted, skip;
+ size_t data_wanted, skip;
size_t trans_size, orig_size;
/* @UNSAFE: move the previously untranslated bytes to trans_buf
static size_t
message_header_decode_encoded(const unsigned char *data, size_t size,
- buffer_t *decodebuf, unsigned int *charsetlen_r)
+ buffer_t *decodebuf, size_t *charsetlen_r)
{
#define QCOUNT 3
unsigned int num = 0;
return start_pos[2] + 2;
}
-static bool is_only_lwsp(const unsigned char *data, unsigned int size)
+static bool is_only_lwsp(const unsigned char *data, size_t size)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < size; i++) {
if (!(data[i] == ' ' || data[i] == '\t' ||
void *context)
{
buffer_t *decodebuf = NULL;
- unsigned int charsetlen = 0;
+ size_t charsetlen = 0;
size_t pos, start_pos, ret;
/* =?charset?Q|B?text?= */
static bool test_istream_attachment_extractor_one(const char *body)
{
- const unsigned int prefix_len = strlen(mail_broken_input_body_prefix);
+ const size_t prefix_len = strlen(mail_broken_input_body_prefix);
struct istream_attachment_settings set;
struct istream *datainput, *input;
char *mail_text;
struct istream *test_input, *input;
const unsigned char *data;
size_t size;
- unsigned int i, outsize, input_len, output_len;
+ unsigned int i;
+ size_t outsize, input_len, output_len;
string_t *str;
uoff_t offset;
int ret;
static void test_istream_dot_error(const char *input_str, bool test_bufsize)
{
struct istream *test_input, *input;
- unsigned int i, outsize, input_len;
+ unsigned int i;
+ size_t outsize, input_len;
uoff_t offset;
int ret;
{
struct run_ctx run_ctx = { .callback = callback, .null_hdr_seen = FALSE };
struct istream *filter;
- unsigned int i, output_len = strlen(output);
+ unsigned int i;
+ size_t output_len = strlen(output);
const struct stat *st;
const unsigned char *data;
size_t size;
const char *input = "From: foo\nFrom: abc\nTo: bar\nSubject: plop\nX-Drop: 1\n\nhello world\n";
const char *output = "From: abc\n\nhello world\n";
struct istream *istream, *filter, *filter2;
- unsigned int i, input_len = strlen(input);
- unsigned int output_len = strlen(output);
+ unsigned int i;
+ size_t input_len = strlen(input);
+ size_t output_len = strlen(output);
const unsigned char *data;
const struct stat *st;
size_t size;
const char *output = "From: foo\n\nhello world\n";
const struct stat *st;
struct istream *istream, *filter;
- unsigned int i, input_len = strlen(input);
- unsigned int output_len = strlen(output);
+ unsigned int i;
+ size_t input_len = strlen(input);
+ size_t output_len = strlen(output);
const unsigned char *data;
string_t *str = t_str_new(64);
size_t size;
decode_test(const char *qp_input, const char *output, bool broken_input,
unsigned int buffer_size)
{
- unsigned int qp_input_len = strlen(qp_input);
+ size_t qp_input_len = strlen(qp_input);
struct istream *input_data, *input;
const unsigned char *data;
size_t i, size;
{ 0, 0, NULL, -1 },
{ 0, 0, NULL, -1 },
};
- unsigned int i, j, len;
+ unsigned int i, j;
+ size_t len;
struct tm *tm;
char *sender;
bool success;
struct message_header_parser_ctx *parser;
struct message_header_line *hdr;
struct istream *input;
- unsigned int i, len = strlen(str);
+ unsigned int i;
+ size_t len = strlen(str);
input = test_istream_create(str);
test_istream_set_max_buffer_size(input, buffer_size);
static const char *lf_str = "1234567890: 345\n\n";
static const char *crlf_str = "1234567890: 345\r\n\r\n";
struct message_size hdr_size;
- unsigned int i, len;
+ size_t i, len;
test_begin("message header parser long lines");
len = strlen(lf_str);
struct master_login *login = pl->client->conn->login;
char buf[1024];
const char *const *auth_args;
- unsigned int len;
+ size_t len;
ssize_t ret;
int fd = -1;
struct master_login_client *client;
struct master_login *login = conn->login;
unsigned char data[MASTER_AUTH_MAX_DATA_SIZE];
- unsigned int i, session_len = 0;
+ size_t i, session_len = 0;
int ret, client_fd;
ret = master_login_conn_read_request(conn, &req, data, &client_fd);
unsigned major_version,
unsigned int *minor_version_r)
{
- unsigned int service_name_len = strlen(service_name);
+ size_t service_name_len = strlen(service_name);
bool ret;
if (strncmp(line, "VERSION\t", 8) != 0)
uint32_t uid;
const char *dir;
string_t *src_path, *dest_path;
- unsigned int n, src_prefixlen, dest_prefixlen;
+ unsigned int n;
+ size_t src_prefixlen, dest_prefixlen;
i_assert(ctx->finished);
struct mail_index_transaction *trans;
string_t *path;
- unsigned int path_dir_prefix_len;
+ size_t path_dir_prefix_len;
uint32_t uid_validity;
};
static void dbox_file_skip_broken_header(struct dbox_file *file)
{
- const unsigned int magic_len = strlen(DBOX_MAGIC_PRE);
+ const size_t magic_len = strlen(DBOX_MAGIC_PRE);
const unsigned char *data;
size_t i, size;
static int
mdbox_find_highest_file_id(struct mdbox_map *map, uint32_t *file_id_r)
{
- const unsigned int prefix_len = strlen(MDBOX_MAIL_FILE_PREFIX);
+ const size_t prefix_len = strlen(MDBOX_MAIL_FILE_PREFIX);
DIR *dir;
struct dirent *d;
unsigned int id, highest_id = 0;
DIR *dir;
struct dirent *d;
string_t *path;
- unsigned int file_id, dir_len;
+ unsigned int file_id;
+ size_t dir_len;
int ret = 0;
if (!array_is_created(&dstorage->move_to_alt_map_uids) &&
{
struct imapc_mailbox_list *list = (struct imapc_mailbox_list *)_list;
const char *prefix = list->set->imapc_list_prefix;
- unsigned int prefix_len;
+ size_t prefix_len;
if (*storage_name == '\0') {
/* ACL plugin does these lookups */
vname = mailbox_list_get_vname(&list->list, name);
if (list->set->imapc_list_prefix[0] != '\0') {
/* put back the prefix, so it gets included in the filesystem. */
- unsigned int vname_len = strlen(vname);
+ size_t vname_len = strlen(vname);
if (ns->prefix_len > 0) {
/* skip over the namespace prefix */
struct mailbox_list_iterate_context *iter;
const struct mailbox_info *info;
const char *imapc_list_prefix = list->set->imapc_list_prefix;
- unsigned int imapc_list_prefix_len = strlen(imapc_list_prefix);
+ size_t imapc_list_prefix_len = strlen(imapc_list_prefix);
const char *fs_name, *vname;
if (fs_list == NULL)
case SEARCH_SINCE:
if ((capa & IMAPC_CAPABILITY_WITHIN) == 0) {
/* a bit kludgy way to check this.. */
- unsigned int pos = str_len(str);
+ size_t pos = str_len(str);
if (!mail_search_arg_to_imap(str, arg, &error))
return FALSE;
if (strncasecmp(str_c(str) + pos, "OLDER", 5) == 0 ||
imapc_namespace_find_mailbox(struct imapc_storage *storage, const char *name)
{
const struct imapc_namespace *ns, *best_ns = NULL;
- unsigned int best_len = UINT_MAX, len;
+ size_t best_len = UINT_MAX, len;
array_foreach(&storage->remote_namespaces, ns) {
len = strlen(ns->prefix);
struct mailbox_attribute_iter iter;
struct dict_iterate_context *diter;
char *prefix;
- unsigned int prefix_len;
+ size_t prefix_len;
bool dict_disabled;
};
static void str_replace_nuls(string_t *str)
{
char *data = str_c_modifiable(str);
- unsigned int i, len = str_len(str);
+ size_t i, len = str_len(str);
for (i = 0; i < len; i++) {
if (data[i] == '\0')
}
static void compress_lwsp(string_t *dest, const unsigned char *src,
- unsigned int src_len)
+ size_t src_len)
{
- unsigned int i;
+ size_t i;
bool prev_lwsp = TRUE;
for (i = 0; i < src_len; i++) {
if (addr->name != NULL) {
string_t *str;
- unsigned int len = strlen(addr->name);
+ size_t len = strlen(addr->name);
str = t_str_new(len*2);
(void)message_header_decode_utf8(
string_t *fname)
{
const unsigned int *indexes;
- unsigned int i, count, start = str_len(fname);
+ unsigned int i, count;
+ size_t start = str_len(fname);
char chr;
indexes = array_get(keywords, &count);
{
struct mailbox *box = &mbox->box;
const struct mailbox_permissions *perm = mailbox_get_permissions(box);
- unsigned int prefix_len;
+ size_t prefix_len;
const char *tmp_fname;
string_t *path;
mode_t old_mask;
{
const unsigned char *p;
buffer_t *buf;
- unsigned int len;
+ size_t len;
/* copy existing extensions, except for the one we're updating */
buf = buffer_create_dynamic(pool_datastack_create(), 128);
string_t *str;
const unsigned char *p;
const char *strp;
- unsigned int len;
+ size_t len;
i_assert(fd != -1);
mbox_is_internal_name(struct mailbox_list *list ATTR_UNUSED,
const char *name)
{
- unsigned int len;
+ size_t len;
/* don't allow *.lock files/dirs */
len = strlen(name);
{
struct mail_namespace *ns = list->ns;
const char *ns_ref, *prefix = list->ns->prefix;
- unsigned int prefix_len = strlen(prefix);
+ size_t prefix_len = strlen(prefix);
if (*ref != '\0' && strncmp(ref, prefix, prefix_len) == 0)
ns_ref = ref + prefix_len;
DIR *dir;
struct dirent *d;
string_t *full_path;
- unsigned int dir_len;
+ size_t dir_len;
const char *error;
bool mailbox_dir, unlinked_something = FALSE;
enum mailbox_list_path_type type)
{
const char *root_dir, *p;
- unsigned int len;
+ size_t len;
root_dir = mailbox_list_get_root_forced(list, type);
if (strncmp(path, root_dir, strlen(root_dir)) != 0) {
struct mailbox_list *_list = ctx->ctx.list;
ARRAY(const char *) valid_patterns;
const char *pattern, *test_pattern, *real_pattern, *error;
- unsigned int prefix_len;
+ size_t prefix_len;
prefix_len = strlen(_list->ns->prefix);
p_array_init(&valid_patterns, ctx->ctx.pool, 8);
ctx->ctx.list->mail_set->mail_full_filesystem_access;
const char *const *patterns, *pattern, *const *parentp, *const *childp;
const char *p, *last, *root, *prefix_vname;
- unsigned int i, parentlen;
+ unsigned int i;
+ size_t parentlen;
i_assert(*ctx->valid_patterns != NULL);
/* Get the current mailbox name with \0 separators. */
char sep = mailbox_list_get_hierarchy_sep(box->list);
char *box_zerosep_name = t_strdup_noconst(box->name);
- unsigned int box_name_len = strlen(box_zerosep_name);
- for (unsigned int i = 0; i < box_name_len; i++) {
+ size_t box_name_len = strlen(box_zerosep_name);
+ for (size_t i = 0; i < box_name_len; i++) {
if (box_zerosep_name[i] == sep)
box_zerosep_name[i] = '\0';
}
struct mailbox_list *_newlist, const char *newname)
{
struct index_mailbox_list *list = (struct index_mailbox_list *)_oldlist;
- const unsigned int oldname_len = strlen(oldname);
+ const size_t oldname_len = strlen(oldname);
struct mailbox_list_index_sync_context *sync_ctx;
struct mailbox_list_index_record oldrec, newrec;
struct mailbox_list_index_node *oldnode, *newnode, *child;
struct mailbox_info info;
pool_t info_pool;
- unsigned int parent_len;
+ size_t parent_len;
string_t *path;
struct mailbox_list_index_node *next_node;
struct imap_match_glob *glob;
enum imap_match_result result;
const char *prefix_without_sep;
- unsigned int len;
+ size_t len;
len = ns->prefix_len;
if (len > 0 && ns->prefix[len-1] == mail_namespace_get_sep(ns))
const char *prefix)
{
struct mail_namespace *ns;
- unsigned int prefix_len = strlen(prefix);
+ size_t prefix_len = strlen(prefix);
int ret;
for (ns = ctx->namespaces; ns != NULL; ns = ns->next) {
bool only_subscribed, unsigned int *idx_r)
{
struct mailbox_settings *const *sets;
- unsigned int i, count, len, name_len = strlen(name);
+ unsigned int i, count;
+ size_t len, name_len = strlen(name);
enum autocreate_match_result result = 0;
char sep = mail_namespace_get_sep(ns);
/* there are autocreate parent boxes.
set their children flag states. */
struct autocreate_box *autobox;
- unsigned int name_len;
+ size_t name_len;
char sep = mail_namespace_get_sep(ctx->list->ns);
array_foreach_modifiable(&actx->boxes, autobox) {
struct mail_namespace *ns = ctx->ctx.list->ns;
struct mailbox_node *node;
const char *p;
- unsigned int vname_len = strlen(vname);
+ size_t vname_len = strlen(vname);
bool created;
char ns_sep = mail_namespace_get_sep(ns);
ARRAY(const char *) names_arr;
const char *pattern, *oldpath, *newpath, *old_childname, *new_childname;
const char *const *names, *old_vname, *new_vname;
- unsigned int i, count, old_vnamelen;
+ unsigned int i, count;
+ size_t old_vnamelen;
pool_t pool;
char old_ns_sep;
int ret;
{
struct mailbox_node *node;
struct mailbox_notify_node *nnode;
- unsigned int prefix_len;
+ size_t prefix_len;
bool created;
str_append(path, index_node->name);
struct mail_namespace *namespaces = default_ns->user->namespaces;
struct mailbox_node *node;
const char *vname, *ns_name, *error;
- unsigned int len;
+ size_t len;
bool created;
/* default_ns is whatever namespace we're currently listing.
{
struct mail_namespace *ns = namespaces;
struct mail_namespace *best = NULL;
- unsigned int best_len = 0;
+ size_t best_len = 0;
bool inbox;
inbox = strncasecmp(box, "INBOX", 5) == 0;
const char *prefix)
{
struct mail_namespace *ns;
- unsigned int len = strlen(prefix);
+ size_t len = strlen(prefix);
for (ns = namespaces; ns != NULL; ns = ns->next) {
if (ns->prefix_len == len &&
const char *prefix)
{
struct mail_namespace *ns;
- unsigned int len = strlen(prefix);
+ size_t len = strlen(prefix);
for (ns = namespaces; ns != NULL; ns = ns->next) {
if (ns->prefix_len == len + 1 &&
struct setting_parser_context *set_parser = user->set_parser;
bool mail_debug;
const char *key, *orig_key, *append_value = NULL;
- unsigned int len;
+ size_t len;
int ret;
mail_debug = mail_user_set_get_mail_debug(user->user_info,
const char *const *fields)
{
const char *field_name = t_strcut(data, ':');
- unsigned int i, field_name_len;
+ unsigned int i;
+ size_t field_name_len;
if (fields == NULL)
return field_get_default(data);
mail_storage_service_generate_session_id(pool_t pool, const char *prefix)
{
guid_128_t guid;
- unsigned int prefix_len = prefix == NULL ? 0 : strlen(prefix);
+ size_t prefix_len = prefix == NULL ? 0 : strlen(prefix);
string_t *str = str_new(pool, MAX_BASE64_ENCODED_SIZE(prefix_len + 1 + sizeof(guid)));
if (prefix != NULL)
{
struct mail_storage_service_privileges priv;
const char *error;
- unsigned int len;
+ size_t len;
bool disallow_root =
(user->flags & MAIL_STORAGE_SERVICE_FLAG_DISALLOW_ROOT) != 0;
bool temp_priv_drop =
static bool have_listable_namespace_prefix(struct mail_namespace *ns,
const char *name)
{
- unsigned int name_len = strlen(name);
+ size_t name_len = strlen(name);
for (; ns != NULL; ns = ns->next) {
if ((ns->flags & (NAMESPACE_FLAG_LIST_PREFIX |
{
struct module_dir_load_settings mod_set;
struct module *module;
- unsigned int name_len = strlen(name);
+ size_t name_len = strlen(name);
memset(&mod_set, 0, sizeof(mod_set));
mod_set.abi_version = DOVECOT_ABI_VERSION;
static bool need_escape_dirstart(const char *vname, const char *maildir_name)
{
- unsigned int len;
+ size_t len;
if (vname[0] == '.') {
if (vname[1] == '\0' || vname[1] == '/')
char ns_sep, char list_sep, char escape_char,
const char *maildir_name)
{
- unsigned int ns_prefix_len = strlen(ns_prefix);
+ size_t ns_prefix_len = strlen(ns_prefix);
string_t *escaped_name = t_str_new(64);
bool dirstart = TRUE;
const char *vname)
{
struct mail_namespace *ns = list->ns;
- unsigned int prefix_len = strlen(ns->prefix);
+ size_t prefix_len = strlen(ns->prefix);
const char *storage_name = vname;
string_t *str;
char list_sep, ns_sep, *ret;
mailbox_list_unescape_name_params(const char *src, const char *ns_prefix,
char ns_sep, char list_sep, char escape_char)
{
- unsigned int ns_prefix_len = strlen(ns_prefix);
+ size_t ns_prefix_len = strlen(ns_prefix);
string_t *dest = t_str_new(strlen(src));
unsigned int num;
const char *mailbox_list_default_get_vname(struct mailbox_list *list,
const char *storage_name)
{
- unsigned int i, prefix_len, name_len;
+ size_t i, prefix_len, name_len;
const char *vname = storage_name;
char list_sep, ns_sep, *ret;
enum mailbox_info_flags *flags_r)
{
const char *path, *fname, *rootdir, *dir, *inbox;
- unsigned int len;
+ size_t len;
*flags_r = 0;
const char **name)
{
const char *root_dir, *path, *mailbox_name;
- unsigned int len;
+ size_t len;
if (!list->mail_set->mail_full_filesystem_access)
return FALSE;
nodes = array_get(&ctx->node_path, &count);
node = NULL;
for (i = count; i != 0; i--) {
- unsigned int len = strlen(nodes[i-1]->name) + 1;
+ size_t len = strlen(nodes[i-1]->name) + 1;
i_assert(len <= ctx->parent_pos);
ctx->parent_pos -= len;
bool log_enoent)
{
string_t *src, *dest;
- unsigned int i, prefix_len;
+ unsigned int i;
+ size_t prefix_len;
int ret;
src = t_str_new(256);
DIR *d;
struct dirent *dp;
const char *fname, *dir, *prefix, *tmp;
- unsigned int i, prefix_len;
+ unsigned int i;
+ size_t prefix_len;
uint32_t cur_value, min_value, max_value;
mode_t old_mask;
int fd;
bool array_equal_fn_i(const struct array *array1, const struct array *array2,
int (*cmp)(const void *, const void*))
{
- unsigned int count1, count2, i, size;
+ unsigned int count1, count2, i;
+ size_t size;
if (!array_is_created_i(array1) || array1->buffer->used == 0)
return !array_is_created_i(array2) || array2->buffer->used == 0;
int (*cmp)(const void *, const void *, const void *),
const void *context)
{
- unsigned int count1, count2, i, size;
+ unsigned int count1, count2, i;
+ size_t size;
if (!array_is_created_i(array1) || array1->buffer->used == 0)
return !array_is_created_i(array2) || array2->buffer->used == 0;
int (*cmp)(const void *, const void *))
{
const void * const data = array->buffer->data;
- const unsigned int s = array->element_size;
+ const size_t s = array->element_size;
unsigned int idx;
for (idx = 0; idx < array_count_i(array); idx++) {
#endif
#else
extern char **environ;
- unsigned int len;
+ size_t len;
char **envp;
len = strlen(name);
io_loop_stop(ioloop);
}
-static int log_fd_write(int fd, const unsigned char *data, unsigned int len)
+static int log_fd_write(int fd, const unsigned char *data, size_t len)
{
struct ioloop *ioloop;
struct io *io;
return log_prefix != NULL ? log_prefix : "";
}
-static int internal_send_split(string_t *full_str, unsigned int prefix_len)
+static int internal_send_split(string_t *full_str, size_t prefix_len)
{
string_t *str;
- unsigned int max_text_len, pos = prefix_len;
+ size_t max_text_len, pos = prefix_len;
str = t_str_new(PIPE_BUF);
str_append_n(str, str_c(full_str), prefix_len);
recursed++;
T_BEGIN {
string_t *str;
- unsigned int prefix_len;
+ size_t prefix_len;
if (!log_prefix_sent && log_prefix != NULL) {
log_prefix_sent = TRUE;
struct istream_private istream;
/* current encoded line length. */
- unsigned int cur_line_len;
+ size_t cur_line_len;
unsigned int chars_per_line;
bool crlf;
static int json_parse_atom(struct json_parser *parser, const char *atom)
{
- unsigned int avail, len = strlen(atom);
+ size_t avail, len = strlen(atom);
avail = parser->end - parser->data;
if (avail < len) {
void json_append_escaped_data(string_t *dest, const unsigned char *src, size_t size)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < size; i++)
json_append_escaped_char(dest, src[i]);
const char **deps;
struct module *m;
string_t *errmsg;
- unsigned int len;
+ size_t len;
deps = dlsym(module->handle,
t_strconcat(module->name, "_dependencies", NULL));
struct module *module_dir_find(struct module *modules, const char *name)
{
struct module *module;
- unsigned int len = strlen(name);
+ size_t len = strlen(name);
for (module = modules; module != NULL; module = module->next) {
if (strncmp(module->name, name, len) == 0) {
static const char *module_name_drop_suffix(const char *name)
{
- unsigned int len;
+ size_t len;
len = strlen(name);
if (len > 7 && strcmp(name + len - 7, "_plugin") == 0)
T_BEGIN {
if (addr[0] == '[') {
/* allow [ipv6 addr] */
- unsigned int len = strlen(addr);
+ size_t len = strlen(addr);
if (addr[len-1] == ']')
addr = t_strndup(addr+1, len-2);
}
of it in one pwrite(). */
} else {
/* write only the suffix */
- unsigned int update_count = size - left;
+ size_t update_count = size - left;
data = CONST_PTR_OFFSET(data, update_count);
size -= update_count;
#include "printf-format-fix.h"
static const char *
-fix_format_real(const char *fmt, const char *p, unsigned int *len_r)
+fix_format_real(const char *fmt, const char *p, size_t *len_r)
{
const char *errstr;
char *buf;
- unsigned int len1, len2, len3;
+ size_t len1, len2, len3;
i_assert((size_t)(p - fmt) < INT_MAX);
i_assert(p[0] == '%' && p[1] == 'm');
}
static const char *
-printf_format_fix_noalloc(const char *format, unsigned int *len_r)
+printf_format_fix_noalloc(const char *format, size_t *len_r)
{
const char *p;
const char *ret = format;
return ret;
}
-const char *printf_format_fix_get_len(const char *format, unsigned int *len_r)
+const char *printf_format_fix_get_len(const char *format, size_t *len_r)
{
const char *ret;
const char *printf_format_fix(const char *format)
{
const char *ret;
- unsigned int len;
+ size_t len;
ret = printf_format_fix_noalloc(format, &len);
if (ret != format)
const char *printf_format_fix_unsafe(const char *format)
{
- unsigned int len;
+ size_t len;
return printf_format_fix_noalloc(format, &len);
}
used. If the format string was modified, it's returned from data stack. */
const char *printf_format_fix(const char *format) ATTR_FORMAT_ARG(1);
/* Like printf_format_fix(), except return also the format string's length. */
-const char *printf_format_fix_get_len(const char *format, unsigned int *len_r)
+const char *printf_format_fix_get_len(const char *format, size_t *len_r)
ATTR_FORMAT_ARG(1);
/* Like printf_format_fix(), except the format string is written to data
stack without actually allocating it. Data stack must not be used until
struct str_find_context *str_find_init(pool_t pool, const char *key)
{
struct str_find_context *ctx;
- unsigned int key_len = strlen(key);
+ size_t key_len = strlen(key);
i_assert(key_len > 0);
+ i_assert(key_len < INT_MAX);
ctx = p_malloc(pool, sizeof(struct str_find_context) +
sizeof(ctx->goodtab[0]) * key_len);
static void str_sanitize_truncate_char(string_t *dest, unsigned int initial_pos)
{
const unsigned char *data = str_data(dest);
- unsigned int len = str_len(dest);
+ size_t len = str_len(dest);
if (len == initial_pos)
return;
void str_sanitize_append(string_t *dest, const char *src, size_t max_bytes)
{
- unsigned int initial_pos = str_len(dest);
+ size_t initial_pos = str_len(dest);
unichar_t chr;
size_t i;
#define SNPRINTF_INITIAL_EXTRA_SIZE 128
va_list args2;
char *tmp;
- unsigned int init_size;
+ size_t init_size;
size_t pos = str->used;
int ret, ret2;
#define SNPRINTF_INITIAL_EXTRA_SIZE 256
va_list args2;
char *tmp;
- unsigned int init_size;
+ size_t init_size;
int ret;
#ifdef DEBUG
int old_errno = errno;
const char *t_str_replace(const char *str, char from, char to)
{
char *out;
- unsigned int i, len;
+ size_t i, len;
if (strchr(str, from) == NULL)
return str;
test_begin("printf_format_fix(safe)");
for (i = 0; i < N_ELEMENTS(tests); ++i) {
- unsigned int len;
+ size_t len;
T_BEGIN {
test_assert_idx(printf_format_fix(tests[i])
== tests[i], i);
needlen = strlen(needle);
for (i = 0; i < N_ELEMENTS(tests); ++i) {
- unsigned int len;
+ size_t len;
char const *chgd;
char const *insert;
unsigned int offs;
struct dirent *d;
struct stat st;
string_t *path;
- unsigned int prefix_len, dir_len;
+ size_t prefix_len, dir_len;
dirp = opendir(dir);
if (dirp == NULL) {
static int
var_expand_long(const struct var_expand_table *table,
const struct var_expand_func_table *func_table,
- const void *key_start, unsigned int key_len, void *context,
+ const void *key_start, size_t key_len, void *context,
const char **var_r, const char **error_r);
static const char *
static const char *
m_str_trim(const char *str, struct var_expand_context *ctx ATTR_UNUSED)
{
- unsigned int len;
+ size_t len;
len = strlen(str);
while (len > 0 && i_isspace(str[len-1]))
static int
var_expand_long(const struct var_expand_table *table,
const struct var_expand_func_table *func_table,
- const void *key_start, unsigned int key_len, void *context,
+ const void *key_start, size_t key_len, void *context,
const char **var_r, const char **error_r)
{
const struct var_expand_table *t;
const char *(*modifier[MAX_MODIFIER_COUNT])
(const char *, struct var_expand_context *);
const char *end;
- unsigned int i, len, modifier_count;
+ unsigned int i, modifier_count;
+ size_t len;
int ret, final_ret = 1;
*error_r = NULL;
str_append_n(dest, var, ctx.width);
} else {
/* %05d -like padding. no truncation. */
- int len = strlen(var);
+ ssize_t len = strlen(var);
while (len < ctx.width) {
str_append_c(dest, '0');
ctx.width--;
{
const char *transpos = client->lmtp_set->lmtp_address_translate;
const char *p, *nextstr, *addrpos = *address;
- unsigned int len;
+ size_t len;
string_t *username, *domain, *dest = NULL;
if (*transpos == '\0')
void log_error_buffer_add(struct log_error_buffer *buf,
const struct log_error *error)
{
- unsigned int prefix_size = strlen(error->prefix)+1;
- unsigned int text_size = strlen(error->text)+1;
+ size_t prefix_size = strlen(error->prefix)+1;
+ size_t text_size = strlen(error->text)+1;
struct log_error_data *data;
if (buf->count == LOG_ERROR_BUFFER_MAX_LINES)
int client_auth_read_line(struct client *client)
{
const unsigned char *data;
- size_t i, size;
- unsigned int len;
+ size_t i, size, len;
if (i_stream_read_more(client->input, &data, &size) == -1) {
client_destroy(client, "Disconnected");
{
struct client *client = context;
const char *field_name = data;
- unsigned int i, field_name_len;
+ unsigned int i;
+ size_t field_name_len;
*value_r = NULL;
static bool login_proxy_state_try_notify(struct login_proxy_state *state,
const char *user)
{
- unsigned int len;
+ size_t len;
ssize_t ret;
if (state->notify_fd == -1) {
const char **error_r)
{
struct file_listener_settings *const *sets;
- unsigned int base_dir_len = strlen(master_set->base_dir);
+ size_t base_dir_len = strlen(master_set->base_dir);
enum service_user_default user_default;
if (!array_is_created(l))
const char *const *strings;
ARRAY_TYPE(const_string) all_listeners;
struct passwd pw;
- unsigned int i, j, count, len, client_limit, process_limit;
+ unsigned int i, j, count, client_limit, process_limit;
unsigned int max_auth_client_processes, max_anvil_client_processes;
+ size_t len;
#ifdef CONFIG_BINARY
const struct service_settings *default_service;
#else
{
struct service_settings *const *services;
struct file_listener_settings *const *uls;
- unsigned int dir_len = strlen(dir);
+ size_t dir_len = strlen(dir);
array_foreach(&set->services, services) {
struct service_settings *service = *services;
struct dirent *dp;
struct stat st;
string_t *str;
- unsigned int prefix_len;
+ size_t prefix_len;
dirp = opendir(path);
if (dirp == NULL) {
{
struct restrict_access_settings rset;
bool disallow_root;
- unsigned int len;
+ size_t len;
if (service->vsz_limit != 0)
restrict_process_size(service->vsz_limit);
ARRAY_TYPE(const_string) old_ids_arr;
unsigned int newi, oldi, old_count, new_count;
string_t *path;
- unsigned int prefix_len;
+ size_t prefix_len;
int ret;
/* get all existing identifiers for the user. we might be able to
{
struct dict_iterate_context *dict_iter;
const char *const *idp, *prefix, *key, *value, *error;
- unsigned int prefix_len;
+ size_t prefix_len;
idp = array_idx(&iter->iter_ids, iter->iter_idx);
iter->iter_idx++;
{
struct mail_namespace *ns = ctx->list->ns;
const char *name;
- unsigned int len;
+ size_t len;
name = mailbox_list_get_storage_name(ns->list, vname);
len = strlen(name);
const struct mailbox_info *info;
string_t *pattern;
const char *prefix;
- unsigned int i, prefix_len;
+ size_t i, prefix_len;
bool stars = FALSE, ret = FALSE;
/* do we have child mailboxes with LOOKUP right that don't match
static bool
dict_ldap_map_match(const struct dict_ldap_map *map, const char *path,
- ARRAY_TYPE(const_string) *values, unsigned int *pat_len_r,
- unsigned int *path_len_r, bool partial_ok, bool recurse)
+ ARRAY_TYPE(const_string) *values, size_t *pat_len_r,
+ size_t *path_len_r, bool partial_ok, bool recurse)
{
const char *path_start = path;
const char *pat, *attribute, *p;
- unsigned int len;
+ size_t len;
array_clear(values);
pat = map->pattern;
ARRAY_TYPE(const_string) *values)
{
const struct dict_ldap_map *maps;
- unsigned int i, count, len;
+ unsigned int i, count;
+ size_t len;
t_array_init(values, dict->set->max_attribute_count);
maps = array_get(&dict->set->maps, &count);
}
static void
-xml_encode_data(string_t *dest, const unsigned char *data, unsigned int len)
+xml_encode_data(string_t *dest, const unsigned char *data, size_t len)
{
unichar_t chr;
- unsigned int i;
+ size_t i;
for (i = 0; i < len; i++) {
switch (data[i]) {
solr_add_definite_query_args(string_t *str, struct mail_search_arg *arg,
bool and_args)
{
- unsigned int last_len;
+ size_t last_len;
last_len = str_len(str);
for (; arg != NULL; arg = arg->next) {
struct mailbox *box;
const char *box_name;
char *box_id;
- unsigned int i, len;
+ unsigned int i;
+ size_t len;
/* use a separate filter query for selecting the mailbox. it shouldn't
affect the score and there could be some caching benefits too. */
return chr < 0x10ffff;
}
-static unsigned int
-xml_encode_data_max(string_t *dest, const unsigned char *data, unsigned int len,
+static size_t
+xml_encode_data_max(string_t *dest, const unsigned char *data, size_t len,
unsigned int max_len)
{
unichar_t chr;
- unsigned int i;
+ size_t i;
i_assert(max_len > 0 || len == 0);
}
static void
-xml_encode_data(string_t *dest, const unsigned char *data, unsigned int len)
+xml_encode_data(string_t *dest, const unsigned char *data, size_t len)
{
(void)xml_encode_data_max(dest, data, len, len);
}
{
struct solr_fts_backend_update_context *ctx =
(struct solr_fts_backend_update_context *)_ctx;
- unsigned int len;
+ size_t len;
if (_ctx->failed)
return -1;
solr_add_definite_query_args(string_t *str, struct mail_search_arg *arg,
bool and_args)
{
- unsigned int last_len;
+ size_t last_len;
last_len = str_len(str);
for (; arg != NULL; arg = arg->next) {
solr_add_maybe_query_args(string_t *str, struct mail_search_arg *arg,
bool and_args)
{
- unsigned int last_len;
+ size_t last_len;
last_len = str_len(str);
for (; arg != NULL; arg = arg->next) {
struct mailbox_status status;
string_t *str;
const char *box_guid;
- unsigned int prefix_len;
+ size_t prefix_len;
if (fts_mailbox_get_guid(box, &box_guid) < 0)
return -1;
HASH_TABLE(char *, struct mailbox *) mailboxes;
struct mailbox *box;
const char *box_guid;
- unsigned int i, len;
+ unsigned int i;
+ size_t len;
bool search_all_mailboxes;
/* use a separate filter query for selecting the mailbox. it shouldn't
char *line, *str, buf[4096];
buffer_t *valid;
int ret, fd;
- unsigned int len, last = 0, seq = 1, node_count, uidlist_count;
+ unsigned int last = 0, seq = 1, node_count, uidlist_count;
+ size_t len;
enum squat_index_type index_type;
bool data_header = TRUE, first = TRUE, skip_body = FALSE;
bool mime_header = TRUE;
struct mailbox *box;
struct fts_index_header hdr;
const char *vname;
- unsigned int len;
+ size_t len;
int ret;
if ((ns->flags & NAMESPACE_FLAG_INBOX_USER) != 0)
struct mail_search_arg *orig_arg,
const char *orig_token, const char **error_r)
{
- unsigned int orig_token_len = strlen(orig_token);
+ size_t orig_token_len = strlen(orig_token);
struct mail_search_arg *and_arg;
const char *token, *error;
int ret;
imap_acl_write_rights_list(string_t *dest, const char *const *rights)
{
const struct imap_acl_letter_map *map;
- unsigned int i, orig_len = str_len(dest);
+ unsigned int i;
+ size_t orig_len = str_len(dest);
bool append_c = FALSE, append_d = FALSE;
for (i = 0; rights[i] != NULL; i++) {
struct acl_rights rights;
string_t *tmp;
const char *username;
- unsigned int orig_len = str_len(dest);
+ size_t orig_len = str_len(dest);
bool seen_owner = FALSE, seen_positive_owner = FALSE;
int ret;
struct stats_client_command *scmd = IMAP_STATS_IMAP_CONTEXT(cmd);
struct stats *new_stats, *diff_stats;
const char *error;
- unsigned int args_pos = 0, args_len = 0;
+ size_t args_pos = 0, args_len = 0;
string_t *str;
buffer_t *buf;
if (str_len(str) > PIPE_BUF) {
/* truncate the args so it fits */
- unsigned int delete_count = str_len(str) - PIPE_BUF;
+ size_t delete_count = str_len(str) - PIPE_BUF;
i_assert(args_pos != 0);
if (delete_count > args_len)
string_t *set_key = t_str_new(64);
str_append(set_key, set_prefix);
str_append(set_key, "_private_key");
- unsigned int prefix_len = str_len(set_key);
+ size_t prefix_len = str_len(set_key);
unsigned int i = 1;
const char *key_data;
string_t *set_key = t_str_new(64);
str_append(set_key, set_prefix);
str_append(set_key, "_private_key");
- unsigned int prefix_len = str_len(set_key);
+ size_t prefix_len = str_len(set_key);
unsigned int i = 1;
const char *key_data;
const char *path, bool is_file)
{
struct quota_count_path *count_path;
- unsigned int i, count, path_len;
+ unsigned int i, count;
+ size_t path_len;
path_len = strlen(path);
count_path = array_get_modifiable(paths, &count);
replicator_send_buf(struct replicator_connection *conn, buffer_t *buf)
{
const unsigned char *data = buf->data;
- unsigned int len = IO_BLOCK_SIZE;
+ size_t len = IO_BLOCK_SIZE;
/* try to send about IO_BLOCK_SIZE amount of data,
but only full lines */
replicator_send(struct replicator_connection *conn,
enum replication_priority priority, const char *data)
{
- unsigned int data_len = strlen(data);
+ size_t data_len = strlen(data);
if (conn->fd != -1 &&
o_stream_get_buffer_used_size(conn->output) == 0) {
projects / thirdparty / dovecot / core.git / commitdiff
