1 /*
2  * Copyright (c) 2000, 2001, 2002, 2003, 2004 by Martin C. Shepherd.
3  *
4  * All rights reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the
8  * "Software"), to deal in the Software without restriction, including
9  * without limitation the rights to use, copy, modify, merge, publish,
10  * distribute, and/or sell copies of the Software, and to permit persons
11  * to whom the Software is furnished to do so, provided that the above
12  * copyright notice(s) and this permission notice appear in all copies of
13  * the Software and that both the above copyright notice(s) and this
14  * permission notice appear in supporting documentation.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
19  * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
20  * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
21  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
22  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
23  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
24  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
25  *
26  * Except as contained in this notice, the name of a copyright holder
27  * shall not be used in advertising or otherwise to promote the sale, use
28  * or other dealings in this Software without prior written authorization
29  * of the copyright holder.
30  */
31 
32 #pragma ident	"%Z%%M%	%I%	%E% SMI"
33 
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <errno.h>
37 
38 #include "strngmem.h"
39 #include "freelist.h"
40 
41 struct StringMem {
42   unsigned long nmalloc;  /* The number of strings allocated with malloc */
43   FreeList *fl;           /* The free-list */
44 };
45 
46 /*.......................................................................
47  * Create a string free-list container and the first block of its free-list.
48  *
49  * Input:
50  *  blocking_factor   int    The blocking_factor argument specifies how
51  *                           many strings of length SM_STRLEN
52  *                           bytes (see stringmem.h) are allocated in each
53  *                           free-list block.
54  *                           For example if blocking_factor=64 and
55  *                           SM_STRLEN=16, then each new
56  *                           free-list block will take 1K of memory.
57  * Output:
58  *  return      StringMem *  The new free-list container, or NULL on
59  *                           error.
60  */
_new_StringMem(unsigned blocking_factor)61 StringMem *_new_StringMem(unsigned blocking_factor)
62 {
63   StringMem *sm;    /* The container to be returned. */
64 /*
65  * Check arguments.
66  */
67   if(blocking_factor < 1) {
68     errno = EINVAL;
69     return NULL;
70   };
71 /*
72  * Allocate the container.
73  */
74   sm = (StringMem *) malloc(sizeof(StringMem));
75   if(!sm) {
76     errno = ENOMEM;
77     return NULL;
78   };
79 /*
80  * Before attempting any operation that might fail, initialize
81  * the container at least up to the point at which it can safely
82  * be passed to _del_StringMem().
83  */
84   sm->nmalloc = 0;
85   sm->fl = NULL;
86 /*
87  * Allocate the free-list.
88  */
89   sm->fl = _new_FreeList(SM_STRLEN, blocking_factor);
90   if(!sm->fl)
91     return _del_StringMem(sm, 1);
92 /*
93  * Return the free-list container.
94  */
95   return sm;
96 }
97 
98 /*.......................................................................
99  * Delete a string free-list.
100  *
101  * Input:
102  *  sm       StringMem *  The string free-list to be deleted, or NULL.
103  *  force          int    If force==0 then _del_StringMem() will complain
104  *                         and refuse to delete the free-list if any
105  *                         of nodes have not been returned to the free-list.
106  *                        If force!=0 then _del_StringMem() will not check
107  *                         whether any nodes are still in use and will
108  *                         always delete the list.
109  * Output:
110  *  return   StringMem *  Always NULL (even if the list couldn't be
111  *                        deleted).
112  */
_del_StringMem(StringMem * sm,int force)113 StringMem *_del_StringMem(StringMem *sm, int force)
114 {
115   if(sm) {
116 /*
117  * Check whether any strings have not been returned to the free-list.
118  */
119     if(!force && (sm->nmalloc > 0 || _busy_FreeListNodes(sm->fl) > 0)) {
120       errno = EBUSY;
121       return NULL;
122     };
123 /*
124  * Delete the free-list.
125  */
126     sm->fl = _del_FreeList(sm->fl, force);
127 /*
128  * Delete the container.
129  */
130     free(sm);
131   };
132   return NULL;
133 }
134 
135 /*.......................................................................
136  * Allocate an array of 'length' chars.
137  *
138  * Input:
139  *  sm      StringMem *  The string free-list to allocate from.
140  *  length     size_t    The length of the new string (including '\0').
141  * Output:
142  *  return       char *  The new string or NULL on error.
143  */
_new_StringMemString(StringMem * sm,size_t length)144 char *_new_StringMemString(StringMem *sm, size_t length)
145 {
146   char *string;   /* The string to be returned */
147   int was_malloc; /* True if malloc was used to allocate the string */
148 /*
149  * Check arguments.
150  */
151   if(!sm)
152     return NULL;
153   if(length < 1)
154     length = 1;
155 /*
156  * Allocate the new node from the free list if possible.
157  */
158   if(length < SM_STRLEN) {
159     string = (char *)_new_FreeListNode(sm->fl);
160     if(!string)
161       return NULL;
162     was_malloc = 0;
163   } else {
164     string = (char *) malloc(length+1); /* Leave room for the flag byte */
165     if(!string)
166       return NULL;
167 /*
168  * Count malloc allocations.
169  */
170     was_malloc = 1;
171     sm->nmalloc++;
172   };
173 /*
174  * Use the first byte of the string to record whether the string was
175  * allocated with malloc or from the free-list. Then return the rest
176  * of the string for use by the user.
177  */
178   string[0] = (char) was_malloc;
179   return string + 1;
180 }
181 
182 /*.......................................................................
183  * Free a string that was previously returned by _new_StringMemString().
184  *
185  * Input:
186  *  sm      StringMem *  The free-list from which the string was originally
187  *                       allocated.
188  *  s            char *  The string to be returned to the free-list, or NULL.
189  * Output:
190  *  return       char *  Always NULL.
191  */
_del_StringMemString(StringMem * sm,char * s)192 char *_del_StringMemString(StringMem *sm, char *s)
193 {
194   int was_malloc;  /* True if the string originally came from malloc() */
195 /*
196  * Is there anything to be deleted?
197  */
198   if(s && sm) {
199 /*
200  * Retrieve the true string pointer. This is one less than the one
201  * returned by _new_StringMemString() because the first byte of the
202  * allocated memory is reserved by _new_StringMemString as a flag byte
203  * to say whether the memory was allocated from the free-list or directly
204  * from malloc().
205  */
206     s--;
207 /*
208  * Get the origination flag.
209  */
210     was_malloc = s[0];
211     if(was_malloc) {
212       free(s);
213       s = NULL;
214       sm->nmalloc--;
215     } else {
216       s = (char *) _del_FreeListNode(sm->fl, s);
217     };
218   };
219   return NULL;
220 }
221