conn->fd = fd;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
if (!fifo) {
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
}
conn->io = io_add(fd, IO_READ, anvil_connection_input, conn);
conn->fd = fd;
conn->input = i_stream_create_fd(fd, AUTH_CLIENT_MAX_LINE_LENGTH);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_set_flush_callback(conn->output, auth_client_output, conn);
conn->io = io_add(fd, IO_READ, auth_client_input, conn);
conn->path = i_strdup(path);
conn->auth = auth;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_set_flush_callback(conn->output, master_output, conn);
conn->io = io_add(fd, IO_READ, master_input, conn);
.type_offset = offsetof(struct auth_passdb_settings, name),
.struct_size = sizeof(struct auth_passdb_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &auth_setting_parser_info,
.check_func = auth_passdb_settings_check
.type_offset = offsetof(struct auth_userdb_settings, name),
.struct_size = sizeof(struct auth_userdb_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &auth_setting_parser_info,
.check_func = auth_userdb_settings_check
.defines = auth_setting_defines,
.defaults = &auth_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct auth_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = auth_settings_check
};
.service_name_out = "auth-worker",
.major_version = AUTH_WORKER_PROTOCOL_MAJOR_VERSION,
.minor_version = AUTH_WORKER_PROTOCOL_MINOR_VERSION,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1, /* we use throttling */
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX, /* we use throttling */
};
struct auth_worker_client *
conn = i_new(struct auth_worker_connection, 1);
conn->fd = fd;
conn->input = i_stream_create_fd(fd, AUTH_WORKER_MAX_LINE_LENGTH);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
conn->io = io_add(fd, IO_READ, worker_input, conn);
conn->to = timeout_add(AUTH_WORKER_MAX_IDLE_SECS * 1000,
hash_table_create(&pw->users, pw->pool, 0, str_hash, strcmp);
start_time = time(NULL);
- input = i_stream_create_fd(pw->fd, (size_t)-1);
+ input = i_stream_create_fd(pw->fd, SIZE_MAX);
i_stream_set_return_partial_line(input, TRUE);
while ((line = i_stream_read_next_line(input)) != NULL) {
if (*line == '\0' || *line == ':' || *line == '#')
e_info(request->mech_event,
"While %s: %s", description,
- str_sanitize(status_string.value, (size_t)-1));
+ str_sanitize(status_string.value, SIZE_MAX));
(void)gss_release_buffer(&minor_status, &status_string);
} while (message_context != 0);
winbind->in_pipe =
i_stream_create_fd_autoclose(&infd[0], AUTH_CLIENT_MAX_LINE_LENGTH);
winbind->out_pipe =
- o_stream_create_fd_autoclose(&outfd[1], (size_t)-1);
+ o_stream_create_fd_autoclose(&outfd[1], SIZE_MAX);
if (!sigchld_handler_set) {
sigchld_handler_set = TRUE;
i_error("open(%s) failed: %m", ctx->path);
ctx->ctx.failed = TRUE;
} else {
- ctx->input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ ctx->input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
}
return &ctx->ctx;
}
conn = i_new(struct config_connection, 1);
conn->fd = fd;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
conn->io = io_add(fd, IO_READ, config_connection_input, conn);
DLLIST_PREPEND(&config_connections, conn);
/* section inside strlist */
return -1;
}
- if (info->type_offset == (size_t)-1)
+ if (info->type_offset == SIZE_MAX)
return 0;
str = t_str_new(256);
new_input = p_new(ctx->pool, struct input_stack, 1);
new_input->prev = ctx->cur_input;
new_input->path = p_strdup(ctx->pool, path);
- new_input->input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ new_input->input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
i_stream_set_return_partial_line(new_input->input, TRUE);
ctx->cur_input = new_input;
return 0;
ctx.str = str_new(ctx.pool, 256);
full_line = str_new(default_pool, 512);
ctx.cur_input->input = fd != -1 ?
- i_stream_create_fd_autoclose(&fd, (size_t)-1) :
+ i_stream_create_fd_autoclose(&fd, SIZE_MAX) :
i_stream_create_from_data("", 0);
i_stream_set_return_partial_line(ctx.cur_input->input, TRUE);
old_settings_init(&ctx);
return;
}
name_offset = def->list_info->type_offset;
- i_assert(name_offset != (size_t)-1);
+ i_assert(name_offset != SIZE_MAX);
name = CONST_PTR_OFFSET(set, name_offset);
if (*name == NULL || **name == '\0') {
.defines = dict_setting_defines,
.defaults = &dict_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct dict_server_settings),
- .parent_offset = (size_t)-1
+ .parent_offset = SIZE_MAX
};
const struct dict_server_settings *dict_settings;
}
conn->input = i_stream_create_fd(conn->fd, AUTH_CLIENT_MAX_LINE_LENGTH);
- conn->output = o_stream_create_fd(conn->fd, (size_t)-1);
+ conn->output = o_stream_create_fd(conn->fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
conn->io = io_add(conn->fd, IO_READ, auth_connection_input, conn);
return 0;
.defines = director_setting_defines,
.defaults = &director_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct director_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = director_settings_verify
};
client = i_new(struct imap_client, 1);
client->fd = fd;
client->input = i_stream_create_fd(fd, 4096);
- client->output = o_stream_create_fd(fd, (size_t)-1);
+ client->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
client->io = io_add(fd, IO_READ, imap_client_input, client);
client->parser =
conn = i_new(struct director_connection, 1);
conn->in_fd = in_fd;
- conn->in_input = i_stream_create_fd(conn->in_fd, (size_t)-1);
- conn->in_output = o_stream_create_fd(conn->in_fd, (size_t)-1);
+ conn->in_input = i_stream_create_fd(conn->in_fd, SIZE_MAX);
+ conn->in_output = o_stream_create_fd(conn->in_fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->in_output, TRUE);
conn->in_io = io_add(conn->in_fd, IO_READ,
director_connection_in_input, conn);
conn->out_fd = out_fd;
- conn->out_input = i_stream_create_fd(conn->out_fd, (size_t)-1);
- conn->out_output = o_stream_create_fd(conn->out_fd, (size_t)-1);
+ conn->out_input = i_stream_create_fd(conn->out_fd, SIZE_MAX);
+ conn->out_output = o_stream_create_fd(conn->out_fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->out_output, TRUE);
conn->out_io = io_add(conn->out_fd, IO_READ,
director_connection_out_input, conn);
admin_random_action, conn);
net_set_nonblock(conn->fd, FALSE);
- conn->input = i_stream_create_fd(conn->fd, (size_t)-1);
+ conn->input = i_stream_create_fd(conn->fd, SIZE_MAX);
admin_send(conn, DIRECTOR_ADMIN_HANDSHAKE);
line = i_stream_read_next_line(conn->input);
ctx->username_hash);
if (result == 0) {
- struct istream *is = iostream_temp_finish(&ctx->reply, (size_t)-1);
+ struct istream *is = iostream_temp_finish(&ctx->reply, SIZE_MAX);
char *data;
i_stream_set_return_partial_line(is, TRUE);
data = i_stream_read_next_line(is);
conn->fd = fd;
conn->dir = dir;
conn->input = i_stream_create_fd(conn->fd, 1024);
- conn->output = o_stream_create_fd(conn->fd, (size_t)-1);
+ conn->output = o_stream_create_fd(conn->fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
doveadm_connection_set_io(conn);
o_stream_nsend_str(conn->output, DOVEADM_HANDSHAKE);
conn->refcount = 1;
conn->fd = fd;
conn->dir = dir;
- conn->output = o_stream_create_fd(conn->fd, (size_t)-1);
+ conn->output = o_stream_create_fd(conn->fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
if (type != LOGIN_CONNECTION_TYPE_AUTHREPLY) {
i_assert(auth != NULL);
.service_name_out = "dns",
.major_version = 1,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX
};
static void client_connected(struct master_service_connection *master_conn)
conn->io_setup = TRUE;
if (conn->use_multiplex) {
struct ostream *os = conn->output;
- conn->output = o_stream_create_multiplex(os, (size_t)-1);
+ conn->output = o_stream_create_multiplex(os, SIZE_MAX);
o_stream_set_name(conn->output, o_stream_get_name(os));
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_unref(&os);
doveadm_print_init(DOVEADM_PRINT_TYPE_SERVER);
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
i_stream_set_name(conn->input, conn->conn.name);
o_stream_set_name(conn->output, conn->conn.name);
o_stream_set_no_error_handling(conn->output, TRUE);
fd = doveadm_connect(ctx->socket_path);
net_set_nonblock(fd, FALSE);
- ctx->input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ ctx->input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
director_send(ctx, DIRECTOR_HANDSHAKE);
alarm(5);
if (ctx->input == NULL) {
fd_set_nonblock(ctx->fd_in, TRUE);
fd_set_nonblock(ctx->fd_out, TRUE);
- ctx->input = i_stream_create_fd(ctx->fd_in, (size_t)-1);
- ctx->output = o_stream_create_fd(ctx->fd_out, (size_t)-1);
+ ctx->input = i_stream_create_fd(ctx->fd_in, SIZE_MAX);
+ ctx->output = o_stream_create_fd(ctx->fd_out, SIZE_MAX);
} else {
i_assert(ctx->fd_in == -1 && ctx->fd_out == -1);
ctx->fd_in = i_stream_get_fd(ctx->input);
ctx->fd_out = o_stream_get_fd(ctx->output);
ctx->input_orig_bufsize = i_stream_get_max_buffer_size(ctx->input);
ctx->output_orig_bufsize = o_stream_get_max_buffer_size(ctx->output);
- i_stream_set_max_buffer_size(ctx->input, (size_t)-1);
- o_stream_set_max_buffer_size(ctx->output, (size_t)-1);
+ i_stream_set_max_buffer_size(ctx->input, SIZE_MAX);
+ o_stream_set_max_buffer_size(ctx->output, SIZE_MAX);
}
if (ctx->rawlog_path != NULL) {
iostream_rawlog_create_path(ctx->rawlog_path,
if (fd < 0)
i_fatal("open(%s) failed: %m", argv[1]);
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
i_stream_set_name(input, argv[1]);
hdr_size = dump_file_hdr(input);
do {
unsigned int version;
int ret;
- input = i_stream_create_file(argv[1], (size_t)-1);
+ input = i_stream_create_file(argv[1], SIZE_MAX);
dump_hdr(input, &modseq, &version);
do {
T_BEGIN {
i_fatal("net_connect_unix(%s) failed: %m", path);
net_set_nonblock(fd, FALSE);
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
doveadm_print_init(DOVEADM_PRINT_TYPE_FORMATTED);
doveadm_print_formatted_set_format("%{timestamp} %{type}: %{prefix}: %{text}\n");
if (write_full(fd, cmd, strlen(cmd)) < 0)
i_fatal("write(%s) failed: %m", path);
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
/* read header */
args = read_next_line(input);
hash_table_create(&ctx.sessions, default_pool, 0, str_hash, strcmp);
net_set_nonblock(ctx.fd, FALSE);
- ctx.input = i_stream_create_fd(ctx.fd, (size_t)-1);
+ ctx.input = i_stream_create_fd(ctx.fd, SIZE_MAX);
if (strstr(sort_type, "cpu") != NULL)
ctx.lines_sort = sort_cpu;
fd = doveadm_connect(path);
net_set_nonblock(fd, FALSE);
- input = i_stream_create_fd(fd, (size_t)-1);
+ input = i_stream_create_fd(fd, SIZE_MAX);
cmd = t_str_new(10);
str_append(cmd, "RESET");
if (write(fd, ANVIL_CMD, strlen(ANVIL_CMD)) < 0)
i_fatal("write(%s) failed: %m", ctx->anvil_path);
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
while ((line = i_stream_read_next_line(input)) != NULL) {
if (*line == '\0')
break;
fd = doveadm_connect(ctx->socket_path);
net_set_nonblock(fd, FALSE);
- ctx->input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ ctx->input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
replicator_send(ctx, REPLICATOR_HANDSHAKE);
alarm(5);
.defines = doveadm_setting_defines,
.defaults = &doveadm_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct doveadm_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = doveadm_settings_check,
.dependencies = doveadm_setting_dependencies
};
if (write_full(fd, str_data(cmd), str_len(cmd)) < 0)
i_fatal("write(%s) failed: %m", path);
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
if ((line = i_stream_read_next_line(input)) == NULL)
i_fatal("%s: Failed to read VERSION line", path);
else if (!version_string_verify(line, "stats-reader-server", 2)) {
if (write(fd, ANVIL_CMD, strlen(ANVIL_CMD)) < 0)
i_fatal("write(%s) failed: %m", ctx->anvil_path);
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
while ((line = i_stream_read_next_line(input)) != NULL) {
if (*line == '\0')
break;
i_zero(&client);
client.fd = fd;
- client.input = i_stream_create_fd(fd, (size_t)-1);
+ client.input = i_stream_create_fd(fd, SIZE_MAX);
client.output = o_stream_create_fd(fd, 0);
o_stream_set_no_error_handling(client.output, TRUE);
client.io_client = io_add(STDIN_FILENO, IO_READ, client_input, &client);
/* ostream-dot writes only up to max buffer size, so keep it non-zero */
o_stream_set_max_buffer_size(conn->cmd_output, IO_BLOCK_SIZE);
res = o_stream_send_istream(conn->cmd_output, conn->cmd_input);
- o_stream_set_max_buffer_size(conn->cmd_output, (size_t)-1);
+ o_stream_set_max_buffer_size(conn->cmd_output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
doveadm_settings->doveadm_port);
net_set_nonblock(conn->fd, TRUE);
conn->input = i_stream_create_fd(conn->fd, MAX_INBUF_SIZE);
- conn->output = o_stream_create_fd(conn->fd, (size_t)-1);
+ conn->output = o_stream_create_fd(conn->fd, SIZE_MAX);
o_stream_set_flush_callback(conn->output, server_connection_output, conn);
o_stream_set_no_error_handling(conn->output, TRUE);
.major_version = 1,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
.major_version = 1,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE
};
.defines = imap_login_setting_defines,
.defaults = &imap_login_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct imap_login_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.dependencies = imap_login_setting_dependencies
};
client->username = i_strdup(username);
client->service = i_strdup(service);
- client->output = o_stream_create_fd(fd_out, (size_t)-1);
+ client->output = o_stream_create_fd(fd_out, SIZE_MAX);
imap_urlauth_client_count++;
DLLIST_PREPEND(&imap_urlauth_clients, client);
return -1;
}
- client->ctrl_output = o_stream_create_fd(client->fd_ctrl, (size_t)-1);
+ client->ctrl_output = o_stream_create_fd(client->fd_ctrl, SIZE_MAX);
/* send protocol version handshake */
if (o_stream_send_str(client->ctrl_output, handshake) < 0) {
.module_name = "imap-urlauth-login",
.defines = imap_urlauth_login_setting_defines,
- .type_offset = (size_t)-1,
- .parent_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
+ .parent_offset = SIZE_MAX,
.dependencies = imap_urlauth_login_setting_dependencies
};
.defines = imap_urlauth_setting_defines,
.defaults = &imap_urlauth_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct imap_urlauth_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.dependencies = imap_urlauth_setting_dependencies
};
.defines = imap_urlauth_worker_setting_defines,
.defaults = &imap_urlauth_worker_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct imap_urlauth_worker_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.dependencies = imap_urlauth_worker_setting_dependencies
};
client->debug = debug;
client->input = i_stream_create_fd(fd_in, MAX_INBUF_SIZE);
- client->output = o_stream_create_fd(fd_out, (size_t)-1);
+ client->output = o_stream_create_fd(fd_out, SIZE_MAX);
client->io = io_add(fd_in, IO_READ, client_input, client);
client->to_idle = timeout_add(CLIENT_IDLE_TIMEOUT_MSECS,
client_idle_timeout, client);
client->ctrl_input =
i_stream_create_fd(client->fd_ctrl, MAX_INBUF_SIZE);
- client->ctrl_output = o_stream_create_fd(client->fd_ctrl, (size_t)-1);
+ client->ctrl_output = o_stream_create_fd(client->fd_ctrl, SIZE_MAX);
o_stream_set_no_error_handling(client->ctrl_output, TRUE);
return 1;
}
}
client->input = i_stream_create_fd(client->fd_in, MAX_INBUF_SIZE);
- client->output = o_stream_create_fd(client->fd_out, (size_t)-1);
+ client->output = o_stream_create_fd(client->fd_out, SIZE_MAX);
client->io = io_add(client->fd_in, IO_READ, client_input, client);
o_stream_set_no_error_handling(client->output, TRUE);
o_stream_set_flush_callback(client->output, client_output, client);
o_stream_set_max_buffer_size(ctx->cmd->client->output, 0);
res = o_stream_send_istream(ctx->cmd->client->output, ctx->cur_stream);
- o_stream_set_max_buffer_size(ctx->cmd->client->output, (size_t)-1);
+ o_stream_set_max_buffer_size(ctx->cmd->client->output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
/* transfer literal to client */
o_stream_set_max_buffer_size(client->output, 0);
res = o_stream_send_istream(client->output, ctx->input);
- o_stream_set_max_buffer_size(client->output, (size_t)-1);
+ o_stream_set_max_buffer_size(client->output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
client->fd_out = fd_out;
client->input = i_stream_create_fd(fd_in,
set->imap_max_line_length);
- client->output = o_stream_create_fd(fd_out, (size_t)-1);
+ client->output = o_stream_create_fd(fd_out, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
i_stream_set_name(client->input, "<imap client>");
o_stream_set_name(client->output, "<imap client>");
o_stream_set_max_buffer_size(ctx->client->output, 0);
res = o_stream_send_istream(ctx->client->output, state->cur_input);
- o_stream_set_max_buffer_size(ctx->client->output, (size_t)-1);
+ o_stream_set_max_buffer_size(ctx->client->output, SIZE_MAX);
if (ctx->state.cur_stats_sizep != NULL) {
*ctx->state.cur_stats_sizep +=
.major_version = 1,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
.defines = imap_setting_defines,
.defaults = &imap_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct imap_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = imap_settings_verify,
.dependencies = imap_setting_dependencies
client->queue = queue;
client->fd = fd;
client->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
- client->output = o_stream_create_fd(fd, (size_t)-1);
+ client->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
client->io = io_add(fd, IO_READ, indexer_client_input, client);
conn->storage_service = storage_service;
conn->fd = fd;
conn->io = io_add(conn->fd, IO_READ, master_connection_input, conn);
- conn->input = i_stream_create_fd(conn->fd, (size_t)-1);
+ conn->input = i_stream_create_fd(conn->fd, SIZE_MAX);
handshake = t_strdup_printf(INDEXER_WORKER_HANDSHAKE,
master_service_get_process_limit(master_service));
return -1;
}
conn->io = io_add(conn->fd, IO_READ, worker_connection_input, conn);
- conn->input = i_stream_create_fd(conn->fd, (size_t)-1);
- conn->output = o_stream_create_fd(conn->fd, (size_t)-1);
+ conn->input = i_stream_create_fd(conn->fd, SIZE_MAX);
+ conn->output = o_stream_create_fd(conn->fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_nsend_str(conn->output, INDEXER_MASTER_HANDSHAKE);
return 0;
client = i_new(struct client, 1);
client->fd = fd;
client->io = io_add(fd, IO_READ, client_input, client);
- client->input = i_stream_create_fd(fd, (size_t)-1);
- client->output = o_stream_create_fd(fd, (size_t)-1);
+ client->input = i_stream_create_fd(fd, SIZE_MAX);
+ client->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
DLLIST_PREPEND(&clients, client);
conn->id = ++connection_id_counter;
conn->fd = fd;
conn->io = io_add(fd, IO_READ, ipc_connection_input, conn);
- conn->input = i_stream_create_fd(fd, (size_t)-1);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->input = i_stream_create_fd(fd, SIZE_MAX);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
i_array_init(&conn->cmds, 8);
o_stream_nsend_str(conn->output, IPC_SERVER_HANDSHAKE);
.minor_version = AUTH_CLIENT_PROTOCOL_MINOR_VERSION,
.unix_client_connect_msecs = 1000,
.input_max_size = AUTH_SERVER_CONN_MAX_LINE_LENGTH,
- .output_max_size = (size_t)-1,
+ .output_max_size = SIZE_MAX,
.client = TRUE,
};
ic_srcbuf = (ICONV_CONST char *) src;
if (iconv(t->cd, &ic_srcbuf, &srcleft,
- &ic_destbuf, &destleft) != (size_t)-1) {
+ &ic_destbuf, &destleft) != SIZE_MAX) {
i_assert(srcleft == 0);
*result = CHARSET_RET_OK;
} else if (errno == E2BIG) {
{
enum charset_result result;
size_t pos, size;
- size_t prev_invalid_pos = (size_t)-1;
+ size_t prev_invalid_pos = SIZE_MAX;
bool ret;
for (pos = 0;;) {
}
}
- if (prev_invalid_pos != (size_t)-1)
+ if (prev_invalid_pos != SIZE_MAX)
result = CHARSET_RET_INVALID_INPUT;
i_assert(*src_size - pos <= CHARSET_MAX_PENDING_BUF_SIZE);
res = FALSE;
} else {
/* provide result if succeeded */
- buffer_append_buf(result_r, tmp, 0, (size_t)-1);
+ buffer_append_buf(result_r, tmp, 0, SIZE_MAX);
res = TRUE;
}
/* and ensure no data leaks */
unsigned char *data = t_malloc_no0(len);
if (BN_bn2bin(bn, data) != len)
return -1;
- base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, (size_t)-1, data, len, dest);
+ base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, SIZE_MAX, data, len, dest);
return 0;
}
8 + stream->key_data_len);
buffer_append(values, &i, 4);
- buffer_append_buf(values, stream->cipher_oid, 0, (size_t)-1);
- buffer_append_buf(values, stream->mac_oid, 0, (size_t)-1);
+ buffer_append_buf(values, stream->cipher_oid, 0, SIZE_MAX);
+ buffer_append_buf(values, stream->mac_oid, 0, SIZE_MAX);
i = cpu32_to_be(IO_STREAM_ENCRYPT_ROUNDS);
buffer_append(values, &i, 4);
i = cpu32_to_be(stream->key_data_len);
/* store ephemeral key (if present) */
unsigned int val = cpu32_to_be(ephemeral_key->used);
buffer_append(res, &val, 4);
- buffer_append_buf(res, ephemeral_key, 0, (size_t)-1);
+ buffer_append_buf(res, ephemeral_key, 0, SIZE_MAX);
/* store encrypted key */
val = cpu32_to_be(encrypted_key->used);
buffer_append(res, &val, 4);
- buffer_append_buf(res, encrypted_key, 0, (size_t)-1);
+ buffer_append_buf(res, encrypted_key, 0, SIZE_MAX);
return 0;
}
}
static const struct connection_settings dict_conn_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.unix_client_connect_msecs = 1000,
.client = TRUE
};
p_clear(dict->hash_pool);
if (dict->fd != -1) {
- input = i_stream_create_fd(dict->fd, (size_t)-1);
+ input = i_stream_create_fd(dict->fd, SIZE_MAX);
while ((key = i_stream_read_next_line(input)) != NULL) {
/* strdup() before the second read */
}
static const struct connection_settings memcached_ascii_conn_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE
};
}
static const struct connection_settings memcached_conn_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE
};
}
static const struct connection_settings redis_conn_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE
};
.service_name_out = "dns-client",
.major_version = 1,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE,
};
int dns_compare(const char *a, const char *b)
{
- return dns_ncompare(a, b, (size_t)-1);
+ return dns_ncompare(a, b, SIZE_MAX);
}
int dns_compare_labels(const char *a, const char *b)
return -1;
}
buffer_set_used_size(dest->contents, 0);
- buffer_append_buf(dest->contents, src->contents, 0, (size_t)-1);
+ buffer_append_buf(dest->contents, src->contents, 0, SIZE_MAX);
dest->exists = TRUE;
return 0;
}
}
static const struct connection_settings http_client_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE,
.delayed_unix_client_connected_callback = TRUE,
.log_connection_id = TRUE,
offset = req->payload_input->v_offset;
o_stream_set_max_buffer_size(output, IO_BLOCK_SIZE);
res = o_stream_send_istream(output, req->payload_input);
- o_stream_set_max_buffer_size(output, (size_t)-1);
+ o_stream_set_max_buffer_size(output, SIZE_MAX);
i_assert(req->payload_input->v_offset >= offset);
e_debug(req->event, "Send more (sent %"PRIuUOFF_T", buffered=%zu)",
/* FIXME: enforce max payload size (relevant to http-client
only) */
parser->payload =
- i_stream_create_limit(parser->input, (size_t)-1);
+ i_stream_create_limit(parser->input, SIZE_MAX);
} else {
/* RFC 7230, Section 3.3.3: Message Body Length
*/
// FIXME: enforce max payload size (relevant to http-client only)
// FIXME: handle request case correctly.
- parser->payload = i_stream_create_limit(parser->input, (size_t)-1);
+ parser->payload = i_stream_create_limit(parser->input, SIZE_MAX);
return 0;
}
}
static struct connection_settings http_server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE,
.log_connection_id = TRUE,
};
/* Chunked ostream needs to write to the parent stream's buffer */
o_stream_set_max_buffer_size(output, IO_BLOCK_SIZE);
res = o_stream_send_istream(output, resp->payload_input);
- o_stream_set_max_buffer_size(output, (size_t)-1);
+ o_stream_set_max_buffer_size(output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
/* */
static struct connection_settings server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
offset = creq->data->v_offset;
o_stream_set_max_buffer_size(output, IO_BLOCK_SIZE);
res = o_stream_send_istream(output, creq->data);
- o_stream_set_max_buffer_size(output, (size_t)-1);
+ o_stream_set_max_buffer_size(output, SIZE_MAX);
i_assert(creq->data->v_offset >= offset);
if (debug) {
o_stream_set_max_buffer_size(creq->payload_output, IO_BLOCK_SIZE);
res = o_stream_send_istream(creq->payload_output, creq->payload_input);
- o_stream_set_max_buffer_size(creq->payload_output, (size_t)-1);
+ o_stream_set_max_buffer_size(creq->payload_output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
break;
case PAYLOAD_HANDLING_FORWARD:
http_server_request_forward_payload(req,
- payload_output, (size_t)-1,
+ payload_output, SIZE_MAX,
client_request_finish_payload_in, creq);
break;
case PAYLOAD_HANDLING_HANDLER:
o_stream_set_max_buffer_size(output, IO_BLOCK_SIZE);
res = o_stream_send_istream(output, ctx->payload_input);
- o_stream_set_max_buffer_size(output, (size_t)-1);
+ o_stream_set_max_buffer_size(output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
/* */
static struct connection_settings client_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE
};
#define IMAPC_DEFAULT_CONNECT_TIMEOUT_MSECS (1000*30)
#define IMAPC_DEFAULT_COMMAND_TIMEOUT_MSECS (1000*60*5)
-#define IMAPC_DEFAULT_MAX_LINE_LENGTH ((size_t)-1)
+#define IMAPC_DEFAULT_MAX_LINE_LENGTH (SIZE_MAX)
struct imapc_throttling_settings {
unsigned int init_msecs;
conn->fd = fd;
conn->input = conn->raw_input =
i_stream_create_fd(fd, conn->client->set.max_line_length);
- conn->output = conn->raw_output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = conn->raw_output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
if (*conn->client->set.rawlog_dir != '\0' &&
/* we're sending the stream now */
o_stream_set_max_buffer_size(conn->output, 0);
res = o_stream_send_istream(conn->output, stream->input);
- o_stream_set_max_buffer_size(conn->output, (size_t)-1);
+ o_stream_set_max_buffer_size(conn->output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
i_debug("Client connected");
fd_set_nonblock(server->fd, FALSE);
- server->input = i_stream_create_fd(server->fd, (size_t)-1);
- server->output = o_stream_create_fd(server->fd, (size_t)-1);
+ server->input = i_stream_create_fd(server->fd, SIZE_MAX);
+ server->output = o_stream_create_fd(server->fd, SIZE_MAX);
o_stream_set_no_error_handling(server->output, TRUE);
if (send_banner) {
int result = 0;
input = i_stream_create_from_data(header_list, strlen(header_list));
- parser = imap_parser_create(input, NULL, (size_t)-1);
+ parser = imap_parser_create(input, NULL, SIZE_MAX);
if (imap_parser_finish_line(parser, 0, 0, &args) > 0 &&
imap_arg_get_list_full(args, &hdr_list, &list_count) &&
if (conn->literal_fd != -1) {
reply->input = i_stream_create_fd_autoclose(&conn->literal_fd,
- (size_t)-1);
+ SIZE_MAX);
if (i_stream_get_size(reply->input, TRUE, &fd_size) < 1 ||
fd_size != conn->literal_size) {
i_stream_unref(&reply->input);
timeout_remove(&conn->to_reconnect);
conn->fd = fd;
- conn->input = i_stream_create_fd(fd, (size_t)-1);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->input = i_stream_create_fd(fd, SIZE_MAX);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
conn->io = io_add(fd, IO_READ, imap_urlauth_input, conn);
conn->state = IMAP_URLAUTH_STATE_AUTHENTICATING;
input = i_stream_create_from_data(bodystructure, strlen(bodystructure));
(void)i_stream_read(input);
- parser = imap_parser_create(input, NULL, (size_t)-1);
+ parser = imap_parser_create(input, NULL, SIZE_MAX);
ret = imap_parser_finish_line(parser, 0,
IMAP_PARSE_FLAG_LITERAL_TYPE, &args);
if (ret < 0) {
input = i_stream_create_from_data(bodystructure, strlen(bodystructure));
(void)i_stream_read(input);
- parser = imap_parser_create(input, NULL, (size_t)-1);
+ parser = imap_parser_create(input, NULL, SIZE_MAX);
ret = imap_parser_finish_line(parser, 0, IMAP_PARSE_FLAG_NO_UNESCAPE |
IMAP_PARSE_FLAG_LITERAL_TYPE, &args);
if (ret < 0) {
input = i_stream_create_from_data(envelope, strlen(envelope));
(void)i_stream_read(input);
- parser = imap_parser_create(input, NULL, (size_t)-1);
+ parser = imap_parser_create(input, NULL, SIZE_MAX);
ret = imap_parser_finish_line(parser, 0,
IMAP_PARSE_FLAG_LITERAL_TYPE, &args);
if (ret < 0) {
input = i_stream_create_from_data(settings, strlen(settings));
(void)i_stream_read(input);
- parser = imap_parser_create(input, NULL, (size_t)-1);
+ parser = imap_parser_create(input, NULL, SIZE_MAX);
if (imap_parser_finish_line(parser, 0, 0, &args) <= 0)
ret = "NIL";
else
mail_cache_transaction_drop_last_flush(struct mail_cache_transaction_ctx *ctx)
{
buffer_copy(ctx->cache_data, 0,
- ctx->cache_data, ctx->last_rec_pos, (size_t)-1);
+ ctx->cache_data, ctx->last_rec_pos, SIZE_MAX);
buffer_set_used_size(ctx->cache_data,
ctx->cache_data->used - ctx->last_rec_pos);
ctx->last_rec_pos = 0;
diff = dest->used - ext_hdr->hdr_size;
buffer_copy(map->hdr_copy_buf, hdr_offset + diff,
- map->hdr_copy_buf, hdr_offset, (size_t)-1);
+ map->hdr_copy_buf, hdr_offset, SIZE_MAX);
map->hdr_base = map->hdr_copy_buf->data;
hdr->header_size += diff;
*offset_p += diff;
/* drop the field */
hdr->header_size -= next_offset - offset;
buffer_copy(map->hdr_copy_buf, offset,
- map->hdr_copy_buf, next_offset, (size_t)-1);
+ map->hdr_copy_buf, next_offset, SIZE_MAX);
buffer_set_used_size(map->hdr_copy_buf, hdr->header_size);
map->hdr_base = map->hdr_copy_buf->data;
}
mail_index_strmap_set_syscall_error(strmap, "open()");
return -1;
}
- strmap->input = i_stream_create_fd(strmap->fd, (size_t)-1);
+ strmap->input = i_stream_create_fd(strmap->fd, SIZE_MAX);
ret = i_stream_read_bytes(strmap->input, &data, &size, sizeof(hdr));
if (ret <= 0) {
if (ret < 0) {
hdr = array_idx_get_space(&t->ext_hdr_updates, ext_id);
if (hdr->alloc_size < offset || hdr->alloc_size - offset < size) {
- i_assert(size < (size_t)-1 - offset);
+ i_assert(size < SIZE_MAX - offset);
new_size = nearest_power(offset + size);
hdr->mask = i_realloc(hdr->mask, hdr->alloc_size, new_size);
hdr->data = i_realloc(hdr->data, hdr->alloc_size, new_size);
i_assert(MAIL_TRANSACTION_LOG_FILE_IN_MEMORY(file));
i_assert(file->buffer_offset + file->buffer->used == file->sync_offset);
- buffer_append_buf(file->buffer, ctx->output, 0, (size_t)-1);
+ buffer_append_buf(file->buffer, ctx->output, 0, SIZE_MAX);
file->sync_offset = file->buffer_offset + file->buffer->used;
return 0;
}
file->buffer = buffer_create_dynamic(default_pool, 4096);
file->buffer_offset = sizeof(file->hdr);
}
- buffer_append_buf(file->buffer, ctx->output, 0, (size_t)-1);
+ buffer_append_buf(file->buffer, ctx->output, 0, SIZE_MAX);
file->sync_offset = file->buffer_offset + file->buffer->used;
return 0;
}
ssize_t ret;
size = file->buffer_offset - offset;
- buffer_copy(file->buffer, size, file->buffer, 0, (size_t)-1);
+ buffer_copy(file->buffer, size, file->buffer, 0, SIZE_MAX);
data = buffer_get_space_unsafe(file->buffer, 0, size);
ret = pread_full(file->fd, data, size, offset);
}
/* failure. don't leave ourself to inconsistent state */
- buffer_copy(file->buffer, 0, file->buffer, size, (size_t)-1);
+ buffer_copy(file->buffer, 0, file->buffer, size, SIZE_MAX);
buffer_set_used_size(file->buffer, file->buffer->used - size);
if (ret == 0) {
.defines = lda_setting_defines,
.defaults = &lda_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct lda_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
#ifndef CONFIG_BINARY
.check_func = lda_settings_check,
/* remove skipped data from hdr_buf */
buffer_copy(mstream->hdr_buf, 0,
- mstream->hdr_buf, mstream->istream.skip, (size_t)-1);
+ mstream->hdr_buf, mstream->istream.skip, SIZE_MAX);
mstream->istream.pos -= mstream->istream.skip;
mstream->istream.skip = 0;
break;
case STATE_EQUALS_WHITESPACE:
buffer_append_c(qp->dest, '=');
- buffer_append_buf(qp->dest, qp->whitespace, 0, (size_t)-1);
+ buffer_append_buf(qp->dest, qp->whitespace, 0, SIZE_MAX);
buffer_set_used_size(qp->whitespace, 0);
*error_r = "'=<whitespace>' not followed by newline";
break;
case STATE_CR:
- buffer_append_buf(qp->dest, qp->whitespace, 0, (size_t)-1);
+ buffer_append_buf(qp->dest, qp->whitespace, 0, SIZE_MAX);
buffer_set_used_size(qp->whitespace, 0);
buffer_append_c(qp->dest, '\r');
*error_r = "CR not followed by LF";
break;
case STATE_SOFTCR:
buffer_append_c(qp->dest, '=');
- buffer_append_buf(qp->dest, qp->whitespace, 0, (size_t)-1);
+ buffer_append_buf(qp->dest, qp->whitespace, 0, SIZE_MAX);
buffer_set_used_size(qp->whitespace, 0);
buffer_append_c(qp->dest, '\r');
*error_r = "CR not followed by LF";
const char *error;
size_t i;
- *invalid_src_pos_r = (size_t)-1;
+ *invalid_src_pos_r = SIZE_MAX;
*error_r = NULL;
for (i = 0; i < src_size; ) {
/* this wasn't trailing whitespace.
put it back. */
buffer_append_buf(qp->dest, qp->whitespace,
- 0, (size_t)-1);
+ 0, SIZE_MAX);
if (qp->whitespace->used > QP_MAX_WHITESPACE_LEN) {
/* we already truncated some of the
whitespace away, because the line
is too long */
- if (*invalid_src_pos_r == (size_t)-1) {
+ if (*invalid_src_pos_r == SIZE_MAX) {
*invalid_src_pos_r = i;
*error_r = "Too much whitespace";
}
} else {
/* invalid input */
qp_decoder_invalid(qp, &error);
- if (*invalid_src_pos_r == (size_t)-1) {
+ if (*invalid_src_pos_r == SIZE_MAX) {
*invalid_src_pos_r = i;
*error_r = error;
}
} else {
/* invalid input */
qp_decoder_invalid(qp, &error);
- if (*invalid_src_pos_r == (size_t)-1) {
+ if (*invalid_src_pos_r == SIZE_MAX) {
*invalid_src_pos_r = i;
*error_r = error;
}
/* =<whitespace> not followed by [CR]LF
is invalid. */
qp_decoder_invalid(qp, &error);
- if (*invalid_src_pos_r == (size_t)-1) {
+ if (*invalid_src_pos_r == SIZE_MAX) {
*invalid_src_pos_r = i;
*error_r = error;
}
qp->state = STATE_TEXT;
} else {
qp_decoder_invalid(qp, &error);
- if (*invalid_src_pos_r == (size_t)-1) {
+ if (*invalid_src_pos_r == SIZE_MAX) {
*invalid_src_pos_r = i;
*error_r = error;
}
}
i++;
}
- i_assert((*invalid_src_pos_r == (size_t)-1) == (*error_r == NULL));
- return *invalid_src_pos_r == (size_t)-1 ? 0 : -1;
+ i_assert((*invalid_src_pos_r == SIZE_MAX) == (*error_r == NULL));
+ return *invalid_src_pos_r == SIZE_MAX ? 0 : -1;
}
int qp_decoder_finish(struct qp_decoder *qp, const char **error_r)
test_assert(memcmp(str_data(str), test->output, output_len) == 0);
/* read the data after the '.' line and verify it's still there */
- i_stream_set_max_buffer_size(test_input, (size_t)-1);
+ i_stream_set_max_buffer_size(test_input, SIZE_MAX);
(void)i_stream_read(test_input);
data = i_stream_get_data(test_input, &size);
test_assert(size == strlen(test->parent_input));
client->fd = fd;
client->input = i_stream_create_fd(fd, ANVIL_INBUF_SIZE);
- client->output = o_stream_create_fd(fd, (size_t)-1);
+ client->output = o_stream_create_fd(fd, SIZE_MAX);
client->io = io_add(fd, IO_READ, anvil_input, client);
if (o_stream_send_str(client->output, ANVIL_HANDSHAKE) < 0) {
i_error("write(%s) failed: %s", client->path,
}
client->io = io_add(client->fd, IO_READ, ipc_client_input, client);
- client->input = i_stream_create_fd(client->fd, (size_t)-1);
- client->output = o_stream_create_fd(client->fd, (size_t)-1);
+ client->input = i_stream_create_fd(client->fd, SIZE_MAX);
+ client->output = o_stream_create_fd(client->fd, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
return 0;
}
}
server->io = io_add(server->fd, IO_READ, ipc_server_input, server);
- server->input = i_stream_create_fd(server->fd, (size_t)-1);
- server->output = o_stream_create_fd(server->fd, (size_t)-1);
+ server->input = i_stream_create_fd(server->fd, SIZE_MAX);
+ server->output = o_stream_create_fd(server->fd, SIZE_MAX);
o_stream_set_no_error_handling(server->output, TRUE);
o_stream_nsend_str(server->output,
t_strdup_printf(IPC_SERVER_HANDSHAKE, server->name, my_pid));
i_error("open(%s) failed: %m", list->path);
return -1;
}
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
while ((line = i_stream_read_next_line(input)) != NULL) T_BEGIN {
if (master_instance_list_add_line(list, line) < 0)
i_error("Invalid line in %s: %s", list->path, line);
.minor_version = AUTH_MASTER_PROTOCOL_MINOR_VERSION,
.unix_client_connect_msecs = 1000,
.input_max_size = AUTH_MAX_INBUF_SIZE,
- .output_max_size = (size_t)-1,
+ .output_max_size = SIZE_MAX,
.client = TRUE,
};
conn->create_time = ioloop_timeval;
conn->fd = fd;
conn->io = io_add(conn->fd, IO_READ, master_login_conn_input, conn);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
DLLIST_PREPEND(&login->conns, conn);
cache->service = service;
cache->module = p_strdup(pool, module);
cache->service_name = p_strdup(pool, service_name);
- cache->max_cache_size = (size_t)-1;
+ cache->max_cache_size = SIZE_MAX;
return cache;
}
.defines = master_service_setting_defines,
.defaults = &master_service_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct master_service_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = master_service_settings_check
};
retry = FALSE;
}
service->config_fd = fd;
- struct istream *is = i_stream_create_fd(fd, (size_t)-1);
+ struct istream *is = i_stream_create_fd(fd, SIZE_MAX);
const char *line;
/* try read response */
while((line = i_stream_read_next_line(is)) != NULL) {
SETTINGS_PARSER_FLAG_IGNORE_UNKNOWN_KEYS);
if (fd != -1) {
- istream = i_stream_create_fd(fd, (size_t)-1);
+ istream = i_stream_create_fd(fd, SIZE_MAX);
now = time(NULL);
timeout = now + CONFIG_READ_TIMEOUT_SECS;
do {
.defines = master_service_ssl_setting_defines,
.defaults = &master_service_ssl_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct master_service_ssl_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = master_service_ssl_settings_check
};
.major_version = 3,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE
};
static bool compare_test_stats_to(const char *format, ...) ATTR_FORMAT(1, 2);
static struct connection_settings stats_conn_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
i_fatal("failed create stats data file %m");
}
- stats_data_out = o_stream_create_fd_autoclose(&fd, (size_t)-1);
+ stats_data_out = o_stream_create_fd_autoclose(&fd, SIZE_MAX);
o_stream_nsend_str(stats_data_out, line);
o_stream_nsend_str(stats_data_out, "\n");
/* Wait stats data to be recorded by stats process */
wait_for_signal(stats_ready);
- input = i_stream_create_file(stats_data_file, (size_t)-1);
+ input = i_stream_create_file(stats_data_file, SIZE_MAX);
while (i_stream_read(input) > 0) ;
if (input->stream_errno != 0) {
i_fatal("stats data file read failed: %s",
.defines = test_setting_defines,
.defaults = &test_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct test_service_settings),
- .parent_offset = (size_t)-1
+ .parent_offset = SIZE_MAX
};
int master_service_settings_read(struct master_service *service ATTR_UNUSED,
#include <sys/types.h>
#define base64url_encode_str(str, dest) \
- base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, (size_t)-1, (str), \
+ base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, SIZE_MAX, (str), \
strlen((str)), (dest))
/**
buffer_t *sig = t_hmac_buffer(&hash_method_sha256, key->data, key->used,
tokenbuf);
buffer_append(tokenbuf, ".", 1);
- base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, (size_t)-1,
+ base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, SIZE_MAX,
sig->data, sig->used, tokenbuf);
}
buffer_t *secret = t_buffer_create(32);
void *ptr = buffer_append_space_unsafe(secret, 32);
random_fill(ptr, 32);
- buffer_t *b64_key = t_base64_encode(0, (size_t)-1, secret->data, secret->used);
+ buffer_t *b64_key = t_base64_encode(0, SIZE_MAX, secret->data, secret->used);
save_key_to("HS256", "first", str_c(b64_key));
buffer_t *secret2 = t_buffer_create(32);
ptr = buffer_append_space_unsafe(secret2, 32);
random_fill(ptr, 32);
- b64_key = t_base64_encode(0, (size_t)-1, secret2->data, secret2->used);
+ b64_key = t_base64_encode(0, SIZE_MAX, secret2->data, secret2->used);
save_key_to("HS256", "second", str_c(b64_key));
/* create and sign token */
buffer_t *secret = t_buffer_create(32);
void *ptr = buffer_append_space_unsafe(secret, 32);
random_fill(ptr, 32);
- buffer_t *b64_key = t_base64_encode(0, (size_t)-1, secret->data, secret->used);
+ buffer_t *b64_key = t_base64_encode(0, SIZE_MAX, secret->data, secret->used);
save_key_to("HS256", "hello%2eworld%2f%25", str_c(b64_key));
/* make a token */
buffer_t *tokenbuf = create_jwt_token_kid("HS256", "hello.world/%");
dcrypt_key_unref_private(&key);
/* convert to base64 */
buffer_append(tokenbuf, ".", 1);
- base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, (size_t)-1,
+ base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, SIZE_MAX,
sig->data, sig->used, tokenbuf);
test_jwt_token(str_c(tokenbuf));
dcrypt_key_unref_private(&key);
/* convert to base64 */
buffer_append(tokenbuf, ".", 1);
- base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, (size_t)-1,
+ base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, SIZE_MAX,
sig->data, sig->used, tokenbuf);
test_jwt_token(str_c(tokenbuf));
dcrypt_keypair_unref(&pair);
/* convert to base64 */
buffer_append(tokenbuf, ".", 1);
- base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, (size_t)-1,
+ base64url_encode(BASE64_ENCODE_FLAG_NO_PADDING, SIZE_MAX,
sig->data, sig->used, tokenbuf);
test_jwt_token(str_c(tokenbuf));
hs_sign_key =buffer_create_dynamic(default_pool, 32);
void *ptr = buffer_append_space_unsafe(hs_sign_key, 32);
random_fill(ptr, 32);
- buffer_t *b64_key = t_base64_encode(0, (size_t)-1,
+ buffer_t *b64_key = t_base64_encode(0, SIZE_MAX,
hs_sign_key->data, hs_sign_key->used);
save_key("HS256", str_c(b64_key));
}
if (pclient->fd_in >= 0) {
struct istream *program_input;
- program_input = i_stream_create_fd(pclient->fd_in, (size_t)-1);
+ program_input = i_stream_create_fd(pclient->fd_in, SIZE_MAX);
i_stream_set_name(program_input, "program stdout");
pclient->raw_program_input = program_input;
}
for(i = 0; i < count; i++) {
i_assert(efds[i].parent_fd >= 0);
efds[i].input = i_stream_create_fd
- (efds[i].parent_fd, (size_t)-1);
+ (efds[i].parent_fd, SIZE_MAX);
i_stream_set_name(efds[i].input,
t_strdup_printf("program output fd=%d",
efds[i].child_fd));
break;
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
client->body =
- iostream_temp_finish(&client->os_body, -1);
+ iostream_temp_finish(&client->os_body, SIZE_MAX);
i_stream_unref(&client->is_body);
client->state = CLIENT_STATE_FINISH;
return 0;
client = p_new(pool, struct test_client, 1);
client->pool = pool;
client->fd = fd;
- client->in = i_stream_create_fd(fd, -1);
- client->out = o_stream_create_fd(fd, -1);
+ client->in = i_stream_create_fd(fd, SIZE_MAX);
+ client->out = o_stream_create_fd(fd, SIZE_MAX);
client->io = io_add_istream(client->in, test_program_input, client);
p_array_init(&client->args, client->pool, 2);
server->client = client;
break;
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
client->body =
- iostream_temp_finish(&client->os_body, -1);
+ iostream_temp_finish(&client->os_body, SIZE_MAX);
return 1;
case OSTREAM_SEND_ISTREAM_RESULT_WAIT_OUTPUT:
i_panic("Cannot write to ostream-temp");
client = p_new(pool, struct test_client, 1);
client->pool = pool;
client->fd = fd;
- client->in = i_stream_create_fd(fd, -1);
- client->out = o_stream_create_fd(fd, -1);
+ client->in = i_stream_create_fd(fd, SIZE_MAX);
+ client->out = o_stream_create_fd(fd, SIZE_MAX);
client->io = io_add_istream(client->in, test_program_input, client);
p_array_init(&client->args, client->pool, 2);
server->client = client;
.defines = NULL,
.defaults = NULL,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = 0,
- .parent_offset = (size_t)-1
+ .parent_offset = SIZE_MAX
};
HASH_TABLE_DEFINE_TYPE(setting_link, struct setting_link *,
setting_parser_copy_defaults(ctx, link->info, link);
array_push_back(link->array, &link->set_struct);
- if (link->info->parent_offset != (size_t)-1 && link->parent != NULL) {
+ if (link->info->parent_offset != SIZE_MAX && link->parent != NULL) {
ptr = STRUCT_MEMBER_P(link->set_struct,
link->info->parent_offset);
*((void **)ptr) = link->parent->set_struct;
}
i_close_fd(&fd[1]);
- input = i_stream_create_fd_autoclose(&fd[0], (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd[0], SIZE_MAX);
i_stream_set_name(input, bin_path);
ret = settings_parse_stream_read(ctx, input);
i_stream_destroy(&input);
{
void **ptr;
- if (info->parent_offset == (size_t)-1)
+ if (info->parent_offset == SIZE_MAX)
return;
ptr = PTR_OFFSET(child, info->parent_offset);
unsigned int i, j, src_count, dest_count, ccount;
unsigned int type_offset;
- i_assert(def->list_info->type_offset != (size_t)-1);
+ i_assert(def->list_info->type_offset != SIZE_MAX);
src_arr = CONST_PTR_OFFSET(src_link->set_struct, def->offset);
src_carr = CONST_PTR_OFFSET(src_link->change_struct, def->offset);
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);
+ new_input->input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
i_stream_set_return_partial_line(new_input->input, TRUE);
*inputp = new_input;
return 0;
full_line = t_str_new(512);
sections = 0; root_section = 0; errormsg = NULL;
- input->input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input->input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
i_stream_set_return_partial_line(input->input, TRUE);
prevfile:
while ((line = i_stream_read_next_line(input->input)) != NULL) {
/* we're sending the stream now */
o_stream_set_max_buffer_size(output, IO_BLOCK_SIZE);
res = o_stream_send_istream(output, stream);
- o_stream_set_max_buffer_size(output, (size_t)-1);
+ o_stream_set_max_buffer_size(output, SIZE_MAX);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
}
static const struct connection_settings smtp_client_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE,
.delayed_unix_client_connected_callback = TRUE,
.log_connection_id = TRUE,
#define SMTP_DEFAULT_CONNECT_TIMEOUT_MSECS (1000*30)
#define SMTP_DEFAULT_COMMAND_TIMEOUT_MSECS (1000*60*5)
-#define SMTP_DEFAULT_MAX_REPLY_SIZE ((size_t)-1)
+#define SMTP_DEFAULT_MAX_REPLY_SIZE (SIZE_MAX)
#define SMTP_DEFAULT_MAX_DATA_CHUNK_SIZE NET_BLOCK_SIZE
#define SMTP_DEFAULT_MAX_DATA_CHUNK_PIPELINE 4
parser = i_new(struct smtp_reply_parser, 1);
parser->max_reply_size =
- (max_reply_size > 0 ? max_reply_size : (size_t)-1);
+ (max_reply_size > 0 ? max_reply_size : SIZE_MAX);
parser->input = input;
i_stream_ref(input);
parser->strbuf = str_new(default_pool, 128);
*/
static struct connection_settings smtp_server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE,
.log_connection_id = TRUE,
};
.defines = smtp_submit_setting_defines,
.defaults = &smtp_submit_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct smtp_submit_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
#ifndef CONFIG_BINARY
.check_func = smtp_submit_settings_check,
/* */
static struct connection_settings server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE,
};
struct _many_bad_commands_client *ctx;
ctx = p_new(conn->pool, struct _many_bad_commands_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
struct _bad_mail_client *ctx;
ctx = p_new(conn->pool, struct _bad_mail_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
struct _bad_rcpt_client *ctx;
ctx = p_new(conn->pool, struct _bad_rcpt_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
struct _bad_vrfy_client *ctx;
ctx = p_new(conn->pool, struct _bad_vrfy_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
struct _bad_noop_client *ctx;
ctx = p_new(conn->pool, struct _bad_noop_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
struct _mail_workarounds_client *ctx;
ctx = p_new(conn->pool, struct _mail_workarounds_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
struct _rcpt_workarounds_client *ctx;
ctx = p_new(conn->pool, struct _rcpt_workarounds_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
struct _mail_broken_path_client *ctx;
ctx = p_new(conn->pool, struct _mail_broken_path_client, 1);
- ctx->parser = smtp_reply_parser_init(conn->conn.input, (size_t)-1);
+ ctx->parser = smtp_reply_parser_init(conn->conn.input, SIZE_MAX);
conn->context = ctx;
switch (client_index) {
/* */
static struct connection_settings client_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE
};
/* */
static struct connection_settings server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
msize = strlen(message);
- input = i_stream_create_file(file, (size_t)-1);
+ input = i_stream_create_file(file, SIZE_MAX);
while ((ret = i_stream_read_more(input, &data, &size)) > 0) {
const unsigned char *mdata;
}
i_assert(def->offset + field_size <= dest_size);
} else {
- result->map[i].offset = (size_t)-1;
+ result->map[i].offset = SIZE_MAX;
}
}
}
memset(result->fetch_dest, 0, result->fetch_dest_size);
count = result->map_size;
for (i = 0; i < count; i++) {
- if (result->map[i].offset == (size_t)-1)
+ if (result->map[i].offset == SIZE_MAX)
continue;
value = sql_result_get_field_value(result, i);
/* now make sure that we read everything already buffered in OpenSSL
into the stream (without reading anything more). this makes I/O loop
behave similarly for ssl-istream as file-istream. */
- stream->max_buffer_size = (size_t)-1;
+ stream->max_buffer_size = SIZE_MAX;
while ((ret = SSL_read(ssl_io->ssl, buffer, sizeof(buffer))) > 0) {
memcpy(i_stream_alloc(stream, ret), buffer, ret);
stream->pos += ret;
/* skip over the actual metadata */
buf_size = i_stream_get_max_buffer_size(file->input);
- i_stream_set_max_buffer_size(file->input, (size_t)-1);
+ i_stream_set_max_buffer_size(file->input, SIZE_MAX);
while ((line = i_stream_read_next_line(file->input)) != NULL) {
if (*line == DBOX_METADATA_OLDV1_SPACE || *line == '\0') {
/* end of metadata */
ret = 0;
buf_size = i_stream_get_max_buffer_size(file->input);
/* use unlimited line length for metadata */
- i_stream_set_max_buffer_size(file->input, (size_t)-1);
+ i_stream_set_max_buffer_size(file->input, SIZE_MAX);
while ((line = i_stream_read_next_line(file->input)) != NULL) {
if (*line == DBOX_METADATA_OLDV1_SPACE || *line == '\0') {
/* end of metadata */
o_stream_nsend(output, &meta_hdr, sizeof(meta_hdr));
buf_size = i_stream_get_max_buffer_size(file->input);
/* use unlimited line length for metadata */
- i_stream_set_max_buffer_size(file->input, (size_t)-1);
+ i_stream_set_max_buffer_size(file->input, SIZE_MAX);
while ((line = i_stream_read_next_line(file->input)) != NULL) {
if (*line == '\0') {
/* end of metadata */
buf_size = i_stream_get_max_buffer_size(file->input);
/* use unlimited line length for metadata */
- i_stream_set_max_buffer_size(file->input, (size_t)-1);
+ i_stream_set_max_buffer_size(file->input, SIZE_MAX);
while ((line = i_stream_read_next_line(file->input)) != NULL) {
if (*line == '\0') {
/* end of metadata */
.defines = mdbox_setting_defines,
.defaults = &mdbox_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct mdbox_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &mail_user_setting_parser_info
};
.defines = imapc_setting_defines,
.defaults = &imapc_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct imapc_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &mail_user_setting_parser_info,
.check_func = imapc_settings_check
.defines = maildir_setting_defines,
.defaults = &maildir_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct maildir_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &mail_user_setting_parser_info
};
st.st_size/8));
}
- input = i_stream_create_fd(fd, (size_t)-1);
+ input = i_stream_create_fd(fd, SIZE_MAX);
i_stream_seek(input, last_read_offset);
orig_uid_validity = uidlist->uid_validity;
/* See if we have From-line here - note that it works right only
because all characters are different in mbox_from. */
- fromp = mbox_from; from_start_pos = from_after_pos = (size_t)-1;
+ fromp = mbox_from; from_start_pos = from_after_pos = SIZE_MAX;
eoh_char = rstream->body_offset == (uoff_t)-1 ? '\n' : -1;
for (i = stream->pos; i < pos; i++) {
if (buf[i] == eoh_char &&
}
}
fromp = mbox_from;
- } else if (from_after_pos != (size_t)-1) {
+ } else if (from_after_pos != SIZE_MAX) {
/* we have the whole From-line here now.
See if it's a valid one. */
mbox_verify:
from_start_pos);
break;
}
- from_after_pos = (size_t)-1;
+ from_after_pos = SIZE_MAX;
}
} else {
fromp = mbox_from;
/* we want to go at least one byte further next time */
rstream->input_peak_offset = stream->istream.v_offset + i;
- if (from_after_pos != (size_t)-1) {
+ if (from_after_pos != SIZE_MAX) {
/* we're waiting for the \n at the end of From-line */
new_pos = from_start_pos;
} else {
.defines = mbox_setting_defines,
.defaults = &mbox_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct mbox_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &mail_user_setting_parser_info
};
ctx->hdr_offset = ctx->mail.offset;
ctx->mail.flags = MAIL_RECENT; /* default to having recent flag */
- ctx->header_first_change = (size_t)-1;
+ ctx->header_first_change = SIZE_MAX;
ctx->header_last_change = 0;
for (i = 0; i < MBOX_HDR_COUNT; i++)
- ctx->hdr_pos[i] = (size_t)-1;
+ ctx->hdr_pos[i] = SIZE_MAX;
ctx->content_length = (uoff_t)-1;
str_truncate(ctx->header, 0);
/* this header is broken, remove it */
ctx->need_rewrite = TRUE;
str_truncate(ctx->header, line_start_pos);
- if (ctx->header_first_change == (size_t)-1) {
+ if (ctx->header_first_change == SIZE_MAX) {
ctx->header_first_change =
line_start_pos;
}
} else {
/* Append at the end of X-Keywords header,
or X-UID if it doesn't exist */
- start_pos = ctx->hdr_pos[MBOX_HDR_X_KEYWORDS] != (size_t)-1 ?
+ start_pos = ctx->hdr_pos[MBOX_HDR_X_KEYWORDS] != SIZE_MAX ?
ctx->hdr_pos[MBOX_HDR_X_KEYWORDS] :
ctx->hdr_pos[MBOX_HDR_X_UID];
}
if (ctx->header_first_change > pos)
ctx->header_first_change = pos;
- ctx->header_last_change = (size_t)-1;
+ ctx->header_last_change = SIZE_MAX;
ctx->mail.space = (pos - start_pos) + size;
ctx->mail.offset = ctx->hdr_offset;
/* and remove what we can */
if (ctx->header_first_change > start_pos)
ctx->header_first_change = start_pos;
- ctx->header_last_change = (size_t)-1;
+ ctx->header_last_change = SIZE_MAX;
if (data_size - start_pos <= *size) {
/* remove it all */
for (i = 0; i < 3 && size > 0; i++) {
pos = space_positions[i];
- if (ctx->hdr_pos[pos] != (size_t)-1) {
+ if (ctx->hdr_pos[pos] != SIZE_MAX) {
mbox_sync_header_remove_space(ctx, ctx->hdr_pos[pos],
&size);
}
/* we wrote the first mail. update last-uid offset so we can find
it later */
i_assert(ctx->last_uid_value_start_pos != 0);
- i_assert(ctx->hdr_pos[MBOX_HDR_X_IMAPBASE] != (size_t)-1);
+ i_assert(ctx->hdr_pos[MBOX_HDR_X_IMAPBASE] != SIZE_MAX);
ctx->sync_ctx->base_uid_last_offset = hdr_offset +
ctx->hdr_pos[MBOX_HDR_X_IMAPBASE] +
i_assert(ctx->mail.space >= 0);
- if (ctx->header_first_change == (size_t)-1 && move_diff == 0) {
+ if (ctx->header_first_change == SIZE_MAX && move_diff == 0) {
/* no changes actually. we get here if index sync record told
us to do something that was already there */
return 1;
ctx->header_last_change = 0;
}
- if (ctx->header_last_change != (size_t)-1 &&
+ if (ctx->header_last_change != SIZE_MAX &&
ctx->header_last_change != 0)
str_truncate(ctx->header, ctx->header_last_change);
if (mails[idx].space != 0) {
if (mails[idx].space < 0) {
/* remove all possible spacing before updating */
- mbox_sync_headers_remove_space(mail_ctx, (size_t)-1);
+ mbox_sync_headers_remove_space(mail_ctx, SIZE_MAX);
}
mbox_sync_update_header_from(mail_ctx, &mails[idx]);
} else {
if (diff == 0) {
if (ctx->header_last_change < pos + have ||
- ctx->header_last_change == (size_t)-1)
+ ctx->header_last_change == SIZE_MAX)
ctx->header_last_change = pos + have;
} else {
/* FIXME: if (diff < ctx->space && pos < ctx->offset) then
move the data only up to space offset and give/take the
space from there. update header_last_change accordingly.
(except pos and offset can't be compared directly) */
- ctx->header_last_change = (size_t)-1;
+ ctx->header_last_change = SIZE_MAX;
for (i = 0; i < MBOX_HDR_COUNT; i++) {
if (ctx->hdr_pos[i] > pos &&
- ctx->hdr_pos[i] != (size_t)-1)
+ ctx->hdr_pos[i] != SIZE_MAX)
ctx->hdr_pos[i] += diff;
}
if (diff < 0)
str_delete(ctx->header, pos, -diff);
else {
- ctx->header_last_change = (size_t)-1;
+ ctx->header_last_change = SIZE_MAX;
buffer_copy(ctx->header, pos + diff,
- ctx->header, pos, (size_t)-1);
+ ctx->header, pos, SIZE_MAX);
}
}
}
}
if (ctx->sync_ctx->dest_first_mail &&
- ctx->hdr_pos[MBOX_HDR_X_IMAPBASE] == (size_t)-1) {
+ ctx->hdr_pos[MBOX_HDR_X_IMAPBASE] == SIZE_MAX) {
i_assert(ctx->sync_ctx->base_uid_validity != 0);
str_append(ctx->header, "X-IMAPbase: ");
str_append_c(ctx->header, '\n');
}
- if (ctx->hdr_pos[MBOX_HDR_X_UID] == (size_t)-1 && !ctx->mail.pseudo) {
+ if (ctx->hdr_pos[MBOX_HDR_X_UID] == SIZE_MAX && !ctx->mail.pseudo) {
str_append(ctx->header, "X-UID: ");
ctx->hdr_pos[MBOX_HDR_X_UID] = str_len(ctx->header);
str_printfa(ctx->header, "%u\n", ctx->mail.uid);
ctx->mail.flags ^= MBOX_NONRECENT_KLUDGE;
- if (ctx->hdr_pos[MBOX_HDR_STATUS] == (size_t)-1 &&
+ if (ctx->hdr_pos[MBOX_HDR_STATUS] == SIZE_MAX &&
(ctx->mail.flags & STATUS_FLAGS_MASK) != 0) {
str_append(ctx->header, "Status: ");
ctx->hdr_pos[MBOX_HDR_STATUS] = str_len(ctx->header);
str_append_c(ctx->header, '\n');
}
- if (ctx->hdr_pos[MBOX_HDR_X_STATUS] == (size_t)-1 &&
+ if (ctx->hdr_pos[MBOX_HDR_X_STATUS] == SIZE_MAX &&
(ctx->mail.flags & XSTATUS_FLAGS_MASK) != 0) {
str_append(ctx->header, "X-Status: ");
ctx->hdr_pos[MBOX_HDR_X_STATUS] = str_len(ctx->header);
ctx->mail.flags ^= MBOX_NONRECENT_KLUDGE;
- if (ctx->hdr_pos[MBOX_HDR_X_KEYWORDS] == (size_t)-1 &&
+ if (ctx->hdr_pos[MBOX_HDR_X_KEYWORDS] == SIZE_MAX &&
array_is_created(&ctx->mail.keywords) &&
array_count(&ctx->mail.keywords) > 0) {
str_append(ctx->header, "X-Keywords: ");
}
if (str_len(ctx->header) != new_hdr_size) {
- if (ctx->header_first_change == (size_t)-1)
+ if (ctx->header_first_change == SIZE_MAX)
ctx->header_first_change = new_hdr_size;
- ctx->header_last_change = (size_t)-1;
+ ctx->header_last_change = SIZE_MAX;
}
if (ctx->have_eoh)
static void mbox_sync_update_status(struct mbox_sync_mail_context *ctx)
{
- if (ctx->hdr_pos[MBOX_HDR_STATUS] != (size_t)-1) {
+ if (ctx->hdr_pos[MBOX_HDR_STATUS] != SIZE_MAX) {
status_flags_replace(ctx, ctx->hdr_pos[MBOX_HDR_STATUS],
mbox_status_flags);
}
static void mbox_sync_update_xstatus(struct mbox_sync_mail_context *ctx)
{
- if (ctx->hdr_pos[MBOX_HDR_X_STATUS] != (size_t)-1) {
+ if (ctx->hdr_pos[MBOX_HDR_X_STATUS] != SIZE_MAX) {
status_flags_replace(ctx, ctx->hdr_pos[MBOX_HDR_X_STATUS],
mbox_xstatus_flags);
}
}
mbox_sync_move_buffer(ctx, pos, str_len(new_line), p - hdr + 1);
- buffer_copy(ctx->header, pos, new_line, 0, (size_t)-1);
+ buffer_copy(ctx->header, pos, new_line, 0, SIZE_MAX);
}
static void mbox_sync_update_xkeywords(struct mbox_sync_mail_context *ctx)
{
string_t *str;
- if (ctx->hdr_pos[MBOX_HDR_X_KEYWORDS] == (size_t)-1)
+ if (ctx->hdr_pos[MBOX_HDR_X_KEYWORDS] == SIZE_MAX)
return;
str = t_str_new(256);
i_assert(sync_ctx->base_uid_validity != 0);
if (!sync_ctx->dest_first_mail ||
- ctx->hdr_pos[MBOX_HDR_X_IMAPBASE] == (size_t)-1)
+ ctx->hdr_pos[MBOX_HDR_X_IMAPBASE] == SIZE_MAX)
return;
if (!ctx->imapbase_rewrite) {
{
string_t *str;
- if (ctx->hdr_pos[MBOX_HDR_X_UID] == (size_t)-1 ||
+ if (ctx->hdr_pos[MBOX_HDR_X_UID] == SIZE_MAX ||
ctx->mail.uid == ctx->parsed_uid)
return;
client->input = client->raw_input =
i_stream_create_fd(client->fd, POP3C_MAX_INBUF_SIZE);
client->output = client->raw_output =
- o_stream_create_fd(client->fd, (size_t)-1);
+ o_stream_create_fd(client->fd, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
if (*client->set.rawlog_dir != '\0' &&
.defines = pop3c_setting_defines,
.defaults = &pop3c_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct pop3c_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &mail_user_setting_parser_info,
.check_func = pop3c_settings_check
.defines = mail_storage_setting_defines,
.defaults = &mail_storage_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct mail_storage_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &mail_user_setting_parser_info,
.check_func = mail_storage_settings_check,
.type_offset = offsetof(struct mailbox_settings, name),
.struct_size = sizeof(struct mailbox_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &mail_user_setting_parser_info,
.check_func = mailbox_settings_check
.defines = mail_user_setting_defines,
.defaults = &mail_user_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct mail_user_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = mail_user_settings_check,
#ifndef CONFIG_BINARY
tstream->skip_diff = new_skip_diff;
cur_max = tstream->max_pos;
- if (stream->max_buffer_size < (size_t)-1 - stream->skip &&
+ if (stream->max_buffer_size < SIZE_MAX - stream->skip &&
cur_max > stream->skip + stream->max_buffer_size)
cur_max = stream->skip + stream->max_buffer_size;
i_stream_create(&tstream->istream, NULL, -1, 0);
tstream->istream.statbuf.st_size = tstream->max_pos = size;
tstream->allow_eof = TRUE;
- tstream->istream.max_buffer_size = (size_t)-1;
+ tstream->istream.max_buffer_size = SIZE_MAX;
return &tstream->istream.istream;
}
struct ostream *ostream;
tstream = i_new(struct test_ostream, 1);
- tstream->ostream.max_buffer_size = (size_t)-1;
+ tstream->ostream.max_buffer_size = SIZE_MAX;
tstream->ostream.iostream.destroy = o_stream_test_destroy;
tstream->ostream.sendv = o_stream_test_sendv;
tstream->ostream.flush = o_stream_test_flush;
tstream->ostream.ostream.blocking = TRUE;
tstream->output_buf = output;
- tstream->max_output_size = (size_t)-1;
+ tstream->max_output_size = SIZE_MAX;
ostream = o_stream_create(&tstream->ostream, NULL, -1);
o_stream_set_name(ostream, "(test-ostream)");
return ostream;
pos = idx * array->element_size;
buffer_copy(array->buffer, pos + array->element_size,
- array->buffer, pos, (size_t)-1);
+ array->buffer, pos, SIZE_MAX);
data = buffer_get_space_unsafe(array->buffer, pos, array->element_size);
memset(data, 0, array->element_size);
array_append_array_i(struct array *dest_array, const struct array *src_array)
{
i_assert(dest_array->element_size == src_array->element_size);
- buffer_append_buf(dest_array->buffer, src_array->buffer, 0, (size_t)-1);
+ buffer_append_buf(dest_array->buffer, src_array->buffer, 0, SIZE_MAX);
}
#define array_append_array(dest_array, src_array) \
array_append_array_i(&(dest_array)->arr + ARRAY_TYPES_CHECK(dest_array, src_array), \
unsigned int extra;
size_t new_size;
- if (unlikely((size_t)-1 - pos < data_size))
+ if (unlikely(SIZE_MAX - pos < data_size))
i_panic("Buffer write out of range (%zu + %zu)", pos, data_size);
new_size = pos + data_size;
if (pos >= buf->used)
buffer_write(_buf, pos, data, data_size);
else {
- buffer_copy(_buf, pos + data_size, _buf, pos, (size_t)-1);
+ buffer_copy(_buf, pos + data_size, _buf, pos, SIZE_MAX);
memcpy(buf->w_buffer + pos, data, data_size);
}
}
} else {
/* insert */
buffer_copy(_buf, pos + data_size, _buf, pos + size,
- (size_t)-1);
+ SIZE_MAX);
memcpy(buf->w_buffer + pos, data, data_size);
}
} else {
if (pos >= buf->used)
buffer_write_zero(_buf, pos, data_size);
else {
- buffer_copy(_buf, pos + data_size, _buf, pos, (size_t)-1);
+ buffer_copy(_buf, pos + data_size, _buf, pos, SIZE_MAX);
memset(buf->w_buffer + pos, 0, data_size);
}
}
/* Copy data from buffer to another. The buffers may be same in which case
it's internal copying, possibly with overlapping positions (ie. memmove()
- like functionality). copy_size may be set to (size_t)-1 to copy the rest of
+ like functionality). copy_size may be set to SIZE_MAX to copy the rest of
the used data in buffer. */
void buffer_copy(buffer_t *dest, size_t dest_pos,
const buffer_t *src, size_t src_pos, size_t copy_size);
-/* Append data to buffer from another. copy_size may be set to (size_t)-1 to
+/* Append data to buffer from another. copy_size may be set to SIZE_MAX to
copy the rest of the used data in buffer. */
void buffer_append_buf(buffer_t *dest, const buffer_t *src,
size_t src_pos, size_t copy_size);
if (size <= cache->mmap_length)
return 0;
- if (size > (size_t)-1) {
+ if (size > SIZE_MAX) {
i_error("file_cache_set_size(%s, %"PRIuUOFF_T"): size too large",
cache->path, size);
return -1;
stream = i_new(struct istream_private, 1);
stream->buffer = data;
stream->pos = size;
- stream->max_buffer_size = (size_t)-1;
+ stream->max_buffer_size = SIZE_MAX;
stream->read = i_stream_data_read;
stream->seek = i_stream_data_seek;
i_assert(sstream->fd != -1);
- stream->max_buffer_size = (size_t)-1;
+ stream->max_buffer_size = SIZE_MAX;
data = i_stream_alloc(stream, sstream->write_peak);
if (pread_full(sstream->fd, data, sstream->write_peak, 0) < 0) {
/* copy everything to temp file and use it as the stream */
if (copy_to_temp_file(sstream) < 0) {
- stream->max_buffer_size = (size_t)-1;
+ stream->max_buffer_size = SIZE_MAX;
if (!read_from_buffer(sstream, &ret))
i_unreached();
return ret;
struct tee_child_istream *tstream = tee->children;
size_t min_skip;
- min_skip = (size_t)-1;
+ min_skip = SIZE_MAX;
for (; tstream != NULL; tstream = tstream->next) {
if (tstream->istream.skip < min_skip &&
!tstream->istream.istream.closed)
min_skip = tstream->istream.skip;
}
- if (min_skip > 0 && min_skip != (size_t)-1) {
+ if (min_skip > 0 && min_skip != SIZE_MAX) {
i_stream_skip(tee->input, min_skip);
tee_streams_update_buffer(tee);
}
size_t old_size, size_t new_size)
{
#if defined(HAVE_MALLOC_USABLE_SIZE)
- i_assert(old_size == (size_t)-1 || mem == NULL ||
+ i_assert(old_size == SIZE_MAX || mem == NULL ||
old_size <= malloc_usable_size(mem));
#endif
/* we don't set buffer as blocking, because if max_buffer_size is
changed it can get truncated. this is used in various places in
unit tests. */
- bstream->ostream.max_buffer_size = (size_t)-1;
+ bstream->ostream.max_buffer_size = SIZE_MAX;
bstream->ostream.seek = o_stream_buffer_seek;
bstream->ostream.sendv = o_stream_buffer_sendv;
bstream->ostream.write_at = o_stream_buffer_write_at;
i_assert(parent != NULL);
o_stream_set_max_buffer_size(parent, IO_BLOCK_SIZE);
sent = o_stream_sendv(parent, iov, iov_count);
- o_stream_set_max_buffer_size(parent, (size_t)-1);
+ o_stream_set_max_buffer_size(parent, SIZE_MAX);
if (sent < 0) {
wrapper_ostream_handle_parent_error(wostream);
return -1;
struct wrapper_ostream *wostream = (struct wrapper_ostream *)stream;
size_t size = 0;
- if (wostream->ostream.max_buffer_size == (size_t)-1)
- return (size_t)-1;
+ if (wostream->ostream.max_buffer_size == SIZE_MAX)
+ return SIZE_MAX;
if (wostream->buffer == NULL)
size = wostream->ostream.max_buffer_size;
size_t len;
i_assert(str != NULL);
- i_assert(max_chars != (size_t)-1);
+ i_assert(max_chars != SIZE_MAX);
len = 0;
while (len < max_chars && ((const char *) str)[len] != '\0')
fd_set_nonblock(fds[0], TRUE);
fd_set_nonblock(fds[1], TRUE);
- struct istream *is = i_stream_create_fd(fds[0], (size_t)-1);
+ struct istream *is = i_stream_create_fd(fds[0], SIZE_MAX);
/* test just the READ_MORE stuff */
test_assert(write_full(fds[1], "some data ", 10) == 0);
for(size_t i = 0; i < N_ELEMENTS(test_cases); i++) {
buffer_set_used_size(buf, 0);
- buffer_copy(buf, 0, &test_cases[i].input, 0, (size_t)-1);
+ buffer_copy(buf, 0, &test_cases[i].input, 0, SIZE_MAX);
buffer_truncate_rshift_bits(buf, test_cases[i].bits);
test_assert_idx(buffer_cmp(buf, &test_cases[i].output) == TRUE, i);
}
.major_version = 1,
.minor_version = 0,
.client = TRUE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
};
static const struct connection_settings server_set =
.major_version = 1,
.minor_version = 0,
.client = FALSE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
};
static bool received_quit = FALSE;
.minor_version = 0,
.client = TRUE,
.input_max_size = 0,
- .output_max_size = (size_t)-1,
+ .output_max_size = SIZE_MAX,
};
static const struct connection_settings no_input_server_set =
.minor_version = 0,
.client = FALSE,
.input_max_size = 0,
- .output_max_size = (size_t)-1,
+ .output_max_size = SIZE_MAX,
};
static void
test_connection_no_input_input(struct connection *conn)
{
const char *input;
- struct istream *is = i_stream_create_fd(conn->fd_in, -1);
+ struct istream *is = i_stream_create_fd(conn->fd_in, SIZE_MAX);
i_stream_set_blocking(is, FALSE);
while ((input = i_stream_read_next_line(is)) != NULL) {
const char *const *args = t_strsplit_tabescaped(input);
.minor_version = 0,
.client = TRUE,
.input_max_size = 100,
- .output_max_size = (size_t)-1,
+ .output_max_size = SIZE_MAX,
};
static int test_connection_input_full_input_args(struct connection *conn,
.major_version = 1,
.minor_version = 0,
.client = FALSE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.input_idle_timeout_secs = 1,
};
.major_version = 1,
.minor_version = 0,
.client = TRUE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
},
{
.service_name_in = "TEST-C",
.major_version = 1,
.minor_version = 0,
.client = TRUE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
},
{
.service_name_in = "TEST-S",
.major_version = 2,
.minor_version = 0,
.client = TRUE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
}
};
.major_version = 1,
.minor_version = 2,
.client = TRUE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
};
test_begin("connection handshake failed (version)");
.major_version = 0,
.minor_version = 0,
.client = TRUE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.dont_send_version = TRUE,
};
{
.major_version = 0,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.dont_send_version = TRUE,
};
file_cache_free(&cache);
i_close_fd(&fd);
- struct istream *is = i_stream_create_file(TEST_FILENAME, (size_t)-1);
+ struct istream *is = i_stream_create_file(TEST_FILENAME, SIZE_MAX);
const unsigned char *data;
test_assert(i_stream_read_more(is, &data, &size) > 0 && size == 13);
test_assert(memcmp(data, "initial data\n", 13) == 0);
if (!ctx.out->blocking && ctx.in->stream_errno != 0 &&
ctx.out->stream_errno == 0) {
/* input failed, finish flushing output */
- test_ostream_set_max_output_size(ctx.out, (size_t)-1);
+ test_ostream_set_max_output_size(ctx.out, SIZE_MAX);
test_assert(o_stream_flush(ctx.out) > 0);
} else {
test_assert(o_stream_flush(ctx.out) != 0);
struct istream *input = test_istream_create_data(data, data_len);
size_t siz;
- struct istream *chan0 = i_stream_create_multiplex(input, (size_t)-1);
+ struct istream *chan0 = i_stream_create_multiplex(input, SIZE_MAX);
struct istream *chan1 = i_stream_multiplex_add_channel(chan0, 1);
/* nothing to read until the first byte */
test_assert(pipe(fds) == 0);
fd_set_nonblock(fds[0], TRUE);
fd_set_nonblock(fds[1], TRUE);
- struct ostream *os = o_stream_create_fd(fds[1], (size_t)-1);
+ struct ostream *os = o_stream_create_fd(fds[1], SIZE_MAX);
struct istream *is = i_stream_create_fd(fds[0], 10 + i_rand_limit(10));
- struct istream *chan0 = i_stream_create_multiplex(is, (size_t)-1);
+ struct istream *chan0 = i_stream_create_multiplex(is, SIZE_MAX);
struct istream *chan1 = i_stream_multiplex_add_channel(chan0, 1);
struct io *io0 =
struct istream *input = test_istream_create_data(data, data_len);
size_t siz;
- struct istream *chan0 = i_stream_create_multiplex(input, (size_t)-1);
+ struct istream *chan0 = i_stream_create_multiplex(input, SIZE_MAX);
struct istream *chan1 = i_stream_multiplex_add_channel(chan0, 1);
i_stream_unref(&chan1);
i_stream_unref(&input);
input = test_istream_create_data(data, data_len);
- chan0 = i_stream_create_multiplex(input, (size_t)-1);
+ chan0 = i_stream_create_multiplex(input, SIZE_MAX);
chan1 = i_stream_multiplex_add_channel(chan0, 1);
/* this is needed to populate chan1 data */
test_assert(pipe(channel->fds) == 0);
fd_set_nonblock(channel->fds[0], TRUE);
fd_set_nonblock(channel->fds[1], TRUE);
- channel->in_alt = i_stream_create_fd(channel->fds[0], (size_t)-1);
+ channel->in_alt = i_stream_create_fd(channel->fds[0], SIZE_MAX);
channel->out_alt = o_stream_create_fd(channel->fds[1], IO_BLOCK_SIZE);
channel->io_alt = io_add_istream(channel->in_alt, test_istream_read_alt,
channel);
test_assert(pipe(fds) == 0);
fd_set_nonblock(fds[0], TRUE);
fd_set_nonblock(fds[1], TRUE);
- struct ostream *os = o_stream_create_fd(fds[1], (size_t)-1);
- struct istream *is = i_stream_create_fd(fds[0], (size_t)-1);
+ struct ostream *os = o_stream_create_fd(fds[1], SIZE_MAX);
+ struct istream *is = i_stream_create_fd(fds[0], SIZE_MAX);
- struct istream *ichan0 = i_stream_create_multiplex(is, (size_t)-1);
+ struct istream *ichan0 = i_stream_create_multiplex(is, SIZE_MAX);
struct istream *ichan1 = i_stream_multiplex_add_channel(ichan0, 1);
i_stream_unref(&is);
test_begin("ostream buffer size/available");
output = o_stream_create_buffer(str);
test_assert(o_stream_get_buffer_used_size(output) == 0);
- test_assert(o_stream_get_buffer_avail_size(output) == (size_t)-1);
+ test_assert(o_stream_get_buffer_avail_size(output) == SIZE_MAX);
/* test shrinking sink's max buffer size */
o_stream_set_max_buffer_size(output, 10);
buffer_t *result = t_str_new(64);
struct ostream *os = test_ostream_create(result);
- struct ostream *os2 = o_stream_create_multiplex(os, (size_t)-1);
+ struct ostream *os2 = o_stream_create_multiplex(os, SIZE_MAX);
struct ostream *os3 = o_stream_multiplex_add_channel(os2, 1);
test_assert(o_stream_send_str(os2, "hello") == 5);
test_assert(pipe(fds) == 0);
fd_set_nonblock(fds[0], TRUE);
fd_set_nonblock(fds[1], TRUE);
- struct ostream *os = o_stream_create_fd(fds[1], (size_t)-1);
- struct istream *is = i_stream_create_fd(fds[0], (size_t)-1);
+ struct ostream *os = o_stream_create_fd(fds[1], SIZE_MAX);
+ struct istream *is = i_stream_create_fd(fds[0], SIZE_MAX);
- chan0 = o_stream_create_multiplex(os, (size_t)-1);
+ chan0 = o_stream_create_multiplex(os, SIZE_MAX);
chan1 = o_stream_multiplex_add_channel(chan0, 1);
struct io *io0 =
test_begin("ostream multiplex (corking)");
buffer_t *output = t_buffer_create(128);
struct ostream *os = test_ostream_create(output);
- struct ostream *chan0 = o_stream_create_multiplex(os, (size_t)-1);
+ struct ostream *chan0 = o_stream_create_multiplex(os, SIZE_MAX);
const struct const_iovec iov[] = {
{ "hello", 5 },
int uni_utf8_get_char(const char *input, unichar_t *chr_r)
{
- return uni_utf8_get_char_n((const unsigned char *)input, (size_t)-1,
+ return uni_utf8_get_char_n((const unsigned char *)input, SIZE_MAX,
chr_r);
}
if (pend == NULL) {
/* NULL means unlimited; solely rely on '\0' */
- pend = (const unsigned char *)(size_t)-1;
+ pend = (const unsigned char *)SIZE_MAX;
}
if (p >= pend || *p == '\0') {
.defines = lmtp_setting_defines,
.defaults = &lmtp_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct lmtp_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = lmtp_settings_check,
.dependencies = lmtp_setting_dependencies
conn = i_new(struct doveadm_connection, 1);
conn->errorbuf = errorbuf;
conn->fd = fd;
- conn->output = o_stream_create_fd(conn->fd, (size_t)-1);
+ conn->output = o_stream_create_fd(conn->fd, SIZE_MAX);
if (doveadm_connection_send_errors(conn) < 0)
doveadm_connection_destroy(&conn);
else {
proxy->server_input =
i_stream_create_fd(proxy->server_fd, MAX_PROXY_INPUT_SIZE);
proxy->server_output =
- o_stream_create_fd(proxy->server_fd, (size_t)-1);
+ o_stream_create_fd(proxy->server_fd, SIZE_MAX);
o_stream_set_no_error_handling(proxy->server_output, TRUE);
proxy->server_io =
.defines = login_setting_defines,
.defaults = &login_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct login_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = login_settings_check
};
.type_offset = offsetof(struct file_listener_settings, path),
.struct_size = sizeof(struct file_listener_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &service_setting_parser_info
};
.type_offset = offsetof(struct inet_listener_settings, name),
.struct_size = sizeof(struct inet_listener_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.parent = &service_setting_parser_info
};
.defines = master_setting_defines,
.defaults = &master_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct master_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = master_settings_verify
};
/* */
static struct connection_settings server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
/* */
static struct connection_settings server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
/* */
static struct connection_settings server_connection_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
client->fd = fd;
client->io = io_add(fd, IO_READ, client_input, client);
client->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
- client->output = o_stream_create_fd(fd, (size_t)-1);
+ client->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
o_stream_set_flush_callback(client->output, client_output, client);
client->cmd_pool = pool_alloconly_create("cmd pool", 1024);
void global_memory_alloc(size_t size)
{
- i_assert(size < (size_t)-1 - global_used_memory);
+ i_assert(size < SIZE_MAX - global_used_memory);
global_used_memory += size;
while (global_used_memory > stats_settings->memory_limit) {
.defines = old_stats_setting_defines,
.defaults = &old_stats_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct old_stats_settings),
- .parent_offset = (size_t)-1
+ .parent_offset = SIZE_MAX
};
const struct old_stats_settings *stats_settings;
backend->acllist_mtime = st.st_mtime;
acllist_clear(backend, st.st_size);
- input = i_stream_create_fd(fd, (size_t)-1);
+ input = i_stream_create_fd(fd, SIZE_MAX);
while ((line = i_stream_read_next_line(input)) != NULL) {
acllist.mtime = 0;
for (p = line; *p >= '0' && *p <= '9'; p++)
if (aclobj->backend->debug)
i_debug("acl vfile: reading file %s", path);
- input = i_stream_create_fd(fd, (size_t)-1);
+ input = i_stream_create_fd(fd, SIZE_MAX);
i_stream_set_return_partial_line(input, TRUE);
linenum = 0;
while ((line = i_stream_read_next_line(input)) != NULL) {
ctx.file = file;
i_array_init(&ctx.parse_rights, 32);
- input = i_stream_create_file(file->path, (size_t)-1);
+ input = i_stream_create_file(file->path, SIZE_MAX);
i_stream_set_return_partial_line(input, TRUE);
while ((line = i_stream_read_next_line(input)) != NULL) {
linenum++;
return 1;
valid = buffer_create_dynamic(default_pool, 4096);
- input = i_stream_create_fd(fd, (size_t)-1);
+ input = i_stream_create_fd(fd, SIZE_MAX);
ret = 0;
while (ret == 0 && (line = i_stream_read_next_line(input)) != NULL) {
if (last != input->v_offset/(1024*100)) {
if (fts_expunge_log_reopen_if_needed(log, FALSE) < 0)
ctx->failed = TRUE;
else if (log->fd != -1)
- ctx->input = i_stream_create_fd(log->fd, (size_t)-1);
+ ctx->input = i_stream_create_fd(log->fd, SIZE_MAX);
ctx->unlink = TRUE;
return ctx;
}
struct istream *input;
int ret;
- input = i_stream_create_file(path, (size_t)-1);
+ input = i_stream_create_file(path, SIZE_MAX);
while (i_stream_read(input) > 0) ;
if (input->stream_errno != 0) {
*error_r = t_strdup_printf("%s: read(%s) failed: %s",
.defines = fs_crypt_setting_defines,
.defaults = &fs_crypt_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct fs_crypt_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.dependencies = fs_crypt_setting_dependencies
};
.defines = quota_status_setting_defines,
.defaults = "a_status_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct quota_status_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.dependencies = quota_status_setting_dependencies
};
}
static struct connection_settings client_set = {
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
p_array_init(&tuser->trash_boxes, user->pool, INIT_TRASH_MAILBOX_COUNT);
- input = i_stream_create_fd(fd, (size_t)-1);
+ input = i_stream_create_fd(fd, SIZE_MAX);
i_stream_set_return_partial_line(input, TRUE);
while ((line = i_stream_read_next_line(input)) != NULL) {
/* <priority> <mailbox name> */
input = i_stream_create_from_data(str_data(rule), str_len(rule));
(void)i_stream_read(input);
- imap_parser = imap_parser_create(input, NULL, (size_t)-1);
+ imap_parser = imap_parser_create(input, NULL, SIZE_MAX);
ret = imap_parser_finish_line(imap_parser, 0, 0, &args);
if (ret < 0) {
sargs = NULL;
ctx.mbox = mbox;
ctx.pool = mbox->box.pool;
ctx.rule = t_str_new(256);
- ctx.input = i_stream_create_fd(fd, (size_t)-1);
+ ctx.input = i_stream_create_fd(fd, SIZE_MAX);
i_stream_set_return_partial_line(ctx.input, TRUE);
while ((line = i_stream_read_next_line(ctx.input)) != NULL) {
linenum++;
.module_name = "pop3-login",
.defines = pop3_login_setting_defines,
- .type_offset = (size_t)-1,
- .parent_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
+ .parent_offset = SIZE_MAX,
.dependencies = pop3_login_setting_dependencies
};
client->fd_in = fd_in;
client->fd_out = fd_out;
client->input = i_stream_create_fd(fd_in, MAX_INBUF_SIZE);
- client->output = o_stream_create_fd(fd_out, (size_t)-1);
+ client->output = o_stream_create_fd(fd_out, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
o_stream_set_flush_callback(client->output, client_output, client);
.defines = pop3_setting_defines,
.defaults = &pop3_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct pop3_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = pop3_settings_verify,
.dependencies = pop3_setting_dependencies
.defines = aggregator_setting_defines,
.defaults = &aggregator_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct aggregator_settings),
- .parent_offset = (size_t)-1
+ .parent_offset = SIZE_MAX
};
const struct aggregator_settings *aggregator_settings;
conn->io = io_add(fd, IO_READ, notify_input, conn);
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
if (!fifo) {
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
}
conn->fd = fd;
conn->io = io_add(fd, IO_READ, replicator_input, conn);
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_nsend_str(conn->output, REPLICATOR_HANDSHAKE);
o_stream_set_flush_callback(conn->output, replicator_output, conn);
.major_version = REPLICATOR_DOVEADM_MAJOR_VERSION,
.minor_version = REPLICATOR_DOVEADM_MINOR_VERSION,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = FALSE
};
}
client->last_connect_failure = 0;
client->io = io_add(client->fd, IO_READ, dsync_input, client);
- client->input = i_stream_create_fd(client->fd, (size_t)-1);
- client->output = o_stream_create_fd(client->fd, (size_t)-1);
+ client->input = i_stream_create_fd(client->fd, SIZE_MAX);
+ client->output = o_stream_create_fd(client->fd, SIZE_MAX);
o_stream_set_no_error_handling(client->output, TRUE);
o_stream_nsend_str(client->output, DOVEADM_HANDSHAKE);
return 0;
conn->queue = queue;
conn->fd = fd;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE);
- conn->output = o_stream_create_fd(fd, (size_t)-1);
+ conn->output = o_stream_create_fd(fd, SIZE_MAX);
o_stream_set_no_error_handling(conn->output, TRUE);
conn->io = io_add(fd, IO_READ, notify_connection_input, conn);
conn->queue = queue;
return -1;
}
- input = i_stream_create_fd_autoclose(&fd, (size_t)-1);
+ input = i_stream_create_fd_autoclose(&fd, SIZE_MAX);
while ((line = i_stream_read_next_line(input)) != NULL) {
T_BEGIN {
ret = replicator_queue_import_line(queue, line);
.defines = replicator_setting_defines,
.defaults = &replicator_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct replicator_settings),
- .parent_offset = (size_t)-1
+ .parent_offset = SIZE_MAX
};
const struct replicator_settings *replicator_settings;
.minor_version = 0,
.input_max_size = 1024,
- .output_max_size = (size_t)-1,
+ .output_max_size = SIZE_MAX,
.client = FALSE,
};
.minor_version = 0,
.input_max_size = 1024*128, /* "big enough" */
- .output_max_size = (size_t)-1,
+ .output_max_size = SIZE_MAX,
.client = FALSE,
};
.type_offset = offsetof(struct stats_exporter_settings, name),
.struct_size = sizeof(struct stats_exporter_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = stats_exporter_settings_check,
};
.type_offset = offsetof(struct stats_metric_settings, metric_name),
.struct_size = sizeof(struct stats_metric_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = stats_metric_settings_check,
};
.defines = stats_setting_defines,
.defaults = &stats_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct stats_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = stats_settings_check,
};
.major_version = 2,
.minor_version = 0,
.allow_empty_args_input = TRUE,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE,
};
.major_version = 3,
.minor_version = 0,
- .input_max_size = (size_t)-1,
- .output_max_size = (size_t)-1,
+ .input_max_size = SIZE_MAX,
+ .output_max_size = SIZE_MAX,
.client = TRUE,
};
.defines = submission_login_setting_defines,
.defaults = &submission_login_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct submission_login_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
#ifndef CONFIG_BINARY
.check_func = submission_login_settings_check,
.defines = submission_setting_defines,
.defaults = &submission_default_settings,
- .type_offset = (size_t)-1,
+ .type_offset = SIZE_MAX,
.struct_size = sizeof(struct submission_settings),
- .parent_offset = (size_t)-1,
+ .parent_offset = SIZE_MAX,
.check_func = submission_settings_verify,
.dependencies = submission_setting_dependencies
proxy = i_new(struct rawlog_proxy, 1);
proxy->server_fd = server_fd;
- proxy->server_output = o_stream_create_fd(server_fd, (size_t)-1);
+ proxy->server_output = o_stream_create_fd(server_fd, SIZE_MAX);
o_stream_set_no_error_handling(proxy->server_output, TRUE);
o_stream_set_flush_callback(proxy->server_output, server_output, proxy);
proxy->server_io = io_add(server_fd, IO_READ, server_input, proxy);
proxy->client_in_fd = client_in_fd;
proxy->client_out_fd = client_out_fd;
proxy->client_output =
- o_stream_create_fd(client_out_fd, (size_t)-1);
+ o_stream_create_fd(client_out_fd, SIZE_MAX);
o_stream_set_no_error_handling(proxy->client_output, TRUE);
proxy->client_io = io_add(proxy->client_in_fd, IO_READ,
client_input, proxy);
projects / thirdparty / dovecot / core.git / commitdiff
