buffer: deprecate legacy code

Several things are now no longer necessary. These have been deprecated,
and will be removed in v0.13.

buffer: remove c-style casts

buffer: expose class methods alloc and dispose

Expose the ability for users to allocate and manually dispose data on
any object. These are user-safe versions of internal smalloc functions.

buffer: reimplement Buffer pools

While the new Buffer implementation is much faster we still have the
necessity of using Buffer pools. This is undesirable because it may
still lead to unwanted memory retention, but for the time being this is
the best solution.

Because of this re-introduction, and since there is no more SlowBuffer
type, the SlowBuffer method has been re-purposed to return a non-pooled
Buffer instance. This will be helpful for developers to store data for
indeterminate lengths of time without introducing a memory leak.

Another change to Buffer pools was that they are only allocated if the
requested chunk is < poolSize / 2. This was done because allocations are
much quicker now, and it's a better use of the pool.

buffer: use smalloc as backing data store

Memory allocations are now done through smalloc. The Buffer cc class has
been removed completely, but for backwards compatibility have left the
namespace as Buffer.

The .parent attribute is only set if the Buffer is a slice of an
allocation. Which is then set to the alloc object (not a Buffer).

The .offset attribute is now a ReadOnly set to 0, for backwards
compatibility. I'd like to remove it in the future (pre v1.0).

A few alterations have been made to how arguments are either coerced or
thrown. All primitives will now be coerced to their respective values,
and (most) all out of range index requests will throw.

The indexes that are coerced were left for backwards compatibility. For
example: Buffer slice operates more like Array slice, and coerces
instead of throwing out of range indexes. This may change in the future.

The reason for wanting to throw for out of range indexes is because
giving js access to raw memory has high potential risk. To mitigate that
it's easier to make sure the developer is always quickly alerted to the
fact that their code is attempting to access beyond memory bounds.

Because SlowBuffer will be deprecated, and simply returns a new Buffer
instance, all tests on SlowBuffer have been removed.

Heapdumps will now show usage under "smalloc" instead of "Buffer".

ParseArrayIndex was added to node_internals to support proper uint
argument checking/coercion for external array data indexes.

SlabAllocator had to be updated since handle_ no longer exists.

smalloc: add api to manually dispose Persistent

If the user knows the allocation is no longer needed then the memory can
be manually released.

Currently this will not ClearWeak the Persistent, so the callback will
still run.

If the user passed a ClearWeak callback, and then disposed the object,
the buffer callback argument will == NULL.

smalloc: initial implementation

smalloc is a simple utility for quickly allocating external memory onto
js objects. This will be used to centralize how memory is managed in
node, and will become the backer for Buffers. So in the future crypto's
SlabBuffer, stream's SlabAllocator will be removed.

Note on the js API: because no arguments are optional the order of
arguments have been placed to match their cc counterparts as closely as
possible.

doc: cleanup addons code, fix isolate positioning

isolate declaration global and above `using namespace v8`
removed BUILDING_NODE_EXTENSION and tidied up code

doc: cleanup addons docs for 80 char lines

stream_wrap: remove bogus assert

Libuv may provide a NULL buffer to the uv_read callback in case of an
error, so with this assert we'd be using the api incorrectly. None of
the current DoRead implementations rely on this constraint, either.

src: clean up `using` directives

Remove the unused ones and alphabetically sort the ones that remain.

doc: call console module 'console' not 'stdio'

The console module has always been called 'stdio' in the
table-of-contents, but nowhere else, since its name is
'console'. This makes it difficult to find.

build: fix include order for building on windows

fallout from the tls_wrap feature landing

build: add android support

Resolves minor discrepancies between android and standard POSIX systems.
In addition, some configure parameters were added, and a helper-script
for android configuration. Ideally, this script should be merged into
the standard configure script.

To build for android, source the android-configure script with an NDK
path:

    source ./android-configure ~/android-ndk-r8d

This will create an android standalone toolchain and export the
necessary environment parameters.

After that, build as normal:

    make -j8

After the build, you should now have android-compatible NodeJS binaries.

readline: strip ctrl chars for prompt width calc

Use regular expression to strip vt ansi escape codes from display when
calulating prompt display width and cursor position

Fixes #3860 and #5628.

tls: session API returns

doc: Correct TLS deprecation notices

stream_wrap: fix signed/unsigned comparison warning

cares: fix uninitialized variable warning

Suppress the following warning:

  ../../src/cares_wrap.cc: In function ‘v8::Handle<v8::Value>
  node::cares_wrap::SetServers(const v8::Arguments&)’:
  ../../src/cares_wrap.cc:1017:5: warning: ‘uv_ret.uv_err_s::code’
  may be used uninitialized in this function [-Wuninitialized]

tls: share socket._hadError with http_client

tls: introduce TLSSocket based on tls_wrap binding

Split `tls.js` into `_tls_legacy.js`, containing legacy
`createSecurePair` API, and `_tls_wrap.js` containing new code based on
`tls_wrap` binding.

Remove tests that are no longer useful/valid.

tls_wrap: embed TLS encryption into streamwrap

stream_wrap: introduce StreamWrapCallbacks

StreamWrapCallbacks is a helper class for incepting into uv_stream_t*
management process.

process: abstract out HandleToStream

Originally contributed by @tjfontaine, but modified to be faster and
more generic.

crypto: clear error on return in AddCRL

crypto: ensure that read head is always non-empty

crypto: do not deallocate embedded buffer

crypto: fix excessive buffer allocation

Allocate buffer only if the next one isn't free.

string_bytes: write strings using new API

StringBytes::Write now uses new v8 API and also does preliminary check
if the string is external, then will use external memory instead.

string_bytes: use external for large strings

When large strings are used they cause v8's GC to spend a lot more time
cleaning up. In these cases it's much faster to use external string
resources.

UTF8 strings do not use external string resources because only one and
two byte external strings are supported.

EXTERN_APEX is the value at which v8's GC overtakes performance.

The following table has the type and buffer size that use to encode the
strings as rough estimates of the percentage of performance gain from
this patch (UTF8 is missing because they cannot be externalized).

encoding  128KB    1MB    5MB
-----------------------------
ASCII       58%   208%   250%
HEX         15%    74%    86%
BASE64      11%    74%    71%
UCS2         2%   225%   398%
BINARY    2234%  1728%  2305%

BINARY is so much faster across the board because of using the new v8
WriteOneByte API.

string_bytes: implement new v8 API

v8 has a new API to write out strings to memory. This has been
implemented.

One other change of note is BINARY encoded strings have a new
implementation. This has improved performance substantially.

lint: add mising isolates and minor style fixes

test: fix up weakref.cc after v8 api change

src: upgrade after v8 api change

The prototype of v8::Persistent<T>::MakeWeak() has changed. Update the
code in src/ to follow suit.

v8: reapply floating patches

v8: upgrade to v3.19.13

crypto: free excessive memory in NodeBIO

Before this commit NodeBIO never shrank, possibly consuming a lot of
memory (depending on reader's haste).

All buffers between write_head's child and read_head should be
deallocated on read, leaving only space left in write_head and in the
next buffer.

src: unexport node_isolate

Commit 0bba5902 accidentally (or maybe erroneously) added node_isolate
to src/node.h and src/node_object_wrap.h.

Undo that, said variable is not for public consumption. Add-on authors
should use v8::Isolate::GetCurrent() instead.

I missed that while reviewing. Mea culpa.

Fixes #5639.

Merge remote-tracking branch 'ry/v0.10'

Conflicts:
ChangeLog
deps/uv/AUTHORS
deps/uv/ChangeLog
deps/uv/src/unix/linux-core.c
deps/uv/src/version.c
deps/uv/src/win/timer.c
lib/url.js
src/node_version.h
test/simple/test-url.js

net: Destroy when not readable and not writable

This is only relevant for CentOS 6.3 using kernel version 2.6.32.

On other linuxes and darwin, the `read` call gets an ECONNRESET in that
case.  On sunos, the `write` call fails with EPIPE.

However, old CentOS will occasionally send an EOF instead of a
ECONNRESET or EPIPE when the client has been destroyed abruptly.

Make sure we don't keep trying to write or read more in that case.

Fixes #5504

However, there is still the question of what libuv should do when it
gets an EOF.  Apparently in this case, it will continue trying to read,
which is almost certainly the wrong thing to do.

That should be fixed in libuv, even though this works around the issue.

Now working on v0.10.11

blog: Release v0.10.10

Merge branch 'v0.10.10-release' into v0.10

2013.06.04, Version 0.10.10 (Stable)

* uv: Upgrade to 0.10.10

* npm: Upgrade to 1.2.25

* url: Properly parse certain oddly formed urls (isaacs)

* stream: unshift('') is a noop (isaacs)

uv: Upgrade to 0.10.10

url: remove unused global variable

npm: Upgrade to 1.2.25

doc: ChangeLog update for v0.8.24

blog: 0.8 is maintenace, not stable

blog: Release v0.8.24

blog: Release v0.10.9

src: replace ngx-queue.h with queue.h

No functional changes, just one less entry in the LICENSE file.

src: wrap macros in `do {...} while (0)`

Wrapped two macros in do {...} while (0) blocks and lined up
backslashes.  Uses up semicolon in contexts where a dangling semicolon
is erroneous.

url: Set href to null by default

url: Properly parse certain oddly formed urls

In cases where there are multiple @-chars in a url, Node currently
parses the hostname and auth sections differently than web browsers.

This part of the bug is serious, and should be landed in v0.10, and
also ported to v0.8, and releases made as soon as possible.

The less serious issue is that there are many other sorts of malformed
urls which Node either accepts when it should reject, or interprets
differently than web browsers.  For example, `http://a.com*foo` is
interpreted by Node like `http://a.com/*foo` when web browsers treat
this as `http://a.com%3Bfoo/`.

In general, *only* the `hostEndingChars` should be the characters that
delimit the host portion of the URL.  Most of the current `nonHostChars`
that appear in the hostname should be escaped, but some of them (such as
`;` and `%` when it does not introduce a hex pair) should raise an
error.

We need to have a broader discussion about whether it's best to throw in
these cases, and potentially break extant programs, or return an object
that has every field set to `null` so that any attempt to read the
hostname/auth/etc. will appear to be empty.

stream: unshift('') is a noop

In some cases, the http CONNECT/Upgrade API is unshifting an empty
bodyHead buffer onto the socket.

Normally, stream.unshift(chunk) does not set state.reading=false.
However, this check was not being done for the case when the chunk was
empty (either `''` or `Buffer(0)`), and as a result, it was causing the
socket to think that a read had completed, and to stop providing data.

This bug is not limited to http or web sockets, but rather would affect
any parser that unshifts data back onto the source stream without being
very careful to never unshift an empty chunk.  Since the intent of
unshift is to *not* change the state.reading property, this is a bug.

Fixes #5557
Fixes LearnBoost/socket.io#1242

Merge remote-tracking branch 'ry/v0.10'

Conflicts:
ChangeLog
src/node_version.h

process: use Tock for nextTickQueue items

v8 plays very well with constructed objects, so we're using one in the
nextTickQueue.

src: remove old comment code

Now that maxTickDepth no longer exists there's no depth index on
infoBox. Forgot to remove the comment about this.

process: remove spinner

Remove the need to call start/stop the uv_idle spinner between
MakeCallbacks. The one place where the tick processor needs to be kicked
is where a user catches uncaughtException. For that we'll now use
setImmediate, which accomplishes the same task.

Now working on v0.10.10

Merge branch 'v0.10.9-release' into v0.10

2013.05.30, Version 0.10.9 (Stable)

* npm: Upgrade to 1.2.24

* uv: Upgrade to v0.10.9

* repl: fix JSON.parse error check (Brian White)

* tls: proper .destroySoon (Fedor Indutny)

* tls: invoke write cb only after opposite read end (Fedor Indutny)

* tls: ignore .shutdown() syscall error (Fedor Indutny)

npm: Upgrade to 1.2.24

process: remove max tick check for domains

maxTickDepth checks have been removed for domains and replaced with a
flag that checks if the last callback threw. If it did then execution of
the remaining tickQueue is deferred to the spinner.

This is to prevent domains from entering a continuous loop when an error
callback also throws an error.

process: remove maxTickDepth from _tickCallback

Removes the check for maxTickDepth for non-domain callbacks. So a user
can starve I/O by setting a recursive nextTick.

The domain case is more complex and will be addressed in another commit.

process: relocate needSpinner calls

It's only necessary to request the spinner once tickDone has been
called, and not on every nextTick.

vm: fix race condition in watchdog cleanup

Previous code was calling uv_loop_delete() directly on a running loop,
which led to race condition aborts/segfaults within libuv.  This change
changes the watchdog thread to call uv_run() with UV_RUN_ONCE so that
the call exits after either the timer times out or uv_async_send() is
called from the main thread in Watchdog::Destroy().  The timer/async
handles are then closed and uv_run() with UV_RUN_DEFAULT is called so
that libuv has a chance to cleanup before the thread exits.  The main
thread meanwhile calls uv_thread_join() and then uv_loop_delete() to
complete the cleanup.

doc: remove `bufferSize` option

`bufferSize` option has been removed in b0f6789.

events: define properties on prototype

Speeds up EventEmitter object construction by about 15-20%.

repl: fix JSON.parse error check

Before this, entering something like:

> JSON.parse('066');

resulted in the "..." prompt instead of displaying the expected
"SyntaxError: Unexpected number"

buffer: return `this` in fill() for chainability

tls: proper .destroySoon

1. Emit `sslOutEnd` only when `_internallyPendingBytes() === 0`.
2. Read before checking `._halfRead`, otherwise we'll see only previous
   value, and will invoke `._write` callback improperly.
3. Wait for both `end` and `finish` events in `.destroySoon`.
4. Unpipe encrypted stream from socket to prevent write after destroy.

uv: upgrade to v0.11.4

buffer: guard against integer overflow

buffer: simplify ReadFloatGeneric offset checks

os: use IsBigEndian() in GetEndianness() function

buffer: guard against pointer aliasing issues

src: add endianness helper functions

src: simplify HandleWrap initialization

src: replace c-style casts with c++-style casts

Merge remote-tracking branch 'origin/v0.10'

Conflicts:
deps/uv/ChangeLog
deps/uv/src/unix/stream.c
deps/uv/src/version.c
lib/tls.js

doc: sending dgram handles only works on unix

https: Add `secureProtocol` docs

Add `secureProtocol` parameter docs to the https.request method.

tls: Add `secureProtocol` docs

Add `secureProtocol` parameter docs to the tls.connect method.

uv: Upgrade to v0.10.9

tls: invoke write cb only after opposite read end

Stream's `._write()` callback should be invoked only after it's opposite
stream has finished processing incoming data, otherwise `finish` event
fires too early and connection might be closed while there's some data
to send to the client.

see #5544

tls: ignore .shutdown() syscall error

Quote from SSL_shutdown man page:

  The output of SSL_get_error(3) may be misleading,
  as an erroneous SSL_ERROR_SYSCALL may be flagged even though
  no error occurred.

Also, handle all other errors to prevent assertion in `ClearError()`.

Merge remote-tracking branch 'ry/v0.10'

Conflicts:
AUTHORS
ChangeLog
configure
deps/uv/ChangeLog
deps/uv/src/unix/darwin.c
deps/uv/src/unix/stream.c
deps/uv/src/version.c
deps/v8/src/isolate.cc
deps/v8/src/version.cc
lib/http.js
src/node_version.h

doc: add link to Brazilian Node community

Add a link to the Brazilian community portal.

doc: remove broken links on community page

Links to Node Manual and Node Bits both are broken, so this commit
removes them from the community page.

blog: Post for v0.10.8

Now working on 0.10.9

Merge branch 'v0.10.8-release' into v0.10

2013.05.24, Version 0.10.8 (Stable)

* v8: update to 3.14.5.9

* uv: upgrade to 0.10.8

* npm: Upgrade to 1.2.23

* http: remove bodyHead from 'upgrade' events (Nathan Zadoks)

* http: Return true on empty writes, not false (isaacs)

* http: save roundtrips, convert buffers to strings (Ben Noordhuis)

* configure: respect the --dest-os flag consistently (Nathan Rajlich)

* buffer: throw when writing beyond buffer (Trevor Norris)

* crypto: Clear error after DiffieHellman key errors (isaacs)

* string_bytes: strip padding from base64 strings (Trevor Norris)

doc: Minor fixup in http doc re bodyHead

tls: retry writing after hello parse error

When writing bad data to EncryptedStream it'll first get to the
ClientHello parser, and, only after it will refuse it, to the OpenSSL.
But ClientHello parser has limited buffer and therefore write could
return `bytes_written` < `incoming_bytes`, which is not the case when
working with OpenSSL.

After such errors ClientHello parser disables itself and will
pass-through all data to the OpenSSL. So just trying to write data one
more time will throw the rest into OpenSSL and let it handle it.

npm: Upgrade to 1.2.23

uv: upgrade to 0.10.8

http: remove bodyHead from 'upgrade' events

Streams2 makes this unnecessary.
An empty buffer is provided for compatibility.