1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/sysmacros.h>
32 #include <sys/systm.h>
33 #include <sys/debug.h>
34 #include <sys/kmem.h>
35 #include <sys/sunddi.h>
36 #include <sys/byteorder.h>
37 #include <sys/errno.h>
38 #include <sys/modctl.h>
39 #include <sys/u8_textprep.h>
40 #include <sys/kiconv.h>
41 #include <sys/kiconv_cck_common.h>
42 #include <sys/kiconv_ko.h>
43 #include <sys/kiconv_uhc_utf8.h>
44 #include <sys/kiconv_utf8_uhc.h>
45 #include <sys/kiconv_euckr_utf8.h>
46 #include <sys/kiconv_utf8_euckr.h>
47 
48 static int8_t utf8_to_euckr(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
49 	uchar_t *ob, uchar_t *obtail, size_t *ret_val);
50 static int8_t utf8_to_uhc(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
51 	uchar_t *ob, uchar_t *obtail, size_t *ret_val);
52 static int8_t ko_to_utf8(uint32_t ko_val, uchar_t *ob, uchar_t *obtail,
53 	size_t *ret_val, kiconv_table_array_t *table, size_t nitems);
54 
55 
56 #define	KICONV_KO_EUCKR		(0x01)
57 #define	KICONV_KO_UHC		(0x02)
58 #define	KICONV_KO_MAX_MAGIC_ID	(0x02)
59 
60 static void *
open_fr_euckr()61 open_fr_euckr()
62 {
63 	return ((void *)KICONV_KO_EUCKR);
64 }
65 
66 static void *
open_fr_uhc()67 open_fr_uhc()
68 {
69 	return ((void *)KICONV_KO_UHC);
70 }
71 
72 static int
close_fr_ko(void * s)73 close_fr_ko(void *s)
74 {
75 	if ((uintptr_t)s > KICONV_KO_MAX_MAGIC_ID)
76 		return (EBADF);
77 
78 	return (0);
79 }
80 
81 /*
82  * Encoding convertor from EUC-KR to UTF-8.
83  */
84 static size_t
kiconv_fr_euckr(void * kcd,char ** inbuf,size_t * inbufleft,char ** outbuf,size_t * outbufleft,int * errno)85 kiconv_fr_euckr(void *kcd, char **inbuf, size_t *inbufleft,
86 	char **outbuf, size_t *outbufleft, int *errno)
87 {
88 	uchar_t		*ib;
89 	uchar_t		*ob;
90 	uchar_t		*ibtail;
91 	uchar_t		*obtail;
92 	size_t		ret_val;
93 	int8_t		sz;
94 	uint32_t	euckr_val;
95 
96 	/* Check on the kiconv code conversion descriptor. */
97 	if (kcd == NULL || kcd == (void *)-1) {
98 		*errno = EBADF;
99 		return ((size_t)-1);
100 	}
101 
102 	/* If this is a state reset request, process and return. */
103 	if (inbuf == NULL || *inbuf == NULL) {
104 		return (0);
105 	}
106 
107 	ret_val = 0;
108 	ib = (uchar_t *)*inbuf;
109 	ob = (uchar_t *)*outbuf;
110 	ibtail = ib + *inbufleft;
111 	obtail = ob + *outbufleft;
112 
113 	while (ib < ibtail) {
114 		if (KICONV_IS_ASCII(*ib)) {
115 			if (ob >= obtail) {
116 				KICONV_SET_ERRNO_AND_BREAK(E2BIG);
117 			}
118 
119 			*ob++ = *ib++;
120 			continue;
121 		}
122 
123 		/*
124 		 * Issue EILSEQ error if the first byte is not a
125 		 * valid EUC-KR leading byte.
126 		 */
127 		if (! KICONV_KO_IS_EUCKR_BYTE(*ib)) {
128 			KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
129 		}
130 
131 		/*
132 		 * Issue EINVAL error if input buffer has an incomplete
133 		 * character at the end of the buffer.
134 		 */
135 		if (ibtail - ib < 2) {
136 			KICONV_SET_ERRNO_AND_BREAK(EINVAL);
137 		}
138 
139 		/*
140 		 * Issue EILSEQ error if the remaining byte is not
141 		 * a valid EUC-KR byte.
142 		 */
143 		if (! KICONV_KO_IS_EUCKR_BYTE(*(ib + 1))) {
144 			KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
145 		}
146 
147 		euckr_val = (uint32_t)(*ib) << 8 | *(ib + 1);
148 		sz = ko_to_utf8(euckr_val, ob, obtail, &ret_val,
149 		    kiconv_euckr_utf8, KICONV_EUCKR_UTF8_MAX);
150 
151 		if (sz < 0) {
152 			KICONV_SET_ERRNO_AND_BREAK(E2BIG);
153 		}
154 
155 		ib += 2;
156 		ob += sz;
157 	}
158 
159 	*inbuf = (char *)ib;
160 	*inbufleft = ibtail - ib;
161 	*outbuf = (char *)ob;
162 	*outbufleft = obtail - ob;
163 
164 	return (ret_val);
165 }
166 
167 /*
168  * String based encoding convertor from EUC-KR to UTF-8.
169  */
170 static size_t
kiconvstr_fr_euckr(char * inarray,size_t * inlen,char * outarray,size_t * outlen,int flag,int * errno)171 kiconvstr_fr_euckr(char *inarray, size_t *inlen, char *outarray,
172 	size_t *outlen, int flag, int *errno)
173 {
174 	uchar_t		*ib;
175 	uchar_t		*ob;
176 	uchar_t		*ibtail;
177 	uchar_t		*obtail;
178 	uchar_t		*oldib;
179 	size_t		ret_val;
180 	int8_t		sz;
181 	uint32_t	euckr_val;
182 	boolean_t	do_not_ignore_null;
183 
184 	ret_val = 0;
185 	ib = (uchar_t *)inarray;
186 	ob = (uchar_t *)outarray;
187 	ibtail = ib + *inlen;
188 	obtail = ob + *outlen;
189 	do_not_ignore_null = ((flag & KICONV_IGNORE_NULL) == 0);
190 
191 	while (ib < ibtail) {
192 		if (*ib == '\0' && do_not_ignore_null)
193 			break;
194 
195 		if (KICONV_IS_ASCII(*ib)) {
196 			if (ob >= obtail) {
197 				KICONV_SET_ERRNO_AND_BREAK(E2BIG);
198 			}
199 
200 			*ob++ = *ib++;
201 			continue;
202 		}
203 
204 		oldib = ib;
205 
206 		if (! KICONV_KO_IS_EUCKR_BYTE(*ib)) {
207 			KICONV_SET_ERRNO_WITH_FLAG(1, EILSEQ);
208 		}
209 
210 		if (ibtail - ib < 2) {
211 			KICONV_SET_ERRNO_WITH_FLAG(1, EINVAL);
212 		}
213 
214 		if (! KICONV_KO_IS_EUCKR_BYTE(*(ib + 1))) {
215 			KICONV_SET_ERRNO_WITH_FLAG(2, EILSEQ);
216 		}
217 
218 		euckr_val = *ib++;
219 		euckr_val = (euckr_val << 8) | *ib++;
220 		sz = ko_to_utf8(euckr_val, ob, obtail, &ret_val,
221 		    kiconv_euckr_utf8, KICONV_EUCKR_UTF8_MAX);
222 
223 		if (sz < 0) {
224 			ib = oldib;
225 			KICONV_SET_ERRNO_AND_BREAK(E2BIG);
226 		}
227 
228 		ob += sz;
229 		continue;
230 
231 REPLACE_INVALID:
232 		if (obtail - ob < KICONV_UTF8_REPLACEMENT_CHAR_LEN) {
233 			ib = oldib;
234 			KICONV_SET_ERRNO_AND_BREAK(E2BIG);
235 		}
236 
237 		*ob++ = KICONV_UTF8_REPLACEMENT_CHAR1;
238 		*ob++ = KICONV_UTF8_REPLACEMENT_CHAR2;
239 		*ob++ = KICONV_UTF8_REPLACEMENT_CHAR3;
240 		ret_val++;
241 	}
242 
243 	*inlen = ibtail - ib;
244 	*outlen = obtail - ob;
245 
246 	return (ret_val);
247 }
248 
249 /*
250  * Encoding convertor from Unified Hangul Code to UTF-8.
251  */
252 static size_t
kiconv_fr_uhc(void * kcd,char ** inbuf,size_t * inbufleft,char ** outbuf,size_t * outbufleft,int * errno)253 kiconv_fr_uhc(void *kcd, char **inbuf, size_t *inbufleft,
254 	char **outbuf, size_t *outbufleft, int *errno)
255 {
256 	uchar_t		*ib;
257 	uchar_t		*ob;
258 	uchar_t		*ibtail;
259 	uchar_t		*obtail;
260 	size_t		ret_val;
261 	int8_t		sz;
262 	uint32_t	uhc_val;
263 
264 	/* Check on the kiconv code conversion descriptor. */
265 	if (kcd == NULL || kcd == (void *)-1) {
266 		*errno = EBADF;
267 		return ((size_t)-1);
268 	}
269 
270 	/* If this is a state reset request, process and return. */
271 	if (inbuf == NULL || *inbuf == NULL) {
272 		return (0);
273 	}
274 
275 	ret_val = 0;
276 	ib = (uchar_t *)*inbuf;
277 	ob = (uchar_t *)*outbuf;
278 	ibtail = ib + *inbufleft;
279 	obtail = ob + *outbufleft;
280 
281 	while (ib < ibtail) {
282 		if (KICONV_IS_ASCII(*ib)) {
283 			if (ob >= obtail) {
284 				KICONV_SET_ERRNO_AND_BREAK(E2BIG);
285 			}
286 
287 			*ob++ = *ib++;
288 			continue;
289 		}
290 
291 		/*
292 		 * Issue EILSEQ error if the first byte is not a
293 		 * valid UHC leading byte.
294 		 */
295 		if (! KICONV_KO_IS_UHC_1st_BYTE(*ib)) {
296 			KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
297 		}
298 
299 		/*
300 		 * Issue EINVAL error if input buffer has an incomplete
301 		 * character at the end of the buffer.
302 		 */
303 		if (ibtail - ib < 2) {
304 			KICONV_SET_ERRNO_AND_BREAK(EINVAL);
305 		}
306 
307 		/*
308 		 * Issue EILSEQ error if the remaining byte is not
309 		 * a valid UHC byte.
310 		 */
311 		if (! KICONV_KO_IS_UHC_2nd_BYTE(*(ib + 1))) {
312 			KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
313 		}
314 
315 		uhc_val = (uint32_t)(*ib) << 8 | *(ib + 1);
316 		sz = ko_to_utf8(uhc_val, ob, obtail, &ret_val,
317 		    kiconv_uhc_utf8, KICONV_UHC_UTF8_MAX);
318 
319 		if (sz < 0) {
320 			KICONV_SET_ERRNO_AND_BREAK(E2BIG);
321 		}
322 
323 		ib += 2;
324 		ob += sz;
325 	}
326 
327 	*inbuf = (char *)ib;
328 	*inbufleft = ibtail - ib;
329 	*outbuf = (char *)ob;
330 	*outbufleft = obtail - ob;
331 
332 	return (ret_val);
333 }
334 
335 /*
336  * String based encoding convertor from Unified Hangul Code to UTF-8.
337  */
338 static size_t
kiconvstr_fr_uhc(char * inarray,size_t * inlen,char * outarray,size_t * outlen,int flag,int * errno)339 kiconvstr_fr_uhc(char *inarray, size_t *inlen, char *outarray,
340 	size_t *outlen, int flag, int *errno)
341 {
342 	uchar_t		*ib;
343 	uchar_t		*ob;
344 	uchar_t		*ibtail;
345 	uchar_t		*obtail;
346 	uchar_t		*oldib;
347 	size_t		ret_val;
348 	int8_t		sz;
349 	uint32_t	uhc_val;
350 	boolean_t	do_not_ignore_null;
351 
352 	ret_val = 0;
353 	ib = (uchar_t *)inarray;
354 	ob = (uchar_t *)outarray;
355 	ibtail = ib + *inlen;
356 	obtail = ob + *outlen;
357 	do_not_ignore_null = ((flag & KICONV_IGNORE_NULL) == 0);
358 
359 	while (ib < ibtail) {
360 		if (*ib == '\0' && do_not_ignore_null)
361 			break;
362 
363 		if (KICONV_IS_ASCII(*ib)) {
364 			if (ob >= obtail) {
365 				KICONV_SET_ERRNO_AND_BREAK(E2BIG);
366 			}
367 
368 			*ob++ = *ib++;
369 			continue;
370 		}
371 
372 		oldib = ib;
373 
374 		if (! KICONV_KO_IS_UHC_1st_BYTE(*ib)) {
375 			KICONV_SET_ERRNO_WITH_FLAG(1, EILSEQ);
376 		}
377 
378 		if (ibtail - ib < 2) {
379 			KICONV_SET_ERRNO_WITH_FLAG(1, EINVAL);
380 		}
381 
382 		if (! KICONV_KO_IS_UHC_2nd_BYTE(*(ib + 1))) {
383 			KICONV_SET_ERRNO_WITH_FLAG(2, EILSEQ);
384 		}
385 
386 		uhc_val = *ib++;
387 		uhc_val = (uhc_val << 8) | *ib++;
388 		sz = ko_to_utf8(uhc_val, ob, obtail, &ret_val,
389 		    kiconv_uhc_utf8, KICONV_UHC_UTF8_MAX);
390 
391 		if (sz < 0) {
392 			ib = oldib;
393 			KICONV_SET_ERRNO_AND_BREAK(E2BIG);
394 		}
395 
396 		ob += sz;
397 		continue;
398 
399 REPLACE_INVALID:
400 		if (obtail - ob < KICONV_UTF8_REPLACEMENT_CHAR_LEN) {
401 			ib = oldib;
402 			KICONV_SET_ERRNO_AND_BREAK(E2BIG);
403 		}
404 
405 		*ob++ = KICONV_UTF8_REPLACEMENT_CHAR1;
406 		*ob++ = KICONV_UTF8_REPLACEMENT_CHAR2;
407 		*ob++ = KICONV_UTF8_REPLACEMENT_CHAR3;
408 		ret_val++;
409 	}
410 
411 	*inlen = ibtail - ib;
412 	*outlen = obtail - ob;
413 
414 	return (ret_val);
415 }
416 
417 /*
418  * Encoding convertor from UTF-8 to EUC-KR.
419  */
420 static size_t
kiconv_to_euckr(void * kcd,char ** inbuf,size_t * inbytesleft,char ** outbuf,size_t * outbytesleft,int * errno)421 kiconv_to_euckr(void *kcd, char **inbuf, size_t *inbytesleft,
422 	char **outbuf, size_t *outbytesleft, int *errno)
423 {
424 	return (kiconv_utf8_to_cck(kcd, inbuf, inbytesleft, outbuf,
425 	    outbytesleft, errno, utf8_to_euckr));
426 }
427 
428 /*
429  * Encoding convertor from UTF-8 to Unified Hangul Code.
430  */
431 static size_t
kiconv_to_uhc(void * kcd,char ** inbuf,size_t * inbytesleft,char ** outbuf,size_t * outbytesleft,int * errno)432 kiconv_to_uhc(void *kcd, char **inbuf, size_t *inbytesleft,
433 	char **outbuf, size_t *outbytesleft, int *errno)
434 {
435 	return (kiconv_utf8_to_cck(kcd, inbuf, inbytesleft, outbuf,
436 	    outbytesleft, errno, utf8_to_uhc));
437 }
438 
439 /*
440  * String based encoding convertor from UTF-8 to EUC-KR.
441  */
442 static size_t
kiconvstr_to_euckr(char * inarray,size_t * inlen,char * outarray,size_t * outlen,int flag,int * errno)443 kiconvstr_to_euckr(char *inarray, size_t *inlen, char *outarray,
444 	size_t *outlen, int flag, int *errno)
445 {
446 	return kiconvstr_utf8_to_cck((uchar_t *)inarray, inlen,
447 	    (uchar_t *)outarray, outlen, flag, errno, utf8_to_euckr);
448 }
449 
450 /*
451  * String based encoding convertor from UTF-8 to Unified Hangul Code.
452  */
453 static size_t
kiconvstr_to_uhc(char * inarray,size_t * inlen,char * outarray,size_t * outlen,int flag,int * errno)454 kiconvstr_to_uhc(char *inarray, size_t *inlen, char *outarray,
455 	size_t *outlen, int flag, int *errno)
456 {
457 	return kiconvstr_utf8_to_cck((uchar_t *)inarray, inlen,
458 	    (uchar_t *)outarray, outlen, flag, errno, utf8_to_uhc);
459 }
460 
461 /*
462  * Convert an UTF-8 character to a character of ko encodings
463  * (EUC-KR or UHC).
464  */
465 static int8_t
utf8_to_ko(uint32_t utf8,uchar_t * ob,uchar_t * obtail,size_t * ret_val,kiconv_table_t * table,size_t nitems)466 utf8_to_ko(uint32_t utf8, uchar_t *ob, uchar_t *obtail, size_t *ret_val,
467 	kiconv_table_t *table, size_t nitems)
468 {
469 	size_t	index;
470 	size_t	kocode;
471 	int8_t  kolen;
472 
473 	if (KICONV_KO_IS_UDC_IN_UTF8(utf8)) {
474 		/* User Definable Area handing. */
475 		kocode = (((utf8 & 0xF0000) >> 4) | ((utf8 & 0x3F00) >> 2) |
476 		    (utf8 & 0x3F)) - KICONV_KO_UDA_UCS4_START;
477 		if (kocode < KICONV_KO_UDA_RANGE) {
478 			kocode = (KICONV_KO_UDA_EUC_SEG1 << 8) |
479 			    (kocode + KICONV_KO_UDA_OFFSET_START);
480 		} else {
481 			/* 0x43 = 0xA1 - 0x5E */
482 			kocode = (KICONV_KO_UDA_EUC_SEG2 << 8) |
483 			    (kocode + 0x43);
484 		}
485 
486 		index = 1;
487 	} else {
488 		index = kiconv_binsearch(utf8, table, nitems);
489 		kocode = table[index].value;
490 	}
491 
492 	kolen = (kocode <= 0xFF) ? 1 : 2;
493 
494 	if (obtail - ob < kolen) {
495 		*ret_val = (size_t)-1;
496 		return (-1);
497 	}
498 
499 	if (index == 0)
500 		(*ret_val)++;
501 
502 	if (kolen > 1)
503 		*ob++ = (uchar_t)(kocode >> 8);
504 	*ob = (uchar_t)(kocode & 0xFF);
505 
506 	return (kolen);
507 }
508 
509 /*
510  * Convert an UTF-8 character to Unified Hangual Code.
511  */
512 /* ARGSUSED */
513 static int8_t
utf8_to_uhc(uint32_t utf8,uchar_t ** inbuf,uchar_t * ibtail,uchar_t * ob,uchar_t * obtail,size_t * ret_val)514 utf8_to_uhc(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
515 	uchar_t *ob, uchar_t *obtail, size_t *ret_val)
516 {
517 	return (utf8_to_ko(utf8, ob, obtail, ret_val, kiconv_utf8_uhc,
518 	    KICONV_UTF8_UHC_MAX));
519 }
520 
521 /*
522  * Convert an UTF-8 character to EUC-KR.
523  */
524 /* ARGSUSED */
525 static int8_t
utf8_to_euckr(uint32_t utf8,uchar_t ** inbuf,uchar_t * ibtail,uchar_t * ob,uchar_t * obtail,size_t * ret_val)526 utf8_to_euckr(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
527 	uchar_t *ob, uchar_t *obtail, size_t *ret_val)
528 {
529 	return (utf8_to_ko(utf8, ob, obtail, ret_val, kiconv_utf8_euckr,
530 	    KICONV_UTF8_EUCKR_MAX));
531 }
532 
533 /*
534  * Convert a single ko encoding (EUC-KR or UHC) character to UTF-8.
535  */
536 static int8_t
ko_to_utf8(uint32_t ko_val,uchar_t * ob,uchar_t * obtail,size_t * ret_val,kiconv_table_array_t * table,size_t nitems)537 ko_to_utf8(uint32_t ko_val, uchar_t *ob, uchar_t *obtail, size_t *ret_val,
538 	kiconv_table_array_t *table, size_t nitems)
539 {
540 	size_t	index;
541 	int8_t	sz;
542 	uchar_t	udc[3];
543 	uchar_t	*u8;
544 
545 	if (KICONV_KO_IS_UDC_IN_EUC(ko_val)) {
546 		/* UDA(User Definable Area) handling. */
547 		uint32_t u32;
548 
549 		u32 = (ko_val & 0xFF) + (((ko_val & 0xFF00) == 0xC900) ?
550 		    KICONV_KO_UDA_OFFSET_1 : KICONV_KO_UDA_OFFSET_2);
551 		udc[0] = 0xEF;
552 		udc[1] = (uchar_t)(0x80 | (u32 & 0x00000FC0) >> 6);
553 		udc[2] = (uchar_t)(0x80 | (u32 & 0x0000003F));
554 		u8 = udc;
555 		index = 1;
556 	} else {
557 		index = kiconv_binsearch(ko_val, table, nitems);
558 		u8 = table[index].u8;
559 	}
560 
561 	sz = u8_number_of_bytes[u8[0]];
562 
563 	if (obtail - ob < sz) {
564 		*ret_val = (size_t)-1;
565 		return (-1);
566 	}
567 
568 	if (index == 0)
569 		(*ret_val)++;	/* Non-identical conversion */
570 
571 	for (index = 0; index < sz; index++)
572 		*ob++ = u8[index];
573 
574 	return (sz);
575 }
576 
577 static kiconv_ops_t kiconv_ko_ops_tbl[] = {
578 	{
579 		"euc-kr", "utf-8", kiconv_open_to_cck, kiconv_to_euckr,
580 		kiconv_close_to_cck, kiconvstr_to_euckr
581 	},
582 	{
583 		"utf-8", "euc-kr", open_fr_euckr, kiconv_fr_euckr,
584 		close_fr_ko, kiconvstr_fr_euckr
585 	},
586 	{
587 		"unifiedhangul", "utf-8", kiconv_open_to_cck, kiconv_to_uhc,
588 		kiconv_close_to_cck, kiconvstr_to_uhc
589 	},
590 	{
591 		"utf-8", "unifiedhangul", open_fr_uhc, kiconv_fr_uhc,
592 		close_fr_ko, kiconvstr_fr_uhc
593 	}
594 };
595 
596 static kiconv_module_info_t kiconv_ko_info = {
597 	"kiconv_ko",		/* module name */
598 	sizeof (kiconv_ko_ops_tbl) / sizeof (kiconv_ko_ops_tbl[0]),
599 	kiconv_ko_ops_tbl,
600 	0,
601 	NULL,
602 	NULL,
603 	0
604 };
605 
606 static struct modlkiconv modlkiconv_ko = {
607 	&mod_kiconvops,
608 	"kiconv korean module 1.0",
609 	&kiconv_ko_info
610 };
611 
612 static struct modlinkage modlinkage = {
613 	MODREV_1,
614 	(void *)&modlkiconv_ko,
615 	NULL
616 };
617 
618 int
_init(void)619 _init(void)
620 {
621 	int err;
622 
623 	err = mod_install(&modlinkage);
624 	if (err)
625 		cmn_err(CE_WARN, "kiconv_ko: failed to load kernel module");
626 
627 	return (err);
628 }
629 
630 int
_fini(void)631 _fini(void)
632 {
633 	int err;
634 
635 	/*
636 	 * If this module is being used, then, we cannot remove the module.
637 	 * The following checking will catch pretty much all usual cases.
638 	 *
639 	 * Any remaining will be catached by the kiconv_unregister_module()
640 	 * during mod_remove() at below.
641 	 */
642 	if (kiconv_module_ref_count(KICONV_MODULE_ID_KO))
643 		return (EBUSY);
644 
645 	err = mod_remove(&modlinkage);
646 	if (err)
647 		cmn_err(CE_WARN, "kiconv_ko: failed to remove kernel module");
648 
649 	return (err);
650 }
651 
652 int
_info(struct modinfo * modinfop)653 _info(struct modinfo *modinfop)
654 {
655 	return (mod_info(&modlinkage, modinfop));
656 }
657