[apple/libc.git] / sys / fix-3375657.c

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

/*
 * When mutexes or spinlocks were added for thread safety, the system would
 * hang during the boot process, just after changing to the blue background.
 * So for the common case of not calling _s[eh]m_hack_{add,init}(), we just
 * use static name lists.  This should be reinvestigated when there is time.
 */

#define PRIVATE		__private_extern__
//#define SEM_DEBUG_FILE	"/tmp/sem_names"
//#define SHM_DEBUG_FILE	"/tmp/shm_names"

#if defined(SEM_DEBUG_FILE) || defined(SHM_DEBUG_FILE)
#include <stdio.h>
#include <unistd.h>
#endif /* defined(SEM_DEBUG_FILE) || defined(SHM_DEBUG_FILE) */
#include <stdlib.h>
#include <string.h>
#include <stdlib.h>

#ifdef SEM_DEBUG_FILE
#define SEM_PRINTF(fmt, args...) \
{ \
	FILE *_sem_fp_; \
	if (access(SEM_DEBUG_FILE, F_OK) == 0 && \
	    (_sem_fp_ = fopen(SEM_DEBUG_FILE, "a")) != NULL) { \
		fprintf(_sem_fp_, fmt, ## args); \
		fclose(_sem_fp_); \
	} \
}
#endif /* SEM_DEBUG_FILE */
#ifdef SHM_DEBUG_FILE
#define SHM_PRINTF(fmt, args...) \
{ \
	FILE *_shm_fp_; \
	if (access(SHM_DEBUG_FILE, F_OK) == 0 && \
	    (_shm_fp_ = fopen(SHM_DEBUG_FILE, "a")) != NULL) { \
		fprintf(_shm_fp_, fmt, ## args); \
		fclose(_shm_fp_); \
	} \
}
#endif /* SHM_DEBUG_FILE */

/*-----------------------------------------------------------------------
 * For the Hack structure:
 *
 * first >= 0	starting serial number
 * first < 0	no serial number
 * last		ending serial number (only if first >= 0)
 * debug	whether an option 'D' can be appended
 *-----------------------------------------------------------------------*/
typedef struct {
	const char *name;
	int first;
	int last;
	int debug;
} Hack;

/*-----------------------------------------------------------------------
 * For the HackList structure:
 *
 * list		the list of Hack structures
 * cur		the number of valid Hack structures in list
 * max		the actual number of Hack structures allocated
 *-----------------------------------------------------------------------*/
#define	HACKLISTDELTA	16
#define	HACKLISTSTART	16
typedef struct {
	const Hack *list;
	int cur;
	int max;
} HackList;

static const Hack sem_hack_default_names[] = {
	{"EDBPool", 1, 255, 0},
	{"EDDPoolLock", -1, 0, 0},
	{"Mso97SharedDg", 1920, 2047, 1},
	{"Office", 1920, 2047, 1},
	{"PT_EDBPool", 1, 255, 0},
	{"PT_EDDPoolLock", -1, 0, 0},
	{"PT_Mso97SharedDg", 1920, 2047, 0},
	{"PT_Office", 1920, 2047, 0},
	{"ShMemExtCritSection", -1, 0, 0},
	{"ShMemIntCritSection", -1, 0, 0},
	{NULL, 0, 0, 0},
};
static HackList sem_hack_defaults = {
	sem_hack_default_names,
	(sizeof(sem_hack_default_names) / sizeof(const Hack)) - 1,
	0
};
static HackList *sem_hack_names = &sem_hack_defaults;

static const Hack shm_hack_default_names[] = {
	{"EDBPool", 1, 255, 0},
	{"EDDPoolLock", -1, 0, 0},
	{"Mso97SharedDg", 1920, 2047, 1},
	{"Office", 1920, 2047, 1},
	{"PT_EDBPool", 1, 255, 0},
	{"PT_EDDPoolLock", -1, 0, 0},
	{"PT_Mso97SharedDg", 1920, 2047, 0},
	{"PT_Office", 1920, 2047, 0},
	{"PT_ShMemRefCount", -1, 0, 0},	/* not specified by MS, but seen */
	{"ShMemRefCount", -1, 0, 0},
	{NULL, 0, 0, 0},
};
static HackList shm_hack_defaults = {
	shm_hack_default_names,
	(sizeof(shm_hack_default_names) / sizeof(const Hack)) - 1,
	0
};
static HackList *shm_hack_names = &shm_hack_defaults;

static int comparkey(const void *key, const void *hname);
static int comparstr(const void *a, const void *b);
static int dosearch(const char *name, const HackList *hl);
static int hl_add(HackList *hl, const Hack *h);
static void hl_free(HackList *hl);
static HackList *hl_init(void);
static HackList *initList(const Hack *list);
int _sem_hack_add(const Hack *list);
void _sem_hack_init(void);
PRIVATE int _sem_match(const char *name);
int _shm_hack_add(const Hack *list);
void _shm_hack_init(void);
PRIVATE int _shm_match(const char *name);

/*-----------------------------------------------------------------------
 * comparkey - used by bsearch to find the Hack structure with the given key
 *-----------------------------------------------------------------------*/
static int
comparkey(const void *key, const void *h)
{
	return strcmp(key, ((const Hack *)h)->name);
}

/*-----------------------------------------------------------------------
 * comparstr - used by qsort to sort the Hack list
 *-----------------------------------------------------------------------*/
static int
comparstr(const void *a, const void *b)
{
	return strcmp(((const Hack *)a)->name, ((const Hack *)b)->name);
}

/*-----------------------------------------------------------------------
 * dosearch - search of the given name in the given HackList.  First see
 * if there is a trailing D, and a serial number.  If the serial number
 * exists, try to match without the serial number, checking the series
 * range and whether the trailing D is allowed.  Otherwise, try to match
 * the whole string, but check if the matched Hack structure requires a
 * serial number.
 *-----------------------------------------------------------------------*/
static int
dosearch(const char *name, const HackList *hl)
{
	int series;
	int len = strlen(name);
	const char *end, *p;
	char *key;
	const Hack *h;

	end = name + len - 1;
	if (*end != 'D')
		end++;
	p = end - 1;
	while (p >= name && *p >= '0' && *p <= '9')
		p--;
	p++;
	if (p < end && (len = p - name) > 0) {
		key = alloca(len + 1);
		if (key) {
			series = atoi(p);
			strncpy(key, name, len);
			key[len] = 0;
			h = (const Hack *)bsearch(key, hl->list, hl->cur,
			    sizeof(const Hack), comparkey);
			if (h && h->first >= 0
			    && series >= h->first && series <= h->last
			    && (*end == 0 || h->debug))
				return 1;
		}
	}
	h = (const Hack *)bsearch(name, hl->list, hl->cur, sizeof(const Hack),
	    comparkey);
	return (h && h->first < 0);
}

/*-----------------------------------------------------------------------
 * hl_add - append to the given HackList a copy of the given Hack structure
 *-----------------------------------------------------------------------*/
static int
hl_add(HackList *hl, const Hack *c)
{
	int i = hl->cur;
	Hack *h;

	if (!c->name)
		return -1;
	if (i >= hl->max) {
		int s = hl->max + HACKLISTDELTA;
		const Hack *new = (const Hack *)realloc((void *)hl->list,
		    s * sizeof(const Hack));

		if (!new)
			return -1;
		hl->list = new;
		hl->max = s;
	}
	h = (Hack *)(hl->list + i);
	if ((h->name = strdup(c->name)) == NULL)
		return -1;
	h->first = c->first;
	h->last = c->last;
	h->debug = c->debug;
	hl->cur++;
	return 0;
}

/*-----------------------------------------------------------------------
 * hl_free - deallocate all memory from the given HackList
 *-----------------------------------------------------------------------*/
static void
hl_free(HackList *hl)
{
	const Hack *h;
	int i;

	for (h = hl->list, i = hl->cur; i > 0; h++, i--)
		free((void *)h->name);
	free((void *)hl->list);
	free(hl);
}

/*-----------------------------------------------------------------------
 * hl_init - create a new HackList, with preallocated Hack structures
 *-----------------------------------------------------------------------*/
static HackList *
hl_init(void)
{
	HackList *hl = (HackList *)malloc(sizeof(HackList));

	if (!hl)
		return NULL;
	hl->list = (Hack *)malloc(HACKLISTSTART * sizeof(Hack));
	if (!hl->list) {
		free(hl);
		return NULL;
	}
	hl->cur = 0;
	hl->max = HACKLISTSTART;
	return hl;
}

/*-----------------------------------------------------------------------
 * initList - initialize a new HackList with the given list of Hack structures
 *-----------------------------------------------------------------------*/
static HackList *
initList(const Hack *list)
{
	HackList *hl = hl_init();

	if (hl == NULL)
		return NULL;
	for (; list->name; list++)
		if (hl_add(hl, list) < 0) {
			hl_free(hl);
			return NULL;
		}
	return hl;
}

/*-----------------------------------------------------------------------
 * PUBLIC _sem_hack_add - add the given Hack list to sem_hack_names.
 *-----------------------------------------------------------------------*/
int
_sem_hack_add(const Hack *list)
{
	if (list == NULL)
		return -1;
	if (sem_hack_names == &sem_hack_defaults) {
		HackList *hl = initList(sem_hack_default_names);
		if (!hl)
			return -1;
		sem_hack_names = hl;
	}
	for (; list->name; list++)
		if (hl_add(sem_hack_names, list) < 0)
			return -1;
	qsort((void *)sem_hack_names->list, sem_hack_names->cur,
	    sizeof(const Hack), comparstr);
	return 0;
}

/*-----------------------------------------------------------------------
 * PUBLIC _sem_hack_init - reinitialize sem_hack_names to the default
 *-----------------------------------------------------------------------*/
void
_sem_hack_init(void)
{
	if (sem_hack_names == &sem_hack_defaults)
		return;
	hl_free(sem_hack_names);
	sem_hack_names = &sem_hack_defaults;
}

/*-----------------------------------------------------------------------
 * _sem_match - try to match the given named to sem_hack_names.  Called
 * by sem_open() and sem_unlink().
 *-----------------------------------------------------------------------*/
PRIVATE int
_sem_match(const char *name)
{
#ifdef SEM_DEBUG_FILE
	int match;
#endif /* SEM_DEBUG_FILE */

	if (!name || !*name)
		return 0;
#ifdef SEM_DEBUG_FILE
	match = dosearch(name, sem_hack_names);
	if (!match)
		SEM_PRINTF("%s\n", name);
	return match;
#else /* SEM_DEBUG_FILE */
	return dosearch(name, sem_hack_names);
#endif /* SEM_DEBUG_FILE */
}

/*-----------------------------------------------------------------------
 * PUBLIC _shm_hack_add - add the given Hack list to shm_hack_names.
 *-----------------------------------------------------------------------*/
int
_shm_hack_add(const Hack *list)
{
	if (list == NULL)
		return -1;
	if (shm_hack_names == &shm_hack_defaults) {
		HackList *hl = initList(shm_hack_default_names);
		if (!hl)
			return -1;
		shm_hack_names = hl;
	}
	for (; list->name; list++)
		if (hl_add(shm_hack_names, list) < 0)
			return -1;
	qsort((void *)shm_hack_names->list, shm_hack_names->cur,
	    sizeof(const Hack), comparstr);
	return 0;
}

/*-----------------------------------------------------------------------
 * PUBLIC _shm_hack_init - reinitialize shm_hack_names to the default
 *-----------------------------------------------------------------------*/
void
_shm_hack_init(void)
{
	if (shm_hack_names == &shm_hack_defaults)
		return;
	hl_free(shm_hack_names);
	shm_hack_names = &shm_hack_defaults;
}

/*-----------------------------------------------------------------------
 * _shm_match - try to match the given named to shm_hack_names.  Called
 * by shm_open() and shm_unlink().
 *-----------------------------------------------------------------------*/
PRIVATE int
_shm_match(const char *name)
{
#ifdef SHM_DEBUG_FILE
	int match;
#endif /* SHM_DEBUG_FILE */

	if (!name || !*name)
		return 0;
#ifdef SHM_DEBUG_FILE
	match = dosearch(name, shm_hack_names);
	if (!match)
		SHM_PRINTF("%s\n", name);
	return match;
#else /* SHM_DEBUG_FILE */
	return dosearch(name, shm_hack_names);
#endif /* SHM_DEBUG_FILE */
}
Commit	Line	Data
9385eb3d A	1	/*
	2	* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
9385eb3d A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
9385eb3d A	24	/*
	25	* When mutexes or spinlocks were added for thread safety, the system would
	26	* hang during the boot process, just after changing to the blue background.
	27	* So for the common case of not calling _s[eh]m_hack_{add,init}(), we just
	28	* use static name lists. This should be reinvestigated when there is time.
	29	*/
	30
	31	#define PRIVATE __private_extern__
	32	//#define SEM_DEBUG_FILE "/tmp/sem_names"
	33	//#define SHM_DEBUG_FILE "/tmp/shm_names"
	34
	35	#if defined(SEM_DEBUG_FILE) \|\| defined(SHM_DEBUG_FILE)
	36	#include <stdio.h>
	37	#include <unistd.h>
	38	#endif /* defined(SEM_DEBUG_FILE) \|\| defined(SHM_DEBUG_FILE) */
	39	#include <stdlib.h>
	40	#include <string.h>
	41	#include <stdlib.h>
	42
	43	#ifdef SEM_DEBUG_FILE
	44	#define SEM_PRINTF(fmt, args...) \
	45	{ \
	46	FILE *_sem_fp_; \
	47	if (access(SEM_DEBUG_FILE, F_OK) == 0 && \
	48	(_sem_fp_ = fopen(SEM_DEBUG_FILE, "a")) != NULL) { \
	49	fprintf(_sem_fp_, fmt, ## args); \
	50	fclose(_sem_fp_); \
	51	} \
	52	}
	53	#endif /* SEM_DEBUG_FILE */
	54	#ifdef SHM_DEBUG_FILE
	55	#define SHM_PRINTF(fmt, args...) \
	56	{ \
	57	FILE *_shm_fp_; \
	58	if (access(SHM_DEBUG_FILE, F_OK) == 0 && \
	59	(_shm_fp_ = fopen(SHM_DEBUG_FILE, "a")) != NULL) { \
	60	fprintf(_shm_fp_, fmt, ## args); \
	61	fclose(_shm_fp_); \
	62	} \
	63	}
	64	#endif /* SHM_DEBUG_FILE */
	65
	66	/*-----------------------------------------------------------------------
	67	* For the Hack structure:
	68	*
	69	* first >= 0 starting serial number
	70	* first < 0 no serial number
	71	* last ending serial number (only if first >= 0)
	72	* debug whether an option 'D' can be appended
	73	-----------------------------------------------------------------------/
	74	typedef struct {
	75	const char *name;
	76	int first;
	77	int last;
	78	int debug;
	79	} Hack;
	80
	81	/*-----------------------------------------------------------------------
	82	* For the HackList structure:
	83	*
	84	* list the list of Hack structures
	85	* cur the number of valid Hack structures in list
	86	* max the actual number of Hack structures allocated
	87	-----------------------------------------------------------------------/
88	#define HACKLISTDELTA 16
89	#define HACKLISTSTART 16
90	typedef struct {
91	const Hack *list;
92	int cur;
93	int max;
94	} HackList;
95
96	static const Hack sem_hack_default_names[] = {
97	{"EDBPool", 1, 255, 0},
98	{"EDDPoolLock", -1, 0, 0},
99	{"Mso97SharedDg", 1920, 2047, 1},
100	{"Office", 1920, 2047, 1},
101	{"PT_EDBPool", 1, 255, 0},
102	{"PT_EDDPoolLock", -1, 0, 0},
103	{"PT_Mso97SharedDg", 1920, 2047, 0},
104	{"PT_Office", 1920, 2047, 0},
105	{"ShMemExtCritSection", -1, 0, 0},
106	{"ShMemIntCritSection", -1, 0, 0},
107	{NULL, 0, 0, 0},
108	};
109	static HackList sem_hack_defaults = {
110	sem_hack_default_names,
111	(sizeof(sem_hack_default_names) / sizeof(const Hack)) - 1,
112	0
113	};
114	static HackList *sem_hack_names = &sem_hack_defaults;
115
116	static const Hack shm_hack_default_names[] = {
117	{"EDBPool", 1, 255, 0},
118	{"EDDPoolLock", -1, 0, 0},
119	{"Mso97SharedDg", 1920, 2047, 1},
120	{"Office", 1920, 2047, 1},
121	{"PT_EDBPool", 1, 255, 0},
122	{"PT_EDDPoolLock", -1, 0, 0},
123	{"PT_Mso97SharedDg", 1920, 2047, 0},
124	{"PT_Office", 1920, 2047, 0},
125	{"PT_ShMemRefCount", -1, 0, 0}, /* not specified by MS, but seen */
126	{"ShMemRefCount", -1, 0, 0},
127	{NULL, 0, 0, 0},
128	};
129	static HackList shm_hack_defaults = {
130	shm_hack_default_names,
131	(sizeof(shm_hack_default_names) / sizeof(const Hack)) - 1,
132	0
133	};
134	static HackList *shm_hack_names = &shm_hack_defaults;
135
136	static int comparkey(const void key, const void hname);
137	static int comparstr(const void a, const void b);
138	static int dosearch(const char name, const HackList hl);
139	static int hl_add(HackList hl, const Hack h);
140	static void hl_free(HackList *hl);
141	static HackList *hl_init(void);
142	static HackList initList(const Hack list);
143	int _sem_hack_add(const Hack *list);
144	void _sem_hack_init(void);
145	PRIVATE int _sem_match(const char *name);
146	int _shm_hack_add(const Hack *list);
147	void _shm_hack_init(void);
148	PRIVATE int _shm_match(const char *name);
149
150	/*-----------------------------------------------------------------------
151	* comparkey - used by bsearch to find the Hack structure with the given key
152	-----------------------------------------------------------------------/
153	static int
154	comparkey(const void key, const void h)
155	{
156	return strcmp(key, ((const Hack *)h)->name);
157	}
158
159	/*-----------------------------------------------------------------------
160	* comparstr - used by qsort to sort the Hack list
161	-----------------------------------------------------------------------/
162	static int
163	comparstr(const void a, const void b)
164	{
165	return strcmp(((const Hack )a)->name, ((const Hack )b)->name);
166	}
167
168	/*-----------------------------------------------------------------------
169	* dosearch - search of the given name in the given HackList. First see
170	* if there is a trailing D, and a serial number. If the serial number
171	* exists, try to match without the serial number, checking the series
172	* range and whether the trailing D is allowed. Otherwise, try to match
173	* the whole string, but check if the matched Hack structure requires a
174	* serial number.
175	-----------------------------------------------------------------------/
176	static int
177	dosearch(const char name, const HackList hl)
178	{
179	int series;
180	int len = strlen(name);
181	const char end, p;
182	char *key;
183	const Hack *h;
184
185	end = name + len - 1;
186	if (*end != 'D')
187	end++;
188	p = end - 1;
189	while (p >= name && p >= '0' && p <= '9')
190	p--;
191	p++;
192	if (p < end && (len = p - name) > 0) {
193	key = alloca(len + 1);
194	if (key) {
195	series = atoi(p);
196	strncpy(key, name, len);
197	key[len] = 0;
198	h = (const Hack *)bsearch(key, hl->list, hl->cur,
199	sizeof(const Hack), comparkey);
200	if (h && h->first >= 0
201	&& series >= h->first && series <= h->last
202	&& (*end == 0 \|\| h->debug))
203	return 1;
204	}
205	}
206	h = (const Hack *)bsearch(name, hl->list, hl->cur, sizeof(const Hack),
207	comparkey);
208	return (h && h->first < 0);
209	}
210
211	/*-----------------------------------------------------------------------
212	* hl_add - append to the given HackList a copy of the given Hack structure
213	-----------------------------------------------------------------------/
214	static int
215	hl_add(HackList hl, const Hack c)
216	{
217	int i = hl->cur;
218	Hack *h;
219
220	if (!c->name)
221	return -1;
222	if (i >= hl->max) {
223	int s = hl->max + HACKLISTDELTA;
224	const Hack new = (const Hack )realloc((void *)hl->list,
225	s * sizeof(const Hack));
226
227	if (!new)
228	return -1;
229	hl->list = new;
230	hl->max = s;
231	}
232	h = (Hack *)(hl->list + i);
233	if ((h->name = strdup(c->name)) == NULL)
234	return -1;
235	h->first = c->first;
236	h->last = c->last;
237	h->debug = c->debug;
238	hl->cur++;
239	return 0;
240	}
241
242	/*-----------------------------------------------------------------------
243	* hl_free - deallocate all memory from the given HackList
244	-----------------------------------------------------------------------/
245	static void
246	hl_free(HackList *hl)
247	{
248	const Hack *h;
249	int i;
250
251	for (h = hl->list, i = hl->cur; i > 0; h++, i--)
252	free((void *)h->name);
253	free((void *)hl->list);
254	free(hl);
255	}
256
257	/*-----------------------------------------------------------------------
258	* hl_init - create a new HackList, with preallocated Hack structures
259	-----------------------------------------------------------------------/
260	static HackList *
261	hl_init(void)
262	{
263	HackList hl = (HackList )malloc(sizeof(HackList));
264
265	if (!hl)
266	return NULL;
267	hl->list = (Hack )malloc(HACKLISTSTART sizeof(Hack));
268	if (!hl->list) {
269	free(hl);
270	return NULL;
271	}
272	hl->cur = 0;
273	hl->max = HACKLISTSTART;
274	return hl;
275	}
276
277	/*-----------------------------------------------------------------------
278	* initList - initialize a new HackList with the given list of Hack structures
279	-----------------------------------------------------------------------/
280	static HackList *
281	initList(const Hack *list)
282	{
283	HackList *hl = hl_init();
284
285	if (hl == NULL)
286	return NULL;
287	for (; list->name; list++)
288	if (hl_add(hl, list) < 0) {
289	hl_free(hl);
290	return NULL;
291	}
292	return hl;
293	}
294
295	/*-----------------------------------------------------------------------
296	* PUBLIC _sem_hack_add - add the given Hack list to sem_hack_names.
297	-----------------------------------------------------------------------/
298	int
299	_sem_hack_add(const Hack *list)
300	{
301	if (list == NULL)
302	return -1;
303	if (sem_hack_names == &sem_hack_defaults) {
304	HackList *hl = initList(sem_hack_default_names);
305	if (!hl)
306	return -1;
307	sem_hack_names = hl;
308	}
309	for (; list->name; list++)
310	if (hl_add(sem_hack_names, list) < 0)
311	return -1;
312	qsort((void *)sem_hack_names->list, sem_hack_names->cur,
313	sizeof(const Hack), comparstr);
314	return 0;
315	}
316
317	/*-----------------------------------------------------------------------
318	* PUBLIC _sem_hack_init - reinitialize sem_hack_names to the default
319	-----------------------------------------------------------------------/
320	void
321	_sem_hack_init(void)
322	{
323	if (sem_hack_names == &sem_hack_defaults)
324	return;
325	hl_free(sem_hack_names);
326	sem_hack_names = &sem_hack_defaults;
327	}
328
329	/*-----------------------------------------------------------------------
330	* _sem_match - try to match the given named to sem_hack_names. Called
331	* by sem_open() and sem_unlink().
332	-----------------------------------------------------------------------/
333	PRIVATE int
334	_sem_match(const char *name)
335	{
336	#ifdef SEM_DEBUG_FILE
337	int match;
338	#endif /* SEM_DEBUG_FILE */
339
340	if (!name \|\| !*name)
341	return 0;
342	#ifdef SEM_DEBUG_FILE
343	match = dosearch(name, sem_hack_names);
344	if (!match)
345	SEM_PRINTF("%s\n", name);
346	return match;
347	#else /* SEM_DEBUG_FILE */
348	return dosearch(name, sem_hack_names);
349	#endif /* SEM_DEBUG_FILE */
350	}
351
352	/*-----------------------------------------------------------------------
353	* PUBLIC _shm_hack_add - add the given Hack list to shm_hack_names.
354	-----------------------------------------------------------------------/
355	int
356	_shm_hack_add(const Hack *list)
357	{
358	if (list == NULL)
359	return -1;
360	if (shm_hack_names == &shm_hack_defaults) {
361	HackList *hl = initList(shm_hack_default_names);
362	if (!hl)
363	return -1;
364	shm_hack_names = hl;
365	}
366	for (; list->name; list++)
367	if (hl_add(shm_hack_names, list) < 0)
368	return -1;
369	qsort((void *)shm_hack_names->list, shm_hack_names->cur,
370	sizeof(const Hack), comparstr);
371	return 0;
372	}
373
374	/*-----------------------------------------------------------------------
375	* PUBLIC _shm_hack_init - reinitialize shm_hack_names to the default
376	-----------------------------------------------------------------------/
377	void
378	_shm_hack_init(void)
379	{
380	if (shm_hack_names == &shm_hack_defaults)
381	return;
382	hl_free(shm_hack_names);
383	shm_hack_names = &shm_hack_defaults;
384	}
385
386	/*-----------------------------------------------------------------------
387	* _shm_match - try to match the given named to shm_hack_names. Called
388	* by shm_open() and shm_unlink().
389	-----------------------------------------------------------------------/
390	PRIVATE int
391	_shm_match(const char *name)
392	{
393	#ifdef SHM_DEBUG_FILE
394	int match;
395	#endif /* SHM_DEBUG_FILE */
396
397	if (!name \|\| !*name)
398	return 0;
399	#ifdef SHM_DEBUG_FILE
400	match = dosearch(name, shm_hack_names);
401	if (!match)
402	SHM_PRINTF("%s\n", name);
403	return match;
404	#else /* SHM_DEBUG_FILE */
405	return dosearch(name, shm_hack_names);
406	#endif /* SHM_DEBUG_FILE */
407	}