cde/lib/csa/free.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $XConsortium: free.c /main/1 1996/04/21 19:23:16 drk $ */
  24 /*
  25  *  (c) Copyright 1993, 1994 Hewlett-Packard Company
  26  *  (c) Copyright 1993, 1994 International Business Machines Corp.
  27  *  (c) Copyright 1993, 1994 Novell, Inc.
  28  *  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
  29  */
  30
  31 #include <EUSCompat.h>
  32 #include <stdlib.h>
  33 #include "csa.h"
  34 #include "free.h"
  35
  36 #define _DtCM_OUR_MEMORY        0x55555555
  37
  38 typedef void (*_DtCmFreeProc)(uint num_elem, void *ptr);
  39
  40 typedef struct {
  41         int             mark;
  42         uint            num_elem;
  43         _DtCmFreeProc   fproc;
  44 } _DtCmMemHeader;
  45
  46 /******************************************************************************
  47  * forward declaration of static functions used within the file
  48  ******************************************************************************/
  49 static void _DtCm_free_calendar_users(uint num_elem, void *vptr);
  50
  51 /*****************************************************************************
  52  * extern functions used in the library
  53  *****************************************************************************/
  54
  55 extern CSA_calendar_user *
  56 _DtCm_alloc_calendar_users(uint num_elem)
  57 {
  58         char *ptr;
  59         _DtCmMemHeader  *hptr;
  60
  61         if ((ptr = calloc(1, sizeof(_DtCmMemHeader) +
  62             sizeof(CSA_calendar_user) * num_elem)) == NULL)
  63                 return (NULL);
  64         else {
  65                 hptr = (_DtCmMemHeader *)ptr;
  66                 hptr->mark = _DtCM_OUR_MEMORY;
  67                 hptr->num_elem = num_elem;
  68                 hptr->fproc = _DtCm_free_calendar_users;
  69                 return ((CSA_calendar_user *)(ptr + sizeof(_DtCmMemHeader)));
  70         }
  71 }
  72
  73 extern char **
  74 _DtCm_alloc_character_pointers(uint num_elem)
  75 {
  76         char *ptr;
  77         _DtCmMemHeader  *hptr;
  78
  79         if ((ptr = calloc(1, sizeof(_DtCmMemHeader) +
  80             sizeof(char *) * num_elem)) == NULL)
  81                 return (NULL);
  82         else {
  83                 hptr = (_DtCmMemHeader *)ptr;
  84                 hptr->mark = _DtCM_OUR_MEMORY;
  85                 hptr->num_elem = num_elem;
  86                 hptr->fproc = _DtCm_free_character_pointers;
  87                 return ((char **)(ptr + sizeof(_DtCmMemHeader)));
  88         }
  89 }
  90
  91 extern CSA_attribute *
  92 _DtCm_alloc_attributes(uint num_elem)
  93 {
  94         char *ptr;
  95         _DtCmMemHeader  *hptr;
  96         extern void _DtCm_free_attributes(uint size, void *attrs);
  97
  98         if ((ptr = calloc(1, sizeof(_DtCmMemHeader) +
  99             sizeof(CSA_attribute) * num_elem)) == NULL)
 100                 return (NULL);
 101         else {
 102                 hptr = (_DtCmMemHeader *)ptr;
 103                 hptr->mark = _DtCM_OUR_MEMORY;
 104                 hptr->num_elem = num_elem;
 105                 hptr->fproc = _DtCm_free_attributes;
 106                 return ((CSA_attribute *)(ptr + sizeof(_DtCmMemHeader)));
 107         }
 108 }
 109
 110 extern CSA_entry_handle *
 111 _DtCm_alloc_entry_handles(uint num_elem)
 112 {
 113         char *ptr;
 114         _DtCmMemHeader  *hptr;
 115         extern void _DtCm_free_entry_handles(uint num_entries, void *entries);
 116
 117         if ((ptr = calloc(1, sizeof(_DtCmMemHeader) +
 118             sizeof(CSA_entry_handle) * num_elem)) == NULL)
 119                 return (NULL);
 120         else {
 121                 hptr = (_DtCmMemHeader *)ptr;
 122                 hptr->mark = _DtCM_OUR_MEMORY;
 123                 hptr->num_elem = num_elem;
 124                 hptr->fproc = _DtCm_free_entry_handles;
 125                 return ((CSA_entry_handle *)(ptr + sizeof(_DtCmMemHeader)));
 126         }
 127 }
 128
 129 extern void *
 130 _DtCm_alloc_entry(uint size)
 131 {
 132         char *ptr;
 133         _DtCmMemHeader  *hptr;
 134         extern void _DtCm_free_entry_content(uint dummy, void *entry);
 135
 136         if ((ptr = calloc(1, sizeof(_DtCmMemHeader) + size)) == NULL)
 137                 return (NULL);
 138         else {
 139                 hptr = (_DtCmMemHeader *)ptr;
 140                 hptr->mark = _DtCM_OUR_MEMORY;
 141                 hptr->num_elem = 1;
 142                 hptr->fproc = _DtCm_free_entry_content;
 143                 return ((void *)(ptr + sizeof(_DtCmMemHeader)));
 144         }
 145 }
 146
 147 extern CSA_reminder_reference *
 148 _DtCm_alloc_reminder_references(uint num_elem)
 149 {
 150         char *ptr;
 151         _DtCmMemHeader  *hptr;
 152         extern void _DtCm_free_reminder_references(uint num_rems, void *rems);
 153
 154         if ((ptr = calloc(1, sizeof(_DtCmMemHeader) +
 155             sizeof(CSA_reminder_reference) * num_elem)) == NULL)
 156                 return (NULL);
 157         else {
 158                 hptr = (_DtCmMemHeader *)ptr;
 159                 hptr->mark = _DtCM_OUR_MEMORY;
 160                 hptr->num_elem = num_elem;
 161                 hptr->fproc = _DtCm_free_reminder_references;
 162                 return ((CSA_reminder_reference *)(ptr +
 163                         sizeof(_DtCmMemHeader)));
 164         }
 165 }
 166
 167 extern CSA_return_code
 168 _DtCm_free(void *ptr)
 169 {
 170         _DtCmMemHeader *hptr;
 171
 172         if (ptr == NULL)
 173                 return (CSA_E_INVALID_MEMORY);
 174
 175         hptr = (_DtCmMemHeader *)(((char *)ptr) - sizeof(_DtCmMemHeader));
 176
 177         if (hptr->mark != _DtCM_OUR_MEMORY)
 178                 return (CSA_E_INVALID_MEMORY);
 179         else {
 180                 hptr->mark = 0;
 181                 hptr->fproc(hptr->num_elem, ptr);
 182                 free(hptr);
 183                 return (CSA_SUCCESS);
 184         }
 185 }
 186
 187 extern void
 188 _DtCm_free_character_pointers(uint num_elem, void *vptr)
 189 {
 190         char **ptr = (char **)vptr;
 191         int     i;
 192
 193         for (i = 0; i < num_elem; i++) {
 194                 if (ptr[i])
 195                         free(ptr[i]);
 196                 else
 197                         break;
 198         }
 199 }
 200
 201 /******************************************************************************
 202  * static functions used within in the file
 203  ******************************************************************************/
 204
 205 static void
 206 _DtCm_free_calendar_users(uint num_elem, void *vptr)
 207 {
 208         CSA_calendar_user *ptr = (CSA_calendar_user *)vptr;
 209         int     i;
 210
 211         for (i = 0; i < num_elem; i++) {
 212                 if (ptr[i].user_name)
 213                         free(ptr[i].user_name);
 214
 215                 if (ptr[i].calendar_address)
 216                         free(ptr[i].calendar_address);
 217         }
 218 }
 219