.client_limit = 0,
.service_count = 0,
.idle_kill = UINT_MAX,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &anvil_unix_listeners_buf,
sizeof(anvil_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &auth_unix_listeners_buf,
sizeof(auth_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &auth_worker_unix_listeners_buf,
sizeof(auth_worker_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = UINT_MAX,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &config_unix_listeners_buf,
sizeof(config_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &dict_unix_listeners_buf,
sizeof(dict_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &dict_async_unix_listeners_buf,
sizeof(dict_async_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = UINT_MAX,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &director_unix_listeners_buf,
sizeof(director_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &dns_client_unix_listeners_buf,
sizeof(dns_client_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &doveadm_unix_listeners_buf,
sizeof(doveadm_unix_listeners[0]) } },
/* Received timestamp for saves, if brain.sync_since/until_timestamp is set */
time_t received_timestamp;
/* Mail's size for saves if brain.sync_max_size is set,
- (uoff_t)-1 otherwise. */
+ UOFF_T_MAX otherwise. */
uoff_t virtual_size;
};
const char *guid, *hdr_hash;
enum mail_fetch_field wanted_fields = MAIL_FETCH_GUID;
time_t received_timestamp = 0;
- uoff_t virtual_size = (uoff_t)-1;
+ uoff_t virtual_size = UOFF_T_MAX;
int ret;
/* update wanted fields in case we didn't already set them for the
if (exporter->export_virtual_sizes) {
if (mail_get_virtual_size(mail, &virtual_size) < 0)
return dsync_mail_error(exporter, mail, "virtual-size");
- i_assert(virtual_size != (uoff_t)-1);
+ i_assert(virtual_size != UOFF_T_MAX);
}
change = export_save_change_get(exporter, mail->uid);
}
}
if (importer->sync_max_size > 0) {
- i_assert(change->virtual_size != (uoff_t)-1);
+ i_assert(change->virtual_size != UOFF_T_MAX);
if (change->virtual_size < importer->sync_max_size) {
/* mail is too large - skip it */
*result_r = "Ignoring missing local mail with too large size";
((change->received_timestamp > 0 ||
(importer->sync_since_timestamp == 0 &&
importer->sync_until_timestamp == 0)) &&
- (change->virtual_size != (uoff_t)-1 || importer->sync_max_size == 0)));
+ (change->virtual_size != UOFF_T_MAX || importer->sync_max_size == 0)));
/* try to find the matching local mail */
if (!importer_next_mail(importer, change->uid)) {
if (mail_transaction_log_view_set(log_view,
scan->last_log_seq,
scan->last_log_offset,
- (uint32_t)-1, (uoff_t)-1,
+ (uint32_t)-1, UOFF_T_MAX,
&reset, &reason) > 0) {
while (!found &&
mail_transaction_log_view_next(log_view, &hdr, &data) > 0) {
.client_limit = 0,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &imap_hibernate_unix_listeners_buf,
sizeof(imap_hibernate_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = ARRAY_INIT,
.fifo_listeners = ARRAY_INIT,
.client_limit = 0,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &imap_urlauth_login_unix_listeners_buf,
sizeof(imap_urlauth_login_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &imap_urlauth_unix_listeners_buf,
sizeof(imap_urlauth_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &imap_urlauth_worker_unix_listeners_buf,
sizeof(imap_urlauth_worker_unix_listeners[0]) } },
{
struct cmd_append_context *ctx = cmd->context;
- if (ctx->literal_size > (uoff_t)-1 - ctx->cat_msg_size &&
+ if (ctx->literal_size > UOFF_T_MAX - ctx->cat_msg_size &&
!ctx->failed) {
client_send_tagline(cmd,
"NO [TOOBIG] Composed message grows too big.");
str_append(str, get_body_name(body));
- if (size == (uoff_t)-1)
+ if (size == UOFF_T_MAX)
str_append(str, " NIL");
else if (has_nuls && body->binary)
str_printfa(str, " ~{%"PRIuUOFF_T"}\r\n", size);
partial_offset = imap_msgpart_get_partial_offset(body->msgpart);
partial_size = imap_msgpart_get_partial_size(body->msgpart);
- if (partial_offset != 0 || partial_size != (uoff_t)-1) {
+ if (partial_offset != 0 || partial_size != UOFF_T_MAX) {
str_printfa(str, "<%"PRIuUOFF_T, partial_offset);
- if (partial_size != (uoff_t)-1)
+ if (partial_size != UOFF_T_MAX)
str_printfa(str, ".%"PRIuUOFF_T, partial_size);
str_append_c(str, '>');
}
static int body_parse_partial(struct imap_fetch_body_data *body,
const char *p, const char **error_r)
{
- uoff_t offset, size = (uoff_t)-1;
+ uoff_t offset, size = UOFF_T_MAX;
if (*p == '\0')
return 0;
.client_limit = 1,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &imap_unix_listeners_buf,
sizeof(imap_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &indexer_unix_listeners_buf,
sizeof(indexer_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &indexer_worker_unix_listeners_buf,
sizeof(indexer_worker_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &ipc_unix_listeners_buf,
sizeof(ipc_unix_listeners[0]) } },
input2 = input;
i_stream_ref(input2);
} else {
- input2 = i_stream_create_limit(input, (uoff_t)-1);
+ input2 = i_stream_create_limit(input, UOFF_T_MAX);
}
i_stream_unref(&input);
struct istream_private *stream = &zstream->istream;
i_stream_seek(stream->parent, stream->parent_start_offset);
- zstream->eof_offset = (uoff_t)-1;
+ zstream->eof_offset = UOFF_T_MAX;
zstream->zs.next_in = NULL;
zstream->zs.avail_in = 0;
struct bzlib_istream *zstream;
zstream = i_new(struct bzlib_istream, 1);
- zstream->eof_offset = (uoff_t)-1;
+ zstream->eof_offset = UOFF_T_MAX;
zstream->log_errors = log_errors;
i_stream_bzlib_init(zstream);
struct istream_private *stream = &zstream->istream;
i_stream_seek(stream->parent, stream->parent_start_offset);
- zstream->eof_offset = (uoff_t)-1;
+ zstream->eof_offset = UOFF_T_MAX;
zstream->strm.next_in = NULL;
zstream->strm.avail_in = 0;
struct lzma_istream *zstream;
zstream = i_new(struct lzma_istream, 1);
- zstream->eof_offset = (uoff_t)-1;
+ zstream->eof_offset = UOFF_T_MAX;
zstream->log_errors = log_errors;
i_stream_lzma_init(zstream);
}
/* gzip file with concatenated content */
- stream->cached_stream_size = (uoff_t)-1;
- zstream->eof_offset = (uoff_t)-1;
+ stream->cached_stream_size = UOFF_T_MAX;
+ zstream->eof_offset = UOFF_T_MAX;
zstream->header_read = FALSE;
zstream->trailer_read = FALSE;
zstream->crc32 = 0;
struct istream_private *stream = &zstream->istream;
i_stream_seek(stream->parent, stream->parent_start_offset);
- zstream->eof_offset = (uoff_t)-1;
+ zstream->eof_offset = UOFF_T_MAX;
zstream->crc32 = 0;
zstream->zs.next_in = NULL;
struct zlib_istream *zstream;
zstream = i_new(struct zlib_istream, 1);
- zstream->eof_offset = (uoff_t)-1;
+ zstream->eof_offset = UOFF_T_MAX;
zstream->gz = gz;
zstream->log_errors = log_errors;
if (file->seekable_input != NULL) {
/* allow multiple open streams, each in a different position */
- input = i_stream_create_limit(file->seekable_input, (uoff_t)-1);
+ input = i_stream_create_limit(file->seekable_input, UOFF_T_MAX);
i_stream_seek(input, 0);
return input;
}
str_len(file->metadata_header));
i_stream_seek(input, file->metadata_write_size);
- inputs[1] = i_stream_create_limit(input, (uoff_t)-1);
+ inputs[1] = i_stream_create_limit(input, UOFF_T_MAX);
inputs[2] = NULL;
input2 = i_stream_create_concat(inputs);
i_stream_unref(&inputs[0]);
} else {
i_assert(file->fd != -1);
_file->output = o_stream_create_fd_file(file->fd,
- (uoff_t)-1, FALSE);
+ UOFF_T_MAX, FALSE);
}
o_stream_set_name(_file->output, file->full_path);
}
req->response_time = ioloop_timeval;
req->response_offset =
http_response_parser_get_last_offset(conn->http_parser);
- i_assert(req->response_offset != (uoff_t)-1);
+ i_assert(req->response_offset != UOFF_T_MAX);
i_assert(req->response_offset < conn->conn.input->v_offset);
req->bytes_in = conn->conn.input->v_offset - req->response_offset;
parser->limits = *limits;
if (parser->limits.max_size == 0)
- parser->limits.max_size = (uoff_t)-1;
+ parser->limits.max_size = UOFF_T_MAX;
if (parser->limits.max_field_size == 0)
- parser->limits.max_field_size = (uoff_t)-1;
+ parser->limits.max_field_size = UOFF_T_MAX;
if (parser->limits.max_fields == 0)
parser->limits.max_fields = (unsigned int)-1;
http_message_parser_restart(&parser->parser, NULL);
parser->response_status = 0;
parser->response_reason = NULL;
- parser->response_offset = (uoff_t)-1;
+ parser->response_offset = UOFF_T_MAX;
}
static int http_response_parse_status(struct http_response_parser *parser)
i_assert(req->req.payload != NULL);
- if (max_size == (uoff_t)-1) {
+ if (max_size == UOFF_T_MAX) {
i_stream_ref(input);
} else {
if ((ret = i_stream_get_size(input, TRUE,
test_init_server_settings(struct http_server_settings *server_set_r)
{
i_zero(server_set_r);
- server_set_r->request_limits.max_payload_size = (uoff_t)-1;
+ server_set_r->request_limits.max_payload_size = UOFF_T_MAX;
server_set_r->debug = debug;
if (small_socket_buffers) {
imap_msgpart_set_partial(msgpart, url->partial_offset,
url->partial_size == 0 ?
- (uoff_t)-1 : url->partial_size);
+ UOFF_T_MAX : url->partial_size);
*mpurl_r = mpurl;
return 0;
struct mailbox_header_lookup_ctx *header_ctx;
const char *const *headers;
- /* which part of the message part to fetch (default: 0..(uoff_t)-1) */
+ /* which part of the message part to fetch (default: 0..UOFF_T_MAX) */
uoff_t partial_offset, partial_size;
bool decode_cte_to_binary:1;
pool = pool_alloconly_create("imap msgpart", sizeof(*msgpart)+32);
msgpart = p_new(pool, struct imap_msgpart, 1);
msgpart->pool = pool;
- msgpart->partial_size = (uoff_t)-1;
+ msgpart->partial_size = UOFF_T_MAX;
msgpart->fetch_type = fetch_type;
msgpart->section_number = "";
if (fetch_type == FETCH_HEADER || fetch_type == FETCH_FULL)
pool = pool_alloconly_create("imap msgpart", 1024);
msgpart = *msgpart_r = p_new(pool, struct imap_msgpart, 1);
msgpart->pool = pool;
- msgpart->partial_size = (uoff_t)-1;
+ msgpart->partial_size = UOFF_T_MAX;
/* get the section number */
next_digit = TRUE;
if (mail->uid > 0 &&
(msgpart->partial_offset != 0 ||
- msgpart->partial_size != (uoff_t)-1) && !input->eof) {
+ msgpart->partial_size != UOFF_T_MAX) && !input->eof) {
/* update cache */
cache->uid = mail->uid;
cache->physical_start = physical_start;
with storage error set to MAIL_ERROR_CONVERSION. */
void imap_msgpart_set_decode_to_binary(struct imap_msgpart *msgpart);
-/* Set the fetch to be partial. For unlimited size use (uoff_t)-1. */
+/* Set the fetch to be partial. For unlimited size use UOFF_T_MAX. */
void imap_msgpart_set_partial(struct imap_msgpart *msgpart,
uoff_t offset, uoff_t size);
uoff_t imap_msgpart_get_partial_offset(struct imap_msgpart *msgpart);
struct mail_index *index = map->index;
const struct mail_index_header *hdr = &map->hdr;
- if (!mail_index_check_header_compat(index, hdr, (uoff_t)-1, error_r))
+ if (!mail_index_check_header_compat(index, hdr, UOFF_T_MAX, error_r))
return 0;
/* following some extra checks that only take a bit of CPU */
for (i = 0;; i++) {
try_retry = i < MAIL_INDEX_ESTALE_RETRY_COUNT;
- if (file_size == (uoff_t)-1) {
+ if (file_size == UOFF_T_MAX) {
/* fstat() below failed */
ret = 0;
retry = try_retry;
mail_index_set_syscall_error(index, "fstat()");
return -1;
}
- file_size = (uoff_t)-1;
+ file_size = UOFF_T_MAX;
}
}
return ret;
mail_index_set_syscall_error(index, "fstat()");
return -1;
}
- file_size = (uoff_t)-1;
+ file_size = UOFF_T_MAX;
}
/* mmaping seems to be slower than just reading the file, so even if
mmap isn't disabled don't use it unless the file is large enough */
use_mmap = (index->flags & MAIL_INDEX_OPEN_FLAG_MMAP_DISABLE) == 0 &&
- file_size != (uoff_t)-1 && file_size > MAIL_INDEX_MMAP_MIN_SIZE;
+ file_size != UOFF_T_MAX && file_size > MAIL_INDEX_MMAP_MIN_SIZE;
new_map = mail_index_map_alloc(index);
if (use_mmap) {
view = mail_index_view_open_with_map(index, map);
ret = mail_transaction_log_view_set(view->log_view,
map->hdr.log_file_seq, start_offset,
- (uint32_t)-1, (uoff_t)-1,
+ (uint32_t)-1, UOFF_T_MAX,
&reset, &reason);
if (ret <= 0) {
mail_index_view_close(&view);
int ret;
ret = mail_index_sync_begin_to(index, ctx_r, view_r, trans_r,
- (uint32_t)-1, (uoff_t)-1, flags);
+ (uint32_t)-1, UOFF_T_MAX, flags);
i_assert(ret != 0 ||
(flags & MAIL_INDEX_SYNC_FLAG_REQUIRE_CHANGES) != 0);
return ret;
we can't do this, so sync only up to the reset. */
mail_transaction_log_view_get_prev_pos(view->log_view,
&end_seq, &end_offset);
- end_seq--; end_offset = (uoff_t)-1;
+ end_seq--; end_offset = UOFF_T_MAX;
if (end_seq < start_seq) {
/* we have only this reset log */
mail_transaction_log_view_clear(view->log_view,
/* make sure we've read until end of file. this is especially important
with non-head logs which might only have been opened without being
synced. */
- ret = mail_transaction_log_file_map(file, *cur_offset, (uoff_t)-1, &reason);
+ ret = mail_transaction_log_file_map(file, *cur_offset, UOFF_T_MAX, &reason);
if (ret <= 0) {
mail_index_set_error(file->log->index,
"Failed to map transaction log %s for getting offset "
}
return FALSE;
}
- if (end_offset != (uoff_t)-1 && end_offset > file->sync_offset) {
+ if (end_offset != UOFF_T_MAX && end_offset > file->sync_offset) {
*reason_r = t_strdup_printf(
"%s: end_offset (%"PRIuUOFF_T") > "
"current sync_offset (%"PRIuUOFF_T")",
file->sync_offset >= file->buffer_offset + file->buffer->used);
if (file->locked_sync_offset_updated && file == file->log->head &&
- end_offset == (uoff_t)-1) {
+ end_offset == UOFF_T_MAX) {
/* we're not interested of going further than sync_offset */
if (!log_file_map_check_offsets(file, start_offset,
end_offset, reason_r))
if (file->locked) {
/* set this only when we've synced to end of file while locked
- (either end_offset=(uoff_t)-1 or we had to read anyway) */
+ (either end_offset=UOFF_T_MAX or we had to read anyway) */
file->locked_sync_offset_updated = TRUE;
}
uoff_t saved_tail_sync_offset;
/* if we've seen _INDEX_[UN9DELETED transaction in this file,
- this is the offset. otherwise (uoff_t)-1 */
+ this is the offset. otherwise UOFF_T_MAX */
uoff_t index_deleted_offset, index_undeleted_offset;
struct modseq_cache modseq_cache[LOG_FILE_MODSEQ_CACHE_SIZE];
if (file == NULL && max_file_seq == (uint32_t)-1 &&
view->head == view->log->head) {
/* we just wanted to sync everything */
- i_assert(max_file_offset == (uoff_t)-1);
+ i_assert(max_file_offset == UOFF_T_MAX);
max_file_seq = seq-1;
break;
}
start_offset = file->hdr.file_seq == min_file_seq ?
min_file_offset : file->hdr.hdr_size;
end_offset = file->hdr.file_seq == max_file_seq ?
- max_file_offset : (uoff_t)-1;
+ max_file_offset : UOFF_T_MAX;
ret = mail_transaction_log_file_map(file, start_offset,
end_offset, reason_r);
if (ret <= 0) {
i_assert(max_file_seq == (uint32_t)-1 ||
max_file_seq == view->head->hdr.file_seq);
- i_assert(max_file_offset == (uoff_t)-1 ||
+ i_assert(max_file_offset == UOFF_T_MAX ||
max_file_offset <= view->head->sync_offset);
i_assert(min_file_seq != max_file_seq ||
max_file_seq != view->head->hdr.file_seq ||
- max_file_offset != (uoff_t)-1 ||
+ max_file_offset != UOFF_T_MAX ||
min_file_offset <= view->head->sync_offset);
view->prev_file_seq = view->cur->hdr.file_seq;
for (file = view->log->files; file != NULL; file = file->next) {
ret = mail_transaction_log_file_map(file, file->hdr.hdr_size,
- (uoff_t)-1, &reason);
+ UOFF_T_MAX, &reason);
if (ret < 0) {
first = NULL;
break;
/* update sync_offset */
if (mail_transaction_log_file_map(log->head, log->head->sync_offset,
- (uoff_t)-1, &reason) <= 0) {
+ UOFF_T_MAX, &reason) <= 0) {
mail_index_set_error(log->index,
"Failed to map transaction log %s at "
"sync_offset=%"PRIuUOFF_T" after locking: %s",
/* we have files 1-3 opened */
test_begin("set all");
- test_assert(mail_transaction_log_view_set(view, 0, 0, (uint32_t)-1, (uoff_t)-1, &reset, &reason) == 1 &&
+ test_assert(mail_transaction_log_view_set(view, 0, 0, (uint32_t)-1, UOFF_T_MAX, &reset, &reason) == 1 &&
reset && view_is_file_refed(1) && view_is_file_refed(2) &&
view_is_file_refed(3) &&
!mail_transaction_log_view_is_corrupted(view));
test_end();
test_begin("set end");
- test_assert(mail_transaction_log_view_set(view, 3, last_log_size, (uint32_t)-1, (uoff_t)-1, &reset, &reason) == 1);
+ test_assert(mail_transaction_log_view_set(view, 3, last_log_size, (uint32_t)-1, UOFF_T_MAX, &reset, &reason) == 1);
mail_transaction_log_view_get_prev_pos(view, &seq, &offset);
test_assert(seq == 3 && offset == last_log_size);
test_assert(mail_transaction_log_view_next(view, &hdr, &data) == 0);
/* --- first file has been removed --- */
test_begin("set 2-3");
- test_assert(mail_transaction_log_view_set(view, 2, 0, (uint32_t)-1, (uoff_t)-1, &reset, &reason) == 1);
+ test_assert(mail_transaction_log_view_set(view, 2, 0, (uint32_t)-1, UOFF_T_MAX, &reset, &reason) == 1);
test_end();
test_begin("missing log handing");
- test_assert(mail_transaction_log_view_set(view, 0, 0, (uint32_t)-1, (uoff_t)-1, &reset, &reason) == 0);
+ test_assert(mail_transaction_log_view_set(view, 0, 0, (uint32_t)-1, UOFF_T_MAX, &reset, &reason) == 0);
test_end();
test_begin("closed log handling");
view->log = NULL;
- test_assert(mail_transaction_log_view_set(view, 0, 0, (uint32_t)-1, (uoff_t)-1, &reset, &reason) == -1);
+ test_assert(mail_transaction_log_view_set(view, 0, 0, (uint32_t)-1, UOFF_T_MAX, &reset, &reason) == -1);
view->log = log;
test_end();
if (conn->base_input_offset != conn->msg_size) {
i_assert(conn->base_input_offset < conn->msg_size);
- if (conn->msg_size != (uoff_t)-1) {
+ if (conn->msg_size != UOFF_T_MAX) {
trailer_size = conn->msg_size - conn->encoded_offset;
input = i_stream_create_sized_range(conn->base_input,
conn->base_input_offset,
} else {
input = i_stream_create_range(conn->base_input,
conn->base_input_offset,
- (uoff_t)-1);
+ UOFF_T_MAX);
}
array_push_back(&conn->streams, &input);
}
/* Start building a message stream. The base_input contains the message
without attachments. The final stream must be exactly msg_size bytes.
- If the original msg_size isn't known, it can be set to (uoff_t)-1. */
+ If the original msg_size isn't known, it can be set to UOFF_T_MAX. */
struct istream_attachment_connector *
istream_attachment_connector_begin(struct istream *base_input, uoff_t msg_size);
data = i_stream_get_data(stream->parent, &size);
if (stream->parent->v_offset + size == 0 && size == 0)
- last_offset = (uoff_t)-1;
+ last_offset = UOFF_T_MAX;
else
last_offset = stream->parent->v_offset + size - 1;
stream->buffer = mstream->hdr_buf->data;
return mstream->crlf ? 2 : 1;
} else {
- mstream->last_lf_offset = last_lf ? last_offset : (uoff_t)-1;
+ mstream->last_lf_offset = last_lf ? last_offset : UOFF_T_MAX;
}
return ret;
}
} else if (mstream->last_lf_added) {
/* yes, we have added LF */
stream->statbuf.st_size += mstream->crlf ? 2 : 1;
- } else if (mstream->last_lf_offset != (uoff_t)-1) {
+ } else if (mstream->last_lf_offset != UOFF_T_MAX) {
/* no, we didn't need to add LF */
} else {
/* check if we need to add LF */
mstream->add_missing_eoh = (flags & HEADER_FILTER_ADD_MISSING_EOH) != 0;
mstream->end_body_with_lf =
(flags & HEADER_FILTER_END_BODY_WITH_LF) != 0;
- mstream->last_lf_offset = (uoff_t)-1;
+ mstream->last_lf_offset = UOFF_T_MAX;
mstream->last_added_newline = TRUE;
mstream->istream.iostream.destroy = i_stream_header_filter_destroy;
ret = -1;
/* try again without knowing the message's size */
- msg_size = (uoff_t)-1;
+ msg_size = UOFF_T_MAX;
}
/* try with a wrong message size */
*error_r = t_strconcat("Invalid size: ", str, NULL);
return -1;
}
- if (num > ((uoff_t)-1) / multiply) {
+ if (num > (UOFF_T_MAX) / multiply) {
*error_r = t_strconcat("Size is too large: ", str, NULL);
return -1;
}
i_assert(parser->data == NULL);
data = i_stream_create_dot(parser->input, TRUE);
- if (parser->limits.max_data_size != (uoff_t)-1) {
+ if (parser->limits.max_data_size != UOFF_T_MAX) {
parser->data = i_stream_create_failure_at(
data, parser->limits.max_data_size, EMSGSIZE,
t_strdup_printf("Command data size exceeds maximum "
conn->set.max_message_size = set->max_message_size;
if (set->max_message_size == 0 ||
- set->max_message_size == (uoff_t)-1) {
+ set->max_message_size == UOFF_T_MAX) {
conn->set.command_limits.max_data_size = UOFF_T_MAX;
} else if (conn->set.command_limits.max_data_size != 0) {
/* Explicit limit given */
if ((caps & SMTP_CAPABILITY_SIZE) == 0)
return;
- if (cap_size > 0 && cap_size != (uoff_t)-1) {
+ if (cap_size > 0 && cap_size != UOFF_T_MAX) {
smtp_server_reply_ehlo_add_param(reply,
"SIZE", "%"PRIuUOFF_T, cap_size);
} else {
}
if (debug) {
- uoff_t raw_size = (uoff_t)-1, b64_size = (uoff_t)-1;
+ uoff_t raw_size = UOFF_T_MAX, b64_size = UOFF_T_MAX;
(void)i_stream_get_size(fstream, TRUE, &raw_size);
(void)i_stream_get_size(payload, TRUE, &b64_size);
continue;
}
- pre_offset = (uoff_t)-1;
+ pre_offset = UOFF_T_MAX;
match = dbox_file_match_pre_magic(input, &pre_offset, &need_bytes);
if (match < 0) {
/* more data needed */
}
if (match > 0) {
post_offset = input->v_offset;
- if (pre_offset == (uoff_t)-1 ||
+ if (pre_offset == UOFF_T_MAX ||
post_offset < pre_offset) {
pre_offset = post_offset;
*pre_r = FALSE;
}
}
- if (pre_offset != (uoff_t)-1) {
+ if (pre_offset != UOFF_T_MAX) {
*offset_r = pre_offset;
ret = 1;
break;
return -1;
dbox_file_skip_broken_header(file);
body_offset = file->input->v_offset;
- msg_size = (uoff_t)-1;
+ msg_size = UOFF_T_MAX;
} else {
i_stream_skip(file->input,
file->msg_header_size);
} else {
/* msg header is broken. write our own. */
i_stream_seek(file->input, body_offset);
- if (msg_size != (uoff_t)-1) {
+ if (msg_size != UOFF_T_MAX) {
/* previous magic find might have
skipped too much. seek back and
make sure */
{
file->refcount = 1;
file->fd = -1;
- file->cur_offset = (uoff_t)-1;
+ file->cur_offset = UOFF_T_MAX;
file->cur_path = file->primary_path;
}
dbox_file_set_syscall_error(file, "close()");
file->fd = -1;
}
- file->cur_offset = (uoff_t)-1;
+ file->cur_offset = UOFF_T_MAX;
}
int dbox_file_try_lock(struct dbox_file *file)
void dbox_file_seek_rewind(struct dbox_file *file)
{
- file->cur_offset = (uoff_t)-1;
+ file->cur_offset = UOFF_T_MAX;
}
int dbox_file_seek_next(struct dbox_file *file, uoff_t *offset_r, bool *last_r)
i_assert(file->input != NULL);
- if (file->cur_offset == (uoff_t)-1) {
+ if (file->cur_offset == UOFF_T_MAX) {
/* first mail. we may not have read the file at all yet,
so set the offset afterwards. */
offset = 0;
uoff_t metadata_offset;
int ret;
- i_assert(file->cur_offset != (uoff_t)-1);
+ i_assert(file->cur_offset != UOFF_T_MAX);
if (file->metadata_read_offset == file->cur_offset)
return 1;
value = dbox_file_metadata_get(file, DBOX_METADATA_PHYSICAL_SIZE);
if (value == NULL ||
str_to_uintmax_hex(value, &size) < 0 ||
- size > (uoff_t)-1) {
+ size > UOFF_T_MAX) {
/* no. that means we can use the size in the header */
return file->cur_physical_size;
}
if (value == NULL)
return index_mail_get_virtual_size(_mail, size_r);
- if (str_to_uintmax_hex(value, &size) < 0 || size > (uoff_t)-1)
+ if (str_to_uintmax_hex(value, &size) < 0 || size > UOFF_T_MAX)
return -1;
data->virtual_size = (uoff_t)size;
*size_r = data->virtual_size;
unsigned int i, count;
/* don't cache metadata seeks while file isn't being referenced */
- file->metadata_read_offset = (uoff_t)-1;
+ file->metadata_read_offset = UOFF_T_MAX;
mfile->close_time = ioloop_time;
if (mfile->file_id != 0) {
}
if ((data->wanted_fields & (MAIL_FETCH_PHYSICAL_SIZE |
MAIL_FETCH_VIRTUAL_SIZE)) != 0 &&
- data->physical_size == (uoff_t)-1 &&
+ data->physical_size == UOFF_T_MAX &&
IMAPC_BOX_HAS_FEATURE(mbox, IMAPC_FEATURE_RFC822_SIZE))
fields |= MAIL_FETCH_PHYSICAL_SIZE | MAIL_FETCH_VIRTUAL_SIZE;
if ((data->wanted_fields & MAIL_FETCH_IMAP_BODY) != 0 &&
fields &= ~MAIL_FETCH_SAVE_DATE;
}
if ((fields & (MAIL_FETCH_PHYSICAL_SIZE | MAIL_FETCH_VIRTUAL_SIZE)) != 0) {
- if (imail->imail.data.physical_size == (uoff_t)-1)
+ if (imail->imail.data.physical_size == UOFF_T_MAX)
return FALSE;
fields &= ~(MAIL_FETCH_PHYSICAL_SIZE | MAIL_FETCH_VIRTUAL_SIZE);
}
set it to size, because there's no guarantees about
the content having proper CRLF newlines, especially
not if istream_opened() has changed the stream. */
- imail->data.virtual_size = (uoff_t)-1;
+ imail->data.virtual_size = UOFF_T_MAX;
}
imail->data.physical_size = size;
}
uoff_t old_offset;
int ret;
- if (data->physical_size == (uoff_t)-1)
+ if (data->physical_size == UOFF_T_MAX)
(void)index_mail_get_physical_size(_mail, size_r);
- if (data->physical_size != (uoff_t)-1) {
+ if (data->physical_size != UOFF_T_MAX) {
*size_r = data->physical_size;
return 0;
}
so try not to trust it too much. */
if (imapc_mail_fetch(_mail, MAIL_FETCH_PHYSICAL_SIZE, NULL) < 0)
return -1;
- if (data->physical_size == (uoff_t)-1) {
+ if (data->physical_size == UOFF_T_MAX) {
if (imapc_mail_failed(_mail, "RFC822.SIZE") < 0)
return -1;
/* assume that the server never returns RFC822.SIZE
block->converted = TRUE;
block->converted_hdr = TRUE;
- linput = i_stream_create_limit(ctx->input, (uoff_t)-1);
+ linput = i_stream_create_limit(ctx->input, UOFF_T_MAX);
block->input = i_stream_create_header_filter(linput,
HEADER_FILTER_EXCLUDE | HEADER_FILTER_HIDE_BODY,
filter_headers, N_ELEMENTS(filter_headers),
struct index_mail_data *data = &mail->data;
if (data->hdr_size_set && !data->inexact_total_sizes &&
- data->physical_size != (uoff_t)-1 &&
- data->virtual_size != (uoff_t)-1) {
+ data->physical_size != UOFF_T_MAX &&
+ data->virtual_size != UOFF_T_MAX) {
/* We know the total size of this mail and we know the
header size, so we can calculate also the body size.
However, don't do this if there's a possibility that
const uint32_t *vsize = index_mail_get_vsize_extension(_mail);
data->cache_fetch_fields |= MAIL_FETCH_VIRTUAL_SIZE;
- if (data->virtual_size == (uoff_t)-1 && vsize != NULL && *vsize > 0)
+ if (data->virtual_size == UOFF_T_MAX && vsize != NULL && *vsize > 0)
data->virtual_size = (*vsize)-1;
- if (data->virtual_size == (uoff_t)-1) {
+ if (data->virtual_size == UOFF_T_MAX) {
if (index_mail_get_cached_uoff_t(mail,
MAIL_CACHE_VIRTUAL_FULL_SIZE,
&size))
return -1;
i_stream_seek(data->stream, old_offset);
- i_assert(data->virtual_size != (uoff_t)-1);
+ i_assert(data->virtual_size != UOFF_T_MAX);
*size_r = data->virtual_size;
return 0;
}
index_mail_get_cached_body_size(). */
data->cache_fetch_fields |= MAIL_FETCH_PHYSICAL_SIZE;
}
- if (data->physical_size == (uoff_t)-1) {
+ if (data->physical_size == UOFF_T_MAX) {
if (index_mail_get_cached_uoff_t(mail,
MAIL_CACHE_PHYSICAL_FULL_SIZE,
&size))
(void)get_cached_msgpart_sizes(mail);
}
*size_r = data->physical_size;
- return *size_r == (uoff_t)-1 ? -1 : 0;
+ return *size_r == UOFF_T_MAX ? -1 : 0;
}
void index_mail_cache_add(struct index_mail *mail, enum index_cache_field field,
*/
if ((mail_index_map_get_ext_idx(view->index->map, _mail->box->mail_vsize_ext_id, &idx) ||
mail_index_map_get_ext_idx(view->index->map, _mail->box->vsize_hdr_ext_id, &idx)) &&
- (sizes[0] != (uoff_t)-1 &&
+ (sizes[0] != UOFF_T_MAX &&
sizes[0] < (uint32_t)-1)) {
const uint32_t *vsize_ext =
index_mail_get_vsize_extension(_mail);
_mail->box->mail_vsize_ext_id, &vsize, NULL);
}
/* it's already in index, so don't update cache */
- sizes[0] = (uoff_t)-1;
+ sizes[0] = UOFF_T_MAX;
}
for (i = 0; i < N_ELEMENTS(size_fields); i++) {
- if (sizes[i] != (uoff_t)-1 &&
+ if (sizes[i] != UOFF_T_MAX &&
index_mail_want_cache(mail, size_fields[i])) {
index_mail_cache_add(mail, size_fields[i],
&sizes[i], sizeof(sizes[i]));
{
struct index_mail_data *data = &mail->data;
- data->virtual_size = (uoff_t)-1;
- data->physical_size = (uoff_t)-1;
+ data->virtual_size = UOFF_T_MAX;
+ data->physical_size = UOFF_T_MAX;
data->save_date = (time_t)-1;
data->received_date = (time_t)-1;
data->sent_date.time = (uint32_t)-1;
break;
case MAIL_FETCH_PHYSICAL_SIZE:
field_name = "physical size";
- imail->data.physical_size = (uoff_t)-1;
- imail->data.virtual_size = (uoff_t)-1;
+ imail->data.physical_size = UOFF_T_MAX;
+ imail->data.virtual_size = UOFF_T_MAX;
imail->data.parts = NULL;
index_mail_reset_vsize_ext(mail);
break;
case MAIL_FETCH_VIRTUAL_SIZE:
field_name = "virtual size";
- imail->data.physical_size = (uoff_t)-1;
- imail->data.virtual_size = (uoff_t)-1;
+ imail->data.physical_size = UOFF_T_MAX;
+ imail->data.virtual_size = UOFF_T_MAX;
imail->data.parts = NULL;
index_mail_reset_vsize_ext(mail);
break;
struct mail *mail = mstream->mail;
enum mail_lookup_abort orig_lookup_abort;
- if (mstream->expected_size != (uoff_t)-1)
+ if (mstream->expected_size != UOFF_T_MAX)
return TRUE;
/* make sure this call doesn't change any existing error message,
orig_lookup_abort = mail->lookup_abort;
mail->lookup_abort = MAIL_LOOKUP_ABORT_NOT_IN_CACHE;
if (mail_get_physical_size(mail, &mstream->expected_size) < 0)
- mstream->expected_size = (uoff_t)-1;
+ mstream->expected_size = UOFF_T_MAX;
mail->lookup_abort = orig_lookup_abort;
mail_storage_last_error_pop(mail->box->storage);
- return mstream->expected_size != (uoff_t)-1;
+ return mstream->expected_size != UOFF_T_MAX;
}
static const char *
mstream = i_new(struct mail_istream, 1);
mstream->mail = mail;
mstream->input_has_body = input_has_body;
- mstream->expected_size = (uoff_t)-1;
+ mstream->expected_size = UOFF_T_MAX;
(void)i_stream_mail_try_get_cached_size(mstream);
mstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
mstream->istream.stream_size_passthrough = TRUE;
old_abort = mail->lookup_abort;
mail->lookup_abort = MAIL_LOOKUP_ABORT_READ_MAIL;
if (mail_get_physical_size(mail, &size) < 0)
- size = (uoff_t)-1;
+ size = UOFF_T_MAX;
if (mail_get_virtual_size(mail, &vsize) < 0)
- vsize = (uoff_t)-1;
+ vsize = UOFF_T_MAX;
maildir_save_set_sizes(mf, size, vsize);
mail->lookup_abort = old_abort;
return 1;
return -1;
}
- if (data->virtual_size == (uoff_t)-1) {
+ if (data->virtual_size == UOFF_T_MAX) {
if (index_mail_get_cached_virtual_size(mail, size_r)) {
- i_assert(mail->data.virtual_size != (uoff_t)-1);
+ i_assert(mail->data.virtual_size != UOFF_T_MAX);
maildir_handle_size_caching(mail, TRUE, TRUE);
return 0;
}
&data->virtual_size) < 0)
return -1;
}
- if (data->virtual_size != (uoff_t)-1) {
+ if (data->virtual_size != UOFF_T_MAX) {
data->dont_cache_fetch_fields |= MAIL_FETCH_VIRTUAL_SIZE;
*size_r = data->virtual_size;
return 0;
return -1;
}
- if (data->physical_size == (uoff_t)-1) {
+ if (data->physical_size == UOFF_T_MAX) {
if (index_mail_get_physical_size(_mail, size_r) == 0) {
- i_assert(mail->data.physical_size != (uoff_t)-1);
+ i_assert(mail->data.physical_size != UOFF_T_MAX);
maildir_handle_size_caching(mail, TRUE, FALSE);
return 0;
}
&data->physical_size) < 0)
return -1;
}
- if (data->physical_size != (uoff_t)-1) {
+ if (data->physical_size != UOFF_T_MAX) {
data->dont_cache_fetch_fields |= MAIL_FETCH_PHYSICAL_SIZE;
*size_r = data->physical_size;
return 0;
info = strchr(fname, MAILDIR_INFO_SEP);
if (info == NULL) info = "";
- if (ctx->physical_size == (uoff_t)-1) {
+ if (ctx->physical_size == UOFF_T_MAX) {
if (stat(path, &st) < 0) {
if (errno == ENOENT)
return 0;
return;
i_zero(&ctx);
- ctx.physical_size = (uoff_t)-1;
+ ctx.physical_size = UOFF_T_MAX;
if (field == MAIL_FETCH_VIRTUAL_SIZE &&
maildir_filename_get_size(fname, MAILDIR_EXTRA_VIRTUAL_SIZE,
&size)) {
mf = p_new(ctx->pool, struct maildir_filename, 1);
mf->tmp_name = mf->dest_basename = p_strdup(ctx->pool, tmp_fname);
mf->flags = mdata->flags;
- mf->size = (uoff_t)-1;
- mf->vsize = (uoff_t)-1;
+ mf->size = UOFF_T_MAX;
+ mf->vsize = UOFF_T_MAX;
ctx->file_last = mf;
i_assert(*ctx->files_tail == NULL);
{
const char *basename = mf->dest_basename;
- if (mf->size != (uoff_t)-1 && !mf->preserve_filename) {
+ if (mf->size != UOFF_T_MAX && !mf->preserve_filename) {
basename = t_strdup_printf("%s,%c=%"PRIuUOFF_T, basename,
MAILDIR_EXTRA_FILE_SIZE, mf->size);
}
- if (mf->vsize != (uoff_t)-1 && !mf->preserve_filename) {
+ if (mf->vsize != UOFF_T_MAX && !mf->preserve_filename) {
basename = t_strdup_printf("%s,%c=%"PRIuUOFF_T, basename,
MAILDIR_EXTRA_VIRTUAL_SIZE,
mf->vsize);
struct maildir_filename *mf = maildir_save_get_mf(t, seq);
*size_r = vsize ? mf->vsize : mf->size;
- return *size_r == (uoff_t)-1 ? -1 : 0;
+ return *size_r == UOFF_T_MAX ? -1 : 0;
}
const char *maildir_save_file_get_path(struct mailbox_transaction_context *t,
if (ctx->cur_dest_mail == NULL ||
mail_get_virtual_size(ctx->cur_dest_mail,
&ctx->file_last->vsize) < 0)
- ctx->file_last->vsize = (uoff_t)-1;
+ ctx->file_last->vsize = UOFF_T_MAX;
output_errno = _ctx->data.output->stream_errno;
output_errstr = t_strdup(o_stream_get_error(_ctx->data.output));
if (!maildir_filename_get_size(mf->dest_basename,
MAILDIR_EXTRA_FILE_SIZE, &size))
- size = (uoff_t)-1;
+ size = UOFF_T_MAX;
if (!maildir_filename_get_size(mf->dest_basename,
MAILDIR_EXTRA_VIRTUAL_SIZE, &vsize))
- vsize = (uoff_t)-1;
+ vsize = UOFF_T_MAX;
if (size != mf->size || vsize != mf->vsize ||
!ctx->locked_uidlist_refresh ||
b) file already exists. give it another name.
but preserve the size/vsize in the filename if possible */
- if (mf->size == (uoff_t)-1)
+ if (mf->size == UOFF_T_MAX)
mf->size = size;
- if (mf->vsize == (uoff_t)-1)
+ if (mf->vsize == UOFF_T_MAX)
mf->vsize = size;
mf->guid = mf->dest_basename;
i_assert(fd != -1);
- output = o_stream_create_fd_file(fd, (uoff_t)-1, FALSE);
+ output = o_stream_create_fd_file(fd, UOFF_T_MAX, FALSE);
o_stream_cork(output);
str = t_str_new(512);
uoff_t new_body_offset =
rstream->hdr_offset + rstream->mail_size;
- if (rstream->body_offset != (uoff_t)-1) {
+ if (rstream->body_offset != UOFF_T_MAX) {
/* Header didn't have ending \n */
rstream->header_missing_eoh = TRUE;
} else {
}
/* The +2 check is for CR+LF linefeeds */
- i_assert(rstream->body_offset == (uoff_t)-1 ||
+ i_assert(rstream->body_offset == UOFF_T_MAX ||
rstream->body_offset == new_body_offset + 1 ||
rstream->body_offset == new_body_offset + 2);
rstream->body_offset = new_body_offset;
/* 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_MAX;
- eoh_char = rstream->body_offset == (uoff_t)-1 ? '\n' : -1;
+ eoh_char = rstream->body_offset == UOFF_T_MAX ? '\n' : -1;
for (i = stream->pos; i < pos; i++) {
if (buf[i] == eoh_char &&
((i > 0 && buf[i-1] == '\n') ||
from_start_pos = i - 6;
}
- if (rstream->mail_size == (uoff_t)-1 ||
+ if (rstream->mail_size == UOFF_T_MAX ||
rstream->hdr_offset + rstream->mail_size ==
stream->istream.v_offset + from_start_pos) {
from_after_pos = i;
stream->statbuf = *st;
stream->statbuf.st_size =
- !exact && rstream->seeked && rstream->mail_size != (uoff_t)-1 ?
+ !exact && rstream->seeked && rstream->mail_size != UOFF_T_MAX ?
(off_t)rstream->mail_size : -1;
return 0;
}
rstream = i_new(struct raw_mbox_istream, 1);
- rstream->body_offset = (uoff_t)-1;
- rstream->mail_size = (uoff_t)-1;
+ rstream->body_offset = UOFF_T_MAX;
+ rstream->mail_size = UOFF_T_MAX;
rstream->received_time = (time_t)-1;
rstream->next_received_time = (time_t)-1;
i_assert(rstream->seeked);
- if (rstream->body_offset != (uoff_t)-1) {
+ if (rstream->body_offset != UOFF_T_MAX) {
*body_offset_r = rstream->body_offset;
return 0;
}
offset = stream->v_offset;
i_stream_seek(stream, rstream->hdr_offset);
- while (rstream->body_offset == (uoff_t)-1) {
+ while (rstream->body_offset == UOFF_T_MAX) {
i_stream_skip(stream, i_stream_get_data_size(stream));
if (i_stream_read(stream) < 0) {
i_stream_get_name(stream),
rstream->from_offset);
} else {
- i_assert(rstream->body_offset != (uoff_t)-1);
+ i_assert(rstream->body_offset != UOFF_T_MAX);
}
return -1;
}
uoff_t old_offset, body_offset, body_size, next_body_offset;
i_assert(rstream->seeked);
- i_assert(rstream->hdr_offset != (uoff_t)-1);
+ i_assert(rstream->hdr_offset != UOFF_T_MAX);
if (istream_raw_mbox_get_body_offset(stream, &body_offset) < 0)
return -1;
- body_size = rstream->mail_size == (uoff_t)-1 ? (uoff_t)-1 :
+ body_size = rstream->mail_size == UOFF_T_MAX ? UOFF_T_MAX :
rstream->mail_size - (rstream->body_offset -
rstream->hdr_offset);
old_offset = stream->v_offset;
- if (expected_body_size != (uoff_t)-1) {
+ if (expected_body_size != UOFF_T_MAX) {
/* if we already have the existing body size, use it as long as
it's >= expected body_size. otherwise the previous parsing
may have stopped at a From_-line that belongs to the body. */
- if (body_size != (uoff_t)-1 && body_size >= expected_body_size) {
+ if (body_size != UOFF_T_MAX && body_size >= expected_body_size) {
*body_size_r = body_size;
return 0;
}
}
/* invalid expected_body_size */
}
- if (body_size != (uoff_t)-1) {
+ if (body_size != UOFF_T_MAX) {
*body_size_r = body_size;
return 0;
}
if (stream->stream_errno != 0)
return -1;
- i_assert(rstream->mail_size != (uoff_t)-1);
+ i_assert(rstream->mail_size != UOFF_T_MAX);
*body_size_r = rstream->mail_size -
(rstream->body_offset - rstream->hdr_offset);
return 0;
if (istream_raw_mbox_get_body_size(stream, expected_body_size,
&body_size) < 0)
return -1;
- rstream->mail_size = (uoff_t)-1;
+ rstream->mail_size = UOFF_T_MAX;
rstream->received_time = rstream->next_received_time;
rstream->next_received_time = (time_t)-1;
rstream->from_offset = rstream->body_offset + body_size;
rstream->hdr_offset = rstream->from_offset;
- rstream->body_offset = (uoff_t)-1;
+ rstream->body_offset = UOFF_T_MAX;
rstream->header_missing_eoh = FALSE;
if (stream->v_offset != rstream->from_offset)
/* if seeked is FALSE, we unlocked in the middle. don't try to use
any cached state then. */
- if (rstream->mail_size != (uoff_t)-1 && rstream->seeked &&
+ if (rstream->mail_size != UOFF_T_MAX && rstream->seeked &&
rstream->hdr_offset + rstream->mail_size == offset)
- return istream_raw_mbox_next(stream, (uoff_t)-1);
+ return istream_raw_mbox_next(stream, UOFF_T_MAX);
if (offset == rstream->from_offset && rstream->seeked) {
/* back to beginning of current message */
offset = rstream->hdr_offset;
check = offset == 0;
} else {
- rstream->body_offset = (uoff_t)-1;
- rstream->mail_size = (uoff_t)-1;
+ rstream->body_offset = UOFF_T_MAX;
+ rstream->mail_size = UOFF_T_MAX;
rstream->received_time = (time_t)-1;
rstream->next_received_time = (time_t)-1;
rstream->header_missing_eoh = FALSE;
struct raw_mbox_istream *rstream =
(struct raw_mbox_istream *)stream->real_stream;
- i_assert(rstream->hdr_offset != (uoff_t)-1);
+ i_assert(rstream->hdr_offset != UOFF_T_MAX);
rstream->mail_size_forced = TRUE;
rstream->mail_size = offset - rstream->hdr_offset;
uoff_t *body_offset_r);
/* Return the number of bytes in the body of this message. If
- expected_body_size isn't (uoff_t)-1, we'll use it as potentially valid body
+ expected_body_size isn't UOFF_T_MAX, we'll use it as potentially valid body
size to avoid actually reading through the whole message. */
int istream_raw_mbox_get_body_size(struct istream *stream,
uoff_t expected_body_size,
/* Return TRUE if the empty line between this and the next mail contains CR. */
bool istream_raw_mbox_has_crlf_ending(struct istream *stream);
-/* Jump to next message. If expected_body_size isn't (uoff_t)-1, we'll use it
+/* Jump to next message. If expected_body_size isn't UOFF_T_MAX, we'll use it
as potentially valid body size. */
int istream_raw_mbox_next(struct istream *stream, uoff_t expected_body_size);
int trailer_size;
int ret = 1;
- *next_offset_r = (uoff_t)-1;
+ *next_offset_r = UOFF_T_MAX;
hdr = mail_index_get_header(mail->mail.mail.transaction->view);
if (mail->mail.mail.seq > hdr->messages_count) {
if (mbox_mail_get_next_offset(mail, &next_offset) > 0)
body_size = next_offset - body_offset;
else
- body_size = (uoff_t)-1;
+ body_size = UOFF_T_MAX;
/* verify that the calculated body size is correct */
if (istream_raw_mbox_get_body_size(mbox->mbox_stream,
}
i_stream_seek(raw_stream, hdr_offset);
- if (next_offset != (uoff_t)-1)
+ if (next_offset != UOFF_T_MAX)
istream_raw_mbox_set_next_offset(raw_stream, next_offset);
- raw_stream = i_stream_create_limit(raw_stream, (uoff_t)-1);
+ raw_stream = i_stream_create_limit(raw_stream, UOFF_T_MAX);
mail->data.stream =
i_stream_create_header_filter(raw_stream,
HEADER_FILTER_EXCLUDE | HEADER_FILTER_NO_CR,
const char *str;
size_t len;
- i_assert(ctx->eoh_offset != (uoff_t)-1);
+ i_assert(ctx->eoh_offset != UOFF_T_MAX);
if (ctx->mbox->mbox_writeonly) {
/* we can't seek, don't set Content-Length */
return -1;
}
- if (ctx->append_offset == (uoff_t)-1) {
+ if (ctx->append_offset == UOFF_T_MAX) {
/* first appended mail in this transaction */
if (t->write_lock_id == 0) {
if (mbox_lock(mbox, F_WRLCK, &t->write_lock_id) <= 0)
}
/* the syncing above could have changed the append offset */
- if (ctx->append_offset == (uoff_t)-1) {
+ if (ctx->append_offset == UOFF_T_MAX) {
if (mbox_seek_to_end(ctx, &ctx->append_offset) < 0)
return -1;
ctx->ctx.transaction = t;
ctx->mbox = mbox;
ctx->trans = t->itrans;
- ctx->append_offset = (uoff_t)-1;
+ ctx->append_offset = UOFF_T_MAX;
ctx->headers = str_new(default_pool, 512);
- ctx->mail_offset = (uoff_t)-1;
+ ctx->mail_offset = UOFF_T_MAX;
t->save_ctx = &ctx->ctx;
}
return t->save_ctx;
i_assert(ctx->mbox->mbox_lock_type == F_WRLCK);
ctx->mail_offset = ctx->output->offset;
- ctx->eoh_offset = (uoff_t)-1;
+ ctx->eoh_offset = UOFF_T_MAX;
ctx->last_char = '\n';
if (write_from_line(ctx, mdata->received_date, mdata->from_envelope) < 0)
static int mbox_save_finish_headers(struct mbox_save_context *ctx)
{
- i_assert(ctx->eoh_offset == (uoff_t)-1);
+ i_assert(ctx->eoh_offset == UOFF_T_MAX);
/* append our own headers and ending empty line */
ctx->extra_hdr_offset = ctx->output->offset;
if (ctx->failed)
return -1;
- if (ctx->eoh_offset != (uoff_t)-1) {
+ if (ctx->eoh_offset != UOFF_T_MAX) {
/* writing body */
return mbox_save_body(ctx);
}
{
struct mbox_save_context *ctx = MBOX_SAVECTX(_ctx);
- if (!ctx->failed && ctx->eoh_offset == (uoff_t)-1)
+ if (!ctx->failed && ctx->eoh_offset == UOFF_T_MAX)
(void)mbox_save_finish_headers(ctx);
if (ctx->output != NULL) {
if (ctx->input != NULL)
i_stream_destroy(&ctx->input);
- if (ctx->failed && ctx->mail_offset != (uoff_t)-1) {
+ if (ctx->failed && ctx->mail_offset != UOFF_T_MAX) {
/* saving this mail failed - truncate back to beginning of it */
i_assert(ctx->output != NULL);
(void)o_stream_flush(ctx->output);
if (ftruncate(ctx->mbox->mbox_fd, (off_t)ctx->mail_offset) < 0)
mbox_set_syscall_error(ctx->mbox, "ftruncate()");
(void)o_stream_seek(ctx->output, ctx->mail_offset);
- ctx->mail_offset = (uoff_t)-1;
+ ctx->mail_offset = UOFF_T_MAX;
}
if (ctx->seq != 0 && ctx->failed) {
static void mbox_save_truncate(struct mbox_save_context *ctx)
{
- if (ctx->append_offset == (uoff_t)-1 || ctx->mbox->mbox_fd == -1)
+ if (ctx->append_offset == UOFF_T_MAX || ctx->mbox->mbox_fd == -1)
return;
i_assert(ctx->mbox->mbox_lock_type == F_WRLCK);
uoff_t value = 0;
size_t i;
- if (ctx->content_length != (uoff_t)-1) {
+ if (ctx->content_length != UOFF_T_MAX) {
/* duplicate */
return FALSE;
}
for (i = 0; i < MBOX_HDR_COUNT; i++)
ctx->hdr_pos[i] = SIZE_MAX;
- ctx->content_length = (uoff_t)-1;
+ ctx->content_length = UOFF_T_MAX;
str_truncate(ctx->header, 0);
mbox_md5_ctx = ctx->sync_ctx->mbox->md5_v.init();
i_stream_sync(sync_ctx->input);
- output = o_stream_create_fd_file(sync_ctx->write_fd, (uoff_t)-1, FALSE);
+ output = o_stream_create_fd_file(sync_ctx->write_fd, UOFF_T_MAX, FALSE);
i_stream_seek(sync_ctx->file_input, source);
if (o_stream_seek(output, dest) < 0) {
mbox_set_syscall_error(sync_ctx->mbox,
str_append_c(ctx->header, '\n');
}
- if (ctx->content_length == (uoff_t)-1 &&
+ if (ctx->content_length == UOFF_T_MAX &&
ctx->mail.body_size >= MBOX_MIN_CONTENT_LENGTH_SIZE) {
str_printfa(ctx->header, "Content-Length: %"PRIuUOFF_T"\n",
ctx->mail.body_size);
static int mbox_sync_handle_header(struct mbox_sync_mail_context *mail_ctx)
{
struct mbox_sync_context *sync_ctx = mail_ctx->sync_ctx;
- uoff_t orig_from_offset, postlf_from_offset = (uoff_t)-1;
+ uoff_t orig_from_offset, postlf_from_offset = UOFF_T_MAX;
off_t move_diff;
int ret;
from_offset to point to the beginning of the
From-line, because the previous [CR]LF is already
covered by expunged_space. */
- i_assert(postlf_from_offset != (uoff_t)-1);
+ i_assert(postlf_from_offset != UOFF_T_MAX);
mail_ctx->mail.from_offset = postlf_from_offset;
i_zero(&mail);
struct message_size hdr_size, body_size;
struct istream *input;
- if (mail->data.virtual_size != (uoff_t)-1) {
+ if (mail->data.virtual_size != UOFF_T_MAX) {
/* virtual size is already known. it's the same as our
(correct) physical size */
*size_r = mail->data.virtual_size;
if (mail_get_stream(_mail, &hdr_size, &body_size, &input) < 0)
return -1;
- i_assert(mail->data.physical_size != (uoff_t)-1);
+ i_assert(mail->data.physical_size != UOFF_T_MAX);
*size_r = mail->data.physical_size;
return 0;
}
struct index_mail *mail = INDEX_MAIL(_mail);
struct raw_mailbox *mbox = RAW_MAILBOX(_mail->box);
- if (mbox->size == (uoff_t)-1) {
+ if (mbox->size == UOFF_T_MAX) {
if (raw_mail_stat(_mail) < 0)
return -1;
}
/* we can't just reference mbox->input, because
index_mail_close() expects to be able to free the stream */
mail->data.stream =
- i_stream_create_limit(_mail->box->input, (uoff_t)-1);
+ i_stream_create_limit(_mail->box->input, UOFF_T_MAX);
}
return index_mail_init_stream(mail, hdr_size, body_size, stream_r);
mbox->mtime = mbox->ctime = (time_t)-1;
mbox->storage = RAW_STORAGE(storage);
- mbox->size = (uoff_t)-1;
+ mbox->size = UOFF_T_MAX;
return &mbox->box;
}
doesn't have to deal with any extra checks. */
size = SSIZE_T_MAX;
}
- if (offset >= (uoff_t)-1 - size)
- size = (uoff_t)-1 - offset;
+ if (offset >= UOFF_T_MAX - size)
+ size = UOFF_T_MAX - offset;
if (offset + size > cache->mmap_length &&
offset + size - cache->mmap_length > 1024*1024) {
unsigned int first_page, last_page;
i_assert(page_size > 0);
- i_assert((uoff_t)-1 - offset > size);
+ i_assert(UOFF_T_MAX - offset > size);
if (file_cache_set_size(cache, offset + size) < 0) {
/* couldn't grow mapping. just make sure the written memory
{
struct concat_istream *cstream = (struct concat_istream *)stream;
i_assert(cstream->cur_input == cstream->input[cstream->cur_idx]);
- uoff_t v_offset = (uoff_t)-1;
+ uoff_t v_offset = UOFF_T_MAX;
unsigned int i, cur_idx;
/* make sure we have all sizes */
stream->pos = new_pos;
}
} else if (ret < 0 && stream->istream.stream_errno == 0 &&
- fstream->failure_offset == (uoff_t)-1) {
+ fstream->failure_offset == UOFF_T_MAX) {
/* failure at EOF */
stream->istream.stream_errno = errno =
fstream->error_code;
i_stream_create_failure_at_eof(struct istream *input, int stream_errno,
const char *error_string)
{
- return i_stream_create_failure_at(input, (uoff_t)-1, stream_errno,
+ return i_stream_create_failure_at(input, UOFF_T_MAX, stream_errno,
error_string);
}
if (ret == -2)
return -2;
- if (lstream->v_size != (uoff_t)-1) {
+ if (lstream->v_size != UOFF_T_MAX) {
left = lstream->v_size - stream->istream.v_offset;
if (pos >= left) {
pos = left;
}
stream->statbuf = *st;
- if (lstream->v_size != (uoff_t)-1)
+ if (lstream->v_size != UOFF_T_MAX)
stream->statbuf.st_size = lstream->v_size;
return 0;
}
struct limit_istream *lstream = (struct limit_istream *) stream;
const struct stat *st;
- if (lstream->v_size != (uoff_t)-1) {
+ if (lstream->v_size != UOFF_T_MAX) {
*size_r = lstream->v_size;
return 1;
}
struct istream *parent; /* for filter streams */
uoff_t parent_start_offset;
- /* Initially (uoff_t)-1. Otherwise it's the exact known stream size,
+ /* Initially UOFF_T_MAX. Otherwise it's the exact known stream size,
which can be used by stat() / get_size(). */
uoff_t cached_stream_size;
uoff_t old_offset, len;
ssize_t ret;
- if (sstream->size != (uoff_t)-1) {
+ if (sstream->size != UOFF_T_MAX) {
/* we've already reached EOF and know the size */
stream->statbuf.st_size = sstream->size;
return 0;
sstream->context = context;
sstream->istream.max_buffer_size = max_buffer_size;
sstream->fd = -1;
- sstream->size = (uoff_t)-1;
+ sstream->size = UOFF_T_MAX;
sstream->input = i_new(struct istream *, count + 1);
memcpy(sstream->input, input, sizeof(*input) * count);
i_stream_ref(input);
tee->input = input;
} else {
- tee->input = i_stream_create_limit(input, (uoff_t)-1);
+ tee->input = i_stream_create_limit(input, UOFF_T_MAX);
}
return tee;
}
static int
seekable_i_stream_get_size(struct istream_private *stream)
{
- if (stream->cached_stream_size == (uoff_t)-1) {
+ if (stream->cached_stream_size == UOFF_T_MAX) {
uoff_t old_offset = stream->istream.v_offset;
ssize_t ret;
_stream->statbuf.st_atime =
_stream->statbuf.st_mtime =
_stream->statbuf.st_ctime = ioloop_time;
- _stream->cached_stream_size = (uoff_t)-1;
+ _stream->cached_stream_size = UOFF_T_MAX;
io_stream_init(&_stream->iostream);
struct file_ostream *fstream;
struct ostream *ostream;
- if (offset == (uoff_t)-1)
+ if (offset == UOFF_T_MAX)
offset = lseek(fd, 0, SEEK_CUR);
fstream = i_new(struct file_ostream, 1);
/* The fd is set to -1 immediately to avoid accidentally closing it twice. */
struct ostream *o_stream_create_fd_autoclose(int *fd, size_t max_buffer_size);
/* Create an output stream from a regular file which begins at given offset.
- If offset==(uoff_t)-1, the current offset isn't known. */
+ If offset==UOFF_T_MAX, the current offset isn't known. */
struct ostream *
o_stream_create_fd_file(int fd, uoff_t offset, bool autoclose_fd);
struct ostream *o_stream_create_fd_file_autoclose(int *fd, uoff_t offset);
if (str_to_uintmax(str, &l) < 0)
return -1;
- if (l > (uoff_t)-1)
+ if (l > UOFF_T_MAX)
return -1;
*num_r = (uoff_t)l;
return 0;
/* non-working fd-dup: send two istreams */
i_stream_seek(input, 0);
- input2 = i_stream_create_limit(input, (uoff_t)-1);
+ input2 = i_stream_create_limit(input, UOFF_T_MAX);
output = iostream_temp_create_sized(".intentional-nonexistent-error/",
IOSTREAM_TEMP_FLAG_TRY_FD_DUP, "test", 4);
test_assert(o_stream_send_istream(output, input) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
if (simult > 0) {
limits = t_new(struct istream *, simult);
for (i = 0; i < simult; i++)
- limits[i] = i_stream_create_limit(concat, (uoff_t)-1);
+ limits[i] = i_stream_create_limit(concat, UOFF_T_MAX);
}
for (i = 0; i < 1000; i++) {
{ "a", 1, 0 },
{ "ab", 1, EINVAL },
{ "ab", 0, EINVAL },
- { "ab", (uoff_t)-1, EPIPE },
+ { "ab", UOFF_T_MAX, EPIPE },
};
static void
parent = test_istream_create_data("123456789", 9);
test_istream_set_max_buffer_size(parent, 3);
- child1 = i_stream_create_limit(parent, (uoff_t)-1);
- child2 = i_stream_create_limit(parent, (uoff_t)-1);
+ child1 = i_stream_create_limit(parent, UOFF_T_MAX);
+ child2 = i_stream_create_limit(parent, UOFF_T_MAX);
/* child1 read beginning */
test_assert(i_stream_read(child1) == 3);
lmtp_set.capabilities |= SMTP_CAPABILITY_STARTTLS;
lmtp_set.hostname = client->unexpanded_lda_set->hostname;
lmtp_set.login_greeting = client->lmtp_set->login_greeting;
- lmtp_set.max_message_size = (uoff_t)-1;
+ lmtp_set.max_message_size = UOFF_T_MAX;
lmtp_set.rcpt_param_extensions = rcpt_param_extensions;
lmtp_set.rcpt_domain_optional = TRUE;
lmtp_set.max_client_idle_time_msecs = CLIENT_IDLE_TIMEOUT_MSECS;
e_error(client->event,
"i_stream_get_size(data_input) failed: %s",
i_stream_get_error(proxy->data_input));
- size = (uoff_t)-1;
+ size = UOFF_T_MAX;
}
/* Create the data_input streams first */
continue;
}
- if (size == (uoff_t)-1) {
+ if (size == UOFF_T_MAX) {
conn->data_input =
- i_stream_create_limit(data_input, (uoff_t)-1);
+ i_stream_create_limit(data_input, UOFF_T_MAX);
} else {
conn->data_input =
i_stream_create_sized(data_input, size);
.client_limit = 1,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &lmtp_unix_listeners_buf,
sizeof(lmtp_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = UINT_MAX,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &log_unix_listeners_buf,
sizeof(log_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = ARRAY_INIT,
.fifo_listeners = ARRAY_INIT,
service->client_limit > set->service_count)
service->client_limit = set->service_count;
- service->vsz_limit = set->vsz_limit != (uoff_t)-1 ? set->vsz_limit :
+ service->vsz_limit = set->vsz_limit != UOFF_T_MAX ? set->vsz_limit :
set->master_set->default_vsz_limit;
service->idle_kill = set->idle_kill != 0 ? set->idle_kill :
set->master_set->default_idle_kill;
.client_limit = 0,
.service_count = 0,
.idle_kill = UINT_MAX,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &old_stats_unix_listeners_buf,
sizeof(old_stats_unix_listeners[0]) } },
if (uidlist->file_cache != NULL) {
file_cache_invalidate(uidlist->file_cache,
- page_size, (uoff_t)-1);
+ page_size, UOFF_T_MAX);
} else {
(void)madvise(uidlist->mmap_base, uidlist->mmap_size,
MADV_DONTNEED);
cache->input = input;
/* index-mail wants the stream to be destroyed at close, so create
a new stream instead of just increasing reference. */
- return i_stream_create_limit(cache->input, (uoff_t)-1);
+ return i_stream_create_limit(cache->input, UOFF_T_MAX);
}
return input;
already be seeked into the wanted offset. */
i_stream_unref(stream);
i_stream_seek(cache->input, 0);
- *stream = i_stream_create_limit(cache->input, (uoff_t)-1);
+ *stream = i_stream_create_limit(cache->input, UOFF_T_MAX);
return mmail->super.istream_opened(_mail, stream);
}
struct mail *mail;
struct pop3_uidl_map *map;
const char *uidl;
- uoff_t size = (uoff_t)-1;
+ uoff_t size = UOFF_T_MAX;
int ret = 0;
if (array_is_created(&mstorage->pop3_uidl_map)) {
struct mail_search_context *ctx;
struct mail *mail;
struct imap_msg_map *map;
- uoff_t psize = (uoff_t)-1;
+ uoff_t psize = UOFF_T_MAX;
string_t *uidl;
int ret = 0;
continue;
p = strstr(dp->d_name, ",S=");
- num = (uoff_t)-1;
+ num = UOFF_T_MAX;
if (p != NULL) {
/* ,S=nnnn[:,] */
p += 3;
if (*p != ':' && *p != '\0' && *p != ',') {
/* not in expected format, fallback to stat() */
- num = (uoff_t)-1;
+ num = UOFF_T_MAX;
} else {
*total_bytes += num;
*total_count += 1;
}
}
- if (num == (uoff_t)-1) {
+ if (num == UOFF_T_MAX) {
struct stat st;
str_truncate(path, len);
cache->input = input;
/* index-mail wants the stream to be destroyed at close, so create
a new stream instead of just increasing reference. */
- return i_stream_create_limit(cache->input, (uoff_t)-1);
+ return i_stream_create_limit(cache->input, UOFF_T_MAX);
} else {
return input;
}
already be seeked into the wanted offset. */
i_stream_unref(stream);
i_stream_seek(cache->input, 0);
- *stream = i_stream_create_limit(cache->input, (uoff_t)-1);
+ *stream = i_stream_create_limit(cache->input, UOFF_T_MAX);
return zmail->module_ctx.super.istream_opened(_mail, stream);
}
.client_limit = 0,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = ARRAY_INIT,
.fifo_listeners = ARRAY_INIT,
return ret;
}
- if (body_lines == (uoff_t)-1 && client->seen_bitmask != NULL) {
+ if (body_lines == UOFF_T_MAX && client->seen_bitmask != NULL) {
if ((mail_get_flags(ctx->mail) & MAIL_SEEN) == 0) {
/* mark the message seen with RETR command */
client->seen_bitmask[msgnum / CHAR_BIT] |=
}
ctx->body_lines = body_lines;
- if (body_lines == (uoff_t)-1) {
+ if (body_lines == UOFF_T_MAX) {
client_send_line(client, "+OK %"PRIuUOFF_T" octets",
client->message_sizes[msgnum]);
} else {
client->last_seen_pop3_msn = msgnum+1;
client->retr_count++;
- return fetch(client, msgnum, (uoff_t)-1, "RETR", &client->retr_bytes);
+ return fetch(client, msgnum, UOFF_T_MAX, "RETR", &client->retr_bytes);
}
static int cmd_rset(struct client *client, const char *args ATTR_UNUSED)
.client_limit = 1,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &pop3_unix_listeners_buf,
sizeof(pop3_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &aggregator_unix_listeners_buf,
sizeof(aggregator_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = UINT_MAX,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &replicator_unix_listeners_buf,
sizeof(replicator_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 0,
.idle_kill = UINT_MAX,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &stats_unix_listeners_buf,
sizeof(stats_unix_listeners[0]) } },
.client_limit = 0,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = ARRAY_INIT,
.fifo_listeners = ARRAY_INIT,
.client_limit = 1,
.service_count = 1,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = { { &submission_unix_listeners_buf,
sizeof(submission_unix_listeners[0]) } },
.client_limit = 1,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = ARRAY_INIT,
.fifo_listeners = ARRAY_INIT,
.client_limit = 1,
.service_count = 0,
.idle_kill = 0,
- .vsz_limit = (uoff_t)-1,
+ .vsz_limit = UOFF_T_MAX,
.unix_listeners = ARRAY_INIT,
.fifo_listeners = ARRAY_INIT,
projects / thirdparty / dovecot / core.git / commitdiff
