lib: Add i_stream_get_root_io() and use it to deduplicate code

global: start relying on str_free(NULL) being a no-op Cleanup performed with the following semantic patch: @@ expression E; @@ - if (E != NULL) { - str_free(&E); - } + str_free(&E);

lib: istream: Allow switching to a specific ioloop.

lib: iostream: Record the ioloop that the iostream was last switched to.

Updated copyright notices to include the year 2018.

lib: use temp var in i_stream_unref for clarity

lib: Add i_stream_get_last_read_time()

lib: istream - Avoid panic in snapshot() with nonpersistent buffers

lib: istream - Don't leak snapshot memory if close() triggers a read Also move the line_str freeing just before stream is freed. That didn't cause any known memory leaks though.

lib: i_stream_w_buffer_realloc() - avoid passing NULL to memcpy() It happened only with size=0, so it shouldn't have mattered much.

global: start relying on [io]_stream_close(NULL) being a no-op Cleanup performed with the following semantic patch (and a bit of hand-editing): @@ expression E; @@ - if (E != NULL) { - i_stream_close(E); - } + i_stream_close(E); @@ expression E; @@ - if (E != NULL) { - o_stream_close(E); - } + o_stream_close(E);

lib: [io]_stream_close(NULL) should be no-ops

global: Use i_stream_read_memarea() wherever possible

lib: i_stream_compress() - assert-crash if trying to compress shared memarea The caller is always expected to check the refcount before calling this.

lib: i_stream_read() - Add buffer validity checks if DEBUG is enabled

lib: i_stream_read() - Use snapshots This guarantees that data returned by i_stream_get_data() won't be freed until the next i_stream_read() returns >0. This is mainly important, because often the error handling for <=0 doesn't update the buffer pointers correctly and it leads to complicated bugs where already freed memory is attempted to be read (but never written).

lib: Add ISTREAM_CREATE_FLAG_NOOP_SNAPSHOT flag

global: Add flags parameter to i_stream_create() and set it to 0 This just changes the API - the following changes add the new flag.

lib: Add i_stream_try_alloc_avoid_compress()

lib: Add istream.snapshot() method for referencing the current memarea It will be used by following commits.

lib: Use memarea for default istream memory allocations.

global: Use i_stream_free_buffer() instead of freeing w_buffer directly

lib: Add i_stream_free_buffer() to free i_stream_*alloc()ed memory

global: Rename i_stream_is_eof() to i_stream_read_eof() This describes its behavior a bit better.

global: stop including fd-set-nonblock.h & fd-close-on-exec.h directly

lib: Add i_stream_set_blocking()

global: start relying on [io]_stream_unref(NULL) being a no-op Cleanup performed with the following semantic patch: @@ expression E; @@ - if (E != NULL) { - i_stream_unref(&E); - } + i_stream_unref(&E); @@ expression E; @@ - if (E != NULL) { - o_stream_unref(&E); - } + o_stream_unref(&E);

lib: [io]_stream_unref(NULL) should be a no-op

lib: [io]_stream_destroy(NULL) should be a no-op

Updated copyright notices to include the year 2017.

global: Replaced all instances of memset(p, 0, sizeof(*p)) with the new i_zero() macro. Used the following script: C_FILES=`git ls-files *.c` H_FILES=`git ls-files *.h` for F in "$C_FILES $H_FILES"; do echo "$F" perl -p -i -e 's/safe_memset\(&\(?([^,]*)\)?,\s*0,\s*sizeof\(\g1\)\)/i_zero_safe(&$1)/g' $F perl -p -i -e 's/safe_memset\(([^,]*),\s*0,\s*sizeof\(\*\g1\)\)/i_zero_safe($1)/g' $F perl -p -i -e 's/memset\(&\(?([^,]*)\)?,\s*0,\s*sizeof\(\g1\)\)/i_zero(&$1)/g' $F perl -p -i -e 's/memset\(([^,]*),\s*0,\s*sizeof\(\*\g1\)\)/i_zero($1)/g' $F done

global: Code cleanup - avoid passing NULL to functions with non-null parameter

lib: Mark istream with eof=TRUE on all errors Previously only i_stream_read() did this, but i_stream_seek(), _stat(), _get_size() and _create() didn't. This caused assert-crashes on error conditions in code which assumed that when stream_errno != 0, eof==TRUE.

global: Added uchar_empty_ptr and use it instead of &uchar_nul. This makes Coverity happier about not treating a char as an array. For now this is a pointer to a 0, but could as well become a pointer that crashes if dereferenced. Shouldn't be NULL anyway because clang's -fsanitize=nonnull-attribute will complain about them.

lib: return non-NULL pointer in i_stream_get_data when size is 0

Calling i_stream_next_line() on a chain stream would sometimes erroneously use the stream->w_buffer. It used the wrong check to assess whether the w_buffer is usable. The chain stream only uses the w_buffer when partial stream data needs to be merged. Otherwise, a parent stream's buffer is used directly. However, this does not mean that w_buffer will be NULL in that case, which is what i_stream_next_line() assumed.

global: Use only explicit int -> bool conversions These were checked with a patched clang.

global: Use i_stream_get_max_buffer_size() wherever possible After 7be8ba0c0 it's no longer correct to access stream->max_buffer_size directly. These changes fix using istream-chain with various wrapper streams.

lib: i_stream_get_max_buffer_size() checks also parents' max sizes This fixes i_stream_get_max_buffer_size() to work correctly with istream-chain.

lib: Changed istream.abs_start_offset to be relative start_offset i_stream_get_absolute_offset() walks through the stream's parents to get the absolute offset. This allows streams to change their start_offset after they have already created (e.g. istream-metawrap).

lib: Fixed potential crash in i_stream_stat() failures. We shouldn't have been copying parent's stream_errno here. Especially because the parent can be NULL.

lib: check stream_errno too when checking whether istream is closed

lib: Added i_stream_get_disconnect_reason()

lib: istream's max_buffer_size=0 means 0, not unlimited. Make sure we don't grow the buffer size then.

lib: When istream is destroyed, it now always unrefs the parent istream if it exists. This way the implementations don't have to do it themselves in their destroy() function. This change doesn't necessarily require changing the existing code, because if the istream implementation already unrefs the parent it gets set to NULL so the auto-unref won't be done.

lib: Added i_stream_set_persistent_buffers()

global: freshen copyright git ls-files | xargs perl -p -i -e 's/(\d+)-201[0-5]/$1-2016/g;s/ (201[0-5]) Dovecot/ $1-2016 Dovecot/'

lib: i_stream_get_error() now returns "EOF" if stream_errno==0 and eof==TRUE. This can be used to replace a lot of code like: input->stream_errno == 0 ? "EOF" : i_stream_get_error(input) with simply: i_stream_get_error(input)

lib: Added extra assert to i_stream_read()

istream filters: If parent's i_stream_stat() fails, copy the stream_errno. This doesn't actually change any functionality yet, since most i_stream_stat() callers aren't using i_stream_get_error().

lib: If i_stream_read() sets stream_errno even if it didn't return -1, make sure we set eof=TRUE

lib: Added o_stream_add_destroy_callback()

global: freshen copyright Robomatically: git ls-files | xargs perl -p -i -e 's/(\d+)-201[0-4]/$1-2015/g;s/ (201[0-4]) Dovecot/ $1-2015 Dovecot/' Happy 2015 everyone! Signed-off-by: Phil Carmody <phil@dovecot.fi>

lib: Never implicitly clear istream's stream_errno. I'm not really sure why these were added in the first place. At some point the stream_errno was cleared in more places, such as just before reading, but those were also removed already. I don't see any benefit for these, just potential problems.

lib: If i_stream_seek() works by reading forward and read() fails, don't override the error message.

lib: i_stream_read_next_line() now sets a better error message if line is too long.

lib: If i_stream_default_seek_nonseekable() can't seek, set a more readable error message.

lib: i_stream_read_copy_from_parent() needs to update access counter also when returning -2 This finishes the 467a4d19f873 fix.

lib: i_stream_read_copy_from_parent() now directly updates the access counter This fixes a bug in istream-mail where it called i_stream_get_data() after it and reset the stream's skip/pos.

lib: i_stream_get_data() should also reset eof=FALSE if it truncates the output.

Compiler warning fix

lib: If two istreams share one parent, i_stream_get_data() may have returned corrupted data to another. This happened only for istreams that used parent's buffer directly instead of having their own buffer. For now at least we've solved this by truncating the other stream's buffer so it needs to be read again. Hopefully this is good enough. Added also unit test to check this functionality.

lib: a couple of trivial sparse cleanups The #include isn't needed on modern linux, as the macros are already defined The compiler seems to silently ignore redefinitions in system header files, so didn't throw a warning, but probably should have, as redefinitions can lead to insanity. The cast just makes it explicit that we're changing the prototype.

i_stream_read_next_line(): Set also errno=ENOBUFS on too large line. Some callers assume that errno is set to same as istream->stream_errno

Added io_add_istream() and related functionality for combining the ioloop/istream. The idea here is that it's possible to implement asynchronous istreams when there isn't a file descriptor that can be used to reliably receive updates.

i_stream_read(): If stream_errno is set, fail immediately. Previously the stream_errno was reset to 0, but this required the istream implementation to correctly set the stream_errno back, which wasn't often done.

Updated copyright notices to include year 2014.

istream: Added i_stream_init_parent() to lazily initialize the parent stream.

lib: Added [io]_stream_create_error_str()

iostream: Added ability to set/get error strings for streams.

istream: Improved "stream not seekable" panic message.

istream API change: Added support for multiple destroy callbacks.

i_stream_read(): Added assert.

iostreams: Added close_parent flag to close() handler and clarified close/destroy APIs. This makes it unambiguous how things work: Unless you explicitly call [io]_stream_close(), the parent streams won't be closed. This is what most (hopefully all!) of the existing code expects. I was wondering a bit if [io]_stream_destroy() should simply have been removed and replaced with [io]_stream_unref() calls, since they would have worked basically everywhere, but there might be some places where it's better to have explicitly closed the stream (and where closing the parent stream doesn't matter).

i_stream_create(): Copy stream_errno/eof immediately from the parent stream. This makes wrapper istream behavior more reliable when the original istream is an istream-error.

istream: Fail in the default stat() implementation if stream_errno is set.

i_stream_close(): Set stream_errno to EPIPE instead of ENOENT.

i_stream_create_error() should have set eof=TRUE immediately.

Oops :) Update copyrights to 2013 without breaking all .c files.