noderb 0.0.4 → 0.0.6

data/ext/noderb_extension/libuv/src/win/process.c

@@ -45,19 +45,16 @@ typedef struct env_var {
     uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");          \
   }                                                       \
   if (!uv_utf8_to_utf16(s, t, size / sizeof(wchar_t))) {  \
-    uv_set_sys_error(GetLastError());                     \
+    uv_set_sys_error(loop, GetLastError());                     \
     err = -1;                                             \
     goto done;                                            \
   }
 
 
-static const wchar_t DEFAULT_PATH_EXT[10] = L".COM;.EXE";
-
-
-static void uv_process_init(uv_process_t* handle) {
+static void uv_process_init(uv_loop_t* loop, uv_process_t* handle) {
   handle->type = UV_PROCESS;
+  handle->loop = loop;
   handle->flags = 0;
-  handle->error = uv_ok_;
   handle->exit_cb = NULL;
   handle->pid = 0;
   handle->exit_signal = 0;
@@ -71,17 +68,17 @@ static void uv_process_init(uv_process_t* handle) {
   handle->stdio_pipes[2].server_pipe = NULL;
   handle->stdio_pipes[2].child_pipe = INVALID_HANDLE_VALUE;
 
-  uv_req_init((uv_req_t*)&handle->exit_req);
+  uv_req_init(loop, (uv_req_t*)&handle->exit_req);
   handle->exit_req.type = UV_PROCESS_EXIT;
   handle->exit_req.data = handle;
-  uv_req_init((uv_req_t*)&handle->close_req);
+  uv_req_init(loop, (uv_req_t*)&handle->close_req);
   handle->close_req.type = UV_PROCESS_CLOSE;
   handle->close_req.data = handle;
 
-  uv_counters()->handle_init++;
-  uv_counters()->process_init++;
+  loop->counters.handle_init++;
+  loop->counters.process_init++;
 
-  uv_ref();
+  uv_ref(loop);
 }
 
 
@@ -126,8 +123,8 @@ static wchar_t* search_path_join_test(const wchar_t* dir,
   }
 
   /* Allocate buffer for output */
-  result = result_pos =
-      (wchar_t*)malloc(sizeof(wchar_t) * (cwd_len + 1 + dir_len + 1 + name_len + 1 + ext_len + 1));
+  result = result_pos = (wchar_t*)malloc(sizeof(wchar_t) *
+      (cwd_len + 1 + dir_len + 1 + name_len + 1 + ext_len + 1));
 
   /* Copy cwd */
   wcsncpy(result_pos, cwd, cwd_len);
@@ -153,10 +150,14 @@ static wchar_t* search_path_join_test(const wchar_t* dir,
   wcsncpy(result_pos, name, name_len);
   result_pos += name_len;
 
-  /* Copy extension */
   if (ext_len) {
-    result_pos[0] = L'.';
-    result_pos++;
+    /* Add a dot if the filename didn't end with one */
+    if (name_len && result_pos[-1] != '.') {
+      result_pos[0] = L'.';
+      result_pos++;
+    }
+
+    /* Copy extension */
     wcsncpy(result_pos, ext, ext_len);
     result_pos += ext_len;
   }
@@ -185,54 +186,39 @@ static wchar_t* path_search_walk_ext(const wchar_t *dir,
                                      int name_len,
                                      wchar_t *cwd,
                                      int cwd_len,
-                                     const wchar_t *path_ext,
                                      int name_has_ext) {
-  wchar_t* result = NULL;
-
-  const wchar_t *ext_start,
-              *ext_end = path_ext;
+  wchar_t* result;
 
-  /* If the name itself has a nonemtpy extension, try this extension first */
+  /* If the name itself has a nonempty extension, try this extension first */
   if (name_has_ext) {
     result = search_path_join_test(dir, dir_len,
                                    name, name_len,
                                    L"", 0,
                                    cwd, cwd_len);
-  }
-
-  /* Add path_ext extensions and try to find a name that matches */
-  while (result == NULL) {
-    if (*ext_end == L'\0') {
-      break;
+    if (result != NULL) {
+      return result;
     }
+  }
 
-    /* Skip the separator that ext_end now points to */
-    if (ext_end != path_ext) {
-      ext_end++;
-    }
-
-    /* Find the next dot in path_ext */
-    ext_start = wcschr(ext_end, L'.');
-    if (ext_start == NULL) {
-      break;
-    }
-
-    /* Skip the dot */
-    ext_start++;
-
-    /* Slice until we found a ; or alternatively a \0 */
-    ext_end = wcschr(ext_start, L';');
-    if (ext_end == NULL) {
-       ext_end = wcschr(ext_start, '\0');
-    }
+  /* Try .com extension */
+  result = search_path_join_test(dir, dir_len,
+                                 name, name_len,
+                                 L"com", 3,
+                                 cwd, cwd_len);
+  if (result != NULL) {
+    return result;
+  }
 
-    result = search_path_join_test(dir, dir_len,
-                                   name, name_len,
-                                   ext_start, (ext_end - ext_start),
-                                   cwd, cwd_len);
+  /* Try .exe extension */
+  result = search_path_join_test(dir, dir_len,
+                                 name, name_len,
+                                 L"exe", 3,
+                                 cwd, cwd_len);
+  if (result != NULL) {
+    return result;
   }
 
-  return result;
+  return NULL;
 }
 
 
@@ -243,35 +229,28 @@ static wchar_t* path_search_walk_ext(const wchar_t *dir,
  *
  * It tries to return an absolute filename.
  *
- * Furthermore, it tries to follow the semantics that cmd.exe uses as closely
- * as possible:
+ * Furthermore, it tries to follow the semantics that cmd.exe, with this
+ * exception that PATHEXT environment variable isn't used. Since CreateProcess
+ * can start only .com and .exe files, only those extensions are tried. This
+ * behavior equals that of msvcrt's spawn functions.
  *
  * - Do not search the path if the filename already contains a path (either
  *   relative or absolute).
- *     (but do use path_ext)
  *
  * - If there's really only a filename, check the current directory for file,
  *   then search all path directories.
  *
- * - If filename specifies has *any* extension, search for the file with the
+ * - If filename specified has *any* extension, search for the file with the
  *   specified extension first.
- *     (not necessary an executable one or one that appears in path_ext;
- *      *but* no extension or just a dot is *not* allowed)
  *
  * - If the literal filename is not found in a directory, try *appending*
- *   (not replacing) extensions from path_ext in the specified order.
- *     (an extension consisting of just a dot *may* appear in path_ext;
- *      unlike what happens if the specified filename ends with a dot,
- *      if path_ext specifies a single dot cmd.exe *does* look for an
- *      extension-less file)
+ *   (not replacing) .com first and then .exe.
  *
  * - The path variable may contain relative paths; relative paths are relative
  *   to the cwd.
  *
  * - Directories in path may or may not end with a trailing backslash.
  *
- * - Extensions path_ext portions must always start with a dot.
- *
  * - CMD does not trim leading/trailing whitespace from path/pathex entries
  *   nor from the environment variables as a whole.
  *
@@ -281,13 +260,10 @@ static wchar_t* path_search_walk_ext(const wchar_t *dir,
  *   continue searching.
  *
  * TODO: correctly interpret UNC paths
- * TODO: check with cmd what should happen when a pathext entry does not start
- *       with a dot
  */
 static wchar_t* search_path(const wchar_t *file,
                             wchar_t *cwd,
-                            const wchar_t *path,
-                            const wchar_t *path_ext) {
+                            const wchar_t *path) {
   int file_has_dir;
   wchar_t* result = NULL;
   wchar_t *file_name_start;
@@ -305,7 +281,8 @@ static wchar_t* search_path(const wchar_t *file,
     return NULL;
   }
 
-  /* Find the start of the filename so we can split the directory from the name */
+  /* Find the start of the filename so we can split the directory from the */
+  /* name. */
   for (file_name_start = (wchar_t*)file + file_len;
        file_name_start > file
            && file_name_start[-1] != L'\\'
@@ -320,12 +297,12 @@ static wchar_t* search_path(const wchar_t *file,
   name_has_ext = (dot != NULL && dot[1] != L'\0');
 
   if (file_has_dir) {
-    /* The file has a path inside, don't use path (but do use path_ex) */
+    /* The file has a path inside, don't use path */
     result = path_search_walk_ext(
         file, file_name_start - file,
         file_name_start, file_len - (file_name_start - file),
         cwd, cwd_len,
-        path_ext, name_has_ext);
+        name_has_ext);
 
   } else {
     const wchar_t *dir_start,
@@ -335,7 +312,7 @@ static wchar_t* search_path(const wchar_t *file,
     result = path_search_walk_ext(L"", 0,
                                   file, file_len,
                                   cwd, cwd_len,
-                                  path_ext, name_has_ext);
+                                  name_has_ext);
 
     while (result == NULL) {
       if (*dir_end == L'\0') {
@@ -364,7 +341,7 @@ static wchar_t* search_path(const wchar_t *file,
       result = path_search_walk_ext(dir_start, dir_end - dir_start,
                                     file, file_len,
                                     cwd, cwd_len,
-                                    path_ext, name_has_ext);
+                                    name_has_ext);
     }
   }
 
@@ -381,7 +358,7 @@ wchar_t* quote_cmd_arg(const wchar_t *source, wchar_t *target) {
       i, quote_hit;
   wchar_t* start;
 
-  /* 
+  /*
    * Check if the string must be quoted;
    * if unnecessary, don't do it, it may only confuse older programs.
    */
@@ -397,7 +374,7 @@ wchar_t* quote_cmd_arg(const wchar_t *source, wchar_t *target) {
   }
 
   if (NULL == wcspbrk(source, L"\"\\")) {
-    /* 
+    /*
      * No embedded double quotes or backlashes, so I can just wrap
      * quote marks around the whole thing.
      */
@@ -468,7 +445,7 @@ wchar_t* make_program_args(char** args, int verbatim_arguments) {
     arg_count++;
   }
 
-  /* Adjust for potential quotes. Also assume the worst-case scenario 
+  /* Adjust for potential quotes. Also assume the worst-case scenario
   /* that every character needs escaping, so we need twice as much space. */
   size = size * 2 + arg_count * 2;
 
@@ -511,10 +488,11 @@ error:
  * If we learn that people are passing in huge environment blocks
  * then we should probably qsort() the array and then bsearch()
  * to see if it contains this variable. But there are ownership
- * issues associated with that solution; this is the caller's 
+ * issues associated with that solution; this is the caller's
  * char**, and modifying it is rude.
  */
-static void check_required_vars_contains_var(env_var_t* required, int size, const char* var) {
+static void check_required_vars_contains_var(env_var_t* required, int size,
+    const char* var) {
   int i;
   for (i = 0; i < size; ++i) {
     if (_strnicmp(required[i].narrow, var, required[i].len) == 0) {
@@ -529,7 +507,7 @@ static void check_required_vars_contains_var(env_var_t* required, int size, cons
  * The way windows takes environment variables is different than what C does;
  * Windows wants a contiguous block of null-terminated strings, terminated
  * with an additional null.
- * 
+ *
  * Windows has a few "essential" environment variables. winsock will fail
  * to initialize if SYSTEMROOT is not defined; some APIs make reference to
  * TEMP. SYSTEMDRIVE is probably also important. We therefore ensure that
@@ -552,7 +530,9 @@ wchar_t* make_program_env(char** env_block) {
   };
 
   for (env = env_block; *env; env++) {
-    check_required_vars_contains_var(required_vars, COUNTOF(required_vars), *env);
+    check_required_vars_contains_var(required_vars,
+                                     COUNTOF(required_vars),
+                                     *env);
     env_len += (uv_utf8_to_utf16(*env, NULL, 0) * sizeof(wchar_t));
   }
 
@@ -588,7 +568,9 @@ wchar_t* make_program_env(char** env_block) {
       wcscpy(ptr, required_vars[i].wide);
       ptr += required_vars[i].len - 1;
       *ptr++ = L'=';
-      var_size = GetEnvironmentVariableW(required_vars[i].wide, ptr, required_vars[i].value_len);
+      var_size = GetEnvironmentVariableW(required_vars[i].wide,
+                                         ptr,
+                                         required_vars[i].value_len);
       if (var_size == 0) {
         uv_fatal_error(GetLastError(), "GetEnvironmentVariableW");
       }
@@ -607,19 +589,13 @@ wchar_t* make_program_env(char** env_block) {
  */
 static void CALLBACK exit_wait_callback(void* data, BOOLEAN didTimeout) {
   uv_process_t* process = (uv_process_t*)data;
+  uv_loop_t* loop = process->loop;
 
   assert(didTimeout == FALSE);
   assert(process);
 
-  memset(&process->exit_req.overlapped, 0, sizeof(process->exit_req.overlapped));
-
   /* Post completed */
-  if (!PostQueuedCompletionStatus(LOOP->iocp,
-                                  0,
-                                  0,
-                                  &process->exit_req.overlapped)) {
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-  }
+  POST_COMPLETION_FOR_REQ(loop, &process->exit_req);
 }
 
 
@@ -629,19 +605,13 @@ static void CALLBACK exit_wait_callback(void* data, BOOLEAN didTimeout) {
  */
 static void CALLBACK close_wait_callback(void* data, BOOLEAN didTimeout) {
   uv_process_t* process = (uv_process_t*)data;
+  uv_loop_t* loop = process->loop;
 
   assert(didTimeout == FALSE);
   assert(process);
 
-  memset(&process->close_req.overlapped, 0, sizeof(process->close_req.overlapped));
-
   /* Post completed */
-  if (!PostQueuedCompletionStatus(LOOP->iocp,
-                                  0,
-                                  0,
-                                  &process->close_req.overlapped)) {
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-  }
+  POST_COMPLETION_FOR_REQ(loop, &process->close_req);
 }
 
 
@@ -654,6 +624,7 @@ static DWORD WINAPI spawn_failure(void* data) {
   char syscall[] = "CreateProcessW: ";
   char unknown[] = "unknown error\n";
   uv_process_t* process = (uv_process_t*) data;
+  uv_loop_t* loop = process->loop;
   HANDLE child_stderr = process->stdio_pipes[2].child_pipe;
   char* buf = NULL;
   DWORD count, written;
@@ -679,22 +650,15 @@ static DWORD WINAPI spawn_failure(void* data) {
 
   FlushFileBuffers(child_stderr);
 
-  memset(&process->exit_req.overlapped, 0, sizeof(process->exit_req.overlapped));
-
   /* Post completed */
-  if (!PostQueuedCompletionStatus(LOOP->iocp,
-                                  0,
-                                  0,
-                                  &process->exit_req.overlapped)) {
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-  }
+  POST_COMPLETION_FOR_REQ(loop, &process->exit_req);
 
   return 0;
 }
 
 
 /* Called on main thread after a child process has exited. */
-void uv_process_proc_exit(uv_process_t* handle) {
+void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) {
   int i;
   DWORD exit_code;
 
@@ -734,12 +698,12 @@ void uv_process_proc_exit(uv_process_t* handle) {
 
 
 /* Called on main thread after UnregisterWaitEx finishes. */
-void uv_process_proc_close(uv_process_t* handle) {
-  uv_want_endgame((uv_handle_t*)handle);
+void uv_process_proc_close(uv_loop_t* loop, uv_process_t* handle) {
+  uv_want_endgame(loop, (uv_handle_t*)handle);
 }
 
 
-void uv_process_endgame(uv_process_t* handle) {
+void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle) {
   if (handle->flags & UV_HANDLE_CLOSING) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
     handle->flags |= UV_HANDLE_CLOSED;
@@ -748,12 +712,12 @@ void uv_process_endgame(uv_process_t* handle) {
       handle->close_cb((uv_handle_t*)handle);
     }
 
-    uv_unref();
+    uv_unref(loop);
   }
 }
 
 
-void uv_process_close(uv_process_t* handle) {
+void uv_process_close(uv_loop_t* loop, uv_process_t* handle) {
   if (handle->wait_handle != INVALID_HANDLE_VALUE) {
     handle->close_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
     UnregisterWaitEx(handle->wait_handle, handle->close_handle);
@@ -763,25 +727,30 @@ void uv_process_close(uv_process_t* handle) {
         close_wait_callback, (void*)handle, INFINITE,
         WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
   } else {
-    uv_want_endgame((uv_handle_t*)handle);
+    uv_want_endgame(loop, (uv_handle_t*)handle);
   }
 }
 
 
-static int uv_create_stdio_pipe_pair(uv_pipe_t* server_pipe, HANDLE* child_pipe,  DWORD server_access, DWORD child_access) {
+static int uv_create_stdio_pipe_pair(uv_loop_t* loop, uv_pipe_t* server_pipe,
+    HANDLE* child_pipe,  DWORD server_access, DWORD child_access) {
   int err;
   SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
   char pipe_name[64];
   DWORD mode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT;
 
   if (server_pipe->type != UV_NAMED_PIPE) {
-    uv_set_error(UV_EINVAL, 0);
+    uv_set_error(loop, UV_EINVAL, 0);
     err = -1;
     goto done;
   }
 
   /* Create server pipe handle. */
-  err = uv_stdio_pipe_server(server_pipe, server_access, pipe_name, sizeof(pipe_name));
+  err = uv_stdio_pipe_server(loop,
+                             server_pipe,
+                             server_access,
+                             pipe_name,
+                             sizeof(pipe_name));
   if (err) {
     goto done;
   }
@@ -796,13 +765,13 @@ static int uv_create_stdio_pipe_pair(uv_pipe_t* server_pipe, HANDLE* child_pipe,
                             NULL);
 
   if (*child_pipe == INVALID_HANDLE_VALUE) {
-    uv_set_sys_error(GetLastError());
+    uv_set_sys_error(loop, GetLastError());
     err = -1;
     goto done;
   }
 
   if (!SetNamedPipeHandleState(*child_pipe, &mode, NULL, NULL)) {
-    uv_set_sys_error(GetLastError());
+    uv_set_sys_error(loop, GetLastError());
     err = -1;
     goto done;
   }
@@ -812,7 +781,7 @@ static int uv_create_stdio_pipe_pair(uv_pipe_t* server_pipe, HANDLE* child_pipe,
    */
   if (!ConnectNamedPipe(server_pipe->handle, NULL)) {
     if (GetLastError() != ERROR_PIPE_CONNECTED) {
-      uv_set_sys_error(GetLastError());
+      uv_set_sys_error(loop, GetLastError());
       err = -1;
       goto done;
     }
@@ -836,19 +805,22 @@ done:
 }
 
 
-int uv_spawn(uv_process_t* process, uv_process_options_t options) {
+int uv_spawn(uv_loop_t* loop, uv_process_t* process,
+    uv_process_options_t options) {
   int err = 0, i;
   wchar_t* path;
   int size;
+  BOOL result;
   wchar_t* application_path, *application, *arguments, *env, *cwd;
   STARTUPINFOW startup;
   PROCESS_INFORMATION info;
 
-  uv_process_init(process);
+  uv_process_init(loop, process);
 
   process->exit_cb = options.exit_cb;
   UTF8_TO_UTF16(options.file, application);
-  arguments = options.args ? make_program_args(options.args, options.windows_verbatim_arguments) : NULL;
+  arguments = options.args ? make_program_args(options.args,
+      options.windows_verbatim_arguments) : NULL;
   env = options.env ? make_program_env(options.env) : NULL;
 
   if (options.cwd) {
@@ -862,7 +834,7 @@ int uv_spawn(uv_process_t* process, uv_process_options_t options) {
       }
       GetCurrentDirectoryW(size, cwd);
     } else {
-      uv_set_sys_error(GetLastError());
+      uv_set_sys_error(loop, GetLastError());
       err = -1;
       goto done;
     }
@@ -879,8 +851,7 @@ int uv_spawn(uv_process_t* process, uv_process_options_t options) {
 
   application_path = search_path(application,
                                  cwd,
-                                 path,
-                                 DEFAULT_PATH_EXT);
+                                 path);
 
   if (!application_path) {
     /* CreateProcess will fail, but this allows us to pass this error to */
@@ -890,7 +861,12 @@ int uv_spawn(uv_process_t* process, uv_process_options_t options) {
 
   /* Create stdio pipes. */
   if (options.stdin_stream) {
-    err = uv_create_stdio_pipe_pair(options.stdin_stream, &process->stdio_pipes[0].child_pipe, PIPE_ACCESS_OUTBOUND, GENERIC_READ | FILE_WRITE_ATTRIBUTES);
+    err = uv_create_stdio_pipe_pair(
+        loop,
+        options.stdin_stream,
+        &process->stdio_pipes[0].child_pipe,
+        PIPE_ACCESS_OUTBOUND,
+        GENERIC_READ | FILE_WRITE_ATTRIBUTES);
     if (err) {
       goto done;
     }
@@ -899,7 +875,11 @@ int uv_spawn(uv_process_t* process, uv_process_options_t options) {
   }
 
   if (options.stdout_stream) {
-    err = uv_create_stdio_pipe_pair(options.stdout_stream, &process->stdio_pipes[1].child_pipe, PIPE_ACCESS_INBOUND, GENERIC_WRITE);
+    err = uv_create_stdio_pipe_pair(
+        loop, options.stdout_stream,
+        &process->stdio_pipes[1].child_pipe,
+        PIPE_ACCESS_INBOUND,
+        GENERIC_WRITE);
     if (err) {
       goto done;
     }
@@ -908,7 +888,12 @@ int uv_spawn(uv_process_t* process, uv_process_options_t options) {
   }
 
   if (options.stderr_stream) {
-    err = uv_create_stdio_pipe_pair(options.stderr_stream, &process->stdio_pipes[2].child_pipe, PIPE_ACCESS_INBOUND, GENERIC_WRITE);
+    err = uv_create_stdio_pipe_pair(
+        loop,
+        options.stderr_stream,
+        &process->stdio_pipes[2].child_pipe,
+        PIPE_ACCESS_INBOUND,
+        GENERIC_WRITE);
     if (err) {
       goto done;
     }
@@ -942,9 +927,10 @@ int uv_spawn(uv_process_t* process, uv_process_options_t options) {
     process->pid = info.dwProcessId;
 
     /* Setup notifications for when the child process exits. */
-    if (!RegisterWaitForSingleObject(&process->wait_handle, process->process_handle,
-        exit_wait_callback, (void*)process, INFINITE,
-        WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE)) {
+    result = RegisterWaitForSingleObject(&process->wait_handle,
+        process->process_handle, exit_wait_callback, (void*)process, INFINITE,
+        WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
+    if (!result) {
       uv_fatal_error(GetLastError(), "RegisterWaitForSingleObject");
     }