1 files changed, 51 insertions, 17 deletions

diff --git a/src/microhttpd/memorypool.c b/src/microhttpd/memorypool.c
index c5e5b4fd..fb6c0652 100644
--- a/src/microhttpd/memorypool.c
+++ b/src/microhttpd/memorypool.c
@@ -105,22 +105,6 @@ MHD_init_mem_pools_ (void)
 
 
 /**
- * Get the real size that would be allocated by the memory pool when
- * requested to allocate @a size.
- * @param size the size of memory area that would be rounded up to the
- *             allocation granularity
- * @return the size that would be allocated by #MHD_pool_allocate() when
- *         requested to allocate @a size. It is also minimal size of free
- *         space in the pool required to #MHD_pool_allocate() succeed.
- */
-size_t
-MHD_pool_alloc_size (size_t size)
-{
-  return ROUND_TO_ALIGN (size);
-}
-
-
-/**
  * Handle for a memory pool.  Pools are not reentrant and must not be
  * used by multiple threads.
  */
@@ -312,6 +296,56 @@ MHD_pool_allocate (struct MemoryPool *pool,
 
 
 /**
+ * Try to allocate @a size bytes memory area from the @a pool.
+ *
+ * If allocation fails, @a required_bytes is updated with size required to be
+ * freed in the @a pool from relocatable area to allocate requested number
+ * of bytes.
+ * Allocated memory area is always not rellocatable ("from end").
+ *
+ * @param pool memory pool to use for the operation
+ * @param size the size of memory in bytes to allocate
+ * @param[out] required_bytes the pointer to variable to be updated with
+ *                            the size of the required additional free
+ *                            memory area, not updated if function succeed.
+ *                            Cannot be NULL.
+ * @return the pointer to allocated memory area if succeed,
+ *         NULL if the pool doesn't have enough space, required_bytes is updated
+ *         with amount of space needed to be freed in relocatable area or
+ *         set to SIZE_MAX if requested size is too large for the pool.
+ */
+void *
+MHD_pool_try_alloc (struct MemoryPool *pool,
+                    size_t size,
+                    size_t *required_bytes)
+{
+  void *ret;
+  size_t asize;
+
+  mhd_assert (pool->end >= pool->pos);
+  mhd_assert (pool->size >= pool->end - pool->pos);
+  asize = ROUND_TO_ALIGN (size);
+  if ( (0 == asize) && (0 != size) )
+  { /* size is too close to SIZE_MAX, very unlikely */
+    *required_bytes = SIZE_MAX;
+    return NULL;
+  }
+  if ( (pool->pos + asize > pool->end) ||
+       (pool->pos + asize < pool->pos))
+  {
+    if (asize <= pool->end)
+      *required_bytes = asize - (pool->end - pool->pos);
+    else
+      *required_bytes = SIZE_MAX;
+    return NULL;
+  }
+  ret = &pool->memory[pool->end - asize];
+  pool->end -= asize;
+  return ret;
+}
+
+
+/**
  * Reallocate a block of memory obtained from the pool.
  * This is particularly efficient when growing or
  * shrinking the block that was last (re)allocated.
@@ -355,7 +389,7 @@ MHD_pool_reallocate (struct MemoryPool *pool,
               pool->end);
 
   if (0 != old_size)
-  {   /* Need to save some data */
+  {   /* Have previously allocated data */
     const size_t old_offset = (uint8_t*) old - pool->memory;
     const bool shrinking = (old_size > new_size);
     /* Try resizing in-place */