dlls/wsdapi/memory.c

   1 /*
   2  * Web Services on Devices
   3  *
   4  * Copyright 2017 Owen Rudge for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wine/debug.h"
  28 #include "wine/list.h"
  29 #include "wsdapi.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wsdapi);
  32
  33 #define MEMORY_ALLOCATION_MAGIC     0xB10C5EED
  34
  35 #define ALIGNMENT                   (2 * sizeof(void*))
  36 #define ROUND_TO_ALIGNMENT(size)    (((size) + ALIGNMENT - 1) & ~(ALIGNMENT - 1))
  37 #define MEMORY_ALLOCATION_SIZE      ROUND_TO_ALIGNMENT(sizeof(struct memory_allocation))
  38
  39 struct memory_allocation
  40 {
  41     int magic;
  42     struct list entry;
  43
  44     struct list children;
  45 };
  46
  47 static struct memory_allocation *find_allocation(void *ptr)
  48 {
  49     struct memory_allocation *allocation;
  50
  51     if (ptr == NULL)
  52     {
  53         return NULL;
  54     }
  55
  56     allocation = (struct memory_allocation *)((char *)ptr - MEMORY_ALLOCATION_SIZE);
  57
  58     if (allocation->magic != MEMORY_ALLOCATION_MAGIC)
  59     {
  60         return NULL;
  61     }
  62
  63     return allocation;
  64 }
  65
  66 static void free_allocation(struct memory_allocation *item)
  67 {
  68     struct memory_allocation *child, *cursor;
  69
  70     LIST_FOR_EACH_ENTRY_SAFE(child, cursor, &item->children, struct memory_allocation, entry)
  71     {
  72         free_allocation(child);
  73     }
  74
  75     list_remove(&item->entry);
  76     item->magic = 0;
  77     HeapFree(GetProcessHeap(), 0, item);
  78 }
  79
  80 void * WINAPI WSDAllocateLinkedMemory(void *pParent, SIZE_T cbSize)
  81 {
  82     struct memory_allocation *allocation, *parent;
  83     void *ptr;
  84
  85     TRACE("(%p, %lu)\n", pParent, cbSize);
  86
  87     ptr = HeapAlloc(GetProcessHeap(), 0, MEMORY_ALLOCATION_SIZE + cbSize);
  88
  89     if (ptr == NULL)
  90     {
  91         return NULL;
  92     }
  93
  94     allocation = ptr;
  95     allocation->magic = MEMORY_ALLOCATION_MAGIC;
  96
  97     list_init(&allocation->children);
  98
  99     /* See if we have a parent */
 100     parent = find_allocation(pParent);
 101
 102     if (parent != NULL)
 103     {
 104         list_add_tail(&parent->children, &allocation->entry);
 105     }
 106     else
 107     {
 108         list_init(&allocation->entry);
 109     }
 110
 111     return (char *)ptr + MEMORY_ALLOCATION_SIZE;
 112 }
 113
 114 void WINAPI WSDAttachLinkedMemory(void *pParent, void *pChild)
 115 {
 116     struct memory_allocation *parent, *child;
 117
 118     TRACE("(%p, %p)\n", pParent, pChild);
 119
 120     child = find_allocation(pChild);
 121     parent = find_allocation(pParent);
 122
 123     TRACE("child: %p, parent: %p\n", child, parent);
 124
 125     if ((child == NULL) || (parent == NULL))
 126     {
 127         return;
 128     }
 129
 130     list_remove(&child->entry);
 131     list_add_tail(&parent->children, &child->entry);
 132 }
 133
 134 void WINAPI WSDDetachLinkedMemory(void *pVoid)
 135 {
 136     struct memory_allocation *allocation;
 137
 138     TRACE("(%p)\n", pVoid);
 139
 140     allocation = find_allocation(pVoid);
 141
 142     if (allocation == NULL)
 143     {
 144         TRACE("Memory allocation not found\n");
 145         return;
 146     }
 147
 148     list_remove(&allocation->entry);
 149 }
 150
 151 void WINAPI WSDFreeLinkedMemory(void *pVoid)
 152 {
 153     struct memory_allocation *allocation;
 154
 155     TRACE("(%p)\n", pVoid);
 156
 157     allocation = find_allocation(pVoid);
 158
 159     if (allocation == NULL)
 160     {
 161         TRACE("Memory allocation not found\n");
 162         return;
 163     }
 164
 165     free_allocation(allocation);
 166 }