blob: 4fac3506d8935e2c12164184707a5958512d56da [file] [log] [blame]
/*
* This file and its contents are supplied under the terms of the
* Common Development and Distribution License ("CDDL"), version 1.0.
* You may only use this file in accordance with the terms of version
* 1.0 of the CDDL.
*
* A full copy of the text of the CDDL should have accompanied this
* source. A copy of the CDDL is also available via the Internet at
* http://www.illumos.org/license/CDDL.
*/
/*
* Copyright 2016 Nexenta Systems, Inc. All rights reserved.
*/
/*
* implement "iconv -l"
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <alloca.h>
#include <sys/avl.h>
#include <sys/list.h>
#include <sys/param.h>
#include <stddef.h>
#include <dirent.h>
#include <unistd.h>
#define PATH_LIBICONV "/usr/lib/iconv"
#define PATH_BTABLES "/usr/lib/iconv/geniconvtbl/binarytables"
#define PATH_ALIASES "/usr/lib/iconv/alias"
typedef struct codeset {
avl_node_t cs_node;
char *cs_name;
list_t cs_aliases;
} codeset_t;
typedef struct csalias {
list_node_t a_node;
char *a_name;
} csalias_t;
static avl_tree_t cs_avl;
static void alias_destroy(csalias_t *);
/*
* codesets
*/
static int
cs_compare(const void *n1, const void *n2)
{
const codeset_t *c1 = n1;
const codeset_t *c2 = n2;
int rv;
rv = strcmp(c1->cs_name, c2->cs_name);
return ((rv < 0) ? -1 : (rv > 0) ? 1 : 0);
}
static void
cs_insert(char *key)
{
codeset_t tmp, *cs;
avl_index_t where;
(void) memset(&tmp, 0, sizeof (tmp));
tmp.cs_name = key;
cs = avl_find(&cs_avl, &tmp, &where);
if (cs != NULL)
return; /* already there */
cs = calloc(1, sizeof (*cs));
if (cs == NULL) {
perror("cs_insert:calloc");
exit(1);
}
cs->cs_name = strdup(key);
if (cs->cs_name == NULL) {
perror("cs_insert:strdup");
exit(1);
}
list_create(&cs->cs_aliases, sizeof (csalias_t),
offsetof(csalias_t, a_node));
avl_insert(&cs_avl, cs, where);
}
const char topmatter[] =
"The following are all supported code set names. All combinations\n"
"of those names are not necessarily available for the pair of the\n"
"fromcode-tocode. Some of those code set names have aliases, which\n"
"are case-insensitive and described in parentheses following the\n"
"canonical name:\n";
static void
cs_dump(void)
{
codeset_t *cs;
csalias_t *a;
(void) puts(topmatter);
for (cs = avl_first(&cs_avl); cs != NULL;
cs = AVL_NEXT(&cs_avl, cs)) {
(void) printf(" %s", cs->cs_name);
if (!list_is_empty(&cs->cs_aliases)) {
a = list_head(&cs->cs_aliases);
(void) printf(" (%s", a->a_name);
while ((a = list_next(&cs->cs_aliases, a)) != NULL) {
(void) printf(", %s", a->a_name);
}
(void) printf(")");
}
(void) printf(",\n");
}
}
static void
cs_destroy(void)
{
void *cookie = NULL;
codeset_t *cs;
csalias_t *a;
while ((cs = avl_destroy_nodes(&cs_avl, &cookie)) != NULL) {
while ((a = list_remove_head(&cs->cs_aliases)) != NULL) {
alias_destroy(a);
}
free(cs->cs_name);
free(cs);
}
avl_destroy(&cs_avl);
}
/*
* aliases
*/
static void
alias_insert(char *codeset, char *alias)
{
codeset_t tcs, *cs;
csalias_t *a;
/*
* Find the codeset. If non-existent,
* ignore aliases of this codeset.
*/
(void) memset(&tcs, 0, sizeof (tcs));
tcs.cs_name = codeset;
cs = avl_find(&cs_avl, &tcs, NULL);
if (cs == NULL)
return;
/*
* Add this alias
*/
a = calloc(1, sizeof (*a));
if (a == NULL) {
perror("alias_insert:calloc");
exit(1);
}
a->a_name = strdup(alias);
if (a->a_name == NULL) {
perror("alias_insert:strdup");
exit(1);
}
list_insert_tail(&cs->cs_aliases, a);
}
static void
alias_destroy(csalias_t *a)
{
free(a->a_name);
free(a);
}
static void
scan_dir(DIR *dh, char sep, char *suffix)
{
char namebuf[MAXNAMELEN];
struct dirent *de;
while ((de = readdir(dh)) != NULL) {
char *p2, *p1;
/*
* We'll modify, so let's copy. If the dirent name is
* longer than MAXNAMELEN, then it can't possibly be a
* valid pair of codeset names, so just skip it.
*/
if (strlcpy(namebuf, de->d_name, sizeof (namebuf)) >=
sizeof (namebuf))
continue;
/* Find suffix (.so | .t) */
p2 = strrchr(namebuf, *suffix);
if (p2 == NULL)
continue;
if (strcmp(p2, suffix) != 0)
continue;
*p2 = '\0';
p1 = strchr(namebuf, sep);
if (p1 == NULL)
continue;
*p1++ = '\0';
/* More than one sep? */
if (strchr(p1, sep) != NULL)
continue;
/* Empty strings? */
if (*namebuf == '\0' || *p1 == '\0')
continue;
/* OK, add both to the map. */
cs_insert(namebuf);
cs_insert(p1);
}
}
static void
scan_aliases(FILE *fh)
{
char linebuf[256];
char *p1, *p2;
while (fgets(linebuf, sizeof (linebuf), fh) != NULL) {
if (linebuf[0] == '#')
continue;
p1 = strchr(linebuf, ' ');
if (p1 == NULL)
continue;
*p1++ = '\0';
p2 = strchr(p1, '\n');
if (p2 == NULL)
continue;
*p2 = '\0';
alias_insert(p1, linebuf);
}
}
int
list_codesets(void)
{
DIR *dh;
FILE *fh;
avl_create(&cs_avl, cs_compare, sizeof (codeset_t),
offsetof(codeset_t, cs_node));
dh = opendir(PATH_LIBICONV);
if (dh == NULL) {
perror(PATH_LIBICONV);
return (1);
}
scan_dir(dh, '%', ".so");
rewinddir(dh);
scan_dir(dh, '.', ".t");
(void) closedir(dh);
dh = opendir(PATH_BTABLES);
if (dh == NULL) {
perror(PATH_BTABLES);
return (1);
}
scan_dir(dh, '%', ".bt");
(void) closedir(dh);
fh = fopen(PATH_ALIASES, "r");
if (fh == NULL) {
perror(PATH_ALIASES);
/* let's continue */
} else {
scan_aliases(fh);
(void) fclose(fh);
}
cs_dump();
cs_destroy();
return (0);
}