Add process_get_pid() to the Process subsystem.

This patch adds support for getting the unique process identifier from a
given process_t. This patch implements both support for both the Unix
and Microsoft Windows backend.

See: https://bugs.torproject.org/28179

diff --git a/src/lib/process/process.c b/src/lib/process/process.c
index d4237b2b1fb9ce051dc7eef37496fa7a39562523..ab19378a930b452e87181fec28fa0f0ec3285bdf 100644 (file)
--- a/src/lib/process/process.c
+++ b/src/lib/process/process.c
@@ -255,6 +255,19 @@ process_exec(process_t *process)
   return status;
 }
 
+/** Returns the unique process identifier for the given <b>process</b>. */
+process_pid_t
+process_get_pid(process_t *process)
+{
+  tor_assert(process);
+
+#ifndef _WIN32
+  return process_unix_get_pid(process);
+#else
+  return process_win32_get_pid(process);
+#endif
+}
+
 /** Set the callback function for output from the child process's standard out
  * handle.  This function sets the callback function which is called every time
  * the child process have written output to its standard out file handle.

diff --git a/src/lib/process/process.h b/src/lib/process/process.h
index f759c719391f0afdb07a32fa319b81f9859ecc22..7fd6cf53d081e04a758d8504a4850bce3a6ba1ea 100644 (file)
--- a/src/lib/process/process.h
+++ b/src/lib/process/process.h
@@ -49,6 +49,7 @@ struct process_t;
 typedef struct process_t process_t;
 
 typedef uint64_t process_exit_code_t;
+typedef uint64_t process_pid_t;
 
 typedef void (*process_read_callback_t)(process_t *,
                                         char *,
@@ -66,6 +67,8 @@ void process_free_(process_t *process);
 
 process_status_t process_exec(process_t *process);
 
+process_pid_t process_get_pid(process_t *process);
+
 void process_set_stdout_read_callback(process_t *,
                                       process_read_callback_t);
 void process_set_stderr_read_callback(process_t *,

diff --git a/src/lib/process/process_unix.c b/src/lib/process/process_unix.c
index c3691f1851f998abc2920d3ef677af81c823b862..fa03fdbbe42140a51a2194604032b258313bf576 100644 (file)
--- a/src/lib/process/process_unix.c
+++ b/src/lib/process/process_unix.c
@@ -356,6 +356,16 @@ process_unix_exec(process_t *process)
   return PROCESS_STATUS_RUNNING;
 }
 
+/** Returns the unique process identifier for the given <b>process</b>. */
+process_pid_t
+process_unix_get_pid(process_t *process)
+{
+  tor_assert(process);
+
+  process_unix_t *unix_process = process_get_unix_process(process);
+  return (process_pid_t)unix_process->pid;
+}
+
 /** Write the given <b>buffer</b> as input to the given <b>process</b>'s
  * standard input. Returns the number of bytes written. */
 int

diff --git a/src/lib/process/process_unix.h b/src/lib/process/process_unix.h
index 5fc23bcf07a94b92716c4e18c47fd907583b46f5..0474746b2621ec4294bd1dc3c078bc894dc3ae6b 100644 (file)
--- a/src/lib/process/process_unix.h
+++ b/src/lib/process/process_unix.h
@@ -30,6 +30,8 @@ void process_unix_free_(process_unix_t *unix_process);
 
 process_status_t process_unix_exec(struct process_t *process);
 
+process_pid_t process_unix_get_pid(struct process_t *process);
+
 int process_unix_write(struct process_t *process, buf_t *buffer);
 int process_unix_read_stdout(struct process_t *process, buf_t *buffer);
 int process_unix_read_stderr(struct process_t *process, buf_t *buffer);

diff --git a/src/lib/process/process_win32.c b/src/lib/process/process_win32.c
index a019e0b4f35f6260065ebb3ca1e852d67462baa8..3e97f378010f56c905d44bcdc803e69d2146ea9c 100644 (file)
--- a/src/lib/process/process_win32.c
+++ b/src/lib/process/process_win32.c
@@ -271,6 +271,16 @@ process_win32_exec(process_t *process)
   return PROCESS_STATUS_RUNNING;
 }
 
+/** Returns the unique process identifier for the given <b>process</b>. */
+process_pid_t
+process_win32_get_pid(process_t *process)
+{
+  tor_assert(process);
+
+  process_win32_t *win32_process = process_get_win32_process(process);
+  return (process_pid_t)win32_process->process_information.dwProcessId;
+}
+
 /** Schedule an async write of the data found in <b>buffer</b> for the given
  * process.  This function runs an async write operation of the content of
  * buffer, if we are not already waiting for a pending I/O request. Returns the

diff --git a/src/lib/process/process_win32.h b/src/lib/process/process_win32.h
index 8c3b80d3415ae0f07f18eac81d36567c4be6f50a..dbd264104cf78229f1a19f7a433546fd8dd13961 100644 (file)
--- a/src/lib/process/process_win32.h
+++ b/src/lib/process/process_win32.h
@@ -34,6 +34,8 @@ void process_win32_deinit(void);
 
 process_status_t process_win32_exec(struct process_t *process);
 
+process_pid_t process_win32_get_pid(struct process_t *process);
+
 int process_win32_write(struct process_t *process, buf_t *buffer);
 int process_win32_read_stdout(struct process_t *process, buf_t *buffer);
 int process_win32_read_stderr(struct process_t *process, buf_t *buffer);

diff --git a/src/test/test_process.c b/src/test/test_process.c
index 85ee9691a4a656735a8bf7ed9ad4f7dc2a8558c9..4f86e786cb9dffd9cb097d6822d558bf4758605e 100644 (file)
--- a/src/test/test_process.c
+++ b/src/test/test_process.c
@@ -160,6 +160,9 @@ test_default_values(void *arg)
   tt_assert(smartlist_contains(process_get_all_processes(),
                                process));
 
+  /* Default PID is 0. */
+  tt_int_op(0, OP_EQ, process_get_pid(process));
+
   /* Our arguments should be empty. */
   tt_int_op(0, OP_EQ,
             smartlist_len(process_get_arguments(process)));