Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/locale/rune.c	Lines:	0	112	0.0 %
Date:	2017-11-13	Branches:	0	76	0.0 %


/*	$OpenBSD: rune.c,v 1.7 2016/09/05 09:47:03 schwarze Exp $ */
/*	$NetBSD: rune.c,v 1.26 2004/05/09 11:26:33 kleink Exp $	*/

/*-
 * Copyright (c)1999 Citrus Project,
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*-
 * Copyright (c) 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Paul Borman at Krystal Technologies.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include "rune.h"
#include "rune_local.h"

#define SAFE_ADD(x, y)			\
do {					\
	if ((x) > SIZE_MAX - (y))	\
		return NULL;		\
	(x) += (y);			\
} while (0);

static int readrange(_RuneLocale *, _RuneRange *, uint32_t, void *, FILE *);
static void _freeentry(_RuneRange *);
static void _wctype_init(_RuneLocale *rl);

static int
readrange(_RuneLocale *rl, _RuneRange *rr, uint32_t nranges, void *lastp,
	FILE *fp)
{
	uint32_t i;
	_RuneEntry *re;
	_FileRuneEntry fre;

	re = (_RuneEntry *)rl->rl_variable;

	rr->rr_nranges = nranges;
	if (rr->rr_nranges == 0) {
		rr->rr_rune_ranges = NULL;
		return 0;
	}

	rr->rr_rune_ranges = re;
	for (i = 0; i < rr->rr_nranges; i++) {
		if ((void *)re >= lastp)
			return -1;

		if (fread(&fre, sizeof(fre), 1, fp) != 1)
			return -1;

		re->re_min = ntohl((uint32_t)fre.fre_min);
		re->re_max = ntohl((uint32_t)fre.fre_max);
		re->re_map = ntohl((uint32_t)fre.fre_map);
		re++;
	}
	rl->rl_variable = re;
	return 0;
}

static int
readentry(_RuneRange *rr, FILE *fp)
{
	_RuneEntry *re;
	size_t l, i, j;
	int error;

	re = rr->rr_rune_ranges;
	for (i = 0; i < rr->rr_nranges; i++) {
		if (re[i].re_map != 0) {
			re[i].re_rune_types = NULL;
			continue;
		}

		if (re[i].re_max < re[i].re_min) {
			error = EINVAL;
			goto fail;
		}

		l = re[i].re_max - re[i].re_min + 1;
		re[i].re_rune_types = calloc(l, sizeof(_RuneType));
		if (!re[i].re_rune_types) {
			error = ENOMEM;
			goto fail;
		}

		if (fread(re[i].re_rune_types, sizeof(_RuneType), l, fp) != l)
			goto fail2;

		for (j = 0; j < l; j++)
			re[i].re_rune_types[j] = ntohl(re[i].re_rune_types[j]);
	}
	return 0;

fail:
	for (j = 0; j < i; j++) {
		free(re[j].re_rune_types);
		re[j].re_rune_types = NULL;
	}
	return error;
fail2:
	for (j = 0; j <= i; j++) {
		free(re[j].re_rune_types);
		re[j].re_rune_types = NULL;
	}
	return errno;
}

/* XXX: temporary implementation */
static int
find_codeset(_RuneLocale *rl)
{
	char *top, *codeset, *tail, *ep;

	if (rl->rl_variable == NULL)
		return 0;

	/* end of rl_variable region */
	ep = (char *)rl->rl_variable;
	ep += rl->rl_variable_len;
	rl->rl_codeset = NULL;
	if (!(top = strstr(rl->rl_variable, _RUNE_CODESET)))
		return 0;
	tail = strpbrk(top, " \t");
	codeset = top + sizeof(_RUNE_CODESET) - 1;
	if (tail) {
		*top = *tail;
		*tail = '\0';
		rl->rl_codeset = strdup(codeset);
		strlcpy(top + 1, tail + 1, (unsigned)(ep - (top + 1)));
	} else {
		*top = '\0';
		rl->rl_codeset = strdup(codeset);
	}
	return (rl->rl_codeset == NULL);
}

void
_freeentry(_RuneRange *rr)
{
	_RuneEntry *re;
	uint32_t i;

	re = rr->rr_rune_ranges;
	for (i = 0; i < rr->rr_nranges; i++) {
		free(re[i].re_rune_types);
		re[i].re_rune_types = NULL;
	}
}

void
_wctype_init(_RuneLocale *rl)
{
	memcpy(&rl->rl_wctype, &_DefaultRuneLocale.rl_wctype,
	       sizeof(rl->rl_wctype));
}


_RuneLocale *
_Read_RuneMagi(FILE *fp)
{
	/* file */
	_FileRuneLocale frl;
	/* host data */
	char *hostdata;
	size_t hostdatalen;
	void *lastp;
	_RuneLocale *rl;
	struct stat sb;
	int x;
	uint32_t runetype_nranges, maplower_nranges, mapupper_nranges, var_len;

	if (fstat(fileno(fp), &sb) < 0)
		return NULL;

	if (sb.st_size < sizeof(_FileRuneLocale))
		return NULL;
	/* XXX more validation? */

	/* Someone might have read the magic number once already */
	rewind(fp);

	if (fread(&frl, sizeof(frl), 1, fp) != 1)
		return NULL;
	if (memcmp(frl.frl_magic, _RUNE_MAGIC_1, sizeof(frl.frl_magic)))
		return NULL;

	runetype_nranges = ntohl(frl.frl_runetype_ext.frr_nranges);
	maplower_nranges = ntohl(frl.frl_maplower_ext.frr_nranges);
	mapupper_nranges = ntohl(frl.frl_mapupper_ext.frr_nranges);
	var_len = ntohl((uint32_t)frl.frl_variable_len);

#if SIZE_MAX <= UINT32_MAX
	if (runetype_nranges > SIZE_MAX / sizeof(_RuneEntry) ||
	    maplower_nranges > SIZE_MAX / sizeof(_RuneEntry) ||
	    mapupper_nranges > SIZE_MAX / sizeof(_RuneEntry))
		return NULL;
#endif

	if (var_len > INT32_MAX)
		return NULL;

	hostdatalen = sizeof(*rl);
	SAFE_ADD(hostdatalen, var_len);
	SAFE_ADD(hostdatalen, runetype_nranges * sizeof(_RuneEntry));
	SAFE_ADD(hostdatalen, maplower_nranges * sizeof(_RuneEntry));
	SAFE_ADD(hostdatalen, mapupper_nranges * sizeof(_RuneEntry));

	if ((hostdata = calloc(hostdatalen, 1)) == NULL)
		return NULL;
	lastp = hostdata + hostdatalen;

	rl = (_RuneLocale *)hostdata;
	rl->rl_variable = rl + 1;

	memcpy(rl->rl_magic, frl.frl_magic, sizeof(rl->rl_magic));
	memcpy(rl->rl_encoding, frl.frl_encoding, sizeof(rl->rl_encoding));

	/* XXX assumes rune_t = uint32_t */
	rl->rl_invalid_rune = ntohl((uint32_t)frl.frl_invalid_rune);
	rl->rl_variable_len = ntohl((uint32_t)frl.frl_variable_len);

	for (x = 0; x < _CACHED_RUNES; ++x) {
		rl->rl_runetype[x] = ntohl(frl.frl_runetype[x]);

		/* XXX assumes rune_t = uint32_t */
		rl->rl_maplower[x] = ntohl((uint32_t)frl.frl_maplower[x]);
		rl->rl_mapupper[x] = ntohl((uint32_t)frl.frl_mapupper[x]);
	}

	if (readrange(rl, &rl->rl_runetype_ext, runetype_nranges, lastp, fp) ||
	    readrange(rl, &rl->rl_maplower_ext, maplower_nranges, lastp, fp) ||
	    readrange(rl, &rl->rl_mapupper_ext, mapupper_nranges, lastp, fp))
		goto err;

	if (readentry(&rl->rl_runetype_ext, fp) != 0)
		goto err;

	if ((uint8_t *)rl->rl_variable + rl->rl_variable_len >
	    (uint8_t *)lastp)
		goto rune_err;

	if (rl->rl_variable_len == 0)
		rl->rl_variable = NULL;
	else if (fread(rl->rl_variable, rl->rl_variable_len, 1, fp) != 1)
		goto rune_err;
	if (find_codeset(rl))
		goto rune_err;
	_wctype_init(rl);

	/*
	 * error if we have junk at the tail,
	 * or if we can't allocate memory.
	 */
	if (ftello(fp) != sb.st_size || __make_ctype_tabs(rl) == -1)
		goto rune_err;

	return(rl);
rune_err:
	_freeentry(&rl->rl_runetype_ext);
err:
	free(hostdata);
	return NULL;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: rune.c,v 1.7 2016/09/05 09:47:03 schwarze Exp $ */
2			/* $NetBSD: rune.c,v 1.26 2004/05/09 11:26:33 kleink Exp $ */
3
4			/*-
5			* Copyright (c)1999 Citrus Project,
6			* All rights reserved.
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			*
17			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27			* SUCH DAMAGE.
28			*/
29
30			/*-
31			* Copyright (c) 1993
32			* The Regents of the University of California. All rights reserved.
33			*
34			* This code is derived from software contributed to Berkeley by
35			* Paul Borman at Krystal Technologies.
36			*
37			* Redistribution and use in source and binary forms, with or without
38			* modification, are permitted provided that the following conditions
39			* are met:
40			* 1. Redistributions of source code must retain the above copyright
41			* notice, this list of conditions and the following disclaimer.
42			* 2. Redistributions in binary form must reproduce the above copyright
43			* notice, this list of conditions and the following disclaimer in the
44			* documentation and/or other materials provided with the distribution.
45			* 3. Neither the name of the University nor the names of its contributors
46			* may be used to endorse or promote products derived from this software
47			* without specific prior written permission.
48			*
49			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59			* SUCH DAMAGE.
60			*/
61
62			#include <sys/types.h>
63			#include <sys/stat.h>
64			#include <assert.h>
65			#include <errno.h>
66			#include <stdint.h>
67			#include <stdio.h>
68			#include <stdlib.h>
69			#include <string.h>
70			#include <wchar.h>
71			#include "rune.h"
72			#include "rune_local.h"
73
74			#define SAFE_ADD(x, y) \
75			do { \
76			if ((x) > SIZE_MAX - (y)) \
77			return NULL; \
78			(x) += (y); \
79			} while (0);
80
81			static int readrange(_RuneLocale , _RuneRange , uint32_t, void , FILE );
82			static void _freeentry(_RuneRange *);
83			static void _wctype_init(_RuneLocale *rl);
84
85			static int
86			readrange(_RuneLocale rl, _RuneRange rr, uint32_t nranges, void *lastp,
87			FILE *fp)
88			{
89			uint32_t i;
90			_RuneEntry *re;
91			_FileRuneEntry fre;
92
93			re = (_RuneEntry *)rl->rl_variable;
94
95			rr->rr_nranges = nranges;
96			if (rr->rr_nranges == 0) {
97			rr->rr_rune_ranges = NULL;
98			return 0;
99			}
100
101			rr->rr_rune_ranges = re;
102			for (i = 0; i < rr->rr_nranges; i++) {
103			if ((void *)re >= lastp)
104			return -1;
105
106			if (fread(&fre, sizeof(fre), 1, fp) != 1)
107			return -1;
108
109			re->re_min = ntohl((uint32_t)fre.fre_min);
110			re->re_max = ntohl((uint32_t)fre.fre_max);
111			re->re_map = ntohl((uint32_t)fre.fre_map);
112			re++;
113			}
114			rl->rl_variable = re;
115			return 0;
116			}
117
118			static int
119			readentry(_RuneRange rr, FILE fp)
120			{
121			_RuneEntry *re;
122			size_t l, i, j;
123			int error;
124
125			re = rr->rr_rune_ranges;
126			for (i = 0; i < rr->rr_nranges; i++) {
127			if (re[i].re_map != 0) {
128			re[i].re_rune_types = NULL;
129			continue;
130			}
131
132			if (re[i].re_max < re[i].re_min) {
133			error = EINVAL;
134			goto fail;
135			}
136
137			l = re[i].re_max - re[i].re_min + 1;
138			re[i].re_rune_types = calloc(l, sizeof(_RuneType));
139			if (!re[i].re_rune_types) {
140			error = ENOMEM;
141			goto fail;
142			}
143
144			if (fread(re[i].re_rune_types, sizeof(_RuneType), l, fp) != l)
145			goto fail2;
146
147			for (j = 0; j < l; j++)
148			re[i].re_rune_types[j] = ntohl(re[i].re_rune_types[j]);
149			}
150			return 0;
151
152			fail:
153			for (j = 0; j < i; j++) {
154			free(re[j].re_rune_types);
155			re[j].re_rune_types = NULL;
156			}
157			return error;
158			fail2:
159			for (j = 0; j <= i; j++) {
160			free(re[j].re_rune_types);
161			re[j].re_rune_types = NULL;
162			}
163			return errno;
164			}
165
166			/* XXX: temporary implementation */
167			static int
168			find_codeset(_RuneLocale *rl)
169			{
170			char top, codeset, tail, ep;
171
172			if (rl->rl_variable == NULL)
173			return 0;
174
175			/* end of rl_variable region */
176			ep = (char *)rl->rl_variable;
177			ep += rl->rl_variable_len;
178			rl->rl_codeset = NULL;
179			if (!(top = strstr(rl->rl_variable, _RUNE_CODESET)))
180			return 0;
181			tail = strpbrk(top, " \t");
182			codeset = top + sizeof(_RUNE_CODESET) - 1;
183			if (tail) {
184			top = tail;
185			*tail = '\0';
186			rl->rl_codeset = strdup(codeset);
187			strlcpy(top + 1, tail + 1, (unsigned)(ep - (top + 1)));
188			} else {
189			*top = '\0';
190			rl->rl_codeset = strdup(codeset);
191			}
192			return (rl->rl_codeset == NULL);
193			}
194
195			void
196			_freeentry(_RuneRange *rr)
197			{
198			_RuneEntry *re;
199			uint32_t i;
200
201			re = rr->rr_rune_ranges;
202			for (i = 0; i < rr->rr_nranges; i++) {
203			free(re[i].re_rune_types);
204			re[i].re_rune_types = NULL;
205			}
206			}
207
208			void
209			_wctype_init(_RuneLocale *rl)
210			{
211			memcpy(&rl->rl_wctype, &_DefaultRuneLocale.rl_wctype,
212			sizeof(rl->rl_wctype));
213			}
214
215
216			_RuneLocale *
217			_Read_RuneMagi(FILE *fp)
218			{
219			/* file */
220			_FileRuneLocale frl;
221			/* host data */
222			char *hostdata;
223			size_t hostdatalen;
224			void *lastp;
225			_RuneLocale *rl;
226			struct stat sb;
227			int x;
228			uint32_t runetype_nranges, maplower_nranges, mapupper_nranges, var_len;
229
230			if (fstat(fileno(fp), &sb) < 0)
231			return NULL;
232
233			if (sb.st_size < sizeof(_FileRuneLocale))
234			return NULL;
235			/* XXX more validation? */
236
237			/* Someone might have read the magic number once already */
238			rewind(fp);
239
240			if (fread(&frl, sizeof(frl), 1, fp) != 1)
241			return NULL;
242			if (memcmp(frl.frl_magic, _RUNE_MAGIC_1, sizeof(frl.frl_magic)))
243			return NULL;
244
245			runetype_nranges = ntohl(frl.frl_runetype_ext.frr_nranges);
246			maplower_nranges = ntohl(frl.frl_maplower_ext.frr_nranges);
247			mapupper_nranges = ntohl(frl.frl_mapupper_ext.frr_nranges);
248			var_len = ntohl((uint32_t)frl.frl_variable_len);
249
250			#if SIZE_MAX <= UINT32_MAX
251			if (runetype_nranges > SIZE_MAX / sizeof(_RuneEntry) \|\|
252			maplower_nranges > SIZE_MAX / sizeof(_RuneEntry) \|\|
253			mapupper_nranges > SIZE_MAX / sizeof(_RuneEntry))
254			return NULL;
255			#endif
256
257			if (var_len > INT32_MAX)
258			return NULL;
259
260			hostdatalen = sizeof(*rl);
261			SAFE_ADD(hostdatalen, var_len);
262			SAFE_ADD(hostdatalen, runetype_nranges * sizeof(_RuneEntry));
263			SAFE_ADD(hostdatalen, maplower_nranges * sizeof(_RuneEntry));
264			SAFE_ADD(hostdatalen, mapupper_nranges * sizeof(_RuneEntry));
265
266			if ((hostdata = calloc(hostdatalen, 1)) == NULL)
267			return NULL;
268			lastp = hostdata + hostdatalen;
269
270			rl = (_RuneLocale *)hostdata;
271			rl->rl_variable = rl + 1;
272
273			memcpy(rl->rl_magic, frl.frl_magic, sizeof(rl->rl_magic));
274			memcpy(rl->rl_encoding, frl.frl_encoding, sizeof(rl->rl_encoding));
275
276			/* XXX assumes rune_t = uint32_t */
277			rl->rl_invalid_rune = ntohl((uint32_t)frl.frl_invalid_rune);
278			rl->rl_variable_len = ntohl((uint32_t)frl.frl_variable_len);
279
280			for (x = 0; x < _CACHED_RUNES; ++x) {
281			rl->rl_runetype[x] = ntohl(frl.frl_runetype[x]);
282
283			/* XXX assumes rune_t = uint32_t */
284			rl->rl_maplower[x] = ntohl((uint32_t)frl.frl_maplower[x]);
285			rl->rl_mapupper[x] = ntohl((uint32_t)frl.frl_mapupper[x]);
286			}
287
288			if (readrange(rl, &rl->rl_runetype_ext, runetype_nranges, lastp, fp) \|\|
289			readrange(rl, &rl->rl_maplower_ext, maplower_nranges, lastp, fp) \|\|
290			readrange(rl, &rl->rl_mapupper_ext, mapupper_nranges, lastp, fp))
291			goto err;
292
293			if (readentry(&rl->rl_runetype_ext, fp) != 0)
294			goto err;
295
296			if ((uint8_t *)rl->rl_variable + rl->rl_variable_len >
297			(uint8_t *)lastp)
298			goto rune_err;
299
300			if (rl->rl_variable_len == 0)
301			rl->rl_variable = NULL;
302			else if (fread(rl->rl_variable, rl->rl_variable_len, 1, fp) != 1)
303			goto rune_err;
304			if (find_codeset(rl))
305			goto rune_err;
306			_wctype_init(rl);
307
308			/*
309			* error if we have junk at the tail,
310			* or if we can't allocate memory.
311			*/
312			if (ftello(fp) != sb.st_size \|\| __make_ctype_tabs(rl) == -1)
313			goto rune_err;
314
315			return(rl);
316			rune_err:
317			_freeentry(&rl->rl_runetype_ext);
318			err:
319			free(hostdata);
320			return NULL;
321			}