Try to clear up more size_t vs int/long issues.

Fix signal handler types for win64.

Set _EVENT_SIZEOF_VOID_P correctly on win32 and win64

Fix some ints to evutil_socket_t; make tests pass on win64.

Fix som event_warns that should have been event_warnx

Merge remote branch 'trondn/master'

Check return value for ioctlsocket on win32

Fix some uses of int for socket in regress

Merge remote branch 'github/20_http_read_after_write'

Merge remote branch 'github/20_abi_breaks'

Merge remote branch 'github/20_ratelim_size'

Merge remote branch 'github/20_chain_realign'

Fix bugs in posix thread-id calculation when sizeof(pthread_t) != sizeof(long)

When pthread_t was smaller, our calculated thread IDs would include
uninitialized RAM, and so our unit tests would fail because thread_ids
would never match one another.

When pthread_t was larger and alignment was big-endian, our calculated
thread IDs would only have the most significant bytes of the
pthread_t, when in practice all the entropy is in the low-order bytes.

Found with help from Dagobert Michelsen.

Remove event-config.h from .gitignore; it moved to include/event2

Fix a minor syntax error that most compilers didn't care about

Note that 2.0.9 will break the ABI, and make changes we were postponing.

We had to turn a couple of 32-bit size arguments into 64-bit arguments
or size_t arguments (since otherwise we would have had to do it post
2.0.x-stable, and that would be worse).

Make rate-limits go up to SIZE_MAX/EV_SSIZE_MAX, not just INT32_MAX

Someday, when networks are far faster and people frequently want a
burst value greater than 2GB per tick, this will seem very forsightful
indeed.

For now, it breaks ABI, but not source.  Fixes bug 3092096.

Correct logic for realigning a chain in evbuffer_add

The old logic was both too eager to realign (it would move a whole
chain to save a byte) and too reluctant to realign (it would only
realign when data would fit into the misaligned portion, without
considering the space at the end of the chain).

The new logic matches that from evbuffer_expand_singlechain: it only
realigns a chain when not much data is to be moved, and there's a
bunch of space to be regained.

Spotted by Yan Lin.

Avoid missed-request bug when entire http request arrives before data is flushed

The trigger for starting to read the first line of a request used to
be, "When data has arrived and we're looking for the first line."
But that's not good enough: if the entire next request gets read
into our bufev->inbuf while we're still processing the current
request, we'll never see any more data arrive, and so will never
process it.

So the fix is to make sure that whenever we hit evhttp_send_done, we
call evhttp_read_cb.  We can't call it directly, though, since
evhttp_send_done is reachable from the user API, and evhttp_read_cb
can invoke user functions, and we don't want to force everyone to
have reentrant callbacks.  So, we use a deferred_cb.

Found by Ivan Andropov.  This is bug 3008344.

Correctly count req->body_size on http usage without Content-Length

There was a dumb bug where we would look at the length of the input
buffer immediately _after_ we drained it.

Fix a bug where we would read too much data in HTTP bodies or requests.

We were using evbuffer_add_buffer, which moved the entire buffer
contents.  But if we had a valid content_length, we only wanted to
move up to the amount of data remaining in ntoread.  Our bug would
make us put our ntoread in the negative, which would in turn make us
read all data until the connection closed.

Found by Denis Bilenko.  Should fix bug 2963172.

Fix Content-Length when trying send more than 100GB of data (!) on an evhttp.

add a requested docstring for event_rpcgen.CommandLine.__init__

Merge remote branch 'github/http_and_listener'

Make evbuffer_add_file take ev_off_t, not off_t

This change has no effect on non-windows platforms, since those
either define off_t to 64-bits, or allow you to decide whether
it should be 64-bits yourself via some LARGEFILE-like macro.

On Windows, however, off_t is always 32-bit, so it's a bad choice
for "file size" or "file offset" values.  Instead, I'm adding
an ev_off_t type, and using it in the one place where we used
off_t to mean "the size of a file" or "an offset into a file" in the
API.

This breaks ABI compatibility on Windows.

Functions to actually use evhttp_bound_socket with/as evconnlistener.

Add a function to change a listener's callback.

You can also now initialize listeners with no callbacks set; if so,
they won't get enabled until the callback is set to non-NULL.

Simplify the logic for choosing EPOLL_CTL_ADD vs EPOLL_CTL_MOD

Previously, we chose "ADD" whenever old_events==new_events, (since
we expected the add to fail with EEXIST), or whenever old_events
was==0, and MOD otherwise (i.e., when old_events was nonzero and not
equal to new_events).

But now that we retry failed MOD events as ADD *and* failed ADD
events as MOD, the important thing is now to try to guess right the
largest amount of the time, since guessing right means we do only
one syscall, but guessing wrong means we do two.

When old_events is 0, ADD is probably right (unless we're hitting
the dup bug, when we'll fall back).

And when old_events is set and != new_events, MOD is almost
certainly right for the same reasons as before.

But when old_events is equal to new events, then MOD will work fine
unless we closed and reopened the fd, in which case we'll have to
fall back to the ADD case.  (Redundant del/add pairs are more common
than closes for most use cases.)

This change lets us avoid calculating new_events, which ought to
save a little time in epoll.c

Fix a nasty bug related to use of dup() with epoll on Linux

Current versions of the Linux kernel don't seem to remove the struct
epitem for a given (file,fd) combo when the fd is closed unless the
file itself is also completely closed.  This means that if you do:
   fd = dup(fd_orig);
   add(fd);
   close(fd);
   dup2(fd_orig, fd);
   add(fd);
you will get an EEXIST when you should have gotten a success.  This
could cause warnings and dropped events when using dup and epoll.

The solution is pretty simple: when we get an EEXIST from
EPOLL_CTL_ADD, we retry with EPOLL_CTL_MOD.

Unit test included to demonstrate the bug.

Found due to the patient efforts of Gilad Benjamini; diagnosed with
help from Nicholas Marriott.

Merge branch 'http_uri_parse'

Unit tests for evhttp_uri_set*

Make evhttp_uri non-public, and give it accessor functions.

Document that two bufferevent functions only work on socket bufferevents

Add a bufferevent_get_base function

Update the HTTP regression tests to use Libevent2 apis for non-http stuff

Stop using Libevent-1 headers in regress_http

Merge branch 'http_small_tweaks'

Conflicts:
http-internal.h

Add evhttp_connection_get_base() to get the event_base from an http connection

Based on a patch by Mark Ellzey from 27 July 2010.

Closes ticket 3052406

Fix a 100%-CPU bug where an SSL connection would sometimes never stop trying to write

If an SSL connection becamse disabled or suspended before became open,
it could (under the right circumstances) wind up without ever getting
its write callback disabled.

The most correct fix is probably more subtle, and involves checking
all caseswhen a write callback is enabled or disabled.  This fix is
more blunt, and explicitly checks whether the callback should have
been disabled at the end of the callback to prevent infinite looping.

Diagnosed with help from Sebastian Hahn

Add evhttp_parse_query_str to be used with evhttp_uri_parse.

The old evhttp_parse_query() doesn't work well with struct
evhttp_uri.query, since it expects to get whole URIs, rather than
just the query portion.

Document behavior of URI parsing more thoroughly.

Also, move evhttp_uri struct into http.h, since it is part of the API.

Add a huge pile of tests for the new URI functions, and make them pass.

Improvements to tinytest_macros.h

First, handle cases where we have %s in a tt_want or tt_assert.

Second, add tt_want_*_op that do a tt_*_op test, but do not exit the
test on failure.

We should push these upstream to tinytest some time.

Revise evhttp_uri_parse implementation to handle more of RFC3986

Clean up error handling in uri_parse a little

Do not silently truncate URIs in evhttp_uri_join. Also avoid evbuffer_pullup.

Make evhttp_uri_parse and friends conform to memory management standards

Introduce absolute URI parsing helpers.

See evhttp_uri_parse(), evhttp_uri_free() and evhttp_uri_join() for details.

Merge branch 'http_parse'

Add evhttp_request_get_command so code can tell GET from POST without peeking at the struct.

Modernize header usage in bench_http.c

Increment version in git to 2.0.8-rc-dev

Increment the version to 2.0.8-rc

NOTE: This is not the official release until I tag it.  If you see
    this commit, and you decide that Libevent 2.0.8-rc is now
    finalized, you might get something besides 2.0.8-rc.

Changelog and readme for 2.0.8-rc

Fixes for MSVC compilation

Make the --enable-gcc-warnings option include signed comparison warnings

Fix signed/unsigned warnings on win32

Fix signed/unsigned warnings on opensolaris, where iov_len is signed

Fix -Wsigned-compare warnings in test/*

add limits.h to event_tagging.c so opensolaris will build

fix a signed/unsigned warning in kqueue.c

New unit test for ssl bufferevents starting with connected SSLs.

Fix a case where an ssl bufferevent with CLOSE_ON_FREE didn't close its fd

This could happen when we got an SSL with a BIO already set on it.

Avoid spurious reads from just-created open openssl bufferevents

When handshaking, we listen for reads or writes from the
transport. But when we're connected, we start out with writes enabled
and reads disabled, which means we should not have the transport read
for us.

The corrected bufferevent filter semantics let us fix our openssl tests

Correct logic on disabling underlying bufferevents when disabling a filter

Previously, whenever writing was disabled on a bufferevent_filter (or
a filtering SSL bufferevent), we would stop writing on the underlying
bufferevent.  This would make for trouble, though, since if you
implemented common patterns like "stop writing once data X has been
flushed", your bufferevent filter would disable the underlying
bufferevent after the data was flushed to the underlying bufferevent,
but before actually having it written to the network.

Now, we have filters leave their underlying bufferevents enabled for
reading and writing for reading and writing immediately.  They are not
disabled, unless the user wants to disable them, which is now allowed.
To handle the case where we want to choke reading on the underlying
bufferevent because the filter no longer wants to read, we use
bufferevent_suspend_read().  This is analogous to the way that we use
bufferevent_suspend_write() to suspend writing on a filtering
bufferevent when the underlying bufferevent's output buffer has hit
its high watermark.

Fix serious bugs in per-bufferevent rate-limiting code

Our old code was too zealous about deleting the refill events that
would actually make connections able to read or write again after
they had run out of bandwidth.  Under some circumstances, this could
cause a bufferevent to never actually refill one of its
rate-limiting buckets.

Also, the code treated setting a per-connection rate-limit on a
connection that already had a group-limit as if it were changing the
limit on a connection whose allocation had already run out.

This patch fixes both of those problems.

Handle rate-limiting for reading on OpenSSL bufferevents correctly.

We were looking at the number of bytes read on the wbio, not in the
rbio.  But these are usually different BIOs, and the reading is
supposed to happen on the rbio.

Merge branch '20_internal_prio'

New evhttp_uri(encode|decode) functions to handle + and NUL characters right

The old evhttp_decode_uri() function would act as tough it was doing
an (illegal, undefined) decode operation on a whole URL at once, and
treat + characters following a ? as different from + characters
preceding one.  But that's not useful: If you are decoding a URI
before splitting off query parameters, you are begging to fail as soon
as somebody gives you a value with an encoded & in it.

The new evhttp_uridecode() function takes an argument that says
whether to decode + signs.  Both uridecode and uriencode also now
support encoding or decoding to strings with internal 0-valued
characters.

evhttp_encode_uri encodes all reserved characters, including !$'()*+,/:=@

Perviously, some characters not listed as "unreserved" by RFC 3986
(notably "!$'()*+,/:=@") were not encoded by evhttp_encode_uri.  This
made trouble, especially when encoding path components (where @ and /
are bad news) and parameters (where + should get encoded so it doesn't
later decode into a space).

Spotted by Bas Verhoeven.

Merge branch 'iovmax'

Turn some booleans in evconnlistener_iocp into one-bit bitfields.

Make iocp/listener/error work; don't accept again if lev is disabled.

Fix allocation error for IOCP listeners. Probably harmless, since struct event is big

Add a LEV_OPT_THREADSAFE option for threadsafe evconnlisteners

Tweak evhttp_parse_query hack to avoid breaking abi

Let evhttp_parse_query return -1 on failure

We already detected certain malformed queries, but we responded by
aborting the query-parsing process half-way through without telling
the user.  Now, if query-parsing fails, no headers are returned, and
evhttp_parse_query returns -1.

Fix an EINVAL on evbuffer_write_iovec on OpenSolaris.

The writev() call is limited to at most IOV_MAX iovecs (or UIO_MAXIOV,
depending on whom you ask).  This isn't a problem anywhere we've
tested except on OpenSolaris, where IOV_MAX was a mere 16.

This patch makes us go from "use up to 128 iovecs when writing" to
"use up to 128 iovecs when writing, or IOV_MAX/UIO_MAXIOV, whichever
is less".  This is still wrong if you somehow find a platform that
defines IOV_MAX < UIO_MAXIOV, but I hereby claim that such a platform
is too stupid to worry about for now.

Found by Michael Herf.

Fix warnings on mingw with gcc 4.5

Define symbolic constants to use in place of SHUT_RD etc

Send a shutdown(SHUT_WR) before closing an http connection

This avoids getting an ECONNRESET from the TCP stack.

Fixes bug 2928690

Fix a spurious-call bug on epoll.c

We were trying to check whether any events had really been
notified on an fd before calling evmap_io_active on it, but instead
we were checking for an event pointer, which was always true.

In practice, this patch shouldn't change much, since epoll_wait
shouldn't return an event unless there is actually an event going
on.

Spotted by an anonymous bug reporter on Sourceforge.  Closes bug
3078425.

Merge remote branch 'github/signed_compare'

Merge remote branch 'github/win_lib'

Do not search outside of the system directory for windows DLLs

Hardens against some attacks.

Fix compile in kqueue.c

Commit 38d09606 removed the evsigbase pointer, but forgot to remove
an assignment to it in kqueue.c.

Fix all warnings in the main codebase flagged by -Wsigned-compare

Remember, the code
   int is_less_than(int a, unsigned b) {
      return a < b;
   }
is buggy, since the C integer promotion rules basically turn it into
   int is_less_than(int a, unsigned b) {
      return ((unsigned)a) < b;
   }
and we really want something closer to
   int is_less_than(int a, unsigned b) {
      return a < 0 || ((unsigned)a) < b;
   }
.

Suggested by an example from Ralph Castain

Unit tests for listener error callbacks

Add error callback to evconnlistener

Make event.c debugging messages report fds

Make debugging output for epoll backend more comprehensive

Put internal events at highest priority

(If we allow user events to starve internal events, then internal events
never actually happen, signals don't get acked, etc)

Remove event_base.evsigbase; nothing used it.

Remove the now-useless evsig_caught and evsig_process

Make default signal backend fully threadsafe

Jason Toffaletti discovered with helgrind that our signal handler was
messing with evsig_base, which can be set from lots of places in the
code.  Ordinarly, we'd just stick a lock on it, except that it is
illegal (and genuinely error-prone) to call pthread_mutex_acquire()
from inside a signal handler.

The solution is to only store the fd we write to in a static variable,
write the signal number to the fd, and put evsig_cb in charge of
activating signal events.

I have no idea how we'll cope if we want to enable this to handle
siginfo (where available) in the future.

Warn when using the error-prone EV_SIGNAL interface in an error-prone way.  Also, fix a couple of race conditions in signal.c

When using the signal.c signal backend, Libevent currently only allows
one event_base to actually receive signals at a time.  (This has been
the behavior since at least 1.4 and probably much earlier.)  Now, we
detect and warn if you're likely to be racing about which signal goes
to which thread.

We also add a lock to control modifications of the evsig_base field,
to avoid race conditions like those found by Jason Toffaletti.

Also, more comments.  Comments are good.

Obey enabled status when unsuspending

Bump to the latest version of tinytest

This lets us do without libevent-specific code in tinytest.c, and
lets us add a feature to skip individual tests from the command
line.

Make SSL tests cover enabling/disabling EV_READ.

I want my 80% coverage.