diff --git a/nodejs-revert-utf8-node.patch b/nodejs-revert-utf8-node.patch new file mode 100644 index 0000000..f8c8f37 --- /dev/null +++ b/nodejs-revert-utf8-node.patch @@ -0,0 +1,784 @@ +From a9e60792a9c4044e29ec7bbb88419d9283044b86 Mon Sep 17 00:00:00 2001 +From: "T.C. Hollingsworth" +Date: Wed, 18 Jun 2014 23:19:19 -0700 +Subject: [PATCH] Revert "src: replace usage of String::Utf8Value" + +This reverts commit 535c7777ac674ba86cf93c44824e07b0e23ea8c4. +--- + src/cares_wrap.cc | 8 ++--- + src/fs_event_wrap.cc | 3 +- + src/node.cc | 42 +++++++++++++------------- + src/node_crypto.cc | 31 ++++++++++--------- + src/node_dtrace.cc | 6 ++-- + src/node_file.cc | 37 +++++++++++------------ + src/node_stat_watcher.cc | 3 +- + src/process_wrap.cc | 9 +++--- + src/udp_wrap.cc | 9 +++--- + src/util.h | 78 ------------------------------------------------ + 10 files changed, 68 insertions(+), 158 deletions(-) + delete mode 100644 src/util.h + +diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc +index 321e144..b7ba828 100644 +--- a/src/cares_wrap.cc ++++ b/src/cares_wrap.cc +@@ -31,8 +31,6 @@ + #include "tree.h" + #include "uv.h" + +-#include "util.h" +- + #if defined(__OpenBSD__) || defined(__MINGW32__) || defined(_MSC_VER) + # include + #else +@@ -741,7 +739,7 @@ static Handle Query(const Arguments& args) { + // object reference, causing wrap->GetObject() to return undefined. + Local object = Local::New(wrap->GetObject()); + +- node::Utf8Value name(args[0]); ++ String::Utf8Value name(args[0]); + + int r = wrap->Send(*name); + if (r) { +@@ -770,7 +768,7 @@ static Handle QueryWithFamily(const Arguments& args) { + // object reference, causing wrap->GetObject() to return undefined. + Local object = Local::New(wrap->GetObject()); + +- node::Utf8Value name(args[0]); ++ String::Utf8Value name(args[0]); + int family = args[1]->Int32Value(); + + int r = wrap->Send(*name, family); +@@ -900,7 +898,7 @@ static Handle IsIP(const Arguments& args) { + static Handle GetAddrInfo(const Arguments& args) { + HandleScope scope; + +- node::Utf8Value hostname(args[0]); ++ String::Utf8Value hostname(args[0]); + + int fam = AF_UNSPEC; + if (args[1]->IsInt32()) { +diff --git a/src/fs_event_wrap.cc b/src/fs_event_wrap.cc +index fc54283..7e3eb8c 100644 +--- a/src/fs_event_wrap.cc ++++ b/src/fs_event_wrap.cc +@@ -21,7 +21,6 @@ + + #include "node.h" + #include "handle_wrap.h" +-#include "util.h" + + #include + +@@ -98,7 +97,7 @@ Handle FSEventWrap::Start(const Arguments& args) { + return ThrowException(Exception::TypeError(String::New("Bad arguments"))); + } + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + int r = uv_fs_event_init(uv_default_loop(), &wrap->handle_, *path, OnEvent, 0); + if (r == 0) { +diff --git a/src/node.cc b/src/node.cc +index e9696cd..8257604 100644 +--- a/src/node.cc ++++ b/src/node.cc +@@ -82,8 +82,6 @@ typedef int mode_t; + #include "node_script.h" + #include "v8_typed_array.h" + +-#include "util.h" +- + using namespace v8; + + # ifdef __APPLE__ +@@ -1102,7 +1100,7 @@ enum encoding ParseEncoding(Handle encoding_v, enum encoding _default) { + + if (!encoding_v->IsString()) return _default; + +- node::Utf8Value encoding(encoding_v); ++ String::Utf8Value encoding(encoding_v); + + if (strcasecmp(*encoding, "utf8") == 0) { + return UTF8; +@@ -1202,12 +1200,12 @@ void DisplayExceptionLine (TryCatch &try_catch) { + + if (!message.IsEmpty()) { + // Print (filename):(line number): (message). +- node::Utf8Value filename(message->GetScriptResourceName()); ++ String::Utf8Value filename(message->GetScriptResourceName()); + const char* filename_string = *filename; + int linenum = message->GetLineNumber(); + fprintf(stderr, "%s:%i\n", filename_string, linenum); + // Print line of source code. +- node::Utf8Value sourceline(message->GetSourceLine()); ++ String::Utf8Value sourceline(message->GetSourceLine()); + const char* sourceline_string = *sourceline; + + // Because of how node modules work, all scripts are wrapped with a +@@ -1254,7 +1252,7 @@ static void ReportException(TryCatch &try_catch, bool show_line) { + + if (show_line) DisplayExceptionLine(try_catch); + +- node::Utf8Value trace(try_catch.StackTrace()); ++ String::Utf8Value trace(try_catch.StackTrace()); + + // range errors have a trace member set to undefined + if (trace.length() > 0 && !try_catch.StackTrace()->IsUndefined()) { +@@ -1269,11 +1267,11 @@ static void ReportException(TryCatch &try_catch, bool show_line) { + !(er->ToObject()->Get(String::New("name"))->IsUndefined()); + + if (isErrorObject) { +- node::Utf8Value name(er->ToObject()->Get(String::New("name"))); ++ String::Utf8Value name(er->ToObject()->Get(String::New("name"))); + fprintf(stderr, "%s: ", *name); + } + +- node::Utf8Value msg(!isErrorObject ? er ++ String::Utf8Value msg(!isErrorObject ? er + : er->ToObject()->Get(String::New("message"))); + fprintf(stderr, "%s\n", *msg); + } +@@ -1355,7 +1353,7 @@ static Handle Chdir(const Arguments& args) { + return ThrowException(Exception::Error(String::New("Bad argument."))); + } + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + uv_err_t r = uv_chdir(*path); + +@@ -1406,7 +1404,7 @@ static Handle Umask(const Arguments& args) { + oct = args[0]->Uint32Value(); + } else { + oct = 0; +- node::Utf8Value str(args[0]); ++ String::Utf8Value str(args[0]); + + // Parse the octal string. + for (int i = 0; i < str.length(); i++) { +@@ -1512,7 +1510,7 @@ static uid_t uid_by_name(Handle value) { + if (value->IsUint32()) { + return static_cast(value->Uint32Value()); + } else { +- node::Utf8Value name(value); ++ String::Utf8Value name(value); + return uid_by_name(*name); + } + } +@@ -1522,7 +1520,7 @@ static gid_t gid_by_name(Handle value) { + if (value->IsUint32()) { + return static_cast(value->Uint32Value()); + } else { +- node::Utf8Value name(value); ++ String::Utf8Value name(value); + return gid_by_name(*name); + } + } +@@ -1665,7 +1663,7 @@ static Handle InitGroups(const Arguments& args) { + return ThrowTypeError("argument 2 must be a number or a string"); + } + +- node::Utf8Value arg0(args[0]); ++ String::Utf8Value arg0(args[0]); + gid_t extra_group; + bool must_free; + char* user; +@@ -1826,7 +1824,7 @@ Handle DLOpen(const v8::Arguments& args) { + } + + Local module = args[0]->ToObject(); // Cast +- node::Utf8Value filename(args[1]); // Cast ++ String::Utf8Value filename(args[1]); // Cast + + if (exports_symbol.IsEmpty()) { + exports_symbol = NODE_PSYMBOL("exports"); +@@ -1842,7 +1840,7 @@ Handle DLOpen(const v8::Arguments& args) { + return ThrowException(Exception::Error(errmsg)); + } + +- node::Utf8Value path(args[1]); ++ String::Utf8Value path(args[1]); + base = *path; + + /* Find the shared library filename within the full path. */ +@@ -1961,7 +1959,7 @@ static Handle Binding(const Arguments& args) { + HandleScope scope; + + Local module = args[0]->ToString(); +- node::Utf8Value module_v(module); ++ String::Utf8Value module_v(module); + node_module_struct* modp; + + if (binding_cache.IsEmpty()) { +@@ -2020,7 +2018,7 @@ static void ProcessTitleSetter(Local property, + Local value, + const AccessorInfo& info) { + HandleScope scope; +- node::Utf8Value title(value); ++ String::Utf8Value title(value); + // TODO: protect with a lock + uv_set_process_title(*title); + } +@@ -2030,7 +2028,7 @@ static Handle EnvGetter(Local property, + const AccessorInfo& info) { + HandleScope scope; + #ifdef __POSIX__ +- node::Utf8Value key(property); ++ String::Utf8Value key(property); + const char* val = getenv(*key); + if (val) { + return scope.Close(String::New(val)); +@@ -2059,8 +2057,8 @@ static Handle EnvSetter(Local property, + const AccessorInfo& info) { + HandleScope scope; + #ifdef __POSIX__ +- node::Utf8Value key(property); +- node::Utf8Value val(value); ++ String::Utf8Value key(property); ++ String::Utf8Value val(value); + setenv(*key, *val, 1); + #else // _WIN32 + String::Value key(property); +@@ -2080,7 +2078,7 @@ static Handle EnvQuery(Local property, + const AccessorInfo& info) { + HandleScope scope; + #ifdef __POSIX__ +- node::Utf8Value key(property); ++ String::Utf8Value key(property); + if (getenv(*key)) { + return scope.Close(Integer::New(0)); + } +@@ -2108,7 +2106,7 @@ static Handle EnvDeleter(Local property, + const AccessorInfo& info) { + HandleScope scope; + #ifdef __POSIX__ +- node::Utf8Value key(property); ++ String::Utf8Value key(property); + if (!getenv(*key)) return False(); + unsetenv(*key); // can't check return value, it's void on some platforms + return True(); +diff --git a/src/node_crypto.cc b/src/node_crypto.cc +index 46faba2..0ae1f8a 100644 +--- a/src/node_crypto.cc ++++ b/src/node_crypto.cc +@@ -26,7 +26,6 @@ + #include "node.h" + #include "node_buffer.h" + #include "string_bytes.h" +-#include "util.h" + + #include + #ifdef _MSC_VER +@@ -242,7 +241,7 @@ Handle SecureContext::Init(const Arguments& args) { + OPENSSL_CONST SSL_METHOD *method = SSLv23_method(); + + if (args.Length() == 1 && args[0]->IsString()) { +- node::Utf8Value sslmethod(args[0]); ++ String::Utf8Value sslmethod(args[0]); + + if (strcmp(*sslmethod, "SSLv2_method") == 0) { + #ifndef OPENSSL_NO_SSL2 +@@ -362,7 +361,7 @@ static BIO* LoadBIO (Handle v) { + int r = -1; + + if (v->IsString()) { +- node::Utf8Value s(v); ++ String::Utf8Value s(v); + r = BIO_write(bio, *s, s.length()); + } else if (Buffer::HasInstance(v)) { + char* buffer_data = Buffer::Data(v); +@@ -414,7 +413,7 @@ Handle SecureContext::SetKey(const Arguments& args) { + BIO *bio = LoadBIO(args[0]); + if (!bio) return False(); + +- node::Utf8Value passphrase(args[1]); ++ String::Utf8Value passphrase(args[1]); + + EVP_PKEY* key = PEM_read_bio_PrivateKey(bio, NULL, NULL, + len == 1 ? NULL : *passphrase); +@@ -644,7 +643,7 @@ Handle SecureContext::SetCiphers(const Arguments& args) { + return ThrowException(Exception::TypeError(String::New("Bad parameter"))); + } + +- node::Utf8Value ciphers(args[0]); ++ String::Utf8Value ciphers(args[0]); + SSL_CTX_set_cipher_list(sc->ctx_, *ciphers); + + return True(); +@@ -673,7 +672,7 @@ Handle SecureContext::SetSessionIdContext(const Arguments& args) { + return ThrowException(Exception::TypeError(String::New("Bad parameter"))); + } + +- node::Utf8Value sessionIdContext(args[0]); ++ String::Utf8Value sessionIdContext(args[0]); + const unsigned char* sid_ctx = (const unsigned char*) *sessionIdContext; + unsigned int sid_ctx_len = sessionIdContext.length(); + +@@ -1281,7 +1280,7 @@ Handle Connection::New(const Arguments& args) { + if (is_server) { + SSL_CTX_set_tlsext_servername_callback(sc->ctx_, SelectSNIContextCallback_); + } else { +- node::Utf8Value servername(args[2]); ++ String::Utf8Value servername(args[2]); + SSL_set_tlsext_host_name(p->ssl_, *servername); + } + #endif +@@ -2234,7 +2233,7 @@ class Cipher : public ObjectWrap { + ssize_t key_written = DecodeWrite(key_buf, key_buf_len, args[1], BINARY); + assert(key_written == key_buf_len); + +- node::Utf8Value cipherType(args[0]); ++ String::Utf8Value cipherType(args[0]); + + bool r = cipher->CipherInit(*cipherType, key_buf, key_buf_len); + +@@ -2285,7 +2284,7 @@ class Cipher : public ObjectWrap { + ssize_t iv_written = DecodeWrite(iv_buf, iv_len, args[2], BINARY); + assert(iv_written == iv_len); + +- node::Utf8Value cipherType(args[0]); ++ String::Utf8Value cipherType(args[0]); + + bool r = cipher->CipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len); + +@@ -2544,7 +2543,7 @@ class Decipher : public ObjectWrap { + ssize_t key_written = DecodeWrite(key_buf, key_len, args[1], BINARY); + assert(key_written == key_len); + +- node::Utf8Value cipherType(args[0]); ++ String::Utf8Value cipherType(args[0]); + + bool r = cipher->DecipherInit(*cipherType, key_buf,key_len); + +@@ -2595,7 +2594,7 @@ class Decipher : public ObjectWrap { + ssize_t iv_written = DecodeWrite(iv_buf, iv_len, args[2], BINARY); + assert(iv_written == iv_len); + +- node::Utf8Value cipherType(args[0]); ++ String::Utf8Value cipherType(args[0]); + + bool r = cipher->DecipherInitIv(*cipherType, key_buf,key_len,iv_buf,iv_len); + +@@ -2776,7 +2775,7 @@ class Hmac : public ObjectWrap { + return ThrowException(exception); + } + +- node::Utf8Value hashType(args[0]); ++ String::Utf8Value hashType(args[0]); + + bool r; + +@@ -2921,7 +2920,7 @@ class Hash : public ObjectWrap { + "Must give hashtype string as argument"))); + } + +- node::Utf8Value hashType(args[0]); ++ String::Utf8Value hashType(args[0]); + + Hash *hash = new Hash(); + if (!hash->HashInit(*hashType)) { +@@ -3095,7 +3094,7 @@ class Sign : public ObjectWrap { + "Must give signtype string as argument"))); + } + +- node::Utf8Value signType(args[0]); ++ String::Utf8Value signType(args[0]); + + bool r = sign->SignInit(*signType); + +@@ -3328,7 +3327,7 @@ class Verify : public ObjectWrap { + "Must give verifytype string as argument"))); + } + +- node::Utf8Value verifyType(args[0]); ++ String::Utf8Value verifyType(args[0]); + + bool r = verify->VerifyInit(*verifyType); + +@@ -3511,7 +3510,7 @@ class DiffieHellman : public ObjectWrap { + String::New("No group name given"))); + } + +- node::Utf8Value group_name(args[0]); ++ String::Utf8Value group_name(args[0]); + + modp_group* it = modp_groups; + +diff --git a/src/node_dtrace.cc b/src/node_dtrace.cc +index 0b2d0f4..4b851e3 100644 +--- a/src/node_dtrace.cc ++++ b/src/node_dtrace.cc +@@ -20,8 +20,6 @@ + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + +-#include "util.h" +- + #ifdef HAVE_DTRACE + #include "node_dtrace.h" + #include +@@ -68,7 +66,7 @@ using namespace v8; + return (ThrowException(Exception::Error(String::New("expected " \ + "object for " #obj " to contain string member " #member)))); \ + } \ +- node::Utf8Value _##member(obj->Get(String::New(#member))); \ ++ String::Utf8Value _##member(obj->Get(String::New(#member))); \ + if ((*(const char **)valp = *_##member) == NULL) \ + *(const char **)valp = ""; + +@@ -243,7 +241,7 @@ Handle DTRACE_HTTP_SERVER_REQUEST(const Arguments& args) { + "object for request to contain string member headers")))); + + Local strfwdfor = headers->Get(String::New("x-forwarded-for")); +- node::Utf8Value fwdfor(strfwdfor); ++ String::Utf8Value fwdfor(strfwdfor); + + if (!strfwdfor->IsString() || (req.forwardedFor = *fwdfor) == NULL) + req.forwardedFor = const_cast(""); +diff --git a/src/node_file.cc b/src/node_file.cc +index 3c35e0b..f665b19 100644 +--- a/src/node_file.cc ++++ b/src/node_file.cc +@@ -24,7 +24,6 @@ + #include "node_buffer.h" + #include "node_stat_watcher.h" + #include "req_wrap.h" +-#include "util.h" + + #include + #include +@@ -404,7 +403,7 @@ static Handle Stat(const Arguments& args) { + if (args.Length() < 1) return TYPE_ERROR("path required"); + if (!args[0]->IsString()) return TYPE_ERROR("path must be a string"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + if (args[1]->IsFunction()) { + ASYNC_CALL(stat, args[1], *path) +@@ -421,7 +420,7 @@ static Handle LStat(const Arguments& args) { + if (args.Length() < 1) return TYPE_ERROR("path required"); + if (!args[0]->IsString()) return TYPE_ERROR("path must be a string"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + if (args[1]->IsFunction()) { + ASYNC_CALL(lstat, args[1], *path) +@@ -459,12 +458,12 @@ static Handle Symlink(const Arguments& args) { + if (!args[0]->IsString()) return TYPE_ERROR("dest path must be a string"); + if (!args[1]->IsString()) return TYPE_ERROR("src path must be a string"); + +- node::Utf8Value dest(args[0]); +- node::Utf8Value path(args[1]); ++ String::Utf8Value dest(args[0]); ++ String::Utf8Value path(args[1]); + int flags = 0; + + if (args[2]->IsString()) { +- node::Utf8Value mode(args[2]); ++ String::Utf8Value mode(args[2]); + if (strcmp(*mode, "dir") == 0) { + flags |= UV_FS_SYMLINK_DIR; + } else if (strcmp(*mode, "junction") == 0) { +@@ -492,8 +491,8 @@ static Handle Link(const Arguments& args) { + if (!args[0]->IsString()) return TYPE_ERROR("dest path must be a string"); + if (!args[1]->IsString()) return TYPE_ERROR("src path must be a string"); + +- node::Utf8Value orig_path(args[0]); +- node::Utf8Value new_path(args[1]); ++ String::Utf8Value orig_path(args[0]); ++ String::Utf8Value new_path(args[1]); + + if (args[2]->IsFunction()) { + ASYNC_DEST_CALL(link, args[2], *new_path, *orig_path, *new_path) +@@ -509,7 +508,7 @@ static Handle ReadLink(const Arguments& args) { + if (args.Length() < 1) return TYPE_ERROR("path required"); + if (!args[0]->IsString()) return TYPE_ERROR("path must be a string"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + if (args[1]->IsFunction()) { + ASYNC_CALL(readlink, args[1], *path) +@@ -528,8 +527,8 @@ static Handle Rename(const Arguments& args) { + if (!args[0]->IsString()) return TYPE_ERROR("old path must be a string"); + if (!args[1]->IsString()) return TYPE_ERROR("new path must be a string"); + +- node::Utf8Value old_path(args[0]); +- node::Utf8Value new_path(args[1]); ++ String::Utf8Value old_path(args[0]); ++ String::Utf8Value new_path(args[1]); + + if (args[2]->IsFunction()) { + ASYNC_DEST_CALL(rename, args[2], *new_path, *old_path, *new_path) +@@ -599,7 +598,7 @@ static Handle Unlink(const Arguments& args) { + if (args.Length() < 1) return TYPE_ERROR("path required"); + if (!args[0]->IsString()) return TYPE_ERROR("path must be a string"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + if (args[1]->IsFunction()) { + ASYNC_CALL(unlink, args[1], *path) +@@ -615,7 +614,7 @@ static Handle RMDir(const Arguments& args) { + if (args.Length() < 1) return TYPE_ERROR("path required"); + if (!args[0]->IsString()) return TYPE_ERROR("path must be a string"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + if (args[1]->IsFunction()) { + ASYNC_CALL(rmdir, args[1], *path) +@@ -632,7 +631,7 @@ static Handle MKDir(const Arguments& args) { + return THROW_BAD_ARGS; + } + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + int mode = static_cast(args[1]->Int32Value()); + + if (args[2]->IsFunction()) { +@@ -649,7 +648,7 @@ static Handle ReadDir(const Arguments& args) { + if (args.Length() < 1) return TYPE_ERROR("path required"); + if (!args[0]->IsString()) return TYPE_ERROR("path must be a string"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + + if (args[1]->IsFunction()) { + ASYNC_CALL(readdir, args[1], *path, 0 /*flags*/) +@@ -687,7 +686,7 @@ static Handle Open(const Arguments& args) { + if (!args[1]->IsInt32()) return TYPE_ERROR("flags must be an int"); + if (!args[2]->IsInt32()) return TYPE_ERROR("mode must be an int"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + int flags = args[1]->Int32Value(); + int mode = static_cast(args[2]->Int32Value()); + +@@ -827,7 +826,7 @@ static Handle Chmod(const Arguments& args) { + if(args.Length() < 2 || !args[0]->IsString() || !args[1]->IsInt32()) { + return THROW_BAD_ARGS; + } +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + int mode = static_cast(args[1]->Int32Value()); + + if(args[2]->IsFunction()) { +@@ -874,7 +873,7 @@ static Handle Chown(const Arguments& args) { + if (!args[1]->IsUint32()) return TYPE_ERROR("uid must be an unsigned int"); + if (!args[2]->IsUint32()) return TYPE_ERROR("gid must be an unsigned int"); + +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + uv_uid_t uid = static_cast(args[1]->Uint32Value()); + uv_gid_t gid = static_cast(args[2]->Uint32Value()); + +@@ -925,7 +924,7 @@ static Handle UTimes(const Arguments& args) { + if (!args[1]->IsNumber()) return TYPE_ERROR("atime must be a number"); + if (!args[2]->IsNumber()) return TYPE_ERROR("mtime must be a number"); + +- const node::Utf8Value path(args[0]); ++ const String::Utf8Value path(args[0]); + const double atime = static_cast(args[1]->NumberValue()); + const double mtime = static_cast(args[2]->NumberValue()); + +diff --git a/src/node_stat_watcher.cc b/src/node_stat_watcher.cc +index fd3e5d1..c3f668c 100644 +--- a/src/node_stat_watcher.cc ++++ b/src/node_stat_watcher.cc +@@ -20,7 +20,6 @@ + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + #include "node_stat_watcher.h" +-#include "util.h" + + #include + #include +@@ -105,7 +104,7 @@ Handle StatWatcher::Start(const Arguments& args) { + HandleScope scope; + + StatWatcher* wrap = ObjectWrap::Unwrap(args.Holder()); +- node::Utf8Value path(args[0]); ++ String::Utf8Value path(args[0]); + const bool persistent = args[1]->BooleanValue(); + const uint32_t interval = args[2]->Uint32Value(); + +diff --git a/src/process_wrap.cc b/src/process_wrap.cc +index ac63e4b..784300f 100644 +--- a/src/process_wrap.cc ++++ b/src/process_wrap.cc +@@ -25,7 +25,6 @@ + #include "tty_wrap.h" + #include "tcp_wrap.h" + #include "udp_wrap.h" +-#include "util.h" + + #include + #include +@@ -188,7 +187,7 @@ class ProcessWrap : public HandleWrap { + + // options.file + Local file_v = js_options->Get(String::NewSymbol("file")); +- node::Utf8Value file(file_v->IsString() ? file_v : Local()); ++ String::Utf8Value file(file_v->IsString() ? file_v : Local()); + if (file.length() > 0) { + options.file = *file; + } else { +@@ -203,7 +202,7 @@ class ProcessWrap : public HandleWrap { + // Heap allocate to detect errors. +1 is for NULL. + options.args = new char*[argc + 1]; + for (int i = 0; i < argc; i++) { +- node::Utf8Value arg(js_argv->Get(i)); ++ String::Utf8Value arg(js_argv->Get(i)); + options.args[i] = strdup(*arg); + } + options.args[argc] = NULL; +@@ -211,7 +210,7 @@ class ProcessWrap : public HandleWrap { + + // options.cwd + Local cwd_v = js_options->Get(String::NewSymbol("cwd")); +- node::Utf8Value cwd(cwd_v->IsString() ? cwd_v : Local()); ++ String::Utf8Value cwd(cwd_v->IsString() ? cwd_v : Local()); + if (cwd.length() > 0) { + options.cwd = *cwd; + } +@@ -223,7 +222,7 @@ class ProcessWrap : public HandleWrap { + int envc = env->Length(); + options.env = new char*[envc + 1]; // Heap allocated to detect errors. + for (int i = 0; i < envc; i++) { +- node::Utf8Value pair(env->Get(i)); ++ String::Utf8Value pair(env->Get(i)); + options.env[i] = strdup(*pair); + } + options.env[envc] = NULL; +diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc +index 31a4e78..b33f4e8 100644 +--- a/src/udp_wrap.cc ++++ b/src/udp_wrap.cc +@@ -25,7 +25,6 @@ + #include "req_wrap.h" + #include "handle_wrap.h" + #include "udp_wrap.h" +-#include "util.h" + + #include + +@@ -161,7 +160,7 @@ Handle UDPWrap::DoBind(const Arguments& args, int family) { + // bind(ip, port, flags) + assert(args.Length() == 3); + +- node::Utf8Value address(args[0]); ++ String::Utf8Value address(args[0]); + const int port = args[1]->Uint32Value(); + const int flags = args[2]->Uint32Value(); + +@@ -220,8 +219,8 @@ Handle UDPWrap::SetMembership(const Arguments& args, + + assert(args.Length() == 2); + +- node::Utf8Value address(args[0]); +- node::Utf8Value iface(args[1]); ++ String::Utf8Value address(args[0]); ++ String::Utf8Value iface(args[1]); + + const char* iface_cstr = *iface; + if (args[1]->IsUndefined() || args[1]->IsNull()) { +@@ -272,7 +271,7 @@ Handle UDPWrap::DoSend(const Arguments& args, int family) { + length); + + const unsigned short port = args[3]->Uint32Value(); +- node::Utf8Value address(args[4]); ++ String::Utf8Value address(args[4]); + + switch (family) { + case AF_INET: +diff --git a/src/util.h b/src/util.h +deleted file mode 100644 +index 0dbf7f4..0000000 +--- a/src/util.h ++++ /dev/null +@@ -1,78 +0,0 @@ +-// Copyright Joyent, Inc. and other Node contributors. +-// +-// Permission is hereby granted, free of charge, to any person obtaining a +-// copy of this software and associated documentation files (the +-// "Software"), to deal in the Software without restriction, including +-// without limitation the rights to use, copy, modify, merge, publish, +-// distribute, sublicense, and/or sell copies of the Software, and to permit +-// persons to whom the Software is furnished to do so, subject to the +-// following conditions: +-// +-// The above copyright notice and this permission notice shall be included +-// in all copies or substantial portions of the Software. +-// +-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +-// USE OR OTHER DEALINGS IN THE SOFTWARE. +- +-#ifndef SRC_UTIL_H_ +-#define SRC_UTIL_H_ +- +-#include "v8.h" +-#include "string_bytes.h" +- +-namespace node { +- +-class Utf8Value { +- public: +- explicit Utf8Value(v8::Handle value) +- : length_(0), str_(NULL) { +- if (value.IsEmpty()) +- return; +- +- v8::Local val_ = value->ToString(); +- +- // Allocate enough space to include the null terminator +- size_t len = StringBytes::StorageSize(val_, UTF8) + 1; +- +- char* str = static_cast(calloc(1, len)); +- +- int flags = WRITE_UTF8_FLAGS; +- flags |= ~v8::String::NO_NULL_TERMINATION; +- +- length_ = val_->WriteUtf8(str, +- len, +- 0, +- flags); +- +- str_ = reinterpret_cast(str); +- } +- +- ~Utf8Value() { +- free(str_); +- } +- +- char* operator*() { +- return str_; +- }; +- +- const char* operator*() const { +- return str_; +- }; +- +- size_t length() const { +- return length_; +- }; +- +- private: +- size_t length_; +- char* str_; +-}; +- +-} // namespace node +- +-#endif // SRC_UTIL_H_ +-- +1.9.3 + diff --git a/nodejs-revert-utf8-v8.patch b/nodejs-revert-utf8-v8.patch new file mode 100644 index 0000000..f617cf3 --- /dev/null +++ b/nodejs-revert-utf8-v8.patch @@ -0,0 +1,90 @@ +From c7c934c66cd8712c9ff169f1ef4c5670d3ff99c8 Mon Sep 17 00:00:00 2001 +From: "T.C. Hollingsworth" +Date: Wed, 18 Jun 2014 23:09:03 -0700 +Subject: [PATCH] Revert "string_bytes: Guarantee valid utf-8 output" + +This reverts commit 0da4c671659cfbae12def127b2e94690b9d9b5e1. +--- + src/node.cc | 7 ------- + src/string_bytes.cc | 2 +- + src/string_bytes.h | 2 -- + test/simple/test-buffer.js | 12 ------------ + 4 files changed, 1 insertion(+), 22 deletions(-) + +diff --git a/src/node.cc b/src/node.cc +index 4223973..e9696cd 100644 +--- a/src/node.cc ++++ b/src/node.cc +@@ -178,8 +178,6 @@ static uv_async_t dispatch_debug_messages_async; + // Declared in node_internals.h + Isolate* node_isolate = NULL; + +-int WRITE_UTF8_FLAGS = v8::String::HINT_MANY_WRITES_EXPECTED | +- v8::String::NO_NULL_TERMINATION; + + static void Spin(uv_idle_t* handle, int status) { + assert((uv_idle_t*) handle == &tick_spinner); +@@ -3046,11 +3044,6 @@ static char **copy_argv(int argc, char **argv) { + } + + int Start(int argc, char *argv[]) { +- const char* replaceInvalid = getenv("NODE_INVALID_UTF8"); +- +- if (replaceInvalid == NULL) +- WRITE_UTF8_FLAGS |= String::REPLACE_INVALID_UTF8; +- + // Hack aroung with the argv pointer. Used for process.title = "blah". + argv = uv_setup_args(argc, argv); + +diff --git a/src/string_bytes.cc b/src/string_bytes.cc +index a7bab38..e4a34fe 100644 +--- a/src/string_bytes.cc ++++ b/src/string_bytes.cc +@@ -199,7 +199,7 @@ size_t StringBytes::Write(char* buf, + break; + + case UTF8: +- len = str->WriteUtf8(buf, buflen, chars_written, WRITE_UTF8_FLAGS); ++ len = str->WriteUtf8(buf, buflen, chars_written, flags); + break; + + case UCS2: +diff --git a/src/string_bytes.h b/src/string_bytes.h +index 31f04bb..8071a49 100644 +--- a/src/string_bytes.h ++++ b/src/string_bytes.h +@@ -29,8 +29,6 @@ + + namespace node { + +-extern int WRITE_UTF8_FLAGS; +- + using v8::Handle; + using v8::Local; + using v8::String; +diff --git a/test/simple/test-buffer.js b/test/simple/test-buffer.js +index f8b2798..3026824 100644 +--- a/test/simple/test-buffer.js ++++ b/test/simple/test-buffer.js +@@ -791,18 +791,6 @@ assert.equal(buf[3], 0xFF); + assert.equal(buf[3], 0xFF); + }); + +-// test unmatched surrogates not producing invalid utf8 output +-// ef bf bd = utf-8 representation of unicode replacement character +-// see https://codereview.chromium.org/121173009/ +-buf = new Buffer('ab\ud800cd', 'utf8'); +-assert.equal(buf[0], 0x61); +-assert.equal(buf[1], 0x62); +-assert.equal(buf[2], 0xef); +-assert.equal(buf[3], 0xbf); +-assert.equal(buf[4], 0xbd); +-assert.equal(buf[5], 0x63); +-assert.equal(buf[6], 0x64); +- + // test for buffer overrun + buf = new Buffer([0, 0, 0, 0, 0]); // length: 5 + var sub = buf.slice(0, 4); // length: 4 +-- +1.9.3 + diff --git a/nodejs.spec b/nodejs.spec index 04c0e29..63e4e94 100644 --- a/nodejs.spec +++ b/nodejs.spec @@ -28,6 +28,13 @@ Patch1: nodejs-disable-gyp-deps.patch # http://patch-tracker.debian.org/patch/series/view/nodejs/0.10.26~dfsg1-1/2014_donotinclude_root_certs.patch Patch2: nodejs-use-system-certs.patch +# The invalid UTF8 fix has been reverted since this breaks v8 API, which cannot +# be done in a stable distribution release. This build of nodejs will behave as +# if NODE_INVALID_UTF8 was set. For more information on the implications, see: +# http://blog.nodejs.org/2014/06/16/openssl-and-breaking-utf-8-change/ +Patch3: nodejs-revert-utf8-v8.patch +Patch4: nodejs-revert-utf8-node.patch + # V8 presently breaks ABI at least every x.y release while never bumping SONAME, # so we need to be more explicit until spot fixes that %global v8_ge 1:3.14.5.7 @@ -100,6 +107,9 @@ rm -rf deps %patch2 -p1 rm -f src/node_root_certs.h +%patch3 -p1 +%patch4 -p1 + %build # build with debugging symbols and add defines from libuv (#892601) @@ -183,8 +193,6 @@ cp -p common.gypi %{buildroot}%{_datadir}/node * Fri Aug 01 2014 T.C. Hollingsworth - 0.10.30-1 - new upstream release 0.10.30 http://blog.nodejs.org/2014/07/31/node-v0-10-30-stable/ -- allow UTF8 change to happen: - http://blog.nodejs.org/2014/06/16/openssl-and-breaking-utf-8-change/ * Thu Jun 19 2014 T.C. Hollingsworth - 0.10.29-1 - new upstream release 0.10.29