1/* $FreeBSD: releng/10.2/lib/libc/iconv/bsd_iconv.c 282275 2015-04-30 16:08:47Z tijl $ */ 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 "iconv-internal.h" 51 52#define ISBADF(_h_) (!(_h_) || (_h_) == (iconv_t)-1) 53 54static iconv_t 55__bsd___iconv_open(const char *out, const char *in, struct _citrus_iconv *handle) 56{ 57 const char *out_slashes; 58 char *out_noslashes; 59 int ret; 60 61 /* 62 * Remove anything following a //, as these are options (like 63 * //ignore, //translate, etc) and we just don't handle them. 64 * This is for compatibility with software that uses these 65 * blindly. 66 */ 67 out_slashes = strstr(out, "//"); 68 if (out_slashes != NULL) { 69 out_noslashes = strndup(out, out_slashes - out); 70 if (out_noslashes == NULL) { 71 errno = ENOMEM; 72 return ((iconv_t)-1); 73 } 74 ret = _citrus_iconv_open(&handle, in, out_noslashes); 75 free(out_noslashes); 76 } else { 77 ret = _citrus_iconv_open(&handle, in, out); 78 } 79 80 if (ret) { 81 errno = ret == ENOENT ? EINVAL : ret; 82 return ((iconv_t)-1); 83 } 84 85 handle->cv_shared->ci_discard_ilseq = strcasestr(out, "//IGNORE"); 86 handle->cv_shared->ci_ilseq_invalid = false; 87 handle->cv_shared->ci_hooks = NULL; 88 89 return ((iconv_t)(void *)handle); 90} 91 92iconv_t 93__bsd_iconv_open(const char *out, const char *in) 94{ 95 96 return (__bsd___iconv_open(out, in, NULL)); 97} 98 99int 100__bsd_iconv_open_into(const char *out, const char *in, iconv_allocation_t *ptr) 101{ 102 struct _citrus_iconv *handle; 103 104 handle = (struct _citrus_iconv *)ptr; 105 return ((__bsd___iconv_open(out, in, handle) == (iconv_t)-1) ? -1 : 0); 106} 107 108int 109__bsd_iconv_close(iconv_t handle) 110{ 111 112 if (ISBADF(handle)) { 113 errno = EBADF; 114 return (-1); 115 } 116 117 _citrus_iconv_close((struct _citrus_iconv *)(void *)handle); 118 119 return (0); 120} 121 122size_t 123__bsd_iconv(iconv_t handle, char **in, size_t *szin, char **out, size_t *szout) 124{ 125 size_t ret; 126 int err; 127 128 if (ISBADF(handle)) { 129 errno = EBADF; 130 return ((size_t)-1); 131 } 132 133 err = _citrus_iconv_convert((struct _citrus_iconv *)(void *)handle, 134 in, szin, out, szout, 0, &ret); 135 if (err) { 136 errno = err; 137 ret = (size_t)-1; 138 } 139 140 return (ret); 141} 142 143size_t 144__bsd___iconv(iconv_t handle, char **in, size_t *szin, char **out, 145 size_t *szout, uint32_t flags, size_t *invalids) 146{ 147 size_t ret; 148 int err; 149 150 if (ISBADF(handle)) { 151 errno = EBADF; 152 return ((size_t)-1); 153 } 154 155 err = _citrus_iconv_convert((struct _citrus_iconv *)(void *)handle, 156 in, szin, out, szout, flags, &ret); 157 if (invalids) 158 *invalids = ret; 159 if (err) { 160 errno = err; 161 ret = (size_t)-1; 162 } 163 164 return (ret); 165} 166 167int 168__bsd___iconv_get_list(char ***rlist, size_t *rsz, bool sorted) 169{ 170 int ret; 171 172 ret = _citrus_esdb_get_list(rlist, rsz, sorted); 173 if (ret) { 174 errno = ret; 175 return (-1); 176 } 177 178 return (0); 179} 180 181void 182__bsd___iconv_free_list(char **list, size_t sz) 183{ 184 185 _citrus_esdb_free_list(list, sz); 186} 187 188/* 189 * GNU-compatibile non-standard interfaces. 190 */ 191static int 192qsort_helper(const void *first, const void *second) 193{ 194 const char * const *s1; 195 const char * const *s2; 196 197 s1 = first; 198 s2 = second; 199 return (strcmp(*s1, *s2)); 200} 201 202void 203__bsd_iconvlist(int (*do_one) (unsigned int, const char * const *, 204 void *), void *data) 205{ 206 char **list, **names; 207 const char * const *np; 208 char *curitem, *curkey, *slashpos; 209 size_t sz; 210 unsigned int i, j; 211 212 i = 0; 213 214 if (__bsd___iconv_get_list(&list, &sz, true)) 215 list = NULL; 216 qsort((void *)list, sz, sizeof(char *), qsort_helper); 217 while (i < sz) { 218 j = 0; 219 slashpos = strchr(list[i], '/'); 220 curkey = (char *)malloc(slashpos - list[i] + 2); 221 names = (char **)malloc(sz * sizeof(char *)); 222 if ((curkey == NULL) || (names == NULL)) { 223 __bsd___iconv_free_list(list, sz); 224 return; 225 } 226 strlcpy(curkey, list[i], slashpos - list[i] + 1); 227 names[j++] = curkey; 228 for (; (i < sz) && (memcmp(curkey, list[i], strlen(curkey)) == 0); i++) { 229 slashpos = strchr(list[i], '/'); 230 curitem = (char *)malloc(strlen(slashpos) + 1); 231 if (curitem == NULL) { 232 __bsd___iconv_free_list(list, sz); 233 return; 234 } 235 strlcpy(curitem, &slashpos[1], strlen(slashpos) + 1); 236 if (strcmp(curkey, curitem) == 0) { 237 continue; 238 } 239 names[j++] = curitem; 240 } 241 np = (const char * const *)names; 242 do_one(j, np, data); 243 free(names); 244 } 245 246 __bsd___iconv_free_list(list, sz); 247} 248 249__inline const char * 250__bsd_iconv_canonicalize(const char *name) 251{ 252 253 return (_citrus_iconv_canonicalize(name)); 254} 255 256int 257__bsd_iconvctl(iconv_t cd, int request, void *argument) 258{ 259 struct _citrus_iconv *cv; 260 struct iconv_hooks *hooks; 261 const char *convname; 262 char src[PATH_MAX], *dst; 263 int *i; 264 265 cv = (struct _citrus_iconv *)(void *)cd; 266 hooks = (struct iconv_hooks *)argument; 267 i = (int *)argument; 268 269 if (ISBADF(cd)) { 270 errno = EBADF; 271 return (-1); 272 } 273 274 switch (request) { 275 case ICONV_TRIVIALP: 276 convname = cv->cv_shared->ci_convname; 277 dst = strchr(convname, '/'); 278 279 strlcpy(src, convname, dst - convname + 1); 280 dst++; 281 if ((convname == NULL) || (src == NULL) || (dst == NULL)) 282 return (-1); 283 *i = strcmp(src, dst) == 0 ? 1 : 0; 284 return (0); 285 case ICONV_GET_TRANSLITERATE: 286 *i = 1; 287 return (0); 288 case ICONV_SET_TRANSLITERATE: 289 return ((*i == 1) ? 0 : -1); 290 case ICONV_GET_DISCARD_ILSEQ: 291 *i = cv->cv_shared->ci_discard_ilseq ? 1 : 0; 292 return (0); 293 case ICONV_SET_DISCARD_ILSEQ: 294 cv->cv_shared->ci_discard_ilseq = *i; 295 return (0); 296 case ICONV_SET_HOOKS: 297 cv->cv_shared->ci_hooks = hooks; 298 return (0); 299 case ICONV_SET_FALLBACKS: 300 errno = EOPNOTSUPP; 301 return (-1); 302 case ICONV_GET_ILSEQ_INVALID: 303 *i = cv->cv_shared->ci_ilseq_invalid ? 1 : 0; 304 return (0); 305 case ICONV_SET_ILSEQ_INVALID: 306 cv->cv_shared->ci_ilseq_invalid = *i; 307 return (0); 308 default: 309 errno = EINVAL; 310 return (-1); 311 } 312} 313 314void 315__bsd_iconv_set_relocation_prefix(const char *orig_prefix __unused, 316 const char *curr_prefix __unused) 317{ 318 319} 320