#ifndef lint
static char *rcsid = "$Id: util.c,v 1.1.1.1 2003-06-04 00:27:08 marka Exp $";
#endif
#include <config.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <idn/resconf.h>
#include <idn/converter.h>
#include <idn/res.h>
#include <idn/utf8.h>
#include "util.h"
#include "selectiveencode.h"
extern int line_number;
idn_result_t
selective_encode(idn_resconf_t conf, idn_action_t actions,
char *from, char *to, int tolen)
{
for (;;) {
int len;
char *region_start, *region_end;
idn_result_t r;
char save;
r = idn_selectiveencode_findregion(from, ®ion_start,
®ion_end);
if (r == idn_notfound) {
if (tolen <= strlen(from))
return (idn_buffer_overflow);
(void)strcpy(to, from);
return (idn_success);
} else if (r != idn_success) {
errormsg("internal error at line %d: %s\n",
line_number, idn_result_tostring(r));
return (r);
}
len = region_start - from;
if (tolen < len) {
errormsg("internal buffer overflow at line %d\n",
line_number);
return (idn_buffer_overflow);
}
(void)memcpy(to, from, len);
to += len;
tolen -= len;
save = *region_end;
*region_end = '\0';
r = idn_res_encodename(conf, actions, region_start, to, tolen);
*region_end = save;
if (r != idn_success)
return (r);
len = strlen(to);
to += len;
tolen -= len;
from = region_end;
}
}
idn_result_t
selective_decode(idn_resconf_t conf, idn_action_t actions,
char *from, char *to, int tolen)
{
char *domain_name;
char *ignored_chunk;
char save;
int len;
idn_result_t r;
domain_name = NULL;
ignored_chunk = NULL;
for (;;) {
if (*from == '-') {
if (domain_name != NULL) {
if (*(from - 1) == '.') {
ignored_chunk = domain_name;
domain_name = NULL;
}
} else if (ignored_chunk == NULL) {
ignored_chunk = from;
}
} else if (*from == '.') {
if (domain_name != NULL) {
if (*(from - 1) == '-' || *(from - 1) == '.') {
ignored_chunk = domain_name;
domain_name = NULL;
}
} else if (ignored_chunk == NULL) {
ignored_chunk = from;
}
} else if (('a' <= *from && *from <= 'z') ||
('A' <= *from && *from <= 'Z') ||
('0' <= *from && *from <= '9')) {
if (ignored_chunk == NULL && domain_name == NULL)
domain_name = from;
} else {
if (ignored_chunk != NULL) {
len = from - ignored_chunk;
if (tolen < len)
return (idn_buffer_overflow);
(void)memcpy(to, ignored_chunk, len);
to += len;
tolen -= len;
} else if (domain_name != NULL) {
save = *from;
*from = '\0';
r = idn_res_decodename(conf, actions,
domain_name, to, tolen);
*from = save;
if (r == idn_success) {
len = strlen(to);
} else if (r == idn_invalid_encoding) {
len = from - domain_name;
if (tolen < len)
return (idn_buffer_overflow);
(void)memcpy(to, domain_name, len);
} else {
return (r);
}
to += len;
tolen -= len;
}
if (tolen < 1)
return (idn_buffer_overflow);
*to = *from;
to++;
tolen--;
domain_name = NULL;
ignored_chunk = NULL;
if (*from == '\0')
break;
}
from++;
}
return (idn_success);
}
void
set_defaults(idn_resconf_t conf) {
idn_result_t r;
if ((r = idn_resconf_setdefaults(conf)) != idn_success) {
errormsg("error setting default configuration: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
load_conf_file(idn_resconf_t conf, const char *file) {
idn_result_t r;
if ((r = idn_resconf_loadfile(conf, file)) != idn_success) {
errormsg("error reading configuration file: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
set_encoding_alias(const char *encoding_alias) {
idn_result_t r;
if ((r = idn_converter_resetalias()) != idn_success) {
errormsg("cannot reset alias information: %s\n",
idn_result_tostring(r));
exit(1);
}
if ((r = idn_converter_aliasfile(encoding_alias)) != idn_success) {
errormsg("cannot read alias file %s: %s\n",
encoding_alias, idn_result_tostring(r));
exit(1);
}
}
void
set_localcode(idn_resconf_t conf, const char *code) {
idn_result_t r;
r = idn_resconf_setlocalconvertername(conf, code,
IDN_CONVERTER_RTCHECK);
if (r != idn_success) {
errormsg("cannot create converter for codeset %s: %s\n",
code, idn_result_tostring(r));
exit(1);
}
}
void
set_idncode(idn_resconf_t conf, const char *code) {
idn_result_t r;
r = idn_resconf_setidnconvertername(conf, code,
IDN_CONVERTER_RTCHECK);
if (r != idn_success) {
errormsg("cannot create converter for codeset %s: %s\n",
code, idn_result_tostring(r));
exit(1);
}
}
void
set_delimitermapper(idn_resconf_t conf, unsigned long *delimiters,
int ndelimiters) {
idn_result_t r;
r = idn_resconf_addalldelimitermapucs(conf, delimiters, ndelimiters);
if (r != idn_success) {
errormsg("cannot add delimiter: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
set_localmapper(idn_resconf_t conf, char **mappers, int nmappers) {
idn_result_t r;
r = idn_resconf_addalllocalmapselectornames(conf,
IDN_MAPSELECTOR_DEFAULTTLD,
(const char **)mappers,
nmappers);
if (r != idn_success) {
errormsg("cannot add local map: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
set_nameprep(idn_resconf_t conf, char *version) {
idn_result_t r;
r = idn_resconf_setnameprepversion(conf, version);
if (r != idn_success) {
errormsg("error setting nameprep %s: %s\n",
version, idn_result_tostring(r));
exit(1);
}
}
void
set_mapper(idn_resconf_t conf, char **mappers, int nmappers) {
idn_result_t r;
r = idn_resconf_addallmappernames(conf, (const char **)mappers,
nmappers);
if (r != idn_success) {
errormsg("cannot add nameprep map: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
set_normalizer(idn_resconf_t conf, char **normalizers, int nnormalizer) {
idn_result_t r;
r = idn_resconf_addallnormalizernames(conf,
(const char **)normalizers,
nnormalizer);
if (r != idn_success) {
errormsg("cannot add normalizer: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
set_prohibit_checkers(idn_resconf_t conf, char **prohibits, int nprohibits) {
idn_result_t r;
r = idn_resconf_addallprohibitcheckernames(conf,
(const char **)prohibits,
nprohibits);
if (r != idn_success) {
errormsg("cannot add prohibit checker: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
set_unassigned_checkers(idn_resconf_t conf, char **unassigns, int nunassigns) {
idn_result_t r;
r = idn_resconf_addallunassignedcheckernames(conf,
(const char **)unassigns,
nunassigns);
if (r != idn_success) {
errormsg("cannot add unassigned checker: %s\n",
idn_result_tostring(r));
exit(1);
}
}
void
errormsg(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
}
void
strbuf_init(idnconv_strbuf_t *buf) {
buf->str = buf->local_buf;
buf->str[0] = '\0';
buf->size = sizeof(buf->local_buf);
}
void
strbuf_reset(idnconv_strbuf_t *buf) {
if (buf->str != NULL && buf->str != buf->local_buf) {
free(buf->str);
}
strbuf_init(buf);
}
char *
strbuf_get(idnconv_strbuf_t *buf) {
return (buf->str);
}
size_t
strbuf_size(idnconv_strbuf_t *buf) {
return (buf->size);
}
char *
strbuf_copy(idnconv_strbuf_t *buf, const char *str) {
size_t len = strlen(str);
if (strbuf_alloc(buf, len + 1) == NULL)
return (NULL);
strcpy(buf->str, str);
return (buf->str);
}
char *
strbuf_append(idnconv_strbuf_t *buf, const char *str) {
size_t len1 = strlen(buf->str);
size_t len2 = strlen(str);
char *p;
#define MARGIN 50
p = strbuf_alloc(buf, len1 + len2 + 1 + MARGIN);
if (p != NULL)
strcpy(buf->str + len1, str);
return (p);
}
char *
strbuf_alloc(idnconv_strbuf_t *buf, size_t size) {
char *p;
if (buf->size >= size)
return (buf->str);
if (buf->str == buf->local_buf) {
if ((p = malloc(size)) == NULL)
return (NULL);
memcpy(p, buf->local_buf, sizeof(buf->local_buf));
} else {
if ((p = realloc(buf->str, size)) == NULL)
return (NULL);
}
buf->str = p;
buf->size = size;
return (buf->str);
}
char *
strbuf_double(idnconv_strbuf_t *buf) {
return (strbuf_alloc(buf, buf->size * 2));
}
char *
strbuf_getline(idnconv_strbuf_t *buf, FILE *fp) {
char s[256];
buf->str[0] = '\0';
while (fgets(s, sizeof(s), fp) != NULL) {
if (strbuf_append(buf, s) == NULL)
return (NULL);
if (strlen(s) < sizeof(s) - 1 || s[sizeof(s) - 2] == '\n')
return (buf->str);
}
if (buf->str[0] != '\0')
return (buf->str);
return (NULL);
}