Stop accepting connections after close.

The server it will not accept new connections after `Server.close` is
called in accordance with the `net.Server` API.

Added `.js` suffix to test file names.

Implemented assignment of `connect` event callback if one is provided to
`Socket.connect`.

Removed Node.js 0.6 from `.travis.yml` and Travis CI builds.

Updated change log in `README.md`.

Closes #18.
Closes #19.
Closes #20.
Closes #22.
Merge branch `close` into `master`.
Send single data packet.

Created a minimal send only client socket that can send a single packet
to a server. Created an integer server to test the client socket. The
integer server accepts a single integer, prints it to standard out, adn
closes the connection.

Gathered the C++ example programs into separate directories so I could
reuse the names `client` and `server` for each pair, and the directory
name to describe the program's operation.

Implemented a binary heap. Has strange premonition of admonishments over
the use of socket object properties in the heap implementations. It may
offend the sensibilities of certain delicate souls because it uses a
property in the object that it stores to store a bit of its
implementation data &mdash; the array index.

It creates an arbitrary property name to store the index and deletes the
property when the object is removed. It knows little about the stored
object, just that it is an object and not a primitive, and it has some
sense of what sort of property name will not collide with the properties
already defined in the object.

The name binary heap uses a comparator function, as you might expect of
a generalized data structure. The difference being that the heap uses a
stored object property to store its data, establishing the requirement
that the stored type must be of type object, but it does not know
anything more about the object. It defers to a comparator to define the
ordering.

There is a lot more to do to implement the senders algorithm, but that
would be a huge commits that would bury the incremental progress being
made. Now that I have a better understanding of how the protocol works,
I can better define the steps to implement it.

Closes #9.
Merge branch `send` into `master`.
Fixed failing server close test.

Fixed the failing server close test. I added the message buffer length
to the recieved packet handler function binding in anticipation of light
versus full acks. Adding a parameter to the binding was a surprise to
the handshake callback.

Closes #25.
Merge branch `receive-binding` into `master`.
Implement light acknowledgement.

Implement the acknowledgement acknowledgement in response to an
acknowledgement. This works for a single packet. The `client.js` program
correctly connects to the C++ implementation of the integer server,
sends and integer, and acknowledges the server's acknowledgement of
packet receipt.

Added an optional five second sleep to the integer server's response
thread between the socket read and the socket close to give the socket a
chance to preform the acknowledgement exchange before hanging up.
Without it, when the C++ implementation of the client is used, a
shutdown is sent to the client before it has a chance to send an
acknowledgement. The option is tiggered by a command line argument.

Closes #26.
Merge branch `ack` into `master`.
Wrap sequence number.

Wrap the socket's packet sequence number when it reaches the maximum
sequence number value. Track the sequences and maintain the order in
which they were sent across the wrap boundary. That is, when we receive
an acknowledgement packet, we know that acknowledging packet 2 would
mean that packet 2147483647 has also been acknowledged.

Closes #24.
Merge branch `rollover` into `master`.
Added license.

Closes #10.
Merge branch `license` into `master`.
Create `Makefile` to build UDT4 and C++ examples.

Created a `Makefile` that will download and build the UDT4 C++ reference
implementation and build it along with our C++ example programs. We're
going to use the server side of the C++ programs as part of our strategy
to ensure that we conform to the protocol, testing against the UDT4 C++
reference on the platforms where it will easily compile, ensuring
protocol parity between the C++ and JavaScript implementations.
Merge branch `makefile` into `travis-ci`.
Invoke `make` at Travis CI.
Build on Linux.

Needed to include `unistd.h` in `sdk/integer/server.cpp` for the sake of
the `sleep` function.
Merge branch `makefile` into `travis-ci`.