Update VERSION.

obey soft-bounce even if the reject comes from a sieve script

the session initialiser does select on dm where mailbox=$1 and modseq>$2
all the time, so we need an index or that will be dog slow on a large db

untested

continue splitting messages and mailbox_messages.

the trivia fetcher conflated the two, which led to strange failures and
race conditions, all very unusual but decidedly buggy.

as a bonus change, the injector now records that the message it caches
contains information. this makes whip happy, not sure why. but from now on
the cache may actually lead to speedups.

make the AddressCreator generally more similar to HRC.

important difference: the AC has an optimisation where it skips using a
savepoint for the first select. because of this, the caller has to look at
whether the AC is done, not just send more queries (or? hm? not sure.
maybe it would work anyway, due to the magic of subtransactions.) and the
AC may have to notify the caller itself, not rely on sub->commit().

stop saying 'select distinct ...' in the Selector. it bothered too many
callers, and I don't think it has been necessary for a while. six months
or so.

update callers.

tweak the Transaction logic in Fetcher so it'll use a Transaction only
when really needed or told to, and lock the messages so a big query won't
accidentally collide with an expunge.

addresscreator must go back to selecting addresses if the copy fails.

also initialise a variable that accidentally wasn't.

don't send the notify if we only did select, not copy.

don't send it even if we do select/copy/rollback/select/release.

if a session update makes a command able to proceed, then let it.

no point in blocking the flag-update fetch, it'll be set to executing
again in a moment anyway.

add a debug message which we ought to remove again in a few releases, when
it's clear whether slow DNS resolution is why aox sometimes starts slowly.

better error message.

there were too many questions about the previous message, so we'd better
make some effort to give a more helpful message. the previous one didn't
give people enough information to report the bug well, hopefully this one
will.

minor optimisation: avoid sending a query that almost always is a no-op

make the fetcher use a transaction if it is to fetch dynamic data, to be
sure that the reported modseq is in sync with the other queries. (I'm not
sure this is sufficient, but I also don't care greatly.)

allow setters to provide a transaction, of which the fetcher will use a
subtransaction (so the fetcher gets exclusive use of the transaction for a
little while).

use the new setter for flag-update fetches, so noone will be able to sneak
in and expunge the message after fetch has found it, but before the
fetcher has retrieved data.

don't ask for the current rows while we're trying to add new rows.  it
might be safe, but we might want to roll back the COPY, and we don't know
that yet.

also use Transaction::restart(). I thought I'd submitted this, but not.

tell jam where schema.pg is IN THE RIGHT FORMAT

add new function Transaction::restart(), to roll back and restart a
subtransaction.

use it in the callers that expected rollback() to do this.

actually startup wipes out the mailbox tree too (sort of), so use the same
mechanism to make sure SASL authenticaiton will wait until the server has
started up.

make refreshing() return true only if mailboxes might disappear.

refreshing() should now return false always during normal operation, which
fixes a serious race between append and login. Login would never complete.

q-p lines that start with "--" or "From "

If a string includes a line starting with From, but there's no other
reason to q-p it, then we don't q-p it.

no need to tell the owner that we've been able to begin

if the HRC failed completely and can't go either forwards or backwards, it
has to release its subtransaction by calling ->commit().

calling the parent transaction's notify() isn't necessary, Transaction
does it itself when the parent can go on.

1. make Transaction::subTransaction() just return an object, without
   locking the parent. makes it possible to create lots of subtransactions
   and use them one by one, as Injector does via HRC.

2. lock the parent when control passes to the subtransaction instead. the
   trampoline releases the parent when control passes back.

3. make Transaction::execute() do nothing when the object is blocked.
   Injector accidentally called it.

Avoid enqueueing into the blocked parent transaction.

Use this->id() when making a SELECT/COPY in any HelperRowCreator.

Fix typo.

edit the Received: format to avoid triggering SA's RCVD_NUMERIC_whatever
rule.

http://archives.oryx.com/archives/mailstore-users/2197/thread

log authenticated used in the Received line.

log the address rather than login just in case someone feels the urge to
try password guessing with the login.

Convert HelperRowCreator to use subtransactions.

Needs a careful once-over.

Make the injector ask the *creators for newly-created ids.

Fetch newly-created ids from the HelperRowCreator.

Get rid of the bogus rollback() functions in Flag etc.

We'll depend on real transaction semantics instead, with
no risk of races.

Signed-off-by: Abhijit Menon-Sen <ams@oryx.com>

Make the HelperRowCreator(s) remember the names they create.

1. add() and id() methods for HelperRowCreator.
2. processSelect() just calls add on the creator itself.

Delete unneeded d class.

make SURE we use only asfd@as.df as mail from... shouldn't matter, the
address we use as sender ought never to have a display-name. but it's
better to be sure.

help imaptest with RFC 5256, where a SORT extension makes demands on what
APPEND should do with nonconformant data.

add a specific Message::parse() command and use it for parsing messages
instead of a constructor.

callers that wished to pass a specific parent now have to call
setParent(). there is one such caller.

the next change will make IMAP APPEND take advantage of this.

Convert insertBodyparts() to use subtransactions.

Makes d->ignoreError go away. Good.

Convert AddressCreator to use subtransactions.

do lsub correctly. 2.12 fodder, (assuming that anyone ever cares about odd
lsub behaviour).

a message without a subject should have an empty base-subject, not none

if there is no read-write session where we might advertise \recent, then
advertise it in a read-only session. 3501 doesn't demand this, but an
example suggests it and imaptest likes it.

there are unspecified areas concerning \recent when messages are appended
to multiselected mailboxes. aox does what comes easiest.

Use a trampoline to detect the end of a subtransaction.

make sure the EXPUNGE responses are sent as the last responses of the last
command where we can send them. they could be sent too early by mistake,
something imaptest ran into.

(if there isn't a last command, don't send EXPUNGE.)

sent mail to the smarthost in order of retry date.

if we're five seconds past one message's retry time and three seconds past
another's, we'll try the five-second one first. this gives us a little
more flexibility if the smarthost doesn't want to accept one message and
spends a long time. the bad message will get a new retry date and other
messages will then be tried first during the next run.

change Message::baseSubject() to use the algorithm in the final RFC 5256.

also uses titlecase instead of lowercase.

may differ from 5256 in two ways:
- 5256 doesn't define space, we use all unicode space characters
- 5256 doesn't say whether "Subject: " is the same as no subject field
  (it's not for us)

update callers.

ideally, we should drop all contents of thread_members and threads when we
upgrade to 3.0.1 (and 2.12?) since the old and new content isn't the same
(lower case vs. titlecase, etc).

searches for 'smaller 128' didn't work when embedded within boolean logic. fix.

rework the spool manager to use only one query.

when there's only one query, there's no scope for things to get out of
sync.

also less state machinery in general. d->again is almost all there is, it
means "might want to look at the tables again, maybe one of them changed
after you sent the query".

update last_attempt on EVERY delivery attempt, not just those that produce
final resolution for that recipient

stop using deliveres.tried_at. use only dr.last_attempt instead. (tried_at
is logically required to be the maximum last_attempt for its delivery.)

move the bottleneck query from DA to SM, so SM won't create a DA which
does nothing. the SM would loop quickly creating lots of DAs for messages
which couldn't be delivered yet because an attempt had been made less than
one hour previously. massive load on the database.

demand that the server answers the TCP connection within four seconds,
but allow more time for the banner.

if the error message changes, then our state changed, and it's advisable
to notify the owner.

this is necessary to handle the case where the smarthost is down when aox
starts up.

set the log the right way and log a little more

Initial support for subtransactions.

Mostly works, but doesn't set Completed on correctly-finished
subtransactions, because the state doesn't go back to Idle,
and Postgres has no way to tell when the subtransaction's
finished for good.

Make "aox delete mailbox" really delete mailboxes sensibly.

1. Refuse to delete mailboxes containing (either existing or deleted)
   messages, and
2. Provide a -f flag to delete the messages too.

make a note about how we handle the RFC 1047 race

Don't segfault.

set an own log id, and set it properly, where EventHandler::notify() will look

smtpclient could work itself into a no-good state. fix.

there was a race. if the smarthost closed the connection JUST when a new
message was spooled for deliveries, then smtpclient would be asked to
deliver, find itself unable to, reconnect, but never actually get anything
done, there would just be a sequence of five-minute connections doing
nothing.

this fixes the race by simplifying the notification model. the owner and
user (spoolmanager and deliveryagent) are notified (newly via notify()
instead of execute() whenever the smtpclient changes state in react, no
more, no less.

don't call die() when someone sends STORE and then closes the connection

instead, throw Invariant directly, so the cleanup logic closes the
connection without involving a breakpoint on die()

the search was fubared if the sort program contained two or more entries
and size wasn't the last. fix.

the query order has changed; we need to wait on the new second query
before proceeding. otherwise we'll have an occasional segfault.

expunge could deadlock with store if one session tried to change flags on
a particular message while another tries to expunge it.

this change fixes that by locking the affected messages first in both
cases, and only then locking the mailboxes row to get a modseq.

I decided to change expunge rather than store since one of them would have
to become slower, and I'd rather slow down expunge than store.

unfuck accidentally changed 'not' logic.

we want to delete flags rows for a particular flag if there is at least
one message with that flag set in our UID range. (ie. the opposite of zero
is >=1, not all.)

constrain sender differently now that we have a better list

Don't allow the injector to see recoverable errors in helperrowcreator.

(Because it'll try to rollback the transaction, even if the last queries
enqueued by the helper would have reset the error.)

This is just a stopgap solution.

Guard Timer::notify in try/catch.

Don't dereference a pointer we just set to 0.

Wrong column name in fetch.

pattern a*b may match children of a/c.

don't send * 0 EXPUNGE.

it's not clear to me why it could happen, but it's clear to me how to
prevent such responses from being sent, and the change should have no
adverse effects on the various state machines. it can lead to a
superfluous EXISTS response, that's all.

compute MSNs only when we send the response, instead of computing
responses as soon as possible and then trickling out.

send \noselect when a client asks for the separator

sort always sorted the entire mailbox.

the search program was disregarded in 3.0.0. fix.

implement 5257 section 4.9

5257 4.9 says "if you've also done 5256, you MUST ...", but I implemented
5257 before 5256 and forgot about this when implementing 5256. oops.

messages without an annotation sort after those with. I think that's
correct but can't find any rule in either RFC now.

update for RFC 5257 *sigh*

reference the RFCs we implement

this implements RFC 5257 and more, so say so

we handle I18NLEVEL=1 (practically a no-op in our case), so advertise it.

this is a little sneaky. whether we comply or not depends on what postgres
does, but we don't check that postgres does the right thing.

when sorting by subject we need to smash to lower case

make the code handle the correct append syntax, as given by a combination
of RFC 3501, 3502, 4466, 4469 and 5258.

segfaults are such fun. not.

no need to rebuild privileges.inc when the top-level directory changes;
it depends only on schema.pg and list-privileges

simplify Granter and update callers

fix bad line wrapping

aox upgrade schema talks about what it does, so don't make an exception
for granting privileges

Don't advertise LISTEXT before authentication.

we implement 5256 as well (imap sort)

our listext is like what RFC 5258 describes

Avoid excessively long timeout.

(Submitted by accident with an earlier change.)

that _is_ an error, so log it like that

roll back a transaction if something throws Invariant while processing it

Be careful to not hold locks and die.

Cure the symptoms of the /3.0.0foo disease.

be slightly more flexible about guessing content-type:

if we have to guess, we first set a default, then try to guess something,
and if we can't guess, we don't touch the default.

authenticate can also contains passwords (base64-encoded, but still)

the code to not close listeners only caught one of the two instances. this
catches the other.

also closes the connection instead of just forgetting it.

also forgets about connections even if they're already closed.

build an actual, working query for aox tune database

this also is prettier. we like =any($x) much better than building long
boolean chains.

pg versions differ in how the indexdef is returned, so use the name more and
the defintion less

The sender's copy is delivered through the smarthost.

don't try to use tsearch2 on pg 8.1 or 8.2