an, awi, cue and kue don't use the miibus interface.
[dragonfly.git] / contrib / smbfs / lib / smb / nls.c
1 /*
2  * Copyright (c) 2000-2001, Boris Popov
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *    This product includes software developed by Boris Popov.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $Id: nls.c,v 1.10 2002/07/22 08:33:59 bp Exp $
33  */
34
35 #include <sys/types.h>
36 #include <sys/iconv.h>
37 #include <sys/sysctl.h>
38 #include <ctype.h>
39 #ifndef APPLE
40 #include <dlfcn.h>
41 #endif
42 #include <errno.h>
43 #include <stdio.h>
44 #include <strings.h>
45 #include <stdlib.h>
46 #include <locale.h>
47 #include <err.h>
48 #include <netsmb/smb_lib.h>
49
50 /*
51  * prototype iconv* functions
52  */
53 typedef void *iconv_t;
54
55 static iconv_t (*my_iconv_open)(const char *, const char *);
56 static size_t(*my_iconv)(iconv_t, const char **, size_t *, char **, size_t *);
57 static int(*my_iconv_close)(iconv_t);
58
59 u_char nls_lower[256];
60 u_char nls_upper[256];
61
62 static iconv_t nls_toext, nls_toloc;
63 static int iconv_loaded;
64 static void *iconv_lib;
65
66 int
67 nls_setlocale(const char *name)
68 {
69         int i;
70
71         if (setlocale(LC_CTYPE, name) == NULL) {
72                 warnx("can't set locale '%s'\n", name);
73                 return EINVAL;
74         }
75         for (i = 0; i < 256; i++) {
76                 nls_lower[i] = tolower(i);
77                 nls_upper[i] = toupper(i);
78         }
79         return 0;
80 }
81
82 int
83 nls_setrecode(const char *local, const char *external)
84 {
85 #ifdef APPLE
86         return ENOENT;
87 #else
88         iconv_t icd;
89
90         if (iconv_loaded == 2)
91                 return ENOENT;
92         else if (iconv_loaded == 0) {
93                 iconv_loaded++;
94                 iconv_lib = dlopen("libiconv.so", RTLD_LAZY | RTLD_GLOBAL);
95                 if (iconv_lib == NULL) {
96                         warn("Unable to load iconv library: %s\n", dlerror());
97                         iconv_loaded++;
98                         return ENOENT;
99                 }
100                 my_iconv_open = dlsym(iconv_lib, "iconv_open");
101                 my_iconv = dlsym(iconv_lib, "iconv");
102                 my_iconv_close = dlsym(iconv_lib, "iconv_close");
103         }
104         if (nls_toext)
105                 my_iconv_close(nls_toext);
106         if (nls_toloc)
107                 my_iconv_close(nls_toloc);
108         nls_toext = nls_toloc = (iconv_t)0;
109         icd = my_iconv_open(external, local);
110         if (icd == (iconv_t)-1)
111                 return errno;
112         nls_toext = icd;
113         icd = my_iconv_open(local, external);
114         if (icd == (iconv_t)-1) {
115                 my_iconv_close(nls_toext);
116                 nls_toext = (iconv_t)0;
117                 return errno;
118         }
119         nls_toloc = icd;
120         return 0;
121 #endif
122 }
123
124 char *
125 nls_str_toloc(char *dst, const char *src)
126 {
127         char *p = dst;
128         int inlen, outlen;
129
130         if (!iconv_loaded)
131                 return strcpy(dst, src);
132
133         if (nls_toloc == (iconv_t)0)
134                 return strcpy(dst, src);
135         inlen = outlen = strlen(src);
136         my_iconv(nls_toloc, NULL, NULL, &p, &outlen);
137         while (my_iconv(nls_toloc, &src, &inlen, &p, &outlen) == -1) {
138                 *p++ = *src++;
139                 inlen--;
140                 outlen--;
141         }
142         *p = 0;
143         return dst;
144 }
145
146 char *
147 nls_str_toext(char *dst, const char *src)
148 {
149         char *p = dst;
150         int inlen, outlen;
151
152         if (!iconv_loaded)
153                 return strcpy(dst, src);
154
155         if (nls_toext == (iconv_t)0)
156                 return strcpy(dst, src);
157         inlen = outlen = strlen(src);
158         my_iconv(nls_toext, NULL, NULL, &p, &outlen);
159         while (my_iconv(nls_toext, &src, &inlen, &p, &outlen) == -1) {
160                 *p++ = *src++;
161                 inlen--;
162                 outlen--;
163         }
164         *p = 0;
165         return dst;
166 }
167
168 void *
169 nls_mem_toloc(void *dst, const void *src, int size)
170 {
171         char *p = dst;
172         const char *s = src;
173         int inlen, outlen;
174
175         if (!iconv_loaded)
176                 return memcpy(dst, src, size);
177
178         if (size == 0)
179                 return NULL;
180
181         if (nls_toloc == (iconv_t)0)
182                 return memcpy(dst, src, size);
183         inlen = outlen = size;
184         my_iconv(nls_toloc, NULL, NULL, &p, &outlen);
185         while (my_iconv(nls_toloc, &s, &inlen, &p, &outlen) == -1) {
186                 *p++ = *s++;
187                 inlen--;
188                 outlen--;
189         }
190         return dst;
191 }
192
193 void *
194 nls_mem_toext(void *dst, const void *src, int size)
195 {
196         char *p = dst;
197         const char *s = src;
198         int inlen, outlen;
199
200         if (size == 0)
201                 return NULL;
202
203         if (!iconv_loaded || nls_toext == (iconv_t)0)
204                 return memcpy(dst, src, size);
205
206         inlen = outlen = size;
207         my_iconv(nls_toext, NULL, NULL, &p, &outlen);
208         while (my_iconv(nls_toext, &s, &inlen, &p, &outlen) == -1) {
209                 *p++ = *s++;
210                 inlen--;
211                 outlen--;
212         }
213         return dst;
214 }
215
216 char *
217 nls_str_upper(char *dst, const char *src)
218 {
219         char *p = dst;
220
221         while (*src)
222                 *dst++ = toupper(*src++);
223         *dst = 0;
224         return p;
225 }
226
227 char *
228 nls_str_lower(char *dst, const char *src)
229 {
230         char *p = dst;
231
232         while (*src)
233                 *dst++ = tolower(*src++);
234         *dst = 0;
235         return p;
236 }