apr_file_io: Add apr_file_pipe_create_pools() allowing a pair of
pipes to be created, each in a different pool.


git-svn-id: https://svn.apache.org/repos/asf/apr/apr/trunk@1734816 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/CHANGES b/CHANGES
index 91a2050..605e3c0 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,6 +1,9 @@
                                                      -*- coding: utf-8 -*-
 Changes for APR 2.0.0
 
+  *) apr_file_io: Add apr_file_pipe_create_pools() allowing a pair of
+     pipes to be created, each in a different pool. [Graham Leggett]
+
   *) apr_table_overlap: Add APR_OVERLAP_TABLES_ADD to merge and set when
      overlapping tables. [Graham Leggett]
 
diff --git a/file_io/netware/pipe.c b/file_io/netware/pipe.c
index adc53ee..b918a29 100644
--- a/file_io/netware/pipe.c
+++ b/file_io/netware/pipe.c
@@ -133,7 +133,8 @@
     return apr_os_pipe_put_ex(file, thefile, 0, pool);
 }
 
-APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *pool)
+static apr_status_t file_pipe_create(apr_file_t **in, apr_file_t **out,
+        apr_pool_t *pool_in, apr_pool_t *pool_out)
 {
     int         filedes[2];
 
@@ -141,11 +142,11 @@
         return errno;
     }
 
-    (*in) = (apr_file_t *)apr_pcalloc(pool, sizeof(apr_file_t));
-    (*out) = (apr_file_t *)apr_pcalloc(pool, sizeof(apr_file_t));
+    (*in) = (apr_file_t *)apr_pcalloc(pool_in, sizeof(apr_file_t));
+    (*out) = (apr_file_t *)apr_pcalloc(pool_out, sizeof(apr_file_t));
 
-    (*in)->pool     =
-    (*out)->pool    = pool;
+    (*in)->pool     = pool_in;
+    (*out)->pool    = pool_out;
     (*in)->filedes   = filedes[0];
     (*out)->filedes  = filedes[1];
     (*in)->flags     = APR_INHERIT;
@@ -163,8 +164,8 @@
     (*in)->ungetchar = -1;
     (*in)->thlock    =
     (*out)->thlock   = NULL;
-    (void) apr_pollset_create(&(*in)->pollset, 1, pool, 0);
-    (void) apr_pollset_create(&(*out)->pollset, 1, pool, 0);
+    (void) apr_pollset_create(&(*in)->pollset, 1, pool_in, 0);
+    (void) apr_pollset_create(&(*out)->pollset, 1, pool_out, 0);
 
     apr_pool_cleanup_register((*in)->pool, (void *)(*in), apr_unix_file_cleanup,
                          apr_pool_cleanup_null);
@@ -174,6 +175,30 @@
     return APR_SUCCESS;
 }
 
+static void file_pipe_block(apr_file_t **in, apr_file_t **out,
+        apr_int32_t blocking)
+{
+    switch (blocking) {
+    case APR_FULL_BLOCK:
+        break;
+    case APR_READ_BLOCK:
+        apr_file_pipe_timeout_set(*out, 0);
+        break;
+    case APR_WRITE_BLOCK:
+        apr_file_pipe_timeout_set(*in, 0);
+        break;
+    default:
+        apr_file_pipe_timeout_set(*out, 0);
+        apr_file_pipe_timeout_set(*in, 0);
+        break;
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *pool)
+{
+    return file_pipe_create(in, out, pool, pool);
+}
+
 APR_DECLARE(apr_status_t) apr_file_pipe_create_ex(apr_file_t **in, 
                                                   apr_file_t **out, 
                                                   apr_int32_t blocking,
@@ -181,23 +206,26 @@
 {
     apr_status_t status;
 
-    if ((status = apr_file_pipe_create(in, out, pool)) != APR_SUCCESS)
+    if ((status = file_pipe_create(in, out, pool, pool)) != APR_SUCCESS) {
         return status;
-
-    switch (blocking) {
-        case APR_FULL_BLOCK:
-            break;
-        case APR_READ_BLOCK:
-            apr_file_pipe_timeout_set(*out, 0);
-            break;
-        case APR_WRITE_BLOCK:
-            apr_file_pipe_timeout_set(*in, 0);
-            break;
-        default:
-            apr_file_pipe_timeout_set(*out, 0);
-            apr_file_pipe_timeout_set(*in, 0);
     }
 
+    file_pipe_block(in, out, blocking);
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_file_pipe_create_pools(apr_file_t **in,
+        apr_file_t **out, apr_int32_t blocking, apr_pool_t *pool_in, apr_pool_t *pool_out)
+{
+    apr_status_t status;
+
+    if ((status = file_pipe_create(in, out, pool_in, pool_out)) != APR_SUCCESS) {
+        return status;
+    }
+
+    file_pipe_block(in, out, blocking);
+
     return APR_SUCCESS;
 }
 
diff --git a/file_io/os2/pipe.c b/file_io/os2/pipe.c
index bf0aaae..914b777 100644
--- a/file_io/os2/pipe.c
+++ b/file_io/os2/pipe.c
@@ -24,7 +24,8 @@
 #include <string.h>
 #include <process.h>
 
-APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *pool)
+static apr_status_t file_pipe_create(apr_file_t **in, apr_file_t **out,
+        apr_pool_t *pool_in, apr_pool_t *pool_out)
 {
     ULONG filedes[2];
     ULONG rc, action;
@@ -54,7 +55,7 @@
         return APR_FROM_OS_ERROR(rc);
     }
 
-    (*in) = (apr_file_t *)apr_palloc(pool, sizeof(apr_file_t));
+    (*in) = (apr_file_t *)apr_palloc(pool_in, sizeof(apr_file_t));
     rc = DosCreateEventSem(NULL, &(*in)->pipeSem, DC_SEM_SHARED, FALSE);
 
     if (rc) {
@@ -76,9 +77,9 @@
         return APR_FROM_OS_ERROR(rc);
     }
 
-    (*in)->pool = pool;
+    (*in)->pool = pool_in;
     (*in)->filedes = filedes[0];
-    (*in)->fname = apr_pstrdup(pool, pipename);
+    (*in)->fname = apr_pstrdup(pool_in, pipename);
     (*in)->isopen = TRUE;
     (*in)->buffered = FALSE;
     (*in)->flags = APR_FOPEN_READ;
@@ -86,9 +87,10 @@
     (*in)->timeout = -1;
     (*in)->blocking = BLK_ON;
     (*in)->ungetchar = -1;
-    apr_pool_cleanup_register(pool, *in, apr_file_cleanup, apr_pool_cleanup_null);
+    apr_pool_cleanup_register(pool_in, *in, apr_file_cleanup,
+            apr_pool_cleanup_null);
 
-    (*out) = (apr_file_t *)apr_palloc(pool, sizeof(apr_file_t));
+    (*out) = (apr_file_t *)apr_palloc(pool_out, sizeof(apr_file_t));
     rc = DosCreateEventSem(NULL, &(*out)->pipeSem, DC_SEM_SHARED, FALSE);
 
     if (rc) {
@@ -108,9 +110,9 @@
         return APR_FROM_OS_ERROR(rc);
     }
 
-    (*out)->pool = pool;
+    (*out)->pool = pool_out;
     (*out)->filedes = filedes[1];
-    (*out)->fname = apr_pstrdup(pool, pipename);
+    (*out)->fname = apr_pstrdup(pool_out, pipename);
     (*out)->isopen = TRUE;
     (*out)->buffered = FALSE;
     (*out)->flags = APR_FOPEN_WRITE;
@@ -118,12 +120,37 @@
     (*out)->timeout = -1;
     (*out)->blocking = BLK_ON;
     (*out)->ungetchar = -1;
-    apr_pool_cleanup_register(pool, *out, apr_file_cleanup, apr_pool_cleanup_null);
+    apr_pool_cleanup_register(pool_out, *out, apr_file_cleanup,
+            apr_pool_cleanup_null);
 
     return APR_SUCCESS;
 }
 
+static void file_pipe_block(apr_file_t **in, apr_file_t **out,
+        apr_int32_t blocking)
+{
+    switch (blocking) {
+    case APR_FULL_BLOCK:
+        break;
+    case APR_READ_BLOCK:
+        apr_file_pipe_timeout_set(*out, 0);
+        break;
+    case APR_WRITE_BLOCK:
+        apr_file_pipe_timeout_set(*in, 0);
+        break;
+    default:
+        apr_file_pipe_timeout_set(*out, 0);
+        apr_file_pipe_timeout_set(*in, 0);
+        break;
+    }
+}
 
+APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in,
+                                               apr_file_t **out,
+                                               apr_pool_t *pool)
+{
+    return file_pipe_create(in, out, pool, pool);
+}
 
 APR_DECLARE(apr_status_t) apr_file_pipe_create_ex(apr_file_t **in, 
                                                   apr_file_t **out, 
@@ -132,26 +159,29 @@
 {
     apr_status_t status;
 
-    if ((status = apr_file_pipe_create(in, out, pool)) != APR_SUCCESS)
+    if ((status = file_pipe_create(in, out, pool, pool)) != APR_SUCCESS)
         return status;
 
-    switch (blocking) {
-        case APR_FULL_BLOCK:
-            break;
-        case APR_READ_BLOCK:
-            apr_file_pipe_timeout_set(*out, 0);
-            break;
-        case APR_WRITE_BLOCK:
-            apr_file_pipe_timeout_set(*in, 0);
-            break;
-        default:
-            apr_file_pipe_timeout_set(*out, 0);
-            apr_file_pipe_timeout_set(*in, 0);
-    }
+    file_pipe_block(in, out, blocking);
 
     return APR_SUCCESS;
 }
 
+APR_DECLARE(apr_status_t) apr_file_pipe_create_pools(apr_file_t **in,
+                                                     apr_file_t **out,
+                                                     apr_int32_t blocking,
+                                                     apr_pool_t *pool_in,
+                                                     apr_pool_t *pool_out)
+{
+    apr_status_t status;
+
+    if ((status = file_pipe_create(in, out, pool_in, pool_out)) != APR_SUCCESS)
+        return status;
+
+    file_pipe_block(in, out, blocking);
+
+    return APR_SUCCESS;
+}
     
     
 APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename, apr_fileperms_t perm, apr_pool_t *pool)
diff --git a/file_io/unix/pipe.c b/file_io/unix/pipe.c
index 571d9bc..7be16e5 100644
--- a/file_io/unix/pipe.c
+++ b/file_io/unix/pipe.c
@@ -176,7 +176,8 @@
     return apr_os_pipe_put_ex(file, thefile, 0, pool);
 }
 
-APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *pool)
+static apr_status_t file_pipe_create(apr_file_t **in, apr_file_t **out,
+        apr_pool_t *pool_in, apr_pool_t *pool_out)
 {
     int filedes[2];
 
@@ -184,8 +185,8 @@
         return errno;
     }
     
-    (*in) = (apr_file_t *)apr_pcalloc(pool, sizeof(apr_file_t));
-    (*in)->pool = pool;
+    (*in) = (apr_file_t *)apr_pcalloc(pool_in, sizeof(apr_file_t));
+    (*in)->pool = pool_in;
     (*in)->filedes = filedes[0];
     (*in)->is_pipe = 1;
     (*in)->fname = NULL;
@@ -200,8 +201,8 @@
 #ifndef WAITIO_USES_POLL
     (*in)->pollset = NULL;
 #endif
-    (*out) = (apr_file_t *)apr_pcalloc(pool, sizeof(apr_file_t));
-    (*out)->pool = pool;
+    (*out) = (apr_file_t *)apr_pcalloc(pool_out, sizeof(apr_file_t));
+    (*out)->pool = pool_out;
     (*out)->filedes = filedes[1];
     (*out)->is_pipe = 1;
     (*out)->fname = NULL;
@@ -222,6 +223,30 @@
     return APR_SUCCESS;
 }
 
+static void file_pipe_block(apr_file_t **in, apr_file_t **out, apr_int32_t blocking)
+{
+    switch (blocking) {
+    case APR_FULL_BLOCK:
+        break;
+    case APR_READ_BLOCK:
+        apr_file_pipe_timeout_set(*out, 0);
+        break;
+    case APR_WRITE_BLOCK:
+        apr_file_pipe_timeout_set(*in, 0);
+        break;
+    default:
+        apr_file_pipe_timeout_set(*out, 0);
+        apr_file_pipe_timeout_set(*in, 0);
+        break;
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in,
+        apr_file_t **out, apr_pool_t *pool)
+{
+    return file_pipe_create(in, out, pool, pool);
+}
+
 APR_DECLARE(apr_status_t) apr_file_pipe_create_ex(apr_file_t **in, 
                                                   apr_file_t **out, 
                                                   apr_int32_t blocking,
@@ -229,23 +254,26 @@
 {
     apr_status_t status;
 
-    if ((status = apr_file_pipe_create(in, out, pool)) != APR_SUCCESS)
+    if ((status = file_pipe_create(in, out, pool, pool)) != APR_SUCCESS) {
         return status;
-
-    switch (blocking) {
-        case APR_FULL_BLOCK:
-            break;
-        case APR_READ_BLOCK:
-            apr_file_pipe_timeout_set(*out, 0);
-            break;
-        case APR_WRITE_BLOCK:
-            apr_file_pipe_timeout_set(*in, 0);
-            break;
-        default:
-            apr_file_pipe_timeout_set(*out, 0);
-            apr_file_pipe_timeout_set(*in, 0);
     }
 
+    file_pipe_block(in, out, blocking);
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_file_pipe_create_pools(apr_file_t **in,
+        apr_file_t **out, apr_int32_t blocking, apr_pool_t *pool_in, apr_pool_t *pool_out)
+{
+    apr_status_t status;
+
+    if ((status = file_pipe_create(in, out, pool_in, pool_out)) != APR_SUCCESS) {
+        return status;
+    }
+
+    file_pipe_block(in, out, blocking);
+
     return APR_SUCCESS;
 }
 
diff --git a/file_io/win32/pipe.c b/file_io/win32/pipe.c
index bb6e0c1..491a1a5 100644
--- a/file_io/win32/pipe.c
+++ b/file_io/win32/pipe.c
@@ -68,7 +68,7 @@
                                                apr_pool_t *p)
 {
     /* Unix creates full blocking pipes. */
-    return apr_file_pipe_create_ex(in, out, APR_FULL_BLOCK, p);
+    return apr_file_pipe_create_pools(in, out, APR_FULL_BLOCK, p, p);
 }
 
 APR_DECLARE(apr_status_t) apr_file_pipe_create_ex(apr_file_t **in,
@@ -76,6 +76,15 @@
                                                   apr_int32_t blocking,
                                                   apr_pool_t *p)
 {
+    return apr_file_pipe_create_pools(in, out, APR_FULL_BLOCK, p, p);
+}
+
+APR_DECLARE(apr_status_t) apr_file_pipe_create_pools(apr_file_t **in,
+                                                     apr_file_t **out,
+                                                     apr_int32_t blocking,
+                                                     apr_pool_t *pool_in,
+                                                     apr_pool_t *pool_out)
+{
 #ifdef _WIN32_WCE
     return APR_ENOTIMPL;
 #else
@@ -96,8 +105,8 @@
 #endif
     sa.lpSecurityDescriptor = NULL;
 
-    (*in) = (apr_file_t *)apr_pcalloc(p, sizeof(apr_file_t));
-    (*in)->pool = p;
+    (*in) = (apr_file_t *)apr_pcalloc(pool_in, sizeof(apr_file_t));
+    (*in)->pool = pool_in;
     (*in)->fname = NULL;
     (*in)->pipe = 1;
     (*in)->timeout = -1;
@@ -111,8 +120,8 @@
 #if APR_FILES_AS_SOCKETS
     (void) apr_pollset_create(&(*in)->pollset, 1, p, 0);
 #endif
-    (*out) = (apr_file_t *)apr_pcalloc(p, sizeof(apr_file_t));
-    (*out)->pool = p;
+    (*out) = (apr_file_t *)apr_pcalloc(pool_out, sizeof(apr_file_t));
+    (*out)->pool = pool_out;
     (*out)->fname = NULL;
     (*out)->pipe = 1;
     (*out)->timeout = -1;
@@ -150,7 +159,8 @@
         if (blocking == APR_WRITE_BLOCK /* READ_NONBLOCK */
                || blocking == APR_FULL_NONBLOCK) {
             dwOpenMode |= FILE_FLAG_OVERLAPPED;
-            (*in)->pOverlapped = (OVERLAPPED*) apr_pcalloc(p, sizeof(OVERLAPPED));
+            (*in)->pOverlapped =
+                    (OVERLAPPED*) apr_pcalloc((*in)->pool, sizeof(OVERLAPPED));
             (*in)->pOverlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
             (*in)->timeout = 0;
         }
@@ -179,7 +189,8 @@
         if (blocking == APR_READ_BLOCK /* WRITE_NONBLOCK */
                 || blocking == APR_FULL_NONBLOCK) {
             dwOpenMode |= FILE_FLAG_OVERLAPPED;
-            (*out)->pOverlapped = (OVERLAPPED*) apr_pcalloc(p, sizeof(OVERLAPPED));
+            (*out)->pOverlapped =
+                    (OVERLAPPED*) apr_pcalloc((*out)->pool, sizeof(OVERLAPPED));
             (*out)->pOverlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
             (*out)->timeout = 0;
         }
diff --git a/include/apr_file_io.h b/include/apr_file_io.h
index ea5c66f..59a502d 100644
--- a/include/apr_file_io.h
+++ b/include/apr_file_io.h
@@ -714,7 +714,7 @@
  * @bug  Some platforms cannot toggle between blocking and nonblocking,
  * and when passing a pipe as a standard handle to an application which
  * does not expect it, a non-blocking stream will fluxor the client app.
- * @deprecated @see apr_file_pipe_create_ex()
+ * @deprecated @see apr_file_pipe_create_pools()
  */
 APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, 
                                                apr_file_t **out,
@@ -738,6 +738,7 @@
  * does not expect it, a non-blocking stream will fluxor the client app.
  * Use this function rather than apr_file_pipe_create() to create pipes 
  * where one or both ends require non-blocking semantics.
+ * @deprecated @see apr_file_pipe_create_pools()
  */
 APR_DECLARE(apr_status_t) apr_file_pipe_create_ex(apr_file_t **in, 
                                                   apr_file_t **out, 
@@ -745,6 +746,33 @@
                                                   apr_pool_t *pool);
 
 /**
+ * Create an anonymous pipe which portably supports async timeout options,
+ * placing each side of the pipe in a different pool.
+ * @param in The newly created pipe's file for reading.
+ * @param out The newly created pipe's file for writing.
+ * @param blocking one of these values defined in apr_thread_proc.h;
+ *                 @li #APR_FULL_BLOCK
+ *                 @li #APR_READ_BLOCK
+ *                 @li #APR_WRITE_BLOCK
+ *                 @li #APR_FULL_NONBLOCK
+ * @param pool_in The pool for the reading pipe.
+ * @param pool_out The pool for the writing pipe.
+ * @remark By default, the returned file descriptors will be inherited
+ * by child processes created using apr_proc_create().  This can be
+ * changed using apr_file_inherit_unset().
+ * @remark Some platforms cannot toggle between blocking and nonblocking,
+ * and when passing a pipe as a standard handle to an application which
+ * does not expect it, a non-blocking stream will fluxor the client app.
+ * Use this function rather than apr_file_pipe_create() to create pipes
+ * where one or both ends require non-blocking semantics.
+ */
+APR_DECLARE(apr_status_t) apr_file_pipe_create_pools(apr_file_t **in,
+                                                     apr_file_t **out,
+                                                     apr_int32_t blocking,
+                                                     apr_pool_t *pool_in,
+                                                     apr_pool_t *pool_out);
+
+/**
  * Create a named pipe.
  * @param filename The filename of the named pipe
  * @param perm The permissions for the newly created pipe.
diff --git a/test/testpipe.c b/test/testpipe.c
index d15eacf..810ffe7 100644
--- a/test/testpipe.c
+++ b/test/testpipe.c
@@ -56,7 +56,7 @@
     apr_status_t rv;
     apr_interval_time_t timeout;
 
-    rv = apr_file_pipe_create_ex(&readp, &writep, APR_WRITE_BLOCK, p);
+    rv = apr_file_pipe_create_pools(&readp, &writep, APR_WRITE_BLOCK, p, p);
     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
     ABTS_PTR_NOTNULL(tc, readp);
     ABTS_PTR_NOTNULL(tc, writep);
@@ -83,7 +83,7 @@
     nbytes = strlen("this is a test");
     buf = (char *)apr_palloc(p, nbytes + 1);
 
-    rv = apr_file_pipe_create_ex(&readp, &writep, APR_WRITE_BLOCK, p);
+    rv = apr_file_pipe_create_pools(&readp, &writep, APR_WRITE_BLOCK, p, p);
     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
     ABTS_PTR_NOTNULL(tc, readp);
     ABTS_PTR_NOTNULL(tc, writep);