lib: ostream: 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: Add o_stream_abort()

lib: Add o_stream_get_last_write_time()

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

lib: Add o_stream_set_finish_also_parent() and _finish_via_child() These allow controlling on both directions whether o_stream_finish() should be finishing the parent stream. If either one is set to FALSE, the parent stream isn't finished. Which one of these to use depends on the situation.

global: Use o_stream_flush_parent()

lib: Add o_stream_flush_parent()

lib: Automatically flush ostream when it's closed Also verify that it unexpectedly didn't get fully flushed.

lib: Add o_stream_finish() This marks the ostream as fully finished, with no further writes coming to it. Otherwise it behaves like o_stream_flush(). The ostream.flush() methods are supposed to write their trailer (if the ostream has one) when they see that ostream.finished is set. These will be implemented by the following commits.

lib: o_stream_flush() - check for send overflows and reset error handling This begins the removal of o_stream_nfinish().

lib: Remove o_stream_nflush() None of its previous callers were calling it correctly, so it's better to remove it entirely to avoid more of such wrong calls.

lib: o_stream_uncork() - call o_stream_nflush() instead of o_stream_flush() Otherwise flush errors may be unintentionally ignored. This change requires that all the o_stream_uncork() callers must call o_stream_nfinish() afterwards, unless the ostream is set to ignore errors.

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

o_stream_send_istream() API changed again The new API enforces the caller to correctly handle all the possible situations. It also makes in unambiguous whether to wait for input or output stream.

global: Simplify code with the new o_stream_send_istream() API

lib: Added o_stream_nsend_istream()

lib: Simplified and clarified o_stream_send_istream() API

lib: Added ostream.blocking boolean Similar to istream.blocking.

lib: Don't silently ignore partial writes for o_stream_nsend() Normally o_stream_nsend() should be used only for blocking streams or streams with infinite (or "enough") buffer space.

lib: Removed ostream.last_failed_errno It's been identical to ostream.stream_errno for a while now.

lib: istream - migrate to i_stream_read_more() Scripted to find all the low-hanging-fruit (single line calls), but hand-checked: git grep i_stream_read_data.*,\ 0\) | sed s/:.*// | \ xargs sed -i -e 's/i_stream_read_data(\(.*\), \(.*\), \(.*\), 0)/i_stream_read_more(\1, \2, \3)/' Signed-off-by: Phil Carmody <phil@dovecot.fi>

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.

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: Added o_stream_create_passthrough() for creating simple wrapper ostreams

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: ostream.stream_errno is now exactly the same as last_failed_errno. There's a lot of code that checks only for stream_errno instead of last_failed_errno at the flush time where the stream_errno might have already been cleared. I'm not sure why these were separated in the first place. I don't think there are any stream errors which just correctly go away by retrying the operation. Perhaps some code could have attempted seeking and try to handle the ESPIPE error, but that kind of code paths are rare and they could clear the errors themselves if needed.

lib: Make sure ostream.last_failed_errno is always set when stream_errno is set.

lib: o_stream_uncork() could also cause write errors. Make sure last_failed_errno is updated. This caused some write errors not to be detected, such as in code like: o_stream_cork() o_stream_nsend(..) o_stream_uncork() if (o_stream_nfinish() < 0) { // error not detected because last_failed_errno was 0 }

lib: Fixed assert-crash in o_stream_send_istream() if input stream was the one that failed.

lib: o_stream_send_istream() should return -1 if there was an error reading input stream.

lib: io_stream_copy() no longer attempts to read full block sizes from input. Although that may be more efficient for writing (to files), it causes unnecessary work for the input stream. The writing part should also be optimized anyway if the caller corks the output stream.

lib: Added o_stream_flush_parent_if_needed() for wrapper ostreams.

lib: Added o_stream_is_corked().

Added o_stream_get_max_buffer_size()

Updated copyright notices to include year 2014.

ostream: Don't mark the stream closed too early after all. Use another flag instead to avoid losing the last data written to the stream before closing.

ostream: Mark stream closed before handling its callback to avoid infinite loops. The callback could call o_stream_copy_error_from_parent(), which in turn would try to close the same ostream again.

liblib: If parent ostream closes itself on error, close our ostream as well. This avoids a situation where ostream is basically unusable with last_failed_errno set, but it's not marked as closed. The current code often checks ostream->closed but doesn't check last_failed_errno. ostream-file also autocloses the stream, but filter ostreams without this patch don't autoclose, so this caused problems with e.g. IMAP COMPRESSION extension where the zlib-ostream didn't get marked as closed, although the problem was only logging "BUG: Unknown internal error" instead of "Disconnected" as the client's disconnect reason.

lib: Added [io]_stream_create_error_str()

ostream-errno: last_failed_errno wasn't set, causing problems with some functions.

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

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).

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

Updated copyright notices to include year 2013.