Glibc's headers are not as promiscuous about including each other as
OSX's are.  Also, apparently there exist at least two incompatible
definitions of 'struct tcphdr'.  Down, not across.

The fix involves two complementary changes: (1) restore the upper
limit of 64 outstanding downstream connections per circuit; (2) HTTP
steg needs to call ->cease_transmission() and ->expect_close() on its
connections at the right times (for now, unconditionally; in the
future, paying attention to the HTTP "Connection:" header).

 * src/pgen_fake.cc: New file.
 * Makefile.am: Build it.  Integrate it with 'make check'.

 * src/compression.cc: Distinguish an inflate failure due to inadequate
   output buffer space from other causes.
 * src/steg/swfSteg.cc: Enlarge the inflate output buffer as necessary.

 * src/pgen.h: Make internal padding in pentry_header explicit.
 * src/steg/payloads.cc: Remove overly chatty log_debug messages which
   were causing test_tl to deadlock.

 * pgen.h, pgen_pcap.cc: New files.
 * util.cc: Split libevent-using routines to util-net.cc.
 * configure.ac: Detect availability of libpcap.
 * Makefile.am: Build pgen_pcap if we have libpcap.  Shuffle linkage
   variables around a little so each program is only linked against the
   libraries it needs.

 * Use quadrigraphs for "rm -f conft[ABC].o" in ranlib.m4 so they actually
   get deleted.
 * Stop using EXTRA_*_DEPENDENCIES which autoconf 1.11 doesn't support.
 * Make the spacing of the silent-mode custom printouts match autoconf 1.12
   (purely cosmetic).

Up till now, when we were done writing to a downstream socket, we
would use shutdown() to send a TCP FIN immediately, even if there
might be data still to be _read_ from that socket.  This turns out to
be unreliable: on the far side, the FIN may cause libevent to signal
read EOF before we are completely done reading data from the network,
causing block loss.  (This is arguably a bug in libevent, but
shutdown() on socket bufferevents is not officially supported at
present, so we need to fix it on our side.)  Also, we have reason to
believe none of our intended cover protocols normally leave sockets
half-closed for any significant length of time, so this might be a
'tell.'  And it has been observed to confuse middleboxes to the point
where they won't pass our traffic at all.

Instead, on the receive side, take note of a half-closed connection if
the cover protocol provides an in-band indication of that fact
(e.g. 'Connection: close' in HTTP) (i.e. conn_t::expect_close() now
does something) but do not call shutdown() on the transmit side.

This exposes a race condition in connection-to-circuit association
which could cause a spurious fatal assertion, and allows us to
simplify the 'should we open new downstream connections?' logic
substantially.

We still half-close our *upstream* sockets when we're done writing to
them.  That should probably change too, but that may require changes
to tltester.

All of the header formatting code and the reassembly queue move to their
own file.  Some of the low-level transmission and reception code may follow.
This will make it easier to add new types of control blocks (for retransmit,
in-band connection close, the long-awaited rekeying and handshake logic, etc)
and will also make it possible to unit test the separated code.