Skip to content
Commits on May 30, 2013
  1. @isaacs

    2013.05.30, Version 0.10.9 (Stable)

    isaacs committed
    * 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)
  2. @isaacs

    npm: Upgrade to 1.2.24

    isaacs committed
  3. @kysnm @bnoordhuis

    doc: remove `bufferSize` option

    kysnm committed with bnoordhuis
    `bufferSize` option has been removed in b0f6789.
  4. @mscdex @bnoordhuis

    repl: fix JSON.parse error check

    mscdex committed with bnoordhuis
    Before this, entering something like:
    > JSON.parse('066');
    resulted in the "..." prompt instead of displaying the expected
    "SyntaxError: Unexpected number"
  5. @indutny

    tls: proper .destroySoon

    indutny committed
    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.
Commits on May 29, 2013
  1. @bnoordhuis
Commits on May 28, 2013
  1. @danielgtaylor @bnoordhuis

    https: Add `secureProtocol` docs

    danielgtaylor committed with bnoordhuis
    Add `secureProtocol` parameter docs to the https.request method.
  2. @danielgtaylor @bnoordhuis

    tls: Add `secureProtocol` docs

    danielgtaylor committed with bnoordhuis
    Add `secureProtocol` parameter docs to the tls.connect method.
  3. @isaacs

    uv: Upgrade to v0.10.9

    isaacs committed
  4. @indutny

    tls: invoke write cb only after opposite read end

    indutny committed
    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
  5. @indutny

    tls: ignore .shutdown() syscall error

    indutny committed
    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()`.
Commits on May 25, 2013
  1. @rafadev7 @bnoordhuis

    doc: add link to Brazilian Node community

    rafadev7 committed with bnoordhuis
    Add a link to the Brazilian community portal.
  2. @rafadev7 @bnoordhuis

    doc: remove broken links on community page

    rafadev7 committed with bnoordhuis
    Links to Node Manual and Node Bits both are broken, so this commit
    removes them from the community page.
Commits on May 24, 2013
  1. @isaacs

    blog: Post for v0.10.8

    isaacs committed
  2. @isaacs

    Now working on 0.10.9

    isaacs committed
  3. @isaacs
  4. @isaacs

    2013.05.24, Version 0.10.8 (Stable)

    isaacs committed
    * v8: update to
    * 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)
  5. @isaacs
  6. @indutny @isaacs

    tls: retry writing after hello parse error

    indutny committed with isaacs
    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.
  7. @isaacs

    npm: Upgrade to 1.2.23

    isaacs committed
  8. @isaacs

    uv: upgrade to 0.10.8

    isaacs committed
  9. @nathan7 @isaacs

    http: remove bodyHead from 'upgrade' events

    nathan7 committed with isaacs
    Streams2 makes this unnecessary.
    An empty buffer is provided for compatibility.
Commits on May 23, 2013
  1. @tjfontaine

    buffer: special case empty string writes

    tjfontaine committed
    Prior to 119354f we specifically handled passing a zero length string
    to write on a buffer, restore that functionality.
  2. @isaacs

    http: Return true on empty writes, not false

    isaacs committed
    Otherwise, writing an empty string causes the whole program to grind to
    a halt when piping data into http messages.
    This wasn't as much of a problem (though it WAS a bug) in 0.8 and
    before, because our hyperactive 'drain' behavior would mean that some
    *previous* write() would probably have a pending drain event, and cause
    things to start moving again.
  3. @tjfontaine

    v8: re-apply floating patches

    tjfontaine committed
  4. @tjfontaine

    v8: fix GetLocalizedMessage usage

    tjfontaine committed
    As is the backport of the abort on uncaught exception wouldn't compile
    because we it was passing in `this` when it was unnecessary.
  5. @tjfontaine

    v8: update to

    tjfontaine committed
  6. @bnoordhuis

    http: save roundtrips, convert buffers to strings

    bnoordhuis committed
    This commit adds an optimization to the HTTP client that makes it
    possible to:
    * Pack the headers and the first chunk of the request body into a
      single write().
    * Pack the chunk header and the chunk itself into a single write().
    Because only one write() system call is issued instead of several,
    the chances of data ending up in a single TCP packet are phenomenally
    higher: the benchmark with `type=buf size=32` jumps from 50 req/s to
    7,500 req/s, a 150-fold increase.
    This commit removes the check from e4b716e that pushes binary encoded
    strings into the slow path. The commit log mentions that:
        We were assuming that any string can be concatenated safely to
        CRLF.  However, for hex, base64, or binary encoded writes, this
        is not the case, and results in sending the incorrect response.
    For hex and base64 strings that's certainly true but binary strings
    are 'das Ding an sich': string.length is the same before and after
    Fixes #5528.
Commits on May 22, 2013
  1. @bnoordhuis
  2. @TooTallNate

    configure: respect the --dest-os flag consistently

    TooTallNate committed
    Consider a user on his Mac, who wants to cross-compile for his Linux ARM device:
        ./configure --dest-cpu=arm --dest-os=linux
    Before this patch, for example, DTrace probes would incorrectly attempt to be
    enabled because the configure script is running on a MacOS machine, even though
    we're trying to compile a binary for `linux`.
    With this patch, the `--dest-os` flag is respected throughout the configure
    script, thus leaving DTrace probes disabled in this cross-compiling scenario.
Commits on May 21, 2013
  1. @tjfontaine
  2. @tjfontaine

    timers: internal unref'd timer for api timeouts

    tjfontaine committed
    When an internal api needs a timeout, they should use
    timers._unrefActive since that won't hold the loop open. This solves
    the problem where you might have unref'd the socket handle but the
    timeout for the socket was still active.
Commits on May 20, 2013
  1. @trevnorris

    buffer: throw when writing beyond buffer

    trevnorris committed
    Previously one could write anywhere in a buffer pool if they accidently
    got their offset wrong. Mainly because the cc level checks only test
    against the parent slow buffer and not against the js object properties.
    So now we check to make sure values won't go beyond bounds without
    letting the dev know.
  2. @isaacs
  3. @trevnorris

    string_bytes: strip padding from base64 strings

    trevnorris committed
    Because of variations in different base64 implementation, it's been
    decided to strip all padding from the end of a base64 string and
    calculate its size from that.
Something went wrong with that request. Please try again.