xref: /freebsd/lib/libc/iconv/iconv.c (revision 0a10f22a30d61a6f32777a236a82d461129538cc) 
1 /* $FreeBSD$ */
2 /* $NetBSD: iconv.c,v 1.11 2009/03/03 16:22:33 explorer Exp $ */
3 
4 /*-
5  * Copyright (c) 2003 Citrus Project,
6  * Copyright (c) 2009, 2010 Gabor Kovesdan <gabor@FreeBSD.org>,
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 #include <sys/cdefs.h>
32 #include <sys/queue.h>
33 #include <sys/types.h>
34 
35 #include <assert.h>
36 #include <errno.h>
37 #include <iconv.h>
38 #include <limits.h>
39 #include <paths.h>
40 #include <stdbool.h>
41 #include <stdlib.h>
42 #include <string.h>
43 
44 #include "citrus_types.h"
45 #include "citrus_module.h"
46 #include "citrus_esdb.h"
47 #include "citrus_hash.h"
48 #include "citrus_iconv.h"
49 
50 #include <_libiconv_compat.h>
51 #ifdef __LIBICONV_COMPAT
52 __weak_reference(iconv, libiconv);
53 __weak_reference(iconv_open, libiconv_open);
54 __weak_reference(iconv_open_into, libiconv_open_into);
55 __weak_reference(iconv_close, libiconv_close);
56 __weak_reference(iconvlist, libiconvlist);
57 __weak_reference(iconvctl, libiconvctl);
58 __weak_reference(iconv_set_relocation_prefix, libiconv_set_relocation_prefix);
59 __weak_reference(_iconv_version, _libiconv_version);
60 #endif
61 
62 #define ISBADF(_h_)	(!(_h_) || (_h_) == (iconv_t)-1)
63 
64 int _iconv_version = _ICONV_VERSION;
65 
66 iconv_t		 _iconv_open(const char *out, const char *in,
67 		    struct _citrus_iconv *prealloc);
68 
69 iconv_t
70 _iconv_open(const char *out, const char *in, struct _citrus_iconv *handle)
71 {
72 	const char *out_slashes;
73 	char *out_noslashes;
74 	int ret;
75 
76 	/*
77 	 * Remove anything following a //, as these are options (like
78 	 * //ignore, //translate, etc) and we just don't handle them.
79 	 * This is for compatibility with software that uses these
80 	 * blindly.
81 	 */
82 	out_slashes = strstr(out, "//");
83 	if (out_slashes != NULL) {
84 		out_noslashes = strndup(out, out_slashes - out);
85 		if (out_noslashes == NULL) {
86 			errno = ENOMEM;
87 			return ((iconv_t)-1);
88 		}
89 		ret = _citrus_iconv_open(&handle, in, out_noslashes);
90 		free(out_noslashes);
91 	} else {
92 		ret = _citrus_iconv_open(&handle, in, out);
93 	}
94 
95 	if (ret) {
96 		errno = ret == ENOENT ? EINVAL : ret;
97 		return ((iconv_t)-1);
98 	}
99 
100 	handle->cv_shared->ci_discard_ilseq = strcasestr(out, "//IGNORE");
101 	handle->cv_shared->ci_hooks = NULL;
102 
103 	return ((iconv_t)(void *)handle);
104 }
105 
106 iconv_t
107 iconv_open(const char *out, const char *in)
108 {
109 
110 	return (_iconv_open(out, in, NULL));
111 }
112 
113 int
114 iconv_open_into(const char *out, const char *in, iconv_allocation_t *ptr)
115 {
116 	struct _citrus_iconv *handle;
117 
118 	handle = (struct _citrus_iconv *)ptr;
119 	return ((_iconv_open(out, in, handle) == (iconv_t)-1) ? -1 : 0);
120 }
121 
122 int
123 iconv_close(iconv_t handle)
124 {
125 
126 	if (ISBADF(handle)) {
127 		errno = EBADF;
128 		return (-1);
129 	}
130 
131 	_citrus_iconv_close((struct _citrus_iconv *)(void *)handle);
132 
133 	return (0);
134 }
135 
136 size_t
137 iconv(iconv_t handle, const char **in, size_t *szin, char **out, size_t *szout)
138 {
139 	size_t ret;
140 	int err;
141 
142 	if (ISBADF(handle)) {
143 		errno = EBADF;
144 		return ((size_t)-1);
145 	}
146 
147 	err = _citrus_iconv_convert((struct _citrus_iconv *)(void *)handle,
148 	    in, szin, out, szout, 0, &ret);
149 	if (err) {
150 		errno = err;
151 		ret = (size_t)-1;
152 	}
153 
154 	return (ret);
155 }
156 
157 size_t
158 __iconv(iconv_t handle, const char **in, size_t *szin, char **out,
159     size_t *szout, uint32_t flags, size_t *invalids)
160 {
161 	size_t ret;
162 	int err;
163 
164 	if (ISBADF(handle)) {
165 		errno = EBADF;
166 		return ((size_t)-1);
167 	}
168 
169 	err = _citrus_iconv_convert((struct _citrus_iconv *)(void *)handle,
170 	    in, szin, out, szout, flags, &ret);
171 	if (invalids)
172 		*invalids = ret;
173 	if (err) {
174 		errno = err;
175 		ret = (size_t)-1;
176 	}
177 
178 	return (ret);
179 }
180 
181 int
182 __iconv_get_list(char ***rlist, size_t *rsz, bool sorted)
183 {
184 	int ret;
185 
186 	ret = _citrus_esdb_get_list(rlist, rsz, sorted);
187 	if (ret) {
188 		errno = ret;
189 		return (-1);
190 	}
191 
192 	return (0);
193 }
194 
195 void
196 __iconv_free_list(char **list, size_t sz)
197 {
198 
199 	_citrus_esdb_free_list(list, sz);
200 }
201 
202 /*
203  * GNU-compatibile non-standard interfaces.
204  */
205 static int
206 qsort_helper(const void *first, const void *second)
207 {
208 	const char * const *s1;
209 	const char * const *s2;
210 
211 	s1 = first;
212 	s2 = second;
213 	return (strcmp(*s1, *s2));
214 }
215 
216 void
217 iconvlist(int (*do_one) (unsigned int, const char * const *,
218     void *), void *data)
219 {
220 	char **list, **names;
221 	const char * const *np;
222 	char *curitem, *curkey, *slashpos;
223 	size_t sz;
224 	unsigned int i, j;
225 
226 	i = 0;
227 
228 	if (__iconv_get_list(&list, &sz, true))
229 		list = NULL;
230 	qsort((void *)list, sz, sizeof(char *), qsort_helper);
231 	while (i < sz) {
232 		j = 0;
233 		slashpos = strchr(list[i], '/');
234 		curkey = (char *)malloc(slashpos - list[i] + 2);
235 		names = (char **)malloc(sz * sizeof(char *));
236 		if ((curkey == NULL) || (names == NULL)) {
237 			__iconv_free_list(list, sz);
238 			return;
239 		}
240 		strlcpy(curkey, list[i], slashpos - list[i] + 1);
241 		names[j++] = strdup(curkey);
242 		for (; (i < sz) && (memcmp(curkey, list[i], strlen(curkey)) == 0); i++) {
243 			slashpos = strchr(list[i], '/');
244 			curitem = (char *)malloc(strlen(slashpos) + 1);
245 			if (curitem == NULL) {
246 				__iconv_free_list(list, sz);
247 				return;
248 			}
249 			strlcpy(curitem, &slashpos[1], strlen(slashpos) + 1);
250 			if (strcmp(curkey, curitem) == 0) {
251 				continue;
252 			}
253 			names[j++] = strdup(curitem);
254 		}
255 		np = (const char * const *)names;
256 		do_one(j, np, data);
257 		free(names);
258 	}
259 
260 	__iconv_free_list(list, sz);
261 }
262 
263 __inline const char
264 *iconv_canonicalize(const char *name)
265 {
266 
267 	return (_citrus_iconv_canonicalize(name));
268 }
269 
270 int
271 iconvctl(iconv_t cd, int request, void *argument)
272 {
273 	struct _citrus_iconv *cv;
274 	struct iconv_hooks *hooks;
275 	const char *convname;
276 	char src[PATH_MAX], *dst;
277 	int *i;
278 
279 	cv = (struct _citrus_iconv *)(void *)cd;
280 	hooks = (struct iconv_hooks *)argument;
281 	i = (int *)argument;
282 
283 	if (ISBADF(cd)) {
284 		errno = EBADF;
285 		return (-1);
286 	}
287 
288 	switch (request) {
289 	case ICONV_TRIVIALP:
290 		convname = cv->cv_shared->ci_convname;
291 		dst = strchr(convname, '/');
292 
293 		strlcpy(src, convname, dst - convname + 1);
294 		dst++;
295 		if ((convname == NULL) || (src == NULL) || (dst == NULL))
296 			return (-1);
297 		*i = strcmp(src, dst) == 0 ? 1 : 0;
298 		return (0);
299 	case ICONV_GET_TRANSLITERATE:
300 		*i = 1;
301 		return (0);
302 	case ICONV_SET_TRANSLITERATE:
303 		return  ((*i == 1) ? 0 : -1);
304 	case ICONV_GET_DISCARD_ILSEQ:
305 		*i = cv->cv_shared->ci_discard_ilseq ? 1 : 0;
306 		return (0);
307 	case ICONV_SET_DISCARD_ILSEQ:
308 		cv->cv_shared->ci_discard_ilseq = *i;
309 		return (0);
310 	case ICONV_SET_HOOKS:
311 		cv->cv_shared->ci_hooks = hooks;
312 		return (0);
313 	case ICONV_SET_FALLBACKS:
314 		errno = EOPNOTSUPP;
315 		return (-1);
316 	default:
317 		errno = EINVAL;
318 		return (-1);
319 	}
320 }
321 
322 void
323 iconv_set_relocation_prefix(const char *orig_prefix __unused,
324     const char *curr_prefix __unused)
325 {
326 
327 }
328