s/11/10/

Merge branch 'master' of ssh://strange/home/git/aox

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

speling

pg 8.1 does not have xact_start

Update release date

accept subaddresses properly even with the magic separator

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

make check-sender-address remove/change bad addresses

telling smtp/submit clients "no" is not good; they generally can't fix
whatever is wrong, so we're better off doing our best on their behalf.

this change removes any bad addresses in from/resent-fron/return-path, and
if nothing's left, inserts uses the authenticated user's own address. the
old code would tell the smtp client "no, go fix it".

that was dead code, really: the maximum needed always overrode

so kill it

just prettier logging

handlesNeeded didn't shrink nicely. make it do so.

minimum and maximum were broken for timespans starting after max

and describe

add the keywords from RFC 3848 to the Received

reveal even less about logged-in users

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

if the transaction is rolled back, we have to say NO...

fix transaction idleness timeout

the old code was called only if !usable(), and a transaction can be usable
even if its last query was in a transaction. this code is called anyway.

also, change the timeout so that a transaction can be Failed for only five
seconds, idle for up to 20. after 5 (or 20) seconds of complete inaction
it loses its database handle, boom.

udoc fix

we can't send rollback if we've SENT commit.

the previous test waited until commit was completely processed by the
server.

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

don't drop queued queries when we rollback()

it's just an optimisation and it shows up in a puzzling log excerpt. let's
just send them, have the server process them, and process the rollback.
simpler state machine.

make sure there always is a date on the autoreply

kill invalid errors-to and remove unnecessary ones

I typoed while splitting the previous commit in two. fix.

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

sending vacation notices to postmaster? no...

Errors-To is used only for robot/list mail (says my archive)

magic

select() returns 0, so taken teh hint

cleanliness, in an attempt to kill possible select() loops

- only ever read() when we select()
- ask select() for read-ability if we will read
- base all decisions on select(), none on errno

I'm not sure there was a loop in this select. all I know is that there was
a loop involving high load, and this loop seemed like a likely suspect.

check whether to go away regularly, not just once

clean up the addresses table only on explicit request (-a)

this lessens the risk of colliding with pg_dump greatly

rollback ALL transactions in case of an IMAP error

this is significant, because an IMAP client causes an error if it closes
the connection abruptly. any active transactions will be rolled back at
that point.

active commands have caused too much pain and too many crashes

if a command has a session when it starts executing, use that all the time

basically wording

try to lock who holds locks if we need them and can't get them in 20s

Closing means: we want to write, then close

if we don't have to write, we'll select for the ability anyway,
so we'll close at once when that's suitable

make logout close the connection after one second

not much more, and not much less either. and don't bother trying to defeat
NAT before logon.

try a little harder to close

nothing much. read the next diff instead.

comment

that line made aox restart barf too much

simplify the code

ask select for 'read' always, always, always, so we won't loop, loop, loop.

and just in case we loop, use a .2-second timeout.

type

if all clients go away sooner than three hours, so can the server

gentle shutdown/restart.

aox restart makes the server stop listening at once, but allows existing
connections to function for up to three more hours. ten seconds before the
time is up, the db handles are closed, so no more work is possible (e.g.
imap commands will be accepted, but not processed).

get rid of Query::allowSlowness() entirely

we weren't using it

its disappearance simplifies Postgres

allow transactions to be slow

warn, but don't abort them

aborting suffered from (what seems to be) load- or pgdump-related
timeouts, it seems better to just press on

slow standalone queries will still time out, which is probably the right
thing, since we may have timing requirements acting as a server

a little more debugging

remove all errno references from Buffer

detect that the client went away ONLY in EventLoop; there was enough
code there already, so the code in Buffer was superfluous

adapt EventLoop, Connection and others to the smaller Buffer API

This is really 92.

fix obviously bad logic

that timeout might be misunderstood

the fetcher's queries can be slow. cope.

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

we have to keep the transaction open

we may need to create subtransactions, so don't commit until we've
done all of that

better code

get rid of Re: in the subject of autoresponses

send supplemental LISTENs... but not necessarily at once

in practice I don't think we have supplemental LISTENs. but if we do, then
we need to send them after choosing a listener. this code ensures that the
next time we try to use the listener, we'll send the additional LISTEN.

forgot to commit

obscenity

forgot to commit

remove a line of dead code

log it when we start work on a transaction

this is debug logging and I'm curious to see whether it will appear
for the LISTENs

the server shouldn't shut down just because this transaction times out

so test for whether this _is_ the startup, not for being in a transaction

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

random simplification

unnecessary complexity often hides bugs

pick a better log ID for the new connection, if possible

Remove redundant backend number in messages

make move work

imap move. untested

try harder to avoid creating new db handles

create 3 connections at startup, and don't segfault if pg closes all

count db handles only when they've managed to log in.

as of this change, handlesNeeded() < handles->count() will no longer
consider handles that are in the process of connecting.

if connecting is really slow, we should still obey db-handle-interval

the removed code made us be slower still, which seems unwarranted

do not try to reissue queries when pg shuts down

it happens too seldom to test well, and is too difficult to get right

that code was too seldom-run and might be broken

pick a range, not 1024 random rows above a given ID

that debug logging is not needed

Transaction::commit() on a failed transaction leaves state

this is unfortunate. however, much code expects that done() && failed(),
so this is the best I can do.

no, done() cannot return false for failed, too much code breaks

a transaction isn't done merely because it's in a failed state

rollback() or restart() can be used to progress, and the postgresql server
know that.

try harder to get rid of idle transactions

also don't provoke misleading logging by calling rollback() on
transactions that are idle because they're done.

do not offer authentication for lmtp

use 117 seconds instead of 64 for the NAT defeater

117 is a little less than two minutes. NAT boxes that time out after less
than two minutes are just too broken to care about.

do not send a quick OK after IDLE, some clients quit idle mode

get rid of unnecessary Connection::write() calls

they SHOULD be unnecessary. if they're needed, there's a bug in EventLoop,
so we need to fix that, not scatter these across the code.

why didn't I comment this when I write it? I suck.

improve db timeout logic

the old logic was based on extendTimeout(), and would start with a
ten-second timeout and then add the db-handle-inteval to the timeout every
time it sent a query. that is, query number 5 would get 5*timeout+10
seconds to finish, minus whatever the first four needed (usually a second
or less in total).

this logic:
 - a query that canBeSlow() receives db-handle-interval, but at least 60
   seconds
 - other queries receive db-handle-interval, but at most 10 seconds
 - if a transaction is idle, not progressing, and we're using most/all
   handles, we roll that transaction back after 20 seconds idleness

submit-copy-to-sender even for vacation mail

some people know c++, others do not

tweak f=f heuristic

prettier autoresponses

segfault in case of managesieve with some errors

Merge branch 'master' of ssh://strange.aox.org/home/git/aox

try to cancel SEARCH-related queries, and only those, in case the client
goes away abruptly.

just get rid of Database::cancelQueries()

it doesn't do that much, and smells a little strange. I've looked
wonderingly at it too many times now.

Warn about use-{http,webmail,web-archive}=true